using System;
using System.Collections.Generic;
using System.Linq;
using System.Net;
using System.Net.Sockets;
using System.Text;
using System.Threading;
using System.Threading.Tasks;

namespace BLL
{
    /// <summary>
    /// 康奈德 IO
    /// </summary>
    public class KND_IO : IO_Interface
    {
        private bool loop;
        private ushort _flag;     //ModBus TCP 标识
        private byte[] _buff;     //TCP接收缓存
        private Socket client;    //客户端
        private Thread tListen;   //监听网络
        private Thread tReadDI;   //自动读取DI
        private Thread tTrigger;  //触发DI改变事件
        private Status[] staTrigger;

        
        /// <summary>
        /// 自动读取DI事件触发
        /// </summary>
        public event IOManage.DI_Changed DI_Changed_Event;

        /// <summary>
        /// 康奈德
        /// </summary>
        public KND_IO(string ip = "")
        {
            if (string.IsNullOrWhiteSpace(ip))
                IP = "192.168.1.100";
            else
                IP = ip;
            Mask = "255.255.255.0";
            Gateway = "192.168.1.1";
            Port = 502;
        }

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

        /// <summary>
        /// 子网掩码
        /// </summary>
        public string Mask { set; get; }

        /// <summary>
        /// 子网网关
        /// </summary>
        public string Gateway { set; get; }

        /// <summary>
        /// ModBus端口
        /// </summary>
        public int Port { set; get; }

        /// <summary>
        /// 是否连接
        /// </summary>
        public bool IsConn
        {
            get
            {
                lock (this)
                {
                    if (client != null)
                    {
                        //return client.Connected;
                        if (!client.Connected)
                        {
                            Connect();
                            Thread.Sleep(200);
                            Model.LogNet.log.Info("IO断开了,重新连接:" + client.Connected);
                            return client.Connected;
                        }
                        else
                        {
                            return true;
                        }
                    }
                    return false;
                }
            }
        }

        /// <summary>
        /// 错误信息
        /// </summary>
        public string ErrInfo { get; private set; }

        /// <summary>
        /// 连接
        /// </summary>
        /// <returns></returns>
        public bool Connect()
        {
            //TEST
            //IsConn = true;
            //return true;


            try
            {
                //IP合法
                string pattern = @"^((2[0-4]\d|25[0-5]|[01]?\d\d?)\.){3}(2[0-4]\d|25[0-5]|[01]?\d\d?)$";
                bool rtn = System.Text.RegularExpressions.Regex.IsMatch(IP, pattern);
                if (!rtn)
                {
                    Model.LogNet.log.Info("非法的IP地址");
                    return false;
                }

                //Ping服务端
                System.Net.NetworkInformation.Ping ping = new System.Net.NetworkInformation.Ping();
                System.Net.NetworkInformation.PingReply result = ping.Send(IP, 10000);
                if (result.Status != System.Net.NetworkInformation.IPStatus.Success)
                {
                    Model.LogNet.log.Info("Ping " + IP + " 请求没有回应");
                    return false;
                }

                //建立连接
                _flag = 0;
                client = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
                client.SetSocketOption(SocketOptionLevel.Socket, SocketOptionName.SendTimeout, 500);
                client.SetSocketOption(SocketOptionLevel.Socket, SocketOptionName.ReceiveTimeout, 500);
                client.SetSocketOption(SocketOptionLevel.Socket, SocketOptionName.NoDelay, 1);
                client.Connect(IPAddress.Parse(IP), Port);
                Thread.Sleep(100);  //需要等待一会才能获取连接状态

                loop = true;
                tListen = new Thread(new ThreadStart(Receive));
                tReadDI = new Thread(new ThreadStart(Auto_Read_DI));
                tTrigger = new Thread(new ThreadStart(Trigger_DI));
                tListen.Start();
                tReadDI.Start();
                tTrigger.Start();
                Model.LogNet.log.Info(IP + " 连接");

                ErrInfo = "OK";
                //IsConn = true;
                return true;
            }
            catch (Exception ex)
            {
                ErrInfo = ex.Message;
                return false;
            }
        }

        /// <summary>
        /// 关闭连接
        /// </summary>
        public void Close()
        {
            loop = false;
            if (client == null) return;

            try
            {
                client.Shutdown(SocketShutdown.Both);
                client.Close();
                client = null;
            }
            catch (Exception)
            {
            }
        }

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

