using Aitex.Core.RT.Event;
using Aitex.Core.RT.Log;
using Aitex.Core.RT.SCCore;
using Aitex.Core.Util;
using System;
using System.Collections.Concurrent;
using System.Collections.Generic;
using System.IO.Ports;
using System.Linq;
using System.Text;
using System.Threading;
using System.Threading.Tasks;

namespace MECF.Framework.Common.Device.ResistivityProbe
{
    public class ThorntonSerialDevice
    {
        #region Delegate
        public delegate void ThorntonDataChanged(string name,List<string> lstContent);
        #endregion
        #region 常量
        private const string CONSTANT_COMMAND = "D00Z\r";
        private const char SPLIT_CHARACTER = '\t';
        #endregion
        #region 内部变量
        /// <summary>
        /// 连接状态
        /// </summary>
        private bool _connected;
        /// <summary>
        /// 串口
        /// </summary>
        private SerialPort _serialPort;
        /// <summary>
        /// 模块名称
        /// </summary>
        private string _name;
        /// <summary>
        /// 定时器
        /// </summary>
        private PeriodicJob _periodJob;
        /// <summary>
        /// 接收超时
        /// </summary>
        private int _receiveTimeout = 2000;
        /// <summary>
        /// 错误信息
        /// </summary>
        private string _errmsg = "";
        /// <summary>
        /// 重连
        /// </summary>
        private bool _reconnected;
        /// <summary>
        /// 离线时间
        /// </summary>
        private DateTime _offlineDateTime;
        /// <summary>
        /// 锁
        /// </summary>
        private object _locker = new object();
        #endregion

        #region 公共变量
        public event ThorntonDataChanged OnDataChanged;
        #endregion

        #region 属性
        /// <summary>
        /// 连接状态
        /// </summary>
        public bool Connected
        {
            get { return _connected; }
            set { _connected = value; }
        }
        #endregion
        /// <summary>
        /// 构造函数
        /// </summary>
        /// <param name="name"></param>
        /// <param name="portName"></param>
        /// <param name="baudRate"></param>
        /// <param name="stopBits"></param>
        /// <param name="dataBits"></param>
        /// <param name="parity"></param>
        public ThorntonSerialDevice(string name, string portName, int baudRate = 9600, StopBits stopBits = StopBits.One, int dataBits = 8, Parity parity = Parity.None, bool reconnected = false,int receiveTimeout=2000)
        {
            _serialPort = new SerialPort();
            _serialPort.BaudRate = baudRate;
            _serialPort.StopBits = stopBits;
            _serialPort.DataBits = dataBits;
            _serialPort.Parity = parity;
            _serialPort.PortName = portName;
            _serialPort.ErrorReceived += SerialPort_ErrorReceived;
            _serialPort.WriteTimeout = receiveTimeout;
            _serialPort.ReadTimeout = receiveTimeout;
            _receiveTimeout = receiveTimeout;
            _name = name;
            _reconnected = reconnected;
            _periodJob = new PeriodicJob(500, OnTimer, $"{_name}_reader", true, true);
        }
        /// <summary>
        /// 启动
        /// </summary>
        public void Start()
        {
            //Open();
        }
        /// <summary>
        /// 打开串口
        /// </summary>
        private void Open()
        {
            lock (_locker)
            {
                if (!_connected)
                {
                    try
                    {
                        if (!_serialPort.IsOpen)
                        {
                            _serialPort.Open();
                        }
                        _connected = true;

                        LOG.WriteLog(eEvent.INFO_RESISTIVITY, _name, $"connect port[{_serialPort.PortName}] success");
                    }
                    catch (Exception ex)
                    {
                        WriteErrorMsg(ex.Message);
                    }
                }
            }
        }
        /// <summary>
        /// 关闭
        /// </summary>
        public void Close()
        {
            try
            {
                _connected = false;
                _serialPort.Close();
                _periodJob.Stop();
            }
            catch (Exception ex)
            {
                WriteErrorMsg(ex.Message);
            }
        }
        #region 事件
        /// <summary>
        /// 串口错误
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void SerialPort_ErrorReceived(object sender, SerialErrorReceivedEventArgs e)
        {
            LOG.WriteLog(eEvent.ERR_RESISTIVITY, _name, e.EventType.ToString());
        }
        #endregion

        /// <summary>
        /// 定时器
        /// </summary>
        /// <returns></returns>
        private bool OnTimer()
        {
            if (!_connected)
            {
                if (_reconnected)
                {
                    Open();
                }
                else
                {
                    _periodJob.Stop();
                }
            }
            else
            {
                ReadData();
            }
            return true;
        }
        /// <summary>
        /// 读取数据
        /// </summary>
        public void ReadData()
        {
            try
            {
                _serialPort.WriteLine(CONSTANT_COMMAND);
                DateTime dt = DateTime.Now;
                string str = "";
                while(DateTime.Now.Subtract(dt).TotalMilliseconds<=_receiveTimeout)
                {
                    if (_serialPort.BytesToRead > 0)
                    {
                        string tmp = _serialPort.ReadLine();
                        if(!string.IsNullOrEmpty(tmp))
                        {
                            WriteInfoMsg(0,tmp);
                        }
                        if (tmp != CONSTANT_COMMAND)
                        {
                            str = tmp;
                            break;
                        }
                    }
                    else
                    {
                        Thread.Sleep(100);
                    }
                }
                if (!string.IsNullOrEmpty(str))
                {
                    string[] strAry = str.Split(SPLIT_CHARACTER);
                    if(strAry.Length>=4)
                    {
                        List<string> lst = new List<string>();
                        int length=strAry.Length%2==0?strAry.Length:strAry.Length-1;
                        for(int i=2;i<length; i+=2)
                        {
                            lst.Add(strAry[i]);
                        }
                        if(OnDataChanged!=null)
                        {
                            OnDataChanged(_name,lst);
                        }
                    }
                }
                _errmsg = "";
            } 
            catch(Exception ex)
            {
                WriteErrorMsg(ex.Message);
            }
        }

        /// <summary>
        /// 记录错误信息
        /// </summary>
        /// <param name="msg"></param>
        private void WriteErrorMsg(string msg, bool disConnected = true)
        {
            if (disConnected)
            {
                _connected = false;
                _offlineDateTime = DateTime.Now;
            }
            if (_errmsg != msg)
            {
                _errmsg = msg;
                LOG.WriteLog(eEvent.ERR_RESISTIVITY, _name, msg);
            }
        }
        /// <summary>
        /// 写日志
        /// </summary>
        /// <param name="bytes"></param>
        private void WriteInfoMsg(int logType, string str)
        {
            bool enableLog = false;
            if (SC.ContainsItem("Log.EnableResistivityLog"))
            {
                enableLog = SC.GetValue<bool>("Log.EnableResistivityLog");
            }
            if (enableLog)
            {
                string type = logType == 0 ? "receive" : "send";
                LOG.WriteBackgroundLog(eEvent.INFO_RESISTIVITY, _name, $"{type} {str}");
            }
        }
    }
}