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

namespace OnlineStore.DeviceLibrary
{ 
    public class RobotMoveInfo
    {
        internal DateTime preCheckAxisTime = DateTime.Now;
        internal DateTime MoveStartTime = DateTime.Now;
        private static int MaxMoveId=1;
        /// <summary>
        /// 超时时间
        /// </summary>
        internal int TimeOutSeconds = 60;
        internal string Name = "";
        internal bool ShelfNoTray = false;
        internal int MoveID = 0;
        public RobotMoveInfo(string name)
        {
            this.Name = name;
            moveType = RobotMoveType.None;
            MoveParam = new WorkParam();
            this.moveStep = StepEnum.Wait;
            IsInWait = false;
            MoveNum = 0;
            MoveID = MaxMoveId++;
        }
        public int ErrorLogType
        {
            get { return MaxMoveId * 100000 + (int)MoveStep; }
        }
        public int MoveNum { get; set; }

        public DateTime LastSetpTime { get; set; }

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

     
        private RobotMoveType moveType;

        public RobotMoveType MoveType
        {
            get { return moveType; }
        }
      
        public WorkParam MoveParam { get; set; }

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


        /// <summary>
        /// 可以循环运动的次数（轴卡运动才需要）
        /// </summary>
        internal int CanWhileCount = 0;

        private StepEnum moveStep;
        internal StepEnum MoveStep
        {
            get { return moveStep; }
        }

        internal bool IsStep(StepEnum step)
        {
            return MoveStep.Equals(step);
        }
        internal bool IsTimeOut(int timeOutSeconds = 60)
        {
            TimeSpan span = DateTime.Now - LastSetpTime;
            if (span.TotalSeconds > timeOutSeconds)
            {
                return true;
            }
            return false;
        }
        internal int logSeconds()
        {
            TimeSpan span = DateTime.Now - LastSetpTime;
            int second = 10;
            second = (int)( span.TotalSeconds/ TimeOutSeconds) * 10;
            if (second > 120)
            {
                second = 120;
            }
            else if (second < 10)
            {
                second = 10;
            }
            return second;
        }
        internal TimeSpan StepSpan()
        {
            TimeSpan span = DateTime.Now - LastSetpTime;
            return span;
        }
        internal void NextMoveStep(StepEnum step)
        { 
            moveStep = step;
            LastSetpTime = DateTime.Now; 
            IsInWait = true;
            WaitList = new List<WaitResultInfo>(); 
            OneWaitCanEndStep = false;
            CanWhileCount = 5;
        }
        /// <summary>
        /// 当前步骤执行完成
        /// </summary>
        internal void EndStepWait()
        {
            IsInWait = false;
            WaitList = new List<WaitResultInfo>(); 
        }
        public void NewMove(RobotMoveType type , StepEnum step= StepEnum.Wait)
        {
            MoveParam = new WorkParam();
            moveStep = step;
            this.moveType = type; 
            LastSetpTime = DateTime.Now;
            WaitList = new List<WaitResultInfo>(); 
            MoveNum++;
            MoveStartTime = DateTime.Now; 
        }
        public void EndMove()
        {
            this.moveType = RobotMoveType.None;
            this.moveStep = StepEnum.Wait;
            this.MoveParam = null;  
            LastSetpTime = DateTime.Now;
            IsInWait = false;
            WaitList = new List<WaitResultInfo>(); 
            CanWhileCount = 0;
        }
      

        public List<WaitResultInfo> WaitList = new List<WaitResultInfo>(); 
         
    } 
    public class WaitResultInfo
    {
        private WaitResultInfo()
        {
        }

        public static  WaitResultInfo WaitIO(string ioType, IO_VALUE ioValue,int targetP=0)
        {
            //targetP=0表示默认，=1必须检测DI,=2必须检测DO
            WaitResultInfo wait = new WaitResultInfo();
            wait.CanWhileMoveCount = 0;
            wait.WaitType = WaitEnum.W002_IOValue;
            wait.IoType = ioType;
            wait.IoValue = ioValue;
            wait.TargetPosition = targetP;
            wait.IsEnd = false;
            return wait;
        }
        public static WaitResultInfo WaitAxis(ConfigMoveAxis axis,int targetPosition,int targetSpeed )
        {
            WaitResultInfo wait = new WaitResultInfo();
            wait.CanWhileMoveCount = 0;
            wait.WaitType = WaitEnum.W001_AxisMove;
            wait.AxisInfo = axis;
            wait.IsHomeMove = false;
            wait.TargetPosition = targetPosition;
            wait.TargetSpeed = targetSpeed;
            wait.IsEnd = false;
            return wait;
        }
        public static WaitResultInfo WaitAxis(ConfigMoveAxis axis, bool isHomeMove)
        {
            WaitResultInfo wait = new WaitResultInfo();
            wait.CanWhileMoveCount = 0;
            wait.WaitType = WaitEnum.W001_AxisMove;
            wait.AxisInfo = axis;
            wait.IsHomeMove = true;
            wait.IsEnd = false;
            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;
            wait.IsEnd = false;
            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;
            wait.IsEnd = false;
            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.CanWhileMoveCount = 0;
            wait.WaitType = WaitEnum.W006_AxisOrg;
            wait.AxisInfo = axis;
            wait.IsHomeMove = true;
            wait.IoValue = value;
            wait.IsEnd = false;
            return wait;
        }
         
