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

namespace DeviceLibrary
{
    public partial class MainMachine : IRobot
    {
        public static string Name { get; set; } = "XLC";
        private bool _canRunning = true;
        public bool canRunning
        {
            get { return _canRunning; }
            set
            {
                if (_canRunning != value)
                {
                    Msg.setlogones();
                }
                _canRunning = value;
            }
        }
        public bool isBusy { get; set; } = false;
        public bool isAlarm { get; set; } = false;
        public RunStatus runStatus { get; set; } = RunStatus.Stop;
        public Robot_Config Config { get; set; }
        /// <summary>
        /// 用户暂停
        /// </summary>
        public bool UserPause { get; set; } = false;
        public bool IsClearWarnMsg { get; set; } = true;

        public MoveInfo ResetMoveInfo;
        /// <summary>
        /// 右侧移动信息
        /// </summary>
        public MoveInfo StoreMoveInfo;
        public MoveInfo AIOTMoveInfo;

        public delegate void ProcessMsg(List<Msg> msg);
        public event ProcessMsg ProcessMsgEvent;

        //public delegate void ProcessMoveinfo(List<MoveInfo> moveinfoList);
        //public event ProcessMoveinfo ProcessMoveinfoEvent;

        internal AxisBean XAxis;
        internal AxisBean YAxis;
        internal AxisBean ZAxis;

        public InOutDevice LeftInOut;
        public InOutDevice RightInOut;

        BoxTransport boxTransport;
        public bool boxTransportIsFree { get => boxTransport.IsComplateOrFree; }
        public event Action<string, StoreMoveType, bool> InOutEndProcessEvent;

        internal ServerCommunication ServerCM = new ServerCommunication();
        /// <summary>
        /// 开始运行的时间
        /// </summary>
        public DateTime StartTime { get; set; }

        /// <summary>
        /// 是否在急停中
        /// </summary>
        public bool isInSuddenDown = false;



        public MainMachine(Robot_Config _config)
        {
            Config = _config;

            StoreMoveInfo = new MoveInfo("行走机构");
            StoreMoveInfo.SetStateDelegate(StoreState);
            ResetMoveInfo = new MoveInfo("重置");
            AIOTMoveInfo = new MoveInfo("出入库测试");

            #region 初始化led灯 顺序不能变
            RunningLed = new Led(Config.DOList[IO_Type.Run_Led].GetIOAddr(), LedColor.green);
            StandbyLed = new Led(Config.DOList[IO_Type.Standby_Led].GetIOAddr(), LedColor.yellow);
            AlarmLed = new Led(Config.DOList[IO_Type.Alarm_Led].GetIOAddr(), LedColor.red);
            #endregion
            #region 初始化伺服轴
            XAxis = new AxisBean(Config.XAxis, Name);
            XAxis.interference += XAxis_interference;
            XAxis.ForceSafeCheck = true;
            YAxis = new AxisBean(Config.YAxis, Name);
            YAxis.interference += YAxis_interference;
            ZAxis = new AxisBean(Config.ZAxis, Name);
            ZAxis.interference += ZAxis_interference;
            #endregion

            LeftInOut = new InOutDevice(InOutSideE.Left, Setting_Init.Device_LeftInoutMode, Config, this);
            RightInOut = new InOutDevice(InOutSideE.Right, Setting_Init.Device_RightInoutMode, Config, this);

            boxTransport = new BoxTransport(Config, this);

            boxTransport.InOutEndProcessEvent += delegate (string posid, StoreMoveType storeMoveType, bool arg4)
            {
                InOutEndProcessEvent?.Invoke(posid, storeMoveType, arg4);
            };
            //BoxTransport_InOutEndProcessEvent;
            //ProcessMsgEvent += MainMachine_ProcessMsgEvent;
            CodeManager.LoadCamera(true);
            AlarmBuzzer.SetOnOffAction(() => { IOMove(IO_Type.Alarm_Buzzer, IO_VALUE.HIGH); }, () => { IOMove(IO_Type.Alarm_Buzzer, IO_VALUE.LOW); });

            //IOMonitor.RegisterIO(IO_Type.OutLeave_BTN, Config, IO_VALUE.HIGH, OutLeave_BTN,2500,100);
            //IOMonitor.RegisterIO(IO_Type.Reset_BTN, Config, IO_VALUE.HIGH, Reset_BTN, 2500,100);
            LedProcessInit();
        }
        private (bool, string) ZAxis_interference(int from, int to)
        {
            if (to == Config.Zaxis_P1)
                return (false, "");

            if (XAxis.GetAclPosition() > Config.Xaxis_P1 + Config.XAxis.CanErrorCountMax)
            {
                //if (to=Config.y)
            }
            else
            {
                if (!Setting_Init.Device_DisableFloorCheck && GetYAxisLevel() == 0)
                {
                    return (true, "升降机构不在托盘进出位置");
                }
            }
            return (false, "");
        }

