using System;
using System.Collections.Generic;
using System.Linq;
using System.Net;
using System.Net.Sockets;
using System.Threading;
using Dolen;
namespace Dolen.Agv
{
    public class Server
    {
        private bool loop;
        private Socket _server;         //服务端
        Dictionary<string, Client> dictClient = new Dictionary<string, Client>();   //所有客户端
        private Thread tListenClient;   //监听客户端连接
        private Thread tKeepLive;//心跳线程
        private Dictionary<string, bool> nodeOnline = new Dictionary<string, bool>();
        public delegate void NodeChangedEvent(Node clientNode);
        public delegate void NodeOnlineEvent(string nodeName, bool online);
        public event NodeChangedEvent NodeChanged;
        public event NodeOnlineEvent NodeOnline;
        private string serverIp;
        private int serverPort;
        private Dictionary<string, Node> nodeMap = new Dictionary<string, Node>();

        private static Log log = new Log();
        /// <summary>
        /// 服务端信息
        /// </summary>
        public string ServerInfo
        {
            get
            {
                return string.Format("{0}:{1}", serverIp, serverPort.ToString());
            }
        }
        /// <summary>
        /// 开启服务
        /// </summary>
        public void Start(string ip = "0.0.0.0", int port = 12000)
        {
            try
            {
                log.Info($"AGV 服务端开启:{ip}:{port}");
                serverIp = ip;
                serverPort = port;
                IPEndPoint localEP;
                if (ip.Equals("0.0.0.0"))
                    localEP = new IPEndPoint(IPAddress.Any, serverPort);
                else
                    localEP = new IPEndPoint(IPAddress.Parse(ip), serverPort);
                _server = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
                _server.Bind(localEP);
                _server.Listen(100);

                loop = true;
                tListenClient = new Thread(new ThreadStart(ListenClient));
                tListenClient.IsBackground = true;
                tListenClient.Start();
                tKeepLive = new Thread(new ThreadStart(KeepClientLive));
                tKeepLive.IsBackground = true;
                tKeepLive.Start();
            }
            catch (Exception ex)
            {
                log.Error($"AGV 服务端开启:{ip}:{port}", ex);
            }
        }

        /// <summary>
        /// 停止服务
        /// </summary>
        public void Stop()
        {
            try
            {
                loop = false;
                foreach (string c in dictClient.Keys)
                {
                    try
                    {
                        dictClient[c].ListenNet.Abort();
                    }
                    catch (Exception ex)
                    {
                        log.Error(string.Format("关闭连接客户端[{0}]线程失败", c), ex);
                    }
                    try
                    {
                        dictClient[c].Socket.Close();
                    }
                    catch (Exception ex)
                    {
                        log.Error(string.Format("关闭连接客户端[{0}]Socket失败", c), ex);
                    }
                }
                if (dictClient.Count > 0) dictClient.Clear();

                if (nodeMap.Count > 0)
                    nodeMap.Clear();

                if (_server != null)
                {
                    _server.Close();
                    _server.Dispose();
                }
            }
            catch (Exception ex)
            {
                log.Error("AGV 服务端关闭", ex);
            }

        }

        /// <summary>
        /// 向客户端发送命令
        /// </summary>
        /// <param name="info"></param>
        /// <returns></returns>
        public bool SendToClient(int id, string RFID, ClientAction action)
        {
            string tar = "";
            int n = 0;
            do
            {
                tar = FindClient(nodeName);
                if (tar.Equals(""))
                {
                    log.Error("没有找到" + nodeName);
                    Thread.Sleep(500);
                    n++;
                }
                else
                {
                    n = 10;
                }
            } while (n < 4);
            if (tar.Equals("")) return false;

            Node node = new Node(nodeName, RFID, action);
            log.info("SendTo " + nodeName + " RFID=" + RFID + " " + action);
            byte[] buff = Common.Encode(node);
            return Send(tar, buff);
        }
        /// <summary>
        /// 小车到达
        /// </summary>
        /// <param name="info"></param>
        /// <returns></returns>
        public bool Arrive(string nodeName, string RFID = "")
        {
            string tar = "";
            int n = 0;
            do
            {
                tar = FindClient(nodeName);
                if (tar.Equals(""))
                {
                    log.error("Arrive: 没有找到" + nodeName);
                    Thread.Sleep(500);
                    n++;
                }
                else
                {
                    n = 10;
                }
            } while (n < 4);
            if (tar.Equals("")) return false;

            Node node = new Node(nodeName, RFID, ClientAction.Arrive);
            log.info("SendTo " + nodeName + " RFID=" + RFID + " " + ClientAction.Arrive);
            byte[] buff = Common.Encode(node);
            return Send(tar, buff);
        }

