using log4net.Layout;
using OnlineStore.Common;
using System;
using System.Collections.Generic;


namespace CtuDeviceLib
{
    /// <summary>
    /// 料仓当前运动信息类（出入库状态，步骤记录）
    /// </summary>
    public class LineMoveInfo
    {
        /// <summary>
        /// 超时时间
        /// </summary>
        public int TimeOutSeconds = 60;
        public string Name = "";
        public bool ShelfNoTray = false;
        public LineMoveInfo(string name)
        {
            this.Name = name;
            moveType = MoveType.None;
            
            MoveParam = new InOutParam();
            this.moveStep = RunStep.Wait;
            IsInWait = false;
            MoveNum = 0;
        }

        public int MoveNum { get; set; }

        public DateTime MoveStartTime { get; set; }

        public DateTime LastSetpTime { get; set; }

        /// <summary>
        /// =true表示满足一个等待条件,就可以完成此步骤的等待
        /// </summary>
        public bool OneWaitCanEndStep = false;
        
        /// <summary>
        /// 操作类型
        /// </summary>
        private MoveType moveType = MoveType.None;

        public MoveType MoveType
        {
            get { return moveType; }
        }
        /// <summary>
        ///出入库参数
        /// </summary>
        public InOutParam MoveParam { get; set; }

        /// <summary>
        /// 是否再当前步骤等待中
        /// </summary>
        public bool IsInWait { get; set; }
        /// <summary>
        /// 上一个执行步骤
        /// </summary>
        public RunStep PreMoveStep { get; set; }
        /// <summary>
        /// 当前执行到的步骤
        /// </summary>
        private RunStep moveStep;
        /// <summary>
        /// 可以循环运动的次数（轴卡运动才需要）
        /// </summary>
        public int CanWhileCount = 0;
        /// <summary>
        /// 料仓运动步骤记录
        /// </summary>
        public RunStep MoveStep
        {
            get { return moveStep; }
        }
        public bool IsStep(RunStep step)
        {
            return (MoveStep.Equals(step));
        }
        public string SLog
        {
            get { return " "+MoveStep + " "; }
        }

        string curTaskInfo = "";
        public void SetCurTaskInfo(RobotTask task)
        {
            if(task==null)
            {
                curTaskInfo = "";
            }
            else
            {
                curTaskInfo = $"{task?.TaskId}";
            }
        }
        public void SetCurTaskInfo(string prefixMsg)
        {
            curTaskInfo = prefixMsg;
        }
        string preInfo = "";

        public string Msg;
        public void Info(string msg)
        {
            if (string.IsNullOrEmpty(msg)) return;
            if (!preInfo.Equals(msg))
            {
                LogUtil.info($"【{Name}】【{curTaskInfo}】【{SLog}】:{msg}");
                preInfo = msg;
                Msg=msg;
            }
        }
        string preError = "";
        public void Error(string msg)
        {
            if (string.IsNullOrEmpty(msg)) return;
            if(!preError.Equals(msg))
            {
                LogUtil.error($"【{Name}】【{curTaskInfo}】【{SLog}】:{msg}");
                preError = msg;
                Msg = msg;
            }

        }

