using System;
using System.Collections.Generic;
using System.Net;
using System.Net.Sockets;
using Common;
using System.Threading;
using System.Collections.Concurrent;
using System.Linq;

namespace DeviceLibrary
{
    /// <summary>
    /// AGV服务端,要求每个线体拥有不用的IP,根据IP来查找客户端
    /// </summary>
    public class AgvServer
    {
        private static log4net.ILog log = log4net.LogManager.GetLogger("AgvServer");
        private bool _loop;
        private Socket _server;         //服务端
        private List<Client> _client;   //所有客户端
        private Thread tListenClient;   //监听客户端连接
        private static int PORT = 9501;    //端口
        private Thread tPingClient;   //ping
        /// <summary>
        /// 节点改变事件
        /// </summary>
        /// <param name="nodeIndex"></param>
        public delegate void NodeChangedEvent(int nodeIndex);
        /// <summary>
        /// 节点改变
        /// </summary>
        public event NodeChangedEvent NodeChanged;
        /// <summary>
        /// 节点在线
        /// </summary>
        public event NodeChangedEvent NodeOnline;

        /// <summary>
        /// AGV服务端
        /// </summary>
        public AgvServer(int port=9501)
        {
            PORT = port;
            _client = new List<Client>();
        }

        /// <summary>
        /// 开启服务
        /// </summary>
        public void Start()
        {
            try
            {
                IPEndPoint localEP = new IPEndPoint(IPAddress.Any, PORT);
                _server = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
                _server.Bind(localEP);
                _server.Listen(100);
                log.Info("Server Start");
                _loop = true;
                _client = new List<Client>();
                tListenClient = new Thread(new ThreadStart(ListenClient));
                tListenClient.Start();
               tPingClient = new Thread(new ThreadStart(KeepLiveClient));
                tPingClient.Start();
            }
            catch (Exception ex)
            {
                log.Error("Start()", ex);
            }
        }

        /// <summary>
        /// 停止服务
        /// </summary>
        public void Stop()
        {
            _loop = false;
            for (int i = 0; i < _client.Count; i++)
            {
                _client[i].Loop = false;
                _client[i].IsConn = false;
                _client[i].Socket.Close();
            }
            _server.Close();
            _client = null;
            Thread.Sleep(50);
            log.Info("Server Stop");
        }

        public Dictionary<string, DateTime> readyEnterTime = new Dictionary<string, DateTime>();
        public Dictionary<string, DateTime> readyLeaveTime = new Dictionary<string, DateTime>();
        public bool ReadyEnter(string nodeName, string rfid = "")
        {
            int nodeIdx = AGVManager.nodeInfo.FindIndex(s => s.Name == nodeName);
            string ip = AGVManager.nodeInfo[nodeIdx].IP;
            int idx = FindClient(ip);
            if (idx == -1)
            {
                log.Error("ReadyEnter 没有找到" + nodeName + " " + ip);
                return false;
            }
            else
            {
                try
                {
                    if (!readyEnterTime.ContainsKey(nodeName))
                    {
                        readyEnterTime.Add(nodeName, DateTime.Now);
                    }
                    else
                    {
                        TimeSpan timeSpan = DateTime.Now - readyEnterTime[nodeName];
                        if (timeSpan.TotalSeconds < 15)
                        {
                            log.Debug(nodeName + " " + ip + " ReadyEnter 15秒内不重复发送");
                            return false;
                        }
                        else if (timeSpan.TotalSeconds > 30)
                        {
                            readyEnterTime[nodeName] = DateTime.Now;
                        }
                    }
                }
                catch (Exception ex) { log.Debug(ex.Message + ";" + ex.StackTrace); }

                ClientNode node = new ClientNode(nodeName, rfid, eNodeStatus.ReadyEnter);
                byte[] buff = Encode(node);
                return Send(idx, buff);
            }
        }

        public bool ReadyLeave(string nodeName, string rfid = "")
        {
            int nodeIdx = AGVManager.nodeInfo.FindIndex(s => s.Name == nodeName);
            string ip = AGVManager.nodeInfo[nodeIdx].IP;
            int idx = FindClient(ip);
            if (idx == -1)
            {
                log.Error("ReadyLeave 没有找到" + nodeName + " " + ip);
                return false;
            }
            else
            {
                try
                {
                    if (!readyLeaveTime.ContainsKey(nodeName))
                    {
                        readyLeaveTime.Add(nodeName, DateTime.Now);
                    }
                    else
                    {
                        TimeSpan timeSpan = DateTime.Now - readyLeaveTime[nodeName];
                        if (timeSpan.TotalSeconds < 45)
                        {
                            log.Debug(nodeName + " " + ip + " ReadyLeave 45秒内不重复发送");
                            return false;
                        }
                        else if (timeSpan.TotalMinutes > 1)
                        {
                            readyLeaveTime[nodeName] = DateTime.Now;
                        }
                    }
                }
                catch (Exception ex) { log.Debug(ex.Message + ";" + ex.StackTrace); }

                ClientNode node = new ClientNode(nodeName, rfid, eNodeStatus.ReadyLeave);
                byte[] buff = Encode(node);
                return Send(idx, buff);
            }
        }

