using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading;
using System.Threading.Tasks;
using System.Timers;

namespace LineSoldering.Common
{
    /// <summary>
    /// 与Mes连接类
    /// </summary>
    public class MesUtil
    {
        /// <summary>
        /// 是否需要连接MES
        /// </summary>
        public static bool NeedConnect = ConfigAppSettings.GetBoolValue(Setting_Init.Mes_IsConnect);
        public class MES_RESULT_CODE
        {
            /// <summary>
            /// 正常完成
            /// </summary>
            public static  int OK = 0;
            /// <summary>
            /// 焊点未达到要求
            /// </summary>
            public static int Solder_Error = 201;
            /// <summary>
            /// 铆接压⼒未达到要求
            /// </summary>
            public static int Rivet_Error = 202;
            /// <summary>
            /// 锁付扭距未达到要求
            /// </summary>
            public static int Screw_Error = 203;

        }
        //Keep Alive 间隔
        private static int ALIVE_INTERVAL = 60000;

        /// <summary>
        /// 接收到MES反馈的二维码结果
        /// </summary>
        /// <param name="code">二维码</param>
        /// <param name="result">为空时表示OK，其他情况为异常（可直接展示到界面上）,焊接时所有字段都有值，铆接和锁付时只使用code1</param>
        public delegate void CodeResult(string code1, string result1, string code2, string result2);
        private static event CodeResult OnCodeResult;

        public static void SolderInit(string ip, int port)
        {
            connect(ip, port, STEP_SOLDER);
        }

        public static void RivetInit(string ip, int port)
        {
            connect(ip, port, STEP_RIVET);
        }

        public static void ScrewInit(string ip, int port)
        {
            connect(ip, port, STEP_SCREW);
        }

        public static void Close()
        {
            timer.Enabled = false;
            isStop = true;
            if (mesClient != null)
            {
                //关闭socket
                mesClient.close();
            }
        }

        /// <summary>
        /// 铆压工艺结果上传
        /// </summary>
        /// <param name="code">二维码</param>
        /// <param name="result">结果，见MesUtil.MES_RESULT_CODE</param>
        /// <param name="pressure">扭距值</param>
        public static bool UploadScrewResult(string code, RESULT result, List<double> torques)
        {
            int toMesResult = MES_RESULT_CODE.Screw_Error;
            if (RESULT.OK == result)
            {
                toMesResult = MES_RESULT_CODE.OK;
            }
            OpData opData = getOpData(code, toMesResult);
            int i = 1;
            foreach(var torque in torques)
            {
                opData.addData("TORQUE_" + i, torque);
                i++;
            }
            return sendData(opData);
        }


        /// <summary>
        /// 铆压工艺结果上传
        /// </summary>
        /// <param name="code">二维码</param>
        /// <param name="result">结果，见MesUtil.MES_RESULT_CODE</param>
        /// <param name="pressure">压力值</param>
        public static bool UploadRivetResult(string code, int result, double pressure)
        {
            OpData opData = getOpData(code, result);
            opData.addData("PRESSURE", pressure);
            return sendData(opData);
        }
        /// <summary>
        /// 焊接工艺结果上传
        /// </summary>
        /// <param name="code">二维码</param>
        /// <param name="result">结果，见MesUtil.MES_RESULT_CODE</param>
        public static bool UploadSolderResult(string codeLeft, string codeRight, int result)
        { 
            OpData opData = new OpData();
            opData.seq = NextSeq();
            opData.step = STEP;
            opData.op = OP_RESULT;
            opData.addData("CODE_C", codeLeft);
            opData.addData("CODE_B", codeRight);
            opData.addData("RESULT", result);
            return sendData(opData);
            //OpData opData = getOpData(code,result);
            //return sendData(opData);
        }
        /// <summary>
        /// PCB连接板焊接结果上传
        /// </summary> 
        public static bool UploadPCBResult(string code, int result)
        {
            OpData opData = getOpData(OP_PCB, code, result);
            return sendData(opData);
        }
        /// <summary>
        /// 小弹片焊接结果上传
        /// </summary> 
        public static bool UploadSmallPieceResult(string code, int result)
        {
            OpData opData = getOpData(OP_SmallPiece, code, result);
            return sendData(opData);
        }
        private static OpData getOpData(int op, string code, int result)
        {
            OpData opData = new OpData();
            opData.seq = NextSeq();
            opData.step = STEP;
            opData.op = op;
            opData.addData("CODE", code);
            opData.addData("RESULT", result);
            return opData;
        }

