using DeviceLib;
using log4net; 
using OnlineStore.Common;
using OnlineStore.LoadCSVLibrary;
using System;
using System.Collections.Generic;
using System.Drawing;
using System.Linq;
using System.Text;
using System.Threading;
using System.Threading.Tasks;

namespace OnlineStore.DeviceLibrary
{
    /// <summary>
    /// 康泰克单台自动料仓
    /// </summary>
    public abstract class KTK_Store
    {
        /// <summary>
        ///1=设备联机（正常就绪）（入库后，BOX恢复原始状态）（出库后，移载装置恢复原始状态），
        ///2=急停，3=故障，4=警告，5=调试
        ///  6=入库执行中,7=入仓完成，8=入仓失败
        /// 9=出库执行，10=出仓完成，11=出库失败
        /// </summary>
        public StoreStatus storeStatus = StoreStatus.ResetMove;
        /// <summary>
        /// 提示消息，一般发给服务器后清空（LineBean表示报警提示消息，BoxBean表示出入库失败的原因记录）
        /// </summary>
        public string WarnMsg = "";
        /// <summary>
        /// 日志颜色
        /// </summary>
        protected static Color storeMoveColor = Color.Blue; 
        public string Name { get; set; }
        public int ID { get; set; }
        public BaseConfig baseConfig = null;
        /// <summary>
        /// 料仓状态
        /// </summary>
        private StoreRunStatus storerunstatus = StoreRunStatus.Wait;
       
        protected System.Timers.Timer mainTimer;
        protected System.Timers.Timer serverConTimer = new System.Timers.Timer();
        protected System.Timers.Timer IoCheckTimer = new System.Timers.Timer();
        private bool isInit = false;

        public  bool IsDebug = false;

        public KTK_Store()
        {
        }
        /// <summary>
        /// 开始运行的时间
        /// </summary>
        public DateTime StartTime { get; set; }

        /// <summary>
        /// 最后一次气压检测变为0的时间
        /// </summary>
        public DateTime lastAirCloseTime = DateTime.Now;
        /// <summary>
        /// 是否在急停中
        /// </summary>
        public bool isInSuddenDown = false;
        /// <summary>
        /// 是否没有检测到气压
        /// </summary>
        public bool isNoAirCheck = false;
         
        /// <summary>
        /// 是否再报警中
        /// </summary>
        public AlarmType alarmType = AlarmType.None;

        public AlarmInfo alarmInfo = new AlarmInfo();

      
        /// <summary>
        /// 获取料仓运行的时间
        /// </summary>
        /// <returns></returns>
        public TimeSpan GetStoreRunTime()
        {
            if (StartTime != null)
            {
                return DateTime.Now - StartTime;
            }
            else
            {
                return new TimeSpan(0);
            }
        } 
        /// <summary>
        /// 运动处理
        /// </summary> 
        protected bool isInPro = false;
        protected virtual void BusyMoveProcess()
        {
            //if (isInPro)
            //{
            //    return;
            //}
            isInPro = true;
            try
            {
                switch (MoveInfo.MoveType)
                {
                    case MoveType.InStore:
                        InStoreProcess();
                        isInPro = false;
                        break;
                    case MoveType.OutStore:
                        OutStoreProcess();
                        isInPro = false;
                        break;
                    case MoveType.ReturnHome:
                        ResetProcess();
                        isInPro = false;
                        break;
                    case MoveType.Reset:
                        ResetProcess();
                        isInPro = false;
                        break;
                    default: break;
                }
            }
            catch (Exception ex)
            {
                LogUtil.error("BusyMoveProcess出错：" + ex.ToString());
            }
            isInPro = false;
        }
        protected void SaveAlarmInfo(AlarmType alarmType, string alarmDetial, string alarmMsg, MoveType storeMoveType)
        {
            alarmMsg = alarmMsg.Replace(Name, "");
            int inoutStatus = 0;
            if (storeMoveType.Equals(MoveType.InStore))
            {
                inoutStatus = 1;
            }
            else if (storeMoveType.Equals(MoveType.InStore))
            {
                inoutStatus = 2;
            }
            int aType = 0;
            switch (alarmType)
            {
                case AlarmType.AxisMoveError:
                    aType = 2;
                    break;
                case AlarmType.AxisAlarm:
                    aType = 2;
                    break;
                case AlarmType.SuddenStop:
                    aType = 1;
                    alarmDetial = "1";
                    break;
                case AlarmType.NoAirCheck:
                    aType = 1;
                    alarmDetial = "2";
                    break;
                case AlarmType.IoSingleTimeOut:
                    aType = 3;
                    break;
                case AlarmType.StellAlarm:
                    aType = 2;
                    alarmDetial = "5";
                    break;
                default: break;
            }
            alarmInfo = new AlarmInfo(ID, aType, alarmDetial, alarmMsg, inoutStatus);
        }

