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

public class PuYueRFID_C2S
{
    byte station = 1;
    bool Automode;
    public string IP;
    TcpClient tcpClient = new TcpClient();
    Thread iomonitorThread;
    ushort seq = 0;

    public event EventHandler<string> ID_Changed_Event;
    /// <summary>
    /// 连接状态变化, 手动连接不触发
    /// </summary>
    public event EventHandler<bool> ConnectionState_Event;
    public PuYueRFID_C2S(string ip, bool automode = false)
    {
        this.IP = ip;
        Automode = automode;
        //DOdata[0] = 0x00;
        //DOdata[1] = 0x00;
        //if (autoread)
        //    iomonitorThread = new Thread(new ThreadStart(iomonitor));
    }
    /// <summary>
    /// 销毁
    /// </summary>
    ~PuYueRFID_C2S()
    {
        iomonitorrun = false;
        Close();
    }
    bool systemrun = false;
    /// <summary>
    /// 打开IO
    /// </summary>
    /// <returns></returns>
    public bool Open()
    {

        tcpClient.Dispose();
        tcpClient = new TcpClient();
        tcpClient.ReceiveTimeout = 1000;
        tcpClient.SendTimeout = 100;
        lock (tcpClient)
        {
            try
            {
                var connectResult = tcpClient.ConnectAsync(IP, 502);
                if (connectResult.Wait(1000))
                {
                    Init();
                    systemrun = true;
                    if (Automode)
                    {
                        iomonitorrun = true;
                        iomonitorThread = new Thread(new ThreadStart(iomonitor));
                        iomonitorThread.Start();
                    }
                    ConnectionState_Event?.Invoke(this, true);
                    return true;
                }
                else
                {

                    tcpClient.EndConnect(connectResult);
                    tcpClient.Close();
                    return false;
                }
            }
            catch
            {
                return false;
            }
        }

    }

    void Init()
    {

        //设备地址1,波特率,禁止AFI,盘点超时时间(100*5ms),命令触发,操作模式,寄存器地址,寄存器数量,触发时间(10*5ms),输出格式,数据帧枕头,记录保持时间(9*5ms)
        short[] address = new short[] { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11 };
        short[] value = new short[] { 1, 2, 0, 100, 1, 1, 0x20, 4, 20, 1, 0x1234, 19 };

        for (int i = 0; i < address.Length; i++)
        {
            WriteDO(address[i], value[i]);
        }
    }
    /// <summary>
    /// 设置天线功率dBm
    /// </summary>
    public short AntennaPower
    {
        set
        {
            if (this.IsConn)
                WriteDO(0x0100, value);
        }
    }
    /// <summary>
    /// 关闭IO
    /// </summary>
    public void Close()
    {
        try
        {
            systemrun = false;
            iomonitorrun = false;
            if (tcpClient.Connected)
                tcpClient.Close();
        }
        catch { }
    }
    /// <summary>
    /// 连接状态
    /// </summary>
    public bool IsConn
    {
        get => iomonitorrun && systemrun && tcpClient.Connected;
    }

    bool iomonitorrun = false;
    /// <summary>
    /// 循环读全部IO
    /// </summary>
    void iomonitor()
    {
        iomonitorrun = true;
        while (iomonitorrun && systemrun)
        {
            try
            {
                if (ID_Changed_Event != null)
                    ReadDO();
                else
                    Thread.Sleep(1000);
            }
            catch (SocketException)
            {
                if (tcpClient != null)//&& tcpClient.Connected
                    tcpClient.Close();
                ConnectionState_Event?.Invoke(this, false);
                iomonitorrun = false;
            }
            catch(Exception ex)
            {

            }
        }
        if (systemrun)
        {
            do
            {
                Thread.Sleep(1000);
            } while (systemrun && !Open());
        }
    }

