using System;
using System.Collections.Generic;
using Aitex.Core.Common;
using Aitex.Core.RT.Log;
using Aitex.Core.Util;
using Aitex.Sorter.Common;
using MECF.Framework.Common.Equipment;
using MECF.Framework.Common.SubstrateTrackings;
using MECF.Framework.RT.EquipmentLibrary.HardwareUnits.LoadPorts;

namespace Aitex.Sorter.RT.EFEMs.Servers
{
    public class EfemModuleStatus
    {
        private bool _isInitialized;

        public bool IsInitialized
        {
            get
            {
                return _isInitialized;
            }
            set
            {
                _isInitialized = value;
                TrigInitialized.CLK = value;
            }
        }

        public R_TRIG TrigInitialized { get; set; }

        public ModuleName Module { get; set; }

        public EfemModuleStatus(ModuleName module)
        {
            Module = module;
            TrigInitialized = new R_TRIG();
        }
    }

    public partial class EfemEntity
    {
        public IEfemEquipment EfemDevice
        {
            get
            {
                return _efemDevice;
            }
        }

        private Dictionary<string, uint> _eventData = new Dictionary<string, uint>();
        private Dictionary<string, Tuple<uint, uint>> _sigData = new Dictionary<string, Tuple<uint, uint>>();
 
        private IEfemEquipment _efemDevice;

        private Dictionary<ModuleName, EfemModuleStatus> _efemModuleStatus = new Dictionary<ModuleName, EfemModuleStatus>();

        public void SetEfemDevice(IEfemEquipment efemDevice)
        {
            _efemDevice = efemDevice;

            foreach (var module in _efemDevice.GetInstallModules())
            {
                _efemModuleStatus[module] = new EfemModuleStatus(module);
            }
        }
 
        public void SendMapEvent(LoadPort lp)
        {
            if (!((SystemServerModule)EfemServerModule.Instance.GetModule(DeviceName.System)).IsEventEnabled(EfemEventType.ALL))
            {
                LOG.Write("event all disabled.");
                return;
            }

            if ( !((SystemServerModule)EfemServerModule.Instance.GetModule(DeviceName.System)).IsEventEnabled(
                    EfemEventType.PORT))
            {
                LOG.Write("event lp disabled.");
                return;
            }
 

            WaferInfo[] wafers = WaferManager.Instance.GetWafers(ModuleHelper.Converter(lp.Name));
            string slot = "";
            for (int i = 0; i < 25; i++)
            {
                switch (wafers[i].Status)
                {
                    case WaferStatus.Empty:
                        slot += "0";
                        break;
                    case WaferStatus.Normal:
                        slot += "1";
                        break;
                    case WaferStatus.Crossed:
                        slot += "3";
                        break;
                    case WaferStatus.Double:
                        slot += "7";
                        break;
                    case WaferStatus.Unknown:
                        slot += "8";
                        break;
                    case WaferStatus.Dummy:
                        slot += "4";
                        break;
                }
            }

            var slotmap = slot;
            if (lp.Error)
            {
                slotmap = string.Empty;
            }
            string message = string.Format("EVT:MAPDT/{0}/{1}", ModuleName2ProtocolName(ModuleHelper.Converter(lp.Name)), slotmap);
            SendMessage(message);
        }

        public void SetInitialize(ModuleName module, bool initialized)
        {
            if (_efemModuleStatus.ContainsKey(module))
            {
                _efemModuleStatus[module].IsInitialized = initialized;
            }
        }
 
        private string ModuleName2ProtocolName(ModuleName module)
        {
            string protocol = "System";

            Dictionary<ModuleName, string> map = new Dictionary<ModuleName, string>()
            {
                {ModuleName.LP1, "P1"},{ModuleName.LP2,"P2"},{ModuleName.LP3,"P3"},{ModuleName.LP4,"P4"},
                {ModuleName.LL1,"LLA"},{ModuleName.LL2,"LLB"},
            };

            if (map.ContainsKey(module))
                protocol = map[module];

            return protocol;
        }

