using Aurora;
using Aurora.Api;
using Aurora.Api.Manager;
using Aurora.Api.Services;
using Aurora.View;
using Aurora.View.Alarm;
using Aurora.View.AutoBackup;
using AuroraCellTracker;
using AuroraCellTracker.Views;
using AuroraIO;
using AuroraIO.View;
using AuroraLaser;
using AuroraLBAD;
using AuroraLBAD.Services;
using AuroraOCT;
using AuroraOCT.Views;
using AuroraPLC;
using AuroraPLC.Views;
using CoreUnit.Scanner.UserControl.ScannerCanvas;
using DB;
using DB.Recipe;
using GUI;
//using ILSOS_PrismaticRD_TDC.Sequences;
using ILSOS_PrismaticRD_PTOP.Sequences; // 260605
using ILSOS_PrismaticScanner.Alarm;
using ILSOS_PrismaticScanner.Device;
using ILSOS_PrismaticScanner.Device.IO;
using ILSOS_PrismaticScanner.Models;
using ILSOS_PrismaticScanner.Recipes;
using ILSOS_PrismaticScanner.Sequences;
using ILSOS_PrismaticScanner.Settings;
using ILSOS_PrismaticScanner.Views;
using System;
using System.Linq;
using System.Reactive.Concurrency;
using System.Reactive.Linq;
using System.Threading;
using System.Threading.Tasks;
using System.Windows.Controls;
using System.Windows.Threading;
using WeldingCommon;
using WeldingCommon.Alarm;
using WeldingCommon.Recipes;
using WeldingCommon.Sequences;
using WeldingCommon.Settings;
using WeldingCommon.Utils;
using WeldingCommon.Views;
using WeldingCommon.Views.Manual;
using WeldingCommon.Views.Recipes.History;
using WeldingCommon.Vision.Factory;
using static WeldingCommon.Vision.Factory.VisionFactory;

namespace ILSOS_PrismaticScanner
{
    internal class EquipmentSetup : CommonEquipmentSetup, IEquipmentSetup
    {
        private SequenceBuilder _SeqAutoRunPrismaticScanner_Builder;
        private SequenceBuilder _SeqAutoRunComponentWeld_Builder;
        private SequenceBuilder _SeqTestRun_Builder;
        private SequenceBuilder _SeqAlarmMonitor_Builder;

        private SequenceBuilder _SeqAutoRunPTOP_Builder; //260605 추가


        public override void BuildMainStatusView(MainStatusBuilder builder)
        {
            base.BuildMainStatusView(builder);

            builder.AddDeviceActiveStatus(CommonDeviceIds.CellTracker)
                   .AddDeviceActiveStatus(CommonDeviceIds.OCT);
        }

        public override string GetEquipmentName()
        {
            return "ILSOS PrismaticRD_PTOP";
        }

        public void OnSetAlarm(int code, bool isHeavy)
        {
            base.OnSetAlarm(code, isHeavy);

            if (isHeavy) {
                AlarmManager_PrismaticScanner.StopSequenceByAlarm(code);
            }
        }

        public override async void OnStartUp()
        {
            var equipSetting = AuroraEnv.SettingEntry[AuroraSettings.Equipment] as EquipmentInfo;
            if (equipSetting.AutomaticallyConnectDevices) {
                await ActivateDevices();
            }

            //AuroraEx.RegisterRmsHandler<RMSHandlerForScanner>();
            //AuroraEnv.RecipeManager.RmsHandler().RegistryDeviceHandler(AuroraEnv);
            //AuroraEnv.RecipeManager.RmsHandler().Start();

            //// [Singleton Instance] Recipe Change History
            // 260514_ 레시피 파라미터 세팅 때 null settingparameter null인 경우에는 싱글톤상속 해당 생성자를 프로그램 시작 때 등록을 안해줘서 그런 것이니 
            // 주석 해제해서 사용할 것.
            AuroraEnv.RecipeManager.RchHandler().RegistryDeviceHandler(AuroraEnv);

            //AlarmMonitroing Seq Start
            AuroraEnv.SequenceEntry[SequenceIds.SeqAlarmMonitor].Start();
            AuroraEnv.SequenceEntry[SequenceIds.SeqStatusMonitor].Start();
            AuroraEnv.SequenceEntry[CommonSequenceIds.PLCMonitor].Start();


            base.OnStartUp();
        }
        public override void OnShutDown()
        {
            // 모니터링 시퀀스 먼저 종료
            AuroraEnv.SequenceEntry[SequenceIds.SeqAlarmMonitor].Stop();
            AuroraEnv.SequenceEntry[SequenceIds.SeqStatusMonitor].Stop();
            AuroraEnv.SequenceEntry[CommonSequenceIds.PLCMonitor].Stop();
            Thread.Sleep(200);

            base.OnShutDown();
        }

