using Aurora;
using Aurora.Api;
using Aurora.View;
using AuroraLaserScanner;
using CoreUnit.Scanner.UserControl.ScannerCanvas;
using Microsoft.Office.Interop.Excel;
using MilUI;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Windows.Input;
using VisionCommon;
using VisionUI;
using WeldingCommon.RMS;
using WeldingCommon.Sequences;
using WeldingCommon.Utils;

namespace WeldingCommon.Views
{
    public class UCTestSequenceViewModel : NotifyPropertyChangedBase
    {
        private readonly Logger Log = new Logger("UCTestSequenceViewModel");

        public ICommand CMD_VisibleChanged { get; }
        public ICommand CMD_RunSeqMarkGrid { get; }
        public ICommand CMD_RunSeqScannerCalibration { get; }
        public ICommand CMD_RunSeqReceiveCellInfo { get; }
        public ICommand CMD_RunSeqReportCellResult { get; }
        public ICommand CMD_RunSeqScoutFlyingVision { get; }
        public ICommand CMD_RunSeqScoutNormal { get; }
        public ICommand CMD_RunSeqUploadWeldingList { get; }
        public ICommand CMD_RunSeqTeachingRun { get; }

        private readonly IAuroraEnvironment _Aurora;

        private readonly ISequence _SeqMarkGrid;
        private bool _IsSequenceRunning_SeqMarkGrid;
        public bool IsSequenceRunning_SeqMarkGrid { get => _IsSequenceRunning_SeqMarkGrid; set => SetProperty(ref _IsSequenceRunning_SeqMarkGrid, value); }

        private readonly ISequence _SeqScannerCalibration;
        private bool _IsSequenceRunning_SeqScannerCalibration;
        public bool IsSequenceRunning_SeqScannerCalibration { get => _IsSequenceRunning_SeqScannerCalibration; set => SetProperty(ref _IsSequenceRunning_SeqScannerCalibration, value); }

        private readonly ISequence _SeqReceiveCellInfo;
        private bool _IsSequenceRunning_SeqReceiveCellInfo;
        public bool IsSequenceRunning_SeqReceiveCellInfo { get => _IsSequenceRunning_SeqReceiveCellInfo; set => SetProperty(ref _IsSequenceRunning_SeqReceiveCellInfo, value); }

        private readonly ISequence _SeqReportCellResult;
        private bool _IsSequenceRunning_SeqReportCellResult;
        public bool IsSequenceRunning_SeqReportCellResult { get => _IsSequenceRunning_SeqReportCellResult; set => SetProperty(ref _IsSequenceRunning_SeqReportCellResult, value); }

        private readonly ISequence _SeqScoutFlyingVision;
        private bool _IsSequenceRunning_SeqScoutFlyingVision;
        public bool IsSequenceRunning_SeqScoutFlyingVision { get => _IsSequenceRunning_SeqScoutFlyingVision; set => SetProperty(ref _IsSequenceRunning_SeqScoutFlyingVision, value); }

        private readonly ISequence _SeqScoutNormal;
        private bool _IsSequenceRunning_SeqScoutNormal;
        public bool IsSequenceRunning_SeqScoutNormal { get => _IsSequenceRunning_SeqScoutNormal; set => SetProperty(ref _IsSequenceRunning_SeqScoutNormal, value); }

        private readonly ISequence _SeqUploadWeldingList;
        private bool _IsSequenceRunning_SeqUploadWeldingList;
        public bool IsSequenceRunning_SeqUploadWeldingList { get => _IsSequenceRunning_SeqUploadWeldingList; set => SetProperty(ref _IsSequenceRunning_SeqUploadWeldingList, value); }

        private readonly ISequence _SeqTeachingRun;
        private bool _IsSequenceRunning_SeqTeachingRun;
        public bool IsSequenceRunning_SeqTeachingRun { get => _IsSequenceRunning_SeqTeachingRun; set => SetProperty(ref _IsSequenceRunning_SeqTeachingRun, value); }

        private ScannerCanvasUserCtrl _ScannerCanvasUserCtrl;