        private ModuleName ProtocolName2ModuleName(string protocol)
        {
            ModuleName module = ModuleName.System;

            Dictionary<string, ModuleName> map = new Dictionary<string, ModuleName>()
            {
                {"P1", ModuleName.LP1},{"P2", ModuleName.LP2},{"P3", ModuleName.LP3},{"P4", ModuleName.LP4},
                {"LLA", ModuleName.LL1},{"LLB", ModuleName.LL2},
                {"SYS", ModuleName.System},
            };

            if (map.ContainsKey(protocol))
                module = map[protocol];

            return module;
        }

        private void MonitorEvent()
        {
            if (_efemDevice.IsSigStatEventMode)
            {
                MonitorSigStatEvent();
                return;
            }

            MonitorReportEvent();
        }

        private void MonitorSigStatEvent()
        {
            bool allEnable = ((SystemServerModule)EfemServerModule.Instance.GetModule(DeviceName.System)).IsEventEnabled(EfemEventType.ALL);
            if (!allEnable)
                return;

            bool lpEnable = ((SystemServerModule)EfemServerModule.Instance.GetModule(DeviceName.System)).IsEventEnabled(EfemEventType.PORT);
            bool sysEnable = ((SystemServerModule)EfemServerModule.Instance.GetModule(DeviceName.System)).IsEventEnabled(EfemEventType.SYSTEM);
 
            Dictionary<string, Tuple<uint,uint>> sigDatas = _efemDevice.GetSigStatData();
            if (sigDatas == null)
                return;
            foreach (var sigData in sigDatas)
            {
                if (sigData.Key.StartsWith("P") && !lpEnable)
                    continue;

                if (sigData.Key.StartsWith(EfemParameter.SYS) && !sysEnable)
                    continue;

                ModuleName module = ProtocolName2ModuleName(sigData.Key);
                if (!_efemModuleStatus[module].IsInitialized)
                    continue;

                if (_efemModuleStatus[module].TrigInitialized.Q)
                {
                    _efemModuleStatus[module].TrigInitialized.CLK = true;
                    _sigData.Remove(sigData.Key);
                    continue;
                }

                if (_sigData.ContainsKey(sigData.Key)
                    && _sigData[sigData.Key].Item1 == sigData.Value.Item1
                    && _sigData[sigData.Key].Item2 == sigData.Value.Item2)
                {
                    continue;
                }

                _sigData[sigData.Key] = sigData.Value;

                SendMessage($"EVT:SIGSTAT/{sigData.Key}/{_sigData[sigData.Key].Item1:X8}/{_sigData[sigData.Key].Item2:X8}");
            }
        }

        private void MonitorReportEvent()
        {
            bool allEnable = ((SystemServerModule)EfemServerModule.Instance.GetModule(DeviceName.System)).IsEventEnabled(EfemEventType.ALL);
            if (!allEnable)
                return;

            bool lpEnable = ((SystemServerModule)EfemServerModule.Instance.GetModule(DeviceName.System)).IsEventEnabled(EfemEventType.PORT);
            bool sysEnable = ((SystemServerModule)EfemServerModule.Instance.GetModule(DeviceName.System)).IsEventEnabled(EfemEventType.SYSTEM);

            Dictionary<string, uint> evDatas = _efemDevice.GetEventData();
            foreach (var evData in evDatas)
            {
                if (evData.Key.StartsWith("P") && !lpEnable)
                    continue;

                if (evData.Key.StartsWith(EfemParameter.SYS) && !sysEnable)
                    continue;

                if (_eventData.ContainsKey(evData.Key) && _eventData[evData.Key] ==evData.Value)
                    continue;

                _eventData[evData.Key] = evData.Value;

                SendMessage($"EVT:{evData.Key}/{evData.Value:X8}");
            }
        }

        public void SendSigStatEvent(ModuleName lL1)
        {

        }
    }
}