using log4net; 
using OnlineStore.Common;
using OnlineStore.DeviceLibrary.deviceLibrary;
using OnlineStore.LoadCSVLibrary;
using System;
using System.Collections.Generic;
using System.Configuration;
using System.Drawing;
using System.Linq;
using System.Text;
using System.Threading;
using System.Threading.Tasks;
using System.Web.ModelBinding;

namespace OnlineStore.DeviceLibrary
{
    public abstract class DeviceBase
    {
        public DateTime LastAlarmTime = DateTime.Now;
        public RunStatus runStatus = RunStatus.Wait;

        public string WarnMsg = "";
        public string StepMsg = "";
        public DeviceConfig baseConfig = null;
        public string Name { get; set; }
        public int DeviceID { get; set; }

        protected System.Timers.Timer mainTimer;
        protected System.Timers.Timer ledProcessTimer = null;
        protected System.Timers.Timer IoCheckTimer = null;

        private bool isInit = false;

        public DeviceBase()
        {
        }
        /// <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 isNoAirpressure_Check = false;

        /// <summary>
        /// 是否再报警中
        /// </summary>
        public AlarmType alarmType = AlarmType.None;

        public AlarmInfo alarmInfo = new AlarmInfo();

        /// <summary>
        /// 记录上一次的部分IO状态，主要是急停，气压检测信号，复位信号，用来判断是否io发生改变
        /// </summary>
        public Dictionary<string, IO_VALUE> DILastValueMap = new Dictionary<string, IO_VALUE>();

        public object lastDiListLock = "";
        public void addLastDI(string type, IO_VALUE value)
        {
            try
            {
                lock (lastDiListLock)
                {
                    if (DILastValueMap.ContainsKey(type))
                    {
                        DILastValueMap.Remove(type);
                    }
                    DILastValueMap.Add(type, value);
                }
            }
            catch (Exception ex)
            {
                LogUtil.info(ex.ToString());
            }
        }

        /// <summary>
        /// 运动处理
        /// </summary> 
        protected bool isInPro = false;
        protected virtual void BusyMoveProcess()
        {
            isInPro = true;
            try
            {
                switch (MoveInfo.MoveType)
                {
                    case MoveType.InStore:
                        InstoreProcess();
                        isInPro = false;
                        break;
                    case MoveType.OutStore:
                        OutstoreProcess();
                        isInPro = false;
                        break;
                    case MoveType.RHome:
                        ResetProcess();
                        isInPro = false;
                        break;
                    case MoveType.Reset:
                        ResetProcess();
                        isInPro = false;
                        break;
                    default: break;
                }
            }
            catch (Exception ex)
            {
                LogUtil.error("BusyMoveProcess出错：", ex);
            }
            isInPro = false;
        }

        /// <summary>
        /// 没有严重的报警
        /// </summary>
        /// <returns></returns>
        internal bool NoErrorAlarm()
        {
            if (isInSuddenDown || isNoAirpressure_Check)
            {
                return false;
            }
            if (alarmType > AlarmType.IoSingleTimeOut)
            {
                return false;
            }
            return true;
        }
        internal bool NoAlarm()
        {
            if (isInSuddenDown || isNoAirpressure_Check)
            {
                return false;
            }
            if (alarmType.Equals(AlarmType.None))
            {
                return true;
            }
            return false;
        }
        /// <summary>
        /// 开始运行
        /// </summary>
        public abstract bool StartRun();
        /// <summary>
        /// 停止运行
        /// </summary>
        public abstract void StopRun();
        /// <summary>
        /// 报警
        /// </summary>
        /// <param name="alarmType"></param>
        public abstract void Alarm(AlarmType alarmType);
        /// <summary>
        /// 重置（夹料装置状态不变）
        /// </summary>
        public abstract bool Reset(bool checkSafe=true);

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

        /// <summary>
        /// 重置处理
        /// </summary>
        protected abstract void ResetProcess();


        /// <summary>
        /// 初始化
        /// </summary>
        protected virtual void Init()
        {
            if (!isInit)
            {
                mainTimer = new System.Timers.Timer();
                mainTimer.Enabled = false;
                mainTimer.Interval = 200;
                mainTimer.Elapsed += mainTimer_Elapsed;
                mainTimer.AutoReset = true;

                ledProcessTimer = new System.Timers.Timer();
                ledProcessTimer.Interval = 1000;
                //   ledProcessTimer.Elapsed += LedProcess;
                ledProcessTimer.AutoReset = true;
                ledProcessTimer.Enabled = false;

                IoCheckTimer = new System.Timers.Timer();
                IoCheckTimer.Interval = 300;
                //  IoCheckTimer.Elapsed += IoCheckTimerProcess;
                IoCheckTimer.AutoReset = true;
                IoCheckTimer.Enabled = false;
                isInit = true;

            }
        }

