using Aurora.Api;
using Aurora.View;
using System;
using System.Collections.Generic;
using System.Collections.ObjectModel;
using System.Linq;
using System.Text;
using System.Threading;
using System.Threading.Tasks;
using System.Windows.Input;
using VisionCommon;
using VisionSequence.Pattern;

namespace MilUI {
    class VisionImageTestViewModel {
        public ICommand CMD_Start { get; }
        public ICommand CMD_Clear { get; }
        public ICommand CMD_GetFolder { get; }
        public ICommand CMD_GetImages { get; }

        private Logger Log = new Logger("VisionImageTestViewModel");
        private SubSysInfo _SubSysInfo;
        private FovInfo _FovInfo;
        private eVisionTestType _VisionTestType;
        private PatternInfo _PatternInfo;
        private bool TestRunning = false;

        public Dictionary<eFovId, ObservableCollection<SelectedImagePath>> TotalImagePaths = new Dictionary<eFovId, ObservableCollection<SelectedImagePath>>();
        public VisionImageTestSettingViewModel _VisionImageTestSettingViewModel;
        public VisionImageTestLogViewModel _VisionImageTestLogViewModel;

        public VisionImageTestViewModel(FovInfo fovInfo, eVisionTestType visionTestType, PatternInfo patternInfo = null) {
            _FovInfo = fovInfo;
            _SubSysInfo = _FovInfo.ToSubSysInfo();
            _VisionTestType = visionTestType;
            if (patternInfo != null) {
                _PatternInfo = patternInfo;
            }
            foreach(var _FovInfo in VisionRecipeManager.GetFovInfos(_SubSysInfo)) {
                TotalImagePaths.Add(_FovInfo.FovId, new ObservableCollection<SelectedImagePath>());
            }

            CMD_Start = new DelegateCommand(Start);
            CMD_Clear = new DelegateCommand(ClearPaths);
            CMD_GetFolder = new DelegateCommand(GetFolder);
            CMD_GetImages = new DelegateCommand(GetImages);
        }

        public void SetVisionImageTestSettingViewModel(VisionImageTestSettingViewModel viewModel) {
            _VisionImageTestSettingViewModel = viewModel;
        }

        public void SetVisionImageTestLogViewModel(VisionImageTestLogViewModel viewModel) {
            _VisionImageTestLogViewModel = viewModel;
        }

        private async void Start(object obj) {
            if (TestRunning) {
                MessageUtil.ShowErrorToast("Test is Running");
                return;
            }
            TestRunning = true;
            List<string> paths = new List<string>();
            foreach (var imagePath in TotalImagePaths[_FovInfo.FovId]) {
                paths.Add(imagePath.ImagePath);
            }
            var visionImageTester = VisionImageTesterManagerBase.GetVisionImageTester(_FovInfo);
            visionImageTester.SetTestImagePath(paths);
            switch (_VisionTestType) {
                case eVisionTestType.Pattern:
                    _VisionImageTestLogViewModel.ClearPatternResults();
                    await Task.Run(() => {
                        foreach (var imagePath in TotalImagePaths[_FovInfo.FovId]) {
                            StartTestGrabFindSeq();
                        }
                    });
                    break;
                case eVisionTestType.Align:
                case eVisionTestType.Calibration:
                    break;
            }
        }

        private void ClearPaths(object obj) {
            _VisionImageTestSettingViewModel.Clear();
        }

        private void GetFolder(object obj) {
            _VisionImageTestSettingViewModel.GetFolder();
        }

        private void GetImages(object obj) {
            _VisionImageTestSettingViewModel.GetImages();
        }

        private void StartTestGrabFindSeq() {
            var manualFixtureProcSeq = ManualGrabFindSeqManager.GetSeq(_FovInfo);

            if (manualFixtureProcSeq == null) {
                Log.FuncE("manualFixtureProcSeq is null.");
            }
            else {
                while (manualFixtureProcSeq.RunState == SequenceRunState.Running || manualFixtureProcSeq.RunState == SequenceRunState.Finish) {
                    Thread.Sleep(10);
                }
                if (manualFixtureProcSeq.RunState == SequenceRunState.Idle) {
                    GrabFindSeqUtil.Clear(_FovInfo.ToSubSysInfo());

                    var fixtureSeqParam = new GrabFindProcSeqParams(
                        _FovInfo, _PatternInfo, eDisplayType.ImageTest, seqMode: eSeqMode.VisionImageTest);
                    manualFixtureProcSeq.Start(fixtureSeqParam, OnCompletedGrabFindSeq);
                }
                else {
                    Log.FuncE("manualFixtureProcSeq is not idle.");
                }
            }
        }

        private void OnCompletedGrabFindSeq(SequenceActionResult seqResult) {
            var patternResult = seqResult.Param as PatternResult;
            if (patternResult != null) {
                _VisionImageTestLogViewModel.AddPatternResult(patternResult);
                if(TotalImagePaths[_FovInfo.FovId].Count() == _VisionImageTestLogViewModel.PatternTestResults.Count()) {
                    TestRunning = false;
                }
            }
        }
    }
}