using System;
using System.Collections.Generic;
using System.Diagnostics;
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.Util;
using Aitex.Core.Utilities;
using Aitex.Sorter.Common;
using MECF.Framework.Common.Alarms;
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 MECF.Framework.RT.EquipmentLibrary.HardwareUnits.Robots;
using MECF.Framework.RT.EquipmentLibrary.HardwareUnits.Robots.RobotBase;

namespace FurnaceRT.Equipments.WaferRobots
{
    public partial class WaferRobotModule
    {
        public RobotBaseDevice WaferRobotDevice { get; set; }
        private List<AlarmEventItem> _triggeredAlarmList = new List<AlarmEventItem>();
        private int _alarmNumber;
        public IoTrigger TrigActionCommand => _trigActionCommand;
        public IoAlarmSignal AlarmSignaRobotTPStatusWarning { get; set; }
        private IoTrigger _trigAlarmReset;
        private IoTrigger _trigActionCommand;
        private IoAlarmSignal _alarmSignaRobotAlarm;
        private R_TRIG _alarmSignaRobotAlarmTrig = new R_TRIG();
        private Dictionary<string, int> _actionCommand;
        public void InitDevice()
        {
            WaferRobotDevice = DEVICE.GetDevice<RobotBaseDevice>($"{ModuleName.WaferRobot}");
            AlarmSignaRobotTPStatusWarning = DEVICE.GetDevice<IoAlarmSignal>($"PM1.AlarmSignaWaferRobotTPStatusWarning");
            _alarmSignaRobotAlarm = DEVICE.GetDevice<IoAlarmSignal>($"PM1.AlarmSignaWaferRobotAlarm");
            _trigAlarmReset = DEVICE.GetDevice<IoTrigger>($"PM1.TrigWaferRobotAlarmReset");
            _trigActionCommand = DEVICE.GetDevice<IoTrigger>($"PM1.TrigWaferRobotActionCommand");
            WaferManager.Instance.SubscribeLocation($"{ModuleName.WaferRobot}", 5);
            this.OnDeviceAlarmStateChanged += OnModuleDeviceAlarmStateChanged;
            WaferRobotDevice.OnDeviceAlarmStateChanged += OnModuleDeviceAlarmStateChanged;
            _actionCommand = new Dictionary<string, int>()
            {
                {"C01.Pick",1 },
                {"C01.Place",2 },
                {"C02.Pick",3 },
                {"C02.Place",4 },
                {"C03.Pick",5 },
                {"C03.Place",6 },
            };
        }
        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());
                    }

                    int count = 0;
                    var alarms = EV.GetAlarmEvent();
                    foreach (var alarm in alarms)
                    {
                        if (alarm.Level == EventLevel.Alarm && alarm.Source == Name)
                            count++;
                    }
                    if (_alarmNumber != count && count != 0)
                    {
                        PostMsg(MSG.Error);
                    }
                    _alarmNumber = count;
                }
                else
                {
                    EV.PostWarningLog(Module, alarmItem);
                }
            }
            else
            {
            }
        }
        public void SetCassetteRobotReset()
        {
            WaferRobotDevice.RobotReset();
        }
        public bool SetWaferRobotHome(out string reason)
        {
            reason = string.Empty;
            return WaferRobotDevice.HomeModule(null);
        }
        public bool SetSpeed(int speed, out string reason)
        {
            reason = string.Empty;
            return WaferRobotDevice.SetSpeed("SetSpeed", speed);
        }
        public bool RequestWaferPresent(Hand hand, out string reason)
        {
            reason = string.Empty;
            RobotArmEnum arm = hand == Hand.Blade1 ? RobotArmEnum.Blade1 : RobotArmEnum.Blade2;
            List<object> paras = new List<object>() { "CurrentStatus", arm };
            return WaferRobotDevice.ReadParameter(paras.ToArray());
        }
        public bool RobotPick(ModuleName target, int targetSlot, Hand hand, out string reason)
        {
            reason = string.Empty;
            RobotArmEnum arm = hand == Hand.Blade1 ? RobotArmEnum.Blade1 : RobotArmEnum.Both;
            return WaferRobotDevice.Pick(arm, target.ToString(), targetSlot);
        }
        public bool RobotPlace(ModuleName target, int targetSlot, Hand hand, out string reason)
        {
            reason = string.Empty;
            RobotArmEnum arm = hand == Hand.Blade1 ? RobotArmEnum.Blade1 : RobotArmEnum.Both;
            return WaferRobotDevice.Place(arm, target.ToString(), targetSlot);
        }
        public bool RobotMap(ModuleName target, Hand hand, out string reason)
        {
            reason = string.Empty;
            return WaferRobotDevice.WaferMapping(target, out reason);
        }
        public void Stop()
        {
            WaferRobotDevice.Stop();
        }
        public void SetRobotActionCommand(ModuleName traget, EnumTransferType transferType)
        {
            if (!WaferRobotDevice.ModuleAssociateStationDic.ContainsKey(traget.ToString()))
                return;

            var station = WaferRobotDevice.ModuleAssociateStationDic[traget.ToString()];
            if (!_actionCommand.ContainsKey($"{station}.{transferType}"))
                return;
            _trigActionCommand.SetAOTrigger(_actionCommand[$"{station}.{transferType}"], out _);
        }
        public bool CheckRobotActionCommand(ModuleName traget, EnumTransferType transferType)
        {
            if (!WaferRobotDevice.ModuleAssociateStationDic.ContainsKey(traget.ToString()))
                return false;

            var station = WaferRobotDevice.ModuleAssociateStationDic[traget.ToString()];
            if (!_actionCommand.ContainsKey($"{station}.{transferType}"))
                return false;
            return Math.Abs(_trigActionCommand.AIValue - _actionCommand[$"{station}.{transferType}"]) < 0.001;
        }
        public void ResetRobotActionCommand()
        {
            _trigActionCommand?.SetAOTrigger(0, out _);
        }
    }
}