using CodeLibrary;
using OnlineStore.Common;
using OnlineStore.LoadCSVLibrary;
using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Drawing;
using System.Linq;
using System.Text;
using System.Threading;
using System.Threading.Tasks;
using System.Windows.Forms.VisualStyles;

namespace OnlineStore.DeviceLibrary
{
    partial class BoxEquip
    {
        protected override bool CheckWaitResult(DeviceMoveInfo moveInfo, WaitResultInfo wait)
        {
            return false;
        }
        /// <summary>
        /// 忽略相机检测到的抽屉误差误差
        /// </summary>
        public void SetIgnoreCamDect()
        {
            if (MoveInfo.MoveType.Equals(MoveType.InStore) || MoveInfo.MoveType.Equals(MoveType.OutStore))
            {
                IgnoreCamDect = true;
            }
        }
        /// <summary>
        /// 检查当前面是否A面
        /// </summary>
        /// <returns></returns>
        private bool CheckASide()
        {
            if (MoveInfo.MoveParam.PosInfo.PosSide.Equals("A"))
                return true;
            return false;
        }
        /// <summary>
        /// 检查当前面是否A面
        /// </summary>
        /// <param name="param"></param>
        /// <returns></returns>
        private bool CheckASide(InOutParam param)
        {
            if (param.PosInfo.PosSide.Equals("A"))
                return true;
            return false;
        }
        #region 料屉抽取
        /// <summary>
        /// 料斗拉取进出轴到料屉库位点P3/P5
        /// </summary>
        private void PullAxis_Inout_To_P3_P5()
        {
            if (CheckASide())
            {
                PullAxis_Inout.AbsMove(MoveInfo, MoveInfo.MoveParam.MoveP.PullAxis_Inout_P3_P5, Config.PullAxis_Inout_P3_Speed);
            }
            else
            {
                PullAxis_Inout.AbsMove(MoveInfo, MoveInfo.MoveParam.MoveP.PullAxis_Inout_P3_P5, Config.PullAxis_Inout_P5_Speed);
            }
        }
        private void UpdownAxisToP7_P13()
        {
            if (CheckASide())
            {
                UpdownAxis.AbsMove(MoveInfo, MoveInfo.MoveParam.MoveP.Updown_P7_P13, Config.Updown_P7_Speed);
            }
            else
            {
                UpdownAxis.AbsMove(MoveInfo, MoveInfo.MoveParam.MoveP.Updown_P7_P13, Config.Updown_P13_Speed);
            }
        }
        /// <summary>
        /// 到抽屉提取点，料斗拉取进出轴到P2（A/B面料屉提取点）
        /// </summary>
        private void ToTray()
        {
            if (CheckASide())
            {
                PullAxis_Inout.AbsMove(MoveInfo, MoveInfo.MoveParam.MoveP.PullAxis_Inout_P2_P4, Config.PullAxis_Inout_P2_Speed);
            }
            else
            {
                PullAxis_Inout.AbsMove(MoveInfo, MoveInfo.MoveParam.MoveP.PullAxis_Inout_P2_P4, Config.PullAxis_Inout_P4_Speed);
            }
        }
        /// <summary>
        /// AB移栽压紧轴到压紧前点P2
        /// </summary>
        private void ComAxis_To_P2()
        {
            if (CheckASide())
            {
                ComAxis_A.AbsMove(MoveInfo, MoveInfo.MoveParam.MoveP.ComAxis_AB_P2, Config.ComAxis_A_P2_Speed);
            }
            else
            {
                ComAxis_B.AbsMove(MoveInfo, MoveInfo.MoveParam.MoveP.ComAxis_AB_P2, Config.ComAxis_B_P2_Speed);
            }
        }
        /// <summary>
        /// AB移栽压紧轴到压紧点P3
        /// </summary>
        private void ComAxis_To_P3()
        {
            if (CheckASide())
            {
                ComAxis_A.AbsMove(MoveInfo, MoveInfo.MoveParam.MoveP.ComAxis_AB_P3, Config.ComAxis_A_P3_Speed);
            }
            else
            {
                ComAxis_B.AbsMove(MoveInfo, MoveInfo.MoveParam.MoveP.ComAxis_AB_P3, Config.ComAxis_B_P3_Speed);
            }
        }
        /// <summary>
        /// 提升抽屉，料斗拉取升降轴到料屉提取高点P3
        /// </summary>
        private void PullAxis_UpdownToP3()
        {
            PullAxis_Updown.AbsMove(MoveInfo, MoveInfo.MoveParam.MoveP.PullAxis_Updown_P3, Config.PullAxis_Updown_P3_Speed);
        }
        /// <summary>
        /// 移栽升降轴到料屉上方过渡点P6/P12
        /// </summary>
        private void UpdownAxisTo_P6_P12()
        {
            if (CheckASide())
            {
                UpdownAxis.AbsMove(MoveInfo, MoveInfo.MoveParam.MoveP.Updown_P6_P12, Config.Updown_P6_Speed);
            }
            else
            {
                UpdownAxis.AbsMove(MoveInfo, MoveInfo.MoveParam.MoveP.Updown_P6_P12, Config.Updown_P12_Speed);
            }
        }
        /// <summary>
        /// AB面移栽旋转轴到料屉库位垂直取放料点P3
        /// </summary>
        private void MiddleAxis_To_P3()
        {
            if (CheckASide())
            {
                MiddleAxis_A.AbsMove(MoveInfo, Config.MiddleAxis_A_P3, Config.MiddleAxis_A_P3_Speed);
            }
            else
            {
                MiddleAxis_B.AbsMove(MoveInfo, Config.MiddleAxis_B_P3, Config.MiddleAxis_B_P3_Speed);
            }
        }
        /// <summary>
        /// AB面移栽X轴到进出料暂存区取放点P2
        /// </summary>
        private void XAxis_To_P2()
        {
            if (CheckASide())
            {
                XAxis_A.AbsMove(MoveInfo, Config.XAxis_A_P2, Config.XAxis_A_P2_Speed);
            }
            else
            {
                XAxis_B.AbsMove(MoveInfo, Config.XAxis_B_P2, Config.XAxis_B_P2_Speed);
            }
        }
        /// <summary>
        /// AB面移栽X轴到料屉库位取放料点P3
        /// </summary>
        private void XAxis_To_P3()
        {
            if (CheckASide())
            {
                XAxis_A.AbsMove(MoveInfo, MoveInfo.MoveParam.MoveP.XAxis_AB_P3, Config.XAxis_A_P3_Speed);
            }
            else
            {
                XAxis_B.AbsMove(MoveInfo, MoveInfo.MoveParam.MoveP.XAxis_AB_P3, Config.XAxis_B_P3_Speed);
            }
        }
        /// <summary>
        /// AB面移栽X轴到待机点
        /// </summary>
        private void XAxis_To_P1()
        {
            if (CheckASide())
            {
                XAxis_A.AbsMove(MoveInfo, Config.XAxis_A_P1, Config.XAxis_A_P1_Speed);
            }
            else
            {
                XAxis_B.AbsMove(MoveInfo, Config.XAxis_B_P1, Config.XAxis_B_P3_Speed);
            }
        }
        #endregion
        /// <summary>
        /// 设置料仓状态
        ///1=设备联机（正常就绪）（入库后，BOX恢复原始状态）（出库后，移载装置恢复原始状态），
        ///2=急停，3=故障，4=警告，5=调试
        ///  6=入库执行中,7=入仓完成，8=入仓失败
        /// 9=出库执行，10=出仓完成，11=出库失败
        /// </summary>
        private void SetBoxStatus(DeviceStatus deviceStatus, RunStatus runStatus)
        {
            this.deviceStatus = deviceStatus;
            this.runStatus = runStatus;
        }
        private void PullAxisToP1(string InOutType = "入库")
        {
            if (!PullAxis_Updown.IsInPosition(Config.PullAxis_Updown_P1))
            {
                PullAxis_Updown.AbsMove(MoveInfo, Config.PullAxis_Updown_P1, Config.PullAxis_Updown_P1_Speed);
            }
            if (!PullAxis_Inout.IsInPosition(Config.PullAxis_Inout_P1))
            {
                PullAxis_Inout.AbsMove(MoveInfo, Config.PullAxis_Inout_P1, Config.PullAxis_Inout_P1_Speed);
            }
            LogInfo($"存储机构-{InOutType} {MoveInfo.SLog}：料屉拉取升降轴、料屉拉取进出轴到待机点P1");
        }
        #region 相机检查库位
        /// <summary>
        /// 检查抽屉是否偏位
        /// </summary>
        /// <returns></returns>
        private bool CamCheckReelPosition()
        {
            if (IgnoreCamDect)
            {
                CamDetectError = false;
                return true;
            }
            AcqImage(CamPosSide(MoveInfo.MoveParam.PosInfo.PosId), out Bitmap bitmap);
            int res = AutoFindPos.GetMarkInfo(bitmap, out ocsFXYR);
            if (res == 0)
            {
                LogInfo($"存储机构-相机检查库位 {MoveInfo.SLog}：取图[{MoveInfo.MoveParam.PosInfo.PosId}]");
            }
            else if (res == -4)
            {
                SetWarnMsg($"存储机构-相机检查库位异常[code={res}]，未找到Mark点。库位号:{MoveInfo.MoveParam.PosInfo.PosId}");
                CamDetectError = true;
                return false;
            }
            else
            {
                SetWarnMsg($"存储机构-相机检查库位异常[code={res}]，未找到Mark点。库位号:{MoveInfo.MoveParam.PosInfo.PosId}");
                CamDetectError = true;
                return false;
            }
            if (Math.Abs(Config.Drawer_X - ocsFXYR.fX) < Config.Drawer_X_Error && Math.Abs(Config.Drawer_Y - ocsFXYR.fY) < Config.Drawer_Y_Error)
            {
                CamDetectError = false;
                return true;
            }
            else
            {
                SetWarnMsg($"存储机构-相机检查库位异常 {MoveInfo.SLog}：Mark点Y轴坐标{ocsFXYR.fY},模板Mark点Y轴坐标{Config.Drawer_Y},Y轴偏差{(Config.Drawer_Y - ocsFXYR.fY)};" +
                    $"Mark点X轴坐标{ ocsFXYR.fX},模板Mark点X轴坐标{ Config.Drawer_X},X轴偏差{ (Config.Drawer_X - ocsFXYR.fX)}，");
            }
            CamDetectError = true;
            return false;
        }
        #endregion
        #region 入库
        private DateTime startInStoreTime = DateTime.Now;
        public override bool StartInstore(InOutParam param)
        {
            if (isInSuddenDown || isNoAirpressure_Check ||
           (!runStatus.Equals(RunStatus.Runing))
           || (!MoveInfo.MoveType.Equals(MoveType.None)))
            {
                LogUtil.error(Name + " 启动入库出错，忙碌或报警中 ，storeStatus=" + runStatus + ",MoveType=" + MoveInfo.MoveType + ",isInSuddenDown=" + isInSuddenDown + ",isNoAirpressure_Check=" + isNoAirpressure_Check);
                return false;
            }
            if (!PreInStoreCheck(param))
            {
                return false;
            }
            startInStoreTime = DateTime.Now;
            LogInfo(" 启动入库【" + param.PosInfo.ToStr() + "】 ");
            param.MoveP = new LineMoveP(Config, param.PosInfo.PosId);
            LogInfo("LoadInoutParam:" + JsonHelper.SerializeObject(param.MoveP));
            MoveInfo.NewMove(MoveType.InStore, param);
            IgnoreCamDect = false;
            SetBoxStatus(DeviceStatus.InStoreExecute, RunStatus.Busy);
            MoveInfo.NextMoveStep(StepEnum.SI_00_StartInstore);
            return true;
        }

