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

namespace DeviceLibrary
{
    public class OutShelfBean
    {
        public static PuYueRFID_C2S RFID = null;
        public string Name; 
        MoveInfo MoveInfo;
        public string WarnMsg = "";  
        /// <summary>
        /// 出料口定位气缸，high=up，low=down
        /// </summary>
        private CylinderManger locationCylinder; 
        public ShelfInfo CurrShelf; 
        public string rfidIp;
         
        public OutShelfBean(string name )
        {
            this.Name = name;  
            MoveInfo = new MoveInfo(name );

            #region 初始化IO
            string ioStr = name + "_";
            Agv_Detect = ioStr + Agv_Detect;
            Shelf_Front_Check = ioStr + Shelf_Front_Check;
            Shelf_Back_Check = ioStr + Shelf_Back_Check;
            Location_Up = ioStr + Location_Up;
            Location_Down = ioStr + Location_Down;
            Moto_Fwd = ioStr + Moto_Fwd;
            Moto_Rwd = ioStr + Moto_Rwd;

            locationCylinder = new CylinderManger(name + "出料口定位", Location_Up, Location_Down);

            RFID = new PuYueRFID_C2S(rfidIp);
            if (!RFID.Open())
            {
                LogUtil.info(name + " RFID 打开失败：" + rfidIp);
            }
            #endregion
        }
        public void Reset()
        {
            MoveInfo.NewMove(MoveStep.SR01_LocationDown);
            MoveInfo.log("执行重置，定位气缸下降");
            locationCylinder.ToLow(MoveInfo);
            WarnMsg = "";
            pause = false;

        }
        private StoreMoveType storeMoveType = StoreMoveType.None;


        #region 料架状态判断

        public bool IsRightShelf(TrayInfo CurrTray, out string ShelfPosId)
        {
            ShelfPosId = "";
            if (IsDis())
            {
                return false;
            }
            if (ShelfValid())
            {
                if (CurrShelf.realRFID.Equals(CurrTray.realRFID))
                {
                    if (String.IsNullOrEmpty(CurrShelf.rfid))
                    {
                        CurrShelf.rfid = CurrTray.rfid;
                        LogUtil.info(Name + "增加虚拟料架号绑定：" + CurrShelf.ToStr());
                    }
                    ShelfPosId = Name + "_" + +CurrTray.shelfP;
                    return true;
                }
                else if (String.IsNullOrEmpty(CurrTray.realRFID))
                {
                    if ((!CurrShelf.rfid.Equals("")) && CurrShelf.rfid.Equals(CurrTray.rfid))
                    {
                        CurrTray.realRFID = CurrShelf.realRFID;
                        ShelfPosId = Name + "_" + +CurrTray.shelfP;
                        return true;
                    }
                    if (!String.IsNullOrEmpty(CurrTray.usedRfidList))
                    {
                        string[] array = CurrTray.usedRfidList.Split(',');
                        //若料架已使用过，直接返回false
                        if (array.Contains(CurrShelf.realRFID))
                        {
                            return false;
                        }
                    }
                    if (CurrShelf.rfid.Equals(""))
                    {
                        CurrShelf.rfid = CurrTray.rfid;
                        CurrTray.realRFID = CurrShelf.realRFID;
                        LogUtil.info(Name + "增加虚拟料架号绑定：" + CurrShelf.ToStr());
                        ShelfPosId = Name + "_" + CurrTray.shelfP;
                        return true;
                    }
                }
            }

            return false;
        }
        public bool ShelfValid()
        {
            //料架是否有效可放料
            if (CurrShelf.realRFID != "" && CurrShelf.IsNeedLeave == false)
            {
                if (MoveInfo.MoveStep.Equals(MoveStep.S10_ShelfReady) || MoveInfo.MoveStep.Equals(MoveStep.S11_PutReel))
                {
                    return true;
                }
            }
            return false;
        }
        public bool ShelfReady()
        {
            if (MoveInfo.MoveStep.Equals(MoveStep.S10_ShelfReady) && CurrShelf.IsNeedLeave == false)
            {
                if (locationCylinder.IsHigh())
                {
                    return true;
                }
                else
                {
                    locationCylinder.ToHigh(null);
                    WarnMsg = "定位气缸不到位";
                }
            }
            return false;
        }
        public bool StartPutReel()
        {
            if (ShelfReady())
            {
                MoveInfo.NewMove(MoveStep.S11_PutReel);
                MoveInfo.log("开始放料");
                return true;
            }
            return false;
        }