        public bool FinishEnter(string nodeName, string rfid = "")
        {
            int nodeIdx = AGVManager.nodeInfo.FindIndex(s => s.Name == nodeName);
            string ip = AGVManager.nodeInfo[nodeIdx].IP;
            int idx = FindClient(ip);
            if (idx == -1)
            {
                log.Error("FinishEnter 没有找到" + nodeName + " " + ip);
                return false;
            }
            else
            {
                ClientNode node = new ClientNode(nodeName, rfid, eNodeStatus.FinishEnter);
                byte[] buff = Encode(node);
                return Send(idx, buff);
            }
        }

        public bool FinishLeave(string nodeName, string rfid = "")
        {
            int nodeIdx = AGVManager.nodeInfo.FindIndex(s => s.Name == nodeName);
            string ip = AGVManager.nodeInfo[nodeIdx].IP;
            int idx = FindClient(ip);
            if (idx == -1)
            {
                log.Error("FinishLeave 没有找到" + nodeName + " " + ip);
                return false;
            }
            else
            {
                ClientNode node = new ClientNode(nodeName, rfid, eNodeStatus.FinishLeave);
                byte[] buff = Encode(node);
                return Send(idx, buff);
            }
        }


        private void KeepLiveClient()
        {
            int n;

            while (_loop)
            {
                n = 0;
                while (n < 5000)  //所有产线间隔
                {
                    Thread.Sleep(50);
                    n += 50;
                    if (!_loop) return;
                }

                for (int i = 0; i < AGVManager.nodeInfo.Count; i++)
                {
                    try
                    {
                        if (!_loop)
                            break;
                        Thread.Sleep(1000);
                        if (!AGVManager.nodeInfo[i].IP.Equals(""))
                            AGVManager.nodeInfo[i].Online = CheckIP(AGVManager.nodeInfo[i].Name, AGVManager.nodeInfo[i].IP);
                        NodeOnline?.Invoke(i);
                    }
                    catch (Exception e)
                    {
                        log.Error("PingClient", e);
                    }
                }

            }
        }

        public bool CheckIP(string name, 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.Error("非法的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.Debug(name + " Ping " + ip + " 请求没有响应");
                    return false;
                }
                return true;
            }
            catch (Exception ex)
            {
                log.Error("CheckIP", ex);
                return false;
            }
        }

        /// <summary>
        /// 监听客户端
        /// </summary>
        private void ListenClient()
        {
            while (_loop)
            {
                try
                {
                    Socket socket = _server.Accept();  //这边会暂停，不需要sleep
                    IPEndPoint ep = (IPEndPoint)socket.RemoteEndPoint;
                    Thread listen = new Thread(new ParameterizedThreadStart(ListenNet));
                    string ip = ep.Address.ToString();

                    //新的客户端
                    Client client = new Client
                    {
                        IP = ip,
                        Loop = true,
                        IsConn = true,
                        Socket = socket,
                        ListenNet = listen,
                        nodeName = new List<string>(),
                    };

                    //重连后关闭旧连接
                    int idx = _client.FindIndex(s => s.IP.Equals(ip));
                    if (idx > -1)
                    {
                        _client[idx].IsConn = false;
                        _client[idx].nodeName.Clear();
                        _client[idx].Loop = false;
                        _client[idx].Socket.Close();
                        _client.RemoveAt(idx);
                    }

                    _client.Add(client);
                    listen.Start(_client.Count - 1);
                    log.Info(string.Format("[{0}] 已连接", client.IP));
                }
                catch (SocketException)
                {
                    //关闭连接，退出阻塞Accept
                    log.Debug("服务端关闭连接，退出阻塞Accept");
                }
                catch (Exception ex)
                {
                    log.Error("ListenClient()", ex);
                }
            }
        }

