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

namespace DeviceLibrary
{
    class ReelTransport
    {
        Robot_Config Config;
        BoxStorePosition From;
        public BoxStorePosition To;
        MainMachine mainMachine;
        //using static mainMachine;
        AxisBean X_Axis;
        AxisBean Y_Axis;
        AxisBean Z_Axis;
        MoveInfo MoveInfo;
        public string ErrMsgTxt = "";

        public bool IgnoreX09 = false;

        public event Action<string, StoreMoveType, bool> InOutEndProcessEvent;
        public bool IsComplateOrFree { get => MoveInfo.MoveStep == MoveStep.Wait && !movelock; }
        public bool IsTakedReel { get => MoveInfo.MoveStep >= MoveStep.StoreTS20 || MoveInfo.MoveStep == MoveStep.Wait; }
        public bool IsPutOnOut {get=> MoveInfo.MoveStep >= MoveStep.StoreTS16; }
        
        public ReelTransport(Robot_Config _Config, MainMachine _mainMachine)
        {
            Config = _Config;
            mainMachine = _mainMachine;
            MoveInfo = new MoveInfo(crc.GetString("Res0061","出入库机构"),false);
            To = null;
            From = null;
            #region 初始化伺服轴
            X_Axis = _mainMachine.X_Axis;
            Y_Axis = _mainMachine.Y_Axis;
            Z_Axis = _mainMachine.Z_Axis;

            #endregion
        }
        public void Reset() {
            MoveInfo.NewMove(MoveStep.Wait);
            MoveInfo.log("执行重置");
            To = null;
            From = null;
        }
        StoreMoveType storeMoveType = StoreMoveType.None;
        string WareCode="";
        bool PreMove = false;
        bool ignoreFixtureCheck = false;
        int ToCheckOffset = 0;
        int FromCheckOffset = 0;
        public bool isSelfAudit = false;
        public bool CheckHasMatetial = false;
        public bool Start(BoxStorePosition from, BoxStorePosition to, StoreMoveType _storeMoveType, bool premove=false)
        {
            
            if (MoveInfo.MoveStep != MoveStep.Wait)
                return false;
            isSelfAudit = false;
            CheckHasMatetial = false;
            ignoreFixtureCheck = false;
            storeMoveType = _storeMoveType;
            PreMove = premove;

            if (from == null)
            {
                WareCode = "NG";
                To = to.clone();
                MoveInfo.NewMove(MoveStep.StoreTS20);
                MoveInfo.log($"{storeMoveType}:开始运输物料,直接到:{to.posid}");
                MoveInfo.MoveParam.PosID = $"NA=>{To.posid}";
            }
            else
            {
                WareCode = from.Reel.WareCode;
                From = from.clone();
                To = to.clone();
                ignoreFixtureCheck = Common.IsNeedIgnoreFixtureCheck(WareCode);
                MoveInfo.NewMove(MoveStep.StoreTS01);
                MoveInfo.log($"{storeMoveType}:开始运输物料,从:{from.posid},到:{to.posid},WareCode:{WareCode},ignoreFixtureCheck:{ignoreFixtureCheck}");
                MoveInfo.MoveParam.PosID = $"{From.posid}=>{To.posid}";
                MoveInfo.MoveParam.ReelOnFixture = From.Reel.ReelOnFixture;


            }
            FromCheckOffset = CalcOffset(From.posid);
            ToCheckOffset = CalcOffset(To.posid);
            MoveInfo.MoveParam.WareCode = WareCode;
            //MoveInfo.log($"确认检查偏移: FromCheckOffset={FromCheckOffset},ToCheckOffset={ToCheckOffset}");
            ErrMsgTxt = "";
            return true;
            //thread = new Thread(new ThreadStart(Run));
            //thread.Start();
        }


