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

namespace Agv
{
    /// <summary>
    /// AGV客户端
    /// </summary>
    public class AgvClient
    {
        private bool _loopClient;
        private int _countRecon;
        private bool _loopRecon;
        private Socket _clientSocket;        //客户端
        private List<Node> _node;
        private List<Node> _nodeNoneState;
        private Thread tSend;          //发送
        private Thread tListen;        //监听网络
        private Thread tRecon;
        private string SERVER_IP;        //远程IP地址
        private int SERVER_PORT;    //端口
        private bool _IsEecodeSingleNode = false;//是否编码单个节点（默认编码多个节点）
        /// <summary>
        /// 小车接收事件委托
        /// </summary>
        public delegate void ReceiveEvent(Node node);
        /// <summary>
        /// 服务器连接事件
        /// </summary>
        /// <param name="status"></param>
        public delegate void ConnectEvent(bool status);
        /// <summary>
        /// 小车接收事件
        /// </summary>
        public event ReceiveEvent Received;
        /// <summary>
        /// 服务器连接事件
        /// </summary>
        public event ConnectEvent Connected;

        /// <summary>
        /// 服务端信息
        /// </summary>
        public string ServerInfo
        {
            get
            {
                return string.Format("{0}:{1}", SERVER_IP, SERVER_PORT.ToString());
            }
        }
        /// <summary>
        ///  AGV客户端
        /// </summary>
        /// <param name="_IsEecodeSingleNode">编码方式，默认编码多个节点</param>
        public AgvClient(bool _IsEecodeSingleNode = false)
        {
            _node = new List<Node>();
            _nodeNoneState = new List<Node>();
            this._IsEecodeSingleNode = _IsEecodeSingleNode;
        }

        /// <summary>
        /// 是否连接服务器
        /// </summary>
        public bool IsConn { private set; get; } = false;

        /// <summary>
        /// 发送命令的时间间隔，不能大于10s（单位：秒）
        /// </summary>
        public int SendSleep { set; get; } = 1;
        /// <summary>
        /// 禁用状态(true：发送None，false：正常发送)
        /// </summary>
        public bool CancelState { get; set; } = true;


        /// <summary>
        /// 连接
        /// </summary>
        public void Connect(string serverIP, int port = 12000)
        {
            SERVER_IP = serverIP;
            SERVER_PORT = port;
            _countRecon = 0;
            _loopRecon = true;
            IsConn = false;
            _loopClient = true;

            tListen = new Thread(new ThreadStart(ListenServerNet));
            tSend = new Thread(new ThreadStart(KeepSendStatus));
            tRecon = new Thread(new ThreadStart(Reconnect));
            tRecon.Start();
            //Open();
            tListen.Start();
            tSend.Start();
            Agv.log.info("连接服务器");
        }

        /// <summary>
        /// 关闭
        /// </summary>
        public void Close()
        {
            CancelState = true;
            _loopClient = false;
            _loopRecon = false;
            if (_clientSocket != null)
            {
                _clientSocket.Close();
                _clientSocket = null;
            }
            log.info("客户端关闭");
        }

        /// <summary>
        /// 设置状态
        /// </summary>
        /// <param name="nodeName">节点名</param>
        /// <param name="mark">虚拟rfid</param>
        /// <param name="rfid">rfid</param>
        /// <param name="action">动作</param>
        /// <param name="level">等级</param>
        /// <param name="shelf">料架类型</param>
        /// <param name="type">客户端类型</param>
        public void SetStatus(string nodeName, string mark = "", string rfid = "", ClientAction action = ClientAction.None, ClientLevel level = ClientLevel.Low, ClientShelf shelf = ClientShelf.None, ClientType type = ClientType.None)
        {
            int index = _node.FindIndex(s => s.Name == nodeName);
            if (index == -1)  //没有找到
            {
                Node node = new Node
                {
                    Name = nodeName,
                    RFID = rfid,
                    Action = action,
                    Level = level,
                    Shelf = shelf,
                    Type = type,
                    Mark = mark
                };
                _node.Add(node);
                _nodeNoneState.Add(new Node { Name=nodeName});
                log.info("SetStatus " + node.ToText());
            }
            else
            {
                _node[index].RFID = rfid;
                _node[index].Action = action;
                _node[index].Level = level;
                _node[index].Shelf = shelf;
                _node[index].Type = type;
                _node[index].Mark = mark;
                log.info("SetStatus " + _node[index].ToText());
            }
        }

        /// <summary>
        /// 设置状态
        /// </summary>
        /// <param name="nodeName">节点名称</param>
        /// <param name="action">动作</param>
        public void SetStatus(string nodeName, ClientAction action)
        {
            int index = _node.FindIndex(s => s.Name == nodeName);
            if (index == -1)  //没有找到
            {
                log.info("SetStatus 没有找到" + nodeName);
            }
            else
            {
                _node[index].Action = action;
                log.info("SetStatus " + _node[index].ToText());
            }
        }



        /// <summary>
        /// 重连线程
        /// </summary>
        private void Reconnect()
        {
            while (_loopRecon)
            {
                if (!IsConn)
                {
                    Open();
                    if (IsConn)
                    {
                        _countRecon = 0;
                        log.info("连接服务器成功");
                        Connected?.Invoke(IsConn);
                    }
                    else
                    {
                        log.info("连接服务器失败" + ++_countRecon + "次");
                    }
                }
                Thread.Sleep(2000);
            }
            log.info("Quit Thread Reconnect");
        }