        /// <summary>
        /// 开始运行
        /// </summary>
        public abstract bool StartRun(bool isDebug = false);
        /// <summary>
        /// 停止运行
        /// </summary>
        public abstract void StopRun();
        /// <summary>
        /// 报警
        /// </summary>
        /// <param name="alarmType"></param>
        public abstract void Alarm(AlarmType alarmType, string alarmDetial="", string alarmMsg="", MoveType storeMoveType=MoveType.None);
        /// <summary>
        /// 重置（夹料装置状态不变）
        /// </summary>
        public abstract void Reset(bool isNeedClearAuto = true);

        /// <summary>
        /// 停止所有运动
        /// </summary>
        public abstract void StopMove( );

        /// <summary>
        /// 重置处理
        /// </summary>
        protected abstract void ResetProcess();
         
        protected virtual void Init()
        {
            if (!isInit)
            {
                mainTimer = new System.Timers.Timer();
                mainTimer.Enabled = false;
                mainTimer.Interval = 300;
                mainTimer.Elapsed += timersTimer_Elapsed;
                mainTimer.AutoReset = true;
                 
                serverConTimer = new System.Timers.Timer();
                serverConTimer.Interval = 1000;
                serverConTimer.AutoReset = true;
                serverConTimer.Enabled = false;

                IoCheckTimer = new System.Timers.Timer();
                IoCheckTimer.Interval = 200;
                IoCheckTimer.AutoReset = true;
                IoCheckTimer.Enabled = false; 

                isInit = true;
            }
        }
        public StoreRunStatus runStatus
        {
            get
            {
                return storerunstatus;
            }
            set
            {
                StoreRunStatus oldStatus = storerunstatus;
                storerunstatus = value;
            }
        }
         
        public StoreMoveInfo MoveInfo = null;
         
        protected abstract void timersTimer_Elapsed(object sender, System.Timers.ElapsedEventArgs e);
        #region 出库
        /// <summary>
        /// 开始出库运动
        /// </summary> 
        public abstract bool StartOutStoreMove(InOutParam param);
        protected abstract void OutStoreProcess();
        #endregion

        #region 入库
        /// <summary>
        /// 开始入库移动移动
        /// </summary> 
        public abstract bool  StartInStoreMove(InOutParam param);
        protected abstract void InStoreProcess();
        #endregion



