using DL.Utils;
using System;
using System.Collections.Generic;
using System.Net;
using System.Net.Sockets;
using System.Threading;

namespace DL.IOModule
{
    /// <summary>
    /// 零点IO模块操作类
    /// </summary>
    public class AIOBOX
    {
        /// <summary>
        /// 自动读取DIO委托
        /// </summary>
        /// <param name="box">AIOBOX</param>
        /// <param name="sta"></param>
        public delegate void DIO_Changed(AIOBOX box, Box_Sta[] sta);
        /// <summary>
        /// 自动读取AIO委托
        /// </summary>
        /// <param name="box">AIOBOX</param>
        /// <param name="val"></param>
        public delegate void AIO_Changed(AIOBOX box, int[] val);
        /// <summary>
        /// 自动读取DI事件触发
        /// </summary>
        public event DIO_Changed DI_Changed_Event;
        /// <summary>
        /// 自动读取DO事件触发
        /// </summary>
        public event DIO_Changed DO_Changed_Event;
        /// <summary>
        /// 自动读取AI事件触发
        /// </summary>
        public event AIO_Changed AI_Changed_Event;
        /// <summary>
        /// 设备地址
        /// </summary>
        private byte equipAddr = 255;
        private Com.TCP.ModbusTCPMaster _client;   //客户端
        private bool _loop;
        private Box_Sta[] _stateDI;    //DI状态
        private Box_Sta[] _stateDO;    //DO状态
        private int[] _valueAI;        //AI模拟量
        private int[] _valueAO;        //AO模拟量
        private List<byte> _receive;

        private IOType _typeInput;       //输入类型
        private IOType _typeOutput;      //输出类型
        private byte[] _addressInput;      //输入地址
        private byte[] _addressOutput;     //输出地址
        private const int SEND_SLEEP = 50;   //每条命令发送的间隔
        private const int PORT = 502;        //端口
        private const int UPLOAD_TIME = 3000;  //5秒

        private Thread tSend;         //发送命令处理

        /// <summary>
        /// 零点IO模块操作类
        /// 数字信号输入，离散输入,支持功能码为02，
        /// 模拟量输入，输入寄存器,支持功能码为04，
        /// 数字信号输出，线圈，支持功能码为01，05，15
        /// </summary>
        /// <param name="logName"></param>
        public AIOBOX()
        {
            _client = new Com.TCP.ModbusTCPMaster();
            _client.ReceiveData += _client_ReceiveData;
        }
        /// <summary>
        /// 收到的数据解析
        /// </summary>
        /// <param name="ip"></param>
        /// <param name="port"></param>
        /// <param name="requestInfo"></param>
        /// <param name="data"></param>
        private void _client_ReceiveData(string ip, int port, Com.TCP.RequestInfo requestInfo, byte[] data)
        {
            int idx = 0;
            int count=data.Length;
            try
            {
                if(requestInfo.FunCode==1)//ReadDO 
                {
                    Box_Sta[] staDO = new Box_Sta[_stateDO.Length];
                    for (int i = 0; i < count; i++)
                    {
                        int move = 0;
                        byte val = data[i];
                        for (int j = 0; j < 8; j++)  //字节的0-7位
                        {
                            int n = (val & Convert.ToInt32(Math.Pow(2, move))) >> move;
                            staDO[idx++] = n == 1 ? Box_Sta.On : Box_Sta.Off;
                            move++;
                        }
                    }
                    Array.Copy(staDO, 0, _stateDO, 0, staDO.Length);
                    DO_Changed_Event?.Invoke(this, staDO);

                }
                else if (requestInfo.FunCode == 2) //ReadDI
                {
                    Box_Sta[] staDI = new Box_Sta[_stateDI.Length];
                    for (int i = 0; i < count; i++)
                    {
                        int move = 0;
                        byte val = data[i];
                        for (int j = 0; j < 8; j++)  //字节的0-7位
                        {
                            int n = (val & Convert.ToInt32(Math.Pow(2, move))) >> move;
                            staDI[idx++] = n == 1 ? Box_Sta.On : Box_Sta.Off;
                            move++;
                        }
                    }
                    Array.Copy(staDI, 0, _stateDI, 0, staDI.Length);
                    DI_Changed_Event?.Invoke(this, staDI);

                }
            }
            catch (Exception ex)
            {
                LogUtil.Error("ReceiveData", ex);
            }
        }

        /// <summary>
        /// IP地址
        /// </summary>
        public string IP { set; get; } = "192.168.1.100";

        /// <summary>
        /// 输入主动上传
        /// </summary>
        public bool Upload { set; get; } = false;