    /// <summary>
    /// 写寄存器
    /// </summary>
    /// <param name="address"></param>
    /// <param name="value"></param>
    /// <returns></returns>
    public bool WriteDO(short address, short value)
    {
        byte funCode = 0x10;
        byte[] startAddress = BitConverter.GetBytes(address);  //寄存器起始地址;
        byte[] data = BitConverter.GetBytes(value);  //寄存器起始地址;
        byte startLength = 1;
        var seqhead = BitConverter.GetBytes(seq);
        byte[] by = new byte[]
        {
                //事物标识符
                seqhead[0],
                seqhead[1],
                //协议标识符 固定值
                0x00,
                0x00,
                //长度
                0x00,
                0x06,
                //从站地址
                station,
                //功能码
                funCode,
                startAddress[1],//起始地址高位
                startAddress[0], //起始地址低位
                0x00,
                startLength, //读个数
                0x02,
                data[1],
                data[0]
        };
        by[5] = (byte)(by.Length - 6);
        bool check = true;
        lock (tcpClient)
        {
            try
            {
                seqadd();
                tcpClient.Client.Send(by);
                byte[] result = new byte[100];
                var ulength = tcpClient.Client.Receive(result);
                var newResult = result.ToList().Take(ulength).ToArray();
                if (newResult[0] == seqhead[0] && newResult[1] == seqhead[1])
                {
                    check = true;
                }
                else
                {
                    return false;
                }
            }
            catch
            {
                return false;
            }
        }


        /*
        var newResult = result.ToList().Take(ulength).ToArray();
        //输出报文
        var output = string.Join(" ", newResult.Select(x => x.ToString("X2")));

        */
        return check;
    }

    string currentID = "";
    bool hasID = false;
    DateTime currentIDdate = DateTime.MinValue;
    string lastID = "";
    public short StartAddr = 0x0255;
    public short Length = 2;
    /// <summary>
    /// 读全部数据
    /// </summary>
    void ReadDO()
    {
        byte funCode = 0x03;
        byte[] startAddress = BitConverter.GetBytes(StartAddr);
        byte[] startLength = BitConverter.GetBytes((short)Math.Ceiling(Length / 2d));//2;
        var seqhead = BitConverter.GetBytes(seq);
        byte[] by = new byte[]
        {
                //事物标识符
                seqhead[0],
                seqhead[1],
                //协议标识符 固定值
                0x00,
                0x00,
                //长度
                0x00,
                0x06,
                //从站地址
                station,
                //功能码
                funCode,
                startAddress[1],
                startAddress[0], //起始地址
                startLength[1],
                startLength[0], //读个数
        };
        by[5] = (byte)(by.Length - 6);
        byte[] result = new byte[100];
        int ulength = 0;

        lock (tcpClient)
        {
            try
            {
                seqadd();
                tcpClient.Client.Send(by);
                Thread.Sleep(5);
                ulength = tcpClient?.Client?.Receive(result)??0;

            }
            catch (SocketException se)
            {
                throw se;
            }
            finally
            {
                Thread.Sleep(20);
            }
        }
        var newResult = result;//.ToList().Take(ulength).ToArray();
                               //aa = BitConverter.ToString(newResult);
                               //Console.WriteLine(aa);
        if (newResult[0] == seqhead[0] && newResult[1] == seqhead[1])
        {
            if (newResult[7] == 0x03)
            {
                hasID = true;
                currentID = (char)newResult[10] + newResult[11].ToString();
                currentIDdate = DateTime.Now;
                if (currentID != lastID)
                {
                    ID_Changed_Event?.Invoke(this, currentID);
                    lastID = currentID;
                }
            }
            else if (newResult[7] == 0x83)
            {
                hasID = false;
            }
        }
        else
        {
            Thread.Sleep(20);
            if (tcpClient?.Client?.Available > 0)
                _ = tcpClient.Client.Receive(result);

        }
        //输出报文
        //var output = string.Join(" ", newResult.Select(x => x.ToString("X2")));

    }
    /// <summary>
    /// 读取rfid 
    /// </summary>
    /// <param name="id">读取到的id</param>
    /// <param name="ms">最后读到的时间ms</param>
    /// <returns>读取成功状态-1读取失败,0没有读到,1读取成功</returns>
    public int TryRead(out string id, out double ms)
    {
        id = "";
        ms = 0;
        try
        {
            ReadDO();
            id = lastID;
            ms = (DateTime.Now - currentIDdate).TotalMilliseconds;
            if (hasID)
                return 1;
            else
                return 0;
        }
        catch
        {
            Open();
            return -1;
        }
    }