        public void PutReelOk(ShelfTaskInfo taskInfo)
        {
            if (ShelfReady())
            {
                if (MoveInfo.MoveStep.Equals(MoveStep.S11_PutReel))
                { 
                    if (taskInfo.IsValid())
                    {
                        if (taskInfo.smallEmpty == 0 && taskInfo.bigEmpty == 0)
                        {
                            MoveInfo.NextMoveStep(MoveStep.S10_ShelfReady);
                            //当前工单任务已完成，直接送料架离开
                            MoveInfo.log("放料完成，当前工单任务已完成，更改料架为需要离开状态：" + taskInfo.ToStr());
                            CurrShelf.IsNeedLeave = true;
                        }
                        else
                        {
                            MoveInfo.NextMoveStep(MoveStep.S10_ShelfReady);
                            MoveInfo.log("放料完成，料架还有空位，准备放料完成");
                        }
                    }

                }

            }
        }

        #endregion

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

            switch (MoveInfo.MoveStep)
            {
                case MoveStep.Wait:
                    //判断定位气缸是否下降到位
                    if (locationCylinder.IsLow())
                    {
                        if (CheckShelf(IO_VALUE.HIGH))
                        {
                            //料架已到位
                            MoveInfo.NewMove(MoveStep.S04_WaitTime);
                        }
                        else if (IOManager.IOValue(Shelf_Front_Check).Equals(IO_VALUE.HIGH) || IOManager.IOValue(Shelf_Back_Check).Equals(IO_VALUE.HIGH))
                        {
                            //默认是进来的料架 
                            MoveInfo.NewMove(MoveStep.S02_LineFRun);
                            MoveInfo.log("检测到料架信号，电机正传");
                            LineFRun();
                            //等待后端料格检测
                            MoveInfo.WaitList.Add(WaitResultInfo.WaitIO(Shelf_Front_Check, IO_VALUE.HIGH));
                        }
                        else if (IOManager.IOValue(Agv_Detect).Equals(IO_VALUE.HIGH))
                        {
                            //小车已到位
                            //默认是进来的料架 
                            MoveInfo.NewMove(MoveStep.S02_LineFRun);
                            MoveInfo.log("检测到AGV小车，电机正传");
                            LineFRun();
                            //等待后端料格检测
                            MoveInfo.WaitList.Add(WaitResultInfo.WaitIO(Shelf_Front_Check, IO_VALUE.HIGH));
                        }
                        else
                        {
                            //TODO 暂无料架，呼叫小车
                        }
                    }
                    break;
                case MoveStep.SR01_LocationDown:
                    MoveInfo.NewMove(MoveStep.Wait);
                    MoveInfo.log("复位完成");
                    break;
                case MoveStep.S02_LineFRun:
                    MoveInfo.NewMove(MoveStep.S04_WaitTime);
                    MoveInfo.log("检测到料架前端信号，再转动1秒钟");
                    LineFRun();
                    //等待后端料格检测
                    MoveInfo.WaitList.Add(WaitResultInfo.WaitIO(Shelf_Front_Check, IO_VALUE.HIGH));
                    MoveInfo.WaitList.Add(WaitResultInfo.WaitTime(1000));
                    break;
                     
                case MoveStep.S04_WaitTime:

                    //如果料架需要离开，直接离开
                    if (CurrShelf.IsNeedLeave)
                    { 
                        S21_ShelfNeedLeave("料架已经是离开状态");
                    }
                    else
                    {
                        MoveInfo.NewMove(MoveStep.S05_LocationUp);
                        MoveInfo.log("电机停止，定位气缸上升");
                        LineStopRun();
                        locationCylinder.ToHigh(MoveInfo);
                    } 
                    break;
                case MoveStep.S05_LocationUp: 
                    S06_ReadRFID();
                    break;

                case MoveStep.S06_ReadRFID:
                    S06_ReadRFID();
                    break; 

                case MoveStep.S10_ShelfReady:
                    if (CurrShelf.IsNeedLeave)
                    {
                        S21_ShelfNeedLeave("料架已经是离开状态");
                    }
                    else
                    {
                        MoveInfo.WaitList.Add(WaitResultInfo.WaitTime(3000));
                    }
                    break;

                case MoveStep.S11_PutReel:
                    break;

                case MoveStep.S21_ShelfNeedLeave:
                    MoveInfo.NextMoveStep(MoveStep.S22_WaitAGV);
                    MoveInfo.log("呼叫AGV小车");  
                    break;

                case MoveStep.S22_WaitAGV: 
                    //呼叫agv拉料
                    MoveInfo.NextMoveStep(MoveStep.S23_AgvDetect);
                    MoveInfo.WaitList.Add(WaitResultInfo.WaitIO(Agv_Detect, IO_VALUE.HIGH));  
                    MoveInfo.log("等待AGV到达");
                    break;
                case MoveStep.S23_AgvDetect:
                    if (!locationCylinder.IsLow())
                    {
                        MoveInfo.NextMoveStep(MoveStep.S24_LocationDown);
                        MoveInfo.log("定位气缸下降");
                        locationCylinder.ToLow(MoveInfo);
                    }
                    else
                    {
                        MoveInfo.NextMoveStep(MoveStep.S25_LineRRun);
                        MoveInfo.log("电机反转");
                        LineRRun();
                    }
                    break;
                case MoveStep.S24_LocationDown:
                    MoveInfo.NextMoveStep(MoveStep.S25_LineRRun);
                    MoveInfo.log("电机反转");
                    LineRRun();
                    break;
                case MoveStep.S25_LineRRun:
                    MoveInfo.NextMoveStep(MoveStep.S26_ShelfBackHigh);
                    MoveInfo.log("等待后端检测信号亮");
                    LineRRun();
                    MoveInfo.WaitList.Add(WaitResultInfo.WaitIO(Shelf_Back_Check, IO_VALUE.HIGH));
                    break;
                case MoveStep.S26_ShelfBackHigh:
                    MoveInfo.NextMoveStep(MoveStep.S27_ShelfBackLow);
                    MoveInfo.log("等待后端检测信号灭");
                    LineRRun();
                    MoveInfo.WaitList.Add(WaitResultInfo.WaitIO(Shelf_Back_Check, IO_VALUE.LOW));
                    break;
                case MoveStep.S27_ShelfBackLow:
                    MoveInfo.NextMoveStep(MoveStep.S28_WaitTime);
                    MoveInfo.log("继续转动2秒");
                    LineRRun();
                    MoveInfo.WaitList.Add(WaitResultInfo.WaitIO(Shelf_Back_Check, IO_VALUE.LOW));
                    MoveInfo.WaitList.Add(WaitResultInfo.WaitTime(2000));
                    break;
                case MoveStep.S28_WaitTime:
                    MoveInfo.NextMoveStep(MoveStep.Wait);
                    MoveInfo.log("料架已离开，清空料架："+CurrShelf.ToStr());
                    CurrShelf = new ShelfInfo();
                    LineStopRun();
                    break;
                default:
                    MoveInfo.log($"{storeMoveType}:未找到对应步骤:{MoveInfo.MoveStep}");
                    return true;
            }

