using ACS.SPiiPlusNET;
using Aurora;
using Aurora.Api;
using Aurora.Framework.Alarm;
using AuroraACS;
using AuroraChiller;
using AuroraIO;
using AuroraLaser;
using AuroraLaser.Trumpf;
using AuroraLaserScanner;
using AuroraLBAD;
using AuroraMotionBoard.Ajin;
using AuroraOCT;
using Hermes.Functional;
using ILSOS_PrismaticGun.Alarm;
using ILSOS_PrismaticGun.Device;
using ILSOS_PrismaticGun.Device.ACS;
using ILSOS_PrismaticGun.Process;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Security.Claims;
using System.Text;
using System.Threading;
using System.Threading.Tasks;
using WeldingCommon;
using WeldingCommon.Alarm;
using WeldingCommon.Devices;
using WeldingCommon.Sequences;
using WeldingCommon.Settings;
using WeldingCommon.Utils;

namespace ILSOS_PrismaticGun.Sequences.Monitoring
{
    public class SeqAlarmMonitor
    {
        static readonly Logger Log = new Logger("AlarmMonitoring");

        const string SEQ_START = "SEQ START";                                       // 딱 한번 Sequence 진입 시에만 실행될 Node

        const string SEQ_LoopFirst = "SEQ Loop First";

        public const string CHECK_ALARM_PLC = "Check Alarm PLC";
        public const string CHECK_ALARM_ACS = "Check Alarm ACS";
        public const string CHECK_ALARM_LASER = "Check Alarm Laser";
        public const string CHECK_ALARM_IO = "Check Alarm IO";

        private static SequenceSetting _SequenceSetting;

        private static PLCControllerPrismaticGun _plc;
        private static Laser _laser;
        private static LaserTruFiber _laserCore;
        private static PrismaticGunACSIO _io;
        private static PrismaticGunACS _acs;
        private static ACSMotor _axisAX, _axisAY, _axisBX, _axisBY;
        private static AJINMotor _axisAZ, _axisBZ;

        public const int NODE_SLEEP = 100;     // msec

        public static SequenceBuilder Builder()
        {
            SequenceBuilder sb = new SequenceBuilder(1000, true);

            sb.AddAction(SEQ_START, StartNode);
            sb.AddDecision(SEQ_LoopFirst, LoopFirstNode);
            sb.AddAction(CHECK_ALARM_PLC, CheckAlarmPlc);
            sb.AddAction(CHECK_ALARM_LASER, CheckAlarmLaser);
            sb.AddAction(CHECK_ALARM_IO, CheckAlarmIO);
            sb.AddAction(CHECK_ALARM_ACS, CheckAlarmAcs);

            sb.Flows(sb.Init > sb[SEQ_START] > sb[SEQ_LoopFirst]
                     > sb[CHECK_ALARM_PLC] > sb[CHECK_ALARM_LASER]
                     > sb[CHECK_ALARM_IO] > sb[CHECK_ALARM_ACS]
                     > sb[SEQ_LoopFirst]);

            sb.Flows(sb[SEQ_LoopFirst] > sb.Final);

            sb.OnStopped(OnStopped);
            sb.OnForceError(OnForceError);

            //sb.Draw("SeqAlarmMonitor.pdf");

            return sb;

        }

        private static SequenceActionResult StartNode(SequenceContext context, string id, SequenceActionResult param)
        {
            _SequenceSetting = context.Settings[CommonSettingIds.Sequence] as SequenceSetting;

            if (_plc is null)
                _plc = context.Devices[CommonDeviceIds.PLCDevice] as PLCControllerPrismaticGun;

            if (_laser is null)
                _laser = context.Devices[CommonDeviceIds.Laser] as Laser;

            _laserCore = _laser.getCore() as LaserTruFiber;

            if (_io is null)
                _io = context.Devices[CommonDeviceIds.IODevice] as PrismaticGunACSIO;

            if (_acs is null)
                _acs = context.Devices[DeviceIds.ACS] as PrismaticGunACS;

            if (_axisAX is null)
                _axisAX = context.Devices[MotorIds.ALineX] as ACSMotor;

            if (_axisAY is null)
                _axisAY = context.Devices[MotorIds.ALineY] as ACSMotor;

            if (_axisBX is null)
                _axisBX = context.Devices[MotorIds.BLineX] as ACSMotor;

            if (_axisBY is null)
                _axisBY = context.Devices[MotorIds.BLineY] as ACSMotor;

            if (_axisAZ is null)
                _axisAZ = context.Devices[MotorIds.ALineZ] as AJINMotor;

            if (_axisBZ is null)
                _axisBZ = context.Devices[MotorIds.BLineZ] as AJINMotor;

            return SequenceAction.Ok();
        }

