using HalconDotNet;
using Newtonsoft.Json;
using Newtonsoft.Json.Converters;
using Rs.Controls;
using Rs.Framework;
using Rs.MotionPlat.Commom;
using Rs.MotionPlat.Flow.SubFlow;
using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Text;
using System.Threading;
using System.Threading.Tasks;
using static Rs.MotionPlat.Commom.SchedulingAlarms;
using static Rs.MotionPlat.Commom.SchedulingSilo;
using static System.Windows.Forms.AxHost;
using static System.Windows.Forms.VisualStyles.VisualStyleElement;

namespace Rs.MotionPlat.Flow
{
    public class TestCenter
    {
        TcpClientHelper client = new TcpClientHelper("127.0.0.1",2048);
        SchedulingResult schedulResult = new SchedulingResult();
        SchedulingMaterial sm;
        Dictionary<int, AlarmItem> alarmInfos = new Dictionary<int, AlarmItem>();
        public event Action<string> ReciveTaskEvent;
        public event Action<string> ReplayTaskEvent;
        private TestCenter() {
            client.OnConnected += Client_OnConnected;
            client.OnDisconnected += Client_OnDisconnected;
            client.DataRecived += Client_DataRecived;
        }


        int slotIndex = 0;

        private void SwitchStatus(SchedulingStatusInfo ssi)
        {
            switch (ssi.Type)
            {
                case SchedulingStatusInfo.InfoType.OneCycle:

                    break;
                case SchedulingStatusInfo.InfoType.DisableFixtureVacuumCheck:
                    GlobalVar.DisableFixtureVacuumCheck = bool.Parse(ssi.Info);
                    break;
                case SchedulingStatusInfo.InfoType.State:
                    break;
                case SchedulingStatusInfo.InfoType.RunStatus:
                    if(ssi.Info== "Started")
                    {
                        MachineManage.Instance.SetCenterMachineStatus(ERunStatus.Started);
                        MachineManage.Instance.SetLoadUnloadStatus(ERunState.Interrupt);
                        MessageQueue.Instance.Insert("收到中控启动命令");
                        Ops.Start();
                    }
                    else if(ssi.Info== "Stopped")
                    {
                        MessageQueue.Instance.Insert("收到中控停止命令");
                        Ops.Stop();
                    }
                    //WorkEnvironment.Instance.Ready();
                    //Task.Run(() => {
                    //    if (WorkEnvironment.Instance.EnvReadyOkEvent.WaitOne())
                    //    {
                    //        WorkFlow.Instance.Start();
                    //        TurnoverFlow.Instance.Start();
                    //        MachineManage.Instance.RunState = ERunState.Waiting;
                    //        MachineManage.Instance.MachineStatus = EMachineStatus.Working;
                    //    }
                    //});
                    //MachineManage.Instance.RunStatus = ERunStatus.Started;
                    //MachineManage.Instance.RunState = ERunState.Interrupt;
                    break;
                case SchedulingStatusInfo.InfoType.RunMode://手动自动
                        MachineManage.Instance.RunMode = (ERunMode)Enum.Parse(typeof(ERunMode), ssi.Info.ToString());
                    break;
                case SchedulingStatusInfo.InfoType.InitializeState:
                    if(ssi.Info==EInitializeState.Initializing.ToString()) 
                    {
                        Ops.GoHome();
                        //MonitorSystemButton.Instance.ButtonPressed(ESystemButton.ResetPressed);
                    }
                    break;
                case SchedulingStatusInfo.InfoType.AssignMode:
                    break;
                case SchedulingStatusInfo.InfoType.Temperature:
                    DeviceTemprature.Instance.TargetTemprature = double.Parse(ssi.Info);
                    break;
                case SchedulingStatusInfo.InfoType.AirPressure:
                    break;
            }
            client.Send(ssi.ToString());
            LogHelper.Info(" <<< " + ssi.ToString());
        }
        private void Client_DataRecived(System.Net.Sockets.Socket socket, byte[] data)
        {
            string msg = Encoding.UTF8.GetString(data);
            try
            {
                foreach (string json in Scheduling.GetJsons(msg))
                {
                    Scheduling schedule = JsonConvert.DeserializeObject<Scheduling>(json);
                    EInstruction eInstructioneInstruction = schedule.Instruction;
                    if (eInstructioneInstruction != EInstruction.InquireStatus)
                    {
                        LogHelper.Debug(" >>> " + json);
                    }
                    switch (eInstructioneInstruction)
                    {
                        case EInstruction.Cleanout:
                            MachineManage.Instance.SetLoadUnloadStatus(ERunState.Busying);
                            ReportToTestCenter(schedule);
                            Thread.Sleep(100);
                            //在这里启动
                            GlobalVar.CleanOut = true;
                            Ops.Start();
                            CleanOutFlow.Instance.CleanOut();
                            break;
                        case EInstruction.TestFinished:
                            MessageQueue.Instance.Insert("测试完成:" + JsonConvert.SerializeObject(schedule, new StringEnumConverter()));
                            ReportToTestCenter(schedule);
                            MachineManage.Instance.TestStatus = ETestStatus.Finished;
                            break;
                        case EInstruction.Rearrange:
                            Rearrange(json);
                            break;
                        case EInstruction.InquireSiloStatus:
                            InquireSiloStatus(json);
                            break;
                        case EInstruction.RequestSwitchTray:
                            RequestSwitchTray(json);
                            break;
                        case EInstruction.InquireConnectionInfo:
                            InquireConnectionInfo(json);
                            break;
                        case EInstruction.LoadAndUnload:
                            LoadAndUnload(json);
                            break;
                        case EInstruction.CancelLoadAndUnload:
                            //schedulResult = new SchedulingResult() { Instruction = EInstruction.CancelLoadAndUnload, State = ERunState.Busying, GroupID = sm.GroupID, TurnoverID = sm.TurnoverID };
                            ReportToTestCenter(schedule);
                            MachineManage.Instance.SetLoadUnloadStatus(ERunState.Waiting);
                            break;
                        case EInstruction.InquireStatus:
                            SchedulingStatusInfo statusInto = JsonConvert.DeserializeObject<SchedulingStatusInfo>(json);
                            switch (statusInto.Type)
                            {
                                case SchedulingStatusInfo.InfoType.State:
                                    statusInto.Info = MachineManage.Instance.GetLoadUnloadStatus().ToString();// ERunState.Waiting.ToString();
                                    break;
                                case SchedulingStatusInfo.InfoType.RunStatus:
                                    statusInto.Info = MachineManage.Instance.GetCenterRunStatus().ToString();// ERunStatus.Started.ToString();
                                    break;
                                case SchedulingStatusInfo.InfoType.RunMode:
                                    statusInto.Info = MachineManage.Instance.RunMode.ToString();
                                    break;
                                case SchedulingStatusInfo.InfoType.InitializeState:
                                    statusInto.Info = MachineManage.Instance.InitializeState.ToString();// EInitializeState.Initialized.ToString();
                                    break;
                                case SchedulingStatusInfo.InfoType.AssignMode:
                                    statusInto.Info = EAssignMode.Normal.ToString();
                                    break;
                                case SchedulingStatusInfo.InfoType.TesterState:
                                    statusInto.Info = JsonConvert.SerializeObject(MachineManage.Instance.GetTesterInfo());//.ToString();
                                    break;
                                case SchedulingStatusInfo.InfoType.Temperature:
                                    statusInto.Info = DeviceTemprature.Instance.CurTemprature.ToString();
                                    break;
                                default:
                                    break;
                            }
                            ReportToTestCenter(statusInto);
                            //LogHelper.Debug(statusInto.ToString());
                            ReplayTaskEvent?.Invoke(statusInto.ToString());
                            break;
                        case EInstruction.SwitchStatus:
                            SchedulingStatusInfo switchStatus = JsonConvert.DeserializeObject<SchedulingStatusInfo>(msg);
                            SwitchStatus(switchStatus);
                            //MachineManage.Instance.MachineStatus= EMachineStatus.
                            //if (ss.TryConvertInfoTo<ERunMode>(out ERunMode runMode))
                            //    MachineManage.Instance.RunMode = runMode;
                            //client.Send(ss.ToString());
                            //ReplayTaskEvent?.Invoke(ss.ToString());
                            break;
                        case EInstruction.ClearAlarm:
                            break;
                        case EInstruction.GetRecipeList:
                            SchedulingResult sr = JsonConvert.DeserializeObject<SchedulingResult>(msg);
                            sr.Message = "Default";
                            client.Send(sr.ToString());
                            ReplayTaskEvent?.Invoke(sr.ToString());
                            break;
                        case EInstruction.SetRecipe:
                            break;
                        case EInstruction.GetCurrentRecipe:
                            SchedulingResult srcur = JsonConvert.DeserializeObject<SchedulingResult>(msg);
                            srcur.Message = GlobalVar.CurRecipe;
                            client.Send(srcur.ToString());
                            ReplayTaskEvent?.Invoke(srcur.ToString());
                            break;
                        case EInstruction.TurnoverReady:
                            break;
                        case EInstruction.ChangeState:
                            SchedulingResult cs = JsonConvert.DeserializeObject<SchedulingResult>(msg);
                            client.Send(cs.ToString());
                            ReplayTaskEvent?.Invoke(cs.ToString());
                            break;
                        case EInstruction.ShowMessage:
                            break;
                        case EInstruction.CloseMessage:
                            SchedulingMessageBox mbox = JsonConvert.DeserializeObject<SchedulingMessageBox>(json);
                            TestCenterMessageBox.RecivedMsg(mbox);
                            //TestCenterMessageBoxManager.GetMsgbox(mbox.ID)?.Recived(mbox);
                            break;
                        case EInstruction.MachineButtonDown:
                            break;
                        case EInstruction.MachineButtonUp:
                            break;
                        case EInstruction.TrayProductRange:
                            break;
                        case EInstruction.ClearTrayProductRange:
                            schedulResult = JsonConvert.DeserializeObject<SchedulingResult>(msg);
                            client.Send(schedulResult.ToString());
                            ReplayTaskEvent?.Invoke(schedulResult.ToString());
                            break;
                        case EInstruction.BeginSwitchTray:
                            break;
                        case EInstruction.MoveScanner:
                            break;
                        case EInstruction.InquireMoveScannerState:
                            break;
                        case EInstruction.SetAlarms:
                            break;
                        case EInstruction.CancelAlarms:
                            SchedulingAlarms alarms = JsonConvert.DeserializeObject<SchedulingAlarms>(msg);
                            if (alarms != null && alarms.Alarms != null && alarms.Alarms.Count > 0)
                            {
                                foreach (AlarmItem alarm in alarms.Alarms)
                                {
                                    AlarmMessageBox.Close(alarm);
                                    //if (!alarmInfos.ContainsKey(alarm.NO))
                                    //{
                                    //    alarmInfos.Add(alarm.NO, alarm);
                                    //}
                                }
                            }
                            break;
                        case EInstruction.TakingError:
                            break;
                        case EInstruction.CancelTakingError:
                            break;
                        case EInstruction.ScanBarcode:
                            break;
                    }

                }
            }
            catch (Exception ex)
            {
                LogHelper.Debug("receivedata:" + msg);
                LogHelper.Debug("接收数据异常:"+ex.Message);
            }
            //string msg=Encoding.UTF8.GetString(data);
            //LogHelper.TestCenterLog("接收:"+msg);
            //ReciveTaskEvent?.Invoke(msg);

        }