        public UCTestSequenceViewModel(IAuroraEnvironment aurora)
        {
            _Aurora = aurora;

            var mainPage = CommonHelper.GetMainPage();
            _ScannerCanvasUserCtrl = mainPage.ScannerCanvasCtrlTeaching;

            _SeqMarkGrid = _Aurora.SequenceEntry[CommonSequenceIds.SeqMarkGrid];
            _SeqScannerCalibration = _Aurora.SequenceEntry[CommonSequenceIds.SeqScannerCalibration];
            _SeqReceiveCellInfo = _Aurora.SequenceEntry[CommonSequenceIds.SeqReceiveCellInfo];
            _SeqReportCellResult = _Aurora.SequenceEntry[CommonSequenceIds.SeqReportCellResult];
            _SeqScoutFlyingVision = _Aurora.SequenceEntry[CommonSequenceIds.SeqScoutFlyingVision];
            _SeqScoutNormal = _Aurora.SequenceEntry[CommonSequenceIds.SeqScoutNormal];
            _SeqUploadWeldingList = _Aurora.SequenceEntry[CommonSequenceIds.SeqUploadWeldingList];
            _SeqTeachingRun = _Aurora.SequenceEntry[CommonSequenceIds.SeqTeachingRun];

            CMD_RunSeqMarkGrid = new DelegateCommand(PerformCmdRunSeqMarkGrid);
            CMD_RunSeqScannerCalibration = new DelegateCommand(PerformCmdRunSeqScannerCalibration);
            CMD_RunSeqReceiveCellInfo = new DelegateCommand(PerformCmdRunSeqReceiveCellInfo);
            CMD_RunSeqReportCellResult = new DelegateCommand(PerformCmdRunSeqReportCellResult);
            CMD_RunSeqScoutFlyingVision = new DelegateCommand(PerformCmdRunSeqScoutFlyingVision);
            CMD_RunSeqScoutNormal = new DelegateCommand(PerformCmdRunSeqScoutNormal);
            CMD_RunSeqUploadWeldingList = new DelegateCommand(PerformCmdRunSeqUploadWeldingList);
            CMD_RunSeqTeachingRun = new DelegateCommand(PerformCmdRunSeqTeachingRun);
        }

        private void PerformCmdRunSeqMarkGrid(object commandParameter)
        {
            switch ((string)commandParameter) {
                case "Run": {
                        if (_SeqMarkGrid.RunState == SequenceRunState.Running) {
                            MessageUtil.ShowWarningToast(string.Format("이미 시퀀스가 Start 상태입니다.", "SeqMarkGrid"), Log);
                            return;
                        }

                        // ScannerCalibrationViewModel 에 설정된 값으로 세팅이 됨
                        var param = new SeqMarkGrid_InitParam() {
                            ColumnCount = 13,
                            RowCount = 13,
                            UnitLength = 10,
                            MarkPower = 10,
                            MarkSpeed = 100,
                            MarkLength = 10,
                        };

                        IsSequenceRunning_SeqMarkGrid = true;
                        _SeqMarkGrid.Start(param, OnComplete_SeqMarkGrid);
                    }
                    break;

                case "Stop": {
                        if (_SeqMarkGrid.RunState == SequenceRunState.Idle) {
                            return;
                        }

                        IsSequenceRunning_SeqMarkGrid = false;
                        _SeqMarkGrid.Stop();
                    }
                    break;

                default:
                    return;
            }
        }

        private void OnComplete_SeqMarkGrid(SequenceActionResult res)
        {
            if (res != null) {
                if (res.Param is SeqMarkGrid_OutParam result && result.Success == true) {
                    IsSequenceRunning_SeqMarkGrid = false;
                    MessageUtil.ShowSuccessToast(string.Format("Success SeqMarkGrid"));
                    return;
                }
            }

            IsSequenceRunning_SeqMarkGrid = false;
            MessageUtil.ShowWarningToast(string.Format("Fail SeqMarkGrid"));
        }

