using Newtonsoft.Json.Linq;
using Sodao.FastSocket.Server;
using Sodao.FastSocket.Server.Messaging;
using Sodao.FastSocket.SocketBase;
using System;
using System.Collections.Generic;
using System.Configuration;
using System.IO;
using System.Reflection;
using XImaging.Automation.Library.HxDriverLib;
using XImaging.Automation.Service.Interface;

namespace XImaging.Automation.Service
{
    class ResponseMessagePackage
    {
        public static JObject NullData
        {
            get
            {
                return JObject.FromObject(new { });
            }
        }

        public static JObject FormStorageInfoData(int m_stack, int m_level, string m_barcode)
        {
            return JObject.FromObject(
                new
                {
                    stack = m_stack,
                    level = m_level,
                    barcode = m_barcode
                });
        }
    }

    public class HxTcpHandler
    {
        /// <summary>
        /// //主控连接句柄
        /// </summary>
        private Dictionary<long, IConnection> m_mainConnection = new Dictionary<long, IConnection>();
        private static HxTcpHandler m_instance = null;
        private System.Timers.Timer timer = new System.Timers.Timer();

        private string appPath = Path.GetDirectoryName(Assembly.GetExecutingAssembly().Location);

        private HxTcpHandler()
        {
            MessageSection section = ConfigurationManager.GetSection("messages") as MessageSection;

            if (section.Heartbeat.Enabled)
            {
                timer.Interval = 5000;
                timer.Elapsed += (s, e1) =>
                {
                    CheckConnectAlive(section.Heartbeat.Timeout);
                };
                timer.Start();
            }
        }

        private void CheckConnectAlive(int timeout)
        {
            if (m_mainConnection.Count > 0)
            {
                try
                {
                    foreach (var item in m_mainConnection)
                    {
                        if ((DateTime.UtcNow - item.Value.LatestActiveTime).Seconds > timeout)
                        {
                            LogConstant.logger.Print("[CheckConnectAlive 心跳包超时]");
                            Discard(item.Key);
                        }
                    }
                }
                catch { }
            }
        }


        /// <summary>
        /// 获取实例
        /// </summary>
        /// <returns></returns>
        public static HxTcpHandler GetInstance()
        {
            if (m_instance == null)
                m_instance = new HxTcpHandler();

            return HxTcpHandler.m_instance;
        }

        /// <summary>
        /// 当前是否有客户端连接
        /// </summary>
        public bool isConnected { set; get; }

        /// <summary>
        /// 连接ID
        /// </summary>
        
        public bool Contains(long ConnectionID)
        {
            return this.m_mainConnection.ContainsKey(ConnectionID);
        }
        
        /// <summary>
        /// 连接地址
        /// </summary>
        public string Address(long id)
        {
            return this.m_mainConnection[id].RemoteEndPoint.ToString();
        }

        /// <summary>
        /// 保持一个新的连接
        /// </summary>
        /// <param name="connection"></param>
        public void Hold(IConnection connection)
        {
            this.m_mainConnection.Add(connection.ConnectionID, connection);
            this.m_mainConnection[connection.ConnectionID].BeginReceive();
            //UpdateLocalCache();
        }

        private void UpdateLocalCache()
        {
            string remoteEPs = "";
            foreach(IConnection conns in this.m_mainConnection.Values)
            {
                remoteEPs += conns.RemoteEndPoint + "\r\n";
            }
            FileStream fs = new FileStream(Path.Combine(appPath, "biosen_conns.dat"), FileMode.Create);
            StreamWriter sw = new StreamWriter(fs);
            sw.Write(remoteEPs);
            sw.Flush();
            sw.Close();
            fs.Close();
        }

        /// <summary>
        /// 断开时丢弃当前连接
        /// </summary>
        public void Discard(long id)
        {
            this.m_mainConnection[id].BeginDisconnect();
            while (this.m_mainConnection[id].Active)
            {
                System.Threading.Thread.Sleep(200);
            }
            this.m_mainConnection.Remove(id);
            //UpdateLocalCache();
        }

        public static bool Empty()
        {
            return m_instance.m_mainConnection.Count == 0;
        }

        public static void ReplyHeartBeatMessage(HxMessage message, int From = 0, int simulate=0)
        {
            message.Connected = simulate;
            foreach (var conn in m_instance.m_mainConnection)
                if (From == 0 || From.Equals(conn.Value.LocalEndPoint.Port))
                    message.Heartbeat(conn.Value);
        }
        public static void ReplyHeartBeatGWMessage(HxMessage message, int From = 0)
        {
            foreach (var conn in m_instance.m_mainConnection)
                if (From == 0 || From.Equals(conn.Value.LocalEndPoint.Port))
                    message.HeartbeatGW(conn.Value);
        }

        public static void ReplyAckMessage(HxMessage message, int From = 0)
        {
            foreach (var conn in m_instance.m_mainConnection)
            {
                if (From == 0 || From == conn.Value.LocalEndPoint.Port)
                {
                    LogConstant.logger.Print(string.Format("[Socket][Ack][{1}]回复ACK指令给{0}", conn.Value.RemoteEndPoint, message.MessageID));
                    message.Ack(conn.Value);
                }
            }
        }

        public static void ReplyFinishMessage(HxMessage message, JObject data, int From = 0)
        {
            foreach (var conn in m_instance.m_mainConnection)
            {
                if (From == 0 || From == conn.Value.LocalEndPoint.Port)
                {
                    LogConstant.logger.Print(string.Format("[Socket][Finish][{2}]回复Finish指令给{0}, data={1}", 
                        conn.Value.RemoteEndPoint, data.ToString(), message.MessageID));
                    message.Finish(conn.Value, data);
                }
            }
        }