        /// <summary>
        /// 写入单个DO
        /// </summary>
        /// <param name="add"></param>
        /// <param name="sta"></param>
        /// <returns></returns>
        public bool WriteDO(Addr add, Status sta)
        {
            if (!IsConn)
            {
                ErrInfo = "IO模块未连接。";
                return false;
            }

            //if (add <= Addr.DI_16)
            //{
            //    ErrInfo = "地址错误，应输入DO地址。";
            //    return false;
            //}
            _buff = null;
            Command(out byte[] data);
            byte[] buff = new byte[12];
            Array.Copy(data, 0, buff, 0, data.Length);
            buff[5] = 6;
            buff[7] = 5;  //功能码
            byte[] bb = BitConverter.GetBytes((short)add);
            buff[8] = bb[1];
            buff[9] = bb[0];  //地址
            buff[10] = (byte)sta;  //写入值

            try
            {
                client.Send(buff);
                int n = 0;
                lock (client)
                {
                    while (_buff == null)
                    {
                        Thread.Sleep(10);
                        if (n == 20)
                            return false;
                        else
                            n++;
                    }
                }
                Model.LogNet.log.Info(String.Format("WriteDO:" + add.ToString() + ":" + sta.ToString() + ",{0}", BitConverter.ToString(_buff)));
                return true;
            }
            catch (Exception ex)
            {
                ErrInfo = ex.Message;
                return false;
            }
        }

        /// <summary>
        /// 写入单个DO
        /// </summary>
        /// <param name="add"></param>
        /// <param name="sta"></param>
        /// <returns></returns>
        public bool WriteDO(int add, Status sta)
        {
            add += 100;
            Addr addr = (Addr)add;
            return WriteDO(addr, sta);
        }

        /// <summary>
        /// 先把状态取反，然后写入单个DO
        /// </summary>
        /// <param name="add"></param>
        /// <param name="sta"></param>
        /// <returns></returns>
        public bool WriteDO_Reverse(Addr add, ref Status sta)
        {
            Status ss = sta == Status.On ? Status.Off : Status.On;
            bool rtn = WriteDO(add, ss);
            if (rtn) sta = ss;
            return rtn;
        }

        /// <summary>
        /// 写入多个DO
        /// </summary>
        /// <param name="add"></param>
        /// <param name="sta"></param>
        /// <returns></returns>
        public bool WriteDO(Addr add, Status[] sta)
        {
            if (!IsConn)
            {
                ErrInfo = "IO模块未连接。";
                return false;
            }

            //if (add <= Addr.DI_16)
            //{
            //    ErrInfo = "地址错误，应输入DO地址。";
            //    return false;
            //}

            try
            {
                //int n = sta.Length > 8 ? 2 : 1;
                int n = Convert.ToInt32(Math.Ceiling(sta.Length / 8.0));
                Command(out byte[] data);
                byte[] buff = new byte[13 + n];
                Array.Copy(data, 0, buff, 0, data.Length);
                buff[7] = 15;  //功能码
                byte[] bb = BitConverter.GetBytes((short)add);
                buff[8] = bb[1];
                buff[9] = bb[0];  //地址
                buff[11] = (byte)sta.Length;  //个数
                buff[12] = (byte)n;

                int m = 0, move = 0;
                for (int i = 0; i < sta.Length; i++)
                {
                    if (i == 0) { m = 13; move = 0; }
                    else if (i == 8) { m = 14; move = 0; }
                    if (sta[i] == Status.On)
                        buff[m] |= Convert.ToByte(Math.Pow(2, move));
                    move++;
                }

                client.Send(buff);
                return true;
            }
            catch (Exception ex)
            {
                ErrInfo = ex.Message;
                return false;
            }
        }

        /// <summary>
        /// 读取单个DO
        /// </summary>
        /// <param name="add"></param>
        /// <param name="sta"></param>
        /// <returns></returns>
        public bool ReadDO(Addr add, out Status sta)
        {
            bool rtn = ReadDO(add, 1, out Status[] stat);
            sta = stat[0];
            return rtn;
        }