        /// <summary>
        /// 小车已准备好
        /// </summary>
        /// <param name="info"></param>
        /// <returns></returns>
        public bool Ready(string nodeName, string RFID = "")
        {
            string tar = "";
            int n = 0;
            do
            {
                tar = FindClient(nodeName);
                if (tar.Equals(""))
                {
                    log.error("Ready: 没有找到" + nodeName);
                    Thread.Sleep(500);
                    n++;
                }
                else
                {
                    n = 10;
                }
            } while (n < 4);
            if (tar.Equals("")) return false;

            Node node = new Node(nodeName, RFID, ClientAction.Ready);
            log.info("SendTo " + nodeName + " RFID=" + RFID + " " + ClientAction.Ready);
            byte[] buff = Common.Encode(node);
            return Send(tar, buff);
        }

        /// <summary>
        /// 关门
        /// </summary>
        /// <param name="info"></param>
        /// <returns></returns>
        public bool CloseDoor(string nodeName, string RFID = "")
        {
            string tar = "";
            int n = 0;
            do
            {
                tar = FindClient(nodeName);
                if (tar.Equals(""))
                {
                    log.debug("CloseDoor: 没有找到" + nodeName);
                    Thread.Sleep(500);
                    n++;
                }
                else
                {
                    n = 10;
                }
            } while (n < 4);
            if (tar.Equals("")) return false;

            Node node = new Node(nodeName, RFID, ClientAction.CloseDoor);
            log.info("SendTo " + nodeName + " RFID=" + RFID + " " + ClientAction.CloseDoor);
            byte[] buff = Common.Encode(node);
            return Send(tar, buff);
        }


