using Aurora.Api;
using AuroraIO;
using AuroraLaser;
using ILSOS_PrismaticScanner.Device;
using System.Collections.Generic;
using System.Threading;
using WeldingCommon.Alarm;
using WeldingCommon.Settings;
using WeldingCommon.Utils;

namespace WeldingCommon.Sequences
{
    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_UI = "Update UI";
        public const string UPDATE_IO = "Update IO";

        private static SequenceSetting _SequenceSetting;

        private static Laser _laser;
        private static PLCControllerPrismaticScanner _plc;
        private static IODevice _io;

        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_UI, UpdateUI);
            sb.AddAction(UPDATE_IO, UpdateIO);

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

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

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

            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(PLCControllerPrismaticScanner.eBitOutput.PC_HEAVY_ALARM_STATUS, AlarmManager.HasAlarmLevelHigh());
            _plc.WriteBit(PLCControllerPrismaticScanner.eBitOutput.PC_LIGHT_ALARM_STATUS, AlarmManager.HasAlarmLevelLow());

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

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

        private static SequenceActionResult UpdateUI(SequenceContext context, string id, SequenceActionResult param)
        {
            Thread.Sleep(NODE_SLEEP);
            return SequenceAction.Ok();
        }

        private static SequenceActionResult UpdateIO(SequenceContext context, string id, SequenceActionResult param)
        {
            Status.RMSUse = _plc.ReadBit(PLCControllerPrismaticScanner.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)
        {
        }
    }
}