using DataCapture_MA.Const;
using DataCapture_MA.Entity;
using DataCapture_MA.log4Net;
using DataCapture_MA.Model;
using Newtonsoft.Json;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Net.NetworkInformation;
using System.Reflection;
using System.Security.Cryptography;
using System.Text;
using System.Text.RegularExpressions;
using System.Threading;
using System.Threading.Tasks;
using static System.Windows.Forms.VisualStyles.VisualStyleElement;

namespace DataCapture_MA.DataHnadle
{
    public class ReceiveDataHandle
    {
        public static void SaveDataForSqlite(MessageAnalysis messageAnalysis)
        {
            try
            {
                using(DbModel dbModel = new DbModel())
                {
                    var robotInfo = AutoMapper.Mapper.Map<MessageAnalysis, RobotInfo>(messageAnalysis);
                    robotInfo.WarnningContent = JsonConvert.SerializeObject(messageAnalysis.Warnings);
                    robotInfo.CreateTime = DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss");
                    robotInfo.CreateStamp = DateTimeOffset.Now.ToUnixTimeSeconds();
                    dbModel.RobotInfo.Add(robotInfo);
                    dbModel.SaveChanges();
                }
            }
            catch(Exception ex)
            {
                Log4NetHelper.WriteErrorLog(LogType.Receive, "保存至数据库异常：" + ex.Message);
            }
        }

        public static void SendWarnForMes(MessageAnalysis messageAnalysis)
        {
            var sendCount = 0;
            Log4NetHelper.WriteInfoLog(LogType.PushMes, "推送设备完整信息：" + JsonConvert.SerializeObject(messageAnalysis));
            while (true)
            {
                try
                {
                    if (sendCount >= 5)
                    {
                        Log4NetHelper.WriteErrorLog(LogType.PushMes, "推送设备报警信息失败停止推送");
                        return;
                    }
                    // 推送
                    var pushResult = MesApiHelper.PushEquipmentWarning(messageAnalysis);
                    if(pushResult != null && pushResult.statusCode == 0)
                    {
                        Log4NetHelper.WriteInfoLog(LogType.PushMes, "推送设备报警消息至mes成功，返回：" + JsonConvert.SerializeObject(pushResult));
                        return;
                    }
                    Log4NetHelper.WriteErrorLog(LogType.PushMes, "推送设备报警消息至mes失败，返回：" + JsonConvert.SerializeObject(pushResult));
                    Thread.Sleep(2000);
                    sendCount++;
                }
                catch (Exception ex)
                {
                    Log4NetHelper.WriteErrorLog(LogType.PushMes, "推送报警消息至mes失败：" + ex.Message);
                    sendCount++;
                    continue;

                }
            }
        }
        public static void SendEquipmentStatusForMes(MessageAnalysis messageAnalysis)
        {
            var sendCount = 0;
            Log4NetHelper.WriteInfoLog(LogType.PushMes, "推送设备完整信息：" + JsonConvert.SerializeObject(messageAnalysis));
            while (true)
            {
                try
                {
                    if (sendCount >= 5)
                    {
                        Log4NetHelper.WriteErrorLog(LogType.PushMes, "推送设备状态信息失败停止推送");
                        return;
                    }
                    // 推送
                    var pushResult = MesApiHelper.PushEquipmentStatus(messageAnalysis);
                    if (pushResult != null && pushResult.statusCode == 0)
                    {
                        Log4NetHelper.WriteInfoLog(LogType.PushMes, "推送设备状态消息至mes成功，返回："+JsonConvert.SerializeObject(pushResult) );
                        return;
                    }
                    Log4NetHelper.WriteErrorLog(LogType.PushMes, "推送设备状态消息至mes失败，返回：" + JsonConvert.SerializeObject(pushResult));
                    Thread.Sleep(2000);
                    sendCount++;
                }
                catch (Exception ex)
                {
                    Log4NetHelper.WriteErrorLog(LogType.PushMes, "推送设备状态消息至mes失败：" + ex.Message);
                    sendCount++;
                    continue;
                }
            }
        }
        public static void SendEquipmentInfoForMes(MessageAnalysis messageAnalysis)
        {
            var sendCount = 0;
            Log4NetHelper.WriteInfoLog(LogType.PushMes, "推送设备完整信息：" + JsonConvert.SerializeObject(messageAnalysis));
            while (true)
            {
                try
                {
                    if (sendCount >= 5)
                    {
                        Log4NetHelper.WriteErrorLog(LogType.PushMes, "推送设备信息失败停止推送");
                        return;
                    }
                    // 推送
                    var pushResult = MesApiHelper.PushEquipmentInfo(messageAnalysis);
                    if (pushResult != null && pushResult.statusCode == 0)
                    {
                        Log4NetHelper.WriteInfoLog(LogType.PushMes, "推送设备消息至mes成功，返回：" + JsonConvert.SerializeObject(pushResult));
                        return;
                    }
                    Log4NetHelper.WriteErrorLog(LogType.PushMes, "推送设备消息至mes失败，返回：" + JsonConvert.SerializeObject(pushResult));
                    Thread.Sleep(2000);
                    sendCount ++ ;
                }
                catch (Exception ex)
                {
                    Log4NetHelper.WriteErrorLog(LogType.PushMes, "推送消息至mes失败：" + ex.Message);
                    sendCount++;
                    continue;
                }
            }
        }