            return false;
        }

        private void S06_ReadRFID()
        {
            MoveInfo.NextMoveStep(MoveStep.S06_ReadRFID);
            MoveInfo.log("读取RFID");
            if (ReadShelfId())
            {
                if (CurrShelf.rfid == "")
                {
                    S21_ShelfNeedLeave("未读取到RFID");
                }
                else
                {
                    MoveInfo.NextMoveStep(MoveStep.S10_ShelfReady);
                    MoveInfo.log("料架已准备完成");
                }
            }
            else
            {
                MoveInfo.WaitList.Add(WaitResultInfo.WaitTime(1000));
            } 
        }

        private void S21_ShelfNeedLeave(string leaveMsg)
        {
            MoveInfo.NewMove(MoveStep.S21_ShelfNeedLeave);
            locationCylinder.ToLow(MoveInfo);
            MoveInfo.log("料架[" + CurrShelf.ToStr() + "]需要离开：" + leaveMsg + ",定位气缸下降");
        }
        private bool ReadShelfId()
        {
            if (RFID.Open())
            {
                if (RFID.ReadByte(0x20, 16, out byte[] data))
                {
                    string rfid = Encoding.ASCII.GetString(data).Trim();
                    CurrShelf = new ShelfInfo(rfid);
                    LogUtil.info(Name + "RFID["+rfidIp+"]读取到料架号：" + CurrShelf.ToStr());
                    return true;
                }
                else
                {
                    //读取失败,重试之类
                    WarnMsg = "RFID[" + rfidIp + "]读取失败";
                    LogUtil.error(WarnMsg);
                }
            }
            else
            {  
                WarnMsg = "RFID[" + rfidIp + "]打开失败";
                LogUtil.error(WarnMsg);
            }
            return false; 
        }

