using CommunityToolkit.Mvvm.ComponentModel;
using CommunityToolkit.Mvvm.Input;
using HMI.Core.Util;
using HMI.UI;
using HMI.UI.Util;
using log4net;
using Microsoft.Win32;
using NationalInstruments.TestStand.Interop.API;
using Plugin.SeqEditor.Constant;
using Plugin.SeqEditor.Entity;
using Plugin.SeqEditor.Util;
using System.Collections.ObjectModel;
using System.IO;

namespace Plugin.SeqEditor.ViewModel
{

    public partial class SeqEditorViewModel : ObservableObject
    {
        private ObservableCollection<StepUI> setupSteps = new ObservableCollection<StepUI>();

        private ObservableCollection<StepUI> mainSteps = new ObservableCollection<StepUI>();

        private ObservableCollection<StepUI> cleanupSteps = new ObservableCollection<StepUI>();

        [ObservableProperty]
        private ObservableCollection<StepUI> allSteps = new ObservableCollection<StepUI>();

        [ObservableProperty]
        private ObservableCollection<SeqUI> sequences = new ObservableCollection<SeqUI>();

        [ObservableProperty]
        private SeqUI currentSeqUI;

        [ObservableProperty]
        private StepUI currentStepUI;

        [ObservableProperty]
        private string currentFileName;

        [ObservableProperty]
        private string currentSeqTitle = LangUtil.Get("se.steps");

        [ObservableProperty]
        private string targetType = null;


        private string currentFilePath;
        private Engine engine;
        private SequenceFile sequenceFile;
        private bool isLoaded;
        private ILog log;
        public SeqEditor control { get; private set; }

        public List<ItemData> Types = FilterTypeData.ItemSource;

        private HashSet<string> edits = new HashSet<string> {
            StepTypeStr.PassFailTest,
            StepTypeStr.NumericLimitTest,
            StepTypeStr.NI_MultipleNumericLimitTest,
            StepTypeStr.StringValueTest,
            StepTypeStr.Action,
            StepTypeStr.NI_Wait,
            StepTypeStr.SequenceCall,
        };

        public SeqEditorViewModel(SeqEditor control, ILog log)
        {
            this.log = log;
            this.control = control;
            engine = new Engine();
            engine.LoadTypePaletteFilesEx();
        }

        ~SeqEditorViewModel()
        {
            if (engine != null)
            {
                if (sequenceFile != null)
                {
                    engine.ReleaseSequenceFileEx(sequenceFile);
                }
                engine.ShutDown(true);
                // 不加延时会弹窗md
                System.Threading.Thread.Sleep(2500);
            }
        }

        private ObservableCollection<StepUI> LoadSteps(Sequence seq, string group = null)
        {
            //setupSteps.Clear();
            //var steps = new ObservableCollection<StepUI>();
            //int num = seq.GetNumSteps(StepGroups.StepGroup_Setup);
            //for (int i = 0; i < num; i++)
            //{
            //    Step step = seq.GetStep(i, StepGroups.StepGroup_Setup);
            //    var ui = new StepUI(step);
            //    if (edits.Contains(ui.Type))
            //    {
            //        setupSteps.Add(ui);
            //        steps.Add(ui);
            //    }
            //}
            ////SetupSteps = steps;
            ////steps = new ObservableCollection<StepUI>();
            //mainSteps.Clear();
            //num = seq.GetNumSteps(StepGroups.StepGroup_Main);
            //for (int i = 0; i < num; i++)
            //{
            //    Step step = seq.GetStep(i, StepGroups.StepGroup_Main);
            //    var ui = new StepUI(step);
            //    if (edits.Contains(ui.Type))
            //    {
            //        mainSteps.Add(ui);
            //        steps.Add(ui);
            //    }
            //}
            ////MainSteps = steps;
            ////steps = new ObservableCollection<StepUI>();
            //cleanupSteps.Clear();
            //num = seq.GetNumSteps(StepGroups.StepGroup_Cleanup);
            //for (int i = 0; i < num; i++)
            //{
            //    Step step = seq.GetStep(i, StepGroups.StepGroup_Cleanup);
            //    var ui = new StepUI(step);
            //    if (edits.Contains(ui.Type))
            //    {
            //        cleanupSteps.Add(ui);
            //        steps.Add(ui);
            //    }
            //}
            //AllSteps = steps;
            //CurrentStepUI = null;

            var steps = new ObservableCollection<StepUI>();

            int num = seq.GetNumSteps(StepGroups.StepGroup_Setup);
            for (int i = 0; i < num; i++)
            {
                Step step = seq.GetStep(i, StepGroups.StepGroup_Setup);
                var ui = Convert2StepUI(step, group);
                if (ui != null)
                {
                    steps.Add(ui);
                }
            }

            num = seq.GetNumSteps(StepGroups.StepGroup_Main);
            for (int i = 0; i < num; i++)
            {
                Step step = seq.GetStep(i, StepGroups.StepGroup_Main);
                var ui = Convert2StepUI(step, group);
                if (ui != null)
                {
                    steps.Add(ui);
                }
            }

            num = seq.GetNumSteps(StepGroups.StepGroup_Cleanup);
            for (int i = 0; i < num; i++)
            {
                Step step = seq.GetStep(i, StepGroups.StepGroup_Cleanup);
                var ui = Convert2StepUI(step, group);
                if (ui != null)
                {
                    steps.Add(ui);
                }
            }
            return steps;
        }

