using Kdbndp;
using Microsoft.AspNetCore.Mvc;
using NPOI.SS.Formula.Functions;
using SqlSugar;
using WCS.BLL.DbModels;
using WCS.BLL.DbModels.Task;
using WCS.BLL.HardWare;
using WCS.BLL.Manager;
using WCS.BLL.Services.IService;
using WCS.BLL.Services.Service;
using WCS.DAL.Db;
using WCS.DAL.DbModels;
using WCS.Model;
using WCS.Model.ApiModel.Home;

namespace WCS.WebApi.Controllers
{
    /// <summary>
    /// 主页面的接口
    /// </summary>
    [ApiController]
    [Route("[controller]")]
    public class HomeController : ControllerBase
    {
        public IHomerService _homerService { get; set; }
        public ISelfCheckService _selfCheckService { get; set; }

        public HomeController(IHomerService homerService, ISelfCheckService selfCheckService)
        {
            _homerService = homerService;
            _selfCheckService = selfCheckService;
        }

        [Route("getShelfTypes")]
        [HttpPost(Name = "getShelfTypes")]
        public async Task<ResponseBase> getShelfTypes(RequestBase request)
        {
            try
            {
                //直接获取当前所有货架类型并返回
                var shelfTypes = DbHelp.db.Queryable<ShelfTypeInfo>()
                                          .Select(t => new ShelfTypeModel()
                                          {
                                              Id = t.Id,
                                              ShelfTypeName = t.ShelfTypeName
                                          })
                                          .ToList();
                return new PageQueryResponse<ShelfTypeModel>()
                {
                    Code = 200,
                    Message = "success",
                    Data = new PageQueryResponseData<ShelfTypeModel>
                    {
                        Lists = shelfTypes,
                        Count = shelfTypes.Count
                    }
                };
            }
            catch (Exception ex)
            {
                return new PageQueryResponse<ShelfTypeModel>()
                {
                    Code = 300,
                    Message = $"查询失败:{ex.Message}",
                };
            }
        }

        [Route("getShelfStatus")]
        [HttpPost(Name = "getShelfStatus")]
        public async Task<ResponseBase> getShelfStatus(GetShelfStatusRequest request)
        {
            try
            {
                var shelfs = ShelfManager.Shelves
                                         .WhereIF(request.GroupNames?.Count > 0, t => request.GroupNames!.Contains(t.GroupName))
                                         .ToList();
                //直接返回当前内存中缓存的货架和状态
                return new GetShelfStatusResponse()
                {
                    Code = 200,
                    Message = "success",
                    Data = shelfs.Select(t => new ShelfModel
                    {
                        ShelfId = t.ShelfId,
                        ShelfCode = t.ShelfCode,
                        CurrentCom = t.CurrentCom,
                        SetCurrentModeTime = t.SetCurrentModeTime,
                        CurentMode = (int)t.CurrentMode,
                        ModulesStr = t.ModulesStr,
                        GroupName = t.GroupName,
                        OrderNumber = t.OrderNumber,
                    }).ToList(),
                };
            }
            catch (Exception ex)
            {
                return new ResponseBase()
                {
                    Code = 300,
                    Message = "获取失败：" + ex.Message,
                };
            }
        }

        [Route("getShelfStatusDetails")]
        [HttpPost(Name = "getShelfStatusDetails")]
        public async Task<ResponseBase> getShelfStatusDetails(GetShelfStatusRequest request)
        {
            try
            {
                var shelfs = ShelfManager.Shelves
                                         .WhereIF(request.GroupNames?.Count > 0, t => request.GroupNames!.Contains(t.GroupName))
                                         .ToList();
                //直接返回当前内存中缓存的货架和状态
                return new ResponseBase<object>()
                {
                    Code = 200,
                    Message = "success",
                    Data = shelfs,
                };
            }
            catch (Exception ex)
            {
                return new ResponseBase()
                {
                    Code = 300,
                    Message = "获取失败：" + ex.Message,
                };
            }
        }