        /// <summary>
        /// 等待出料移栽可以开始移栽
        /// </summary> 
        public static WaitResultInfo WaitProvidingEquipCanOut()
        {
            WaitResultInfo wait = new WaitResultInfo();
            wait.WaitType = WaitEnum.W201_ProvidingCanOut;  
            return wait;
        }
        /// <summary>
        /// 等待出料流水线可以接收料盘
        /// </summary> 
        public static WaitResultInfo WaitDLineCanReviceTray()
        {
            WaitResultInfo wait = new WaitResultInfo();
            wait.WaitType = WaitEnum.W202_DLineCanOut;
            return wait;
        }
        public static WaitResultInfo WaitBatchAxis(ConfigMoveAxis axis, int targetPosition, int targetSpeed)
        {
            WaitResultInfo wait = new WaitResultInfo();
            wait.CanWhileMoveCount = 0;
            wait.WaitType = WaitEnum.W101_BatchAxisMove;
            wait.AxisInfo = axis;
            wait.IsHomeMove = false;
            wait.TargetPosition = targetPosition;
            wait.TargetSpeed = targetSpeed;
            wait.IsEnd = false;
            return wait;
        }
        public static WaitResultInfo WaitFeedScanCode()
        {
            WaitResultInfo wait = new WaitResultInfo();
            wait.WaitType = WaitEnum.W102_FeedScanCode;
            return wait;
        }
        public static WaitResultInfo WaitFeedNoMove()
        {
            WaitResultInfo wait = new WaitResultInfo();
            wait.WaitType = WaitEnum.W103_FeedNoMove;
            return wait;
        }
        public static WaitResultInfo WaitDLineScanCode()
        {
            WaitResultInfo wait = new WaitResultInfo();
            wait.WaitType = WaitEnum.W301_DLineScanCode;
            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.W101_BatchAxisMove))
            {
                return "上料轴缓慢上升";
            }
            else if (WaitType.Equals(WaitEnum.W102_FeedScanCode))
            {
                return "入料模块扫码";
            }
            else if (WaitType.Equals(WaitEnum.W103_FeedNoMove))
            {
                return "横移机构空闲";
            }
            else if (WaitType.Equals(WaitEnum.W201_ProvidingCanOut))
            {
                return "可移栽出料";
            }else if (WaitType.Equals(WaitEnum.W202_DLineCanOut))
            {
                return "皮带线可放料盘";
            }
            else if (WaitType.Equals(WaitEnum.W301_DLineScanCode))
            {
                return "出料皮带线扫码"; 
            }
            else 
            {
                return "Wait位置类型：WaitType=【" + WaitType + "】";
            }
        }
        /// <summary>
        /// 当未结束时可以重复运动的次数
        /// </summary>
        public int CanWhileMoveCount { get; set; }
        /// <summary>
        /// 等待结果，1=轴运动，2=IO运动，3=时间,4=电钢,5=硕科电机,6=等待轴原点信号
        /// </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; }
        /// <summary>
        /// 高度
        /// </summary>
        public int HeightValue { get; set; }

      
    }
    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 W101_BatchAxisMove = 101;
        /// <summary>
        /// 入料模块扫码
        /// </summary>
        internal static int W102_FeedScanCode = 102;
        /// <summary>
        /// 入料横移机构空闲
        /// </summary>
        internal static int W103_FeedNoMove = 103;
        /// <summary>
        /// 移栽模块可移栽出库
        /// </summary>
        internal static int W201_ProvidingCanOut = 201;
        /// <summary>
        /// 等待出料流水线可以接收料盘
        /// </summary>
        internal static int W202_DLineCanOut = 202;
        /// <summary>
        ///等待出料皮带线扫码结束
        /// </summary>
        internal static int W301_DLineScanCode = 301;
    }
    public enum RobotMoveType
    {
        /// <summary>
        /// 没有任何操作
        /// </summary>
        None = 0,

        /// <summary>
        /// 原点返回
        /// </summary>
        RHome = 1,
        /// <summary>
        /// 重置
        /// </summary>
        Reset = 2,
        /// <summary>
        /// 入库
        /// </summary>
        Working = 3,
        /// <summary>
        /// 贴标
        /// </summary>
        Labelling = 4,
        /// <summary>
        /// 料串处理
        /// </summary>
        ShelfPro = 5,
    }
    
}