        public AlarmItem? GetAlarm(int no)
        {
            AlarmItem? ret = null;
            if (alarmInfos.ContainsKey(no))
            {
                ret = alarmInfos[no];
                alarmInfos.Remove(no);
            }
            return ret;
        }

        /// <summary>
        /// 重排
        /// </summary>
        /// <param name="json"></param>
        private void Rearrange(string json)
        {
            MachineManage.Instance.SetLoadUnloadStatus(ERunState.Busying);
            SiloRearrange info = JsonConvert.DeserializeObject<SiloRearrange>(json);
            ReportToTestCenter(info);
            Thread.Sleep(200);

            TurnoverInfos tis = new TurnoverInfos();
            tis.GroupID = 0;
            tis.Instruction = EInstruction.RearrangeResult;
            ReportToTestCenter(tis);
            MachineManage.Instance.SetLoadUnloadStatus(ERunState.Waiting);
        }

        private void LoadAndUnload(string json)
        {
            MachineManage.Instance.SetLoadUnloadStatus(ERunState.Busying);
            sm = JsonConvert.DeserializeObject<SchedulingMaterial>(json);
            schedulResult = new SchedulingResult() { Instruction = sm.Instruction, State = ERunState.Busying, GroupID = sm.GroupID, TurnoverID = sm.TurnoverID };
            ReportToTestCenter(schedulResult);
            LoadAndUnloadTask.Instance.AddTask(sm);
        }
        /// <summary>
        /// 查询 状态
        /// </summary>
        /// <param name="json"></param>
        private void InquireConnectionInfo(string json)
        {
            SchedulingConnectionInfo info = JsonConvert.DeserializeObject<SchedulingConnectionInfo>(json);
            info.Type = SchedulingConnectionInfo.EType.Scheduling;
            TestCenter.instance.ReportToTestCenter(info);
        }
        /// <summary>
        /// 查询料仓状态
        /// </summary>
        /// <param name="json"></param>
        private void InquireSiloStatus(string json)
        {
            SchedulingSilo inquireSilo = JsonConvert.DeserializeObject<SchedulingSilo>(json);
            inquireSilo.SiloFloor = 1;
            switch (inquireSilo.SiloType)
            {
                case SchedulingSiloBase.ESiloType.ToBeTested:

                    inquireSilo.SiloStatus = ESiloStatus.Standby;// TranlateSiloStatus(StockManager.Instance.GetStock(ETrayType.Input).Status);
                    break;
                case SchedulingSiloBase.ESiloType.Passed:
                    inquireSilo.SiloStatus = ESiloStatus.Standby; //TranlateSiloStatus(StockManager.Instance.GetStock(ETrayType.Ok).Status);
                    break;
                case SchedulingSiloBase.ESiloType.Failed:
                    inquireSilo.SiloStatus = ESiloStatus.Standby; //TranlateSiloStatus(StockManager.Instance.GetStock(ETrayType.Ng).Status);
                    break;
                case SchedulingSiloBase.ESiloType.Multifunction:
                    inquireSilo.SiloStatus = ESiloStatus.Standby; //TranlateSiloStatus(StockManager.Instance.GetStock(ETrayType.Multi).Status);
                    break;
                case SchedulingSiloBase.ESiloType.EmptyInput:
                    inquireSilo.SiloStatus = ESiloStatus.Standby; //TranlateSiloStatus(StockManager.Instance.GetStock(ETrayType.Empty1).Status);
                    break;
                case SchedulingSiloBase.ESiloType.EmptyOutput:
                    inquireSilo.SiloStatus = ESiloStatus.Standby; //TranlateSiloStatus(StockManager.Instance.GetStock(ETrayType.Empty2).Status);
                    break;
            }
            TestCenter.instance.ReportToTestCenter(inquireSilo);
            //查询料仓状态
        }
        /// <summary>
        /// 请求切盘
        /// </summary>
        private void RequestSwitchTray(string json)
        {
            SchedulingSilo inquireSilo = JsonConvert.DeserializeObject<SchedulingSilo>(json);
            //if(inquireSilo.Orientation== ESwitchOrientation.Recycle)
            //{
            //    switch (inquireSilo.SiloType)
            //    {
            //        case SchedulingSiloBase.ESiloType.ToBeTested:

            //            MessageQueue.Instance.Insert($"{ETrayType.Input}料仓收到切盘命令");
            //            //StockManager.Instance.GetStock(ETrayType.Input).Unload(EStockTrayUnLoadMode.Whole, null);
            //            TakeTrayFlow.Instance.Take(ETrayType.Input, ETrayType.Empty1, () => {
            //                //StockManager.Instance.GetStock(ETrayType.Input).Status = EStockTrayStatus.Unloaded;
            //                StockManager.Instance.GetStock(ETrayType.Input).ChangeStatus(EStockTrayStatus.Unloaded, true);
            //            }, null, () => {
            //                Task.Run(() => {
            //                    StockManager.Instance.GetStock(ETrayType.Empty1).Unload(EStockTrayUnLoadMode.Whole, null);
            //                });
            //            });

            //            break;
            //        case SchedulingSiloBase.ESiloType.Passed:
            //            Task.Run(() => {
            //                MessageQueue.Instance.Insert($"{ETrayType.Ok}料仓收到切盘命令");
            //                StockManager.Instance.GetStock(ETrayType.Ok).Unload(EStockTrayUnLoadMode.Whole, null);
            //            });
            //            break;
            //        case SchedulingSiloBase.ESiloType.Failed:
            //            Task.Run(() => {
            //                MessageQueue.Instance.Insert($"{ETrayType.Ng}料仓收到切盘命令");
            //                StockManager.Instance.GetStock(ETrayType.Ng).Unload(EStockTrayUnLoadMode.Whole, null);
            //            });
            //            break;
            //        case SchedulingSiloBase.ESiloType.Multifunction:
            //            Task.Run(() => {
            //                MessageQueue.Instance.Insert($"{ETrayType.Multi}料仓收到切盘命令");
            //                StockManager.Instance.GetStock(ETrayType.Multi).Unload(EStockTrayUnLoadMode.Whole, null);
            //            });
            //            break;
            //        case SchedulingSiloBase.ESiloType.EmptyInput:
            //            Task.Run(() => {
            //                MessageQueue.Instance.Insert($"{ETrayType.Empty1}料仓收到切盘命令");
            //                StockManager.Instance.GetStock(ETrayType.Empty1).Unload(EStockTrayUnLoadMode.Whole, null);
            //            });
            //            break;
            //        case SchedulingSiloBase.ESiloType.EmptyOutput:
            //            Task.Run(() => {
            //                MessageQueue.Instance.Insert($"{ETrayType.Empty2}料仓收到切盘命令");
            //                StockManager.Instance.GetStock(ETrayType.Empty2).Unload(EStockTrayUnLoadMode.Whole, null);
            //            });
            //            break;
            //    }
            //    ReportToTestCenter(inquireSilo);
            //}
        }