        [Route("getTCPClientsDetails")]
        [HttpPost(Name = "getTCPClientsDetails")]
        public async Task<ResponseBase> getTCPClientsDetails(GetShelfStatusRequest request)
        {
            try
            {
                var tcpClients = TCPClientManager.TCPClients.Select(t => new
                {
                    RemoteIPHost = t.RemoteIPHost,
                    IsReceivedClientOnline = t.IsReceivedClientOnline,
                    IsSendClientOnline = t.IsSendClientOnline,
                    IsFirstConnected = t.IsFirstConnected,
                    tcpClientIsNull = t.tcpSendClient == null,
                    tcpClientIsOnLine = t.tcpSendClient?.Online,

                }).ToList();
                //直接返回当前内存中缓存的货架和状态
                return new ResponseBase<object>()
                {
                    Code = 200,
                    Message = $"success！连接数量：{tcpClients.Count}",
                    Data = tcpClients,
                };
            }
            catch (Exception ex)
            {
                return new ResponseBase()
                {
                    Code = 300,
                    Message = "获取失败：" + ex.Message,
                };
            }
        }

        [Route("shelfCheckAll")]
        [HttpPost(Name = "shelfCheckAll")]
        public async Task<ResponseBase> shelfCheckAll(GetShelfStatusRequest request)
        {
            try
            {
                return await _selfCheckService.StartSelfCheckByGroupName(request.GroupNames);
            }
            catch (Exception ex)
            {
                return new ResponseBase()
                {
                    Code = 300,
                    Message = "操作失败：" + ex.Message,
                };
            }
        }


        /// <summary>
        /// 重置货架的状态 使其回到待机模式
        /// </summary>
        /// <param name="request"></param>
        /// <returns></returns>
        [Route("resetShelfStatus")]
        [HttpPost(Name = "resetShelfStatus")]
        public async Task<ResponseBase> resetShelfStatus(ResetShelfStatusRequest request)
        {
            try
            {
                if (request.IsResetAll == false && (request.SelfIds == null || request.SelfIds.Count == 0))
                {
                    return new ResponseBase()
                    {
                        Code = 201,
                        Message = "复位失败：请选择需要复位的货架！",
                    };
                }
                if (request.IsResetAll == true && (request.GroupNames == null || request.GroupNames.Count == 0))
                {
                    return new ResponseBase()
                    {
                        Code = 201,
                        Message = "复位失败：请选择需要复位的货架区域！",
                    };
                }
                var shelfs = new List<IShelfBase>();
                if (request.IsResetAll == false)
                    shelfs = ShelfManager.Shelves
                                             .Where(t => request.SelfIds.Contains(t.ShelfId))
                                             .Where(t => t.CurrentMode != TaskModeEnum.待机模式)
                                             .ToList();
                else
                    shelfs = ShelfManager.Shelves
                                             .Where(t => request.GroupNames.Contains(t.GroupName))
                                             .Where(t => t.CurrentMode != TaskModeEnum.待机模式)
                                             .ToList();
                foreach (var shelf in shelfs)
                {
                    shelf.Reset();
                }
                return new ResponseBase()
                {
                    Code = 200,
                    Message = "success",
                };

            }
            catch (Exception ex)
            {
                return new ResponseBase()
                {
                    Code = 300,
                    Message = ex.Message,
                };
            }
        }



        /// <summary>
        /// 获取货架对应的服务端的Ip和端口号
        /// </summary>
        /// <param name="request"></param>
        /// <returns></returns>
        [Route("getShelfServer")]
        [HttpPost(Name = "getShelfServer")]
        public async Task<ResponseBase> getShelfServer(RequestBase request)
        {
            try
            {
                return await _homerService.GetShelfServer(request);
            }
            catch (Exception ex)
            {
                return new ResponseBase<object>()
                {
                    Code = 300,
                    Message = "查询失败" + ex.Message,
                    Data = null
                };
            }
        }


