using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.IO;
using System.Net;
using System.Net.Sockets;
using System.Threading;
using System.Threading.Tasks;

using Sodao.FastSocket.Server;
using Sodao.FastSocket.Server.Messaging;
using Sodao.FastSocket.SocketBase;
using HxCommonLib.Log;



namespace HxSocket
{
    /// <summary>
    /// 服务端程序监听类：与客户端建立连接，同时接收客户端消息，发送消息到客户端。
    /// 接收消息是一个线程
    /// 监听客户端连接是一个线程
    /// </summary>
    public class SocketTcpListener
    {
        private bool            m_bThreadRecvRunBreak = false;                     //接收线程中断
        private bool            m_bThreadConnRunBreak = false;                     //连接线程中断
        private TcpListener     m_tcpServerListener = null;
        private TcpClient       m_tcpClient = null;
        private NetworkStream   m_tcpRecvStream = null;
        private NetworkStream   m_tcpSendStream = null;
        public string           m_strRecvMessage = null;                        //接收到消息内容
        public bool             m_bRecvMessage = false;                         //是否接收到消息
        public bool             m_bConnectedClient = false;                     //已经连接到客户端
        public List<string>     m_listRecvMessage = new List<string>();         //缓存所有的消息队列，同时可以收到多条消息
        public string           m_strDevicesConntectedStatus = "";              //设备连接状态，心跳包
        /// <summary>
        /// //用于锁定m_listRecvMessage
        /// </summary>                       
        public object m_objListLock = new object();   

        public SocketTcpListener()
        {
            m_bConnectedClient = false;
        }

        /// <summary>
        /// 接收消息线程
        /// </summary>
        void RecvThreadMethod()
        {
            try
            {
                byte[] data = new byte[1024];
                //[1]TcpListener对Socket进行了封装，这各类会自己创建Socket对象，服务端端口为2018
                m_tcpServerListener = new TcpListener(IPAddress.Any, 2018);
                //[2]开始进行监听
                m_tcpServerListener.Start();

                //[3]等待客户端连接过来
                m_tcpClient = m_tcpServerListener.AcceptTcpClient();

                if (m_tcpClient != null)
                {
                    LogConstant.logger.Print("客户端已连接：" + m_tcpClient.Client.RemoteEndPoint.ToString());
                    m_bConnectedClient = true;
                    //[4]取得从客户端发来的数据
                    m_tcpRecvStream = m_tcpClient.GetStream(); //这是一个网络流，从这个网络流可以去的从客户端发来的数据
                }

                while (!m_bThreadRecvRunBreak)
                {
                    /* * 0表示从数组的哪个索引开始读取数据 * 1024 表示最大的读取数 * */
                    try
                    {
                        if (m_bConnectedClient)
                        {
                            int length = m_tcpRecvStream.Read(data, 0, 1024);
                            m_strRecvMessage = Encoding.UTF8.GetString(data, 0, length);
                            AddMessageToList();
                        }
                        else
                        {
                            Thread.Sleep(500);
                        }
                    }
                    catch (System.Exception ex)
                    {
                        LogConstant.logger.Print("[ERROR] " + ex.ToString());
                    }
                }
            }
            catch (System.Exception ex)
            {
                LogConstant.logger.Print("[ERROR] " + ex.ToString());
            }
        }