        public override void OnPostDeviceActivated(string dev)
        {
            base.OnPostDeviceActivated(dev);

            switch (dev) {
                case DeviceIds.IODevice:
                    var io = AuroraEnv.DeviceManager[dev] as IODevice;
                    //io._iOUnit.WriteDoBit((int)PAIX_PrismaticScanner.ePrismaticDOAddress.AirKnifeRegulator, true);
                    break;
                case DeviceIds.PLCDevice:
                    var plc = AuroraEnv.DeviceManager[dev] as PLCControllerPrismaticScanner;
                    plc.WriteBit(PLCControllerPrismaticScanner.eBitOutput.PC_AUTO_STATUS, false);
                    break;
            }
        }
        public override void RegisterDevices(IDeviceRegistry registry)
        {
            base.RegisterDevices(registry);

            var isSimul = ApplicationExt.IsSimulation;

            //registry.Register(CommonDeviceIds.OCT, () => new OCT(CommonDeviceIds.OCT, isSimul), new OCTConfig(),
            //    device => new UCOCTDevice() { DataContext = new UCOCTDeviceViewModel(AuroraEnv, CommonDeviceIds.OCT) });
            //registry.Register(CommonDeviceIds.LBAD, () => new LBAD(CommonDeviceIds.LBAD, isSimul), new LBADConfig());
            //registry.Register(CommonDeviceIds.CellTracker, () => new CellTracker(CommonDeviceIds.CellTracker, eCellTrackerType.Daekhon, isSimul), new CellTrackerConfig(),
            //    device => new UCCellTrackerDevice() { DataContext = new UCCellTrackerDeviceViewModel(AuroraEnv, CommonDeviceIds.CellTracker) });


            //IODevice는 AjinIO가 아니라 IOUnit으로 받아오는것으로 수정해야 함
            
            registry.Register(CommonDeviceIds.IODevice, () => new PAIX_PrismaticScanner(AuroraEnv, CommonDeviceIds.IODevice, isSimul), new IOUnitConfig());
                
            registry.Register(CommonDeviceIds.Laser, () => new Laser(CommonDeviceIds.Laser, isSimul), new LaserConfig(),
                device => new UCLaserDevice() { DataContext = new UCLaserDeviceViewModel(AuroraEnv, CommonDeviceIds.Laser) });

            var _plc = new PLCControllerPrismaticScanner(CommonDeviceIds.PLCDevice, ePLCNetType.MXComponent, ApplicationExt.IsSimulation, PLCMMapFileType.CSV, AuroraEnv);
            //var _plc = new PLCControllerPrismaticScanner(CommonDeviceIds.PLCDevice, ePLCNetType.MXComponent, true, PLCMMapFileType.CSV, AuroraEnv);
            // 260513 plc ㅊㅔㅋㅡ ㅍㅣㄹㅇㅛㅎㅏㅂㄴㅣㄷㅏ.

            registry.Register(CommonDeviceIds.PLCDevice,
                () => _plc, PLCMxComponentConfig.GetDefaultConfig(),
                device => new UCPLCDevice() { DataContext = new UCPLCDeviceViewModel(AuroraEnv, _plc) });

            AlarmManager.Init(AuroraEnv);

        }