        /// <summary>
        /// 断开连接
        /// </summary>
        /// <param name="obj"></param>
        private void Client_OnDisconnected(System.Net.Sockets.Socket obj)
        {
            MessageQueue.Instance.Insert($"中控断开连接");
        }

        /// <summary>
        /// 连接成功
        /// </summary>
        /// <param name="obj"></param>
        private void Client_OnConnected(System.Net.Sockets.Socket obj)
        {
            MessageQueue.Instance.Insert($"中控连接成功");
        }

        private static TestCenter instance;
        public static TestCenter Instance
        {
            get
            {
                if(instance==null)
                {
                    instance = new TestCenter();
                }
                return instance;
            }
        }

        public void Init()
        { 
            client.Connect();
        }

        public bool LoadResult()
        {
            string content = LoadAndUnloadTask.Instance.GetLoadString();
            return Send(content, Encoding.ASCII) > 0;
        }

        public bool LoadTestLoadResult()
        {
            string content = LoadAndUnloadTask.Instance.GetTestLoadString();
            return Send(content, Encoding.ASCII) > 0;
        }

        public bool LoadTestUnLoadResult()
        {
            string content = LoadAndUnloadTask.Instance.GetTestUnLoadString();
            return Send(content, Encoding.ASCII) > 0;
        }