        [Route("getWebSocketWarnings")]
        [HttpPost(Name = "getWebSocketWarnings")]
        public async Task<ResponseBase> getWebSocketWarnings(RequestBase request)
        {
            try
            {
                return new ResponseBase<object>()
                {
                    Code = 200,
                    Message = "success",
                    Data = WarningManager.Warnings
                };
            }
            catch (Exception ex)
            {
                return new ResponseBase<object>()
                {
                    Code = 300,
                    Message = "查询失败" + ex.Message,
                    Data = null
                };
            }
        }

        /// <summary>
        /// 生成模组信息
        /// </summary>
        /// <param name="request"></param>
        /// <returns></returns>
        [Route("generateModuleInfo")]
        [HttpPost(Name = "generateModuleInfo")]
        public async Task<ResponseBase> generateModuleInfo(RequestBase request)
        {
            try
            {
                //获取液晶的货架
                var shelfInfos = DbHelp.db.Queryable<ShelfInfo>()
                                          .Where(t => t.ShelfTypeName.Contains("液晶") && !t.ShelfCode.Contains("CP"))
                                          .ToList();
                var moduleInfos = new List<ModuleInfo>();

                int boardId = 1;
                var lastClientCode = string.Empty;

                foreach (var shelfInfo in shelfInfos)
                {
                    if (lastClientCode != shelfInfo.ClientIp)
                    {
                        lastClientCode = shelfInfo.ClientIp;
                        boardId = 1;
                    }
                    int shelfNumber = 1;
                    int floorNumber = 1;
                    int moduleNumber = 0;
                    while (floorNumber <= 4)
                    {
                        moduleNumber++;
                        if (moduleNumber > 7)
                        {
                            shelfNumber++;
                            moduleNumber = 1;
                        }
                        if (shelfNumber > 4)
                        {
                            floorNumber++;
                            shelfNumber = 1;
                        }

                        if (floorNumber == 5)
                        {
                            continue;
                        }

                        var moduleCode = $"{shelfInfo.ShelfCode}-{shelfNumber}-L{floorNumber}-{moduleNumber}";
                        var module = new ModuleInfo()
                        {
                            ModuleCode = moduleCode,
                            ShelfTypeId = 3,
                            ShelfId = shelfInfo.Id,
                            ShelfCode = shelfInfo.ShelfCode,
                            BoardId = boardId++,
                            LightCount = 1,
                            CleintIp = shelfInfo.ClientIp,
                            GroupName = shelfInfo.GroupName,
                            R = floorNumber.ToString(),
                            C = moduleNumber.ToString(),
                            IsEnable = true,
                        };
                        moduleInfos.Add(module);
                    }
                    ;
                }

                DbHelp.db.Insertable(moduleInfos).ExecuteCommand();

                return new ResponseBase<object>()
                {
                    Code = 200,
                    Message = "生成成功！",
                    Data = null
                };
            }
            catch (Exception ex)
            {
                return new ResponseBase<object>()
                {
                    Code = 300,
                    Message = "生成失败" + ex.Message,
                    Data = null
                };
            }
        }