        private StepUI Convert2StepUI(Step step, string group)
        {
            var ui = new StepUI(step);
            if (!edits.Contains(ui.Type))
            {
                return null;
            }

            if (string.IsNullOrEmpty(group))
            {
                if (ui.StepGroup == StepGroups.StepGroup_Setup)
                {
                    group = "Setup";
                }
                else if (ui.StepGroup == StepGroups.StepGroup_Main)
                {
                    group = "Main";
                }
                else if (ui.StepGroup == StepGroups.StepGroup_Cleanup)
                {
                    group = "Cleanup";
                }
                else
                {
                    group = "Unkown";
                }
            }
            ui.Group = group;

            if (ui.Type == StepTypeStr.SequenceCall)
            {
                var po = step.Module.AsPropertyObject();
                bool useCurFile = po.GetValBoolean("UseCurFile", 0);
                if (useCurFile)
                {
                    string seqName = po.GetValString("SeqName", 0);
                    Sequence sequence = sequenceFile.GetSequenceByName(seqName);
                    if (sequence == null)
                    {
                        return ui;
                    }
                    ui.Children = LoadSteps(sequence, group);
                }
            }
            return ui;
        }


        [RelayCommand]
        private void Loaded()
        {
            if (!isLoaded)
            {
            }
        }

        [RelayCommand]
        private void OpenSeqFile()
        {
            OpenFileDialog ofd = new OpenFileDialog()
            {
                Filter = $"{LangUtil.Get("se.seq")}|*.seq;"
            };
            if (ofd.ShowDialog() == true)
            {
                control.BackgroundAction(() =>
                {
                    try
                    {
                        var start = DateTime.Now;
                        currentFilePath = ofd.FileName;
                        CurrentFileName = $"{LangUtil.Get("se.currentFile")}{Path.GetFileName(currentFilePath)}";
                        if (sequenceFile != null)
                        {
                            engine.ReleaseSequenceFileEx(sequenceFile);
                        }
                        sequenceFile = engine.GetSequenceFileEx(currentFilePath);
                        Sequence main = sequenceFile.GetSequenceByName("MainSequence");
                        CurrentSeqUI = new SeqUI(main);

                        //var seqs = new ObservableCollection<SeqUI>();
                        //for (int i = 0; i < sequenceFile.NumSequences; i++)
                        //{
                        //    var tsSequence = sequenceFile.GetSequence(i);
                        //    seqs.Add(new SeqUI(tsSequence));
                        //}
                        //Sequences = seqs;

                        if (Sequences != null && Sequences.Count > 0)
                        {
                            CurrentSeqUI = Sequences[0];
                        }
                        log.Info($"Open File [{currentFilePath}] In {(DateTime.Now - start).TotalMilliseconds}ms");
                    }
                    catch (Exception ex)
                    {

                    }
                }, LangUtil.Get("se.seqIsLoading"));
            }
        }

        [RelayCommand]
        private void SaveSeqFile()
        {
            sequenceFile?.Save(currentFilePath);
        }

        [RelayCommand]
        private void Refresh()
        {
            if (CurrentSeqUI == null) return;
            if (string.IsNullOrEmpty(TargetType))
            {
                edits = new HashSet<string> {
                    StepTypeStr.PassFailTest,
                    StepTypeStr.NumericLimitTest,
                    StepTypeStr.NI_MultipleNumericLimitTest,
                    StepTypeStr.StringValueTest,
                    StepTypeStr.Action,
                    StepTypeStr.NI_Wait,
                    StepTypeStr.SequenceCall,
                };
            }
            else
            {
                edits = new HashSet<string>(TargetType.Split(','))
                {
                    StepTypeStr.SequenceCall
                };
            }
            AllSteps = LoadSteps(CurrentSeqUI.sequence);
        }

        [RelayCommand]
        private void CloseSeqFile()
        {
            //AllSteps = new ObservableCollection<StepUI>();
            if (engine != null && sequenceFile != null)
            {
                engine.ReleaseSequenceFileEx(sequenceFile);
                sequenceFile = null;
            }
            setupSteps.Clear();
            mainSteps.Clear();
            cleanupSteps.Clear();
            AllSteps = new();
            Sequences.Clear();
            currentFilePath = string.Empty;
            CurrentFileName = string.Empty;
            CurrentSeqUI = null;
            CurrentStepUI = null;
            CurrentSeqTitle = LangUtil.Get("se.steps");
        }

