using SKMC.Api.Common;
using SKMC.Api.Common.Tasks;
using System;
using System.Collections.Concurrent;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace SKMC.Api.Process.Model
{
    /// <summary>
    /// 流程站点管理器接口
    /// </summary>
    public abstract class ProcessStationManager
    {
        protected static readonly ILogger log = LogFactory.Get();

        /// <summary>
        /// 流程站点Id与站点对象的字典
        /// </summary>
        public readonly Dictionary<int, ProcessStation> processStations = new Dictionary<int, ProcessStation>();

        /// <summary>
        /// 已运行的流程站点
        /// </summary>
        public readonly Dictionary<int, ProcessStation> runningStations = new Dictionary<int, ProcessStation>();

        /// <summary>
        /// 运行中的流程步骤
        /// </summary>
        public readonly ConcurrentDictionary<int, ProcessStep> runningSteps = new ConcurrentDictionary<int, ProcessStep>();

        /// <summary>
        /// 获取流程站点
        /// </summary>
        /// <param name="stationId">流程站点Id</param>
        /// <returns></returns>
        public virtual ProcessStation Get(int stationId) => processStations[stationId];

        /// <summary>
        /// 添加流程站点
        /// </summary>
        /// <param name="processStation">流程站点</param>
        public virtual void Add(ProcessStation processStation) => processStations.Add(processStation.Id, processStation);

        /// <summary>
        /// 所有站点是否空闲
        /// 空闲是指自动运行状态下没有打料
        /// </summary>
        /// <returns></returns>
        public abstract bool IsIdle();

        /// <summary>
        /// 判断多个Station的取消状态(中断点)
        /// </summary>
        /// <returns>如果其中一个是取消状态则返回true</returns>
        public bool CheckStationsCancelled(int[] stationIds)
        {
            bool checkResult = false;
            foreach(int stationId in stationIds)
            {
                checkResult |= TaskTokener.IsCancelled(stationId);
            }
            return checkResult;
        }

        /// <summary>
        /// 启动所有流程站点自动运行
        /// </summary>
        public abstract void StartAll();

        /// <summary>
        /// 启动特定的流程站点自动运行
        /// </summary>
        /// <param name="stationId"></param>
        public virtual void Start(int stationId)
        {
            if (!runningStations.ContainsKey(stationId))
            {
                ProcessStation processStation = Get(stationId);
                runningStations.Add(stationId, processStation);
                processStation.Start();
            }
            else
            {
                log.Warn($"Station[{stationId}] Is Actived, Start Failed");
            }
        }

        /// <summary>
        /// 复位所有流程站点
        /// </summary>
        public abstract void ResetAll();

        /// <summary>
        /// 复位特定的流程站点
        /// </summary>
        /// <param name="stationId">流程站点Id</param>
        public virtual void Reset(int stationId)
        {
            // 如果复位异常往上抛出
            Get(stationId).Reset();
            Get(stationId).ResetResult = 0;
        }

        /// <summary>
        /// 停止所有站点自动运行
        /// <param name="hasAction">是否有停止动作</param>
        /// </summary>
        public abstract void StopAll(bool hasAction = false);

        /// <summary>
        /// 停止特定的站点自动运行
        /// </summary>
        /// <param name="stationId">流程站点Id</param>
        /// <param name="hasAction">是否有停止动作</param>
        public virtual void Stop(int stationId, bool hasAction = false)
        {
            log.Debug($"Ready Remove stationId: {stationId},Exist:{runningStations.ContainsKey(stationId)}");
            runningStations.Remove(stationId);
            log.Debug($"After Remove stationId: {stationId},Exist:{runningStations.ContainsKey(stationId)}");
            Get(stationId).Stop(hasAction);
            runningStations.Remove(stationId);
        }

        /// <summary>
        /// 暂停所有的流程站点
        /// </summary>
        public abstract void PauseAll();

        /// <summary>
        /// 暂停特定的流程站点
        /// </summary>
        /// <param name="stationId">流程站点Id</param>
        public virtual void Pause(int stationId) => Get(stationId).Pause();

        /// <summary>
        /// 恢复所有的流程站点运行
        /// </summary>
        public abstract void ResumeAll();

        /// <summary>
        /// 恢复所有的流程站点状态(中断点)
        /// </summary>
        public abstract void RestoreAll();

        /// <summary>
        /// 恢复特定的流程站点
        /// </summary>
        /// <param name="stationId">流程站点Id</param>
        public virtual void Resume(int stationId) => Get(stationId).Resume();

        /// <summary>
        /// 异常报警并暂停所有流程站点
        /// </summary>
        /// <param name="reqBuzzerOn">蜂鸣器是否开启</param>
        public abstract void AlarmPause(bool reqBuzzerOn = true);

        /// <summary>
        ///  不暂停设备只变更状态与灯
        /// </summary>
        /// <param name="reqBuzzerOn">蜂鸣器是否开启</param>
        public abstract void AlarmOnly(bool reqBuzzerOn = true);

        /// <summary>
        /// 关闭报警状态
        /// </summary>
        public abstract void CloseAlarm();

    }
}