using Common.Communication.Protocol.Modbus;
using log4net;
using System;
using System.Collections.Concurrent;
using System.Collections.Generic;
using System.Reflection;
using System.Threading;

namespace Common.Communication.TCP
{
    public class ModbusTCPMaster
    {
        static ILog log = LogManager.GetLogger(MethodBase.GetCurrentMethod()?.DeclaringType);
        List<Register> registers = new List<Register>() {
        new CoilRegister(),new DiscreteInputRegister(),new HoldingRegister(),
        new InputRegister()
        };
        public static List<string> Functions = new List<string>() {
        "01 Read Coils","02 Read Discrete Inputs","03 Read Holding Registers",
        "04 Read Input Registers","05 WriteSingle Coil","06 Write Single Register",
        "0F Write Multiple Coils","10 Write Multiple Registers"
        };
        TcpClient tcpClient = new TcpClient();
        Thread thread;

        public delegate void ConnectionChangedHandler(string ip, int port, bool onOff);
        public delegate void ReceiveDataHandler(string ip, int port, RequestInfo requestInfo, byte[] data);
        public event ConnectionChangedHandler ConnectionChanged;
        public event ReceiveDataHandler ReceiveData;
        public bool IsAutoReconnect = false;
        public int TryTimes = 5;
        public string IP { get; private set; }
        public int Port { get; private set; }
        bool online = false;
        public bool Online
        {
            get { return online; }
            private set
            {
                if (online != value)
                {
                    online = value;
                    ConnectionChanged?.Invoke(IP, Port, value);
                }
            }
        }
        bool start = false;
        public ModbusTCPMaster()
        {
            start = true;
            thread = new Thread(sendQueueRequest);
            thread.IsBackground = true;
            thread.Start();
        }
        ~ModbusTCPMaster()
        {
            start = false;
        }
        object locsend = new object();
        private const int SEND_SLEEP = 50;   //每条命令发送的间隔
        void sendQueueRequest()
        {
            while (start)
            {
                if (Monitor.TryEnter(locsend))
                {
                    try
                    {
                        Online = tcpClient.IsConnected();
                        if (!Online)
                        {
                            if (IsAutoReconnect)
                            {
                                tcpClient.Connect(IP, Port, ReceiveMessage);
                                Thread.Sleep(1000);
                                RequestInfo requestInfo = GetPeek();
                                if (requestInfo != null && requestInfo.Requested)
                                {
                                    requestInfo.SetRequestState(false);
                                    log.Error($"Disconnect 重置请求状态{requestInfo}");
                                    continue;
                                }
                            }
                        }
                        else
                        {
                            SendRequest();
                        }


                    }
                    catch (Exception ex)
                    {
                        log.Error($"sendQueueRequest出错");
                    }
                    finally
                    {
                        Monitor.Exit(locsend);
                    }
                }

            }
        }
        /// <summary>
        /// 请求队列
        /// </summary>
        ConcurrentQueue<RequestInfo> requestInfos = new ConcurrentQueue<RequestInfo>();