        private static string LoopFirstNode(SequenceContext context, string id, ICollection<string> branches, SequenceActionResult param)
        {
            while (!context.Stopped) {
                return CHECK_ALARM_PLC;
            }

            Thread.Sleep(NODE_SLEEP);
            return SeqNodeIds.FINAL;
        }

        private static SequenceActionResult CheckAlarmPlc(SequenceContext context, string id, SequenceActionResult param)
        {
            if (_plc.ReadBit(PLCControllerPrismaticGun.eBitInput.PLC_LIGHT_ALARM_STATUS).data)
                if (!AlarmManager.IsOccuredAlarm(AlarmCode_PrismaticGun.PLC_LIGHT_ALARM))
                    Log.E($"{context.AlarmAccured(AlarmCode_PrismaticGun.PLC_LIGHT_ALARM)}");

            var plcHeavyAlarm = _plc.ReadBit(PLCControllerPrismaticGun.eBitInput.PLC_HEAVY_ALARM_STATUS).data;

            if (ChangeChecker.IsChangedBoolMonitoring("PlcHeavyAlarm", plcHeavyAlarm, true)) {
                Log.E("PLC Heavy Alarm 발생!!!");
                Log.E($"Stage A : X = {_axisAX.GetActualPos()}, Y = {_axisAY.GetActualPos()}, Z = {_axisAZ.GetCurrentPosition()}");
                Log.E($"Stage B : X = {_axisBX.GetActualPos()}, Y = {_axisBY.GetActualPos()}, Z = {_axisBZ.GetCurrentPosition()}");
                ProcessManager.Instance.CycleStop();
            }

            var doorInterlock = _plc.ReadBit(PLCControllerPrismaticGun.eBitInput.PLC_DOOR_INTERLOCK).data;
            if (doorInterlock) {
                if (!AlarmManager.IsOccuredAlarm(AlarmCode_PrismaticGun.PLC_DOOR_INTERLOCK))
                    Log.E($"{context.AlarmAccured(AlarmCode_PrismaticGun.PLC_DOOR_INTERLOCK)}");
            }

            if(doorInterlock && _plc.ReadOutBit(PLCControllerPrismaticGun.eBitOutput.PC_STAGE_A_WELDING_BUSY).data) {
                if (!AlarmManager.IsOccuredAlarm(AlarmCode_PrismaticGun.STAGE_A_DOOR_INTERLOCK_DURING_WELDING))
                    Log.E($"{context.AlarmAccured(AlarmCode_PrismaticGun.STAGE_A_DOOR_INTERLOCK_DURING_WELDING)}");
            }

            if (doorInterlock && _plc.ReadOutBit(PLCControllerPrismaticGun.eBitOutput.PC_STAGE_B_WELDING_BUSY).data) {
                if (!AlarmManager.IsOccuredAlarm(AlarmCode_PrismaticGun.STAGE_B_DOOR_INTERLOCK_DURING_WELDING))
                    Log.E($"{context.AlarmAccured(AlarmCode_PrismaticGun.STAGE_B_DOOR_INTERLOCK_DURING_WELDING)}");
            }

            if (_plc.ReadBit(PLCControllerPrismaticGun.eBitInput.PLC_EMO_STATUS).data){
                if (!AlarmManager.IsOccuredAlarm(AlarmCode_PrismaticGun.PLC_EMO_PUSH)) {
                    _laserCore.LaserOff();
                    Log.E($"{context.AlarmAccured(AlarmCode_PrismaticGun.PLC_EMO_PUSH)}");
                }
            }
            Thread.Sleep(NODE_SLEEP);
            return SequenceAction.Ok();
        }