        //临时缓存
        //线程安全的字典
        ConcurrentDictionary<string, byte[]> dic = new ConcurrentDictionary<string, byte[]>();
        /// <summary>
        /// 客户端数据接收
        /// </summary>
        /// <param name="obj">索引</param>
        private void ListenNet(object obj)
        {
            int sleep = 50;
            Client client = _client[(int)obj];
            byte[] temp = new byte[127];
            int time = 0;

            while (client.Loop)
            {
                Thread.Sleep(sleep);
                try
                {
                    if (!client.Loop) break;
                    if (client.Socket.Available > 0)
                    {
                        time = 0;
                        byte[] supBuff = null;
                        int count = client.Socket.Receive(temp);
                        if (!dic.TryGetValue(client.IP, out supBuff)) //第一次收到开头必须是0xAD开头的字节
                        {
                            if (temp[0].Equals(0xAD))
                            {
                                supBuff = new byte[count];
                                Array.Copy(temp, 0, supBuff, 0, count);
                                //log.Info(string.Format("start with AB receive:{0}", HexBuff(supBuff)));
                            }
                            else
                            {
                                //log.Info(string.Format("start without AB receive:{0}", HexBuff(temp)));
                                for (int i = 0; i < count; i++)
                                {
                                    if (!temp[i].Equals(0xAD))
                                        continue;
                                    supBuff = new byte[count - i];
                                    Array.Copy(temp, i, supBuff, 0, count - i);
                                    //log.Info(string.Format("start without AB receive after filter:{0}", HexBuff(supBuff)));
                                    break;
                                }
                            }
                            dic.TryAdd(client.IP, supBuff);
                        }
                        else
                        {
                            byte[] tmp = new byte[count];
                            Array.Copy(temp, 0, tmp, 0, count);
                            byte[] curBuff = supBuff.Concat(tmp).ToArray();
                            dic.TryUpdate(client.IP, curBuff, supBuff);
                            supBuff = curBuff;
                            //log.Info(string.Format("receive:{0}",HexBuff(tmp)));
                            //log.Info(string.Format("buff:{0}",HexBuff(supBuff)));
                            //log.Info(string.Format("curBuf:{0}",HexBuff(curBuff)));
                            //log.Info(string.Format("dic[0]:{0}", HexBuff(dic[client.IP])));
                        }

                        List<byte> buf = new List<byte>();
                        for (int i = 0; i < supBuff.Length; i++)
                        {
                            if (supBuff[i].Equals(0XAD))
                            {
                                if (buf.Count > 0)
                                    buf.Clear();
                                buf.Add(supBuff[i]);
                            }
                            else if (supBuff[i].Equals(0XDA))
                            {
                                buf.Add(supBuff[i]);
                                byte[] buff = buf.ToArray();
                                //Array.Copy(temp, 0, buff, 0, count);

                                ClientNode node = Decode(client, buff);
                                if (node == null)
                                {
                                    log.Debug(client.IP + " 解码失败：" + HexBuff(buff));
                                }
                                else
                                {
                                    if (!node.Name.StartsWith("A") && !node.Name.Equals("S21")&& !node.Name.Equals("S22"))
                                    {
                                        log.Info("Receive[" + client.IP + "]:[" + HexBuff(buff) + "],解码内容：" + node.StatetText());
                                    }
                                    log.Debug("Receive[" + client.IP + "]:[" + HexBuff(buff) + "],解码内容：" + node.StatetText());
                                    int idx = client.nodeName.FindIndex(s => s == node.Name);
                                    if (idx == -1) client.nodeName.Add(node.Name);
                                    UpdateNode(node);
                                }
                                if (buf.Count > 0)
                                    buf.Clear();
                            }
                            else
                            {
                                buf.Add(supBuff[i]);
                            }
                        }
                        if (buf.Count > 0)//存在部分包
                        {
                            dic.TryUpdate(client.IP, buf.ToArray(), supBuff);
                        }
                        else
                            dic.TryRemove(client.IP, out byte[] bb);

                    }
                    else
                    {
                        time += sleep;
                        if (time > 1000 * 60 * 60 * 1)
                        {
                            Offline(client);
                            log.Debug("[" + client.IP + "] 超过1H没有收到数据，关闭连接");
                        }
                    }
                }
                catch (Exception ex)
                {
                    log.Error("ListenNet()", ex);
                }

            }
        }

        /// <summary>
        /// 编码-定长12字节
        /// </summary>
        /// <param name="node"></param>
        /// <returns></returns>
        private byte[] Encode(ClientNode node)
        {
            int idx = 0;
            byte[] buff = new byte[12];
            buff[idx++] = 0xAD;
            buff[idx++] = (byte)node.Name[0];
            buff[idx++] = Convert.ToByte(node.Name.Substring(1));
            buff[idx++] = (byte)node.RFID[0];
            //buff[idx++] = 0X00;
            //buff[idx++] = 0X00;
            //buff[idx++] = 0X00;
            buff[idx++] = Convert.ToByte(node.RFID.Substring(1));
            buff[idx++] = (byte)node.GetState();
            buff[idx++] = 0;
            idx += 4;  //预留
            buff[idx] = 0xDA;
            return buff;
        }

