using OnlineStore;
using OnlineStore.Common;
using OnlineStore.LoadCSVLibrary;
using System;
using System.Collections.Concurrent;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading;
using System.Threading.Tasks;

namespace DeviceLibrary
{
    class ServerCommunication :IDisposable
    {
        volatile StoreStatus _storeStatus = StoreStatus.Debugging;
        public delegate bool InStoreInfoDelegate(JobInfo jobInfo, bool ng, string msg);
        public event InStoreInfoDelegate InStoreEvent;
        public delegate void OutStoreInfoDelegate(JobInfo jobInfo);
        public event OutStoreInfoDelegate OutStoreEvent;
        public StoreStatus storeStatus {
            get => _storeStatus;
            set {
                if (_storeStatus!= value)
                    LogUtil.info($"set storeStatus to {value}");
                _storeStatus = value;
            }
        }

        public StoreMachine Machine { get; }

        static string server = Setting_Init.Device_Server_Address;
        string CID;
        int StoreID = 1;
        string StoreName="";
        
        string WarnMsg = "";
        private System.Timers.Timer serverConnectTimer = new System.Timers.Timer();

        object serverclock = new object();
        public ServerCommunication(StoreMachine machine) {
            Machine = machine;
            CID = ConfigHelper.Config.Get($"Device_{Machine.MachineSide}_CID", "01");
            serverConnectTimer.Interval = 1000;
            serverConnectTimer.AutoReset = true;
            serverConnectTimer.Enabled = true;
            serverConnectTimer.Elapsed += ServerConnectTimer_Elapsed;
            GC.KeepAlive(serverConnectTimer);
            LogUtil.info($"server:{server},cid:{CID}");
            
        }

