using Newtonsoft.Json;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Text.RegularExpressions;
using System.Threading.Tasks;
using TouchSocket.Sockets;
using WCS.BLL.Config;
using WCS.BLL.DbModels;
using WCS.BLL.DbModels.Task;
using WCS.BLL.Manager;
using WCS.BLL.Tool;
using WCS.DAL.Db;
using WCS.DAL.DbModels;
using WCS.Model;
using WCS.Model.ApiModel.MKYBackgroundThread;
using WCS.Model.ApiModel.SingleLight;
using static WCS.BLL.HardWare.WarningLight;
using static WCS.BLL.Tool.Helper;

namespace WCS.BLL.HardWare
{
    public class SingleLightShelf : IShelfBase
    {
        public SingleLightShelf(ShelfInfo shelfInfo)
        {
            ShelfId = shelfInfo.Id;
            ShelfCode = shelfInfo.ShelfCode;
            RowCounts = shelfInfo.Rowcounts;
            ColumnCounts = shelfInfo.Columncounts;
            SetCurrentMode(TaskModeEnum.待机模式);
            ClientIp = shelfInfo.ClientIp;
            LightId = shelfInfo.LightId;
            IsService = shelfInfo.IsService;
            ClientIp = shelfInfo.ClientIp;

            if (ClientIp.Contains("127"))
            {
                ;
            }

            ShelfTypeName = shelfInfo.ShelfTypeName;

            //初始化Module
            Logs.Write($"[初始化单灯货架]初始化模组{ShelfCode}");
            var task = Task.Run(() =>
            {
                var modules = DbHelp.db.Queryable<ModuleInfo>().Where(t => t.ShelfId == ShelfId).ToList();
                foreach (var module in modules)
                {
                    MXL4Modules.Add(new MXL4ShelfModule()
                    {
                        ModuleId = module.Id,
                        ModuleCode = module.ModuleCode,
                        BoardId = module.BoardId,
                        IsEnable = module.IsEnable,
                        CurrentMode = TaskModeEnum.待机模式,

                        IsNeedRefresh = false,
                    });
                }
                ModulesStr = string.Join(";", MXL4Modules.Select(t => t.ModuleCode));

                ModuleIds = MXL4Modules.Select(t => t.BoardId).ToList();
            });

            Logs.Write($"[初始化单灯货架]初始化单灯线程{ShelfCode}");
            //初始化单灯线程
            //一个货架存在一个线程去刷新数据
            Task.Run(async () =>
            {
                //等待模组加载完毕再开始发送数据进行刷新
                Task.WaitAll(task);
                while (true)
                {
                    try
                    {
                        await Task.Delay(200);
                        //未完成首次连接时 暂不发送
                        if (IsService)
                        {
                            if (TcpCleint == null)
                            {
                                await Task.Delay(2000);
                                continue;
                            }
                            if (TcpCleint.IsFirstConnected == false)
                            {
                                await Task.Delay(2000);
                                continue;
                            }
                        }
                        else
                        {
                            if (ClientIp.Contains("127"))
                            {
                                ;
                            }
                            var tcpClient = TCPClientManager.Service.GetClients().Where(t => t.IP + ":" + t.Port.ToString() == ClientIp).FirstOrDefault();
                            if (tcpClient == null)
                            {
                                await Task.Delay(2000);
                                continue;
                            }
                        }

                        //查询属于本货架的任务
                        var currentShelfTasks = DbHelp.db.Queryable<CurrentTask>()
                                                         .Where(t => t.ShelfId == this.ShelfId)
                                                         .Where(t => t.IsSended == false || t.IsCancel == true)
                                                         .OrderBy(t => t.CreateTime)
                                                         .ToList();

                        //获取因为任务需要刷新的module
                        var haveTaskModules = currentShelfTasks.Where(t => t.IsCancel == true || t.IsSended == false)
                                                               .Select(t => t.ModuleId)
                                                               .Distinct()
                                                               .ToList();
                        MXL4Modules.ForEach(t =>
                        {
                            if (haveTaskModules.Contains(t.ModuleId))
                            {
                                t.IsNeedRefresh = true;
                            }
                        });

                        //查询是否有需要刷新的
                        var needRefreshModules = MXL4Modules.Where(t => t.IsNeedRefresh)
                                                            .ToList();
                        foreach (var module in needRefreshModules)
                        {
                            Logs.Write($"[初始化单灯货架]存在需要刷新的{ShelfCode}");
                            try
                            {
                                //查询当前是否有任务
                                var currentTasks = currentShelfTasks.Where(t => t.ModuleId == module.ModuleId)
                                                                    .OrderBy(t => t.CreateTime)
                                                                    .ToList();
                                #region 取消任务的逻辑 存在取消的任务 先删除任务
                                var cancelTasks = currentTasks.Where(t => t.IsCancel == true)
                                                                   .ToList();
                                if (cancelTasks != null && cancelTasks.Count > 0)
                                {
                                    Logs.Write($"[单灯后台刷新线程]当前有任务需要取消！");
                                    //获取该库位还有无任务
                                    var currentModuleTask = DbHelp.db.Queryable<CurrentTask>()
                                                         .Where(t => t.ShelfId == this.ShelfId)
                                                         .Where(t => t.ModuleId == module.ModuleId)
                                                         .Where(t => t.IsSended == true && t.IsCancel == false)
                                                         .ToList();
                                    //当前库位无任务 关闭库位灯
                                    if (!currentModuleTask.Any())
                                    {
                                        Logs.Write($"[单灯后台刷新线程]当前库位{module.ModuleCode},无任务，关闭库位灯！");

                                        var storeCodes = new List<string>();
                                        storeCodes.Add(module.ModuleCode);
                                        var shelfModel = new SingleLightShelfModel();
                                        //先不操作报警灯
                                        shelfModel.WarningLightMode = -1;
                                        shelfModel.WarningLightColor = 0;
                                        shelfModel.WarningBoardId = 0;

                                        shelfModel.ClientIp = ClientIp;
                                        shelfModel.StoreList = new List<SingleLightStoreModel>();
                                        shelfModel.StoreList.Add(new SingleLightStoreModel()
                                        {
                                            BoardId = module.BoardId,
                                            LightColor = 0,
                                            LightMode = 0,
                                        });
                                        var response = SingleLightControl(shelfModel, storeCodes);
                                        if (response != null && response.Code == 200)
                                        {
                                            //删除取消的这个任务
                                            DbHelp.db.Deleteable(cancelTasks).ExecuteCommand();
                                            //删除被取消的任务
                                            await Task.Delay(20);
                                            module.IsNeedRefresh = false;


                                        }
                                    }
                                    else
                                    {
                                        Logs.Write($"[单灯后台刷新线程]当前库位{module.ModuleCode},还存在任务，不关闭库位灯！");

                                        module.IsNeedRefresh = false;
                                        continue;
                                    }
                                }
                                #endregion
                            }
                            catch (Exception ex)
                            {
                                Logs.Write($"【后台发送线程】遇到异常{ex.Message},{ex.StackTrace}");
                            }

                        }

                        //刷新报警灯
                        if (needRefreshModules != null && needRefreshModules.Count > 0)
                        {
                            var currentTasks = DbHelp.db.Queryable<CurrentTask>()
                                                         .Where(t => t.ShelfId == this.ShelfId)
                                                         .ToList();
                            if (currentTasks != null && currentTasks.Count > 0)
                            {
                                var firstCurrentTask = currentTasks[0];
                                //开报警灯 开大灯
                                var moduleCodes = currentTasks.Select(t => t.ModuleCode)
                                                              .Distinct()
                                                              .ToList();
                                var shelfModel = new SingleLightShelfModel();
                                //报警灯长亮
                                shelfModel.WarningLightMode = 1;
                                shelfModel.WarningLightColor = (int)firstCurrentTask.ButtonColor;
                                shelfModel.WarningBoardId = shelfInfo.LightId;
                                shelfModel.ClientIp = ClientIp;
                                shelfModel.StoreList = new List<SingleLightStoreModel>();

                                Logs.Write($"[单灯后台刷新线程]亮灯任务数量{currentTasks.Count}！");
                                currentTasks.ForEach(task =>
                                {
                                    Logs.Write($"[单灯后台刷新线程]亮灯任务{task.ModuleCode}！");
                                    var module = MXL4Modules.Where(t => t.ModuleCode == task.ModuleCode).First();
                                    if (module != null)
                                    {
                                        shelfModel.StoreList.Add(new SingleLightStoreModel()
                                        {
                                            BoardId = module.BoardId,
                                            LightColor = (int)task.ButtonColor,
                                            LightMode = 1,
                                        });
                                    }
                                });

                                var response = SingleLightControl(shelfModel, moduleCodes);
                                //亮了灯的更新为已发送
                                if (response != null && response.Code == 200)
                                {
                                    Logs.Write($"[单灯后台刷新线程]当前灯继续亮！");

                                    MXL4Modules.ForEach(t => t.IsNeedRefresh = false);
                                    currentTasks.ForEach(t => t.IsSended = true);
                                    DbHelp.db.Updateable(currentTasks).UpdateColumns(ct => new { ct.IsSended }).ExecuteCommand();
                                }
                            }
                            else
                            {
                                //关报警灯 小灯也全关
                                var shelfModel = new SingleLightShelfModel();
                                //报警灯关闭
                                shelfModel.WarningLightMode = 0;
                                shelfModel.WarningLightColor = 0;
                                shelfModel.WarningBoardId = shelfInfo.LightId;
                                shelfModel.ClientIp = ClientIp;
                                shelfModel.StoreList = new List<SingleLightStoreModel>();
                                var response = SingleLightControl(shelfModel, new List<string>());
                                if (response != null && response.Code == 200)
                                {
                                    Logs.Write($"[单灯后台刷新线程]当前灯不继续亮！");
                                    MXL4Modules.ForEach(t => t.IsNeedRefresh = false);
                                }
                            }
                        }

                    }
                    catch (Exception ex)
                    {
                        Logs.Write($"【后台发送线程】遇到异常{ex.Message},{ex.StackTrace}");
                    }
                    await Task.Delay(1500);
                }
            });
        }