        void AddMessageToList()
        {
            if (m_strRecvMessage.Length > 0)
            {
                m_bRecvMessage = true;
                int nListRecvMsgCnt = 0;
                string textCommand = m_strRecvMessage;
                string[] asCommand = textCommand.Split(new string[] {"\r\n"}, StringSplitOptions.RemoveEmptyEntries); //防止两条命令合并为一条来接收
                if (asCommand.Length >= 0)
                {
                    lock (m_objListLock)
                    {
                        for (int i = 0; i < asCommand.Length; i++)
                        {
                            if (asCommand[i].Contains("COMMAND"))
                            {
                                if (asCommand[i].Contains("ID0")) //HeartBeat 
                                {
                                    m_strDevicesConntectedStatus = asCommand[i].Substring(asCommand[i].IndexOf("COMMAND") + 7);
                                    continue;
                                }
                                m_listRecvMessage.Add(asCommand[i] + "\r\n");
                            }
                        }
                        nListRecvMsgCnt = m_listRecvMessage.Count;
                    }
                }

                LogConstant.logger.Print("接收：" + m_strRecvMessage + "=" + nListRecvMsgCnt);
            } 
        }

        
        /// <summary>
        /// 判断客户端是否连接，断开后重新建立连接线程
        /// </summary>
        void ConnectThreadMethod()
        {
            while (!m_bThreadConnRunBreak)
            {
                try
                {
                    if (m_tcpClient != null && m_tcpClient.Connected)
                    {
                        try
                        {
                            int a1 = m_tcpClient.Client.Available;
                            int a2 = m_tcpClient.Available;
                            if (m_tcpClient.Client.Poll(500, SelectMode.SelectRead))
                            {
                                byte[] data = new byte[512];
                                int nRead = m_tcpClient.Client.Receive(data);
                                if (nRead == 0)
                                {
                                    //socket连接已断开
                                    m_bConnectedClient = false;
                                }
                            }
                        }
                        catch (System.Exception ex)
                        {
                            if (m_tcpSendStream != null)
                            {
                                m_tcpSendStream.Close();
                                m_tcpSendStream.Dispose();
                                m_tcpSendStream = null;
                            }
                            if (m_tcpClient != null)
                            {
                                m_tcpClient.Close();
                            }

                            m_bConnectedClient = false;
                            LogConstant.logger.Print("[ERROR] " + ex.ToString());
                        }
                    }

                    if (m_tcpClient != null && (!m_tcpClient.Connected || !m_tcpClient.Client.Connected || !m_bConnectedClient))
                    {
                        if (m_tcpSendStream != null)
                        {
                            m_tcpSendStream.Close();
                            m_tcpSendStream.Dispose();
                            m_tcpSendStream = null;
                        }
                        if (m_tcpClient != null)
                        {
                            m_tcpClient.Close();
                        }

                        m_bConnectedClient = false;
                        LogConstant.logger.Print("客户端已断开：" + m_tcpClient.Connected);

                        //[3]等待客户端连接过来
                        m_tcpClient = m_tcpServerListener.AcceptTcpClient();
                        if (m_tcpClient != null && m_tcpClient.Connected)
                        {
                            LogConstant.logger.Print("客户端已连接：" + m_tcpClient.Client.RemoteEndPoint.ToString());
                            
                            m_tcpRecvStream = m_tcpClient.GetStream();//这是一个网络流，从这个网络流可以去的从客户端发来的数据
                            m_bConnectedClient = true;
                        }
                    }
                    Thread.Sleep(1000);
                }
                catch (System.Exception ex)
                {
                    LogConstant.logger.Print("[ERROR] " + ex.ToString());
                    Thread.Sleep(1000);
                }
            }
        }

        /// <summary>
        /// 发送消息线程
        /// </summary>
        /// <param name="strMsg"></param>
        public void SendMessage(string strMsg)
        {
            if (m_tcpServerListener == null)
            {
                return;
            }

            if (m_tcpSendStream == null && m_tcpClient != null && m_bConnectedClient)
            {
                m_tcpSendStream = m_tcpClient.GetStream();
            }
            if (m_tcpSendStream == null || !m_bConnectedClient)
            {
                return;
            }

            try
            {
                lock (m_tcpSendStream)
                {
                    byte[] dataMsg = Encoding.UTF8.GetBytes(strMsg);
                    m_tcpSendStream.Write(dataMsg, 0, dataMsg.Length);
                    LogConstant.logger.Print("发送：" + strMsg);
                }
            }
            catch (System.Exception ex)
            {
                LogConstant.logger.Print("[ERROR] " + ex.ToString());
            }
        }
        

        /// <summary>
        /// 线程开始,启动函数
        /// </summary>
        public void SocketStart()
        {
            LogConstant.logger.Print("监听线程开始,监听端口：" + 2018);

            try
            {
                Thread aThread = new Thread(new ThreadStart(RecvThreadMethod));
                Thread bThread = new Thread(new ThreadStart(ConnectThreadMethod));

                // Try to restart the aborted thread
                aThread.Start();
                bThread.Start();
                
            }
            catch (ThreadStateException ex)
            {
                LogConstant.logger.Print("[ERROR] " + ex.ToString());
            }
        }

