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

namespace OnlineStore.DeviceLibrary
{
    /// <summary>
    /// 康泰克单台自动料仓
    /// </summary>
    public abstract class AC_Store
    {
        protected static readonly ILog LOGGER = LogManager.GetLogger(System.Reflection.MethodBase.GetCurrentMethod().DeclaringType);

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

        public AlarmInfo alarmInfo = new AlarmInfo();

        /// <summary>
        /// 料仓单个调试状态(默认不是调试状态)
        /// </summary>
        public bool IsDebug = false;
         
        /// <summary>
        ///1=设备联机（正常就绪）（入库后，BOX恢复原始状态）（出库后，移载装置恢复原始状态），
        ///2=急停，3=故障，4=警告，5=调试
        ///  6=入库执行中,7=入仓完成，8=入仓失败
        /// 9=出库执行，10=出仓完成，11=出库失败
        /// </summary>
        public StoreStatus storeStatus = StoreStatus.StoreOnline;
        /// <summary>
        /// 料仓状态
        /// </summary>
        public StoreRunStatus storeRunStatus = StoreRunStatus.Wait;

        /// <summary>
        /// 移动信息
        /// </summary>
        public StoreMoveInfo StoreMove = null;
        /// <summary>
        /// 提示消息，一般发给服务器后清空（LineBean表示报警提示消息，BoxBean表示出入库失败的原因记录）
        /// </summary>
        public string WarnMsg = "";
        
        public string StoreName { get; set; }
        public int StoreID { get; set; }
     
        protected System.Timers.Timer mainTimer;
        protected System.Timers.Timer serverConnectTimer = new System.Timers.Timer();
        protected System.Timers.Timer IoCheckTimer = new System.Timers.Timer();
        protected System.Timers.Timer ledCheckTimer = new System.Timers.Timer();
        public AC_Store()
        {
        }

        /// <summary>
        /// 初始化
        /// </summary>
        protected virtual void Init()
        {
            StoreMove = new StoreMoveInfo(StoreName); 
            mainTimer = new System.Timers.Timer();
            mainTimer.Enabled = false;
            mainTimer.Interval = 300;
            mainTimer.Elapsed += timersTimer_Elapsed;
            mainTimer.AutoReset = true;
            serverConnectTimer = new System.Timers.Timer();
            serverConnectTimer.Interval = 1000;
            serverConnectTimer.AutoReset = true;
            serverConnectTimer.Enabled = false;
            //serverConnectTimer.Elapsed += server_connect_timer_Tick;
            IoCheckTimer = new System.Timers.Timer();
            IoCheckTimer.Interval = 200;
            IoCheckTimer.AutoReset = true;
            IoCheckTimer.Enabled = false;

            ledCheckTimer = new System.Timers.Timer();
            ledCheckTimer.Interval = 500;
            ledCheckTimer.AutoReset = true;
            ledCheckTimer.Enabled = false;
            //IoCheckTimer.Elapsed += IoCheckTimer_Elapsed;
        } 


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

        #region 出库 
        //public abstract bool StartOutStoreMove(InOutStoreParam param);
        protected abstract void OutStoreProcess();
        #endregion

        #region 入库 
        //public abstract bool StartInStoreMove(InOutStoreParam param);
        protected abstract void InStoreProcess();
        #endregion