        public static void AnalysisMeassage(string message)
        {
            try
            {
                // 解析收到的消息
                var messageAnalysis = new MessageAnalysis();

                foreach (var entry in DictMapping.fieldMapping)
                {
                    try
                    {
                        string tag = entry.Key;
                        string propertyName = entry.Value;
                        if (tag.Contains("MSGBUF")) continue;

                        // 正则表达式匹配标签内容
                        string pattern = $@"<{Regex.Escape(tag.Trim())}>(.*?)</{Regex.Escape(tag.Trim())}>";
                        Match match = Regex.Match(message, pattern);

                        if (!match.Success) 
                            continue;

                        string value = match.Groups[1].Value.Trim(); // 提取内容并去掉首尾空格

                        // 通过反射将值赋给实体类属性
                        PropertyInfo property = typeof(MessageAnalysis).GetProperty(propertyName);
                        if (property == null) { continue; }

                        if (property.PropertyType == typeof(int))
                        {
                            property.SetValue(messageAnalysis, int.Parse(value));
                        }
                        else if (property.PropertyType == typeof(bool))
                        {
                            property.SetValue(messageAnalysis, bool.Parse(value));
                        }
                        else
                        {
                            property.SetValue(messageAnalysis, value);
                        }
                    }
                    catch(Exception ex)
                    {
                        // 记录错误日志
                        Log4NetHelper.WriteErrorLog(LogType.Receive, "获取消息赋值失败:" + ex.Message);
                    }
                }
                Log4NetHelper.WriteInfoLog(LogType.Receive, JsonConvert.SerializeObject(messageAnalysis));
                // 处理报警信息
                var errorMsg = GetErrorMsg(message);
                if (!string.IsNullOrEmpty(errorMsg))
                {
                    var warringList = WarningInfoHandle(errorMsg);
                    messageAnalysis.Warnings = warringList;
                    Log4NetHelper.WriteInfoLog(LogType.Receive,"报警信息："+ JsonConvert.SerializeObject(warringList));
                }
                //// 推送mes
                //_ = Task.Run(() => SendWarnForMes(messageAnalysis));
                //_ = Task.Run(() => SendEquipmentStatusForMes(messageAnalysis));
                //_ = Task.Run(() => SendEquipmentInfoForMes(messageAnalysis));

                // Sqlite数据库保存一份
                _ = Task.Run(() => SaveDataForSqlite(messageAnalysis));
            }
            catch(Exception ex)
            {
                // 记录错误日志
                Log4NetHelper.WriteErrorLog(LogType.Receive, "解析收到消息异常:" + ex.Message);
            }
        }
        private static string GetErrorMsg(string message)
        {
            try
            {

                string numberPattern = @"(<ENUMBER>.*?<\/ENUMBER>)";
                Match numberMatch = Regex.Match(message, numberPattern);

                // 正则表达式匹配 MSGBUF 标签
                string msgbufPattern = @"(<MSGBUF\[\d+\].NR>.*?<\/MSGBUF\[\d+\].NR>)";
                MatchCollection msgbufMatches = Regex.Matches(message, msgbufPattern);

                // 拼接结果
                string result = "";
                var num = "0";
                if (numberMatch.Success)
                {
                    result += numberMatch.Groups[1].Value + Environment.NewLine;

                    string pattern = $@"<ENUMBER>(.*?)</ENUMBER>";
                    Match match = Regex.Match(result, pattern);
                    if (match.Success)
                    {
                        num = match.Groups[1].Value.Trim();
                        if (num == "0") return "";
                    }

                }
                var count = 0;
                foreach (Match match in msgbufMatches)
                {
                    if (count >= Convert.ToInt32(num))
                    {
                        return result;
                    }
                    result += match.Groups[1].Value + Environment.NewLine;
                    count++;

                }
                return result;
            }
            catch(Exception ex)
            {
                // 记录错误日志
                Log4NetHelper.WriteErrorLog(LogType.Receive,"获取报警信息异常:"+ex.Message);
                return "";
            }
        }

        private static List<WarningInfo> WarningInfoHandle(string errMsg)
        {
            var warns = new List<WarningInfo>();
            if (string.IsNullOrEmpty(errMsg))
            {
                return warns;
            }
            string pattern = @"<MSGBUF\[\d+\].NR>(.*?)<\/MSGBUF\[\d+\].NR>";
            MatchCollection matches = Regex.Matches(errMsg, pattern);

            foreach (Match match in matches)
            {
                var warn = new WarningInfo();
                string msgContent = match.Groups[1].Value.Trim();
                if (!string.IsNullOrEmpty(msgContent))
                {
                    //result += msgContent + "；"; // 添加分割符
                    CacheWarningDict.WarningDict.TryGetValue(msgContent, out var warnContent);
                    if (warnContent != null)
                    {
                        warn.WarningContent = warnContent.WarningContent.Trim();
                        warn.WarningCode = warnContent.WarningCode;
                    }
                    warn.WarningCache = msgContent;
                }
                // 获取报警描述信息

                warns.Add(warn);
            }

            return warns;
        }
    }
}