        public bool IsTimeOut(int timeOutSeconds = 60)
        {
            TimeSpan span = DateTime.Now - LastSetpTime;
            if (span.TotalSeconds > timeOutSeconds)
            {
                return true;
            }
            return false;
        }
        public TimeSpan StepSpan()
        {
            TimeSpan span = DateTime.Now - LastSetpTime;
            return span;
        }
        public void NextMoveStep(RunStep step)
        {
            StepMoveLog();
            PreMoveStep = moveStep;
            moveStep = step;
            LastSetpTime = DateTime.Now; 
            IsInWait = true;
            WaitList = new List<WaitResultInfo>();
            WriteIoList = new List<WriteIOInfo>();
            OneWaitCanEndStep = false;
            CanWhileCount = 5;
        }
        /// <summary>
        /// 当前步骤执行完成
        /// </summary>
        public void EndStepWait()
        {
            IsInWait = false;
            WaitList = new List<WaitResultInfo>();
            WriteIoList = new List<WriteIOInfo>();
        }
        public void NewMove(MoveType type )
        {
            moveStep = RunStep.Wait;
            this.moveType = type; 
            LastSetpTime = DateTime.Now;
            WaitList = new List<WaitResultInfo>();
            WriteIoList = new List<WriteIOInfo>();
            MoveNum++; 
            MoveStartTime = DateTime.Now;
        }
        public void NewMove(MoveType type, InOutParam param)
        {
            moveStep = RunStep.Wait;
            this.moveType = type;
            this.MoveParam = param;
            LastSetpTime = DateTime.Now;
            WaitList = new List<WaitResultInfo>();
            WriteIoList = new List<WriteIOInfo>();
            MoveStartTime = DateTime.Now;
        }
        public void EndMove()
        {
            StepMoveLog();
            this.moveType = MoveType.None;
            this.MoveParam = new InOutParam(); 
            moveStep = RunStep.Wait;
            LastSetpTime = DateTime.Now;
            IsInWait = false;
            WaitList = new List<WaitResultInfo>();
            WriteIoList = new List<WriteIOInfo>();
            CanWhileCount = 0;
        }
        public LineMoveInfo clone()
        {
            return (LineMoveInfo)this.MemberwiseClone();
        }

        public List<WaitResultInfo> WaitList = new List<WaitResultInfo>();
        public List<WriteIOInfo> WriteIoList = new List<WriteIOInfo>();
        /// <summary>
        /// 重置之后继续出入库时，退回上一个步骤执行
        /// </summary>
        public void BackStep()
        {
            moveStep = PreMoveStep;
            IsInWait = false;
        }

        internal string ToStr()
        {
            string str = $"[{MoveType}][{MoveStep}]{ MoveParam?.ToStr()}";
            return str;
        }
        public string GetMoveType()
        {
            switch (moveType)
            {
                case MoveType.InStore:
                    return "入料";
                case MoveType.OutStore:
                    return "出料";
            }
            return "";
        }
        private void StepMoveLog()
        {
            //try
            //{

            //    RunLogUtil.MoveLog(new MoveLog(Name, GetMoveType(), GetStepDes(), LastSetpTime, DateTime.Now, MoveParam.PosId, MoveParam.WareCode));
            //}
            //catch (Exception ex)
            //{

            //}
        }
    }
    public class WriteIOInfo
    {
        public static  WriteIOInfo NInfo(string type,IO_VALUE value)
        {
            WriteIOInfo i = new WriteIOInfo();
            i.IoType = type;
            i.IoValue = value;
            return i;
        }
        public string IoType = "";
        public IO_VALUE IoValue = IO_VALUE.HIGH;
    }
    public class WaitResultInfo
    {
        private WaitResultInfo()
        {
        }

        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;
        //}

        public static WaitResultInfo WaitHeight(int height)
        {
            WaitResultInfo wait = new WaitResultInfo(); 
            wait.WaitType = WaitEnum.W007_ReelHeight;
            wait.HeightValue = height;
            wait.IsEnd = false;
            return wait;
        }
        public static WaitResultInfo WaitCanInstore()
        {
            WaitResultInfo wait = new WaitResultInfo();
            wait.WaitType = WaitEnum.W008_InStoreCheckOK;  
            return wait;
        }
        public static WaitResultInfo WaitBoxCanReviceTray( )
        {
            WaitResultInfo wait = new WaitResultInfo();
            wait.WaitType = WaitEnum.W009_BoxCanInstore;
            return wait;
        }      