        public override void RegisterRecipes(RecipeRegister register)
        {
            register(CommonRecipeIds.ScannerObjectTeaching, new ScannerObjectTeachingRecipe(),
                (id, item) => new UCScannerObjectTeaching(AuroraEnv));

            base.RegisterRecipes(register);
        }

        public override void RegisterModels(ModelRegister register)
        {
            register(CommonModelIds.EquipmentSpecificModel, new EquipmentSpecificModel_PrismaticScanner(),
                (id, item) => new UCModelEditor(new UCModelEditorViewModel(AuroraEnv), ModelExternalDelegate.ExternalCreateEquipmentSpecificEditor));

            base.RegisterModels(register);
        }

        public override void RegisterSequences(SequenceRegister register)
        {
            // Common Sequences register
            SequenceManager.RegisterSequence(AuroraEnv, register);
            base.RegisterSequences(register);

            var equipSetting = AuroraEnv.SettingEntry[AuroraSettings.Equipment] as EquipmentInfo;
            //register(SequenceIds.SeqTestRun, SeqStreamTest.Builder());

            // Event Q Test 추가
            //var seqEventQTest = new SeqEventQTest();
            //register(SequenceIds.SeqEventQTest, seqEventQTest.Builder());

            var seqAutoRunPrismaticScanner = new SeqAutoRunPrismaticScanner();
            var seqAutoRunComponentWeld = new SeqAutoRunComponentWeld();
            //var seqTestRun = new SeqTestRun();
            var seqAlarmMonitor = new SeqAlarmMonitor();
            //var seqAutoRunTDC = new SeqAutoRunTDC(); // 등록
            var seqAutoRunPTOP = new SeqAutoRunPTOP(); // 등록

            _SeqAutoRunPrismaticScanner_Builder = seqAutoRunPrismaticScanner.Builder();
            _SeqAutoRunComponentWeld_Builder = seqAutoRunComponentWeld.Builder();
            _SeqAlarmMonitor_Builder = seqAlarmMonitor.Builder();
            _SeqAutoRunPTOP_Builder = seqAutoRunPTOP.Builder(); // 260605 등록

            register(SequenceIds.SeqAutoRun, _SeqAutoRunPrismaticScanner_Builder);
            //register(SequenceIds.SeqAutoRunComponentWeld, _SeqAutoRunComponentWeld_Builder);
            //register(SequenceIds.SeqTestRun, _SeqTestRun_Builder);
            register(SequenceIds.SeqAlarmMonitor, _SeqAlarmMonitor_Builder);
            register(SequenceIds.SeqStatusMonitor, SeqStatusMonitor.Builder());

            // 260605 추가
            register(SequenceIds.SeqAutoRunPTOP, _SeqAutoRunPTOP_Builder);// 변경 TDC->PTOP

            // SequenceManager.RegisterSequence(AuroraEnv, register);
        }

        public override void RegisterSettings(SettingRegister register) {
            base.RegisterSettings(register);

            register(CommonSettingIds.UploadDatas, new SettingUploadDataListForScanner());
        }

        public override void RegisterServices(IServiceRegistry register)
        {
            //Stream 사용 시에만 등록하도록 하자
            var equipSetting = AuroraEnv.SettingEntry[AuroraSettings.Equipment] as EquipmentInfo;

            if (equipSetting.UseStream) {
                //LBAD
                register.Register(CommonServiceIds.StreamLBADClient, () => new StreamLBADClient(CommonStreamServiceNames.LBADRPC), new StreamClientConfig());

                #region StreamTest
                //PubSub
                register.Register(CommonServiceIds.StreamPubTest, () => new StreamPub(CommonStreamServiceNames.PubSubTest), new StreamPubConfig());
                register.Register(CommonServiceIds.StreamSubTest, () => new StreamSub(CommonStreamServiceNames.PubSubTest), new StreamSubConfig());

                //RPC
                register.Register(CommonServiceIds.StreamServerTest, () => new StreamServer(CommonStreamServiceNames.LBADRPC), new StreamServerConfig());
                register.Register(CommonServiceIds.StreamClientTest, () => new StreamClient(CommonStreamServiceNames.LBADRPC), new StreamClientConfig());

                //MessageBroadcasting
                register.Register(CommonServiceIds.StreamBroadcastPub, () => new StreamBroadcastPub(), new StreamBroadcastPubConfig());
                register.Register(CommonServiceIds.StreamBroadcastSub, () => new StreamBroadcastSub(), new StreamBroadcastSubConfig());
                #endregion
            }
        }