        public string GetRunStr()
        {
            string sta = "运行中";
            string aa = "";
            switch (runStatus)
            {
                case StoreRunStatus.Busy:
                    sta = "忙碌";
                    break;
                case StoreRunStatus.HomeMoving:
                    sta = "原点返回";
                    break;
                case StoreRunStatus.Reset:
                    sta = "重置";
                    break;
                case StoreRunStatus.Runing:
                    sta = "运行中";
                    break;
                case StoreRunStatus.Wait:
                    sta = "等待启动";
                    break;
            }
            if (runStatus > StoreRunStatus.Wait)
            {
                //"0":"急停中",   "1":"设备联机",   "2":"故障中", "3":"入库执行中",  "4":"出库执行中",   5":"料盘入仓位完成",   "6":"料盘出仓位完成",  7":"设备调试中",
                switch (storeStatus)
                {
                    case StoreStatus.Debugging:
                        aa = "设备调试中";
                        break;
                    case StoreStatus.InStoreEnd:
                        aa = "料盘入仓位完成";
                        break;
                    case StoreStatus.InStoreExecute:
                        aa = "入库执行中";
                        break;
                    case StoreStatus.InTrouble:
                        aa = "故障中";
                        break;
                    case StoreStatus.OutStoreBoxEnd:
                        aa = "料盘出仓位完成";
                        break;
                    case StoreStatus.OutStoreExecute:
                        aa = "出库执行中";
                        break;
                    case StoreStatus.StoreOnline:
                        aa = "设备联机";
                        break;
                    case StoreStatus.SuddenStop:
                        aa = "急停中";
                        break;
                    case StoreStatus.OutMoveExecute:
                        aa = "出库完成";
                        break;
                    case StoreStatus.InStoreFaild:
                        aa = "入库失败（" + WarnMsg + "）";
                        break;
                    case StoreStatus.OutStoreFaild:
                        aa = "出库失败（" + WarnMsg + "）";
                        break;
                }
                if (!aa.Equals(""))
                {
                    return sta + "_" + aa;
                }
                else
                {
                    return sta;
                }
            }
            else
            {
                return sta;
            }
        }


        public void CylinderMove(StoreMoveInfo moveInfo, string IoLowType, string IoHighType)
        { 
            IOMove(IoLowType, IO_VALUE.LOW);
            IOMove(IoHighType, IO_VALUE.HIGH);
            if (moveInfo != null)
            {
                moveInfo.WaitList.Add(WaitResultInfo.WaitIO(IoLowType, IO_VALUE.LOW));
                moveInfo.WaitList.Add(WaitResultInfo.WaitIO(IoHighType, IO_VALUE.HIGH));
            }
        }
        //public void IOMove(string IoType, IO_VALUE value, bool isCheck = false)
        //{
        //    if (isCheck && (IOValue(IoType).Equals(value)))
        //    {
        //        return;
        //    }
        //    IOManager.IOMove(IoType, value, baseConfig.Id);
        //}
        public void IOMove(string IoType, IO_VALUE value, bool isCheck = false, int msTime = 0)
        {
            if (msTime <= 0)
            {
                if (isCheck && (IOValue(IoType).Equals(value)))
                {
                    return;
                }
                IOManager.IOMove(IoType, value, baseConfig.Id);
            }
            else
            {
                Task.Factory.StartNew(delegate
                {
                    IOManager.IOMove(IoType, value, baseConfig.Id);
                    Thread.Sleep(msTime);
                    IO_VALUE tValue = value.Equals(IO_VALUE.HIGH) ? IO_VALUE.LOW : IO_VALUE.HIGH;

                    LogUtil.info(Name + "定时回写IO:  [" + IoType + "]=[" + value + "]，[" + baseConfig.Id + "]，msTime=" + msTime);

                    IOManager.IOMove(IoType, tValue, baseConfig.Id);
                });
            }
        }
        public IO_VALUE IOValue(string IoType)
        {
            return IOManager.IOValue(IoType, baseConfig.Id);
        }
       
        protected bool WaitIo(string ioType, IO_VALUE value, int timeOut, string errName = "")
        {
            return WaitUtil.Wait(timeOut, delegate () {
                return value.Equals(IOValue(ioType));
            }, errName);
        }
        public void LogInfo(string logInfo)
        {
            LogUtil.info(Name + logInfo);
        }
        protected void InOutStoreLog(string msg)
        {
            string type = "";
            if (ID > 0)
            {
                if (MoveInfo.MoveType.Equals(MoveType.OutStore))
                {
                    type = "出库";
                }
                else if (MoveInfo.MoveType.Equals(MoveType.InStore))
                {
                    type = "入库";
                }
            }
            else
            {
                if (MoveInfo.MoveType.Equals(MoveType.OutStore))
                {
                    type = "出料";
                }
                else if (MoveInfo.MoveType.Equals(MoveType.InStore))
                {
                    type = "入料";
                }
            }
            string posId = MoveInfo.MoveParam != null ? "["+MoveInfo.MoveParam.PosID+"]" : ""; 

            LogInfo(  posId +" "+ MoveInfo.SLog+":" + msg);
        }
        protected int GetAlarmCodeByAxis(ConfigMoveAxis axis)
        {
            int alarmCode = LineAlarm.InOutAxisAlarm;
            int axisType = axis.GetAxisValue() % 4;
            if (axisType == 1)
            {
                alarmCode = LineAlarm.MiddleAxisAlarm;
            }
            else if (axisType == 2)
            {
                alarmCode = LineAlarm.UpDownAxisAlarm;
            }
            else if (axisType == 3)
            {
                alarmCode = LineAlarm.InOutAxisAlarm;
            }
            else
            {
                alarmCode = LineAlarm.CompressAxisAlarm;
            }
            return alarmCode;
        }
        internal bool NoAlarm()
        {
            if (isInSuddenDown || isNoAirCheck)
            {
                return false;
            }
            if (alarmType.Equals(AlarmType.None))
            {
                return true;
            }
            return false;
        }