        private void ServerConnectTimer_Elapsed(object sender, System.Timers.ElapsedEventArgs e)
        {
            try
            {
                if (Machine.runStatus!= RunStatus.Stop)
                    ProcessMsg(Machine.Msg.msg);
                SendLineStatus();
            }
            catch (Exception ex)
            {
                LogUtil.info($"ServerConnectTimer_Elapsed:{ex}");
            }
            finally {
                //Monitor.Exit(serverConnectTimer);
            }
        }
        public void ProcessMsg(List<Msg> msg) {
            WarnMsg = string.Join(",", msg.Select(x =>
            {
                if (x.msgLevel == MsgLevel.warning || x.msgLevel == MsgLevel.alarm)
                {
                    return x.msgtxt;
                }
                return null;
            }
            ).Where(x=>!string.IsNullOrEmpty(x)));
        }
        public void SendInStoreRequest(string[] codelist, ReelParam reel,bool printlog=false) {

            if (Machine.AutoInOutTestMode)
                return;
            lock (serverclock)
            {
                var code = ProcessCode(codelist, reel.PlateW, reel.PlateH);
                Operation operation = getLineBoxStatus();
                operation.op = 1;
                operation.data = new Dictionary<string, string>() { { "code", code }, { "boxId", StoreID.ToString() }, { "doorReelSignal", "1" } };

                if (reel.PlateH==100 && Setting_Init.Device_SingleInSingleOut)
                {
                    //singleIn   单盘入库
                    operation.data.Add("singleIn", "true");
                }
                else
                {
                    operation.data.Add("singleIn", "false");
                }
                Operation resultOperation = HttpHelper.Post(GetPostApi(), operation, 15000, printlog);
                if (resultOperation==null || operation.seq != resultOperation.seq)
                {
                    Thread.Sleep(1000);
                    SendInStoreRequest(codelist, reel, printlog);
                    return;
                }
                ResultProcess(resultOperation);
            }
        }
        public bool SendStoreState(string posid, StoreStatus storeStatus)
        {
            lock (serverclock)
            {
                Operation operation = getLineBoxStatus();
                if (!string.IsNullOrEmpty(posid))
                    operation.boxStatus[StoreID].data.Add(ParamDefine.posId, posid);
                
                operation.boxStatus[StoreID].status = (int)storeStatus;

                LogUtil.info(JsonHelper.SerializeObject(operation));
                if (Machine.AutoInOutTestMode)
                    return true;
                Operation resultOperation = HttpHelper.Post(GetPostApi(), operation, 15000);

                if (resultOperation == null)
                {
                    LogUtil.info($"SendStoreState error,posid:{posid}, storeStatus:{storeStatus}");
                    return false;
                }
                if (operation.seq != resultOperation.seq) {
                    LogUtil.info($"SendStoreState seq error,posid:{posid}, storeStatus:{storeStatus}");
                    return false;
                }

                LogUtil.info($"SendStoreState success,posid:{posid}, storeStatus:{storeStatus}");
                ResultProcess(resultOperation);

                if (storeStatus == StoreStatus.OutStoreEnd ||
                    storeStatus == StoreStatus.OutStoreBoxEnd ||
                    storeStatus == StoreStatus.InStoreEnd)
                {
                    this.storeStatus = StoreStatus.StoreOnline;
                }
                
            }
            return true;
        }
        public string spiltStr = "##";
        private string ProcessCode(string[] codeList,int reelw,int reelh)
        {
            string message = "";

            //= 7x12 = CODE  
            foreach (string str in codeList)
            {
                string code = str.Replace("\r","");
                code = code.Replace("\n","");
                //根据二维码开头获取固定尺寸
                string codeSize = $"{reelw}x{reelh}";
                message = message + "=" + "1+0x0-" + codeSize + "=" + code + spiltStr;

            }
            return message;
        }
        /// <summary>
        /// 获取整个料仓的状态
        /// </summary>
        Operation getLineBoxStatus()
        {
            //构建发送给服务器的对象
            Operation lineOperation = new Operation();
            lineOperation.msg = "";
            lineOperation.alarmList = new List<AlarmInfo>();
            lineOperation.cid = CID;
            lineOperation.seq = ConfigAppSettings.nextSeq();
            lineOperation.status = 1;

            lineOperation.status = (int)storeStatus;

            //判断如果是等待料盘拿走超时，状态改为4Warning
            //if (alarmType.Equals(StoreAlarmType.IoSingleTimeOut) && StoreMove.MoveType.Equals(StoreMoveType.OutStore))
            //{
            //    if (StoreMove.MoveStep.Equals(StoreMoveStep.SO_15_WaitTake) || StoreMove.MoveStep.Equals(StoreMoveStep.SO_16_CheckIsTake))
            //    {
            //        lineOperation.status = (int)StoreStatus.Warning;
            //    }
            //}

            BoxStatus boxStatus = new BoxStatus();
            boxStatus.boxId = StoreID;
            boxStatus.humidity = HumitureController.LastData.Humidity.ToString();
            boxStatus.temperature = HumitureController.LastData.Temperate.ToString();
            //状态
            boxStatus.status = (int)storeStatus;


            string sendmsg = "";

            if (commandResultMsg.Count() > 0)
            {
                if (commandResultMsg.TryDequeue(out string msg))
                {
                    sendmsg = msg.Trim().Trim(',');
                }
            }
            else if (!string.IsNullOrEmpty(WarnMsg))
            {
                sendmsg = string.Join(",", new string[] { WarnMsg });
            }
            else if (Machine.runStatus== RunStatus.Stop){
                sendmsg = crc.GetString("Res0121","设备未启动");
            }

            lineOperation.msg = sendmsg;
            lineOperation.msg = lineOperation.msg.Trim().Trim(',');
            boxStatus.msg = lineOperation.msg;
            lineOperation.msgEn = lineOperation.msg;
            lineOperation.msgJp = lineOperation.msg;


            lineOperation.boxStatus.Add(StoreID, boxStatus);
            return lineOperation;
        }
        private static string api_communication = "service/store/communication";    //流水线状态通信接口
        public static string GetPostApi()
        {
            var host = server;
            if (!host.StartsWith("http://"))
            {
                host = "http://" + host;
            }
            if (!host.EndsWith("/"))
            {
                host = host + "/";
            }
            return host + api_communication;
        }
        int getthtime = 0;
        int laststatus = 0;
        public void SendLineStatus()
        {
            if (RobotManage.InoutDebugMode)
                return;

            lock (serverclock)
            {
                bool printlog = false;
                DateTime time = DateTime.Now;
                //构建发送给服务器的对象
                Operation lineOperation = getLineBoxStatus();
                //如果还没湿度范围，先获取
                if (getthtime < 3)
                {
                    if (Max_Humidity <= 0 || (Max_Temperature <= 0))
                    {
                        lineOperation.op = 5;
                        LogUtil.info(StoreName + "没有湿度预警范围，需要从服务器获取，发送OP=" + lineOperation.op);
                        getthtime++;
                    }
                }

                if (lineOperation.status != laststatus) {

                    laststatus = lineOperation.status;
                    printlog = true;
                }

                Operation resultOperation = HttpHelper.Post(GetPostApi(), lineOperation,700, printlog);
                if (resultOperation != null)
                    getthtime = 0;
                //LogUtil.info(JsonHelper.SerializeObject(resultOperation.data));
                ResultProcess(resultOperation);
                TimeSpan span = DateTime.Now - time;
                if (span.TotalMilliseconds > 700)
                {
                //    LogUtil.info(StoreName + "TimerProcess[" + span.TotalMilliseconds + "]");
                }
            }
        }
        public int queueTaskCount=-1;
        ConcurrentQueue<string> commandResultMsg = new ConcurrentQueue<string>();
        void ResultProcess(Operation resultOperation)
        {
            //发送状态信息到服务器 
            if (resultOperation == null)
            {
                //判断服务端是否返回出库操作
                return;
            }

            if (resultOperation.op.Equals(1))
            {
                var barcode = "";
                if (resultOperation.data.ContainsKey("code"))
                    barcode = resultOperation.data["code"];
                ReviceInStoreProcess(barcode, resultOperation);
            }
            else if (resultOperation.op.Equals(2))
            {
                ReviceOutStoreProcess(resultOperation);
            }
            else if (resultOperation.op.Equals(5))
            {
                //ProcessHumidityCMD(resultOperation);
            }
            ProcessHumidityCMD(resultOperation);
            if (resultOperation.data != null)
            {
                string result = "";
                Dictionary<string, string> dataMap = resultOperation.data;

                if (dataMap.ContainsKey(ParamDefine.queueTaskCount))
                {
                    var s = dataMap[ParamDefine.queueTaskCount];
                    if (int.TryParse(s, out int c))
                    {
                        queueTaskCount = c;
                    }
                    else
                    {
                        queueTaskCount = -1;
                    }
                }


            }



        }

