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


namespace OnlineStore.DeviceLibrary
{
    /// <summary>
    /// 料仓当前运动信息类（出入库状态，步骤记录）
    /// </summary>
    public class StoreMoveInfo
    {
        /// <summary>
        /// 超时时间
        /// </summary>
        public int TimeOutSeconds = 60;
        public StoreMoveInfo(int storeId)
        {
            moveType = StoreMoveType.None;

            MoveParam = new InOutParam();
            this.storeId = storeId;
            this.moveStep = StoreMoveStep.Wait;
            IsInWait = false;
            //   MoveNum = 0;
        }

        // public int MoveNum { get; set; }

        public DateTime LastSetpTime { get; set; }

        /// <summary>
        /// =true表示满足一个等待条件,就可以完成此步骤的等待
        /// </summary>
        public bool OneWaitCanEndStep = false;

        public string SLog
        {
            get { return " " + MoveStep + " "; }
        }


        /// <summary>
        /// 操作类型
        /// </summary>
        private StoreMoveType moveType = StoreMoveType.None;

        public StoreMoveType MoveType
        {
            get { return moveType; }
        }
        /// <summary>
        ///出入库参数
        /// </summary>
        public InOutParam MoveParam { get; set; }
        /// <summary>
        /// 当前运动是哪个料仓
        /// </summary>
        public int storeId { get; set; }

        /// <summary>
        /// 是否再当前步骤等待中
        /// </summary>
        public bool IsInWait { get; set; }

        /// <summary>
        /// 当前执行到的步骤
        /// </summary>
        private StoreMoveStep moveStep;
        /// <summary>
        /// 可以循环运动的次数（轴卡运动才需要）
        /// </summary>
        public int CanWhileCount = 0;
        /// <summary>
        /// 料仓运动步骤记录
        /// </summary>
        public StoreMoveStep MoveStep
        {
            get { return moveStep; }
        }

        public bool SingleInstore = false;

        public void NextMoveStep(StoreMoveStep step)
        {
            //  PreMoveStep = moveStep;
            moveStep = step;
            LastSetpTime = DateTime.Now;
            IsInWait = true;
            WaitList = new List<WaitResultInfo>();
            OneWaitCanEndStep = false;
            CanWhileCount = 5;
        }
        /// <summary>
        /// 当前步骤执行完成
        /// </summary>
        public void EndStepWait()
        {
            IsInWait = false;
            WaitList = new List<WaitResultInfo>();
        }
        //public void NewMove(StoreMoveType type )
        //{
        //    moveStep = StoreMoveStep.Wait;
        //    this.moveType = type; 
        //    LastSetpTime = DateTime.Now;
        //    WaitList = new List<WaitResultInfo>();
        //  //  MoveNum++;
        //    currShelfIndex = -1;
        //}
        public void NewMove(StoreMoveType type, InOutParam param = null)
        {
            moveStep = StoreMoveStep.Wait;
            this.moveType = type;
            if (param == null)
            {
                param = new InOutParam();
            }
            this.MoveParam = param;
            LastSetpTime = DateTime.Now;
            WaitList = new List<WaitResultInfo>();
            currShelfIndex = -1;
            lockShelfIndex = -1;
            SingleInstore = false;
        }
        public void EndMove()
        {
            this.moveType = StoreMoveType.None;
            this.MoveParam = null;
            moveStep = StoreMoveStep.Wait;
            LastSetpTime = DateTime.Now;
            IsInWait = false;
            WaitList = new List<WaitResultInfo>();
            CanWhileCount = 0;
        }
        public StoreMoveInfo clone()
        {
            return (StoreMoveInfo)this.MemberwiseClone();
        }

        public List<WaitResultInfo> WaitList = new List<WaitResultInfo>();

        /// <summary>
        /// 入库时，需要循环料架的料盘取出
        /// </summary>
        public List<string> ShelfPositionList = new List<string>();
        private string currShelfPosId = "";
        public int currShelfIndex = -1;
        private int lockShelfIndex = -1;
        public bool NextShelfPos()
        {
            currShelfIndex++;
            if (currShelfIndex >= ShelfPositionList.Count)
            {
                return false;
            }
            currShelfPosId = ShelfPositionList[currShelfIndex];

            //设置取料位置
            MoveParam.UpdateShelfPosId(currShelfPosId);
            MoveParam.PosID = "";
            return true;
        }
        /// <summary>
        /// 入库时，料架已锁定库位的位置，无需扫码
        /// </summary>
        public bool IsShelfLocked = false;//料架是否锁定
                                          /// <summary>
                                          /// 料架锁定位置的料
                                          /// </summary>
        public List<ShelfLockData> shelfLockDatas = null;
        public bool NextLockedShelfPos()
        {
            lockShelfIndex++;
            if (lockShelfIndex >= shelfLockDatas.Count)
            {
                shelfLockDatas = null;
                return false;
            }
            currShelfIndex = shelfLockDatas[lockShelfIndex].rfidLoc;
            currShelfPosId = ShelfPositionList[currShelfIndex];
            //设置取料位置
            MoveParam.UpdatePosIdAndShelfId(shelfLockDatas[lockShelfIndex].barcode,
                shelfLockDatas[lockShelfIndex].rfid,
                shelfLockDatas[lockShelfIndex].lockPosName, currShelfPosId);
            return true;


        }

    }