    object locRead = new object();
    public bool ReadByte(short address, short length, out byte[] data)
    {
        data = null;
        if (Monitor.TryEnter(locRead))
        {
            try
            {
                if (length > 64)
                    throw new Exception("最大读取64个字节");
                data = null;
                byte funCode = 0x03;
                byte[] startAddress = BitConverter.GetBytes(address);//0x0255
                byte[] startLength = BitConverter.GetBytes((short)Math.Ceiling(length / 2d));//2
                var seqhead = BitConverter.GetBytes(seq);
                byte[] by = new byte[]
                {
                //事物标识符
                seqhead[0],
                seqhead[1],
                //协议标识符 固定值
                0x00,
                0x00,
                //长度
                0x00,
                0x06,
                //从站地址
                station,
                //功能码
                funCode,
                startAddress[1],
                startAddress[0], //起始地址
                startLength[1],
                startLength[0], //读个数
                };
                by[5] = (byte)(by.Length - 6);
                byte[] result = new byte[1000];
                int ulength = 0;

                lock (tcpClient)
                {
                    try
                    {
                        if (tcpClient?.Client?.Available > 0)
                            tcpClient?.Client?.Receive(result);

                        seqadd();
                        tcpClient.Client.Send(by);
                        Thread.Sleep(5);
                        ulength = tcpClient?.Client?.Receive(result) ?? 0;

                    }
                    catch (SocketException se)
                    {
                        return false;
                    }
                }
                var newResult = result.ToList().Take(ulength).ToList();
                //aa = BitConverter.ToString(newResult);
                //Console.WriteLine(aa);
                if (newResult.Count > 6 && newResult[0] == seqhead[0] && newResult[1] == seqhead[1])
                {
                    if (newResult[7] == 0x03)
                    {

                        var recvlen = BitConverter.ToInt16(new byte[] { newResult[5], newResult[4] }, 0);
                        if ((recvlen + 6) <= newResult.Count)
                        {
                            data = newResult.GetRange(9, recvlen - 3).ToArray();
                            Console.WriteLine(BitConverter.ToString(newResult.ToArray()));
                            return true;
                        }
                    }
                    else if (newResult[7] == 0x83)
                    {
                        return false;
                    }
                }
                else
                {
                    Thread.Sleep(20);
                    if (tcpClient.Client.Available > 0)
                        _ = tcpClient.Client.Receive(result);
                }
            }finally
            {
                Monitor.Exit(locRead);
            }
            
        }
       
        return false;
    }
    /// <summary>
    ///  写入字节最大 64字
    /// </summary>
    /// <param name="address"></param>
    /// <param name="data"></param>
    /// <returns></returns>
    public bool WriteByte(short address, byte[] data)
    {
        if (data.Length > 64)
            throw new Exception("最大写入64个字节");

        byte funCode = 0x10;
        byte[] startAddress = BitConverter.GetBytes(address);  //寄存器起始地址;
        short registerlength = (short)Math.Ceiling(data.Length / 2d);
        byte[] registerAddress = BitConverter.GetBytes(registerlength);
        var seqhead = BitConverter.GetBytes(seq);
        byte[] by = new byte[]
        {
                //事物标识符
                seqhead[0],
                seqhead[1],
                //协议标识符 固定值
                0x00,
                0x00,
                //长度
                0x00,
                0x06,
                //从站地址
                station,
                //功能码
                funCode,
                startAddress[1],//起始地址高位
                startAddress[0], //起始地址低位
                registerAddress[1],
                registerAddress[0], //寄存器数量
                (byte)(registerlength * 2)
        };
        var ab = by.ToList();
        ab.AddRange(data);
        if (registerlength * 2 > data.Length)
        {
            ab.Add(0x0);
        }
        short datalength = (short)(ab.Count() - 6);
        var dl = BitConverter.GetBytes(datalength);
        ab[4] = dl[1];
        ab[5] = dl[0];


        by = ab.ToArray();


        lock (tcpClient)
        {
            try
            {
                byte[] result = new byte[100];
                if (tcpClient.Client.Available > 0)
                    tcpClient.Client.Receive(result);

                seqadd();
                tcpClient.Client.Send(by);

                var ulength = tcpClient.Client.Receive(result);
                var newResult = result.ToList().Take(ulength).ToArray();
                if (newResult[0] == seqhead[0] && newResult[1] == seqhead[1])
                {
                    Console.WriteLine(BitConverter.ToString(newResult));
                    return true;
                }
                else
                {
                    return false;
                }
            }
            catch
            {
                return false;
            }
        }
    }
    void seqadd()
    {
        seq++;
        if (seq >= ushort.MaxValue - 10)
            seq = 0;
    }
}