        /// <summary>
        /// 处理服务器入库库位消息
        /// </summary>
        /// <param name="message"></param>
        /// <param name="resultOperation"></param>
        private void ReviceInStoreProcess(string message, Operation resultOperation)
        {
            Dictionary<string, string> data = resultOperation.data;
            if (data != null && data.ContainsKey(ParamDefine.posId) && data.ContainsKey(ParamDefine.plateH) && data.ContainsKey(ParamDefine.plateW))
            {
                //服务器返回时有：posId库位编号，plateW:料盘宽度,plateH：料盘高度，
                //postId格式BoxId#位置
                string posId = data[ParamDefine.posId];
                int.TryParse(data[ParamDefine.plateW], out int plateW);
                int.TryParse(data[ParamDefine.plateH], out int plateH);
                //string[] posArray = posId.Split('#');
                //if (!(posArray.Length == 2))
                //{
                //    WarnMsg = StoreName + "入库库位格式错误：二维码【" + message + "】库位【" + posId + "】";
                //    //SetWarnMsg(ResourceControl.InStoreError, message, posId);
                //    LogUtil.error("服务器反馈   入库库位格式错误：二维码【" + message + "】库位【" + posId + "】");
                //    return;
                //}

                //int storeId = int.Parse(posArray[0]);
                //根据发送的posId获取位置列表
                //ACStorePosition position = Machine.StorePosition[posId];
                if (!Machine.StorePosition.TryGetValue(posId, out ACStorePosition position))
                {
                    //出入库没有找到服务器发送的库位，需要打印日志方便查询原因
                    //SetWarnMsg(ResourceControl.InStoreNoPosition, message, posId);
                    WarnMsg = crc.GetString("Res0122","入库未找到库位：") + posId;//0505
                    LogUtil.info("收到服务器入库命令：入库未找到库位：二维码【" + message + "】库位【" + posId + "】");
                    return;
                }
                //TODO:判断BOX是否处于可以入库状态，如果调试或急停中，需要返回给服务器；

                if (plateH > 56)
                    plateH = 56;
                JobInfo inStoreJob = new JobInfo(message, posId, plateW, plateH);
                if (InStoreEvent.Invoke(inStoreJob, false, ""))
                {
                    WarnMsg = "";
                    //如果当前正在出入库中，需要记录下来，等待空闲时执行
                    LogUtil.info(StoreName + " 收到服务器入库命令：库位号【" + posId + "】二维码【" + message + "】 开始入库！");
                }
                else
                {
                    SendStoreState("", StoreStatus.InStoreError);
                }
            }
            else if (InStoreEvent.Invoke(null, true, resultOperation.msg))
            {
                SendStoreState("", StoreStatus.InStoreError);                
                LogUtil.info("服务器没有正确返回库位. msg=" + resultOperation.msg);
            }
            else
            {

            }

        }