        public bool Process()
        {
            if (mainMachine.CheckWait(MoveInfo))
                return false;

            switch (MoveInfo.MoveStep)
            {
                case MoveStep.Wait:
                    break;
                case MoveStep.StoreTS01:
                    Msg.add("", MsgLevel.info, ErrInfo.X09_Clear);
                    IgnoreX09 = false;
                    MoveInfo.NextMoveStep(MoveStep.StoreTS02);
                    MoveInfo.log($"{storeMoveType}:开始");
                    CheckPosStatus(MoveInfo, From.posid, true);
                    break;
                case MoveStep.StoreTS02:
                    MoveInfo.NextMoveStep(MoveStep.StoreTS03);
                    if (From.posid != MainMachine.LabelP)
                        Z_Axis.AbsMove(MoveInfo, Config.Z_Axis_P1, Config.Z_Axis_P1_speed);
                    //MoveInfo.log($"{storeMoveType}:Z轴返回待机点P1");

                    break;
                case MoveStep.StoreTS03:
                    if (MoveInfo.MoveParam.ReelOnFixture)
                    {
                        MoveInfo.NextMoveStep(MoveStep.StoreTS08);
                        MoveInfo.log($"{storeMoveType}:物料已在夹爪上");
                    }
                    else
                        MoveInfo.NextMoveStep(MoveStep.StoreTS04);
                    Y_Axis.AbsMove(MoveInfo, From.Y_Axis_P2 + FromCheckOffset, Config.Y_Axis_P1_speed);
                    //MoveInfo.log($"{storeMoveType}:Y轴到达取料点偏移点");
                    X_Axis.AbsMove(MoveInfo, From.X_Axis_P2, Config.X_Axis_P1_speed);
                    MoveInfo.log($"{storeMoveType}:XY轴到达取料检测,X:{From.X_Axis_P2},Y:{From.Y_Axis_P2}+{FromCheckOffset}");
                    break;
                case MoveStep.StoreTS04:
                    if (CheckPosStatus(MoveInfo, From.posid))
                    {
                        MoveInfo.NextMoveStep(MoveStep.StoreTS05);
                        if (From.posid != MainMachine.LabelP)
                        {
                            var zp2 = From.Z_Axis_P3 - 205000;
                            if (zp2 < 0)
                                zp2 = 0;
                            Z_Axis.AbsMove(MoveInfo, zp2, Config.Z_Axis_P1_speed);
                            MoveInfo.log($"{storeMoveType}:Z轴到达取料前点,{From.Z_Axis_P2}");
                        }
                        RobotManage.mainMachine.CylinderMove(MoveInfo, IO_Type.Taking_Release, IO_Type.Taking_Clamp, IO_VALUE.LOW);
                        MoveInfo.log($"{storeMoveType}:松开夹爪");
                        IgnoreX09 = false;
                    }
                    break;
                case MoveStep.StoreTS05:
                    if (!ignoreFixtureCheck && FromCheckOffset != 0 && !IgnoreX09 && IOManager.IOValue(FromCheckOffset > 0 ? IO_Type.Taking_Left_Check : IO_Type.Taking_Right_Check).Equals(IO_VALUE.LOW))
                    {
                        if (isSelfAudit)
                        {
                            CheckHasMatetial = false;
                            MoveInfo.log($"{storeMoveType}:自检时没有检测到物料");
                            MoveInfo.NextMoveStep(MoveStep.StoreTS26);
                        }
                        else
                        {
                            Msg.add(crc.GetString("Res0062", "取料时没有检测到物料信号,请检查."), MsgLevel.alarm, ErrInfo.X09_BoxNotDetect);
                            MoveInfo.log($"取料时没有检测到物料信号,请检查.");
                            //RobotManage.UserPause(crc.GetString("Res0063", "取料时没有检测到物料信号,请检查"));
                        }
                    }
                    else
                    {
                        CheckHasMatetial = true;
                        Msg.add("", MsgLevel.info, ErrInfo.X09_Clear);
                        IgnoreX09 = false;
                        MoveInfo.NextMoveStep(MoveStep.StoreTS06);
                        MoveInfo.log($"{storeMoveType}:检测有物料");
                    }
                    break;
                case MoveStep.StoreTS06:
                    MoveInfo.NextMoveStep(MoveStep.StoreTS07);
                    Y_Axis.AbsMove(MoveInfo, From.Y_Axis_P2, Config.Y_Axis_P1_speed);
                    MoveInfo.log($"{storeMoveType}:Y轴到达取料点{From.Y_Axis_P2}");
                    break;
                case MoveStep.StoreTS07:
                    //RobotManage.CameraA.CameraGrabOne(RobotManage.CameraA.GetFixtureStateFilename(From.posid, WareCode, storeMoveType, FixtureState.FromIn));
                    MoveInfo.NextMoveStep(MoveStep.StoreTS08);
                    Z_Axis.AbsMove(MoveInfo, From.Z_Axis_P3, Config.Z_Axis_P1_speed);
                    MoveInfo.log($"{storeMoveType}:Z轴到达取料点{From.Z_Axis_P3}");
                    break;
                case MoveStep.StoreTS08:
                    MoveInfo.NextMoveStep(MoveStep.StoreTS09);
                    RobotManage.mainMachine.CylinderMove(MoveInfo, IO_Type.Taking_Release, IO_Type.Taking_Clamp, IO_VALUE.HIGH);
                    //Setting_Init.Runtime_Posid = To.posid;
                    if (storeMoveType == StoreMoveType.InStore && To.posid == MainMachine.LabelP)
                        Setting_Init.Runtime_Step = Runtime_StepE.InToLabel;
                    if (storeMoveType == StoreMoveType.InStore && To.posid != MainMachine.LabelP)
                        Setting_Init.Runtime_Step = Runtime_StepE.InToStore;
                    else if (storeMoveType == StoreMoveType.OutStore)
                        Setting_Init.Runtime_Step = Runtime_StepE.Out;

                    MoveInfo.log($"{storeMoveType}:合拢夹爪");
                    break;
                case MoveStep.StoreTS09:
                    MoveInfo.NextMoveStep(MoveStep.StoreTS10);
                    if (From.posid == MainMachine.LabelP && To.posid == MainMachine.RFIDP)
                        Z_Axis.AbsMove(MoveInfo, To.Z_Axis_P3, Config.Z_Axis_P1_speed);
                    else
                        Z_Axis.AbsMove(MoveInfo, Config.Z_Axis_P1, Config.Z_Axis_P1_speed);
                    MoveInfo.log($"{storeMoveType}:Z轴到达待机点");
                    break;
                case MoveStep.StoreTS10:
                    IgnoreX09 = false;
                    MoveInfo.NextMoveStep(MoveStep.StoreTS20);
                    MoveInfo.log($"{storeMoveType}:完成取料");
                    InOutEndProcess(StoreMoveType.OutStore, From.posid);
                    break;
                case MoveStep.StoreTS20:
                    MoveInfo.NextMoveStep(MoveStep.StoreTS21);
                    CheckPosStatus(MoveInfo, To.posid,true);
                    Y_Axis.AbsMove(MoveInfo, To.Y_Axis_P2 + ToCheckOffset, Config.Y_Axis_P1_speed);
                    X_Axis.AbsMove(MoveInfo, To.X_Axis_P2, Config.X_Axis_P1_speed);
                    MoveInfo.log($"{storeMoveType}:XY轴到达目的地检测,X:{To.X_Axis_P2},Y:{To.Y_Axis_P2}+{ToCheckOffset}");
                    break;
                case MoveStep.StoreTS21:
                    if (CheckPosStatus(MoveInfo, To.posid))
                    {
                        MoveInfo.NextMoveStep(MoveStep.StoreTS22);
                    }
                    break;
                case MoveStep.StoreTS22:
                    MoveInfo.NextMoveStep(MoveStep.StoreTS23);
                    MoveInfo.log($"{storeMoveType}:Z轴到达入库前点");
                    if (From.posid == MainMachine.LabelP && To.posid == MainMachine.RFIDP)
                    {
                        MoveInfo.NextMoveStep(MoveStep.StoreTS29);
                        MoveInfo.log("LabelP=>RFIDP 直接结束");
                    }
                    else if (To.posid == MainMachine.RFIDP)
                    {
                        MoveInfo.NextMoveStep(MoveStep.StoreTS29);
                        Z_Axis.AbsMove(MoveInfo, To.Z_Axis_P3, Config.Z_Axis_P1_speed);
                        MoveInfo.log($"{storeMoveType}:Z轴到达目的地低点:{To.Z_Axis_P3}");
                        MoveInfo.log("???=>RFIDP 升降轴直接到P3 直接结束");
                    }
                    else if (To.posid != MainMachine.LabelP)
                    {
                        var zp2 = To.Z_Axis_P3 - 205000;
                        if (zp2 < 0)
                            zp2 = 0;
                        Z_Axis.AbsMove(MoveInfo, zp2, Config.Z_Axis_P1_speed);
                    }
                    else if (To.posid == MainMachine.LabelP)
                    {
                       RobotManage.mainMachine.FlipEquip.LiftUp(MoveInfo);
                    }
                    break;
                case MoveStep.StoreTS23:
                    if (!ignoreFixtureCheck && ToCheckOffset > 0 && IOManager.IOValue(ToCheckOffset > 0 ? IO_Type.Taking_Left_Check : IO_Type.Taking_Right_Check).Equals(IO_VALUE.HIGH))
                    {
                        Msg.add(crc.GetString("Res0064", "放料时发现库位已经有料,请检查."), MsgLevel.alarm);
                        MoveInfo.log($"放料时发现库位已经有料,请检查.");
                        //RobotManage.UserPause(crc.GetString("Res0064", "放料时发现库位已经有料,请检查"));
                    }
                    else
                    {
                        Msg.add("", MsgLevel.info, ErrInfo.X09_Clear);
                        IgnoreX09 = false;
                        MoveInfo.NextMoveStep(MoveStep.StoreTS24);
                        MoveInfo.log($"{storeMoveType}:检测有无物料,有物料");
                    }

                    break;
                case MoveStep.StoreTS24:
                    MoveInfo.NextMoveStep(MoveStep.StoreTS25);
                    Y_Axis.AbsMove(MoveInfo, To.Y_Axis_P2, Config.Y_Axis_P1_speed);
                    MoveInfo.log($"{storeMoveType}:Y轴到达目的地:{To.Y_Axis_P2}");
                    break;
                case MoveStep.StoreTS25:
                    //RobotManage.CameraA.CameraGrabOne(RobotManage.CameraA.GetFixtureStateFilename(To.posid, WareCode, storeMoveType, FixtureState.ToIn));
                    MoveInfo.NextMoveStep(MoveStep.StoreTS26);
                    Z_Axis.AbsMove(MoveInfo, To.Z_Axis_P3, Config.Z_Axis_P1_speed);
                    MoveInfo.log($"{storeMoveType}:Z轴到达目的地低点:{To.Z_Axis_P3}");
                    break;
                case MoveStep.StoreTS26:
                    if (To.posid == MainMachine.RFIDP)
                    {
                        MoveInfo.NextMoveStep(MoveStep.StoreTS29);
                        MoveInfo.log("RFID口直接结束");
                        return true;
                    }
                    MoveInfo.NextMoveStep(MoveStep.StoreTS27);
                    RobotManage.mainMachine.CylinderMove(MoveInfo, IO_Type.Taking_Release, IO_Type.Taking_Clamp, IO_VALUE.LOW);
                    MoveInfo.log($"{storeMoveType}:释放夹爪");
                    if (To.posid == MainMachine.LabelP)
                        Setting_Init.Runtime_Step = Runtime_StepE.LabelProcess;
                    break;
                case MoveStep.StoreTS27:
                    MoveInfo.NextMoveStep(MoveStep.StoreTS28);
                    if (To.posid == MainMachine.LabelP)
                    {
                        var rfidp = CSVPositionReader<ACStorePosition>.GetPositon(MainMachine.RFIDP);
                        Z_Axis.AbsMove(MoveInfo, rfidp.Z_Axis_P3, Config.Z_Axis_P1_speed);
                        MoveInfo.log($"{storeMoveType}:Z轴到达待机点");
                    }
                    else
                    {
                        Z_Axis.AbsMove(MoveInfo, Config.Z_Axis_P1, Config.Z_Axis_P1_speed);
                        MoveInfo.log($"{storeMoveType}:Z轴到达待机点");
                    }
                    break;
                case MoveStep.StoreTS28:
                    MoveInfo.NextMoveStep(MoveStep.StoreTS29);
                    if (To.posid == MainMachine.LabelP || To.posid.StartsWith("S"))
                    {
                    }
                    else
                    {
                        MoveInfo.log($"{storeMoveType}:XY返回待机点");
                        //Y_Axis.AbsMove(MoveInfo, Config.Y_Axis_P1, Config.Y_Axis_P1_speed);
                        X_Axis.AbsMove(MoveInfo, Config.X_Axis_P1, Config.X_Axis_P1_speed);
                    }
                    MoveInfo.log($"{storeMoveType}:完成放料");
                    InOutEndProcess(StoreMoveType.InStore, To.posid);
                    break;
                case MoveStep.StoreTS29:
                    MoveInfo.log($"{storeMoveType}:转移物料完成");
                    MoveInfo.EndMove();
                    ErrMsgTxt = "";
                    To.posid = "";
                    storeMoveType = StoreMoveType.None;
                    break;
                default:
                    MoveInfo.log($"{storeMoveType}:未找到对应步骤:{MoveInfo.MoveStep}");
                    return true;
            }

            return false;
        }

