using Abp.Dependency;
using Amazon.Runtime.Internal.Transform;
using MongoDB.Driver.Linq;
using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Linq;
using System.Text.RegularExpressions;
using System.Threading.Tasks;
using System.Windows.Controls;
using System.Windows.Forms;
using ToolLibrary.LogHelper;
using Yunda.ISAS.DataMonitoringServer.DataAnalysis.DataCollection;
using Yunda.ISAS.DataMonitoringServer.DataAnalysis.Helper;
using Yunda.ISAS.DataMonitoringServer.DataAnalysis.TeleInfoSave;
using Yunda.ISAS.DataMonitoringServer.DataCenter;
using Yunda.ISAS.DataMonitoringServer.WebApi;
using Yunda.ISAS.DataMonitoringServer.WebSocket;
using Yunda.SOMS.DataMonitoringServer.ProtectionDeviceHandle;
using Yunda.SOMS.DataMonitoringServer.TcpSocket.Server;
using YunDa.SOMS.DataTransferObject.GeneralInformation.SecondaryCircuitDto;

namespace Yunda.ISAS.DataMonitoringServer.DataAnalysis
{

    public class MonitoringDataService : ISingletonDependency
    {
        /// <summary>
        /// 是否在运行
        /// </summary>
        //public bool IsRunning { get; set; }
        private readonly DataCollectionTask _dataCollectionTask;
        private readonly TelemeteringResultSaveTask _telemeteringResultSaveTask;
        private readonly WebSocketServer _webSocketServer;
        //private readonly WebApiServer _webApiServer;
        private readonly ConfigurationHepler _configurationHepler;
        private readonly WebApiRequest _webApiRequest;
        private readonly RunningDataCache _runningDataCache;
        private readonly TelecomDataCenter _telecomDataCenter;
        private readonly DotNettyTcpServer _dotNettyTcpServer;
        private readonly ProtectionDeviceDataCenter _protectionDeviceDataCenter;
        private readonly ProtectionDeviceDZDataHandle _protectionDeviceDZDataHandle;
        private readonly RedisDataRepository _redisDataRepository;
        WPF.ViewModel.Content _settingModel;
        public MonitoringDataService(WebApiRequest webApiRequest,
            RunningDataCache runningDataCache,
            DataCollectionTask dataCollectionTask,
            TelemeteringResultSaveTask telemeteringResultSaveTask,
            WebSocketServer webSocketController,
             ConfigurationHepler configurationHepler,
             TelecomDataCenter telecomDataCenter,
             DotNettyTcpServer dotNettyTcpServer,
             ProtectionDeviceDZDataHandle protectionDeviceDZDataHandle,
             ProtectionDeviceDataCenter protectionDeviceDataCenter,
             RedisDataRepository redisDataRepository
            //WebApiServer webApiServer
            )
        {
            _telecomDataCenter = telecomDataCenter;
            _webApiRequest = webApiRequest;
            _runningDataCache = runningDataCache;
            _dataCollectionTask = dataCollectionTask;
            _telemeteringResultSaveTask = telemeteringResultSaveTask;
            _webSocketServer = webSocketController;
            //_webApiServer = webApiServer;
            _configurationHepler = configurationHepler;
            _dotNettyTcpServer = dotNettyTcpServer;
            //var webapiPort = _configurationHepler.GetAppsettingsValue("ConnectionStrings", "WebApi", "Port");
            _protectionDeviceDZDataHandle = protectionDeviceDZDataHandle;
            _protectionDeviceDataCenter = protectionDeviceDataCenter;
            _redisDataRepository = redisDataRepository;
            //_webApiServer.RunServerAsync(int.Parse(webapiPort));
        }
        private bool IsOpenWebSocket = false;
        private Action<string> _recvMsgAc =msg =>
        {
            MessageBox.Show(msg);
        };
        /// <summary>
        /// 开始服务
        /// </summary>
        /// <returns></returns>
        public async void DataServiceStart(WPF.ViewModel.Content settingModel)
        {
            _settingModel = settingModel;
            Action startWebsocket = () =>
            {
                try
                {
                    if (!IsOpenWebSocket)
                    {
                        _telemeteringResultSaveTask.SaveStart();//开启遥测数据保存
                        _telecomDataCenter.ExcuteSelfChecking();
                        var path = _configurationHepler.GetAppsettingsValue("ConnectionStrings", "Websocket", "Path");
                        var port = _configurationHepler.GetAppsettingsValue("ConnectionStrings", "Websocket", "Port");
                        //_webSocketServer.WebSocketStartAsync(path, int.Parse(port));
                        IsOpenWebSocket = true;
                    }
                }
                catch (Exception ex)
                {
                    Log4Helper.Error(this.GetType(), "websocket", ex);
                }

            };
            SetMonitoringData(_configurationHepler.SubstationId);
            if (settingModel.DataSourceCategoryName =="综自")
            {
                MonitoringEventBus.LogHandler("启动装置定值接口", "装置定值");
                await _protectionDeviceDataCenter.InitProtectionDeviceComms();
                await InitSecondaryCircuitLogicExpressionDic();
            }
            _dataCollectionTask.CollectionStart(settingModel, startWebsocket);//开启数据采集
        }
        public void CallAllData()
        {
            _dataCollectionTask.CallAllData();
        }