        public void Connect(string ip, int port)
        {
            IP = ip;
            Port = port;
            tcpClient.Connect(ip, port, ReceiveMessage);
            Thread.Sleep(1000);
            IsAutoReconnect = true;
        }
        public void Close()
        {
            tcpClient.Close();
        }
        /// <summary>
        /// 添加请求
        /// </summary>
        /// <param name="requestInfo">请求信息</param>
        public void AddRequest(RequestInfo requestInfo)
        {
            EnRequestQueue(requestInfo);
        }
        /// <summary>
        /// 添加请求
        /// </summary>
        /// <param name="funCode"></param>
        /// <param name="startAddr"></param>
        /// <param name="countOrValue"></param>
        /// <param name="equpAddr"></param>
        /// <param name="values"></param>
        public void AddRequest(byte funCode, int startAddr, int countOrValue, byte equpAddr = 1, int[] values = null)
        {
            EnRequestQueue(new RequestInfo()
            {
                FunCode = funCode,
                StartAddr = startAddr,
                CountOrValue = countOrValue,
                EquipAddr = equpAddr,
                Values = values
            });
        }
        /// <summary>
        /// 收到数据
        /// </summary>
        /// <param name="msg"></param>
        void ReceiveMessage(string msg, byte[] data)
        {
            log.Debug($"Receive Data {StringHelper.ToHexString(data)}");
            List<byte[]> recvFun = Register.SplitResponse(data);
            foreach (var item in recvFun)
            {
                log.Debug($"Process Data {StringHelper.ToHexString(item)}");
                RequestInfo requestInfo = GetPeek();
                if (requestInfo != null)
                {
                    byte[] readData;
                    bool rtn = GetResponseResult(requestInfo.FunCode, item, out readData);
                    if (rtn)
                    {
                        RemovePeek(true);
                        if (readData != null)
                        {
                            ReceiveData?.Invoke(IP, Port, requestInfo, readData);
                            log.Debug($"{StringHelper.ToHexString(readData)}{requestInfo}");
                        }
                    }
                    else
                    {
                        rtn = GetResponseResult(requestInfo.FunCode, item, out readData,true);
                        if(rtn)
                        {
                            if (readData != null)
                            {
                                ReceiveData?.Invoke(IP, Port, requestInfo, readData);
                                log.Debug($"{StringHelper.ToHexString(readData)}{requestInfo}");
                            }
                        }
                        else
                        {
                            if (Register.ParseHeader(item, out byte func, out int len))
                            {
                                rtn = GetResponseResult(func, item, out readData, true);
                                if (rtn)
                                {
                                    if (readData != null)
                                    {
                                        ReceiveData?.Invoke(IP, Port, new RequestInfo() { FunCode = func }, readData);
                                        log.Debug($"{StringHelper.ToHexString(readData)}");
                                    }
                                }
                            }
                            else
                            {
                                requestInfo.SetRequestState(false);
                                log.Error($"Request Fail {requestInfo}");
                                requestInfo.TryTimes++;
                                //if (requestInfo.TryTimes > TryTimes)//重试一定次数失败删除
                                //{
                                //    RemovePeek(false);
                                //}
                            }

                        }

                    }
                }
                else//设备主动上传收到的信息
                {
                    log.Debug($"Upload {StringHelper.ToHexString(item)}");
                    if (Register.ParseHeader(item, out byte func, out int len))
                    {
                        bool rtn = GetResponseResult(func, item, out byte[] readData,true);
                        if (rtn)
                        {
                            if (readData != null)
                            {
                                ReceiveData?.Invoke(IP, Port, new RequestInfo() { FunCode = func }, readData);
                                log.Debug($"{StringHelper.ToHexString(readData)}");
                            }
                        }
                        else
                        {
                            log.Error($"Upload GetResponseResult Fail {StringHelper.ToHexString(item)}");
                        }
                    }
                    else
                    {
                        log.Error($"Upload ParseHeader Fail {StringHelper.ToHexString(item)}");
                    }
                }
            }
        }
        RegisterFunction GetFunction(byte funCode)
        {
            Register register = GetRegister(funCode);
            if (register == null)
            {
                log.Error($"不存在的功能码：{StringHelper.ToHexString(funCode)}");
                return RegisterFunction.Read;
            }
            return GetFuncByByte(register, funCode);
        }
        /// <summary>
        /// 获取请求字节数组
        /// </summary>
        /// <param name="funCode"></param>
        /// <param name="startAddr"></param>
        /// <param name="countOrValue"></param>
        /// <param name="values"></param>
        /// <returns></returns>
        byte[] GetRequestBytes(byte funCode, int startAddr, int countOrValue, byte equipAddr, int[] values = null)
        {
            Register register = GetRegister(funCode);
            if (register == null)
            {
                log.Error($"不存在的功能码：{StringHelper.ToHexString(funCode)}");
                return new byte[] { 0x00 };
            }
            RegisterFunction registerFunction = GetFuncByByte(register, funCode);

            if (values != null)
            {
                ushort[] tmpvalues = new ushort[values.Length];
                for (int i = 0; i < values.Length; i++)
                {
                    tmpvalues[i] = (ushort)values[i];
                }
                return register.GetRequestBytes(registerFunction, (ushort)startAddr, (ushort)countOrValue, equipAddr, tmpvalues);
            }
            return register.GetRequestBytes(registerFunction, (ushort)startAddr, (ushort)countOrValue, equipAddr, null);
        }
        /// <summary>
        /// 获取响应结果
        /// </summary>
        /// <param name="funCode">功能码</param>
        /// <param name="response">响应的字节数组</param>
        /// <param name="data">只有读操作可以使用：读取到的数据</param>
        /// <returns>true：操作成功</returns>
        bool GetResponseResult(byte funCode, byte[] response, out byte[] data, bool ignoreSerial = false)
        {
            data = null;
            Register register = GetRegister(funCode);
            if (register == null)
            {
                log.Error($"不存在的功能码：{StringHelper.ToHexString(funCode)}");
                return false;
            }
            RegisterFunction registerFunction = GetFuncByByte(register, funCode);
            if (ignoreSerial)
                return register.GetReadReault(response, out data);
            else
                return register.GetResult(registerFunction, response, out data);
        }
        RegisterFunction GetFuncByByte(Register register, byte funCode)
        {
            RegisterFunction registerFunction = RegisterFunction.Read;
            foreach (RegisterFunction item in register.FunctionCodes.Keys)
            {
                if (register.FunctionCodes[item].Equals(funCode))
                {
                    registerFunction = item;
                    break;
                }
            }
            return registerFunction;
        }
        /// <summary>
        /// 根据功能码定位置指定寄存器
        /// </summary>
        /// <param name="funCode"></param>
        /// <returns></returns>
        Register GetRegister(byte funCode)
        {
            return registers.Find(s => s.FunctionCodes.ContainsValue(funCode));
        }
        /// <summary>
        /// 加入队列
        /// </summary>
        /// <param name="request"></param>
        void EnRequestQueue(RequestInfo request)
        {
            requestInfos.Enqueue(request);
            //if (!GetFunction(request.FunCode).Equals(RegisterFunction.Read))
            //    log.Info($"Enqueue Request {request}");
            //else
                log.Debug($"Enqueue Request {request}");
        }
        /// <summary>
        /// 获取队列第一个请求
        /// </summary>
        /// <returns></returns>
        RequestInfo GetPeek()
        {
            requestInfos.TryPeek(out RequestInfo request);
            return request;
        }
        /// <summary>
        /// 移除队列第一个请求
        /// </summary>
        /// <returns></returns>
        bool RemovePeek(bool success)
        {
            bool rtn = requestInfos.TryDequeue(out RequestInfo request);
            if (success)
            {
                request.Result = true;
                request.FinishTime = DateTime.Now;
                if (!GetFunction(request.FunCode).Equals(RegisterFunction.Read))
                    log.Info($"Request Success {request}");
                else
                    log.Debug($"Request Success {request}");
            }
            else
            {
                log.Error($"Try Request {TryTimes} Times Fail {request}");
            }
            return rtn;
        }
        void SendRequest()
        {
            RequestInfo requestInfo = GetPeek();
            if (requestInfo != null && (!requestInfo.Requested || requestInfo.RequestTimeOut))
            {
                bool rtn = tcpClient.Send(GetRequestBytes(requestInfo.FunCode, requestInfo.StartAddr, requestInfo.CountOrValue, requestInfo.EquipAddr, requestInfo.Values));
                requestInfo.SetRequestState(rtn);
                if (!GetFunction(requestInfo.FunCode).Equals(RegisterFunction.Read))
                    log.Info($"Request {requestInfo}");
                else
                    log.Debug($"Request {requestInfo}");
            }
        }
    }
    /// <summary>
    /// Modbus请求信息
    /// </summary>
    public class RequestInfo
    {
        /// <summary>
        /// 功能码
        /// </summary>
        public byte FunCode { get; set; }
        /// <summary>
        /// 开始地址
        /// </summary>
        public int StartAddr { get; set; }
        /// <summary>
        /// 数量/值
        /// </summary>
        public int CountOrValue { get; set; }
        /// <summary>
        /// 设备地址
        /// </summary>
        public byte EquipAddr { get; set; }
        /// <summary>
        /// 数组值，写多个值用到
        /// </summary>
        public int[] Values { get; set; }
        /// <summary>
        /// 等待一定秒数反转信号。大于0，反转
        /// </summary>
        public int Seconds { get; set; } = 0;
        /// <summary>
        /// 是否请求过
        /// </summary>
        public bool Requested { get; set; } = false;
        public int TryTimes { get; set; } = 0;
        /// <summary>
        /// 请求时间
        /// </summary>
        public DateTime RequestTime { get; set; } = DateTime.Now;
        public DateTime FinishTime { get; set; }
        /// <summary>
        /// 请求超时
        /// </summary>
        public bool RequestTimeOut { get { return (DateTime.Now - RequestTime).TotalSeconds > 5; } }
        /// <summary>
        /// 结果
        /// </summary>
        public bool Result { get; set; } = false;
        /// <summary>
        /// 请求
        /// </summary>
        public void SetRequestState(bool request)
        {
            Requested = request;
            if (request)
                RequestTime = DateTime.Now;
        }
        public override string ToString()
        {
            return $"【{JsonHelper.SerializeObject(this)}】";//{StringHelper.GetPropertiesStr<RequestInfo>(this)}
        }
    }
}