        public static WaitResultInfo WaitFeedScanCode()
        {
            WaitResultInfo wait = new WaitResultInfo();
            wait.WaitType = WaitEnum.W102_FeedScanCode;
            return wait;
        }
        /// <summary>
        /// 入料机构拿走料串上的料，需要同时 SL_ClampCylinder_Check=HIGH，SL_AxisLocationCheck=LOW
        /// </summary>
        /// <returns></returns>
        public static WaitResultInfo WaitGetShelfTray()
        {
            WaitResultInfo wait = new WaitResultInfo();
            wait.WaitType = WaitEnum.W103_GetShelfTray;
            return wait;
        }
        ///// <summary>
        ///// 移栽入料时抓取料盘
        ///// </summary>
        ///// <returns></returns>
        //public static WaitResultInfo WaitInStoreGetTray()
        //{
        //    WaitResultInfo wait = new WaitResultInfo();
        //    wait.WaitType = WaitEnum.W010_InStoreGetTray;
        //    return wait;
        //}
        /// <summary>
        /// 未抓起料报警
        /// </summary>
        /// <returns></returns>
        public static WaitResultInfo WaitNoTrayAlarm()
        {
            WaitResultInfo wait = new WaitResultInfo();
            wait.WaitType = WaitEnum.W1000_NoTrayAlarm;
            return wait;
        }
        public string ToStr()
        {
            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.W007_ReelHeight))
            {
                return "料盘高度【" + HeightValue + "】  ";
            }else if (WaitType.Equals(WaitEnum.W008_InStoreCheckOK))
            {
                return "入库库位验证完成";
            }
            else if (WaitType.Equals(WaitEnum.W009_BoxCanInstore))
            {
                return "BOX可以开始入库";
            } else if (WaitType.Equals(WaitEnum.W010_InStoreGetTray))
            { 
                return "抓起料盘";
            }
            else if (WaitType.Equals(WaitEnum.W101_BatchAxisMove))
            {
                return "上料轴缓慢上升";
            }
            else if (WaitType.Equals(WaitEnum.W102_FeedScanCode))
            {
                return "入料模块扫码";
            } else if (WaitType.Equals(WaitEnum.W103_GetShelfTray))
            {
                return "抓起料盘";
            }
            else if (WaitType.Equals(WaitEnum.W1000_NoTrayAlarm))
            { 
                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 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; }

      
    }
    public class WaitEnum
    {
        /// <summary>
        /// 伺服运动
        /// </summary>
        public static int W001_AxisMove = 1;
        /// <summary>
        /// 信号到达
        /// </summary>
        public static int W002_IOValue = 2;
        /// <summary>
        /// 时间等待
        /// </summary>
        public static int W003_Time = 3;
        /// <summary>
        /// 电钢运动
        /// </summary>
        public static int W004_StellMove = 4;
        /// <summary>
        /// 硕科电机
        /// </summary>
        public static int W005_ShuoKe = 5;
        /// <summary>
        /// 轴原点信号
        /// </summary>
        public static int W006_AxisOrg = 6;
        /// <summary>
        /// 料盘高度
        /// </summary>
        public static int W007_ReelHeight = 7;
        /// <summary>
        /// 入库库位验证完成
        /// </summary>
        public static int W008_InStoreCheckOK = 8;
        /// <summary>
        /// BOX可以开始入库
        /// </summary>
        public static int W009_BoxCanInstore = 9;
        /// <summary>
        /// 入库时移栽拿走料盘上的料
        /// </summary>
        public static int W010_InStoreGetTray = 10;
        ///// <summary>
        ///// 等待横移模块可以顶升，等待入料四和入料一处无托盘处理
        ///// </summary>
        //internal static int W010_SWCanTopUp = 10;
        /// <summary>
        /// 入料模块：批量轴缓慢上升，并检测有料盘后停止
        /// </summary>
        public static int W101_BatchAxisMove = 101;
        /// <summary>
        /// 入料模块扫码
        /// </summary>
        public static int W102_FeedScanCode = 102;
        /// <summary>
        /// 入料机构拿走料串上的料，需要同时 SL_ClampCylinder_Check=HIGH，SL_AxisLocationCheck=LOW
        /// </summary>
        public static int W103_GetShelfTray = 103;

        /// <summary>
        /// 未抓起料盘,请取走料盘后复位
        /// </summary>
        public static int W1000_NoTrayAlarm = 1000;
    }

}