        /// <summary>
        /// DI总数
        /// </summary>
        public int InputCount
        {
            get
            {
                if (_addressInput == null)
                    return 0;
                else
                    return _addressInput.Length;
            }
        }

        /// <summary>
        /// DO总数
        /// </summary>
        public int OutputCount
        {
            get
            {
                if (_addressOutput == null)
                    return 0;
                else
                    return _addressOutput.Length;
            }
        }




        /// <summary>
        /// 设置输入输出的类型
        /// </summary>
        /// <param name="input"></param>
        /// <param name="inputCount"></param>
        /// <param name="output"></param>
        /// <param name="outputCount"></param>
        public void SetType(IOType input, int inputCount, IOType output, int outputCount)
        {
            _typeInput = input;
            _typeOutput = output;

            byte n = 0;
            _addressInput = new byte[inputCount];
            for (int i = 0; i < inputCount; i++)
                _addressInput[i] = n++;
            _addressOutput = new byte[outputCount];
            for (int i = 0; i < outputCount; i++)
                _addressOutput[i] = n++;

            _stateDI = new Box_Sta[inputCount];
            _stateDO = new Box_Sta[outputCount];
            _valueAI = new int[inputCount];
            _valueAO = new int[outputCount];
        }

        /// <summary>
        /// 连接
        /// </summary>
        /// <returns></returns>
        public bool Connect()
        {
            _loop = true;
            bool rtn = Utils.HttpHelper.CheckIP(IP);
            if (!rtn) return false;

            _client.Connect(IP, PORT);
            tSend = new Thread(new ThreadStart(Send)) { Name = "Send" };
            tSend.IsBackground = true;
            tSend.Start();
            _client.AddRequest(GetReadDO_Command());
            _client.AddRequest(GetReadInput_Command());
            return true;
        }

        /// <summary>
        /// 关闭连接
        /// </summary>
        public void Close()
        {
            _loop = false;

            try
            {
                if (_client != null)
                {
                    _client.Close();
                }
            }
            finally
            {
                _client = null;
            }

        }








        /// <summary>
        /// 相反状态(ON/OFF)
        /// </summary>
        /// <param name="sta"></param>
        /// <returns></returns>
        public Box_Sta ReverseStatus(Box_Sta sta)
        {
            return sta == Box_Sta.On ? Box_Sta.Off : Box_Sta.On;
        }

        /// <summary>
        /// 相反状态(ON/OFF)
        /// </summary>
        /// <param name="sta"></param>
        public void ReverseStatus(ref Box_Sta sta)
        {
            if (sta == Box_Sta.On)
                sta = Box_Sta.Off;
            else
                sta = Box_Sta.On;
        }

        /// <summary>
        /// 读取单个DI输入状态(ON/OFF)
        /// </summary>
        /// <param name="add">输入地址，从0开始</param>
        /// <returns></returns>
        public Box_Sta ReadDI(int add)
        {
            return _stateDI[add];
        }

        /// <summary>
        /// 读取多个DI输入状态(ON/OFF)
        /// </summary>
        /// <param name="add">起始地址，从0开始</param>
        /// <param name="count">数量</param>
        /// <returns></returns>
        public Box_Sta[] ReadDI(int add, int count)
        {
            Box_Sta[] sta = new Box_Sta[count];
            Array.Copy(_stateDI, add, sta, 0, count);
            return sta;
        }

        /// <summary>
        /// 读取单个AI模拟量的值
        /// </summary>
        /// <param name="add">模拟量地址，从0开始</param>
        /// <returns></returns>
        public int ReadAI(int add)
        {
            return _valueAI[add];
        }

        /// <summary>
        /// 读取多个AI模拟量的值
        /// </summary>
        /// <param name="add">起始地址，从0开始</param>
        /// <param name="count">数量</param>
        /// <returns></returns>
        public int[] ReadAI(int add, int count)
        {
            int[] sta = new int[count];
            Array.Copy(_valueAI, add, sta, 0, count);
            return sta;
        }

        /// <summary>
        /// 读取单个DO输出状态(ON/OFF)
        /// </summary>
        /// <param name="add">输出地址，从0开始</param>
        /// <returns></returns>
        public Box_Sta ReadDO(int add)
        {
            return _stateDO[add];
        }

        /// <summary>
        /// 读取多个DO输出状态(ON/OFF)
        /// </summary>
        /// <param name="add">起始地址，从0开始</param>
        /// <param name="count">数量</param>
        /// <returns></returns>
        public Box_Sta[] ReadDO(int add, int count)
        {
            Box_Sta[] sta = new Box_Sta[count];
            Array.Copy(_stateDO, add, sta, 0, count);
            return sta;
        }