        // Views는 장비별로 별도로 등록하자.
        public override void RegisterViews(IViewManager manager)
        {
            base.RegisterViews(manager);

            // Auto Run
            var MainAutoRun = new MainMenu(CommonViewIds.AutoRun, MenuIcon.GetMenuIcon(eMenuIcon.HOME), PermissionLevel.NONE, false);
            MainAutoRun.AddSubMenu(CommonViewIds.AutoRun, new UCMainAutoRun(new UCMainAutoRunViewModel(AuroraEnv, SequenceIds.SeqAutoRunTDC)));
            manager.RegisterMainMenu(MainAutoRun);

            // Recipe
            MainMenu recipe = new MainMenu(CommonViewIds.Recipe, MenuIcon.GetMenuIcon(eMenuIcon.RECIPE), PermissionLevel.NONE, true);
            recipe.AddSubMenu(CommonViewIds.Recipe, new UCRecipe());
            recipe.AddSubMenu(CommonViewIds.RecipeChangeHistory, new UCRecipeChangeHistory() { DataContext = new UCRecipeChangeHistoryViewModel(AuroraEnv) });
            recipe.AddSubMenu(CommonViewIds.ModelEditor, new UCModel());
            manager.RegisterMainMenu(recipe);

            AuroraEnv.EventObservable.AsObservable(CommonEventIds.EVENT_EQUIPMENT_STATUS_CHANGE)
                .Select(msg => (eEqpStatus)msg.Param)
                .ObserveOnDispatcher()
                .Subscribe(status => {
                    if (status == eEqpStatus.Auto) {
                        AuroraEnv.ViewManager.ChangeMenu(CommonViewIds.AutoRun);
                        AuroraEnv.ViewManager.MainMenuEnable(false, CommonViewIds.Recipe);
                        RecipeHelper.OnActiveReloaded();
                    } else {
                        AuroraEnv.ViewManager.MainMenuAllEnable(true);
                        //RecipeHelper.RollbackRecipe();
                    }
                    //recipe.SubViews.Where(view => view.SubName == CommonViewIds.Recipe).First().View.IsEnabled = !isAuto;
                });

            // Manual
            //var manual = new MainMenu(CommonViewIds.Manual, MenuIcon.GetMenuIcon(eMenuIcon.DEVICE), PermissionLevel.LEVEL4, true); // Level4 가 맞으나, 개발때는 None 으로 뒀다가 완료되면 풀자.
            var manual = new MainMenu(CommonViewIds.Manual, MenuIcon.GetMenuIcon(eMenuIcon.CAMERA), PermissionLevel.NONE, true);
            manual.AddSubMenu(CommonViewIds.ScannerOperation, new UCManualScannerOperation(new UCManualScannerOperationViewModel(AuroraEnv, CommonDeviceIds.Scanner, false)));
            //manual.AddSubMenu(CommonViewIds.OCT, new UCOCTManualMotion(AuroraEnv, CommonDeviceIds.OCT));
            //manual.AddSubMenu(CommonViewIds.LBAD, new UCLBADDevice(AuroraEnv, CommonDeviceIds.LBAD, CommonDeviceIds.IODevice));
            //manual.AddSubMenu(CommonViewIds.ConvEdgeObject, new UCConvEdgeObject(AuroraEnv));
            manual.AddSubMenu(CommonViewIds.ModelFinder, new UCManualModelFinder(new UCManualModelFinderViewModel(AuroraEnv)));

            // Manual - For Test
            //manual.AddSubMenu(CommonViewIds.TestDevice, new UCTestDevice(new UCTestDeviceViewModel(AuroraEnv)));
            //manual.AddSubMenu(CommonViewIds.TestSequence, new UCTestSequence(new UCTestSequenceViewModel(AuroraEnv)));
            manager.RegisterMainMenu(manual);

            //Calibration
            var calibration = new MainMenu(CommonViewIds.Calibration, MenuIcon.GetMenuIcon(eMenuIcon.SCANNER), PermissionLevel.NONE, true);
            calibration.AddSubMenu(CommonViewIds.Scanner, new UCScannerCalibration(new UCScannerCalibrationViewModel(AuroraEnv)));
            //calibration.AddSubMenu(CommonViewIds.Power, new UCPowerCalibration(AuroraEnv));   // 불필요
            //calibration.AddSubMenu(CommonViewIds.PowerCalProfile, new UCPowerProfile(AuroraEnv, CommonDeviceIds.Laser)); // 불필요
            calibration.AddSubMenu(CommonViewIds.PixelResolution, new UCCameraPixelResolution(new UCCameraPixelResolutionViewModel(AuroraEnv)));
            manager.RegisterMainMenu(calibration);

            // Monitoring
            var monitoring = new MainMenu(CommonViewIds.Monitoring, MenuIcon.GetMenuIcon(eMenuIcon.MONITORING), PermissionLevel.NONE, true);
            //manual.AddSubMenu(CommonViewIds.PLCInterfaceView, new UCPLCInterfaceView(AuroraEnv, CommonDeviceIds.PLCDevice));
            monitoring.AddSubMenu(CommonViewIds.PLCBitMonitoring, new UCPLCBit() { DataContext = PLCStatic.GetInstanceBitVM(AuroraEnv, CommonDeviceIds.PLCDevice, ePLCNetType.MXComponent, PLCBase.ePLCDevice.M) });
            monitoring.AddSubMenu(CommonViewIds.PLCWordMonitoring, new UCPLCWord() { DataContext = PLCStatic.GetInstanceWordVM(AuroraEnv, CommonDeviceIds.PLCDevice, ePLCNetType.MXComponent, PLCBase.ePLCDevice.D) });
            monitoring.AddSubMenu(CommonViewIds.IOInterfaceView, new UCIOInterfaceView(AuroraEnv, CommonDeviceIds.IODevice));
            manager.RegisterMainMenu(monitoring);

            // Device
            var device = new MainMenu(CommonViewIds.Device, MenuIcon.GetMenuIcon(eMenuIcon.GEAR), PermissionLevel.LEVEL3, false);
            device.AddSubMenu(CommonViewIds.Device, new DeviceSettingView());        // "CommonViewIds.Setting" 는 EquipDef.cs 에서 정의한 ViewId
            manager.RegisterMainMenu(device);

            //Setting
            var setting = new MainMenu(CommonViewIds.Setting, MenuIcon.GetMenuIcon(eMenuIcon.SETTING), PermissionLevel.LEVEL1, true);
            setting.AddSubMenu(CommonViewIds.Setting, new EquipSettingView());
            setting.AddSubMenu(CommonViewIds.LogSetting, new LogSettingView());
            setting.AddSubMenu(CommonViewIds.AutoBackupView, new AutoBackupView2() { DataContext = new AutoBackupViewModel() });
            manager.RegisterMainMenu(setting);

            // Alarm
            MainMenu alarm = new MainMenu(CommonViewIds.Alarm, MenuIcon.GetMenuIcon(eMenuIcon.BARCODE), PermissionLevel.NONE, true)
                .AddSubMenu(CommonViewIds.History, new AlarmHistoryView())
                .AddSubMenu(CommonViewIds.Description, new AlarmDescView());
            manager.RegisterMainMenu(alarm);

            var equipSetting = AuroraEnv.SettingEntry[AuroraSettings.Equipment] as EquipmentInfo;
            if (equipSetting.UseStream) {
                MainMenu service = new MainMenu(CommonViewIds.StreamDevice, MenuIcon.GetMenuIcon(eMenuIcon.DEVICE))
                    .AddSubMenu(CommonViewIds.StreamDevice, new UCServiceSettingView());
                manager.RegisterMainMenu(service);
            }

            // Vision (미사용)
            //VisionFactory.RegisterViews(manager);
        }
    }
}