        public static void ReplyFailedMessage(HxMessage message, JObject data, string error_code, string error_text, int dealwithtype=0, int troubleshoot=7, int From = 0)
        {
            foreach (var conn in m_instance.m_mainConnection)
            {
                if (From == 0 || From == conn.Value.LocalEndPoint.Port)
                {
                    LogConstant.logger.Print(string.Format("[Socket][Failed][{4}]回复Failed指令给{0}, data={1}, error_code={2}, error_text={3}", 
                        conn.Value.RemoteEndPoint, data, error_code, error_text, message.MessageID));
                    message.Failed(conn.Value, data, error_code, error_text, dealwithtype, troubleshoot);
                }
            }
        }

        public static void ReplyErrorMessage(HxMessage message, JObject data, string error_code, string error_text, int dealwithtype = 0, int troubleshoot=7, int From = 0)
        {
            foreach (var conn in m_instance.m_mainConnection)
            {
                if (From == 0 || From == conn.Value.LocalEndPoint.Port)
                {
                    LogConstant.logger.Print(string.Format("[Socket][Error][{4}]回复Error指令给{0}, data={1}, error_code={2}, error_text={3}", 
                        conn.Value.RemoteEndPoint, data, error_code, error_text, message.MessageID));
                    message.Error(conn.Value, data, error_code, error_text, dealwithtype, troubleshoot);
                }
            }
        }
    }

    public class BiosenSocketService : AbsSocketService<HxMessage>
    {
        /// <summary>
        /// Tcp连接管理
        /// </summary>
        private HxTcpHandler m_mainTcpListener = HxTcpHandler.GetInstance();
        //private IMessageQueueHandler m_handleMQ;
        private IMessageDispatch m_msgDispatch = MessageDispatch.GetInstance();
        private string hbLogs = "false";
        private bool isConnected = false;

        public BiosenSocketService() : base()
        {
            hbLogs = ConfigurationManager.AppSettings.Get("HBLogs");
            //string mq = ConfigurationManager.ConnectionStrings["MessageQueue"].ConnectionString;
            //if (mq.ToLower().Equals("redis"))
            //{
            //    m_handleMQ = RedisQueueHandler.GetInstance();
            //}
        }

        /// <summary>
        /// 连接函数
        /// </summary>
        /// <param name="connection"></param>
        public override void OnConnected(IConnection connection)
        {
            base.OnConnected(connection);
            LogConstant.logger.Print("[Socket][Connection]检测到来自" + connection.RemoteEndPoint.ToString() + "的远程连接");

            try
            {
                this.m_mainTcpListener.Hold(connection);
                LogConstant.logger.Print("[Socket][Connection]已连接" + connection.RemoteEndPoint.Address);
                m_msgDispatch.OnConnect(true);
                isConnected = true;
            }
            catch (Exception ex)
            {
                LogConstant.logger.Print("[Socket][Exception]" + ex.ToString());
            }
        }

        /// <summary>
        /// 当连接断开时会调用此方法
        /// </summary>
        /// <param name="connection"></param>
        /// <param name="ex"></param>
        public override void OnDisconnected(IConnection connection, Exception ex)
        {
            base.OnDisconnected(connection, ex);
            try
            {
                if (this.m_mainTcpListener.Contains(connection.ConnectionID))
                {
                    LogConstant.logger.Print("[Socket][Connection]即将断开连接: " + connection.RemoteEndPoint.ToString() +
                        " ConnectionID = " + connection.ConnectionID.ToString());
                    this.m_mainTcpListener.Discard(connection.ConnectionID);
                    LogConstant.logger.Print("[Socket][Connection]已断开与" + connection.RemoteEndPoint.ToString() + "的远程连接");

                    m_msgDispatch.OnConnect(false);
                    isConnected = false;

                }
            }
            catch (Exception e)
            {
                LogConstant.logger.Print("[Socket][Exception]" + e.ToString());
            }
        }
        

        /// <summary>
        /// 接收函数
        /// </summary>
        /// <param name="connection"></param>
        /// <param name="message"></param>
        /// 
        public override void OnReceived(IConnection connection, HxMessage message)
        {
            try
            {
                base.OnReceived(connection, message);
                if (message.MessageType == HxMessage.MESSAGE_TYPE_HEARTBEAT)
                {
                    //LogConstant.logger.Print(string.Format("[Socket][HeartBeat][{0}]收到来自{1}的心跳消息", message.MessageID, connection.RemoteEndPoint));
                    HxTcpHandler.ReplyHeartBeatMessage(message, connection.LocalEndPoint.Port);
                    if(!isConnected)
                    {
                        m_msgDispatch.OnConnect(true);
                        isConnected = true;
                    }
                }
                else
                {
                    if (message.MessageType == HxMessage.MESSAGE_TYPE_HEARTBEAT)
                    {
                        if(!string.IsNullOrEmpty(hbLogs) && hbLogs == "true")
                            LogConstant.logger.Print(string.Format("[Socket][Instruction][{0}]收到来自{1}的心跳包: {2}", message.MessageID, connection.RemoteEndPoint, message.OriginJSON));
                    }
                    else
                    {
                        LogConstant.logger.Print(string.Format("[Socket][Instruction][{0}]收到来自{1}指令消息: {2}", message.MessageID, connection.RemoteEndPoint, message.OriginJSON));
                    }
                    // 向消息队列推送请求
                    //m_handleMQ.PushMessage(message, connection.LocalEndPoint.Port);
                    m_msgDispatch.Parse(message);
                }
            }
            catch (System.Exception ex)
            {
                LogConstant.logger.Print("[Exception]" + ex.ToString());
            }

        }

        /// <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("[Socket][Error]接收消息错误: " + ex.ToString());
        }
    }
}