        [Route("generateCPModuleInfo")]
        [HttpPost(Name = "generateCPModuleInfo")]
        public async Task<ResponseBase> generateCPModuleInfo(RequestBase request)
        {
            try
            {
                //获取液晶的货架
                var shelfInfos = DbHelp.db.Queryable<ShelfInfo>()
                                          .Where(t => t.ShelfTypeName.Contains("液晶") && t.ShelfCode.Contains("CP"))
                                          .ToList();
                var moduleInfos = new List<ModuleInfo>();

                int boardId = 1;
                var lastClientCode = string.Empty;

                foreach (var shelfInfo in shelfInfos)
                {
                    if (lastClientCode != shelfInfo.ClientIp)
                    {
                        lastClientCode = shelfInfo.ClientIp;
                        boardId = 1;
                    }

                    //先拆分shelfCode
                    var input = shelfInfo.ShelfCode.Split("-")[1];
                    List<int> numbers = new List<int>();
                    for (int i = 0; i < input.Length; i += 2)
                    {
                        // 提取两位字符
                        string numberStr = input.Substring(i, 2);
                        // 转换为整数并添加到列表中
                        int number = int.Parse(numberStr);
                        numbers.Add(number);
                    }
                    // 将列表转换为数组（如果需要）
                    int[] shelfNumbers = numbers.ToArray();
                    foreach (var shelfNumber in shelfNumbers)
                    {
                        int floorNumber = 1;
                        int moduleNumber = 0;
                        while (floorNumber <= 4)
                        {
                            moduleNumber++;
                            if (moduleNumber > 7)
                            {
                                moduleNumber = 1;
                                floorNumber++;
                            }
                            if (floorNumber == 5)
                            {
                                continue;
                            }
                            var moduleCode = $"CP-{shelfNumber}-L{floorNumber}-{moduleNumber}";
                            var module = new ModuleInfo()
                            {
                                ModuleCode = moduleCode,
                                ShelfTypeId = 3,
                                ShelfId = shelfInfo.Id,
                                ShelfCode = shelfInfo.ShelfCode,
                                BoardId = boardId++,
                                LightCount = 1,
                                CleintIp = shelfInfo.ClientIp,
                                GroupName = shelfInfo.GroupName,
                                R = floorNumber.ToString(),
                                C = moduleNumber.ToString(),
                                IsEnable = true,
                            };
                            moduleInfos.Add(module);
                        }

                    }
                }

                DbHelp.db.Insertable(moduleInfos).ExecuteCommand();

                return new ResponseBase<object>()
                {
                    Code = 200,
                    Message = "生成成功！",
                    Data = null
                };
            }
            catch (Exception ex)
            {
                return new ResponseBase<object>()
                {
                    Code = 300,
                    Message = "生成失败" + ex.Message,
                    Data = null
                };
            }
        }


        /// <summary>
        /// 进入调试模式
        /// </summary>
        /// <param name="request"></param>
        /// <returns></returns>
        [Route("goInDebugMode")]
        [HttpPost(Name = "goInDebugMode")]
        public async Task<ResponseBase> goInDebugMode(SetBoardIdRequest request)
        {
            try
            {
                //获取TCP
                var client = TCPClientManager.TCPClients
                                             .Where(t => t.RemoteIPHost == request.IPPort)
                                             .First();
                if (client == null)
                {
                    return new ResponseBase<object>()
                    {
                        Code = 300,
                        Message = "未获取到对应连接，请检查地址",
                        Data = null
                    };
                }
                //进入调试模式
                byte[] data = { 0x08, 0x00, 0x00, 0x07, 0xFF, 0xDB, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 };
                client.Send(data);

                return new ResponseBase<object>()
                {
                    Code = 200,
                    Message = "指令发送成功",
                    Data = null
                };
            }
            catch (Exception ex)
            {
                return new ResponseBase<object>()
                {
                    Code = 300,
                    Message = "指令发送失败" + ex.Message,
                    Data = null
                };
            }
        }


        [Route("goOutDebugMode")]
        [HttpPost(Name = "goOutDebugMode")]
        public async Task<ResponseBase> goOutDebugMode(SetBoardIdRequest request)
        {
            try
            {
                //获取TCP
                var client = TCPClientManager.TCPClients
                                             .Where(t => t.RemoteIPHost == request.IPPort)
                                             .First();
                if (client == null)
                {
                    return new ResponseBase<object>()
                    {
                        Code = 300,
                        Message = "未获取到对应连接，请检查地址",
                        Data = null
                    };
                }
                //退出调试模式
                byte[] data = { 0x08, 0x00, 0x00, 0x07, 0xFF, 0xDB, 0xFF, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 };
                client.Send(data);

                return new ResponseBase<object>()
                {
                    Code = 200,
                    Message = "指令发送成功",
                    Data = null
                };
            }
            catch (Exception ex)
            {
                return new ResponseBase<object>()
                {
                    Code = 300,
                    Message = "指令发送失败" + ex.Message,
                    Data = null
                };
            }
        }