        /// <summary>
        /// 移动信息
        /// </summary>
        public DeviceMoveInfo MoveInfo = null;

        /// <summary>
        /// 定时处理，监听信号，监听IO
        /// </summary> 
        protected abstract void mainTimer_Elapsed(object sender, System.Timers.ElapsedEventArgs e);



        public abstract bool StartInstore(InOutParam param);
        protected abstract void InstoreProcess();


        public abstract bool StartOutstore(InOutParam param);
        protected abstract void OutstoreProcess();

        /// <summary>
        /// 设置警告并上报
        /// </summary>
        /// <param name="msg"></param>
        public void SetWarnMsg(string msg = "")
        {
            if (String.IsNullOrEmpty(msg).Equals(false))
            {
                if (!WarnMsg.Equals(msg))
                {
                    if (msg.StartsWith(Name))
                    {
                        LogUtil.error(msg);
                    }
                    else
                    {
                        LogUtil.error(Name + msg);
                    }
                }
            }
            WarnMsg = msg;
            if(!string.IsNullOrEmpty(msg))
            {
                Msg.add(msg, MsgLevel.alarm);
            }
        }
        public void SetCriticalMsg(string msg = "")
        {
            if (String.IsNullOrEmpty(msg).Equals(false))
            {
                if (!WarnMsg.Equals(msg))
                {
                    if (msg.StartsWith(Name))
                    {
                        LogUtil.error(msg);
                    }
                    else
                    {
                        LogUtil.error(Name + msg);
                    }
                }
            }
            WarnMsg = msg;
            if (!string.IsNullOrEmpty(msg))
            {
                Msg.add(msg, MsgLevel.critical);

            }
        }