        bool CheckPosStatus(MoveInfo moveInfo,string posid,bool precheck=false) {
            if (posid.StartsWith("L"))
            {
                if (IOManager.IOValue(IO_Type.Entry_Drawer).Equals(IO_VALUE.HIGH) &&
                    IOManager.DOValue(IO_Type.Entry_Drawer_Lock).Equals(IO_VALUE.HIGH))
                {
                    moveInfo.log("入料抽屉已到位已锁定正常");
                    return true;
                }
                else if (IOManager.IOValue(IO_Type.Entry_Drawer).Equals(IO_VALUE.HIGH))
                {
                    //IOManager.IOMove(IO_Type.Entry_Drawer_Lock, IO_VALUE.HIGH);
                    //moveInfo.log("抽屉已关上但未锁定,尝试锁定");
                    moveInfo.log("入料抽屉已到位未锁定");
                    Msg.add(crc.GetString("Res0066","入料抽屉未上锁,请上锁后继续"), MsgLevel.alarm);
                    return false;
                }
                else
                {
                    moveInfo.log("入料抽屉未到位");
                    Msg.add(crc.GetString("Res0067","入料抽屉未关闭无法操作"), MsgLevel.alarm);
                    return false;
                }
            }
            else if (posid.StartsWith("U"))
            {
                if (IOManager.IOValue(IO_Type.Out_Drawer).Equals(IO_VALUE.HIGH) &&
                    IOManager.DOValue(IO_Type.Out_Drawer_Lock).Equals(IO_VALUE.HIGH))
                {
                    moveInfo.log("出料抽屉已到位已锁定正常");
                    return true;
                }
                else if (IOManager.IOValue(IO_Type.Out_Drawer).Equals(IO_VALUE.HIGH))
                {
                    //IOManager.IOMove(IO_Type.Out_Drawer_Lock, IO_VALUE.HIGH);
                    //moveInfo.log("抽屉已关上但未锁定,尝试锁定");
                    moveInfo.log("出料抽屉已到位未锁定");
                    Msg.add(crc.GetString("Res0068","出料抽屉未上锁,请上锁后继续"), MsgLevel.alarm);
                    return false;
                }
                else
                {
                    moveInfo.log("出料抽屉未到位");
                    Msg.add(crc.GetString("Res0069","出料抽屉未关闭无法操作"), MsgLevel.alarm);
                    return false;
                }
            }
            else if (Regex.IsMatch(posid,"^S[A-G]"))
            {
                if (RobotManage.mainMachine.TPMove.IsLow)
                    return true;
                else
                {
                    RobotManage.mainMachine.TPMove.ToLow(precheck?null:moveInfo);
                    moveInfo.log($"{posid},上层库位移至左侧");
                    return false;
                }
            }
            else if (Regex.IsMatch(posid, "^S[H-N][1-6]$"))
            {
                if (RobotManage.mainMachine.TPMove.IsHigh)
                    return true;
                else
                {
                    RobotManage.mainMachine.TPMove.ToHigh(precheck ? null : moveInfo);
                    moveInfo.log($"{posid},上层库位移至右侧");
                    return false;
                }
            }
            else if (Regex.IsMatch(posid, "^S[H-N]([7-9]|\\d{2})$"))
            {
                if (RobotManage.mainMachine.TPMove.IsLow)
                    return true;
                else
                {
                    RobotManage.mainMachine.TPMove.ToLow(precheck ? null : moveInfo);
                    moveInfo.log($"{posid},上层库位移至左侧");
                    return false;
                }
            }
            else {
                //moveInfo.log($"{posid},未知库位");
                return true;
            }
            
        }