        /// <summary>
        /// 读取多个DO
        /// </summary>
        /// <param name="add">起始地址</param>
        /// <param name="count">数量</param>
        /// <param name="sta">状态</param>
        /// <returns></returns>
        public bool ReadDO(Addr add, uint count, out Status[] sta)
        {
            int n = 0;
            sta = null;
            if (!IsConn)
            {
                ErrInfo = "IO模块未连接。";
                return false;
            }
            if (count == 0)
            {
                ErrInfo = "数量为0";
                return false;
            }
            //if (add <= Addr.DI_16)
            //{
            //    ErrInfo = "地址错误，应输入DO地址。";
            //    return false;
            //}
            //if ((Addr)((uint)add + count - 1) > Addr.DO_16)
            //{
            //    ErrInfo = "数量超出总数";
            //    return false;
            //}

            try
            {
                _buff = null;
                Command(out byte[] data);
                byte[] buff = new byte[12];
                Array.Copy(data, 0, buff, 0, data.Length);
                buff[7] = 1;  //功能码
                byte[] bb = BitConverter.GetBytes((short)add);
                buff[8] = bb[1];
                buff[9] = bb[0];  //地址
                buff[11] = (byte)count;  //个数
                client.Send(buff);
                while (_buff == null)
                {
                    Thread.Sleep(10);
                    if (n == 200)
                        return false;
                    else
                        n++;
                }
                if (_buff[7] != 1) return false;
                sta = new Status[count];
                byte val = 0;
                int move = 0;
                byte ad = (byte)add;
                for (int i = 0; i < sta.Length; i++)
                {
                    if (i == 0) { val = _buff[9]; move = 0; }
                    else if (i == 8) { val = _buff[10]; move = 0; }
                    n = (val & Convert.ToInt32(Math.Pow(2, move))) >> move;
                    if (n == 1) sta[i] = Status.On;
                    move++; ad++;
                }
                return true;
            }
            catch (Exception ex)
            {
                ErrInfo = ex.Message;
                return false;
            }



        }

        /// <summary>
        /// 读取单个DI
        /// </summary>
        /// <param name="add"></param>
        /// <param name="sta"></param>
        /// <returns></returns>
        public bool ReadDI(Addr add, out Status sta)
        {
            bool rtn = ReadDI(add, 1, out Status[] stat);
            sta = stat[0];
            return rtn;
        }

        /// <summary>
        /// 读取多个DI
        /// </summary>
        /// <param name="add"></param>
        /// <param name="count"></param>
        /// <param name="sta"></param>
        /// <returns></returns>
        public bool ReadDI(Addr add, int count, out Status[] sta)
        {
            int n = 0;
            sta = null;
            if (!IsConn)
            {
                ErrInfo = "IO模块未连接。";
                return false;
            }
            if (count == 0)
            {
                ErrInfo = "数量为0";
                return false;
            }
            //if (add >= Addr.DO_1)
            //{
            //    ErrInfo = "地址错误，应输入DI地址。";
            //    return false;
            //}
            //if ((Addr)((uint)add + count - 1) > Addr.DI_16)
            //{
            //    ErrInfo = "数量超出总数";
            //    return false;
            //}
            try
            {
                _buff = null;
                Command(out byte[] data);
                byte[] buff = new byte[12];
                Array.Copy(data, 0, buff, 0, data.Length);
                buff[7] = 2;  //功能码
                byte[] bb = BitConverter.GetBytes((short)add);
                buff[8] = bb[1];
                buff[9] = bb[0];  //地址
                buff[11] = (byte)count;  //个数
                client.Send(buff);
                //Model.LogNet.log.Info(String.Format("ReadDI:" + add.ToString() + ":" + sta.ToString() + ",send:{0}", BitConverter.ToString(buff)));
                while (_buff == null)
                {
                    Thread.Sleep(10);
                    if (n == 2000)
                        return false;
                    else
                        n++;
                }
                // Model.LogNet.log.Info(String.Format("ReadDI:" + add.ToString() + ":" + sta.ToString() + ",recv:{0}", BitConverter.ToString(_buff)));
                if (_buff[7] != 2)
                    return false;
                sta = new Status[count];
                byte val = 0;
                int move = 0;
                byte ad = (byte)add;
                for (int i = 0; i < sta.Length; i++)
                {
                    if (i == 0) { val = _buff[9]; move = 0; }
                    else if (i == 8) { val = _buff[10]; move = 0; }
                    n = (val & Convert.ToInt32(Math.Pow(2, move))) >> move;
                    if (n == 1) sta[i] = Status.On;
                    move++; ad++;
                }
                return true;
            }
            catch (Exception ex)
            {
                ErrInfo = ex.ToString();
                return false;
            }



        }

        /// <summary>
        /// 命令，前7个字节
        /// </summary>
        /// <param name="data"></param>
        private void Command(out byte[] data)
        {
            byte[] add = BitConverter.GetBytes(++_flag);
            data = new byte[7];
            data[0] = add[1];
            data[1] = add[0];
            data[2] = 0;
            data[3] = 0;
            data[4] = 0;
            data[5] = 0;
            data[6] = 255;
            if (_flag == ushort.MaxValue) _flag = 0;
        }