        public string GetRunStr(StoreRunStatus runStatus, bool IsStore)
        {
            string sta = ResourceControl.GetString(ResourceControl.Run, "运行中");
            string aa = "";
            switch (runStatus)
            {
                case StoreRunStatus.Busy:
                    sta = ResourceControl.GetString(ResourceControl.Busy, "忙碌");
                    break;
                case StoreRunStatus.HomeMoving:
                    sta = ResourceControl.GetString(ResourceControl.HomeMove, "原点返回");
                    break;
                case StoreRunStatus.Reset:
                    sta = ResourceControl.GetString(ResourceControl.Reset, "重置");
                    break;
                case StoreRunStatus.Runing:
                    sta = ResourceControl.GetString(ResourceControl.Runing, "运行中");
                    break;
                case StoreRunStatus.Wait:
                    sta = ResourceControl.GetString(ResourceControl.Wait, "等待启动");
                    break;
            }
            if (runStatus > StoreRunStatus.Wait)
            {
                //"0":"急停中",   "1":"设备联机",   "2":"故障中", "3":"入库执行中",  "4":"出库执行中",   5":"料盘入仓位完成",   "6":"料盘出仓位完成",  7":"设备调试中",
                switch (storeStatus)
                {
                    case StoreStatus.Debugging:
                        aa = ResourceControl.GetString(ResourceControl.Debugging, "设备调试中");
                        break;
                    case StoreStatus.InStoreEnd:
                        aa = ResourceControl.GetString(ResourceControl.InStoreEnd, "料盘入仓位完成");
                        break;
                    case StoreStatus.InStoreExecute:
                        aa = ResourceControl.GetString(ResourceControl.InStoreExecute, "入库执行中");
                        break;
                    case StoreStatus.InTrouble:
                        aa = ResourceControl.GetString(ResourceControl.InTrouble, "故障中");
                        break;
                    case StoreStatus.OutStoreBoxEnd:
                        aa = ResourceControl.GetString(ResourceControl.OutStoreBoxEnd, "料盘出仓位完成");
                        break;
                    case StoreStatus.OutStoreExecute:
                        aa = ResourceControl.GetString(ResourceControl.OutStoreExecute, "出库执行中");
                        break;
                    case StoreStatus.StoreOnline:
                        aa = ResourceControl.GetString(ResourceControl.StoreOnline, "设备联机");
                        break;
                    case StoreStatus.SuddenStop:
                        aa = ResourceControl.GetString(ResourceControl.SuddenStop, "急停中");
                        break;
                    case StoreStatus.OutMoveExecute:
                        aa = ResourceControl.GetString(ResourceControl.OutMoveExecute, "出库完成");
                        break;
                    case StoreStatus.InStoreFaild:
                        aa = ResourceControl.GetString(ResourceControl.InStoreFailed, "入库失败") + "（" + WarnMsg + "）";
                        break;
                    case StoreStatus.OutStoreFaild:
                        aa = ResourceControl.GetString(ResourceControl.OutStoreFailed, "出库失败") + "（" + WarnMsg + "）";
                        break;
                }
                if (!aa.Equals(""))
                {
                    return sta + "_" + aa;
                }
                else
                {
                    return sta;
                }
            }
            else
            {
                return sta;
            }
        }
        /// <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)
            {
                LOGGER.Error(ex.ToString());
            }
        }
      
          
        /// <summary>
        /// 运动处理
        /// </summary> 
        protected bool isInPro = false;
        protected virtual void BusyMoveProcess()
        { 
            isInPro = true;
            try
            {
                switch (StoreMove.MoveType)
                {
                    case StoreMoveType.InStore:
                        InStoreProcess();
                        isInPro = false;
                        break;
                    case StoreMoveType.OutStore:
                        OutStoreProcess();
                        isInPro = false;
                        break;
                    case StoreMoveType.ReturnHome:
                        ReturnHomeProcess();
                        isInPro = false;
                        break;
                    case StoreMoveType.StoreReset:
                        ResetProcess();
                        isInPro = false;
                        break;
                    default: break;
                }
            }catch(Exception ex)
            {
                LogUtil.error("BusyMoveProcess出错："+ex.ToString());
            }
            isInPro = false;
        } 
        protected void SaveAlarmInfo(StoreAlarmType alarmType, string alarmDetial, string alarmMsg, StoreMoveType storeMoveType)
        {
            alarmMsg = alarmMsg.Replace(StoreName, "");
            int inoutStatus = 0;
            if (storeMoveType.Equals(StoreMoveType.InStore))
            {
                inoutStatus = 1;
            }
            else if (storeMoveType.Equals(StoreMoveType.InStore))
            {
                inoutStatus = 2;
            }
            int aType = 0;
            switch (alarmType)
            {
                case StoreAlarmType.AxisMoveError:
                    aType = 2;
                    break;
                case StoreAlarmType.AxisAlarm:
                    aType = 2;
                    break;
                case StoreAlarmType.SuddenStop:
                    aType = 1;
                    alarmDetial = "1";
                    break;
                case StoreAlarmType.NoAirCheck:
                    aType = 1;
                    alarmDetial = "2";
                    break;
                case StoreAlarmType.IoSingleTimeOut:
                    aType = 3;
                    break;
                //case StoreAlarmType.StellAlarm:
                //    aType = 2;
                //    alarmDetial = "5";
                    //break;
                default: break;
            }
            alarmInfo = new AlarmInfo(StoreID, aType, alarmDetial, alarmMsg, inoutStatus);
        }

        /// <summary>
        /// 开始运行
        /// </summary>
        public abstract bool StartRun();  
        /// <summary>
        /// 停止运行
        /// </summary>
        public abstract void StopRun();
        /// <summary>
        /// 报警
        /// </summary>
        /// <param name="alarmType"></param>
        public abstract void Alarm(StoreAlarmType alarmType, string alarmDetial, string alarmMsg, StoreMoveType storeMoveType);
        /// <summary>
        /// 重置（夹料装置状态不变）
        /// </summary>
        public abstract void Reset();
        
        /// <summary>
        /// 停止所有运动
        /// </summary>
        public abstract void StopMove( bool IsCloseAxis);
 