        private static OpData getOpData(string code, int result)
        {
            OpData opData = new OpData();
            opData.seq = NextSeq();
            opData.step = STEP;
            opData.op = OP_RESULT;
            opData.addData("CODE", code);
            opData.addData("RESULT", result);
            return opData;
        }

        /// <summary>
        /// 将二维码发送到MES进行验证(返回结果只表示发送成功与否，具体结果要看回调里面的数据)
        /// </summary>
        /// <param name="code"></param>
        /// <returns></returns>
        public static bool ConfirmCode(string code, CodeResult OnCodeResult)
        {
            if (!NeedConnect)
            {
                OnCodeResult?.Invoke(code, "", "", "");
                return true ;
            }
            MesUtil.OnCodeResult = OnCodeResult;
            OpData opData = new OpData();
            opData.seq = NextSeq();
            opData.step = STEP;
            opData.op = OP_CODE;
            opData.addData("CODE", code); 
            return sendData(opData);
            //OnCodeResult?.Invoke(code, "", "", "");
            //return true;
        }
        /// <summary>
        /// 将二维码发送到MES进行验证(返回结果只表示发送成功与否，具体结果要看回调里面的数据)
        /// </summary>
        /// <param name="code"></param>
        /// <returns></returns>
        public static bool ConfirmSolderCode(string codeLeft, string codeRight, CodeResult OnCodeResult)
        {
            if (!NeedConnect)
            {
                OnCodeResult?.Invoke(codeLeft, "", codeRight, "");
                return true;
            }
            MesUtil.OnCodeResult = OnCodeResult;
            OpData opData = new OpData();
            opData.seq = NextSeq();
            opData.step = STEP;
            opData.op = OP_CODE;
            opData.addData("CODE_C", codeLeft);
            opData.addData("CODE_B", codeRight);
            return sendData(opData);

        }

        private static void OnMessage(string message)
        {
            try
            {
                if (message.Contains("op"))
                {
                    LogUtil.info("MES返回数据：" + message);
                    OpData opData = JsonHelper.DeserializeJsonToObject<OpData>(message);
                    //条码结果返回
                    if (OP_CODE == opData.op)
                    {
                        string code1 = "";
                        string code2 = "";
                        string result1 = "";
                        string result2 = "";
                        foreach (KeyValuePair<string, Object> kv in opData.data)

                        {
                            if (code1 == "")
                            {
                                code1 = kv.Key;
                                result1 = codeToShowStr(kv.Value.ToString());
                            }
                            else if (code2 == "")
                            {
                                code2 = kv.Key;
                                result2 = codeToShowStr(kv.Value.ToString());
                            }
                        }
                        OnCodeResult?.Invoke(code1, result1, code2, result2);
                    }
                    
                }
            }catch(Exception ex)
            {
                LogUtil.error("MES返回结果解析出错：" + message);
            }
        }

        /// <summary>
        /// MES返回码转展示字串
        /// </summary>
        /// <param name="code"></param>
        /// <returns></returns>
        private static string codeToShowStr(string code)
        {
            string showStr = code;
            switch (code)
            {
                case "0":
                    showStr = "";
                    break;
                case "101":
                    showStr = "条码在MES系统中不存在";
                    break;
                case "102":
                    showStr = "未完成焊接工艺";
                    break;
                case "103":
                    showStr = "未完成铆接工艺";
                    break;
                case "104":
                    showStr = "未完成冲压工艺";
                    break;
                case "1001":
                    showStr = "已过站";
                    break;
                case "1002":
                    showStr = "未过站";
                    break;
                case "1003":
                    showStr = "不在此站";
                    break;
                case "1004":
                    showStr = "已组装";
                    break;
                case "1005":
                    showStr = "需要维修";
                    break;
                case "1006":
                    showStr = "已报废";
                    break;
                case "1007":
                    showStr = "产品流程异常";
                    break;
                

            }
            return showStr;
        }