        private void PerformCmdRunSeqScannerCalibration(object commandParameter)
        {
            switch ((string)commandParameter) {
                case "Run": {
                        if (_SeqScannerCalibration.RunState == SequenceRunState.Running) {
                            MessageUtil.ShowWarningToast(string.Format("이미 시퀀스가 Start 상태입니다.", "SeqScannerCalibration"), Log);
                            return;
                        }

                        // ScannerCalibrationViewModel 에 설정된 값으로 세팅이 됨
                        var param = new SeqScannerCalibration_InitParam() {
                            FovInfo = null,
                            IsVisionCalibration = true,
                            ColumnCount = 13,
                            RowCount = 13,
                            UnitLength = 10,
                            TiltingDegree = 0,
                            CheckOffset = 10,
                            MasterPosOffsetX = 0,
                            MasterPosOffsetY = 0,
                        };

                        IsSequenceRunning_SeqScannerCalibration = true;
                        _SeqScannerCalibration.Start(param, OnComplete_SeqScannerCalibration);
                    }
                    break;

                case "Stop": {
                        if (_SeqScannerCalibration.RunState == SequenceRunState.Idle) {
                            return;
                        }

                        IsSequenceRunning_SeqScannerCalibration = false;
                        _SeqScannerCalibration.Stop();
                    }
                    break;

                default:
                    return;
            }
        }

        private void OnComplete_SeqScannerCalibration(SequenceActionResult res)
        {
            if (res != null) {
                if (res.Param is SeqScannerCalibration_OutParam result && result.Success == true) {
                    IsSequenceRunning_SeqScannerCalibration = false;
                    MessageUtil.ShowSuccessToast(string.Format("Success SeqScannerCalibration"));
                    return;
                }
            }

            IsSequenceRunning_SeqScannerCalibration = false;
            MessageUtil.ShowWarningToast(string.Format("Fail SeqScannerCalibration"));
        }

        private void PerformCmdRunSeqReceiveCellInfo(object commandParameter)
        {
            switch ((string)commandParameter) {
                case "Run": {
                        if (_SeqReceiveCellInfo.RunState == SequenceRunState.Running) {
                            MessageUtil.ShowWarningToast(string.Format("이미 시퀀스가 Start 상태입니다.", "SeqReceiveCellInfo"), Log);
                            return;
                        }

                        var param = new SeqReceiveCellInfo_InitParam() {

                        };

                        IsSequenceRunning_SeqReceiveCellInfo = true;
                        _SeqReceiveCellInfo.Start(param, OnComplete_SeqReceiveCellInfo);
                    }
                    break;

                case "Stop": {
                        if (_SeqReceiveCellInfo.RunState == SequenceRunState.Idle) {
                            return;
                        }

                        IsSequenceRunning_SeqReceiveCellInfo = false;
                        _SeqReceiveCellInfo.Stop();
                    }
                    break;

                default:
                    return;
            }
        }

        private void OnComplete_SeqReceiveCellInfo(SequenceActionResult res)
        {
            if (res != null) {
                if (res.Param is SeqReceiveCellInfo_OutParam result && result.Success == true) {
                    IsSequenceRunning_SeqReceiveCellInfo = false;
                    MessageUtil.ShowSuccessToast(string.Format("Success SeqReceiveCellInfo"));
                    return;
                }
            }

            IsSequenceRunning_SeqReceiveCellInfo = false;
            MessageUtil.ShowWarningToast(string.Format("Fail SeqReceiveCellInfo"));
        }

        private void PerformCmdRunSeqReportCellResult(object commandParameter)
        {
            switch ((string)commandParameter) {
                case "Run": {
                        if (_SeqReportCellResult.RunState == SequenceRunState.Running) {
                            MessageUtil.ShowWarningToast(string.Format("이미 시퀀스가 Start 상태입니다.", "SeqReportCellResult"), Log);
                            return;
                        }

                        var param = new SeqReportCellResult_InitParam() {
                            EDC_Interface = new EDC(),

                        };

                        IsSequenceRunning_SeqReportCellResult = true;
                        _SeqReportCellResult.Start(param, OnComplete_SeqReportCellResult);
                    }
                    break;

                case "Stop": {
                        if (_SeqReportCellResult.RunState == SequenceRunState.Idle) {
                            return;
                        }

                        IsSequenceRunning_SeqReportCellResult = false;
                        _SeqReportCellResult.Stop();
                    }
                    break;

                default:
                    return;
            }
        }

