using Aurora;
using Aurora.Api;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using WeldingCommon.Alarm;
using WeldingCommon.Devices;
using WeldingCommon.RMS;
using WeldingCommon.Settings;

namespace WeldingCommon.Sequences
{
    public class SequenceManager
    {
        private static readonly SequenceManager _SequenceManager;
        internal static SequenceManager Instance { get => _SequenceManager; }

        // Calibration Sequence
        SeqMarkGrid _SeqMarkGrid;
        SeqScannerCalibration _SeqScannerCalibration;

        // MainProcess Sequence
        SeqReceiveCellInfo _SeqReceiveCellInfo;
        SeqReportCellResult _SeqReportCellResult;
        SeqScoutFlyingVision _SeqScoutFlyingVision;
        SeqScoutNormal _SeqScoutNormal;
        SeqUploadWeldingList _SeqUploadWeldingList;

        // Manual Sequence
        SeqTeachingRun _SeqTeachingRun;
        SeqManualRunRCC _SeqManualRunRCC;

        static SequenceManager()
        {
            _SequenceManager = new SequenceManager();
        }

        internal void UpdateSequenceStatus(SequenceSetting sequenceSetting, ISequenceEntry sequenceEntry)
        {            
            ChangeRunState(sequenceEntry, CommonSequenceIds.PLCMonitor, true);
            // AlarmMonitor는 각 프로젝트마다 다르기때문에 각 프로젝트에서 시퀀스 실행하는것으로 변경한다.
            //ChangeRunState(sequenceEntry, CommonSequenceIds.AlarmMonitor, sequenceSetting.AlarmMonitor);
            //ChangeRunState(sequenceEntry, CommonSequenceIds.AlarmMonitor, true);
            //ChangeRunState(sequenceEntry, SequenceIds.DeviceMonitor, sequenceSetting.DeviceMonitor);
            //ChangeRunState(sequenceEntry, SequenceIds.MESMonitor, sequenceSetting.MESMonitor);
        }

        private void ChangeRunState(ISequenceEntry sequenceEntry, string sequenceId, bool isRunning, object param = null)
        {
            if (isRunning) {
                if (sequenceEntry[sequenceId].RunState != SequenceRunState.Running) {
                    sequenceEntry[sequenceId].Start(param);
                }
            } else {
                if (sequenceEntry[sequenceId].RunState == SequenceRunState.Running) {
                    sequenceEntry[sequenceId].Stop();
                }
            }
        }

        internal static void RegisterSequence(IAuroraEnvironment aurora, SequenceRegister register)
        {
            _SequenceManager.Register(aurora, register);
        }

        internal void Register(IAuroraEnvironment aurora, SequenceRegister register)
        {
            register(CommonSequenceIds.PLCMonitor, PLCMonitor.Builder(CommonDeviceIds.PLCDevice));

            var seqAlarmMonitoring = new AlarmMonitoring();
            register(CommonSequenceIds.AlarmMonitor, seqAlarmMonitoring.Builder());
            //register(CommonSequenceIds.DeviceMonitor, DeviceMonitoring.Builder());

            if (_SeqMarkGrid == null) {
                _SeqMarkGrid = new SeqMarkGrid();
            }
            register(CommonSequenceIds.SeqMarkGrid, _SeqMarkGrid.Builder());

            if (_SeqScannerCalibration == null) {
                _SeqScannerCalibration = new SeqScannerCalibration();
            }
            register(CommonSequenceIds.SeqScannerCalibration, _SeqScannerCalibration.Builder());

            if (_SeqReceiveCellInfo == null) {
                _SeqReceiveCellInfo = new SeqReceiveCellInfo();
            }
            register(CommonSequenceIds.SeqReceiveCellInfo, _SeqReceiveCellInfo.Builder());

            if (_SeqReportCellResult == null) {
                _SeqReportCellResult = new SeqReportCellResult();
            }
            register(CommonSequenceIds.SeqReportCellResult, _SeqReportCellResult.Builder());

            if (_SeqScoutFlyingVision == null) {
                _SeqScoutFlyingVision = new SeqScoutFlyingVision();
            }
            register(CommonSequenceIds.SeqScoutFlyingVision, _SeqScoutFlyingVision.Builder());

            if (_SeqScoutNormal == null) {
                _SeqScoutNormal = new SeqScoutNormal();
            }
            register(CommonSequenceIds.SeqScoutNormal, _SeqScoutNormal.Builder());

            if (_SeqUploadWeldingList == null) {
                _SeqUploadWeldingList = new SeqUploadWeldingList();
            }
            register(CommonSequenceIds.SeqUploadWeldingList, _SeqUploadWeldingList.Builder());


            if (_SeqTeachingRun == null) {
                _SeqTeachingRun = new SeqTeachingRun();
            }
            register(CommonSequenceIds.SeqTeachingRun, _SeqTeachingRun.Builder());

            if (_SeqManualRunRCC == null) {
                _SeqManualRunRCC = new SeqManualRunRCC();
            }
            register(CommonSequenceIds.SeqManualRunRCC, _SeqManualRunRCC.Builder());

        }

        // 하나의 Instance 로 등록된 Sequence 의 상태를 확인하고 Main Sequence 실행하기 위해서 관리 한다.
        // Calibration Sequence
        public static SequenceBuilder GetSeqBuilder_SeqMarkGrid() { return Instance._SeqMarkGrid.Builder(); }
        public static SequenceBuilder GetSeqBuilder_SeqScannerCalibration() { return Instance._SeqScannerCalibration.Builder(); }

        // MainProcess Sequence
        public static SequenceBuilder GetSeqBuilder_SeqReceiveCellInfo() { return Instance._SeqReceiveCellInfo.Builder(); }
        public static SequenceBuilder GetSeqBuilder_SeqReportCellResult() { return Instance._SeqReportCellResult.Builder(); }

        public static SequenceBuilder GetSeqBuilder_SeqScoutFlyingVision() { return Instance._SeqScoutFlyingVision.Builder(); }
        public static SequenceBuilder GetSeqBuilder_SeqScoutNormal() { return Instance._SeqScoutNormal.Builder(); }
        public static SequenceBuilder GetSeqBuilder_SeqUploadWeldingList() { return Instance._SeqUploadWeldingList.Builder(); }

        // Manual Sequence
        public static SequenceBuilder GetSeqBuilder_SeqTeachingRun() { return Instance._SeqTeachingRun.Builder(); }
        public static SequenceBuilder GetSeqBuilder_SeqManualRunRCC() { return Instance._SeqManualRunRCC.Builder(); }
    }
}