        #region IO操作
        //agv小车检测
        private string Agv_Detect = "Agv_Detect";

        //出料口前端料格检测
        private string Shelf_Front_Check = "Shelf_Front_Check";

        //出料口后端料格检测
        private string Shelf_Back_Check = "Shelf_Back_Check";

        //出料口定位上升端
        private string Location_Up = "Location_Up";

        //出料口定位下降端,
        private string Location_Down = "Location_Down";

        //电机正传
        private static string Moto_Fwd = "Moto_Fwd";
        //电机反转
        private static string Moto_Rwd = "Moto_Rwd";
        private void LineFRun(MoveInfo move = null)
        {
            lineMove(IO_VALUE.LOW, IO_VALUE.HIGH, move);
        }
        private void LineRRun(MoveInfo move = null)
        {
            lineMove(IO_VALUE.HIGH, IO_VALUE.LOW, move);
        }
        private void LineStopRun(MoveInfo move = null)
        {
            lineMove(IO_VALUE.LOW, IO_VALUE.LOW, move);
        }
        private void lineMove(IO_VALUE rValue, IO_VALUE fValue, MoveInfo move)
        {
            IOManager.IOMove(Moto_Rwd, rValue);
            IOManager.IOMove(Moto_Fwd, fValue);
            if (move != null)
            {
                move.WaitList.Add(WaitResultInfo.WaitIO(Moto_Fwd, fValue));
                move.WaitList.Add(WaitResultInfo.WaitIO(Moto_Rwd, rValue));
            }
        }
        private bool CheckShelf(IO_VALUE value)
        {
            if (IOManager.IOValue(Shelf_Front_Check).Equals(value) && IOManager.IOValue(Shelf_Back_Check).Equals(value))
            {
                return true;
            }
            return false;
        }
        #endregion

        bool pause = false;
        public void Pause()
        {
            pause = true;
        }
        public void Resume()
        {
            pause = false;
        }
        bool movelock = false;
        internal void Lock()
        {
            movelock = true;
        }
        internal void Unlock()
        {
            movelock = false;
        }
        public bool IsDis()
        { 
            return false;
        }
      

    }
    public class ShelfInfo
    {
        //public ShelfTaskInfo TaskInfo = null;
        public string realRFID = "";
        public string rfid = "";
        public bool IsNeedLeave = false;
        public bool IsBusy = false;
        public int EmptyPos = 100;

        public ShelfInfo(string shelfId = "", string xnId = "", bool needLeave = false, bool busy = false)
        {
            this.realRFID = shelfId;
            this.rfid = xnId;
            this.IsNeedLeave = needLeave;
            this.IsBusy = busy;
            EmptyPos = 100;
        }
        public string ToStr()
        {
            string result = "[" + realRFID + "_" + rfid + "]";

            result += "[空位 " + EmptyPos + "]";

            if (IsNeedLeave)
            {
                result += "[需离开]";
            }
            else if (IsBusy)
            {
                result += "[放料中]";
            }
            return result;
        }
    }

}