        /// <summary>
        /// 线程结束
        /// </summary>
        public void SocketClose()
        {
            if (m_tcpSendStream != null)
            {
                m_tcpSendStream.Close();
            }
            if (m_tcpRecvStream != null)
            {
                m_tcpRecvStream.Close();
            }
            m_bThreadConnRunBreak = true;
            m_bThreadRecvRunBreak = true;
            if (m_tcpClient != null)
            {
                m_bThreadConnRunBreak = true;
                Thread.Sleep(700);
                m_tcpClient.Close();
            }
            if (m_tcpServerListener != null)
            {
                m_tcpServerListener.Stop(); //停止监听       
                m_bThreadRecvRunBreak = true;
                Thread.Sleep(700);
            }
        }

        

        

        /// <summary>
        /// 判断是否正常返回RETN，等到接收，30s超时
        /// </summary>
        /// <param name="strReturn"></param>
        /// <returns></returns>
        public bool CheckReturn(string strDevID, string strReturn)
        {
            bool bReturn = false;
            int nTimeOutCount = 0;  //超时计数器
            while (true) 
            {
                lock (m_objListLock)
                {
                    List<int> listIndex = new List<int>();
                    for (int i = 0; i < m_listRecvMessage.Count; i++)
                    {
                        string strRecvMessage = m_listRecvMessage[i];
                        if (strRecvMessage.Contains(strDevID) && 
                            strRecvMessage.Contains(strReturn))
                        {
                            listIndex.Add(i);
                            m_bRecvMessage = false;
                            bReturn = true;
                            break;
                        }
                    }

                    //清空已处理的命令,从后往前清空
                    for (int i = listIndex.Count - 1; i >= 0; i--)
                    {
                        m_listRecvMessage.RemoveAt(listIndex[i]);
                    }
                }
                if (bReturn)
                {
                    break;
                }

                Thread.Sleep(10);
                nTimeOutCount++;
                if (nTimeOutCount > 500) //30s超时
                {
                    break;
                }
            }

            return bReturn;
        }

        /// <summary>
        /// 判断是否正常返回COMMANDDone
        /// </summary>
        /// <param name="strReturn"></param>
        /// <returns></returns>
        public int CheckReturn(string strDevID)
        {
            int nRetCount = 0;
            lock (m_objListLock)
            {
                List<int> listIndex = new List<int>();
                for (int i = 0; i < m_listRecvMessage.Count; i++)
                {
                    string strRecvMessage = m_listRecvMessage[i];
                    if (strRecvMessage.Contains(strDevID) && 
                        strRecvMessage.Contains("COMMANDDone"))
                    {
                        listIndex.Add(i);
                        m_bRecvMessage = false;
                        nRetCount++;
                    }
                }

                //清空已处理的命令,从后往前清空
                for (int i = listIndex.Count - 1; i >= 0; i--)
                {
                    m_listRecvMessage.RemoveAt(listIndex[i]);
                }
            }

            return nRetCount;
        }

       
    }


    /// <summary>
    /// 汇像socket通信类
    /// </summary>
    public class HxSocketServerService : AbsSocketService<CommandLineMessage>
    {
        /// <summary>
        /// //主控连接句柄
        /// </summary>
        private static IConnection m_mainConnection = null;  

        /// <summary>
        /// //用于锁定m_listCacheMessage
        /// </summary>                       
        public static object m_objCacheLock = new object();   
          
        /// <summary>
        /// //缓存所有的消息队列，同时可以收到多条消息
        /// </summary>      
        public static List<string> m_listCacheMessage = new List<string>();   

        /// <summary>
        /// //设备连接状态，心跳包
        /// </summary>
        public static string       m_strDevicesConntectedStatus = "";                        



        /// <summary>
        /// 获取通信连接状态
        /// </summary>
        /// <returns></returns>
        public static bool GetConnectedStatus()
        {
            if (m_mainConnection != null && m_mainConnection.Active)
            {
                return true;
            }
            else
            {
                return false;
            }
        }