        private (bool, string) YAxis_interference(int from, int to)
        {
            if (XAxis.GetAclPosition() > Config.Xaxis_P1 + Config.XAxis.CanErrorCountMax)
            {
                //在出入库口

                //if (to=Config.y)
            }
            else
            { ///在料仓        
                if (!ZAxis.IsInPosition(Config.Zaxis_P1) && Math.Abs(from - to) > 1000 * 10)
                {
                    return (true, "进出轴伸出时升降轴不可以大幅运动");
                }

            }
            return (false, "");
        }

        private (bool, string) XAxis_interference(int from, int to)
        {
            if (!ZAxis.IsInPosition(Config.Zaxis_P1))
            {
                return (true, "周转箱托盘没有收回,无法移动行走机构");
            }
            return (false, "");
        }
        public bool hasAlarm = false;
        /// <summary>
        /// 整机启动变量,设置为false后将退出线程,只在停止时调用
        /// </summary>
        bool mstart = true;
        public void Run()
        {
            mstart = true;
            while (mstart)
            {
                try
                {
                    canRunning = DeviceCheck();
                    if (canRunning)
                    {
                        BtnProcess();
                        canRunning = SafeCheck();
                    }
                    if (IOManager.IOValue(IO_Type.AirValue).Equals(IO_VALUE.LOW))
                    {
                        Msg.add("干燥机电磁阀打开", MsgLevel.info);
                    }
                    else
                    {
                        Msg.add("干燥机电磁阀关闭", MsgLevel.info);
                    }
                    Thread.Sleep(200);
                    if (!canRunning || !mstart)
                        continue;
                    if (runStatus == RunStatus.Running)
                    {
                        ioMonitor();

                        RightInOut.Progress();
                        LeftInOut.Progress();

                        boxTransport.Process();
                        if (RobotManage.mainMachine.AutoInOutTest)
                            AutoInOutTestProcess();
                        else
                            StoreProcess();
                    }
                    else if (runStatus == RunStatus.HomeReset)
                    {
                        HomeReset();
                    }
                }
                catch (Exception ex)
                {
                    Msg.add(ex.ToString(), MsgLevel.warning);
                    Msg.setlogones();
                }
                finally
                {
                    var m = Msg.get();
                    ProcessMsgEvent?.Invoke(m);
                    ServerCM.ProcessMsg(m);
                    StoreStatus currnetstoreStatus = StoreStatus.StoreOnline;
                    if (m.Find((aa) => aa.msgLevel == MsgLevel.alarm) == null)
                    {
                        hasAlarm = false;
                        AlarmBuzzer.OFF();
                        if (ServerCM.storeStatus != StoreStatus.InStoreExecute
                            && ServerCM.storeStatus != StoreStatus.OutStoreExecute
                            && ServerCM.storeStatus != StoreStatus.ResetMove && ServerCM.storeStatus != StoreStatus.StoreOnline)
                        {
                            LogUtil.info($"test storeStatus is {ServerCM.storeStatus} change to StoreOnline");
                            currnetstoreStatus = StoreStatus.StoreOnline;
                        }
                    }
                    else
                    {
                        hasAlarm = true;
                        AlarmBuzzer.ON();
                        currnetstoreStatus = isInSuddenDown ? StoreStatus.SuddenStop : StoreStatus.Warning;
                    }
                    //ProcessMoveinfoEvent?.Invoke(MoveInfo.List);
                    if (!UserPause)
                    {
                        if (IsClearWarnMsg)
                            Msg.clear();
                    }
                    else
                        currnetstoreStatus = StoreStatus.Debugging;

                    //if (ServerCM.storeStatus== StoreStatus.InStoreExecute || ServerCM.storeStatus == StoreStatus.)
                    //ServerCM.storeStatus = currnetstoreStatus;
                }
            }
            LogUtil.info("主线程已退出.");
        }
        public void Start()
        {
            ServerCM.StartConnectServer();
            Run();
        }
        public void Stop()
        {
            mstart = false;
            ServerCM.StopConnectServer();
            Thread.Sleep(300);
            Alarm(AlarmType.None);
            StopMove(true);
            IOMove(IO_Type.Left_Moto_Run, IO_VALUE.LOW);
            IOMove(IO_Type.Right_Moto_Run, IO_VALUE.LOW);

        }
        public void BeginHomeReset(bool firstRun = false)
        {
            if (!firstRun)
            {
                StopMove();
                Thread.Sleep(500);
            }
            OpenAllServo();
            Alarm(AlarmType.None);
            runStatus = RunStatus.HomeReset;
            ResetMoveInfo.NewMove(MoveStep.H01_HomeReset);
            ResetMoveInfo.log("开始回原");
            ResetMoveInfo.WaitList.Add(WaitResultInfo.WaitTime(1000));
        }
        //强制回原
        bool forceHome = false;
        void HomeReset()
        {
            if (CheckWait(ResetMoveInfo))
                return;

            switch (ResetMoveInfo.MoveStep)
            {
                case MoveStep.H01_HomeReset:
                    ResetMoveInfo.NextMoveStep(MoveStep.H02_HomeReset);
                    ResetMoveInfo.log("开始回原,进出轴回原");
                    ServerCM.storeStatus = StoreStatus.ResetMove;
                    ZAxis.HomeMove(ResetMoveInfo, forceHome);
                    break;
                case MoveStep.H02_HomeReset:
                    ResetMoveInfo.NextMoveStep(MoveStep.H03_HomeReset);
                    ResetMoveInfo.log("正在回原,料叉P1待机点");
                    ZAxis.AbsMove(ResetMoveInfo, Config.Zaxis_P1, Config.Zaxis_P1_speed);
                    ResetMoveInfo.WaitList.Add(WaitResultInfo.WaitTime(500));
                    break;
                case MoveStep.H03_HomeReset:
                    if (IOMonitor.IODebound(IO_Type.SideA_ForkMaterial_Check, Config, IO_VALUE.LOW, 2000) &&
                        IOMonitor.IODebound(IO_Type.SideB_ForkMaterial_Check, Config, IO_VALUE.LOW, 2000))
                    {
                        ResetMoveInfo.NextMoveStep(MoveStep.H04_HomeReset);
                        YAxis.HomeMove(ResetMoveInfo, forceHome);
                        ResetMoveInfo.log("正在回原 ,升降轴,回原");
                        ResetMoveInfo.WaitList.Add(WaitResultInfo.WaitTime(1000));
                    }
                    else if (ResetMoveInfo.IsTimeOut(6))
                    {
                        Msg.add("存储机构取料暂停", MsgLevel.warning);//伸缩叉2侧X06/X07检测到有物料无法继续
                        RobotManage.UserPause("再次确认回原时料叉上是否有料");
                        return;
                    }

                    break;
                case MoveStep.H04_HomeReset:
                    ResetMoveInfo.NextMoveStep(MoveStep.H05_HomeReset);

                    ResetMoveInfo.log("开始回原,行走机构,回原");
                    XAxis.HomeMove(ResetMoveInfo, forceHome);
                    break;
                case MoveStep.H05_HomeReset:
                    ResetMoveInfo.NextMoveStep(MoveStep.H06_HomeReset);
                    ResetMoveInfo.WaitList.Add(WaitResultInfo.WaitTime(500));
                    break;
                case MoveStep.H06_HomeReset:
                    ResetMoveInfo.NextMoveStep(MoveStep.H07_HomeReset);
                    ResetMoveInfo.log("正在回原,行走机构,升降轴,到P1待机点,入口顶升下降,出口顶升上升");
                    YAxis.AbsMove(ResetMoveInfo, Config.Yaxis_P1, Config.Yaxis_P1_speed);
                    XAxis.AbsMove(ResetMoveInfo, Config.Xaxis_P1, Config.Xaxis_P1_speed);
                    RightInOut.Lift.LiftUp(ResetMoveInfo);
                    LeftInOut.Lift.LiftDown(ResetMoveInfo);

                    RightInOut.FrontStop(ResetMoveInfo, IO_VALUE.HIGH);
                    LeftInOut.FrontStop(ResetMoveInfo, IO_VALUE.HIGH);
                    RightInOut.MiddleStop(ResetMoveInfo, IO_VALUE.HIGH);
                    LeftInOut.MiddleStop(ResetMoveInfo, IO_VALUE.HIGH);
                    break;
                case MoveStep.H07_HomeReset:
                    if (IOValue(IO_Type.ForkMaterial_Check).Equals(IO_VALUE.HIGH))
                    {
                        ResetMoveInfo.NextMoveStep(MoveStep.HEND_HomeReset);
                        ResetMoveInfo.log("进出轴X05上有周转箱");
                        AddOutStoreTask("Reset", "");

                    }
                    else if (IOValue(IO_Type.SideA_ForkMaterial_Check).Equals(IO_VALUE.HIGH) ||
                             IOValue(IO_Type.SideB_ForkMaterial_Check).Equals(IO_VALUE.HIGH))
                    {
                        if (IOMonitor.IODebound(IO_Type.SideA_ForkMaterial_Check, Config, IO_VALUE.HIGH, 2000) ||
                            IOMonitor.IODebound(IO_Type.SideB_ForkMaterial_Check, Config, IO_VALUE.HIGH, 2000))
                        {
                            Msg.add("存储机构取料暂停", MsgLevel.warning);//伸缩叉2侧X06/X07检测到有物料无法继续
                            RobotManage.UserPause("回源时料叉上有物料");
                            return;
                        }

                    }
                    else
                    {
                        ResetMoveInfo.NextMoveStep(MoveStep.HEND_HomeReset);
                        ResetMoveInfo.log("进出轴上没有周转箱");
                    }
                    break;
                case MoveStep.H08_HomeReset:
                    if (InOutDevice.GetOutStoreFreeSide(out InOutSideE inOutSide2, out InOutDevice iod2))
                    {// && IsOutLiftEmpty) {
                        iod2.TurnToOut(new JobInfo("ReturnHome", "ReturnHome", "ReturnHome"));
                        ResetMoveInfo.NextMoveStep(MoveStep.H09_HomeReset);
                        boxTransport.Start(null, new BoxStorePosition(Config, inOutSide2), StoreMoveType.ReturnHome, "ReturnHome");
                        ResetMoveInfo.log("进出轴上有周转箱,开始送到出口");
                        ResetMoveInfo.WaitList.Add(WaitResultInfo.WaitTime(100));
                    }
                    break;
                case MoveStep.H09_HomeReset:
                    boxTransport.Process();
                    if (boxTransport.IsComplateOrFree)
                    {
                        ResetMoveInfo.NextMoveStep(MoveStep.HEND_HomeReset);
                    }
                    break;
                case MoveStep.HEND_HomeReset:
                    forceHome = false;
                    LeftInOut.MoveInfo.NewMove(MoveStep.Wait);
                    RightInOut.MoveInfo.NewMove(MoveStep.Wait);
                    StoreMoveInfo.NewMove(MoveStep.Wait);
                    boxTransport.Reset();
                    ResetMoveInfo.log("回原完成");
                    ResetMoveInfo.EndMove();

                    runStatus = RunStatus.Running;
                    ServerCM.storeStatus = StoreStatus.StoreOnline;
                    break;
            }
        }
        bool _IgnoreSafecheck = false;
        public bool IgnoreSafecheck
        {
            get => _IgnoreSafecheck; set
            {
                if (value)
                {
                    IOMove(IO_Type.DoorSafe_Disable, IO_VALUE.HIGH);
                }
                else
                {
                    IOMove(IO_Type.DoorSafe_Disable, IO_VALUE.LOW);
                }
                _IgnoreSafecheck = value;
            }
        }
        public bool IgnoreGratingSignal = false;

