using System;
using System.Collections.Generic;
using System.Linq;
using System.Net;
using System.Net.Sockets;
using System.Text;
using System.Threading;
using System.Web.Script.Serialization;

namespace Clinet
{
    public class AgvClient
    {
        private string _ip;           //远程IP地址
        private Socket client;        //客户端
        private int countRecon;       //重连次数
        private Timer timerRecon;
        private Timer timerSend;
        private Timer timerListen;
        private List<ClientNode> _node;
        private const int PORT = 12000;    //端口

        public delegate void LogEvent(string s);
        public event LogEvent Log;

        /// <summary>
        /// 小车动作事件
        /// </summary>
        public delegate void ActionEvent(string name, string rfid);
        /// <summary>
        /// 小车到达，仅包装料仓
        /// </summary>
        public event ActionEvent Arrive;
        /// <summary>
        /// 小车已准备，对接完成
        /// </summary>
        public event ActionEvent Ready;
        /// <summary>
        /// 关门，仅包装料仓
        /// </summary>
        public event ActionEvent CloseDoor;
        /// <summary>
        /// 准备进入料架不能出料，仅包装料仓
        /// </summary>
        public event ActionEvent EnterShelf;


        public AgvClient(string serverIP)
        {
            _ip = serverIP;
            _node = new List<ClientNode>();
            ThreadPool.SetMaxThreads(6, 6);  //线程池最大数量
        }

        public bool IsConn { private set; get; } = false;

        public void Connect()
        {
            countRecon = 0;
            IsConn = false;
            timerRecon = new Timer(Reconnect, null, 0, 5000);
        }

        public void Close()
        {
            if (timerRecon != null)
                timerRecon.Dispose();
            if (timerSend != null)
                timerSend.Dispose();
            if (timerListen != null)
                timerListen.Dispose();
            Log?.Invoke("AGV客户端关闭");
        }

        public void SetStatus(string name, string mark = "", string rfid = "", ClientAction action = ClientAction.None, ClientLevel level = ClientLevel.Low)
        {
            int idx = _node.FindIndex(s => s.Name == name);
            if (idx == -1)
            {
                ClientNode node = new ClientNode(name, mark, rfid, action, level);
                _node.Add(node);
                Log?.Invoke("SetStatus " + node.ToText());
            }
            else
            {
                _node[idx].Mark = mark;
                _node[idx].RFID = rfid;
                _node[idx].Action = action;
                _node[idx].Level = level;
                Log?.Invoke("SetStatus " + _node[idx].ToText());
            }
        }

        public void SetStatus(ClientNode node)
        {
            int idx = _node.FindIndex(s => s.Name == node.Name);
            if (idx == -1)
            {
                _node.Add(node.ToCopy());
                Log?.Invoke("SetStatus " + node.ToText());
            }
            else
            {
                _node[idx].Mark = node.Mark;
                _node[idx].RFID = node.RFID;
                _node[idx].Action = node.Action;
                _node[idx].Level = node.Level;
                Log?.Invoke("SetStatus " + _node[idx].ToText());
            }
        }




        private void Reconnect(object obj)
        {
            if (IsConn) return;

            Open();
            if (IsConn)
            {
                countRecon = 0;
                Log?.Invoke("连接AGV服务器成功");
                timerSend = new Timer(SendStatus, null, 50, 2000);
                timerListen = new Timer(ListenNet, null, 50, 100);
            }
            else
            {
                Log?.Invoke("连接服务器失败" + ++countRecon + "次");
            }
        }

        private void Open()
        {
            IsConn = false;
            try
            {
                if (CheckIP(_ip))
                {
                    client = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
                    client.SetSocketOption(SocketOptionLevel.Socket, SocketOptionName.SendTimeout, 2000);
                    client.SetSocketOption(SocketOptionLevel.Socket, SocketOptionName.ReceiveTimeout, 2000);
                    client.SetSocketOption(SocketOptionLevel.Socket, SocketOptionName.NoDelay, 1);
                    client.Connect(IPAddress.Parse(_ip), PORT);
                    IsConn = true;
                }
            }
            catch (Exception ex)
            {
                Log?.Invoke(ex.Message);
            }
        }

        private void ListenNet(object obj)
        {
            byte[] temp = new byte[200];

            try
            {
                if (client.Available > 0)
                {
                    int count = client.Receive(temp);
                    byte[] buff = new byte[count];
                    Array.Copy(temp, 0, buff, 0, count);

                    ClientNode node = Decode(buff);
                    if (node == null)
                        Log?.Invoke("命令解析失败: " + HexBuff(buff));
                    else
                        Log?.Invoke("From Server: " + node.ToText());
                    Resolve(node);
                }
            }
            catch (Exception ex)
            {
                IsConn = false;
                Log?.Invoke(ex.Message);
            }
        }