        private static SequenceActionResult CheckAlarmAcs(SequenceContext context, string id, SequenceActionResult param)
        {
            if ((_acs.HasHeavyAlarm | _acs.HasLightAlarm) & _acs.IsActivated) {
                foreach (var alarm in _acs.HaveAlarmCodes) {
                    if (alarm != 0) {
                        if (!AlarmManager.IsOccuredAlarm(alarm))
                            Log.E($"{context.AlarmAccured(alarm)}");
                    }
                }
            }

            if (_axisAZ.IsAlarm())
                if (!AlarmManager.IsOccuredAlarm(AlarmCode_PrismaticGun.DEVICE_STAGE_A_AXISZ_ERROR))
                    Log.E($"{context.AlarmAccured(AlarmCode_PrismaticGun.DEVICE_STAGE_A_AXISZ_ERROR)}");

            if (_axisBZ.IsAlarm())
                if (!AlarmManager.IsOccuredAlarm(AlarmCode_PrismaticGun.DEVICE_STAGE_B_AXISZ_ERROR))
                    Log.E($"{context.AlarmAccured(AlarmCode_PrismaticGun.DEVICE_STAGE_B_AXISZ_ERROR)}");

            Thread.Sleep(NODE_SLEEP);
            return SequenceAction.Ok();
        }

        private static SequenceActionResult CheckAlarmLaser(SequenceContext context, string id, SequenceActionResult param)
        {
            _laserCore = _laser.getCore() as LaserTruFiber;
            if (_laserCore.GetEStopOpen()) {
                if (!AlarmManager.IsOccuredAlarm(AlarmCode_PrismaticGun.DEVICE_IO_LASER_EMO))
                    Log.E($"{context.AlarmAccured(AlarmCode_PrismaticGun.DEVICE_IO_LASER_EMO)}");
            }
            if (_laserCore.GetFaultLaser()) {
                if (!AlarmManager.IsOccuredAlarm(AlarmCode_PrismaticGun.DEVICE_LASER_ERROR_MSG)) {
                    string alarmCode = $"{Convert.ToString(_laserCore.GetLastMessageCompID(), 16).ToUpper().PadLeft(2, '0')}{Convert.ToString(_laserCore.GetLastMessageCompNum(), 16).ToUpper().PadLeft(2, '0')} {Convert.ToString(_laserCore.GetLastMessageMsgCode(), 16).ToUpper().PadLeft(2, '0')}";
                    string alarmDescription = $" {_laserCore.GetLastMessageShortText()}";
                    Log.E($"{context.AlarmAccured(AlarmCode_PrismaticGun.DEVICE_LASER_ERROR_MSG)} >> code desc {alarmCode + alarmDescription}");
                }
            } else if (_laserCore.GetMonitoring()) {
                if (!AlarmManager.IsOccuredAlarm(AlarmCode_PrismaticGun.DEVICE_LASER_WARNING_MSG)) {
                    string alarmCode = $"{Convert.ToString(_laserCore.GetLastMessageCompID(), 16).ToUpper().PadLeft(2, '0')}{Convert.ToString(_laserCore.GetLastMessageCompNum(), 16).ToUpper().PadLeft(2, '0')} {Convert.ToString(_laserCore.GetLastMessageMsgCode(), 16).ToUpper().PadLeft(2, '0')}";
                    string alarmDescription = $" {_laserCore.GetLastMessageShortText()}";
                    Log.E($"{context.AlarmAccured(AlarmCode_PrismaticGun.DEVICE_LASER_WARNING_MSG)} >> code desc {alarmCode + alarmDescription}");
                }
            }
            Thread.Sleep(NODE_SLEEP);
            return SequenceAction.Ok();
        }
        private static SequenceActionResult CheckAlarmIO(SequenceContext context, string id, SequenceActionResult param)
        {
            if(!_io.ReadDiBit(PrismaticGunACSIO.InputIO.MAIN_CHILLER_Leak_Sensor))
                if (!AlarmManager.IsOccuredAlarm(AlarmCode_PrismaticGun.CHILLER_LEAK_ALARM))
                    Log.E($"{context.AlarmAccured(AlarmCode_PrismaticGun.CHILLER_LEAK_ALARM)}");


            Thread.Sleep(NODE_SLEEP);
            return SequenceAction.Ok();
        }

        private static void OnStopped(SequenceContext context)
        {
        }

        private static void OnForceError(SequenceContext context, string arg2)
        {
        }
    }
}