        /// <summary>
        /// 连接函数
        /// </summary>
        /// <param name="connection"></param>
        public override void OnConnected(IConnection connection)
        {
            if (m_mainConnection == null)
            {
                base.OnConnected(connection);
                LogConstant.logger.Print("已连上客户端: " + connection.RemoteEndPoint.ToString() + " " + connection.ConnectionID.ToString());

                connection.BeginReceive();

                m_mainConnection = connection;
            }
            else
            {
                m_mainConnection.BeginDisconnect();
                while (m_mainConnection.Active)
                {
                    Thread.Sleep(200);
                }
                m_mainConnection = null;
            }
        }


        /// <summary>
        /// 接收函数
        /// </summary>
        /// <param name="connection"></param>
        /// <param name="message"></param>
        public override void OnReceived(IConnection connection, CommandLineMessage message)
        {
            try
            {
                base.OnReceived(connection, message);
                switch (message.CmdName)
                {
                    case "echo":
                        message.Reply(connection, "echo_reply " + message.Parameters[0]);
                        break;
                    case "init":
                        LogConstant.logger.Print("connection:" + connection.ConnectionID.ToString() + " init");
                        message.Reply(connection, "init_reply ok");
                        break;
                    case "RunCommand":
                        if (message.Parameters != null && message.Parameters.Length > 0)
                        {
                            string strContent = String.Join(" ", message.Parameters) + Environment.NewLine;
                            AddMessageToList(strContent);
                            LogConstant.logger.Print("接收:" + strContent);
                        }
                        break;
                    default:
                        AddMessageToList(message.CmdName);
                        LogConstant.logger.Print("接收未知消息:" + message.CmdName);
                        break;
                }
            }
            catch (System.Exception ex)
            {
                LogConstant.logger.Print("[ERROR] " + ex.ToString());
            }
        }


        /// <summary>
        /// 断连函数
        /// </summary>
        /// <param name="connection"></param>
        /// <param name="ex"></param>
        public override void OnDisconnected(IConnection connection, Exception ex)
        {
            base.OnDisconnected(connection, ex);
            m_mainConnection = null;
            LogConstant.logger.Print(connection.RemoteEndPoint.ToString() + " disconnected");
        }


        /// <summary>
        /// 异常函数
        /// </summary>
        /// <param name="connection"></param>
        /// <param name="ex"></param>
        public override void OnException(IConnection connection, Exception ex)
        {
            base.OnException(connection, ex);
            LogConstant.logger.Print("[ERROR] " + ex.ToString());
        }


        /// <summary>
        /// ToPacket see cref="SocketBase.Packet"
        /// </summary>
        /// <param name="value"></param>
        /// <returns></returns>
        /// <exception cref="ArgumentNullException">value is null</exception>
        public static Packet ToPacket(string value)
        {
            if (value == null) throw new ArgumentNullException("value");
            return new Packet(Encoding.UTF8.GetBytes(string.Concat(value, Environment.NewLine)));
        }


        /// <summary>
        /// 发送消息
        /// </summary>
        /// <param name="message"></param>
        public static void SendMessage(string message)
        {
            if (m_mainConnection != null && m_mainConnection.Active)
            {
                m_mainConnection.BeginSend(ToPacket(message));
            }
        }


        /// <summary>
        /// 添加消息到缓存队列
        /// </summary>
        /// <param name="strRecvMessage"></param>
        private void AddMessageToList(string strRecvMessage)
        {
            if (strRecvMessage.Length > 0)
            {
                int nListRecvMsgCnt = 0;
                //防止两条命令合并为一条来接收
                string[] astrCommand = strRecvMessage.Split(new string[] { "\r\n" }, StringSplitOptions.RemoveEmptyEntries); 
                if (astrCommand.Length >= 0)
                {
                    lock (m_objCacheLock)
                    {
                        for (int i = 0; i < astrCommand.Length; i++)
                        {
                            if (astrCommand[i].Contains("ID0") &&
                                astrCommand[i].Contains("COMMAND")) //HeartBeat 
                            {
                                m_strDevicesConntectedStatus = astrCommand[i].Substring(astrCommand[i].IndexOf("COMMAND") + 7);
                                continue;
                            }
                            if (astrCommand[i].Contains("COMMAND"))
                            {
                                m_listCacheMessage.Add(astrCommand[i] + "\r\n");
                            }
                        }
                        nListRecvMsgCnt = m_listCacheMessage.Count;
                    }
                }

                LogConstant.logger.Print("ListRecvMsgCnt = " + nListRecvMsgCnt + "MsgLength = " + strRecvMessage.Length);
            }
        }