        private void OnComplete_SeqReportCellResult(SequenceActionResult res)
        {
            if (res != null) {
                if (res.Param is SeqReportCellResult_OutParam result && result.Success == true) {
                    IsSequenceRunning_SeqReportCellResult = false;
                    MessageUtil.ShowSuccessToast(string.Format("Success SeqReportCellResult"));
                    return;
                }
            }

            IsSequenceRunning_SeqReportCellResult = false;
            MessageUtil.ShowWarningToast(string.Format("Fail SeqReportCellResult"));
        }

        private void PerformCmdRunSeqScoutFlyingVision(object commandParameter)
        {
            switch ((string)commandParameter) {
                case "Run": {
                        if (_SeqScoutFlyingVision.RunState == SequenceRunState.Running) {
                            MessageUtil.ShowWarningToast(string.Format("이미 시퀀스가 Start 상태입니다.", "SeqScoutFlyingVision"), Log);
                            return;
                        }

                        var param = new SeqScoutFlyingVision_InitParam() {
                            IsRealTimeScout = false,
                            ScoutSeqParams = new ScoutSeqParams(VisionRecipeManager.GetFovInfos()[0], eDisplayType.Machine_B),
                            SequenceAutoRunCount = 0,
                            WeldingScannerListNo = eListNo.LIST2,
                        };

                        IsSequenceRunning_SeqScoutFlyingVision = true;
                        _SeqScoutFlyingVision.Start(param, OnComplete_SeqScoutFlyingVision);
                    }
                    break;

                case "Stop": {
                        if (_SeqScoutFlyingVision.RunState == SequenceRunState.Idle) {
                            return;
                        }

                        IsSequenceRunning_SeqScoutFlyingVision = false;
                        _SeqScoutFlyingVision.Stop();
                    }
                    break;

                default:
                    return;
            }
        }

        private void OnComplete_SeqScoutFlyingVision(SequenceActionResult res)
        {
            if (res != null) {
                if (res.Param is SeqScoutFlyingVision_OutParam result && result.Success == true) {
                    IsSequenceRunning_SeqScoutFlyingVision = false;
                    MessageUtil.ShowSuccessToast(string.Format("Success SeqScoutFlyingVision"));
                    return;
                }
            }

            IsSequenceRunning_SeqScoutFlyingVision = false;
            MessageUtil.ShowWarningToast(string.Format("Fail SeqScoutFlyingVision"));
        }

        private void PerformCmdRunSeqScoutNormal(object commandParameter)
        {
            switch ((string)commandParameter) {
                case "Run": {
                        if (_SeqScoutNormal.RunState == SequenceRunState.Running) {
                            MessageUtil.ShowWarningToast(string.Format("이미 시퀀스가 Start 상태입니다.", "SeqScoutNormal"), Log);
                            return;
                        }

                        var param = new SeqScoutNormal_InitParam() {
                            IsRealTimeScout = false,
                            ScoutSeqParams = new ScoutSeqParams(VisionRecipeManager.GetFovInfos()[0], eDisplayType.Machine_B),
                        };

                        IsSequenceRunning_SeqScoutNormal = true;
                        _SeqScoutNormal.Start(param, OnComplete_SeqScoutNormal);
                    }
                    break;

                case "Stop": {
                        if (_SeqScoutNormal.RunState == SequenceRunState.Idle) {
                            return;
                        }

                        IsSequenceRunning_SeqScoutNormal = false;
                        _SeqScoutNormal.Stop();
                    }
                    break;

                default:
                    return;
            }
        }

