using Aitex.Core.RT.Log;
using Aitex.Core.Util;
using MECF.Framework.Common.DBCore;
using MECF.Framework.Common.ProcessCell;
using System;
using System.Collections.Generic;

namespace MECF.Framework.Common.ToolLayout
{
    public class ReservoirUsageManager : Singleton<ReservoirUsageManager>
    {
        #region 内部变量
        /// <summary>
        /// Reservoir电量字典
        /// </summary>
        private Dictionary<string, ReservoirUsage> _reservoirUsageDictionary = new Dictionary<string, ReservoirUsage>();
        /// <summary>
        /// Reservoir 锁字典
        /// </summary>
        private Dictionary<string, object> _reservoirLockDictionary = new Dictionary<string, object>();
        #endregion
        /// <summary>
        /// 初始化
        /// </summary>
        public void Initialize()
        {
            List<ReservoirUsage> reservoirUsages = ReservoirUsageRecorder.GetAllReservoirUsages();
            foreach (var item in reservoirUsages)
            {
                _reservoirUsageDictionary[item.ReservoirName] = item;
            }

            List<string> installedReservoirs = ReservoirItemManager.Instance.InstalledModules;
            foreach (string item in installedReservoirs)
            {
                _reservoirLockDictionary[item] = new object();
            }
        }
        /// <summary>
        /// 更新Reservoir的用量
        /// </summary>
        /// <param name="metalName"></param>
        /// <param name="usage"></param>
        public void UpdateReservoirUsage(string reservoirName, double anodeAUsage, double anodeBUsage,int waferCount)
        {
            if (!_reservoirLockDictionary.ContainsKey(reservoirName))
            {
                LOG.WriteLog(eEvent.WARN_RESERVOIR, reservoirName, $"reservoir {reservoirName} usage has no locker");
                return;
            }
            lock (_reservoirLockDictionary[reservoirName])
            {
                bool isAdd = false;
                ReservoirUsage reservoirUsage = null;
                if (!_reservoirUsageDictionary.ContainsKey(reservoirName))
                {
                    reservoirUsage = new ReservoirUsage();
                    reservoirUsage.ReservoirName = reservoirName;
                    _reservoirUsageDictionary[reservoirName] = reservoirUsage;
                    isAdd = true;
                }
                else
                {
                    reservoirUsage = _reservoirUsageDictionary[reservoirName];
                }

                reservoirUsage.TotalUsage += anodeAUsage + anodeBUsage;
                reservoirUsage.BathUsage += anodeAUsage + anodeBUsage;
                reservoirUsage.AnodeUsage += anodeAUsage + anodeBUsage;
                reservoirUsage.MembranceUsage += anodeAUsage + anodeBUsage;
                reservoirUsage.TotalWafers += waferCount;
                DateTime now=DateTime.Now;

                if (isAdd)
                {
                    reservoirUsage.BathUsageDays = 0;
                    reservoirUsage.BathResetTime = now;
                    ReservoirUsageRecorder.AddReservoirUsage(reservoirUsage);
                }
                else
                {
                    int days = (int)Math.Floor(now.Subtract(reservoirUsage.BathResetTime).TotalDays);
                    if (days >= reservoirUsage.BathUsageDays)
                    {
                        reservoirUsage.BathUsageDays = days;
                    }
                    ReservoirUsageRecorder.UpdateReservoirUsageData(reservoirName, reservoirUsage);
                }
            }
        }
        /// <summary>
        /// 在PMCounter页面手动修改值
        /// </summary>
        /// <param name="metalName"></param>
        public void UpdateReservoirUsageByManualOperation(string reservoirName, string CounterName, string NewValue)
        {
            if (_reservoirUsageDictionary.ContainsKey(reservoirName))
            {
                switch (CounterName)
                {
                    case "Total Usage(AHr)":
                        _reservoirUsageDictionary[reservoirName].TotalUsage = double.Parse(NewValue); break;
                    case "Bath Usage(AHr)":
                        _reservoirUsageDictionary[reservoirName].BathUsage = double.Parse(NewValue); break;
                    case "Anolyte Bath Usage(AHr)":
                        _reservoirUsageDictionary[reservoirName].AnodeUsage = double.Parse(NewValue); break;
                    case "Bath Usage(Days)":
                        _reservoirUsageDictionary[reservoirName].BathUsageDays = int.Parse(NewValue);
                        _reservoirUsageDictionary[reservoirName].BathResetTime = DateTime.Now;
                        break;
                    case "Membrane Usage(AHr)":
                        _reservoirUsageDictionary[reservoirName].MembranceUsage = double.Parse(NewValue); break;
                    case "Total Wafers":
                        _reservoirUsageDictionary[reservoirName].TotalWafers = int.Parse(NewValue); break;
                    case "CMM Anode Usage(AHr)":
                        _reservoirUsageDictionary[reservoirName].CMMAnodeUsage = double.Parse(NewValue); break;
                    case "CMM Cathode Usage(AHr)":
                        _reservoirUsageDictionary[reservoirName].CMMMembranceUsage = double.Parse(NewValue); break;
                }
                ReservoirUsageRecorder.UpdateReservoirUsageData(reservoirName, _reservoirUsageDictionary[reservoirName]);
            }
        }
        /// <summary>
        /// 获取Reservoir用量
        /// </summary>
        /// <param name="metalName"></param>
        /// <returns></returns>
        public ReservoirUsage GetReservoirUsage(string reservoirName)
        {
            return _reservoirUsageDictionary.ContainsKey(reservoirName) ? _reservoirUsageDictionary[reservoirName] : null;
        }
        /// <summary>
        /// 更新CMMPowerUsage
        /// </summary>
        /// <param name="reservoirName"></param>
        /// <param name="cmmUsage"></param>
        public void UpdateReservoirCMMUsage(string reservoirName, double cmmUsage)
        {
            if (!_reservoirLockDictionary.ContainsKey(reservoirName))
            {
                LOG.WriteLog(eEvent.WARN_RESERVOIR, reservoirName, $"reservoir {reservoirName} usage has no locker");
                return;
            }
            lock (_reservoirLockDictionary[reservoirName])
            {
                bool isAdd = false;
                ReservoirUsage reservoirUsage = null;
                if (!_reservoirUsageDictionary.ContainsKey(reservoirName))
                {
                    reservoirUsage = new ReservoirUsage();
                    reservoirUsage.ReservoirName = reservoirName;
                    _reservoirUsageDictionary[reservoirName] = reservoirUsage;
                    isAdd = true;
                }
                else
                {
                    reservoirUsage = _reservoirUsageDictionary[reservoirName];
                }

                reservoirUsage.CMMAnodeUsage += cmmUsage;
                reservoirUsage.CMMMembranceUsage += cmmUsage;

                DateTime now = DateTime.Now;

                if (isAdd)
                {
                    reservoirUsage.BathUsageDays = 0;
                    reservoirUsage.BathResetTime = now;
                    ReservoirUsageRecorder.AddReservoirUsage(reservoirUsage);
                }
                else
                {
                    ReservoirUsageRecorder.UpdateReservoirUsageData(reservoirName, reservoirUsage);
                }
            }
        }
    }
}