        /// <summary>
        /// 判断是否正常返回RETN，等到接收，30s超时
        /// </summary>
        /// <param name="strDevID">设备ID</param>
        /// <param name="strReturn">返回的指令内容</param>
        /// <returns>是否正常返回Retn指令</returns>
        public static bool CheckReturn(string strDevID, string strReturn)
        {
            bool bReturn = false;
            int nTimeOutCount = 0;  //超时计数器
            while (true)
            {
                lock (m_objCacheLock)
                {
                    List<int> listIndex = new List<int>();
                    for (int i = 0; i < m_listCacheMessage.Count; i++)
                    {
                        string strRecvMessage = m_listCacheMessage[i];
                        if (strRecvMessage.Contains(strDevID) &&
                            strRecvMessage.Contains(strReturn))
                        {
                            listIndex.Add(i);
                            bReturn = true;
                            break;
                        }
                    }

                    //清空已处理的命令,从后往前清空
                    for (int i = listIndex.Count - 1; i >= 0; i--)
                    {
                        m_listCacheMessage.RemoveAt(listIndex[i]);
                    }
                }
                if (bReturn)
                {
                    break;
                }

                Thread.Sleep(10);
                nTimeOutCount++;
                if (nTimeOutCount > 500) //30s超时
                {
                    break;
                }
            }

            return bReturn;
        }


        /// <summary>
        /// 判断是否正常返回RETN，等到接收，30s超时
        /// </summary>
        /// <param name="strDevID">设备ID</param>
        /// <param name="strRetnCmd">返回的指令内容</param>
        /// <param name="nTimeout">超时时间 ms</param>
        /// <returns>是否正常返回Retn指令</returns>
        public static bool CheckReturn(string strDevID, string strRetnCmd, int nTimeout)
        {
            bool bReturn = false;
            int nTimeOutCount = 0;          //超时计数器
            int nMaxCount = nTimeout / 10;  //最大超时次数

            while (true)
            {
                lock (m_objCacheLock)
                {
                    List<int> listIndex = new List<int>();
                    for (int i = 0; i < m_listCacheMessage.Count; i++)
                    {
                        string strRecvMessage = m_listCacheMessage[i];
                        if (strRecvMessage.Contains(strDevID) &&
                            strRecvMessage.Contains(strRetnCmd))
                        {
                            listIndex.Add(i);
                            bReturn = true;
                            break;
                        }
                    }

                    //清空已处理的命令,从后往前清空
                    for (int i = listIndex.Count - 1; i >= 0; i--)
                    {
                        m_listCacheMessage.RemoveAt(listIndex[i]);
                    }
                }

                if (bReturn)
                {
                    break;
                }
                if (nTimeOutCount++ > nMaxCount) //30s超时
                {
                    break;
                }
                Thread.Sleep(10);
            }

            return bReturn;
        }


        /// <summary>
        /// 判断是否正常返回COMMANDDone
        /// </summary>
        /// <param name="strDevID">设备ID</param>
        /// <returns>判断返回Done指令次数，并从缓存清空</returns>
        public static int CheckDone(string strDevID)
        {
            int nRetCount = 0;
            lock (m_objCacheLock)
            {
                List<int> listIndex = new List<int>();
                for (int i = 0; i < m_listCacheMessage.Count; i++)
                {
                    string strRecvMessage = m_listCacheMessage[i];
                    if (strRecvMessage.Contains(strDevID) &&
                        strRecvMessage.Contains("COMMANDDone"))
                    {
                        listIndex.Add(i);
                        nRetCount++;
                    }
                }

                //清空已处理的命令,从后往前清空
                for (int i = listIndex.Count - 1; i >= 0; i--)
                {
                    m_listCacheMessage.RemoveAt(listIndex[i]);
                }
            }

            return nRetCount;
        }