        public int Send(string content,Encoding encode,bool writeLog=true)
        {
           // while (true)
            {
                int len = client.Send(content, encode);

                if (len > 0)
                {
                    if(writeLog)
                    {
                        LogHelper.Debug(" <<< " + content);
                    }
                    return len;
                }
                return len;
                //Thread.Sleep(1000);
            }
            
        }
        /// <summary>
        /// 上报信息给中控
        /// </summary>
        /// <param name="scheduing"></param>
        /// <returns></returns>
        public int ReportToTestCenter(Scheduling scheduing)
        {
            if(scheduing.Instruction== EInstruction.InquireStatus)
            {
                string content = JsonConvert.SerializeObject(scheduing, new StringEnumConverter());
                return Send(content, Encoding.ASCII,false);
            }
            else
            {
                string content = JsonConvert.SerializeObject(scheduing, new StringEnumConverter());
                return Send(content, Encoding.ASCII);
            }
        }

        public void EndInput()
        {
            Scheduling s = new Scheduling();
            s.Instruction = EInstruction.EndInput;
            string content = JsonConvert.SerializeObject(s, new StringEnumConverter());
            Send(content, Encoding.ASCII);
        }


        public void ShowMsgBox(SchedulingMessageBox msgBox)
        {
            try
            {
                string content = JsonConvert.SerializeObject(msgBox, new StringEnumConverter());
                LogHelper.Debug($"<<< send to center: {content}");
                if (client.Send(content, Encoding.UTF8) > 0)
                {
                    LogHelper.Debug($"<<< send to center:{content} success");
                }
            }
            catch (Exception ex)
            {
                LogHelper.Error($"ShowMsgBox {ex.Message}");
            }
            
        }