        /// <summary>
        /// 读取单个AO模拟量的值
        /// </summary>
        /// <param name="add">输出地址，从0开始</param>
        /// <returns></returns>
        public int ReadAO(int add)
        {
            return _valueAO[add];
        }

        /// <summary>
        /// 读取多个AO模拟量的值
        /// </summary>
        /// <param name="add">起始地址，从0开始</param>
        /// <param name="count">数量</param>
        /// <returns></returns>
        public int[] ReadAO(int add, int count)
        {
            int[] sta = new int[count];
            Array.Copy(_valueAO, add, sta, 0, count);
            return sta;
        }

        /// <summary>
        /// 写入单个DO输出状态(ON/OFF)。
        /// 写单个线圈，功能码05
        /// </summary>
        /// <param name="add">输出地址，从0开始</param>
        /// <param name="sta"></param>
        /// <returns></returns>
        public bool WriteDO(int add, Box_Sta sta)
        {
            try
            {
                Com.TCP.RequestInfo request = new Com.TCP.RequestInfo();
                request.StartAddr = _addressOutput[add];//起始地址
                request.FunCode = 5;//功能码
                request.EquipAddr = equipAddr;
                request.CountOrValue = sta.Equals(Box_Sta.On) ? 1 : 0;   //值
                _client.AddRequest(request);
                _client.AddRequest(GetReadDO_Command());
                return true;
            }
            catch (Exception ex)
            {
                LogUtil.Error("WriteDO", ex);
                return false;
            }
        }
        /// <summary>
        /// 写入多个DO输出状态(ON/OFF)
        /// 写多个线圈，功能码15
        /// </summary>
        /// <param name="add">起始地址</param>
        /// <param name="sta">对应的状态</param>
        /// <returns></returns>
        public bool WriteDO(int add, Box_Sta[] sta)
        {
            try
            {
                Com.TCP.RequestInfo request = new Com.TCP.RequestInfo();
                request.StartAddr = _addressOutput[add];//起始地址
                request.FunCode = 15;//功能码
                request.EquipAddr = equipAddr;
                request.CountOrValue = sta.Length;   //个数
                request.Values = Com.Protocol.Modbus.Register.GetValuesWithMultiMode(GetValues(sta));
                _client.AddRequest(request);
                _client.AddRequest(GetReadDO_Command());
                return true;
            }
            catch (Exception ex)
            {
                LogUtil.Error("WriteDO", ex);
                return false;
            }
        }

        int[] GetValues(Box_Sta[] sta)
        {
            int[] tmp = new int[sta.Length];
            for (int i = 0; i < sta.Length; i++)
            {
                tmp[i] = sta[i].Equals(Box_Sta.On) ? 1 : 0;
            }
            return tmp;
        }




        /// <summary>
        /// 发送命令线程
        /// </summary>
        private void Send()
        {
            bool shift = true;       //切换
            int time = UPLOAD_TIME;  //上传时间

            while (_loop)
            {
                Com.TCP.RequestInfo request = null;

                if (Upload)  //主动上传
                {
                    time += SEND_SLEEP;
                    if (time >= UPLOAD_TIME)
                    {
                        request = GetReadInput_Command();
                        time = 0;
                    }
                    else
                    {
                        //2020年6月11日
                        //buff = GetReadDO_Command();

                        Thread.Sleep(SEND_SLEEP);
                        continue;
                    }
                }
                else
                {
                    if (shift)
                        request = GetReadInput_Command();
                    else
                        request = GetReadDO_Command();
                    shift = !shift;
                }
                _client.AddRequest(request);
                Thread.Sleep(SEND_SLEEP);
            }
        }

        /// <summary>
        /// 读取输入
        /// 数字信号输入，功能码为02，读离散输入
        /// 模拟量输入，功能码为04，读输入寄存器
        /// </summary>
        /// <returns></returns>
        private Com.TCP.RequestInfo GetReadInput_Command()
        {
            Com.TCP.RequestInfo request = new Com.TCP.RequestInfo();
            request.StartAddr = _addressInput[0];//起始地址
            //功能码
            if (_typeInput == IOType.DI)
                request.FunCode = 2;
            else if (_typeInput == IOType.AI)
                request.FunCode = 4;
            request.EquipAddr = equipAddr;
            request.CountOrValue = _addressInput.Length;   //个数
            return request;
        }

        /// <summary>
        /// 读取DO，功能码01，读单个线圈
        /// </summary>
        /// <returns></returns>
        private Com.TCP.RequestInfo GetReadDO_Command()
        {
            return new Com.TCP.RequestInfo()
            {
                StartAddr = _addressOutput[0],//起始地址
                FunCode = 1,//功能码
                EquipAddr = equipAddr,
                CountOrValue = _addressOutput.Length  //个数
            };
        }

    }



}