using Aucma.Scada.Model.domain;
using HighWayIot.Config;
using HighWayIot.Log4net;
using HighWayIot.Plc;
using System;
using System.Collections.Generic;
using System.Threading;
using System.Threading.Tasks;

namespace Aucma.Scada.Business
{
    public sealed class TaskHandleBusiness
    {
        private static readonly Lazy<TaskHandleBusiness> lazy = new Lazy<TaskHandleBusiness>(() => new TaskHandleBusiness());
        public static TaskHandleBusiness Instance
        {
            get
            {
                return lazy.Value;
            }
        }

        public delegate void OutStoreFinsih(string storeCode, string taskCode);
        public event OutStoreFinsih OutStoreFinsihEvent;

        /// <summary>
        /// 字典存放PLC连接
        /// </summary>
        private Dictionary<string, IPlc> _plcDictionary = new Dictionary<string, IPlc>();

        private LogHelper logHelper = LogHelper.Instance;
        private AppConfig appConfig = AppConfig.Instance;
        private PlcConfig plcConfig = PlcConfig.Instance;
        private PlcPool _pool = PlcPool.Instance;

        private string shellTaskCode = string.Empty;

        private string linerTaskCode = string.Empty;

        private TaskHandleBusiness()
        {
            _plcDictionary = _pool.GetAll();
        }

        #region 箱壳出库任务下发处理
        /// <summary>
        /// 箱壳出库任务下发
        /// </summary>
        /// <param name="taskInfo"></param>
        public bool SendShellTask_OutStore(RealTaskInfo taskInfo)
        {
            bool result = false;
            try
            {
                IPlc _plc = _plcDictionary[taskInfo.storeCode];

                if (_plc != null)
                {
                    if (_plc.IsConnected)
                    {
                        //写入货道号
                        _plc.writeStringByAddress(plcConfig.out_shell_spaceCode, taskInfo.spaceCode);
                        //写入出库数量
                        _plc.writeInt32ByAddress(plcConfig.out_shell_amount, taskInfo.planAmount);
                        //写入应答字
                        _plc.writeInt32ByAddress(plcConfig.out_shell_answer, 1);
                        //写入任务号
                        _plc.writeStringByAddress(plcConfig.out_shell_task, taskInfo.taskCode);

                        //写入完成后读取应答字进行复位
                        ReadShellAnswer_OutStore(taskInfo.taskCode);

                        result = true;
                    }
                    else
                    {
                        logHelper.Info($"仓库{taskInfo.storeCode}；PLC未连接");
                    }
                }
                else
                {
                    logHelper.Info($"PLC信息为空，通过{taskInfo.storeCode}未获取到该仓库对应的PLC信息");
                }
            }
            catch (Exception ex)
            {
                logHelper.Error("箱壳出库任务下发异常", ex);
            }

            return result;
        }

        /// <summary>
        /// 读取箱壳出库应答
        /// </summary>
        private void ReadShellAnswer_OutStore(string taskCode)
        {
            lock (string.Empty)
            {
                bool isFlag = true;
                IPlc _plc = _plcDictionary[appConfig.shellStoreCode];
                try
                {
                    Task.Run(() =>
                    {
                        if (_plc != null)
                        {
                            if (_plc.IsConnected)
                            {
                                do
                                {
                                    //读取PLC应答字为2时，上位机清空写入的出库内容
                                    if (_plc.readInt32ByAddress(plcConfig.out_shell_answer) == 2)
                                    {
                                        //写入货道号
                                        _plc.writeStringByAddress(plcConfig.out_shell_spaceCode, string.Empty);
                                        //写入出库数量
                                        _plc.writeInt32ByAddress(plcConfig.out_shell_amount, 0);
                                        //写入应答字
                                        _plc.writeInt32ByAddress(plcConfig.out_shell_answer, 0);
                                        //写入任务号
                                        _plc.writeStringByAddress(plcConfig.out_shell_task, string.Empty);
                                        isFlag = false;

                                        ReadShellFinish_OutStore(taskCode);
                                    }

                                    Thread.Sleep(5000);
                                } while (isFlag);
                            }
                            else
                            {
                                logHelper.Info($"仓库{appConfig.shellStoreCode}；PLC未连接");
                            }
                        }
                        else
                        {
                            logHelper.Info($"PLC信息为空，通过{appConfig.shellStoreCode}未获取到该仓库对应的PLC信息");
                        }
                    });
                }
                catch (Exception ex)
                {
                    logHelper.Error("读取箱壳出库应答字异常", ex);
                }
            }
        }

        /// <summary>
        /// 读取箱壳出库完成
        /// </summary>
        private void ReadShellFinish_OutStore(string taskCode)
        {
            lock (string.Empty)
            {
                bool isFlag = true;
                IPlc _plc = _plcDictionary[appConfig.shellStoreCode];
                shellTaskCode = taskCode;
                try
                {
                    Task.Run(() =>
                    {
                        if (_plc != null)
                        {
                            if (_plc.IsConnected)
                            {
                                do
                                {
                                    //读取PLC出库任务完成
                                    if (_plc.readInt32ByAddress(plcConfig.out_shell_finish) == 1)
                                    {
                                        _plc.writeInt32ByAddress(plcConfig.out_shell_finish, 0);

                                        //string taskCode = _plc.readStringByAddress(plcConfig.out_shell_task, 10);

                                        OutStoreFinsihEvent?.Invoke(appConfig.shellStoreCode, taskCode);

                                        isFlag = false;
                                    }

                                    Thread.Sleep(5000);
                                } while (isFlag);
                            }
                            else
                            {
                                logHelper.Info($"仓库{appConfig.shellStoreCode}；PLC未连接");
                            }
                        }
                        else
                        {
                            logHelper.Info($"PLC信息为空，通过{appConfig.shellStoreCode}未获取到该仓库对应的PLC信息");
                        }
                    });
                }
                catch (Exception ex)
                {
                    logHelper.Error("读取箱壳出库出库完成异常", ex);
                }
            }
        }
        #endregion