        int CalcOffset(string posid) {
            if (string.IsNullOrEmpty(posid))
                return 0;
            if (Regex.IsMatch(posid, "^S\\w(12|6)"))
                return Config.X_Axis_Lcheck_Offset * -1;
            if (Regex.IsMatch(posid, "^L\\w4"))
                return Config.X_Axis_Lcheck_Offset * -1;
            if (posid.StartsWith("LabelP") || posid.StartsWith("RFIDP"))
                return 0;
            return Config.X_Axis_Lcheck_Offset;
        }
        public void Continue() {
            if (MoveInfo.MoveStep == MoveStep.StoreTS_WaitOutProcess)
            {
                MoveInfo.NextMoveStep(MoveStep.StoreTS_Continue);
                MoveInfo.log($"{storeMoveType}:外部处理完成,继续");
            }
            else {
                MoveInfo.log($"{storeMoveType}:当前不在外部处理状态");
            }
        }

        bool movelock = false;
        internal void Lock()
        {
            movelock = true;
        }
        internal void Unlock()
        {
            movelock = false;
        }
        private void InOutEndProcess(StoreMoveType storeMoveType, string posid)
        {
            InOutEndProcessEvent?.Invoke(posid, storeMoveType, true);
        }

        HIKCamera GetCamera(int pos) {
            //return pos > 0 ? RobotManage.CameraA : RobotManage.CameraB;
            return RobotManage.CameraA;
        }
    }
}