        /// <summary>
        /// 解码-定长12字节
        /// </summary>
        /// <param name="buff"></param>
        /// <returns></returns>
        private ClientNode Decode(Client client, byte[] buff)
        {
            int idx = 0;
            string name = "";
            string rfid = "";
            if (buff[idx++] != 0xAD) return null;
            if (buff[idx] == 0x00 && buff[idx + 1] == 0x00)//收到产线
            {
                int k = AGVManager.nodeInfo.FindIndex(s => client.IP.Equals(s.IP) && !s.Name.StartsWith("A"));
                if (k > -1)
                {
                    name = AGVManager.nodeInfo[k].Name;
                    rfid = "";
                }
                idx += 2;
                idx += 2;
            }
            else
            {
                name = (char)buff[idx] + buff[idx + 1].ToString();
                idx += 2;
                rfid = (char)buff[idx] + buff[idx + 1].ToString();
                idx += 2;
            }

            eNodeStatus action = (eNodeStatus)buff[idx++];

            ClientLevel level = (ClientLevel)buff[idx++];
            idx += 4;  //预留
            if (buff[idx] != 0xDA) return null;

            ClientNode node = new ClientNode(name, rfid, action);
            node.ClientLevel = level;
            return node;
        }

        private void UpdateNode(ClientNode node)
        {
            int idx = AGVManager.nodeInfo.FindIndex(s => s.Name == node.Name);
            if (idx == -1)
            {
                log.Error("UpdateNode " + node.Name + " 不存在");
                return;
            }

            if (!AGVManager.nodeInfo[idx].Online)
            {
                AGVManager.nodeInfo[idx].Online = true;
                NodeOnline?.Invoke(idx);
            }

            if (!AGVManager.nodeInfo[idx].StateEquals(node.GetState()) ||
                AGVManager.nodeInfo[idx].RFID != node.RFID || AGVManager.nodeInfo[idx].ClientLevel != node.ClientLevel)
            {

                AGVManager.nodeInfo[idx].UpdateNodeStatus(node.GetState());
                AGVManager.nodeInfo[idx].ClientLevel = node.ClientLevel;
                AGVManager.nodeInfo[idx].RFID = node.RFID;
                log.Info("节点更新 " + node.StatetText());
                NodeChanged?.Invoke(idx);
            }
        }

        private void Offline(Client client)
        {
            client.Loop = false;
            client.IsConn = false;
            client.Socket.Close();

            for (int i = 0; i < client.nodeName.Count; i++)
            {
                int idx = AGVManager.nodeInfo.FindIndex(s => s.Name == client.nodeName[i]);
                if (idx == -1) continue;
                AGVManager.nodeInfo[idx].Offline();
                NodeChanged(idx);
                NodeOnline(idx);
            }
            client.nodeName.Clear();
            //_client.Remove(client);
        }

        /// <summary>
        /// 16进制
        /// </summary>
        /// <param name="buff"></param>
        /// <returns></returns>
        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;
        }

        /// <summary>
        /// 查找客户端
        /// </summary>
        /// <param ip="ip">ip地址</param>
        /// <returns></returns>
        private int FindClient(string ip)
        {
            int index = -1;
            if (_client == null) return index;

            try
            {
                foreach (Client item in _client)
                {
                    if (item.IsConn)
                    {
                        //Common.log.Info("已连接客户端：" + string.Join("#", item.IP));
                        if (item.IP.Equals(ip))
                        {
                            index = _client.IndexOf(item);
                            break;
                        }
                        //int idx = item.nodeName.FindIndex(a => a == name);
                        //if (idx != -1)
                        //{
                        //    index = _client.IndexOf(item);
                        //    break;
                        //}
                    }
                }
            }
            catch { };
            return index;
        }

        /// <summary>
        /// 发送命令
        /// </summary>
        /// <param name="idx"></param>
        /// <param name="buff"></param>
        /// <returns></returns>
        private bool Send(int idx, byte[] buff)
        {
            string ip = "[" + _client[idx].IP + "]";

            if (!_client[idx].IsConn)
            {
                log.Error(ip + " 没有连接");
                return false;
            }

            try
            {
                if (_client[idx].IsConn)
                    _client[idx].Socket.Send(buff);
                if (buff.Length > 2)
                    log.Info("SendTo" + ip + ": " + HexBuff(buff));
                return true;
            }
            catch (Exception ex)
            {
                log.Error("Send Error: " + ip, ex);
                return false;
            }
        }

    }

    /// <summary>
    /// 客户端
    /// </summary>
    public class Client
    {
        /// <summary>
        /// 循环
        /// </summary>
        public bool Loop;
        /// <summary>
        /// IP地址
        /// </summary>
        public string IP;
        /// <summary>
        /// 是否连接
        /// </summary>
        public bool IsConn;
        /// <summary>
        /// 节点名称集合
        /// </summary>
        public List<string> nodeName;
        /// <summary>
        /// 套接字
        /// </summary>
        public Socket Socket;
        /// <summary>
        /// 接收数据线程
        /// </summary>
        public Thread ListenNet;
    }


}