        private bool InDoorCheck(InOutParam param)
        {
            if (CheckASide(param))
            {
                if (IOValue(IO_Type.UpperArea_Check_A).Equals(IO_VALUE.HIGH) && param.PosInfo != null)
                {
                    return true;
                }
            }
            else
            {
                if (IOValue(IO_Type.UpperArea_Check_B).Equals(IO_VALUE.HIGH) && param.PosInfo != null)
                {
                    return true;
                }
            }

            return false;
        }

        protected override void InstoreProcess()
        {
            if (MoveInfo.IsInWait)
            {
                CheckWait(MoveInfo);
            }
            if (MoveInfo.IsInWait)
            {
                return;
            }
            InstoreExecute();
        }
        #endregion

        #region 出库
        /// <summary>
        /// 出库前验证
        /// </summary>
        /// <param name="param"></param>
        /// <returns></returns>
        private bool OutDoorCheck(InOutParam param)
        {
            if (param.PosInfo.PosSide.Equals("A"))//A面
            {
                if (CheckAOutDoor())
                {
                    return true;
                }
            }
            else if (param.PosInfo.PosSide.Equals("B"))//B面
            {
                if (CheckBOutDoor())
                {
                    return true;
                }
            }

            return false;
        }
        /// <summary>
        /// 检查A出料口状态
        /// </summary>
        /// <returns>true:A口可以出料</returns>
        private bool CheckAOutDoor()
        {
            if (BufferDataManager.AOutStoreInfo == null && IOValue(IO_Type.UnderArea_Check_A).Equals(IO_VALUE.LOW))
            {
                return true;
            }
            return false;
        }
        /// <summary>
        /// 检查B出料口状态
        /// </summary>
        /// <returns>true:B口可以出料</returns>
        private bool CheckBOutDoor()
        {
            if (BufferDataManager.BOutStoreInfo == null && IOValue(IO_Type.UnderArea_Check_B).Equals(IO_VALUE.LOW))
            {
                return true;
            }
            return false;
        }
        private static object outStoreObject = new object();
        public void StartExecuctOut(InOutParam param)
        {
            bool result = false;
            if (OutDoorCheck(param))
            {
                result = StartOutstore(param);
            }
            if (!result)
            {
                lock (outStoreObject)
                {
                    LogInfo(" 执行出库【" + param.PosInfo.ToStr() + "】失败，加入等待队列");
                    if (MoveInfo.MoveType.Equals(MoveType.OutStore) && MoveInfo.MoveParam.PosInfo.PosId.Equals(param.PosInfo.PosId))
                    {
                        LogUtil.error(Name + " 出库命令【" + param.PosInfo.ToStr() + "】重复，【" + MoveInfo.MoveParam.PosInfo.PosId + "】出库执行中");
                        return;
                    }

                    List<InOutParam> reviceList = new List<InOutParam>();
                    reviceList.AddRange(waitAOutStoreList);
                    reviceList.AddRange(waitBOutStoreList);
                    reviceList = (from m in reviceList where m.PosInfo.PosId.Equals(param.PosInfo.PosId) select m).ToList<InOutParam>();
                    if (reviceList.Count == 0)
                    {
                        if (param.PosInfo.PosSide.Equals("A"))
                        {
                            waitAOutStoreList.Enqueue(param);
                        }
                        else if (param.PosInfo.PosSide.Equals("B"))
                        {
                            waitBOutStoreList.Enqueue(param);
                        }
                    }
                }
            }
        }
        private DateTime startOutStoreTime = DateTime.Now;
        public override bool StartOutstore(InOutParam param)
        {
            if (isInSuddenDown || isNoAirpressure_Check
                || !runStatus.Equals(RunStatus.Runing)
                || !MoveInfo.MoveType.Equals(MoveType.None))
            {
                SetWarnMsg(Name + " 启动出库【" + param.PosInfo.ToStr() + "】失败，忙碌或报警中 ，storeStatus：" + runStatus + ",MoveType：" + MoveInfo.MoveType + ",isInSuddenDown：" + isInSuddenDown + ",isNoAirCheck：" + isNoAirpressure_Check);
                return false;
            }

            if (!param.PosInfo.CheckPosition())
            {
                SetWarnMsg(Name + " 启动出库【" + param.PosInfo.ToStr() + "】出错，找不到库位信息");
                return false;
            }
            startOutStoreTime = DateTime.Now;
            param.MoveP = new LineMoveP(Config, param.PosInfo.PosId);
            SetBoxStatus(DeviceStatus.OutStoreExecute, RunStatus.Busy);
            MoveInfo.NewMove(MoveType.OutStore, param);
            LogInfo("启动出库【" + param.PosInfo.ToStr() + "】  ");
            LogInfo("LoadInoutParam:" + JsonHelper.SerializeObject(param.MoveP));
            IgnoreCamDect = false;
            MoveInfo.NextMoveStep(StepEnum.SI_01_PullAxis_Ready);

            return true;
        }

        protected override void OutstoreProcess()
        {
            if (MoveInfo.IsInWait)
            {
                CheckWait(MoveInfo);
            }
            if (MoveInfo.IsInWait)
            {
                return;
            }
            OutstoreExecute();
        }
        #endregion

    }
}