        /// <summary>
        /// ⼯艺流程，1=焊接，2=铆接，3=锁付
        /// </summary>
        private static int STEP_SOLDER = 1;
        private static int STEP_RIVET = 2;
        private static int STEP_SCREW = 3;

        /// <summary>
        /// 操作类型，1=条码合法性验证； 2=操作结果上传
        /// </summary>
        private static int OP_CODE = 1;
        private static int OP_RESULT = 2;
        /// <summary>
        /// PBC连接板焊接结果上传
        /// </summary>
        private static int OP_PCB= 3;
        /// <summary>
        /// 小弹片焊接结果上传
        /// </summary>
        private static int OP_SmallPiece= 4;

        class OpData
        {
            
            public int seq { get; set; }
            public int op { get; set; }
            public int step { get; set; }
            public Dictionary<string,Object> data { get; set; }

            public void addData(string key, Object value)
            {
                if(data == null)
                {
                    data = new Dictionary<string, object>();
                }
                data.Add(key, value);
            }

        }

        private static int nextSeq = 100;

        /// <summary>
        /// 下一个序列号
        /// </summary>
        /// <returns></returns>
        private static int NextSeq()
        {
            nextSeq = nextSeq + 1;
            if (nextSeq >= int.MaxValue)
            {
                nextSeq = 100;
            }
            return nextSeq;
        }

        private static bool sendData(OpData opData)
        {
            if (!NeedConnect)
            {
                return true;
            }
            string json = JsonHelper.SerializeObject(opData);
            LogUtil.info("给MES发送数据：" + json);
            return sendMsg(json);
        }

        private static bool sendMsg(string msg)
        {
            try
            {
                LogUtil.debug("给MES发送数据：" + msg);
                byte[] sendBuffer = new byte[1024];
                sendBuffer = Encoding.UTF8.GetBytes(msg + "\r\n");
                mesClient.send(msg);
                return true;
            }
            catch(Exception ex)
            {
                LogUtil.error("给MES发送数据[" + msg+"]出错"+ ex.Message);
                Task.Factory.StartNew(delegate() { Reconnect(); });
            }
            return false;
        }
        
        private static int lastAliveTime = 0;
        private static void KeepAlive()
        {
            if (mesClient.IsConnected())
            {
                if (lastAliveTime % ALIVE_INTERVAL == 0)
                {
                    sendMsg("STEP:"+STEP);
                }
            }
            lastAliveTime = lastAliveTime + 1000;
            if (lastAliveTime >= int.MaxValue)
            {
                lastAliveTime = 0;
            }
        }
        private static void connect(string ip, int port, int step)
        {
            if(timer!=null&& timer.Enabled)
            {
                //已经初始化，直接返回
                return;
            }

            if (!NeedConnect)
            {
                //不需要连接，直接返回
                LogUtil.info("Mes不需要连接，直接返回");
                return;
            }

            STEP = step;
            IP = ip;
            PORT = port;
            mesClient = new TcpClient();
            mesClient.TimeOutTime = 2000;
            mesClient.connect(ip, port, OnMessage);
            if (!timer.Enabled)
            {
                timer.Interval = 1000;
                timer.Elapsed += TimerElapsed;
                timer.Enabled = true;
            }
        }

        private static void TimerElapsed(object sender, ElapsedEventArgs e)
        {
            KeepAlive();
            if (!mesClient.IsConnected())
            {
                Reconnect();
            }
        }

        //⼯艺流程，1=焊接，2=铆接，3=锁付
        private static int STEP = 0;

        private static string IP;

        private static int PORT;

        private static System.Timers.Timer timer = new System.Timers.Timer();

        private static TcpClient mesClient;
        /// <summary>
        /// 停止连接，并且不再重连
        /// </summary>
        private static bool isStop = false;


        /// <summary>
        /// 是否正在连接
        /// </summary>
        private static bool IsConnecting = false;
        /// <summary>
        /// 断线重连函数
        /// </summary>
        private static void Reconnect()
        {
            if (isStop || IsConnecting)
            {
                return;
            }
            IsConnecting = true;
            LogUtil.debug("3秒后，关闭连接，进行重连");
            Thread.Sleep(3000);
            //关闭socket
            mesClient.close();
            //创建socket
            connect(IP, PORT, STEP);
            IsConnecting = false;
        }

    }
}