        public float Max_Humidity;
        public float Max_Temperature;
        /// <summary>
        /// 处理服务器温湿度消息
        /// </summary>
        /// <param name="resultOperation"></param>
        private void ProcessHumidityCMD(Operation resultOperation)
        {
            if (resultOperation.data == null)
                return;
            Dictionary<string, string> data = resultOperation.data;
            if (data.ContainsKey(ParamDefine.maxHumidity) && data.ContainsKey(ParamDefine.maxTemperature))
            {
                string maxHumidity = data[ParamDefine.maxHumidity];
                string maxTemp = data[ParamDefine.maxTemperature];
                LogUtil.info( "收到服务器温湿度预警值：maxHumidity=" + maxHumidity + ",maxTemperature=" + maxTemp);

                try
                {
                    this.Max_Humidity = (float)Convert.ToDouble(maxHumidity);
                    this.Max_Temperature = (float)Convert.ToDouble(maxTemp);
                    LogUtil.info( "保存温湿度预警值：Max_Humidity=" + Max_Humidity + ",Max_Temperature=" + Max_Temperature);
                }
                catch (Exception ex)
                {
                    LogUtil.error("转换温湿度失败：" + ex.ToString());
                }
            }
        }
        /// <summary>
        /// 处理服务器出库任务消息
        /// </summary>
        /// <param name="resultOperation"></param>
        private void ReviceOutStoreProcess(Operation resultOperation)
        {
            DateTime time = DateTime.Now;
            Dictionary<string, string> data = resultOperation.data;
            if (data != null && data.ContainsKey(ParamDefine.posId)
                   && data.ContainsKey(ParamDefine.plateH) && data.ContainsKey(ParamDefine.plateW))
            {
                string posIdStr = data[ParamDefine.posId];
                string plateWStr = data[ParamDefine.plateW];
                string plateHStr = data[ParamDefine.plateH];
                string singleOut = data[ParamDefine.singleOut];

                LogUtil.info("收到服务器出库消息：poaIs=" + posIdStr + ",platew=" + plateWStr + ",plateh=" + plateHStr + ",singleOut=" + singleOut);
                char splitChar = '|';
                string[] posIdArray = posIdStr.Split(splitChar);
                string[] plateWArray = plateWStr.Split(splitChar);
                string[] plateHArray = plateHStr.Split(splitChar);
                string[] singleOutArray = singleOut.Split(splitChar);
                int index = -1;
                foreach (string posId in posIdArray)
                {
                    index++;
                    int.TryParse(plateWArray[index], out int plateW);
                    int.TryParse(plateHArray[index], out int plateH);
                    bool isSingleOut = singleOutArray[index].ToLower().Equals("true");

                    //根据发送的posId获取位置列表
                    if (!Machine.StorePosition.TryGetValue(posId, out ACStorePosition position))
                    {
                        //出入库没有找到服务器发送的库位，需要打印日志方便查询原因
                        WarnMsg = StoreName + "出库未找库位：【" + posId + "】";
                        LogUtil.error( "收到服务器出库命令：未找到【" + posId + "】的库位信息");
                        continue;
                    }
                    else
                    {
                        JobInfo outStoreJob = new JobInfo("", posId, plateW, plateH);
                        OutStoreEvent.Invoke(outStoreJob);
                    }
                }
                TimeSpan span = DateTime.Now - time;
                if (span.TotalMilliseconds > 100)
                {
                    LogUtil.info(StoreName + "执行 ReviceOutStoreProcess 共处理了【" + span.TotalMilliseconds + "】毫秒");
                }
            }
        }