        private void SendStatus(object obj)
        {
            for (int i = 0; i < _node.Count; i++)
            {
                if (!IsConn) break;
                Thread.Sleep(50);
                byte[] buff = Encode(_node[i]);
                bool bln = Send(buff);
                if (!bln) IsConn = false;
            }
        }

        private void Resolve(ClientNode node)
        {
            if (node == null) return;

            switch (node.Action)
            {
                case ClientAction.Arrive:
                    Log?.Invoke("触发Arrive事件");
                    Arrive?.Invoke(node.Name, node.RFID);
                    break;
                case ClientAction.Ready:
                    Log?.Invoke("触发Ready事件");
                    Ready?.Invoke(node.Name, node.RFID);
                    break;
                case ClientAction.CloseDoor:
                    Log?.Invoke("触发CloseDoor事件");
                    CloseDoor?.Invoke(node.Name, node.RFID);
                    break;
                case ClientAction.EnterShelf:
                    Log?.Invoke("触发EnterShelf事件");
                    EnterShelf?.Invoke(node.Name, node.RFID);
                    break;
            }

        }

        private bool Send(byte[] buff)
        {
            if (!IsConn)
            {
                Log?.Invoke("Send 服务器没有连接");
                return false;
            }

            try
            {
                //Log?.Invoke("Send: " + HexBuff(buff));
                client.Send(buff);
                return true;
            }
            catch (Exception ex)
            {
                Log?.Invoke(ex.Message);
                return false;
            }

        }

        //private byte[] Encode(ClientNode node)
        //{
        //    byte[] name = Encoding.UTF8.GetBytes(node.Name);
        //    byte[] mark = Encoding.UTF8.GetBytes(node.Mark);
        //    byte[] rfid = Encoding.UTF8.GetBytes(node.RFID);
        //    int count = name.Length + mark.Length + rfid.Length + 7;

        //    int idx = 0;
        //    byte[] buff = new byte[count];
        //    buff[idx++] = 0xAB;

        //    buff[idx++] = Convert.ToByte(name.Length);
        //    Array.Copy(name, 0, buff, idx, name.Length);
        //    idx += name.Length;

        //    buff[idx++] = Convert.ToByte(mark.Length);
        //    Array.Copy(mark, 0, buff, idx, mark.Length);
        //    idx += mark.Length;

        //    buff[idx++] = Convert.ToByte(rfid.Length);
        //    Array.Copy(rfid, 0, buff, idx, rfid.Length);
        //    idx += rfid.Length;

        //    buff[idx++] = (byte)node.Action;
        //    buff[idx++] = Convert.ToByte(node.Level);
        //    buff[idx++] = 0xBA;

        //    return buff;
        //}

        private byte[] Encode(ClientNode node)
        {
            List<string> arr = new List<string>
            {
                "name:\"" + node.Name + "\"",
                "mark:\"" + node.Mark + "\"",
                "rfid:\"" + node.RFID + "\"",
                "action:\"" + node.Action.ToString() + "\"",
                "level:\"" + node.Level.ToString() + "\""
            };
            string s = "{" + string.Join(",", arr) + "}";
            byte[] buff = Encoding.UTF8.GetBytes(s);
            return buff;
        }

        //private ClientNode Decode(byte[] buff)
        //{
        //    int idx = 0;
        //    if (buff[idx++] != 0xAB) return null;

        //    byte[] temp1 = new byte[buff[idx++]];
        //    Array.Copy(buff, idx, temp1, 0, temp1.Length);
        //    string name = Encoding.UTF8.GetString(temp1);
        //    idx += temp1.Length;

        //    temp1 = new byte[buff[idx++]];
        //    Array.Copy(buff, idx, temp1, 0, temp1.Length);
        //    string mark = Encoding.UTF8.GetString(temp1);
        //    idx += temp1.Length;

        //    temp1 = new byte[buff[idx++]];
        //    Array.Copy(buff, idx, temp1, 0, temp1.Length);
        //    string rfid = Encoding.UTF8.GetString(temp1);
        //    idx += temp1.Length;

        //    ClientAction action = (ClientAction)buff[idx++];
        //    ClientLevel level = (ClientLevel)buff[idx++];
        //    ClientNode node = new ClientNode(name, mark, rfid, action, level);

        //    if (buff[idx] != 0xBA)
        //        return null;
        //    return node;
        //}