        [Route("setId")]
        [HttpPost(Name = "setId")]
        public async Task<ResponseBase> setId(SetBoardIdRequest request)
        {
            try
            {
                //获取TCP
                var client = TCPClientManager.TCPClients
                                             .Where(t => t.RemoteIPHost == request.IPPort)
                                             .First();
                if (client == null)
                {
                    return new ResponseBase<object>()
                    {
                        Code = 300,
                        Message = "未获取到对应连接，请检查地址",
                        Data = null
                    };
                }
                //退出调试模式
                byte[] data = { 0x08, 0x00, 0x00, 0x07, 0xFF, 0xDB, 0x02, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00 };
                client.Send(data);

                var boardId = request.StartId;
                var boardIdData = BitConverter.GetBytes(unchecked((short)boardId));
                // 检查是否需要交换字节  
                if (BitConverter.IsLittleEndian)
                {
                    // 如果是小端序系统，则交换字节  
                    byte temp = boardIdData[0];
                    boardIdData[0] = boardIdData[1];
                    boardIdData[1] = temp;
                }

                Thread.Sleep(3000);
                byte[] data1 = { 0x08, 0x00, 0x00, 0x07, 0xFF, 0xC1, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 };
                data1[6] = boardIdData[0];
                data1[7] = boardIdData[1];

                client.Send(data1);

                return new ResponseBase<object>()
                {
                    Code = 200,
                    Message = "指令发送成功",
                    Data = null
                };
            }
            catch (Exception ex)
            {
                return new ResponseBase<object>()
                {
                    Code = 300,
                    Message = "指令发送失败" + ex.Message,
                    Data = null
                };
            }
        }


        [Route("setLight")]
        [HttpPost(Name = "setLight")]
        public async Task<ResponseBase> setLight(SetBoardIdRequest request)
        {
            try
            {
                //获取TCP
                var client = TCPClientManager.TCPClients
                                             .Where(t => t.RemoteIPHost == request.IPPort)
                                             .First();
                if (client == null)
                {
                    return new ResponseBase<object>()
                    {
                        Code = 300,
                        Message = "未获取到对应连接，请检查地址",
                        Data = null
                    };
                }

                var boardId = request.StartId;
                var boardIdData = BitConverter.GetBytes(unchecked((short)boardId));
                // 检查是否需要交换字节  
                if (BitConverter.IsLittleEndian)
                {
                    // 如果是小端序系统，则交换字节  
                    byte temp = boardIdData[0];
                    boardIdData[0] = boardIdData[1];
                    boardIdData[1] = temp;
                }
                byte[] data1 = { 0x08, 0x00, 0x00, 0x07, 0xFF, 0x20, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 };
                data1[7] = boardIdData[0];
                data1[8] = boardIdData[1];

                client.Send(data1);

                return new ResponseBase<object>()
                {
                    Code = 200,
                    Message = "指令发送成功",
                    Data = null
                };
            }
            catch (Exception ex)
            {
                return new ResponseBase<object>()
                {
                    Code = 300,
                    Message = "指令发送失败" + ex.Message,
                    Data = null
                };
            }
        }