        private static string Addr_cancelPutInTask = "/service/store/cancelPutInTask";
        public string cancelPutInTask(string deviceName, string barcode)
        {
            string msg = "";
            try
            {

                Dictionary<string, string> paramMap = new Dictionary<string, string>();
                paramMap.Add("barcode", barcode);

                string server = GetAddr(Addr_cancelPutInTask, paramMap);
                DateTime startTime = DateTime.Now;
                string resultStr = HttpHelper.Post(server, "");
                LogUtil.info(deviceName + "cancelPutInTask    " + FormUtil.GetSpanStr(DateTime.Now - startTime) + "  【" + server + "】【" + resultStr + "】");

                ResultData data = JsonHelper.DeserializeJsonToObject<ResultData>(resultStr);

                if (data == null)
                {
                    return msg = deviceName + " cancelPutInTask【 " + barcode + "】 没有收到服务器反馈";
                }
                else if (data.code.Equals(0).Equals(false))
                {
                    return msg = deviceName + " cancelPutInTask【 " + barcode + "】   ：" + data.msg;
                }

                return "";
            }
            catch (Exception ex)
            {
                LogUtil.error(deviceName + " " + ex.ToString());
            }
            return msg;
        }
        private static string GetAddr(string addr, Dictionary<string, string> paramsMap)
        {
            if (server.EndsWith("/"))
            {
                server = server.Substring(0, server.Length - 1);
            }
            string path = server + addr.Trim() + "?";
            foreach (string paramName in paramsMap.Keys)
            {
                string par = System.Web.HttpUtility.UrlEncode(paramsMap[paramName], System.Text.Encoding.UTF8);
                path += paramName + "=" + par + "&";
            }
            path = path.Substring(0, path.Length - 1);
            return path;
        }

        public void Dispose()
        {
            serverConnectTimer.Enabled = false;
            serverConnectTimer.Dispose();
        }
    }
    public class ResultData
    {
        //{"code":0,"msg":"ok","data":"7"} 
        public int code { get; set; }

        public string msg { get; set; }

        public Dictionary<string, string> data { get; set; }
    }
    /// <summary>
    ///1=设备联机（正常就绪）（入库后，BOX恢复原始状态）（出库后，移载装置恢复原始状态），
    ///2=急停，3=故障，4=警告，5=调试
    /// 6=入库执行中,7=入仓完成，8=入仓失败
    /// 9=出库执行，10=出仓完成，11=出库失败
    /// </summary>
    public enum StoreStatus
    {
        None = 0,
        /// <summary>
        /// 1=设备联机（正常就绪）（入库后，BOX恢复原始状态）（出库后，移载装置恢复原始状态），
        /// </summary>
        StoreOnline = 1,
        /// <summary>
        ///2=急停中
        /// </summary>
        SuddenStop = 2,
        /// <summary>
        /// 3=故障中
        /// </summary>
        InTrouble = 3,
        /// <summary>
        /// 4=警告
        /// </summary>
        Warning = 4,
        /// <summary>
        /// 5=设备调试中 
        /// </summary>
        Debugging = 5,
        /// <summary>
        /// 6=入库执行中 
        /// </summary>
        InStoreExecute = 6,
        /// <summary>
        /// 7= 入仓位完成（料仓Box把料盘放入对应的库位中，装置还未恢复原始状态） 
        /// </summary>
        InStoreEnd = 7,
        /// <summary>
        /// 8=入库失败
        /// </summary>
        InStoreFaild = 8,
        /// <summary>
        /// 9=出库执行中",
        /// </summary>
        OutStoreExecute = 9,
        /// <summary>
        ///10= 出仓位完成（ 料盘已经放到Box门口） 
        /// </summary>
        OutStoreBoxEnd = 10,
        /// <summary>
        ///11=出库完成
        /// </summary>
        OutStoreEnd = 11,
        /// <summary>
        /// 12=移栽出库移栽过程中（移栽完成后变成OnLine）
        /// </summary>
        OutMoveExecute = 12,
        /// <summary>
        /// 重置中（原点返回和重置都发此状态）
        /// </summary>
        ResetMove = 13,
        /// <summary>
        /// 扫码入库失败
        /// </summary>
        InStoreError = 14,
        
    }
}