        #region 内胆出库任务处理
        /// <summary>
        /// 内胆出库任务下发
        /// </summary>
        /// <param name="taskInfo"></param>
        public bool SendLinerTask_OutStore(RealTaskInfo taskInfo)
        {
            bool result = false;
            try
            {
                IPlc _plc = _plcDictionary[taskInfo.storeCode];

                if (_plc != null)
                {
                    if (_plc.IsConnected)
                    {
                        //写入货道号
                        _plc.writeStringByAddress(plcConfig.out_liner_spaceCode, taskInfo.spaceCode);
                        //写入出库数量
                        _plc.writeInt32ByAddress(plcConfig.out_liner_amount, taskInfo.planAmount);
                        //写入应答字
                        _plc.writeInt32ByAddress(plcConfig.out_liner_answer, 1);
                        //写入任务号
                        _plc.writeStringByAddress(plcConfig.out_liner_task, taskInfo.taskCode);

                        //写入完成后读取应答字进行复位
                        ReadLinerAnswer_OutStore(taskInfo.taskCode);

                        result = true;
                    }
                    else
                    {
                        logHelper.Info($"仓库{taskInfo.storeCode}；PLC未连接");
                    }
                }
                else
                {
                    logHelper.Info($"PLC信息为空，通过{taskInfo.storeCode}未获取到该仓库对应的PLC信息");
                }
            }
            catch (Exception ex)
            {
                logHelper.Error("内胆出库任务下发异常", ex);
            }
            return result;
        }

        /// <summary>
        /// 读取内胆出库应答
        /// </summary>
        private void ReadLinerAnswer_OutStore(string taskCode)
        {
            lock (string.Empty)
            {
                bool isFlag = true;
                IPlc _plc = _plcDictionary[appConfig.shellStoreCode];
                linerTaskCode = taskCode;
                try
                {
                    Task.Run(() =>
                    {

                        if (_plc != null)
                        {
                            if (_plc.IsConnected)
                            {
                                do
                                {
                                    //读取PLC应答字为2时，上位机清空写入的出库内容
                                    if (_plc.readInt32ByAddress(plcConfig.out_liner_answer) == 2)
                                    {
                                        //写入货道号
                                        _plc.writeStringByAddress(plcConfig.out_liner_spaceCode, string.Empty);
                                        //写入出库数量
                                        _plc.writeInt32ByAddress(plcConfig.out_liner_amount, 0);
                                        //写入应答字
                                        _plc.writeInt32ByAddress(plcConfig.out_liner_answer, 0);
                                        //写入任务号
                                        _plc.writeStringByAddress(plcConfig.out_liner_task, string.Empty);
                                        isFlag = false;

                                        Thread.Sleep(5000);

                                        ReadLinerFinish_OutStore(taskCode);
                                    }
                                } while (isFlag);
                            }
                            else
                            {
                                logHelper.Info($"仓库{appConfig.linerStoreCode}；PLC未连接");
                            }
                        }
                        else
                        {
                            logHelper.Info($"PLC信息为空，通过{appConfig.linerStoreCode}未获取到该仓库对应的PLC信息");
                        }
                    });
                }
                catch (Exception ex)
                {
                    logHelper.Error("读取内胆出库应答字异常", ex);
                }
            }
        }

        /// <summary>
        /// 读取内胆出库完成
        /// </summary>
        private void ReadLinerFinish_OutStore(string taskCode)
        {
            lock (string.Empty)
            {
                try
                {
                    Task.Run(() =>
                    {
                        bool isFlag = true;
                        IPlc _plc = _plcDictionary[appConfig.linerStoreCode];
                        if (_plc != null)
                        {
                            if (_plc.IsConnected)
                            {
                                do
                                {
                                    //读取PLC出库任务完成
                                    if (_plc.readInt32ByAddress(plcConfig.out_liner_finish) == 1)
                                    {
                                        _plc.writeInt32ByAddress(plcConfig.out_liner_finish, 0);

                                        //string taskCode = _plc.readStringByAddress(plcConfig.out_liner_task, 10);

                                        OutStoreFinsihEvent?.Invoke(appConfig.linerStoreCode, taskCode);

                                        isFlag = false;

                                        Thread.Sleep(5000);
                                    }
                                } while (isFlag);
                            }
                            else
                            {
                                logHelper.Info($"仓库{appConfig.linerStoreCode}；PLC未连接");
                            }
                        }
                        else
                        {
                            logHelper.Info($"PLC信息为空，通过{appConfig.linerStoreCode}未获取到该仓库对应的PLC信息");
                        }
                    });
                }
                catch (Exception ex)
                {
                    logHelper.Error("读取内胆出库完成异常", ex);
                }
            }
        }
        #endregion


    }
}