        /// <summary>
        /// 重置处理
        /// </summary>
        protected abstract void ResetProcess();
        /// <summary>
        /// 原点返回处理
        /// </summary>
        protected abstract void ReturnHomeProcess();

        /// <summary>
        /// 松下伺服轴原点返回运动，等待收到反馈后才会返回
        /// </summary> 
        protected void ACAxisHomeMove(ConfigMoveAxis moveAxis)
        {
            moveAxis.TargetPosition = 0;
            LogUtil.debug(LOGGER, moveAxis.DisplayStr + "speed[" + moveAxis.TargetSpeed + "]开始原点返回");
            StoreMove.WaitList.Add(WaitResultInfo.WaitAxis(moveAxis, true)); 
            ACServerManager.HomeMove(moveAxis.DeviceName, (short)moveAxis.GetAxisValue(), moveAxis.HomeHighSpeed); 
        }

        /// <summary>
        /// 松下伺服电机运动
        /// </summary> 
        protected void ACAxisMove(ConfigMoveAxis moveAxis, int targetPosition, int targetSpeed)
        {
            StoreMove.WaitList.Add(WaitResultInfo.WaitAxis(moveAxis, targetPosition, targetSpeed));
            moveAxis.TargetPosition = targetPosition;
            ACServerManager.AbsMove(moveAxis.DeviceName, moveAxis.GetAxisValue(), targetPosition, targetSpeed);
        }

        /// <summary>
        /// 判断AC伺服电机轴是否运动完成
        /// </summary> 
        protected bool ACAxisMoveIsEnd(ConfigMoveAxis moveAxis, int targetPosition, int targetSpeed, out string msg)
        {
            msg = "";
            string deviceName = moveAxis.DeviceName;
            int axisNo = moveAxis.GetAxisValue();
             
            bool isOk = ACServerManager.GetBusyStatus(deviceName, axisNo).Equals(0);
            int outCount = ACServerManager.GetActualtPosition(deviceName, axisNo);
            int errorCount = Math.Abs(outCount - targetPosition);
           if (isOk)
            {
                if (errorCount > moveAxis.CanErrorCountMax)
                { 
                    //判断是否需要重新运动
                    if (StoreMove.CanWhileCount > 0)
                    {
                        LogUtil.error(LOGGER, moveAxis.DisplayStr + "目标位置[" + targetPosition + "]当前位置[" + outCount +
                         "]，误差过大，重新开始运动，剩余[" + StoreMove.CanWhileCount + "]次");
                        ACServerManager.AbsMove(moveAxis.DeviceName, moveAxis.GetAxisValue(), targetPosition, targetSpeed);
                        StoreMove.CanWhileCount--;
                        return false;
                    }
                    else
                    {
                        msg = StoreName + " storeMoveStep=" + StoreMove.MoveStep + moveAxis.DisplayStr + "目标位置[" + targetPosition + "]当前位置[" + outCount
                            + "]，误差过大，需要报警";
                        LogUtil.error(LOGGER, msg);
                        return false;
                    }

                }
                else
                {
                    return true;
                }
            }
            else if (errorCount <= moveAxis.CanErrorCountMin)
            {
                LogUtil.info(LOGGER, " storeMoveStep=" + StoreMove.MoveStep + moveAxis.DisplayStr + ",targetPosition=" + targetPosition + ",当前outCount=" + outCount +
                        ",误差值小于最小误差【" + moveAxis.CanErrorCountMin + "】,默认轴已经停止运动");
                return true;
            }
            return false;
        }
        protected bool ACHomeMoveIsEnd(ConfigMoveAxis moveAxis, out string msg)
        {
            msg = "";
            if (ACServerManager.IsHomeMoveEnd(moveAxis.DeviceName, moveAxis.GetAxisValue()))
            {
                //原点完成并且位置=0
                int outCount = ACServerManager.GetActualtPosition(moveAxis.DeviceName, moveAxis.GetAxisValue());
                int errorCount = Math.Abs(outCount);
                if (errorCount <= moveAxis.CanErrorCountMax)
                {
                    return true;
                }
                //判断是否需要重新运动
                if (StoreMove.CanWhileCount > 0)
                {
                    LogUtil.error(LOGGER, moveAxis.DisplayStr + "收到原点完成信号，当前位置[" + outCount + "]，重新回原点，剩余[" + StoreMove.CanWhileCount + "]次");
                    ACServerManager.HomeMove(moveAxis.DeviceName, moveAxis.GetAxisValue(), moveAxis.HomeHighSpeed);
                    StoreMove.CanWhileCount--;
                }
                else
                {
                    msg = StoreName + " storeMoveStep=" + StoreMove.MoveStep + moveAxis.DisplayStr + "收到原点完成信号，当前位置[" + outCount + "]，误差过大，需要报警";
                    LogUtil.error(LOGGER, msg);
                } 
            }
            return false;
        } 


    }
}