    public class WaitResultInfo
    {
        private WaitResultInfo()
        {
            IsEnd = false;
            CanWhileMoveCount = 0;
        }

        public static WaitResultInfo WaitIO(string ioType, IO_VALUE ioValue)
        {
            WaitResultInfo wait = new WaitResultInfo();
            wait.WaitType = WaitEnum.W002_IOValue;
            wait.IoType = ioType;
            wait.IoValue = ioValue;
            return wait;
        }
        public static WaitResultInfo WaitAxis(ConfigMoveAxis axis, int targetPosition, int targetSpeed)
        {
            WaitResultInfo wait = new WaitResultInfo();
            wait.WaitType = WaitEnum.W001_AxisMove;
            wait.AxisInfo = axis;
            wait.IsHomeMove = false;
            wait.TargetPosition = targetPosition;
            wait.TargetSpeed = targetSpeed;
            return wait;
        }
        public static WaitResultInfo WaitAxis(ConfigMoveAxis axis, bool isHomeMove)
        {
            WaitResultInfo wait = new WaitResultInfo();
            wait.WaitType = WaitEnum.W001_AxisMove;
            wait.AxisInfo = axis;
            wait.IsHomeMove = true;
            return wait;
        }
        //public static WaitResultInfo WaitStell(byte slvAddr, int targetPosition, int speed)
        //{
        //    WaitResultInfo wait = new WaitResultInfo();
        //    wait.CanWhileMoveCount =10;
        //    wait.WaitType = WaitEnum.W004_StellMove;
        //    wait.SlvAddr = slvAddr;
        //    wait.IsHomeMove = false;
        //    wait.TargetPosition = targetPosition;
        //    wait.TargetSpeed = speed; 
        //    return wait;
        //}
        // public static WaitResultInfo WaitStellHome(byte slvAddr, int targetPosition, int speed)
        //{
        //    WaitResultInfo wait = new WaitResultInfo();
        //    wait.CanWhileMoveCount = 10;
        //    wait.WaitType = WaitEnum.W004_StellMove;
        //    wait.SlvAddr = slvAddr;
        //    wait.IsHomeMove = true;
        //    wait.TargetPosition = 0;
        //    wait.TargetSpeed = speed; 
        //    return wait;
        //}
        //public static WaitResultInfo WaitShuoKe(int slvAddr, int targetPosition, bool isHome)
        //{
        //    WaitResultInfo wait = new WaitResultInfo();
        //    wait.CanWhileMoveCount = 0;
        //    wait.WaitType = WaitEnum.W005_ShuoKe;
        //    wait.SlvAddr =(byte) slvAddr;
        //    wait.TargetPosition = targetPosition;
        //    wait.IsHomeMove = isHome;
        //    return wait;
        //}
        public static WaitResultInfo WaitTime(int MScends)
        {
            WaitResultInfo wait = new WaitResultInfo();
            wait.CanWhileMoveCount = 0;
            wait.WaitType = WaitEnum.W003_Time;
            wait.TimeMSeconds = MScends;
            wait.IsEnd = false;
            return wait;
        }
        public static WaitResultInfo WaitAxisOrg(ConfigMoveAxis axis, IO_VALUE value)
        {
            WaitResultInfo wait = new WaitResultInfo();
            wait.WaitType = WaitEnum.W006_AxisOrg;
            wait.AxisInfo = axis;
            wait.IsHomeMove = true;
            wait.IoValue = value;
            wait.IsEnd = false;
            return wait;
        }
        public static WaitResultInfo WaitComAxis(ConfigMoveAxis axis, int targetPosition, int targetSpeed)
        {
            WaitResultInfo wait = new WaitResultInfo();
            wait.WaitType = WaitEnum.W008_Compress;
            wait.AxisInfo = axis;
            wait.IsHomeMove = false;
            wait.TargetPosition = targetPosition;
            wait.TargetSpeed = targetSpeed;
            return wait;
        }