        [Route("testLight")]
        [HttpPost(Name = "testLight")]
        public async Task<ResponseBase> testLight(SetBoardIdRequest request)
        {
            try
            {
                //获取TCP
                var client = TCPClientManager.TCPClients
                                             .Where(t => t.RemoteIPHost == request.IPPort)
                                             .First();
                if (client == null)
                {
                    return new ResponseBase<object>()
                    {
                        Code = 300,
                        Message = "未获取到对应连接，请检查地址",
                        Data = null
                    };
                }

                var boardId = request.StartId;
                for (; boardId <= 224; boardId++)
                {
                    var boardIdData = BitConverter.GetBytes(unchecked((short)boardId));
                    // 检查是否需要交换字节  
                    if (BitConverter.IsLittleEndian)
                    {
                        // 如果是小端序系统，则交换字节  
                        byte temp = boardIdData[0];
                        boardIdData[0] = boardIdData[1];
                        boardIdData[1] = temp;
                    }

                    //发送入库亮灯
                    byte[] data1 = { 0x08, 0x00, 0x00, 0x07, 0xFF, 0xA1, 0x01, 0x02, 0x02, 0x0A, 0x00, 0x00, 0x00 };
                    data1[7] = boardIdData[0];
                    data1[8] = boardIdData[1];

                    client.Send(data1);
                    Thread.Sleep(490);
                    //发送退出入库
                    byte[] data2 = { 0x08, 0x00, 0x00, 0x07, 0xFF, 0xA1, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 };
                    data2[7] = boardIdData[0];
                    data2[8] = boardIdData[1];
                    client.Send(data2);
                    Thread.Sleep(10);
                }


                return new ResponseBase<object>()
                {
                    Code = 200,
                    Message = "指令发送成功",
                    Data = null
                };
            }
            catch (Exception ex)
            {
                return new ResponseBase<object>()
                {
                    Code = 300,
                    Message = "指令发送失败" + ex.Message,
                    Data = null
                };
            }
        }


        [Route("resetByTCP")]
        [HttpPost(Name = "resetByTCP")]
        public async Task<ResponseBase> resetByTCP(SetBoardIdRequest request)
        {
            try
            {
                //获取TCP
                var client = TCPClientManager.TCPClients
                                             .Where(t => t.RemoteIPHost == request.IPPort)
                                             .First();
                if (client == null)
                {
                    return new ResponseBase<object>()
                    {
                        Code = 300,
                        Message = "未获取到对应连接，请检查地址",
                        Data = null
                    };
                }
                byte[] data = { 0x08, 0x00, 0x00, 0x07, 0xFF, 0xBE, 0x52, 0x54, 0x41, 0x52, 0x54, 0x0A, 0xED };
                client.Send(data);

                return new ResponseBase<object>()
                {
                    Code = 200,
                    Message = "指令发送成功",
                    Data = null
                };
            }
            catch (Exception ex)
            {
                return new ResponseBase<object>()
                {
                    Code = 300,
                    Message = "指令发送失败" + ex.Message,
                    Data = null
                };
            }
        }


        /// <summary>
        /// 配置库位编码
        /// </summary>
        /// <param name="request"></param>
        /// <returns></returns>
        [Route("setStoreCode")]
        [HttpPost(Name = "setStoreCode")]
        public async Task<ResponseBase> setStoreCode(SetBoardIdRequest request)
        {
            try
            {
                var errorList = new List<string>();
                //1.获取所有液晶标签货架
                var shelfs = ShelfManager.Shelves.Where(t => t.ShelfTypeName == "液晶标签货架")
                                                 .WhereIF(!string.IsNullOrEmpty(request.IPPort), t => t.ClientIp == request.IPPort)
                                                 .Select(t => t as MXL4Shelf)
                                                 .ToList();
                shelfs.ForEach(t =>
                {
                    t.MXL4Modules.ForEach(m =>
                    {
                        try
                        {
                            m.SendStoreCode(m.ModuleCode, t.TcpCleint);
                        }
                        catch (Exception ex)
                        {
                            errorList.Add($"模组{m.ModuleCode}更新库位ID失败！原因：{ex.Message}");
                        }

                    });
                });
                return new ResponseCommon
                {
                    Code = 200,
                    Message = "success",
                    Data = errorList
                };
            }
            catch (Exception ex)
            {
                return new ResponseCommon
                {
                    Code = 300,
                    Message = "操作失败：" + ex.Message,
                };
            }
        }
    }
}