        private ClientNode Decode(byte[] buff)
        {
            string json = Encoding.UTF8.GetString(buff);
            JavaScriptSerializer serializer = new JavaScriptSerializer();
            Dictionary<string, object> dic = (Dictionary<string, object>)serializer.DeserializeObject(json);
            if (dic == null) return null;

            ClientNode node = new ClientNode();
            if (dic.TryGetValue("name", out object value))
                node.Name = value.ToString();
            if (dic.TryGetValue("mark", out value))
                node.Mark = value.ToString();
            if (dic.TryGetValue("rfid", out value))
                node.RFID = value.ToString();
            if (dic.TryGetValue("action", out value))
            {
                if (Enum.TryParse(value.ToString(), out ClientAction action))
                    node.Action = action;
            }
            if (dic.TryGetValue("level", out value))
            {
                if (Enum.TryParse(value.ToString(), out ClientLevel level))
                    node.Level = level;
            }
            return node;
        }

        private string HexBuff(byte[] buff)
        {
            string s = "";
            if (buff == null) return s;

            for (int i = 0; i < buff.Length; i++)
                s += buff[i].ToString("X2") + " ";
            return s;
        }

        private bool CheckIP(string ip)
        {
            //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)
            {
                Log?.Invoke("非法的IP地址" + ip);
                return false;
            }

            //Ping服务端
            try
            {
                System.Net.NetworkInformation.Ping ping = new System.Net.NetworkInformation.Ping();
                System.Net.NetworkInformation.PingReply result = ping.Send(ip, 2000);
                ping.Dispose();
                if (result.Status != System.Net.NetworkInformation.IPStatus.Success)
                {
                    Log?.Invoke("Ping " + ip + " 请求没有响应");
                    return false;
                }
                return true;
            }
            catch (Exception ex)
            {
                Log?.Invoke(ex.Message);
                return false;
            }
        }






    }

    /// <summary>
    /// 客户端的动作
    /// </summary>
    public enum ClientAction : byte
    {
        /// <summary>
        /// 没有动作
        /// </summary>
        None = 0,
        /// <summary>
        /// 包装料仓关门
        /// </summary>
        CloseDoor = 1,
        /// <summary>
        /// 可以进入料架，Arrive事件使用，让小车开始对接
        /// </summary>
        MayEnter = 2,
        /// <summary>
        /// 可以出去料架，Arrive事件使用，让小车开始对接
        /// </summary>
        MayLeave = 3,
        /// <summary>
        /// 需要进入料架
        /// </summary>
        NeedEnter = 4,
        /// <summary>
        /// 需要出去料架
        /// </summary>
        NeedLeave = 5,
        /// <summary>
        /// 完成进入料架
        /// </summary>
        FinishEnter = 6,
        /// <summary>
        /// 完成出去料架
        /// </summary>
        FinishLeave = 7,
        /// <summary>
        /// 小车到达，到达包装料仓门口，等待开门
        /// </summary>
        Arrive = 8,
        /// <summary>
        /// 小车已准备，已对接上流水线
        /// </summary>
        Ready = 9,
        /// <summary>
        /// 包装料仓只能入料不能出料
        /// </summary>
        EnterShelf = 10,
        /// <summary>
        /// 不允许
        /// </summary>
        MayNot = 11
    }

    /// <summary>
    /// 客户端的优先级
    /// </summary>
    public enum ClientLevel : byte
    {
        /// <summary>
        /// 低
        /// </summary>
        Low = 0,
        /// <summary>
        /// 中等
        /// </summary>
        Middle = 1,
        /// <summary>
        /// 高
        /// </summary>
        High = 2
    }

    public class ClientNode
    {
        /// <summary>
        /// 节点名称
        /// </summary>
        public string Name { set; get; }
        /// <summary>
        /// 标记，用于包装料仓
        /// </summary>
        public string Mark { set; get; }
        /// <summary>
        /// 当前架子的RFID
        /// </summary>
        public string RFID { set; get; }
        /// <summary>
        /// 动作
        /// </summary>
        public ClientAction Action { set; get; }
        /// <summary>
        /// 优先级
        /// </summary>
        public ClientLevel Level { set; get; }

        public ClientNode()
        {
        }

        public ClientNode(string name, string mark, string rfid, ClientAction action, ClientLevel level)
        {
            Name = name;
            Mark = mark;
            RFID = rfid;
            Action = action;
            Level = level;
        }

        /// <summary>
        /// 所有属性的文本形式
        /// </summary>
        /// <returns></returns>
        public string ToText()
        {
            string s = string.Format("Name={0}, Action={1}, Level={2}, Mark={3}, RFID={4}", Name, Action, Level, Mark, RFID);
            return s;
        }

        public ClientNode ToCopy()
        {
            ClientNode node = new ClientNode(Name, Mark, RFID, Action, Level);
            return node;
        }
    }


}