        public void SwitchTray(ETrayType stockType,int floor)
        {
            //SchedulingSilo tray = new SchedulingSilo();
            //tray.Instruction = EInstruction.BeginSwitchTray;
            //tray.SiloFloor = floor;
            //tray.TurnoverID = 0;
            //tray.GroupID = 0;
            //tray.SiloStatus = ESiloStatus.Switching;
            //switch (stockType)
            //{
            //    case ETrayType.Empty1:
            //        tray.SiloType = SchedulingSiloBase.ESiloType.EmptyInput;
            //        break;
            //    case ETrayType.Input:
            //        tray.SiloType = SchedulingSiloBase.ESiloType.ToBeTested;
            //        break;
            //    case ETrayType.Ok:
            //        tray.SiloType = SchedulingSiloBase.ESiloType.Passed;
            //        break;
            //    case ETrayType.Ng:
            //        tray.SiloType = SchedulingSiloBase.ESiloType.Failed;
            //        break;
            //    case ETrayType.Multi:
            //        tray.SiloType = SchedulingSiloBase.ESiloType.Multifunction;
            //        break;
            //    case ETrayType.Empty2:
            //        tray.SiloType = SchedulingSiloBase.ESiloType.EmptyOutput;
            //        break;
            //    default:
            //        break;
            //}
            //ReportToTestCenter(tray);
        }
    }
}