        bool lastSafeCheckStatus = true;
        bool SafeCheck()
        {
            bool ok = true;

            if (IOValue(IO_Type.FrontDoor_Check).Equals(IO_VALUE.LOW))
            {
                if (!IgnoreSafecheck)
                {
                    ok = false;
                    DeviceSuddenStop();
                }
                if (!ok)
                    Msg.add("前门没有关闭" + (ok ? "[已忽略]" : ""), MsgLevel.warning);
            }
            if (IOValue(IO_Type.BackDoor_Check).Equals(IO_VALUE.LOW))
            {
                if (!IgnoreSafecheck)
                {
                    ok = false;
                    DeviceSuddenStop();
                }
                if (!ok)
                    Msg.add("后门没有关闭" + (ok ? "[已忽略]" : ""), MsgLevel.warning);
            }
            if (!lastSafeCheckStatus && ok)
            {
                SafetyDevice.ResumeAll();
                MoveInfo.List.ForEach((m) => { m.LastSetpTime = DateTime.Now; });
            }
            lastSafeCheckStatus = ok;
            return ok;
        }

        void DeviceSuddenStop()
        {
            if (lastSafeCheckStatus)
            {
                //lastSafeCheckStatus = false;
                //AxisBean.StopMultiAxis(new List<AxisBean>() { Take_Middle_Axis, Take_UpDown_Axis, Label_X_Axis,Label_Y_Axis, Label_Z_Axis, Label_R_Axis });
                AxisBean.StopMultiAxis(AxisBean.List);
                MoveInfo.List.ForEach((m) => { m.CanWhileCount = 5; });
                SafetyDevice.PauseAll();
                if (runStatus == RunStatus.HomeReset)
                {
                    ResetMoveInfo.NewMove(MoveStep.H01_HomeReset);
                }
            }
        }
        void DeviceResume()
        {
            LeftInOut.Line.Resume();
            RightInOut.Line.Resume();
        }