        public    string GetRunStr( )
        {
            string sta = "运行中";
            string aa = "";
            switch (runStatus)
            {
                case RunStatus.Busy:
                    sta = "忙碌";
                    break;
                case RunStatus.HomeMoving:
                    sta = "原点返回";
                    break;
                case RunStatus.Reset:
                    sta = "重置";
                    break;
                case RunStatus.Runing:
                    sta = "运行中";
                    break;
                case RunStatus.Wait:
                    sta = "等待启动";
                    break;
            }
          
                if (isInSuddenDown)
                {
                    aa = "急停中";
                }else if (isNoAirpressure_Check)
                {
                    aa = "无气压信号";
                }
             
             
            if (!aa.Equals(""))
            {
                return sta + "_" + aa;
            }
            else
            {
                return sta;
            }
        }
        public static string GetRunStr(RunStatus runs)
        {
            string sta = "运行中";
            string aa = "";
            switch (runs)
            {
                case RunStatus.Busy:
                    sta = "忙碌";
                    break;
                case RunStatus.HomeMoving:
                    sta = "原点返回";
                    break;
                case RunStatus.Reset:
                    sta = "重置";
                    break;
                case RunStatus.Runing:
                    sta = "运行中";
                    break;
                case RunStatus.Wait:
                    sta = "等待启动";
                    break;
            }
            return sta;
        }
        public bool CylinderIsOk(string IoLowType, string IoHighType)
        {
            if (IOManager.DIValue(IoLowType,DeviceID).Equals(IO_VALUE.LOW) && IOManager.DIValue(IoHighType, DeviceID).Equals(IO_VALUE.HIGH)){
                return true;
            }
            return false;
        } 
        public void CylinderMove(DeviceMoveInfo moveInfo, string IoLowType, string IoHighType, bool isCheckMove = false)
        { 
            try
            {
                    if (!baseConfig.DOList.ContainsKey(IoLowType))
                    {
                        return;
                    }
                    if (!baseConfig.DOList.ContainsKey(IoHighType))
                    {
                        return;
                    }
                 
                if (moveInfo != null)
                {
                    moveInfo.WaitList.Add(WaitResultInfo.WaitIO(IoLowType, IO_VALUE.LOW));
                    moveInfo.WaitList.Add(WaitResultInfo.WaitIO(IoHighType, IO_VALUE.HIGH));
                  
                }
                if (isCheckMove)
                {
                    CheckAndMove(IoLowType, IO_VALUE.LOW);
                    CheckAndMove(IoHighType, IO_VALUE.HIGH);
                }
                else
                {
                    IOMove(IoLowType, IO_VALUE.LOW);
                    IOMove(IoHighType, IO_VALUE.HIGH);
                }
            }catch(Exception ex)
            {
                LogUtil.error(Name + "CylinderMove ["+moveInfo.Name+"] ["+IoLowType+"] ["+IoHighType+"] ["+isCheckMove+"] 出错："+ex.ToString());
            }
     
        }
        public void CheckAndMove(string IoType, IO_VALUE value)
        {
            if (!IOValue(IoType).Equals(value))
            {
                IOMove(IoType, value);
            }
        }
        public void IOMove(string IoType, IO_VALUE value, int msTime = 0)
        {
            if (msTime <= 0)
            {
                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;
                  
                    IOManager.IOMove(IoType, tValue, baseConfig.Id);
                });
            }
        }
        public IO_VALUE IOValue(string IoType)
        {
            return IOManager.IOValue(IoType, baseConfig.Id);
        }
        public IO_VALUE DOValue(string IoType)
        {
            return IOManager.DOValue(IoType, baseConfig.Id);
        }
        public void DebugInfo(string logInfo)
        {
            LogUtil.debug(Name + logInfo);
        }


        string errormsg = "";
        public void LogError(string logInfo)
        {
            if (string.IsNullOrEmpty(logInfo))
            {
                return;
            }
            if (!logInfo.Equals(errormsg))
            {
                errormsg = logInfo;
                LogUtil.error(Name + logInfo);
            }
        }
        public void LogInfo(string logInfo)
        {
            if(string.IsNullOrEmpty(logInfo))
            {
                return;
            }
            if(!logInfo.Equals(StepMsg))
            {
                StepMsg = logInfo;
                LogUtil.info(Name + logInfo);
            }

        }
        protected void MoveLog(string msg)
        { 
            string posId = (MoveInfo.MoveParam != null && MoveInfo.MoveParam.PosInfo != null) ? " [" + MoveInfo.MoveParam.PosInfo.PosId + "]" : ""; 
            //string posId = (MoveInfo.MoveParam != null && MoveInfo.MoveParam.PosInfo != null) ? " [" + MoveInfo.MoveParam.PosInfo.PosId + "][" + MoveInfo.MoveParam.PosInfo.barcode + "]" : "";
            LogUtil.info(Name + "  " + posId + msg);

        }
        /// <summary>
        /// 阻塞等待IO信号，等到返回true,未等到返回false
        /// </summary>c
        public bool WaitIo(string ioType, IO_VALUE value, int timeOut, string errName = "")
        {
            try
            {
                return WaitUtil.Wait(timeOut, delegate ()
                {
                    return value.Equals(IOValue(ioType));
                }, errName);
            }
            catch (Exception ex)
            {
                LogUtil.error(Name + "等待" + ioType + "=" + value + "超时：" + ex.ToString());
                return false;
            }
        }
        public static string GetRunStr(RunStatus runs, DeviceStatus ls = DeviceStatus.None)
        {
            string sta = "运行中";
            string aa = "";
            switch (runs)
            {
                case RunStatus.Busy:
                    sta = "忙碌";
                    break;
                case RunStatus.HomeMoving:
                    sta = "原点返回";
                    break;
                case RunStatus.Reset:
                    sta = "重置";
                    break;
                case RunStatus.Runing:
                    sta = "运行中";
                    break;
                case RunStatus.Wait:
                    sta = "等待启动";
                    break;
            }
            if (runs > RunStatus.Wait && ls > DeviceStatus.None)
            {
                //"0":"急停中",   "1":"设备联机",   "2":"故障中", "3":"入库执行中",  "4":"出库执行中",   5":"料盘入仓位完成",   "6":"料盘出仓位完成",  7":"设备调试中",
                switch (ls)
                {
                    case DeviceStatus.Debugging:
                        aa = "设备调试中";
                        break;
                    //case LineStatus.InStoreEnd:
                    //    aa = "料盘入仓位完成";
                    //    break;
                    case DeviceStatus.InStoreExecute:
                        aa = "入库执行中";
                        break;
                    case DeviceStatus.InTrouble:
                        aa = "故障中";
                        break;
                    case DeviceStatus.OutStoreBoxEnd:
                        aa = "出库执行中";
                        break;
                    case DeviceStatus.OutStoreExecute:
                        aa = "出库执行中";
                        break;
                    case DeviceStatus.StoreOnline:
                        aa = "设备联机";
                        break;
                    case DeviceStatus.SuddenStop:
                        aa = "急停中";
                        break;
                        //case LineStatus.OutMoveExecute:
                        //    aa = "出库完成";
                        //    break;
                        //case LineStatus.InStoreFaild:
                        //    aa = "入库失败（" + WarnMsg + "）";
                        //    break;
                        //case LineStatus.OutStoreFaild:
                        //    aa = "出库失败（" + WarnMsg + "）";
                        //    break;
                }
            }

            if (!aa.Equals(""))
            {
                return sta + "_" + aa;
            }
            else
            {
                return sta;
            }
        }
    }
}