using System;
using System.Collections.Generic;
using System.Net;
using System.Net.Sockets;
using System.Threading;
using AGVControl;

namespace BLL
{
    public class AgvServer
    {
        private bool _loop;
        private Socket _server;         //服务端
        private List<Client> _client;   //所有客户端
        private Thread tListenClient;   //监听客户端连接

        public delegate void NodeChangedEvent(int nodeIndex);
        public event NodeChangedEvent NodeChanged;
        public event NodeChangedEvent NodeOnline;

        public AgvServer()
        {
           
        }

        /// <summary>
        /// 开启服务
        /// </summary>
        public void Start()
        {
            try
            {
                Common.log.Info("服务启动");

                IPEndPoint localEP = new IPEndPoint(IPAddress.Any, 12000);
                _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)
            {
                Common.log.Error(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;
            Common.log.Info("服务关闭");
        }

        /// <summary>
        /// 更新节点界面
        /// </summary>
        /// <param name="nodeIndex"></param>
        public void NodeRefresh(int nodeIndex)
        {
            NodeChanged?.Invoke(nodeIndex);
        }

        /// <summary>
        /// 小车到达
        /// </summary>
        /// <param name="info"></param>
        /// <returns></returns>
        public bool Arrive(Agv_Info info)
        {
            int idx;
            int n = 0;
            do
            {
                idx = FindClient(info.Place);
                if (idx == -1)
                {
                    Common.log.Info("没有找到" + info.Place);
                    Thread.Sleep(500);
                    n++;
                }
                else
                {
                    n = 10;
                }
            } while (n < 4);
            if (idx == -1) return false;

            ClientNode node = new ClientNode(info.Place, info.RFID, ClientAction.Arrive);
            Common.log.Info("SendTo " + info.Place + " " + ClientAction.Arrive);
            byte[] buff = Encode(node);
            return Send(idx, buff);
        }

        /// <summary>
        /// 小车已准备好
        /// </summary>
        /// <param name="info"></param>
        /// <returns></returns>
        public bool Ready(Agv_Info info)
        {
            int idx;
            int n = 0;
            do
            {
                idx = FindClient(info.Place);
                if (idx == -1)
                {
                    Common.log.Info("没有找到" + info.Place);
                    Thread.Sleep(500);
                    n++;
                }
                else
                {
                    n = 10;
                }
            } while (n < 4);
            if (idx == -1) return false;

            ClientNode node = new ClientNode(info.Place, info.RFID, ClientAction.Ready);
            Common.log.Info("SendTo " + info.Place + " " + ClientAction.Ready);
            byte[] buff = Encode(node);
            return Send(idx, buff);
        }

        /// <summary>
        /// 关门
        /// </summary>
        /// <param name="info"></param>
        /// <returns></returns>
        public bool CloseDoor(Agv_Info info)
        {
            int idx;
            int n = 0;
            do
            {
                idx = FindClient(info.Place);
                if (idx == -1)
                {
                    Common.log.Info("没有找到" + info.Place);
                    Thread.Sleep(500);
                    n++;
                }
                else
                {
                    n = 10;
                }
            } while (n < 4);
            if (idx == -1) return false;

            ClientNode node = new ClientNode(info.Place, info.RFID, ClientAction.CloseDoor);
            Common.log.Info("SendTo " + info.Place + " " + ClientAction.CloseDoor);
            byte[] buff = Encode(node);
            return Send(idx, buff);
        }

        /// <summary>
        /// 需要进入料架
        /// </summary>
        /// <param name="info"></param>
        /// <returns></returns>
        public bool EnterShelf(Agv_Info info)
        {
            int idx;
            int n = 0;
            do
            {
                idx = FindClient(info.Place);
                if (idx == -1)
                {
                    Common.log.Info("没有找到" + info.Place);
                    Thread.Sleep(500);
                    n++;
                }
                else
                {
                    n = 10;
                }
            } while (n < 4);
            if (idx == -1) return false;

            ClientNode node = new ClientNode(info.Place, info.RFID, ClientAction.EnterShelf);
            Common.log.Info("SendTo " + info.Place + " " + ClientAction.EnterShelf);
            byte[] buff = Encode(node);
            return Send(idx, buff);
        }








        /// <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();
                    if (ip == System.Configuration.ConfigurationManager.AppSettings["LocalIP"])
                        ip += ":" + ep.Port;

                    //新的客户端
                    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);
                    Common.log.Info(string.Format("[{0}] 已连接", client.IP));
                }
                catch (SocketException)
                {
                    //关闭连接，退出阻塞Accept
                }
                catch (Exception ex)
                {
                    Common.log.Error(ex);
                }
            }
        }

        /// <summary>
        /// 客户端数据接收
        /// </summary>
        /// <param name="obj">索引</param>
        private void ListenNet(object obj)
        {
            int sleep = 10;
            Client client = _client[(int)obj];
            byte[] temp = new byte[200];
            int time = 0;

            while (client.Loop)
            {
                Thread.Sleep(sleep);
                try
                {
                    if (!client.Loop) break;
                    if (client.Socket.Available > 0)
                    {
                        time = 0;
                        int count = client.Socket.Receive(temp);
                        byte[] buff = new byte[count];
                        Array.Copy(temp, 0, buff, 0, count);

                        ClientNode node = Decode(buff);
                        if (node == null)
                        {
                            Common.log.Info("命令解析失败: " + HexBuff(buff));
                        }
                        else
                        {
                            //Common.log.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
                    {
                        time += sleep;
                        if (time > 10000)
                        {
                            Offline(client);
                            Common.log.Info("[" + client.IP + "] 超过10s没有收到数据，关闭连接");
                        }
                    }
                }
                catch (Exception ex)
                {
                    Common.log.Error(ex);
                }
               
            }
        }

        /// <summary>
        /// 编码
        /// </summary>
        /// <param name="node"></param>
        /// <returns></returns>
        private byte[] Encode(ClientNode node)
        {
            byte[] name = System.Text.Encoding.UTF8.GetBytes(node.Name);
            byte[] mark = System.Text.Encoding.UTF8.GetBytes(node.Mark);
            byte[] rfid = System.Text.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;
        }

        /// <summary>
        /// 解码
        /// </summary>
        /// <param name="buff"></param>
        /// <returns></returns>
        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 = System.Text.Encoding.UTF8.GetString(temp1);
            idx += temp1.Length;

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

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

            ClientAction action = (ClientAction)buff[idx++];
            ClientLevel level = (ClientLevel)buff[idx++];

            ClientNode node = new ClientNode(name)
            {
                Mark = mark,
                RFID = rfid,
                Action = action,
                Level = level
            };

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

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

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

            if (Common.nodeInfo[idx].Mark != node.Mark ||
                Common.nodeInfo[idx].Action != node.Action ||
                Common.nodeInfo[idx].Level != node.Level ||
                Common.nodeInfo[idx].RFID != node.RFID)
            {
                Common.nodeInfo[idx].Mark = node.Mark;
                Common.nodeInfo[idx].Action = node.Action;
                Common.nodeInfo[idx].Level = node.Level;
                Common.nodeInfo[idx].RFID = node.RFID;
                Common.log.Info(node.Name + "更新 " + node.ToText());
                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 = AGVControl.Common.nodeInfo.FindIndex(s => s.Name == client.nodeName[i]);
                if (idx == -1) continue;
                AGVControl.Common.nodeInfo[idx].Offline();
                NodeChanged(idx);
                NodeOnline(idx);
            }
            client.nodeName.Clear();
        }

        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="name">节点名称</param>
        /// <returns></returns>
        private int FindClient(string name)
        {
            int index = -1;

            for (int i = 0; i < _client.Count; i++)
            {
                if (_client[i].IsConn)
                {
                    int idx = _client[i].nodeName.FindIndex(a => a == name);
                    if (idx != -1)
                    {
                        index = i;
                        break;
                    }
                }
            }

            return index;
        }

        /// <summary>
        /// 发送命令
        /// </summary>
        /// <param name="idx"></param>
        /// <param name="buff"></param>
        /// <returns></returns>
        private bool Send(int idx, byte[] buff)
        {
            for (int i = 1; i <= 3; i++)
            {
                try
                {
                    _client[idx].Socket.Send(buff);
                    Common.log.Info("[" + _client[idx].IP + "] " + HexBuff(buff));
                    return true;
                }
                catch (Exception ex)
                {
                    Common.log.Info("发送失败" + i + "次：" + ex.Message);
                }
                Thread.Sleep(100);
            }
            return false;
        }



        private class Client
        {
            public bool Loop;
            public string IP;
            public bool IsConn;
            public List<string> nodeName;
            public Socket Socket;
            public Thread ListenNet;

        }





    }




}