        [RelayCommand]
        private void AddStep(string type)
        {
            try
            {
                var group = CurrentStepUI.step.StepGroup;

                ObservableCollection<StepUI> source;
                if (group == StepGroups.StepGroup_Setup)
                {
                    source = setupSteps;
                }
                else if (group == StepGroups.StepGroup_Main)
                {
                    source = mainSteps;
                }
                else
                {
                    source = cleanupSteps;
                }
                int index = source.IndexOf(CurrentStepUI);
                if (index < 0)
                {
                    return;
                }
                Step newStep;
                switch (type)
                {
                    case "Tests.PassFail":
                        newStep = engine.NewStep(AdapterKeyNames.FlexLVAdapterKeyName, StepTypeStr.PassFailTest);
                        newStep.Name = DefaultStepName.PassFailTest;
                        var p = newStep.AsPropertyObject();
                        string name = p.Name;
                        var ps = p.GetSubProperties("", 0);
                        foreach (var pp in ps)
                        {
                            string sname = pp.Name;
                        }

                        break;
                    case "Tests.NumericLimitTest":
                        newStep = engine.NewStep(AdapterKeyNames.FlexLVAdapterKeyName, StepTypeStr.NumericLimitTest);
                        newStep.Name = DefaultStepName.NumericLimitTest;
                        break;
                    case "Tests.NI_MultipleNumericLimitTest":
                        newStep = engine.NewStep(AdapterKeyNames.FlexLVAdapterKeyName, StepTypeStr.NI_MultipleNumericLimitTest);
                        newStep.Name = DefaultStepName.NI_MultipleNumericLimitTest;
                        break;
                    case "Tests.StringValueTest":
                        newStep = engine.NewStep(AdapterKeyNames.FlexLVAdapterKeyName, StepTypeStr.StringValueTest);
                        newStep.Name = DefaultStepName.StringValueTest;
                        break;
                    case "Actions.LabVIEW":
                        newStep = engine.NewStep(AdapterKeyNames.FlexLVAdapterKeyName, StepTypeStr.Action);
                        newStep.Name = DefaultStepName.Action;
                        break;
                    case "Actions.LabWindows/CVI":
                        newStep = engine.NewStep(AdapterKeyNames.FlexCVIAdapterKeyName, StepTypeStr.Action);
                        newStep.Name = DefaultStepName.Action;
                        break;
                    case "Actions.C/C++ DLL":
                        newStep = engine.NewStep(AdapterKeyNames.FlexCAdapterKeyName, StepTypeStr.Action);
                        newStep.Name = DefaultStepName.Action;
                        break;
                    case "Actions..NET":
                        newStep = engine.NewStep(AdapterKeyNames.DotNetAdapterKeyname, StepTypeStr.Action);
                        newStep.Name = DefaultStepName.Action;
                        break;
                    case "Actions.ActiveX/COM":
                        newStep = engine.NewStep(AdapterKeyNames.AutomationAdapterKeyName, StepTypeStr.Action);
                        newStep.Name = DefaultStepName.Action;
                        break;
                    case "Actions.None":
                        newStep = engine.NewStep(AdapterKeyNames.NoneAdapterKeyName, StepTypeStr.Action);
                        newStep.Name = DefaultStepName.Action;
                        break;
                    case "Actions.LabVIEW NXG":
                        newStep = engine.NewStep(AdapterKeyNames.LabVIEWNXGAdapterKeyName, StepTypeStr.Action);
                        newStep.Name = DefaultStepName.Action;
                        break;
                    case "Actions.Python":
                        newStep = engine.NewStep(AdapterKeyNames.PythonAdapterKeyName, StepTypeStr.Action);
                        newStep.Name = DefaultStepName.Action;
                        break;

                    default:
                        return;
                }
                CurrentSeqUI.sequence.InsertStep(newStep, index + 1, group);
                AllSteps = LoadSteps(CurrentSeqUI.sequence);
            }
            catch (Exception ex)
            {
                log.Error("Insert Step Error.", ex);
                MsgBoxHelper2.Error(ex.Message);
            }
        }

        [ObservableProperty]
        private TreeItemData treeItemData;

        partial void OnTreeItemDataChanged(TreeItemData data)
        {
            CurrentStepUI = data?.Data as StepUI;
        }

        partial void OnCurrentStepUIChanged(StepUI stepUI)
        {
            var panel = StepUI2EPO.Convert2EditPanel(stepUI);
            control.editPanelContainer.Child = panel;
            if (stepUI != null)
            {

                //window.commonP.RefreshStep(stepUI);
            }
        }

        partial void OnCurrentSeqUIChanged(SeqUI seqUI)
        {
            if (seqUI != null)
            {
                CurrentStepUI = null;
                AllSteps = LoadSteps(seqUI.sequence);
            }
            CurrentSeqTitle = $"{seqUI?.Name} {LangUtil.Get("se.steps")}";
        }
    }
}