        /// <summary>
        /// 停止服务
        /// </summary>
        public void DataServiceStop()
        {
            _dataCollectionTask.CollectionStop(); //数据采集停止
            _dotNettyTcpServer.StopSeverAsync();
            if (_settingModel.DataSourceCategoryName == "综自")
            {
                _protectionDeviceDataCenter.StopAllProcesses();
            }
            
        }
        /// <summary>
        /// 从服务端获取遥信遥测数据 填入缓存中
        /// </summary>
        private void SetMonitoringData(Guid transformerSubstationId)
        {
            try
            {
                //1、从业务服务中获取监控遥测，遥信数据并更新至MonitoringDataService.EquipmentData中
                //_webApiRequest.GetEquipmentData(transformerSubstationId);
                //_webApiRequest.GetLinkageStrategyData(transformerSubstationId);
                //_webApiRequest.GetVideoDevs(transformerSubstationId);
                _webApiRequest.GetTransubstationInfo(transformerSubstationId);
                _webApiRequest.GetEquipmentInfoSimDatas(transformerSubstationId);
                _webApiRequest.GetEquipmentTypeSimDatas();
                _webApiRequest.GetDMAlarmCategorySimpleSimDatas(transformerSubstationId);
                _webApiRequest.GetTelemeteringAlarmStrategySimDatas(transformerSubstationId);
                //var count = _runningDataCache.VideoDevs.Count;
                //MonitoringEventBus.LogHandler($"从服务器获取了{count}条摄像头数据", "服务器数据更新");
                //_webApiRequest.GetTelecommandModels(transformerSubstationId);
                //count = _runningDataCache.TelecommandModels.Count;
                //MonitoringEventBus.LogHandler($"从服务器获取了{count}条遥控配置数据", "服务器数据更新");
                //_webApiRequest.InitCamAuthCache();
            }
            catch (Exception ex)
            {
                MonitoringEventBus.LogHandler(ex.Message, "异常信息");
            }
        }
        private async Task InitSecondaryCircuitLogicExpressionDic()
        {
            try
            {
                _runningDataCache.SecondaryCircuitLogicExpressionDic.Clear();
                var yxlist =await _redisDataRepository.GetTelesignalisationModels();
                var yclist =await _redisDataRepository.GetTelemeteringModels();
                var ycCheckList =( await _redisDataRepository.GetCheckTelemeteringModels()).ToDictionary(t => t.Id);
                var yxSendList =( await _redisDataRepository.GetSendTelesignalisationModels()).ToDictionary(t => t.Id);

                var yxDic = yxlist.ToDictionary(t => t.Id);
                var ycDic = yclist.ToDictionary(t => t.Id);
                var list = _webApiRequest.GetSecondaryCircuitLogicExpressionList();
                foreach (var item in list) 
                {
                    if (!ycCheckList.ContainsKey(item.TelemeteringConfigurationId.Value)|| !yxSendList.ContainsKey(item.TelesignalisationConfigurationId.Value))
                    {
                        Debug.WriteLine("错误，没有找到遥测/遥信");
                        continue;
                    }
                    var checktelemeteringConfiguration = ycCheckList[item.TelemeteringConfigurationId.Value];
                    var sendtelesignalConfiguration = yxSendList[item.TelesignalisationConfigurationId.Value];


                    float? upperLimit = checktelemeteringConfiguration.UpperLimit;
                    float? lowerLimit = checktelemeteringConfiguration.LowerLimit;
                    // 正则表达式匹配花括号中的内容，包括 GUID
                    string pattern = @"\{([^}]*:([0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{12}))\}";
                    Regex regex = new Regex(pattern);

                    item.LogicalExpression = regex.Replace(item.LogicalExpression, match =>
                    {
                        // 提取 GUID
                        var guidStr = match.Groups[2].Value;
                        var guid = Guid.Parse(guidStr);

                        // 查找对应的 key
                        if (yxDic.TryGetValue(guid, out var yx))
                        {
                            return $"{{{yx.DeviceAddress}_{yx.CPUSector}_{yx.DispatcherAddress}_{(int)yx.DataSourceCategory}}}";

                        }
                        else if (ycDic.TryGetValue(guid, out var yc))
                        {
                            // 构造 key 替换
                            return $"{{{yc.DeviceAddress}_{yc.CPUSector}_{yc.DispatcherAddress}_{(int)yc.DataSourceCategory}}}";
                        }
                        // 如果未找到，保留原内容
                        return match.Value;
                    });
                    // 输出替换后的 LogicalExpression
                    Debug.WriteLine($"替换后的 LogicalExpression: {item.LogicalExpression}");
                    // 正则表达式匹配花括号中的内容
                    string pattern1 = @"\{([^}]*)\}";
                    Regex regex1 = new Regex(pattern1);
                    // 提取匹配结果
                    MatchCollection matches = regex1.Matches(item.LogicalExpression);
                    List<string> extractedValues = new List<string>();
                    var logicalExpression = $"({item.LogicalExpression})>={lowerLimit}&&({item.LogicalExpression})<={upperLimit}";
                    foreach (Match match in matches)
                    {
                        string key = match.Groups[1].Value;
                        var logicExpressionTelesignalisation = new LogicExpressionTelesignalisation
                        {
                            LogicExpression = logicalExpression,
                            TelesignalisationAddr = $"{sendtelesignalConfiguration.DeviceAddress}_{sendtelesignalConfiguration.CPUSector}_{sendtelesignalConfiguration.DispatcherAddress}_{(int)sendtelesignalConfiguration.DataSourceCategory}"
                        };
                        if (_runningDataCache.SecondaryCircuitLogicExpressionDic.ContainsKey(key))
                        {
                            _runningDataCache.SecondaryCircuitLogicExpressionDic[key].Add(logicExpressionTelesignalisation);
                        }
                        else
                        {
                            _runningDataCache.SecondaryCircuitLogicExpressionDic.Add(key, new List<LogicExpressionTelesignalisation> { logicExpressionTelesignalisation });
                        }
                    }
                }
            }
            catch (Exception ex)
            {
                MonitoringEventBus.LogHandler(ex.Message, "异常信息");

            }
        }
    }
}