        /// <summary>
        /// 监听结果线程，把读取到的数据保存到buff
        /// </summary>
        private void Receive()
        {
            byte[] bb = new byte[50];
            while (loop)
            {
                try
                {
                    //lock (client)
                    //{
                    if (client.Available > 0)
                    {
                        Thread.Sleep(10);
                        if (!client.Connected)
                            continue;
                        int len = client.Receive(bb);
                        _buff = new byte[len];
                        Array.Copy(bb, _buff, len);
                    }
                    //}
                    Thread.Sleep(50);
                }
                catch (Exception e)
                {
                    Model.LogNet.log.Info("Receive err:" + e.ToString());
                }
                finally
                {
                    //Thread.Sleep(50);
                }
            }

        }

        /// <summary>
        /// 自动读取DI线程
        /// </summary>
        private void Auto_Read_DI()
        {
            while (loop)
            {
                ReadDI(Addr.DI_1, 4, out staTrigger);
                //Model.LogNet.log.Info("ErrInfo:" + ErrInfo);

                Thread.Sleep(100);
            }
        }

        /// <summary>
        /// 触发DI改变事件
        /// </summary>
        private void Trigger_DI()
        {
            while (loop)
            {
                if (staTrigger != null)
                    DI_Changed_Event?.Invoke(staTrigger);
                Thread.Sleep(100);
            }
        }
    }

    /// <summary>
    /// 寄存器
    /// </summary>
    public class Reg
    {
        /// <summary>
        /// 标识
        /// </summary>
        public int ID;
        /// <summary>
        /// 显示文本
        /// </summary>
        public string Text;
        /// <summary>
        /// 寄存器地址
        /// </summary>
        public Addr Addr;
        /// <summary>
        /// 当前的状态
        /// </summary>
        public Status Status;

        /// <summary>
        /// 寄存器，文本空，状态OFF
        /// </summary>
        /// <param name="address">地址</param>
        public Reg(Addr address) : this(0, "", address, Status.Off)
        {
        }

        /// <summary>
        /// 寄存器，状态OFF
        /// </summary>
        /// <param name="text">文本</param>
        /// <param name="addr">地址</param>
        public Reg(string text, Addr addr) : this(0, text, addr, Status.Off)
        {
        }

        /// <summary>
        /// 寄存器，状态OFF
        /// </summary>
        /// <param name="id">标志</param>
        /// <param name="text">文本</param>
        /// <param name="addr">地址</param>
        public Reg(int id, string text, Addr addr) : this(id, text, addr, Status.Off)
        {
        }

        /// <summary>
        /// 寄存器
        /// </summary>
        /// <param name="text">文本</param>
        /// <param name="addr">地址</param>
        /// <param name="status">状态</param>
        public Reg(string text, Addr addr, Status status) : this(0, text, addr, status)
        {
        }

        /// <summary>
        /// 寄存器
        /// </summary>
        /// <param name="id">标志</param>
        /// <param name="text">文本</param>
        /// <param name="address">地址</param>
        /// <param name="status">状态</param>
        public Reg(int id, string text, Addr address, Status status)
        {
            ID = id;
            Text = text;
            Addr = address;
            Status = status;
        }
    }

    /// <summary>
    /// 寄存器地址
    /// </summary>
    public enum Addr : short
    {
        /// <summary>
        /// 输入点，DI-1
        /// </summary>
        DI_1 = 10200,
        /// <summary>
        /// 输入点，DI-2
        /// </summary>
        DI_2 = 10201,
        /// <summary>
        /// 输入点，DI-3
        /// </summary>
        DI_3 = 10202,
        /// <summary>
        /// 输入点，DI-4
        /// </summary>
        DI_4 = 10203,
        /// <summary>
        /// 输出点，DO-1
        /// </summary>
        DO_1 = 100,
        /// <summary>
        /// 输出点，DO-2
        /// </summary>
        DO_2 = 101,
        /// <summary>
        /// 输出点，DO-3
        /// </summary>
        DO_3 = 102,
        /// <summary>
        /// 输出点，DO-4
        /// </summary>
        DO_4 = 103,
        /// <summary>
        /// 无
        /// </summary>
        NONE = 255
    }

    /// <summary>
    /// 寄存器状态
    /// </summary>
    public enum Status : byte
    {
        /// <summary>
        /// 断开，关闭，低电平
        /// </summary>
        Off = 0,
        /// <summary>
        /// 闭合，打开，高电平
        /// </summary>
        On = 255
    }
}