        public bool IsService { get; set; }

        public string ShelfTypeName { get; set; }
        public int ShelfId { get; set; }
        public string ShelfCode { get; set; }
        public int RowCounts { get; set; }
        public int ColumnCounts { get; set; }
        public TaskModeEnum CurrentMode { get; set; }
        public string ModulesStr { get; set; }
        public string GroupName { get; set; }
        public MatInfoResponse InStoreData { get; set; }
        public string? CurrentCom { get; set; } = string.Empty;
        public string OrderNumber { get; set; }
        public int LightId { get; set; }
        public LightColorEnum LightColor { get; set; }
        public List<int> ModuleIds { get; set; }
        public string ClientIp { get; set; }
        public List<string> ExceptionMessages { get; set; }
        public bool IsWarning { get; set; }
        public string WebSocketIpAddress { get; set; }

        public List<SmartShelfModule> Modules { get; set; } = new List<SmartShelfModule>();
        public DateTime SetCurrentModeTime { get; set; }

        public TCPClient TcpCleint { get { return TCPClientManager.GetTCPClientByIPHost(ClientIp); } }

        public List<MXL4ShelfModule> MXL4Modules { get; set; } = new List<MXL4ShelfModule>();


        public bool ConfirmStocktakingSingle(int BoardId, int LightNumber)
        {
            throw new NotImplementedException();
        }

