using System;
using System.Collections.Generic;
using System.Diagnostics;
using Aitex.Core.Common;
using Aitex.Core.RT.DataCenter;
using Aitex.Core.RT.Device;
using Aitex.Core.RT.Device.Unit;
using Aitex.Core.RT.Event;
using Aitex.Core.RT.Fsm;
using Aitex.Core.RT.OperationCenter;
using Aitex.Core.RT.Routine;
using Aitex.Core.RT.SCCore;
using Aitex.Core.Utilities;
using Aitex.Sorter.Common;
using MECF.Framework.Common.Alarms;
using MECF.Framework.Common.Device.Bases;
using MECF.Framework.Common.Equipment;
using MECF.Framework.Common.Event;
using MECF.Framework.Common.Schedulers;
using MECF.Framework.Common.SubstrateTrackings;
using MECF.Framework.RT.EquipmentLibrary.HardwareUnits.LoadPorts;
using MECF.Framework.RT.EquipmentLibrary.HardwareUnits.Robot;
using FurnaceRT.Equipments.Systems;
using FurnaceRT.Devices;
using Aitex.Core.Util;
using MECF.Framework.RT.EquipmentLibrary.HardwareUnits.CarrierIdReaders.CarrierIDReaderBase;

namespace FurnaceRT.Equipments.LPs
{
    public partial class LoadPortModule
    {
        private List<AlarmEventItem> _triggeredAlarmList = new List<AlarmEventItem>();
        //private IoSmif _smifDevice;
        public IoLP LPDevice { get; set; }
        private int _alarmNumber;
        private RD_TRIG _foupPresentTrig = new RD_TRIG();
        public bool IsPodPresent => LPDevice.IsFoupPresent;
        public bool IsReleased => Module == "LP1" || Module == "LP2" ? LPDevice.Status == DeviceStatus.Release : true;//LP3,4没有相应的sensor
        public bool IsClamp => Module == "LP1" || Module == "LP2" ? LPDevice.Status == DeviceStatus.Clamp : true;//LP3,4没有相应的sensor
        public bool IsHomed => true;
        public string CarrierId { get; set; }
        private bool isNeedReadCarrerID = false;
        public void InitDevice()
        {
            this.OnDeviceAlarmStateChanged += OnModuleDeviceAlarmStateChanged;
            LPDevice = DEVICE.GetDevice<IoLP>($"PM1.{Module}");
            var idReaderDevice = DEVICE.GetDevice<CIDReaderBaseDevice>($"CarrierIDReader.RFIDReader{(Module.ToString().Replace("LP",""))}");
            if (SC.ContainsItem("CarrierID.CarrierIdReaderProtocolType") && SC.GetStringValue("CarrierID.CarrierIdReaderProtocolType") =="1:N")
                idReaderDevice = DEVICE.GetDevice<CIDReaderBaseDevice>($"CarrierIDReader.RFIDReader1");
            if (idReaderDevice != null)
            {
                idReaderDevice.OnCarrierIDReadEvent += OnCarrierIDReadEvent;
                idReaderDevice.OnCarrierIDNReadEvent += OnCarrierIDNReadEvent;
                idReaderDevice.OnCarrierIDReadFailedEvent += OnCarrierIDReadFailedEvent;
                LPDevice.CarrierIDReaderCallBack = idReaderDevice;
                LPDevice.CIDReaders = new CIDReaderBaseDevice[] { idReaderDevice };

            }
      
            //var module = SC.GetStringValue("SMIF.SMIFA.SMIFType") == "Sunway" ? $"{Module}" : $"System.{Module}";
            //SMIFDevice = DEVICE.GetDevice<SMIFBase>(module);
        }
        public void OnModuleDeviceAlarmStateChanged(string deviceId, AlarmEventItem alarmItem)
        {
            if (alarmItem.IsTriggered)
            {
                EventLevel level = alarmItem.Level;

                _triggeredAlarmList.Add(alarmItem);

                if (level == EventLevel.Alarm)
                {
                    try
                    {
                        EV.PostAlarmLog(Module, alarmItem);
                    }
                    catch (Exception ex)
                    {
                        EV.WriteEvent(ex.Message.ToString());
                    }
                }
                else
                {
                    EV.PostWarningLog(Module, alarmItem);
                }
            }
            else
            {
            }
        }

        public void Stop()
        {
            return;
        }

        public override void Monitor()
        {
            _foupPresentTrig.CLK = LPDevice.IsFoupPresent;
            if (_foupPresentTrig.T && IsReady)
            {
                var carrier = CarrierManager.Instance.GetCarrier(Module, 0);
                if (carrier != null && !carrier.IsEmpty)
                {
                    var wafers = WaferManager.Instance.GetWafers(ModuleHelper.Converter(Module));
                    for (int i = 0; i < wafers.Length; i++)
                    {
                        if (!wafers[i].IsEmpty)
                            WaferManager.Instance.DeleteWafer(ModuleHelper.Converter(Module), i);
                    }

                    CarrierManager.Instance.DeleteCarrier(Module);

                }
            }
            if (_foupPresentTrig.R)
            {
                if (SC.GetValue<bool>($"LoadPort.{Name}.EnableAutoCarrierIdRead"))
                    isNeedReadCarrerID = true;
            }
            if(isNeedReadCarrerID && (LPDevice.CarrierIDReaderCallBack as CIDReaderBaseDevice).IsReady && (LPDevice.CarrierIDReaderCallBack as CIDReaderBaseDevice).Check((int)CIDMsg.ReadCarrierID, out _))
            {
                LPDevice.ReadCarrierID();
                isNeedReadCarrerID = false;
            }
        }
        public bool HomeLoadPort(out string reason)
        {
            return LPDevice.Unclamp(out reason);
        }
        public bool LoadLoadPort(out string reason)
        {
            return LPDevice.Unclamp(out reason);
        }
        public bool UnloadLoadPort(out string reason)
        {
            return LPDevice.Clamp(out reason);
        }
        private bool ReadCarrierId( params object[] args)
        {
            ReadCarrierId();
            return true;
        }
        public void ReadCarrierId()
        {
            LPDevice.ReadCarrierID();
        }
        public void OnCarrierIDReadEvent(ModuleName module, string name, string carrierId)
        {
            CarrierId = carrierId;
            CarrierManager.Instance.UpdateCarrierId(module.ToString(), carrierId);          
        }
        public void OnCarrierIDNReadEvent(ModuleName module, string name, string carrierId,int index)
        {
            if ($"LP{index}" == Module.ToString())
            {
                CarrierId = carrierId;
                CarrierManager.Instance.UpdateCarrierId(module.ToString(), carrierId);
            }
        }
        public void OnCarrierIDReadFailedEvent(ModuleName module, string name, string errorcode)
        {
            EV.PostWarningLog(Module, $"{Module} carrier Id read failed for {errorcode}");
        }
       
    }
}