        /// <summary>
        /// 最后一次气压检测变为0的时间
        /// </summary>
        DateTime lastAirCloseTime = DateTime.MinValue;

        internal DateTime checkAlarmTime = DateTime.Now;
        public bool DeviceCheck()
        {
            bool ok = true;
            if (UserPause)
            {
                Msg.add("用户暂停", MsgLevel.warning);
                DeviceSuddenStop();
                ok = false;
                return ok;
            }
            else if (IOValue(IO_Type.SuddenStop_BTN).Equals(IO_VALUE.LOW))
            {
                Alarm(AlarmType.SuddenStop);
                Msg.add("急停中", MsgLevel.alarm);
                ok = false;
            }
            else if (alarmType == AlarmType.SuddenStop)
            {
                //if (IOValue(IO_Type.Right_BTN).Equals(IO_VALUE.HIGH) || IOValue(IO_Type.Left_BTN).Equals(IO_VALUE.HIGH))
                //{
                //    Alarm(AlarmType.None);
                //}
                //else
                {
                    Msg.add("系统需要重置", MsgLevel.warning);
                    ok = false;
                }
            }
            if (RobotManage.InoutDebugMode)
            {
                Msg.add("进出库调试模式", MsgLevel.info);
                //ok = false;
            }
            if (IOValue(IO_Type.Airpressure_Check).Equals(IO_VALUE.LOW))
            {
                if (lastAirCloseTime == DateTime.MinValue)
                    lastAirCloseTime = DateTime.Now;

                TimeSpan span = DateTime.Now - lastAirCloseTime;
                if (span.TotalSeconds > RobotManage.Config.AirCheckSeconds)
                {
                    ok = false;
                    Msg.add("气压不足", MsgLevel.warning);
                }
            }
            else
            {
                lastAirCloseTime = DateTime.MinValue;
            }
            if (alarmType != AlarmType.SuddenStop)
            {
                TimeSpan span = DateTime.Now - checkAlarmTime;
                if (span.TotalSeconds > 2)
                {
                    checkAlarmTime = DateTime.Now;
                    foreach (ConfigMoveAxis configMoveAxis in Config.moveAxisList)
                    {
                        if (AxisManager.GetAlarmStatus(configMoveAxis.DeviceName, configMoveAxis.GetAxisValue()) == 1)
                        {
                            Msg.add($"{configMoveAxis.Explain}[{configMoveAxis.GetAxisValue()}]:运动报警", MsgLevel.warning);
                            ok = false;
                        }
                    }
                }
            }
            return ok;
        }

        int GetYAxisLevel()
        {
            if (IOValue(IO_Type.Lift_1Level_Check).Equals(IO_VALUE.HIGH))
                return 1;
            if (IOValue(IO_Type.Lift_2Level_Check).Equals(IO_VALUE.HIGH))
                return 2;
            if (IOValue(IO_Type.Lift_3Level_Check).Equals(IO_VALUE.HIGH))
                return 3;
            if (IOValue(IO_Type.Lift_4Level_Check).Equals(IO_VALUE.HIGH))
                return 4;
            if (IOValue(IO_Type.Lift_5Level_Check).Equals(IO_VALUE.HIGH))
                return 5;
            if (IOValue(IO_Type.Lift_6Level_Check).Equals(IO_VALUE.HIGH))
                return 6;
            return 0;
        }

        public void IgnoreX09()
        {
            boxTransport.IgnoreX09 = true;
            LogUtil.info("按下X05忽略");
        }
    }
}