        /// <summary>
        /// 监听客户端连接
        /// </summary>
        private void ListenClient()
        {
            while (loop)
            {
                try
                {
                    // 开始监听客户端连接请求，Accept方法会阻断当前的线程；
                    Socket sokConnection = _server.Accept(); // 一旦监听到一个客户端的请求，就返回一个与该客户端通信的 套接字；
                    IPEndPoint endPoint = (IPEndPoint)sokConnection.RemoteEndPoint;
                    string ip = endPoint.Address.ToString();
                    int port = endPoint.Port;
                    if (dictClient.TryGetValue(ip, out Client client1))
                    {
                        Offline(client1);
                        Thread.Sleep(2000);
                        log.debug(string.Format("断开"));
                    }
                    Thread thr = new Thread(ListenNet);
                    Client client = new Client(sokConnection, thr, ip, endPoint.ToString());
                    thr.IsBackground = true;
                    dictClient.Add(ip, client);
                    thr.Start(client);
                    log.info(string.Format("客户端[{0}]连接服务端[{1}]成功", endPoint.ToString(), ServerInfo));
                }
                catch (SocketException)
                {
                    //关闭连接，退出阻塞Accept
                }
                catch (Exception ex)
                {
                    log.error("ListenClient", ex);
                }
            }
        }
        #region 粘包处理
        //线程安全的字典
        ConcurrentDictionary<string, byte[]> dic = new ConcurrentDictionary<string, byte[]>();
        /// <summary>
        /// 处理客户端发来的数据
        /// </summary>
        /// <param name="obj">每个客户的会话ID</param>
        /// <param name="bytes">缓冲区数据</param>
        /// <returns></returns>
        private void StickyBagHandle(Client client, byte[] bytes)
        {
            //bytes 为系统缓冲区数据
            //bytesRead为系统缓冲区长度
            int bytesRead = bytes.Length;
            string endpoint = client.IP;
            if (bytesRead > 0)
            {
                byte[] surplusBuffer = null;
                if (dic.TryGetValue(endpoint, out surplusBuffer))
                {
                    byte[] curBuffer = surplusBuffer.Concat(bytes).ToArray();//拼接上一次剩余的包
                    if (Common.CheckHeadChar(bytes, out int startIdx))//检查是否存在指定包头识别字符
                    {
                        byte[] tmp = new byte[bytesRead - startIdx];
                        Buffer.BlockCopy(bytes, startIdx, tmp, 0, bytesRead - startIdx);
                        //更新会话ID 的最新字节
                        dic.TryUpdate(endpoint, tmp, surplusBuffer);
                        surplusBuffer = curBuffer;//同步
                    }
                    else
                    {
                        byte[] xbtye = null;
                        dic.TryRemove(endpoint, out xbtye);
                    }
                }
                else
                {
                    if (Common.CheckHeadChar(bytes, out int startIdx))//检查是否存在指定包头识别字符
                    {
                        //添加会话ID的bytes
                        byte[] tmp = new byte[bytesRead - startIdx];
                        Buffer.BlockCopy(bytes, startIdx, tmp, 0, bytesRead - startIdx);
                        dic.TryAdd(endpoint, tmp);
                        surplusBuffer = tmp;//同步
                    }
                    else
                        return;
                }

                //已经完成读取每个数据包长度
                int haveRead = 0;
                //这里totalLen的长度有可能大于缓冲区大小的(因为 这里的surplusBuffer 是系统缓冲区+不完整的数据包)
                int totalLen = surplusBuffer.Length;
                while (haveRead <= totalLen)
                {
                    //如果在N次拆解后剩余的数据包连一个包头的长度都不够
                    //说明是上次读取N个完整数据包后，剩下的最后一个非完整的数据包
                    if (totalLen - haveRead < Common.headSize)
                    {
                        byte[] byteSub = new byte[totalLen - haveRead];
                        //把剩下不够一个完整的数据包存起来
                        Buffer.BlockCopy(surplusBuffer, haveRead, byteSub, 0, totalLen - haveRead);
                        dic.TryUpdate(endpoint, byteSub, surplusBuffer);
                        surplusBuffer = byteSub;

                        totalLen = 0;

                        break;

                    }

                    //如果够了一个完整包，则读取包头的数据
                    byte[] headByte = new byte[Common.headSize];
                    Buffer.BlockCopy(surplusBuffer, haveRead, headByte, 0, Common.headSize);//从缓冲区里读取包头的字节
                                                                                            //判断包头起始符
                    int bodySize = BitConverter.ToUInt16(headByte, 2);//从包头里面分析出包体的长度
                                                                      //这里的 haveRead=等于N个数据包的长度 从0开始；0,1,2,3....N

                    //如果自定义缓冲区拆解N个包后的长度 大于 总长度，说最后一段数据不够一个完整的包了，拆出来保存
                    if (haveRead + Common.headSize + bodySize > totalLen)
                    {
                        byte[] byteSub = new byte[totalLen - haveRead];
                        Buffer.BlockCopy(surplusBuffer, haveRead, byteSub, 0, totalLen - haveRead);
                        dic.TryUpdate(endpoint, byteSub, surplusBuffer);
                        surplusBuffer = byteSub;
                        break;
                    }
                    else
                    {
                        //挨个分解每个包，解析成实际文字
                        //String strc = Encoding.UTF8.GetString(surplusBuffer, haveRead + headSize, bodySize);
                        byte[] resBytes = new byte[bodySize];
                        Buffer.BlockCopy(surplusBuffer, haveRead + Common.headSize, resBytes, 0, bodySize);
                        log.debug(string.Format("[Receive data from:{0}] -> {1}", endpoint, Common.HexBuff(resBytes)));
                        DecodeNode(client, resBytes);
                        //依次累加当前的数据包的长度
                        haveRead = haveRead + Common.headSize + bodySize;
                        if (Common.headSize + bodySize == bytesRead)//如果当前接收的数据包长度正好等于缓冲区长度，则待拼接的不规则数据长度归0
                        {
                            byte[] xbtye = null;
                            dic.TryRemove(endpoint, out xbtye);
                            surplusBuffer = null;//设置空 回到原始状态
                            totalLen = 0;//清0
                        }

                    }

                }

            }

        }
        #endregion
        private void DecodeNode(Client client, byte[] resultBytes)
        {
            //解码单个节点
            if (Common.EnDecodeSingleNode)
            {
                Node node = Common.Decode(resultBytes);
                if (node == null)
                {
                    log.error("命令解析失败: " + Common.HexBuff(resultBytes));
                }
                else
                {
                    //CommonVar.LogUtil.info("Receive[" + client.IP + "] " + node.ToText());
                    int idx = client.nodeName.FindIndex(s => s == node.Name);
                    if (idx == -1) client.nodeName.Add(node.Name);
                    UpdateNode(node);

                }
            }
            else
            {
                //解码多个节点
                List<Node> nodes = Common.DecodeNodes(resultBytes);
                if (nodes == null)
                {
                    log.error("命令解析失败: " + Common.HexBuff(resultBytes));
                }
                else
                {
                    int idx = -1;
                    foreach (var node in nodes)
                    {
                        idx = client.nodeName.FindIndex(s => s == node.Name);
                        if (idx == -1) client.nodeName.Add(node.Name);
                    }
                    UpdateNodes(nodes);
                }
            }
        }
        /// <summary>
        /// 客户端数据接收
        /// </summary>
        /// <param name="obj">索引</param>
        private void ListenNet(object obj)
        {
            Client client = obj as Client;
            Socket sokClient = client.Socket;
            while (client.Loop)
            {
                Thread.Sleep(100);
                try
                {
                    // 定义一个缓存区；
                    byte[] arrMsgRec = new byte[1024];
                    // 将接收到的数据存入到输入  arrMsgRec中；
                    int length = -1;
                    if (!client.Loop) return;
                    if (sokClient != null && sokClient.Poll(-1, SelectMode.SelectRead))
                    {
                        length = sokClient.Receive(arrMsgRec); // 接收数据，并返回数据的长度；
                        if (length == 0)//连接正常断开
                        {
                            Offline(client);
                            log.info(string.Format("客户端[{0}]断开与服务端[{1}]的连接", sokClient.RemoteEndPoint.ToString(), ServerInfo));
                            return;
                        }
                    }
                    if (length > 0)
                    {
                        byte[] buff = new byte[length];
                        Array.Copy(arrMsgRec, 0, buff, 0, length);
                        StickyBagHandle(client, buff);
                    }
                }
                catch (Exception e)
                {

                }
            }
        }
        /// <summary>
        /// 查找客户端
        /// </summary>
        /// <param name="nodeName"></param>
        /// <returns></returns>
        private string FindClient(int id)
        {
            foreach (string item in dictClient.Keys)
            {
                if (dictClient[item].nodeName.Contains(nodeName))
                    return item;
            }
            return "";
        }
        private void UpdateNode(Node node)
        {
            if (!nodeOnline.Keys.Contains(node.Name))
            {
                nodeOnline.Add(node.Name, true);
                NodeOnline?.Invoke(node.Name, true);
            }
            else if (nodeOnline[node.Name].Equals(false))
            {
                nodeOnline[node.Name] = true;
                NodeOnline?.Invoke(node.Name, true);
            }
            if (!nodeMap.Keys.Contains(node.Name))
            {
                nodeMap.Add(node.Name, node);
                NodeChanged?.Invoke(node);
                log.info(string.Format("节点添加并状态更新[{0}]", node.ToText()));
            }
            else if (!nodeMap[node.Name].Equals(node))
            {
                nodeMap[node.Name] = node;
                NodeChanged?.Invoke(node);
                log.debug(string.Format("节点状态更新[{0}]", node.ToText()));
            }

        }
        private void UpdateNodes(List<Node> nodes)
        {
            foreach (var node in nodes)
            {
                UpdateNode(node);
                Thread.Sleep(200);
            }
        }
        private void Offline(Client client)
        {
            try
            {
                client.Loop = false;
                dictClient.Remove(client.IP);
                if (client.Socket != null)
                {
                    client.Socket.Close();
                    client.Socket = null;
                }
                for (int i = 0; i < client.nodeName.Count; i++)
                {
                    if (!nodeOnline.Keys.Contains(client.nodeName[i]))
                    {
                        nodeOnline.Add(client.nodeName[i], false);
                        NodeOnline?.Invoke(client.nodeName[i], false);
                    }
                    else if (nodeOnline[client.nodeName[i]].Equals(true))
                    {
                        nodeOnline[client.nodeName[i]] = false;
                        NodeOnline?.Invoke(client.nodeName[i], false);
                    }

                    if (nodeMap.ContainsKey(client.nodeName[i]))
                        nodeMap.Remove(client.nodeName[i]);
                }
                client.nodeName.Clear();
                client.ListenNet.Abort();
                log.info(string.Format("关闭对客户端[{0}]的监听线程", client.Endpoint));
            }
            catch (ThreadAbortException)
            {
                log.error(string.Format("关闭对客户端[{0}]的监听线程", client.Endpoint));
            }
        }
        private void Offline(string clientKey)
        {
            if (!dictClient.Keys.Contains(clientKey))
                return;
            Client client = dictClient[clientKey];
            client.Loop = false;
            client.Socket.Close();
            for (int i = 0; i < client.nodeName.Count; i++)
            {
                if (!nodeOnline.Keys.Contains(client.nodeName[i]))
                {
                    nodeOnline.Add(client.nodeName[i], false);
                    NodeOnline?.Invoke(client.nodeName[i], false);
                }
                else if (nodeOnline[client.nodeName[i]].Equals(true))
                {
                    nodeOnline[client.nodeName[i]] = false;
                    NodeOnline?.Invoke(client.nodeName[i], false);
                }
            }
            client.nodeName.Clear();
            client.ListenNet.Abort();
            client.Socket = null;
            dictClient.Remove(client.IP);
        }

