using Aurora.Api;
using AuroraACS;
using AuroraIO;
using AuroraLaser;
using AuroraLaser.Trumpf;
using AuroraMotionBoard.Ajin;
using ILSOS_PrismaticGun.Alarm;
using ILSOS_PrismaticGun.Device;
using ILSOS_PrismaticGun.Device.ACS;
using ILSOS_PrismaticGun.Process;
using ILSOS_PrismaticGun.Settings;
using ILSOS_PrismaticGun.Tools;
using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Linq;
using System.Text;
using System.Threading;
using System.Threading.Tasks;
using VisionCommon;
using WeldingCommon;
using WeldingCommon.Alarm;
using WeldingCommon.Devices;
using WeldingCommon.Settings;
using WeldingCommon.Utils;

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

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

        const string SEQ_LoopFirst = "SEQ Loop First";

        public const string UPDATE_STATUS = "Update Status";
        public const string UPDATE_FDC = "Update FDC";
        public const string UPDATE_UI = "Update UI";
        public const string UPDATE_IO = "Update IO";

        private static SequenceSetting _SequenceSetting;

        private static PLCControllerPrismaticGun _plc;
        private static Laser _laser;
        private static PrismaticGunACSIO _io;
        private static PrismaticGunACS _acs;
        private static IPrismaticGunACS _acsMotion;
        private static AJINDevice _ajin;
        //private static ACSMotor _axisAX, _axisAY, _axisBX, _axisBY;

        public const int TIMEOUT_PLC_LIVE_CHECK = 2000;     // msec
        public const int NODE_SLEEP = 20;
        public static SequenceBuilder Builder()
        {
            SequenceBuilder sb = new SequenceBuilder(1000, true);

            sb.AddAction(SEQ_START, StartNode);
            sb.AddDecision(SEQ_LoopFirst, LoopFirstNode);
            sb.AddAction(UPDATE_STATUS, UpdateStatus);
            sb.AddAction(UPDATE_FDC, UpdateFdc);
            sb.AddAction(UPDATE_UI, UpdateUI);
            sb.AddAction(UPDATE_IO, UpdateIO);

            sb.Flows(sb.Init > sb[SEQ_START] > sb[SEQ_LoopFirst]
                     > sb[UPDATE_STATUS] > sb[UPDATE_FDC] > sb[UPDATE_UI]
                     > sb[UPDATE_IO] > 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;

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

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

            if(_ajin is null)
                _ajin = context.Devices[DeviceIds.AJIN] as AJINDevice;

            return SequenceAction.Ok();
        }

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

            return SeqNodeIds.FINAL;
        }

        private static SequenceActionResult UpdateStatus(SequenceContext context, string id, SequenceActionResult param)
        {
            _plc.WriteBit(PLCControllerPrismaticGun.eBitOutput.PC_HEAVY_ALARM_STATUS, AlarmManager.HasAlarmLevelHigh());
            _plc.WriteBit(PLCControllerPrismaticGun.eBitOutput.PC_LIGHT_ALARM_STATUS, AlarmManager.HasAlarmLevelLow());

            _plc.WriteBit(PLCControllerPrismaticGun.eBitOutput.PC_STAGE_A_LOAD_ENABLE, _acs.MotionVariables[eStage.A].IsLoadEnable & _acs.IsActivated);
            _plc.WriteBit(PLCControllerPrismaticGun.eBitOutput.PC_STAGE_A_UNLOAD_ENABLE, _acs.MotionVariables[eStage.A].IsUnloadEnable & _acs.IsActivated);
            _plc.WriteBit(PLCControllerPrismaticGun.eBitOutput.PC_STAGE_B_LOAD_ENABLE, _acs.MotionVariables[eStage.B].IsLoadEnable & _acs.IsActivated);
            _plc.WriteBit(PLCControllerPrismaticGun.eBitOutput.PC_STAGE_B_UNLOAD_ENABLE, _acs.MotionVariables[eStage.B].IsUnloadEnable & _acs.IsActivated);

            var boolian = _plc.ReadBit(PLCControllerPrismaticGun.eBitInput.PLC_ALARM_RESET).data;
            if (ChangeChecker.IsChangedBoolMonitoring("AlarmReset", boolian, true)){
                context.EventPublisher.Publish(new EventMessage("SeqAlarmMonitor", CommonEventIds.EVENT_RESET_ALL_ALARMS_REQUEST));
            }

            boolian = _io.ReadDiBit(PrismaticGunACSIO.InputIO.LASER_IO_INPUT_01_TO_PLC);
            if (ChangeChecker.IsChangedBoolMonitoring("AlarmResetpush", boolian, true)){
                context.EventPublisher.Publish(new EventMessage("SeqAlarmMonitor", CommonEventIds.EVENT_RESET_ALL_ALARMS_REQUEST));
            }

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

        private static SequenceActionResult UpdateFdc(SequenceContext context, string id, SequenceActionResult param)
        {
            var _laserCore = _laser.getCore() as LaserTruFiber;
            int LaserPower = 0;
            if (_laserCore != null && int.TryParse(_laserCore.GetData(csReadNodeNo.OW06), out int result))
                LaserPower = result;

            bool AStageRunning = _acsMotion.CheckACSWeldingEnable(eStage.B);
            bool BStageRunning = _acsMotion.CheckACSWeldingEnable(eStage.A);

            _plc.WriteWord(PLCControllerPrismaticGun.eWordOutput.USED_STAGE_A_FDC_LASER_POWER, AStageRunning ? (short)(LaserPower * 10) : (short)0);
            _plc.WriteWord(PLCControllerPrismaticGun.eWordOutput.USED_STAGE_A_FDC_X_VELOCITY, (short)(_acs.MotionVariables[eStage.A].XAxisVelocity * 10));
            _plc.WriteWord(PLCControllerPrismaticGun.eWordOutput.USED_STAGE_A_FDC_Y_VELOCITY, (short)(_acs.MotionVariables[eStage.A].YAxisVelocity * 10));
            _plc.WriteWord(PLCControllerPrismaticGun.eWordOutput.USED_STAGE_A_FDC_X_LOADFACTOR, (short)(_acs.MotionVariables[eStage.A].XAxisLoadFactor * 100));
            _plc.WriteWord(PLCControllerPrismaticGun.eWordOutput.USED_STAGE_A_FDC_Y_LOADFACTOR, (short)(_acs.MotionVariables[eStage.A].YAxisLoadFactor * 100));

            _plc.WriteWord(PLCControllerPrismaticGun.eWordOutput.USED_STAGE_B_FDC_LASER_POWER, BStageRunning ? (short)(LaserPower * 10) : (short)0);
            _plc.WriteWord(PLCControllerPrismaticGun.eWordOutput.USED_STAGE_B_FDC_X_VELOCITY, (short)(_acs.MotionVariables[eStage.B].XAxisVelocity * 10));
            _plc.WriteWord(PLCControllerPrismaticGun.eWordOutput.USED_STAGE_B_FDC_Y_VELOCITY, (short)(_acs.MotionVariables[eStage.B].YAxisVelocity * 10));
            _plc.WriteWord(PLCControllerPrismaticGun.eWordOutput.USED_STAGE_B_FDC_X_LOADFACTOR, (short)(_acs.MotionVariables[eStage.B].XAxisLoadFactor * 100));
            _plc.WriteWord(PLCControllerPrismaticGun.eWordOutput.USED_STAGE_B_FDC_Y_LOADFACTOR, (short)(_acs.MotionVariables[eStage.B].YAxisLoadFactor * 100));

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

        private static SequenceActionResult UpdateUI(SequenceContext context, string id, SequenceActionResult param)
        {
            var doorInterlock = _plc.ReadBit(PLCControllerPrismaticGun.eBitInput.PLC_DOOR_INTERLOCK).data;
            if (ChangeChecker.IsChangedBool("DoorInterlock", doorInterlock))
                context.EventPublisher.Publish(new EventMessage("SeqStatusMonitor", CommonEventIds.EVENT_CHANGE_DOOR_LOCK, doorInterlock));

            return SequenceAction.Ok();
        }

        private static SequenceActionResult UpdateIO(SequenceContext context, string id, SequenceActionResult param)
        {
            Status.RMSUse = _plc.ReadBit(PLCControllerPrismaticGun.eBitInput.PLC_RMS_USED).data;
            Thread.Sleep(NODE_SLEEP);
            return SequenceAction.Ok();
        }

        private static void OnStopped(SequenceContext context)
        {
        }

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