using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Text.RegularExpressions;
using System.Threading.Tasks;
using TouchSocket.Core;
using WCS.BLL.Config;
using WCS.BLL.Manager;
using WCS.BLL.Services.IService;
using WCS.BLL.Tool;
using WCS.DAL;
using WCS.DAL.Db;
using WCS.DAL.Db.AuthDb;
using WCS.DAL.DbModels;
using WCS.Model;
using WCS.Model.ApiModel;
using WCS.Model.ApiModel.SingleLight;
using WCS.Model.ApiModel.User;
using WCS.Model.WebSocketModel;
using static System.Formats.Asn1.AsnWriter;
using static WCS.BLL.Tool.Helper;

namespace WCS.BLL.Services.Service
{
    public class SingleLightService : ISingleLightService
    {
        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);
            }
        }

        /// <summary>
        /// 单灯 一个库位对应一个硬件
        /// </summary>
        /// <param name="request"></param>
        /// <returns></returns>
        public async Task<ResponseCommon<object>> SingleLightControl(SingleLightControlRequest request)
        {
            try
            {
                //传入数据校验
                if (request.StoreCodes == null || request.StoreCodes.Count == 0)
                {
                    return new ResponseCommon<object>()
                    {
                        Code = 201,
                        Message = "操作失败：没有需要控制的库位",
                    };
                }
                //瓦斯分院库位数与灯不匹配所以进行如下操作
                //处理传入的库位
                if(!LocalFile.Config.IsZuantan)
                {
                    for (int i = 0; i < request.StoreCodes.Count; i++)
                    {
                        request.StoreCodes[i] = ExtractUntilSecondDashCorrect(request.StoreCodes[i]);
                    }
                }


                //库位编码去重
                var storeCodes = request.StoreCodes.Distinct()
                                                  .ToList();
                var stores = DbHelp.db.Queryable<StoreInfo>()
                                      .Where(t => storeCodes.Contains(t.StoreCode))
                                      .ToList();
                if (stores == null || stores.Count == 0)
                {
                    return new ResponseCommon<object>
                    {
                        Code = 201,
                        Message = $"操作失败：所有库位不存在！"
                    };
                }

                //对应货架（获取TCP和报警灯ID）
                var shelfIds = stores.Select(t => t.ShelfId).Distinct().ToList();
                var shelfs = DbHelp.db.Queryable<ShelfInfo>().Where(t => shelfIds.Contains(t.Id))
                                                             .ToList();

                ////对应模组信息
                //var moduleIds = stores.Select(t => t.ModuleId).Distinct().ToList();
                //var modules = DbHelp.db.Queryable<ModuleInfo>().Where(t => moduleIds.Contains(t.Id))
                //                                               .ToList();

                //合并：同一个货架的库位合并
                var shelfModels = new List<SingleLightShelfModel>();
                foreach (var shelf in shelfs)
                {
                    var shelfModel = new SingleLightShelfModel();
                    //报警灯
                    if (shelf.LightId > 0)
                    {
                        shelfModel.WarningLightMode = request.LightMode;
                    }
                    shelfModel.WarningLightColor = request.ColorMode;
                    shelfModel.WarningBoardId = shelf.LightId;
                    shelfModel.ClientIp = shelf.ClientIp;

                    shelfModel.StoreList = stores.Where(t => t.ShelfId == shelf.Id)
                                                 .Select(t => new SingleLightStoreModel()
                                                 {
                                                     BoardId = t.BoardId,
                                                     LightMode = request.LightMode,
                                                     LightColor = request.ColorMode,
                                                     LightNumber = t.SingleLightNumber,
                                                 }).ToList();

                    shelfModels.Add(shelfModel);
                }

                //合并：同一个TCP的货架合并 报警灯和库位灯统一只发送一条指令
                var clients = shelfs.Select(t => new
                {
                    ClientIp = t.ClientIp,
                    IsService = t.IsService,
                })
                .Distinct()
                .ToList();
                foreach (var client in clients)
                {
                    var shelfModelsInOneIp = shelfModels.Where(t => t.ClientIp == client.ClientIp).ToList();

                    var sendData = Helper.SingleLightControl(shelfModelsInOneIp);
                    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() == client.ClientIp).FirstOrDefault();
                        if (tcpClient != null)
                        {
                            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}",
                                };
                            }
                        }
                        else
                        {
                            Logs.Write($"【单灯单独控制】{client}未连接，以下指令未能成功发送" + BitConverter.ToString(sendData));
                            return new ResponseCommon<object>()
                            {
                                Code = 201,
                                Message = $"【单灯单独控制】{client}未连接，以下指令未能成功发送",
                            };
                        }
                    }
                }

                //更新数据库灯的状态
                stores.ForEach(t =>
                {
                    t.LightMode = request.LightMode;
                    t.ColorMode = request.ColorMode;
                });
                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 async Task<ResponseCommon<object>> TurnoffLightByArea(TurnoffLightByAreaRequest request)
        {
            try
            {
                //传入数据校验
                if (string.IsNullOrEmpty(request.Area))
                {
                    return new ResponseCommon<object>()
                    {
                        Code = 201,
                        Message = "操作失败：参数传入错误！Area为空！",
                    };
                }
                //库位
                var stores = DbHelp.db.Queryable<StoreInfo>()
                                      .Where(t => t.Area == request.Area)
                                      .ToList();
                if (stores == null || stores.Count == 0)
                {
                    return new ResponseCommon<object>
                    {
                        Code = 201,
                        Message = $"操作失败：所选区域不存在库位！"
                    };
                }

                //对应货架（获取TCP和报警灯ID）
                var shelfIds = stores.Select(t => t.ShelfId).Distinct().ToList();
                var shelfs = DbHelp.db.Queryable<ShelfInfo>().Where(t => shelfIds.Contains(t.Id))
                                                             .ToList();
                //获取对应货架所有IP
                var clients = shelfs.Select(t => new
                {
                    ClientIp = t.ClientIp,
                    IsService = t.IsService,
                })
                .Distinct()
                .ToList();

                //挨个发关灯指令
                foreach (var client in clients)
                {
                    //生成关灯指令
                    var sendData = Helper.SingleLightTrunOffAllLight();

                    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() == client.ClientIp).FirstOrDefault();
                        if (tcpClient != null)
                        {
                            try
                            {
                                tcpClient.Send(sendData, 0, sendData.Length);
                                Logs.Write("【熄灯】发送指令" + BitConverter.ToString(sendData));
                            }
                            catch (Exception ex)
                            {
                                Logs.Write($"【熄灯】{client}以下指令发送中遇到异常{ex.Message}" + BitConverter.ToString(sendData));

                            }
                        }
                        else
                        {
                            Logs.Write($"【熄灯】{client}未连接，以下指令未能成功发送" + BitConverter.ToString(sendData));
                            return new ResponseCommon<object>()
                            {
                                Code = 201,
                                Message = $"【熄灯】{client}未连接，以下指令未能成功发送",
                            };
                        }
                    }
                }

                //更新灯状态为熄灭
                //var stores = DbHelp.db.Queryable<StoreInfo>().Where(t => t.Area == request.Area).ToList();
                stores.ForEach(t =>
                {
                    t.ColorMode = 0;
                    t.LightMode = 0;
                });
                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}",
                };
            }
        }
    }
}