        private void KeepClientLive()
        {
            Node node = new Node("", "Heartbeat package", ClientAction.None);
            byte[] buff = Common.Encode(node);
            while (loop)
            {
                try
                {
                    Thread.Sleep(2000);
                    foreach (string client in dictClient.Keys)
                    {
                        Send(client, buff);
                    }
                }
                catch (Exception ex)
                {
                }
            }
        }
        /// <summary>
        /// 发送命令
        /// </summary>
        /// <param name="idx"></param>
        /// <param name="buff"></param>
        /// <returns></returns>
        private bool Send(string clientKey, byte[] buff)
        {
            for (int i = 1; i <= 3; i++)
            {
                try
                {
                    dictClient[clientKey].Socket.Send(buff);
                    log.debug(string.Format("服务端[{0}]向客户端[{1}]发送消息:[{2}]", ServerInfo, clientKey, Common.HexBuff(buff)));
                    return true;
                }
                catch (Exception ex)
                {
                    log.error("发送失败" + i + "次：" + ex.Message);
                }
                Thread.Sleep(100);
            }
            Offline(clientKey);
            return false;
        }



        private class Client
        {
            public bool Loop;
            public string Endpoint;
            public string IP;
            public List<string> nodeName;
            public Socket Socket;
            public Thread ListenNet;
            public Client(Socket socket, Thread thread, string ip, string Endpoint)
            {
                Socket = socket;
                ListenNet = thread;
                Loop = true;
                IP = ip;
                this.Endpoint = Endpoint;
                nodeName = new List<string>();
            }
        }
    }
}