        private void OnComplete_SeqScoutNormal(SequenceActionResult res)
        {
            if (res != null) {
                if (res.Param is SeqScoutNormal_OutParam result && result.Success == true) {
                    IsSequenceRunning_SeqScoutNormal = false;
                    MessageUtil.ShowSuccessToast(string.Format("Success SeqScoutNormal"));
                    return;
                }
            }

            IsSequenceRunning_SeqScoutNormal = false;
            MessageUtil.ShowWarningToast(string.Format("Fail SeqScoutNormal"));
        }

        private void PerformCmdRunSeqUploadWeldingList(object commandParameter)
        {
            switch ((string)commandParameter) {
                case "Run": {
                        if (_SeqUploadWeldingList.RunState == SequenceRunState.Running) {
                            MessageUtil.ShowWarningToast(string.Format("이미 시퀀스가 Start 상태입니다.", "SeqUploadWeldingList"), Log);
                            return;
                        }

                        var param = new SeqUploadWeldingList_InitParam() {
                            NeedSetLaserTiming = false,
                            IncludeListStartEnd = true,
                            CellMeasureCenterOffsetX = 0,
                            CellMeasureCenterOffsetY = 0,
                            SelectedDrawObjectList = _ScannerCanvasUserCtrl.Model.Layers[0].Objects,
                            WeldingScannerListNo = eListNo.LIST1,
                        };

                        IsSequenceRunning_SeqUploadWeldingList = true;
                        _SeqUploadWeldingList.Start(param, OnComplete_SeqUploadWeldingList);
                    }
                    break;

                case "Stop": {
                        if (_SeqUploadWeldingList.RunState == SequenceRunState.Idle) {
                            return;
                        }

                        IsSequenceRunning_SeqUploadWeldingList = false;
                        _SeqUploadWeldingList.Stop();
                    }
                    break;

                default:
                    return;
            }
        }

        private void OnComplete_SeqUploadWeldingList(SequenceActionResult res)
        {
            if (res != null) {
                if (res.Param is SeqUploadWeldingList_OutParam result && result.Success == true) {
                    IsSequenceRunning_SeqUploadWeldingList = false;
                    MessageUtil.ShowSuccessToast(string.Format("Success SeqUploadWeldingList"));
                    return;
                }
            }

            IsSequenceRunning_SeqUploadWeldingList = false;
            MessageUtil.ShowWarningToast(string.Format("Fail SeqUploadWeldingList"));
        }

        private void PerformCmdRunSeqTeachingRun(object commandParameter)
        {
            switch ((string)commandParameter) {
                case "Run": {
                        if (_SeqTeachingRun.RunState == SequenceRunState.Running) {
                            MessageUtil.ShowWarningToast(string.Format("이미 시퀀스가 Start 상태입니다.", "SeqTeachingRun"), Log);
                            return;
                        }

                        var param = new SeqTeachingRun_InitParam() {
                            UseStream = false,
                            IsObjectSelectAll = true,
                            UseBlow = false,
                            IntervalTimeBlowOn = 10,
                            IntervalTimeBlowOff = 10,
                            NeedSetLaserTiming = false,
                        };

                        IsSequenceRunning_SeqTeachingRun = true;
                        _SeqTeachingRun.Start(param, OnComplete_SeqTeachingRun);
                    }
                    break;

                case "Stop": {
                        if (_SeqTeachingRun.RunState == SequenceRunState.Idle) {
                            return;
                        }

                        IsSequenceRunning_SeqTeachingRun = false;
                        _SeqTeachingRun.Stop();
                    }
                    break;

                default:
                    return;
            }
        }

        private void OnComplete_SeqTeachingRun(SequenceActionResult res)
        {
            if (res != null) {
                if (res.Param is SeqTeachingRun_OutParam result && result.Success == true) {
                    IsSequenceRunning_SeqTeachingRun = false;
                    MessageUtil.ShowSuccessToast(string.Format("Success SeqTeachingRun"));
                    return;
                }
            }

            IsSequenceRunning_SeqTeachingRun = false;
            MessageUtil.ShowWarningToast(string.Format("Fail SeqTeachingRun"));
        }

    }
}