        /// <summary>
        /// 打开，连接到服务器
        /// </summary>
        private void Open()
        {
            try
            {
                if (CheckIP(SERVER_IP))
                {
                    _clientSocket = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
                    _clientSocket.SetSocketOption(SocketOptionLevel.Socket, SocketOptionName.SendTimeout, 2000);
                    _clientSocket.SetSocketOption(SocketOptionLevel.Socket, SocketOptionName.ReceiveTimeout, 2000);
                    _clientSocket.SetSocketOption(SocketOptionLevel.Socket, SocketOptionName.NoDelay, 1);
                    _clientSocket.Connect(IPAddress.Parse(SERVER_IP), SERVER_PORT);
                    if (!_loopRecon) return;
                    IsConn = true;
                    Connected?.Invoke(IsConn);
                }
            }
            catch (Exception ex)
            {
                IsConn = false;
                log.error("Open Error", ex);
            }
        }

        /// <summary>
        /// 监听服务端发送的内容
        /// </summary>
        private void ListenServerNet()
        {
            int timeout = 100;
            while (true)
            {
                while (_loopClient)
                {
                    Thread.Sleep(timeout);
                    if (!IsConn) continue;
                    if (_clientSocket == null) continue;
                    if (!_loopClient) break;

                    try
                    {
                        // 定义一个缓存区；
                        byte[] arrMsgRec = new byte[1024];
                        // 将接收到的数据存入到输入  arrMsgRec中；
                        int length = -1;
                        if (_clientSocket.Poll(-1, SelectMode.SelectRead))
                        {
                            try
                            {
                                length = _clientSocket.Receive(arrMsgRec); // 接收数据，并返回数据的长度；
                                if (length == 0)//连接正常断开
                                {
                                    IsConn = false;
                                    Connected?.Invoke(IsConn);
                                    log.info(string.Format("服务端[{1}]断开与客户端的连接", _clientSocket.RemoteEndPoint.ToString(), ServerInfo));
                                    break;
                                }
                            }
                            catch (SocketException se)
                            {
                                IsConn = false;
                                Connected?.Invoke(IsConn);
                                log.error(string.Format("客户端[{0}]接收服务端[{1}]的消息出现异常", _clientSocket.RemoteEndPoint.ToString(), ServerInfo), se);
                                break;
                            }
                            catch (Exception e)
                            {
                                IsConn = false;
                                Connected?.Invoke(IsConn);
                                log.error(string.Format("客户端[{0}]接收服务端[{1}]的消息出现异常", _clientSocket.RemoteEndPoint.ToString(), ServerInfo), e);
                                break;
                            }
                        }

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

                            Node node = Common.Decode(buff);
                            if (node == null)
                            {
                                log.error("命令解析失败");
                            }
                            else
                            {
                                log.info("触发Received事件，" + node.ToText());
                                Received?.Invoke(node);
                            }
                        }

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

                        //    Node node = Common.Decode(buff);
                        //    if (node == null)
                        //    {
                        //        LogUtil.error("命令解析失败");
                        //    }
                        //    else
                        //    {
                        //        LogUtil.info("触发Received事件，" + node.ToText());
                        //        Received?.Invoke(node);
                        //    }
                        //}
                    }
                    catch (Exception ex)
                    {
                        IsConn = false;
                        log.error("ListenNet Error", ex);
                        Connected?.Invoke(IsConn);
                    }
                }
            }


            log.info("Quit Thread ListenNet");
        }

        /// <summary>
        /// 连续发送状态线程
        /// </summary>
        private void KeepSendStatus()
        {
            bool bln;
            while (_loopClient)
            {
                Thread.Sleep(SendSleep * 1000);
                if (!IsConn) continue;
                if (_clientSocket == null) continue;
                if (_IsEecodeSingleNode)
                {
                    for (int i = 0; i < _node.Count; i++)
                    {
                        if (!_loopClient) break;
                        Thread.Sleep(500);
                        if (!CancelState)
                        {
                            byte[] buff = Common.Encode(_node[i]);
                            bln = Send(buff);
                        }
                        else
                        {
                            Node nostate = _node[i].ToCopy();
                            nostate.Action = ClientAction.None;
                            byte[] buff = Common.Encode(nostate);
                            bln = Send(buff);
                        }
                        if (!bln) continue;
                    }
                }
                else
                {
                    if (_node.Count == 0) continue;
                    if (!CancelState)
                    {
                        byte[] buff = Common.Encode(_node);
                        if (!_loopClient) break;
                        bln = Send(buff);
                    }
                    else
                    {
                        byte[] buff = Common.Encode(_nodeNoneState);
                        if (!_loopClient) break;
                        bln = Send(buff);
                    }
                }

            }
            log.info("Quit Thread SendStatus");
        }


        /// <summary>
        /// 发送命令
        /// </summary>
        /// <param name="buff"></param>
        /// <returns></returns>
        private bool Send(byte[] buff)
        {
            if (!IsConn)
            {
                log.info("Send 服务器没有连接");
                return false;
            }

            try
            {
                if (!_loopRecon) return false;
                if (buff == null) return false;
                _clientSocket.Send(buff);
                log.debug(string.Format("Send to Server:{0}", string.Join(" ", buff)));
                return true;
            }
            catch (Exception ex)
            {
                log.error("Send Error", ex);
                IsConn = false;
                Connected?.Invoke(IsConn);
                return false;
            }

        }

        /// <summary>
        /// 检查IP地址
        /// </summary>
        /// <param name="ip"></param>
        /// <returns></returns>
        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.info("非法的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.info("Ping " + ip + " 请求没有响应");
                    return false;
                }
                return true;
            }
            catch (Exception ex)
            {
                log.error("CheckIP Error", ex);
                return false;
            }
        }

    }

}