        public void GoInInstore(string IPAdress)
        {
            //找到对应的灯 亮灯

        }

        public void GoInOutstore(List<OutOrderMatDetail> MatDetails, OutOrder outOrder, string OperateUser)
        {

        }

        public void GoInStocktaking()
        {

        }

        public void GoInStocktaking(List<StockTakingOrderMatDetail> MatDetails, StockTakingOrder outOrder)
        {

        }

        public void GoOutInstore()
        {
            //找到已亮灯的 灭灯

        }

        public void GoOutOutstore()
        {

        }

        public void GoOutStocktaking()
        {

        }

        public void Reset()
        {
            return;
        }

        public void SetCurrentMode(TaskModeEnum mode)
        {

        }

        public void ShelfCheck()
        {

        }

        public void Warning()
        {

        }


        public ResponseCommon<object> SingleLightControl(SingleLightShelfModel request, List<string> storeCodes)
        {
            try
            {
                var shelf = DbHelp.db.Queryable<ShelfInfo>().Where(t => t.Id == ShelfId)
                                                            .First();
                var client = new
                {
                    ClientIp = shelf.ClientIp,
                    IsService = shelf.IsService,
                };

                List<SingleLightShelfModel> singleLightShelfModels = new List<SingleLightShelfModel>();
                singleLightShelfModels.Add(request);

                var sendData = Helper.SingleLightControl(singleLightShelfModels);
                if (client.IsService)
                {
                    TCPClient tcpClient = TCPClientManager.GetTCPClientByIPHost(client.ClientIp);
                    if (tcpClient != null)
                    {
                        try
                        {
                            tcpClient.Send(sendData);
                            Logs.Write("【单灯单独控制】发送指令" + BitConverter.ToString(sendData));
                        }
                        catch (Exception ex)
                        {
                            Logs.Write($"【单灯单独控制】{client}以下指令发送中遇到异常{ex.Message}" + BitConverter.ToString(sendData));
                        }
                    }
                    else
                    {
                        Logs.Write($"【单灯单独控制】{client}未连接，以下指令未能成功发送" + BitConverter.ToString(sendData));
                    }
                }
                else
                {
                    var tcpClient = TCPClientManager.Service.GetClients().Where(t => t.IP + ":" + t.Port.ToString() == ClientIp).FirstOrDefault();
                    if (tcpClient != null)
                    {
                        lock (tcpClient)
                        {
                            try
                            {
                                tcpClient.Send(sendData, 0, sendData.Length);
                                Logs.Write("【单灯单独控制】发送指令" + BitConverter.ToString(sendData));
                            }
                            catch (Exception ex)
                            {
                                Logs.Write($"【单灯单独控制】{client}以下指令发送中遇到异常{ex.Message}" + BitConverter.ToString(sendData));
                                return new ResponseCommon<object>()
                                {
                                    Code = 201,
                                    Message = $"【单灯单独控制】{client}指令发送中遇到异常{ex.Message}",
                                };
                            }
                            Thread.Sleep(100);
                        }
                    }
                    else
                    {
                        Logs.Write($"【单灯单独控制】{client}未连接，以下指令未能成功发送" + BitConverter.ToString(sendData));
                        return new ResponseCommon<object>()
                        {
                            Code = 201,
                            Message = $"【单灯单独控制】{client}未连接，以下指令未能成功发送",
                        };
                    }
                }

                var stores = DbHelp.db.Queryable<StoreInfo>()
                                      .Where(t => storeCodes.Contains(t.StoreCode))
                                      .ToList();
                //更新数据库灯的状态
                stores.ForEach(t =>
                {
                    t.LightMode = request.WarningLightMode == -1 ? 0 : request.WarningLightMode;
                    t.ColorMode = request.WarningLightColor;
                });
                DbHelp.db.Updateable(stores)
                         .UpdateColumns(t => new { t.LightMode, t.ColorMode })
                         .ExecuteCommand();

                //返回成功
                return new ResponseCommon<object>()
                {
                    Code = 200,
                    Message = "success",
                };
            }
            catch (Exception ex)
            {

                //操作失败
                return new ResponseCommon<object>()
                {
                    Code = 300,
                    Message = $"操作失败：{ex.Message}",
                };
            }
        }

        public string ExtractUntilSecondDashCorrect(string input)
        {
            int firstDashIndex = input.IndexOf('-');
            if (firstDashIndex == -1)
            {
                return string.Empty; // 如果没有找到第一个'-'，则返回空字符串
            }

            int secondDashIndex = input.IndexOf('-', firstDashIndex + 1);
            if (secondDashIndex == -1)
            {
                return input;
            }
            else
            {
                return input.Substring(0, secondDashIndex);
            }
        }
    }
}