        internal static WaitResultInfo WaitCode()
        {
            WaitResultInfo wait = new WaitResultInfo();
            wait.WaitType = WaitEnum.W009_ScanCode;
            wait.IsHomeMove = false;
            return wait;
        }
        public static WaitResultInfo WaitAgvAction(int arrive)
        {
            WaitResultInfo wait = new WaitResultInfo();
            wait.WaitType = WaitEnum.W010_AgvStatus;
            wait.AgvAction = arrive;
            return wait;
        }
        public static WaitResultInfo WaitDoorClose()
        {
            WaitResultInfo wait = new WaitResultInfo();
            wait.WaitType = WaitEnum.W011_DoorCloseEvent;
            return wait;
        }
        public string ToStr()
        {
            if (WaitType.Equals(WaitEnum.W001_AxisMove))
            {
                if (IsHomeMove)
                {
                    return "轴【" + AxisInfo.DisplayStr + "】原点返回";
                }
                else
                {
                    return "轴【" + AxisInfo.DisplayStr + "】绝对运动，目标位置【" + TargetPosition + "】";
                }
            }
            else if (WaitType.Equals(WaitEnum.W002_IOValue))
            {
                return "等待【" + IoType + "】=【" + IoValue + "】";
            }
            else if (WaitType.Equals(WaitEnum.W003_Time))
            {
                return "时间等待：【" + TimeMSeconds + "】毫秒";
            }
            else if (WaitType.Equals(WaitEnum.W004_StellMove))
            {
                return "电钢目标位置：【" + TargetPosition + "】 ";
            }
            else if (WaitType.Equals(WaitEnum.W005_ShuoKe))
            {
                return "硕科电机目标位置：【" + TargetPosition + "】 ";
            }
            else if (WaitType.Equals(WaitEnum.W006_AxisOrg))
            {
                return "轴【" + AxisInfo.DisplayStr + "】ORG信号：【" + IoValue + "】 ";
            }
            else if (WaitType.Equals(WaitEnum.W007_ReelHeight))
            {
                return "料盘高度【" + TargetPosition + "】  ";
            }
            else if (WaitType.Equals(WaitEnum.W008_Compress))
            {
                return "压紧轴压紧到位";
            }
            else if (WaitType.Equals(WaitEnum.W009_ScanCode))
            {
                return "扫码完成";
            }
            else if (WaitType.Equals(WaitEnum.W010_AgvStatus))
            {
                return " Agv_" + (ClientAction)AgvAction + " ";
            }
            else if (WaitType.Equals(WaitEnum.W011_DoorCloseEvent))
            {
                return "Agv_DoorClose事件";
            }
            else
            {
                return "Wait位置类型：WaitType=【" + WaitType + "】";
            }
        }
        /// <summary>
        /// 当未结束时可以重复运动的次数
        /// </summary>
        public int CanWhileMoveCount { get; set; }
        /// <summary>
        /// 等待结果，1=轴运动，2=IO运动，3=时间,4=电钢,5=硕科电机,6=等待轴原点信号，8=等待压紧轴压紧到位
        /// </summary>
        public int WaitType { get; set; }
        /// <summary>
        /// 轴运动时表示轴信息
        /// </summary>
        public ConfigMoveAxis AxisInfo { get; set; }
        /// <summary>
        /// 电钢地址
        /// </summary>
        public byte SlvAddr { get; set; }
        /// <summary>
        /// IO类型
        /// </summary>
        public String IoType { get; set; }
        /// <summary>
        /// IO值
        /// </summary>
        public IO_VALUE IoValue { get; set; }
        /// <summary>
        /// 等待的毫秒
        /// </summary>
        public int TimeMSeconds { get; set; }
        /// <summary>
        /// 是否是原点返回
        /// </summary>
        public bool IsHomeMove = false;

        /// <summary>
        /// 轴目标位置
        /// </summary>
        public int TargetPosition { get; set; }
        /// <summary>
        /// 轴目标速度
        /// </summary>
        public int TargetSpeed { get; set; }
        /// <summary>
        /// 是否已经结束
        /// </summary>
        public bool IsEnd { get; set; }

        public int AgvAction = 0;


    }
    internal class WaitEnum
    {
        /// <summary>
        /// 伺服运动
        /// </summary>
        internal static int W001_AxisMove = 1;
        /// <summary>
        /// 信号到达
        /// </summary>
        internal static int W002_IOValue = 2;
        /// <summary>
        /// 时间等待
        /// </summary>
        internal static int W003_Time = 3;
        /// <summary>
        /// 电钢运动
        /// </summary>
        internal static int W004_StellMove = 4;
        /// <summary>
        /// 硕科电机
        /// </summary>
        internal static int W005_ShuoKe = 5;
        /// <summary>
        /// 轴原点信号
        /// </summary>
        internal static int W006_AxisOrg = 6;
        /// <summary>
        /// 料盘高度
        /// </summary>
        internal static int W007_ReelHeight = 7;
        /// <summary>
        /// 压紧轴压紧到位
        /// </summary>
        internal static int W008_Compress = 8;
        /// <summary>
        /// 扫码完成
        /// </summary>
        internal static int W009_ScanCode = 9;
        /// <summary>
        /// Agv状态
        /// </summary>
        internal static int W010_AgvStatus = 10;

        /// <summary>
        /// 等待agvDoorClose事件
        /// </summary>
        internal static int W011_DoorCloseEvent = 11;
    }
    public enum StoreMoveType
    {
        /// <summary>
        /// 没有任何操作
        /// </summary>
        None = 0,
        /// <summary>
        /// 入库
        /// </summary>
        InStore = 1,
        /// <summary>
        /// 出库
        /// </summary>
        OutStore = 2,
        /// <summary>
        /// 原点返回
        /// </summary>
        ReturnHome = 3,
        /// <summary>
        /// 重置
        /// </summary>
        StoreReset = 4,
        ///// <summary>
        ///// 移栽装置的停止，需要先远点返回，然后停止
        ///// </summary>
        //StopMove=5,
        ///// <summary>
        ///// 移栽检测托盘
        ///// </summary>
        //CheckFixture=6,
    }
}