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 Agv
{
    public class Server
    {
        private bool loop;
        private Socket _server;         //服务端
        Dictionary<string, Client> dictClient = new Dictionary<string, Client>();   //所有客户端
        private Thread tListenClient;   //监听客户端连接
        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 bool _IsdecodeSingleNode = false;
        private Dictionary<string, Node> nodeMap = new Dictionary<string, Node>();
        /// <summary>
        ///         
        /// </summary>
        /// <param name="_IsdecodeSingleNode">解码方式，默认解码多个节点</param>
        public Server(bool _IsdecodeSingleNode=false)
        {
            this._IsdecodeSingleNode = _IsdecodeSingleNode;
        }
        /// <summary>
        /// 服务端信息
        /// </summary>
        public string ServerInfo
        {
            get
            {
                return string.Format("{0}:{1}", serverIp, serverPort.ToString());
            }
        }
        /// <summary>
        /// 开启服务
        /// </summary>
        public void Start(string ip = "127.0.0.1", int port = 12000)
        {
            try
            {
                log.info("AGVServer服务启动");
                serverIp = ip;
                serverPort = port;
                IPEndPoint localEP = new IPEndPoint(IPAddress.Parse(serverIp), serverPort);
                _server = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
                _server.Bind(localEP);
                _server.Listen(100);

                loop = true;
                //_client = new List<Client>();
                tListenClient = new Thread(new ThreadStart(ListenClient));
                tListenClient.Start();
            }
            catch (Exception ex)
            {
                log.error("AGVServer服务启动", 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();
                log.info("AGVServer服务关闭");
            }
            catch (Exception ex)
            {
                log.error("AGVServer服务关闭", ex);
            }

        }

        /// <summary>
        /// 向服务端发送命令
        /// </summary>
        /// <param name="info"></param>
        /// <returns></returns>
        public bool SendToClient(string nodeName, 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(); // 一旦监听到一个客户端的请求，就返回一个与该客户端通信的 套接字；
                    log.info(string.Format("客户端[{0}]连接服务端[{1}]成功", sokConnection.RemoteEndPoint.ToString(), ServerInfo));
                    Thread thr = new Thread(ListenNet);
                    Client client =  new Client(sokConnection, thr, sokConnection.RemoteEndPoint.ToString());
                    thr.IsBackground = true;
                    thr.Start(client);
                    dictClient.Add(sokConnection.RemoteEndPoint.ToString(), client);
                }
                catch (SocketException)
                {
                    //关闭连接，退出阻塞Accept
                }
                catch (Exception ex)
                {
                    log.error("ListenClient", ex);
                }
            }
        }

        /// <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(sleep);
                try
                {
                    // 定义一个缓存区；
                    byte[] arrMsgRec = new byte[1024];
                    // 将接收到的数据存入到输入  arrMsgRec中；
                    int length = -1;
                    if (sokClient.Poll(-1, SelectMode.SelectRead))
                    {
                        try
                        {
                            length = sokClient.Receive(arrMsgRec); // 接收数据，并返回数据的长度；
                            if (length == 0)//连接正常断开
                            {
                                Offline(client);
                                log.debug(string.Format("客户端[{0}]断开与服务端[{1}]的连接", sokClient.RemoteEndPoint.ToString(), ServerInfo));
                                return;
                            }
                        }
                        catch (SocketException se)
                        {
                            Offline(client);
                            log.error(string.Format("客户端[{0}]接收服务端[{1}]的消息出现异常", sokClient.RemoteEndPoint.ToString(), ServerInfo), se);
                            return;
                        }
                        catch (Exception e)
                        {
                            Offline(client);
                            log.error(string.Format("客户端[{0}]接收服务端[{1}]的消息出现异常", sokClient.RemoteEndPoint.ToString(), ServerInfo), e);
                            return;
                        }
                    }

                    if (length > 0)
                    {
                        byte[] buff = new byte[length];
                        Array.Copy(arrMsgRec, 0, buff, 0, length);

                        //解码单个节点
                        if(_IsdecodeSingleNode)
                        {
                            Node node = Common.Decode(buff);
                            if (node == null)
                            {
                                log.error("命令解析失败: " + HexBuff(buff));
                            }
                            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(buff);
                            if (nodes == null)
                            {
                                log.error("命令解析失败: " + HexBuff(buff));
                            }
                            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);
                            }
                        }

                    }
                }
                catch (Exception ex)
                {
                    log.error("ListenNet", ex);
                }

            }
        }

        private string FindClient(string nodeName)
        {
            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.info(string.Format("节点状态更新[{0}]", node.ToText()));
            }

        }
        private void UpdateNodes(List<Node> nodes)
        {
            foreach (var node in nodes)
            {
                UpdateNode(node);
            }
        }
        private void Offline(Client client)
        {
            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 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 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 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, 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 IP;
            public List<string> nodeName;
            public Socket Socket;
            public Thread ListenNet;
            public Client(Socket socket,Thread thread,string IP)
            {
                Socket = socket;
                ListenNet = thread;
                Loop = true;
                this.IP = IP;
                nodeName = new List<string>();
            }
        }
    }
    /// <summary>
    /// 客户端的节点
    /// </summary>
    public class ClientNode : Node
    {

        /// <summary>
        /// 在线状态
        /// </summary>
        public bool Online { get; set; }
        /// <summary>
        /// 是否可调用
        /// </summary>
        public bool IsUse { set; get; }
        /// <summary>
        /// 线体名
        /// </summary>
        public string LineName { set; get; }
        public string AliceName { get; set; }


        /// <summary>
        /// 客户端的节点
        /// </summary>
        public ClientNode() : base()
        {
        }
        public ClientNode(string nodeName, string rfid, ClientAction clientAction) : base(nodeName)
        {
            RFID = rfid;
            Action = clientAction;
        }
        /// <summary>
        /// 客户端节点
        /// </summary>
        /// <param name="name"></param>
        /// <param name="ip"></param>
        /// <param name="isUse"></param>
        public ClientNode(string name, string aliceName, string lineName, bool isUse) : base(name)
        {
            LineName = lineName;
            AliceName = aliceName;
            Online = false;
            IsUse = isUse;
        }
        /// <summary>
        /// 客户端节点
        /// </summary>
        /// <param name="name"></param>
        /// <param name="rfid"></param>
        /// <param name="action"></param>
        /// <param name="level"></param>
        public ClientNode(string name, string rfid = "", string mark = "", ClientAction action = ClientAction.None, Agv.ClientLevel level = Agv.ClientLevel.Low) : base(name)
        {

            RFID = rfid;
            Mark = mark;
            Level = level;
            Action = action;
        }

        /// <summary>
        /// 脱机
        /// </summary>
        public void Offline()
        {
            RFID = "";
            Action = ClientAction.None;
            Online = false;
        }
    }
}