        #region 多个伺服运动

        public bool RunMultiAxis(bool isCheck, string serverOnDO, string breakOnDO, params AxisBean[] axisArray)
        {
            IOManager.IOMove(serverOnDO, IO_VALUE.HIGH, baseConfig.Id);
            string msg = "";
            foreach (AxisBean axis in axisArray)
            {
                bool result = axis.Open(false, out msg);
                if (!result || (!String.IsNullOrEmpty(msg)))
                {
                    SetWarnMsg(Name + msg);
                    Alarm(AlarmType.AxisAlarm);
                    return false;
                }
            }
            Thread.Sleep(500);
            //打开所有轴
            if (isCheck)
            {
                foreach (AxisBean axis in axisArray)
                {
                    if (!axis.AxisIsOpen(out msg))
                    {
                        SetWarnMsg(Name + msg);
                        Alarm(AlarmType.AxisAlarm);
                        return false;
                    }
                }
            }
            IOManager.IOMove(breakOnDO, IO_VALUE.HIGH, baseConfig.Id);
            return true;
        }

        public void CloseMultiAxis(string serverOnDO, string breakOnDO, params AxisBean[] axisArray)
        {
            IOManager.IOMove(breakOnDO, IO_VALUE.LOW, baseConfig.Id);
            foreach (AxisBean axis in axisArray)
            {
                axis.ServoOff();
            }
            Thread.Sleep(100);
            IOManager.IOMove(serverOnDO, IO_VALUE.LOW, baseConfig.Id);
        }

        public bool RunAxis(bool isCheck, AxisBean axis)
        {
            IOMove(axis.Config.ServerOnDO, IO_VALUE.HIGH);
            string msg = "";
            bool result = axis.Open(isCheck, out msg);
            if (result && String.IsNullOrEmpty(msg))
            {
                IOMove(axis.Config.BreakOnDO, IO_VALUE.HIGH);
                return true;
            }
            SetWarnMsg(Name + msg);
            //WarnMsg = DateTime.Now.ToLongTimeString() + " " + Name + msg;
            Alarm(AlarmType.AxisAlarm);
            return false;
        }

        public void CloseAxis(AxisBean axis)
        {
            IOMove(axis.Config.BreakOnDO, IO_VALUE.LOW);
            axis.ServoOff();
            Thread.Sleep(100);
            IOMove(axis.Config.ServerOnDO, IO_VALUE.LOW);
        }


        #endregion

        internal void SetWarnMsg(string msg)
        {
            if (String.IsNullOrEmpty(WarnMsg).Equals(false))
            {
                if (WarnMsg.Equals(msg))
                {
                    if (msg.StartsWith(Name))
                    {
                        LogUtil.error(msg, 105);
                    }
                    else
                    {
                        LogUtil.error(Name + msg, 105);
                    }
                }
                else
                {
                    if (msg.StartsWith(Name))
                    {
                        LogUtil.error(msg);
                    }
                    else
                    {
                        LogUtil.error(Name + msg);
                    }
                }
            }

            WarnMsg = msg;
        }

    }
}