        /// <summary>
        /// 判断是否正常返回COMMANDDone
        /// </summary>
        /// <param name="strDevID">设备ID</param>
        /// <param name="nTimeout">超时时间 ms</param>
        /// <returns>是否成功返回</returns>
        public static bool CheckDone(string strDevID, int nTimeout)
        {
            bool bReturn = false;
            int nTimeOutCount = 0;          //超时计数器
            int nMaxCount = nTimeout / 10;  //最大超时次数

            while (true)
            {
                lock (m_objCacheLock)
                {
                    for (int i = 0; i < m_listCacheMessage.Count; i++)
                    {
                        string strRecvMessage = m_listCacheMessage[i];
                        if (strRecvMessage.Contains(strDevID) &&
                            strRecvMessage.Contains("COMMANDDone"))
                        {
                            //清空已处理的命令,从后往前清空
                            m_listCacheMessage.RemoveAt(i);
                            bReturn = true;
                            break;
                        }
                    }
                }

                if (bReturn)
                {
                    break;
                }
                if (nTimeOutCount++ > nMaxCount)
                {
                    break;
                }
                Thread.Sleep(10);
            }

            return bReturn;
        }


        /// <summary>
        /// 判断是否正常返回COMMANDDone
        /// </summary>
        /// <param name="strDevID">设备ID</param>
        /// <param name="strCmdNo">命令的唯一编号</param>
        /// <param name="nTimeout">超时时间 ms</param>
        /// <returns>是否成功返回</returns>
        public static bool CheckDone(string strDevID, string strCmdNo, int nTimeout)
        {
            bool bReturn = false;
            int nTimeOutCount = 0;          //超时计数器
            int nMaxCount = nTimeout / 10;  //最大超时次数

            while (true)
            {
                lock (m_objCacheLock)
                {
                    for (int i = 0; i < m_listCacheMessage.Count; i++)
                    {
                        string strRecvMessage = m_listCacheMessage[i];
                        if (strRecvMessage.Contains(strDevID) &&
                            strRecvMessage.Contains(strCmdNo) &&
                            strRecvMessage.Contains("COMMANDDone"))
                        {
                            //清空已处理的命令,从后往前清空
                            m_listCacheMessage.RemoveAt(i);
                            bReturn = true;
                            break;
                        }
                    }
                }

                if (bReturn)
                {
                    break;
                }
                if (nTimeOutCount++ > nMaxCount) 
                {
                    break;
                }
                Thread.Sleep(10);
            }

            return bReturn;
        }


        /// <summary>
        /// 获取指令返回的字符串
        /// </summary>
        /// <param name="strDevID">设备ID</param>
        /// <param name="strInCmd">发送的请求指令名称如GET0,SET0,ALAM,STOP</param>
        /// <param name="nTimeout">超时时间 ms</param>
        /// <returns>失败返回为空</returns>
        public static string GetReturnValue(string strDevID, string strInCmd, int nTimeout)
        {
            bool bReturn = false;
            string strReturn = "";
            int nTimeOutCount = 0;  //超时计数器
            int nMaxCount = nTimeout / 10;  //最大超时次数

            while (true) //等待判断运动到位
            {
                lock (m_objCacheLock)
                {
                    List<int> listIndex = new List<int>();
                    for (int i = 0; i < m_listCacheMessage.Count; i++)
                    {
                        string strRecvMessage = m_listCacheMessage[i];
                        if (strRecvMessage.Contains(strDevID) &&
                            strRecvMessage.Contains(strInCmd))//"GET0"
                        {
                            listIndex.Add(i);
                            strReturn = strRecvMessage.Substring(strRecvMessage.IndexOf(strInCmd));
                            bReturn = true;
                            break;
                        }
                    }

                    //清空已处理的命令
                    for (int i = listIndex.Count - 1; i >= 0; i--)
                    {
                        m_listCacheMessage.RemoveAt(listIndex[i]);
                    }
                }

                if (bReturn)
                {
                    break;
                }
                if (nTimeOutCount++ > nMaxCount) //超时
                {
                    break;
                }
                System.Threading.Thread.Sleep(10);
            }

            return strReturn;
        }
        
        /// <summary>
        /// 是否资源
        /// </summary>
        public static void Release()
        {
            if (m_mainConnection != null)
            {
                m_mainConnection.BeginDisconnect();
                m_mainConnection = null;
            }
            m_listCacheMessage.Clear();
        }
    }

    
}