using AddInPlugin;
using AddInPlugin.Setting;
using CommunityToolkit.Mvvm.ComponentModel;
using Microsoft.Win32;
using OpenTap;
using OpenTap.Addin;
using OpenTap.Addin.Listener;
using OpenTap.Addin.Util;
using OpenTap.Plugins.BasicSteps;
using SeqEditor.Util;
using System.Collections.ObjectModel;
using System.Windows;
using System.Windows.Controls;

namespace OpenTapEditor;
/// <summary>
/// Interaction logic for SequencePanel.xaml
/// </summary>
[ObservableObject]
public partial class ExecutionPanel : UserControl, ITabItem, IStepRunStatus
{
    private TestPlan Plan;
    private TestPlanRun PlanRun;
    private TapThread testPlanThread;
    private string startedSeqName;

    [ObservableProperty]
    private ITestStep selectedTestStep;

    [ObservableProperty]
    private bool isRunning = false;

    [ObservableProperty]
    private bool hasChanged = false;

    public string TabName
    {
        get
        {
            return $"Execution-{Plan?.Name}";
        }
        set
        {
        }
    }

    [ObservableProperty]
    private RuningMode runingMode = RuningMode.Stop;

    private ManualResetEvent SingleStepHandle = new ManualResetEvent(true);

    public event EventHandler RunningFinished;

    public ExecutionPanel(TestPlan plan, string seqName)
    {
        this.Plan = plan;
        this.startedSeqName = seqName;

        InitializeComponent();
        treeView.Plan = plan;
    }

    private void VariableControl_SequenceChanged(object? sender, EventArgs e)
    {
        HasChanged = true;
    }

    private void ChildTestSteps_ChildStepsChanged(TestStepList senderList, TestStepList.ChildStepsChangedAction Action, ITestStep Object, int Index)
    {
        HasChanged = true;
    }

    private void ChildTestSteps_CollectionChanged(object? sender, System.Collections.Specialized.NotifyCollectionChangedEventArgs e)
    {
        HasChanged = true;
    }

    private void Button_Click(object sender, RoutedEventArgs e)
    {
        var btn = (Button)sender;
        switch (btn.Tag)
        {
            case "运行":
                RunBtn();
                break;
            case "调试":
                RunTestPlan(RuningMode.RunningInDebugMode);
                break;
            case "单步运行":
                StepRuning();
                break;
            case "停止":
                StopRunTestPlan();
                break;
            default:
                break;
        }
    }

    private void RunBtn()
    {
        if (IsRunning)
        {
            if (RuningMode == RuningMode.RunningInStepMode)
            {
                RuningMode = RuningMode.Running;
                SingleStepHandle.Set();
                return;
            }

            if (RuningMode == RuningMode.RunningInDebugModeButStep)
            {
                RuningMode = RuningMode.RunningInDebugMode;
                SingleStepHandle.Set();
                return;
            }

            if (RuningMode == RuningMode.RunningInDebugMode)
            {
                SingleStepHandle.Set();
                return;
            }
        }
        else
        {
            RunTestPlan(RuningMode.Running);
        }
    }

    public void RunTestPlan(RuningMode mode)
    {
        try
        {
            /// 保存一下StationGlobals变量
            try
            {
                StationGlobalsManager.WriteToLocal(UIStationGlobalsManager.Instance.Datasource);
            }
            catch (Exception ex)
            {

            }
            IsRunning = true;
            RuningMode = mode;
            treeView.ComplatedIds.Clear();
            treeView.UpdateStepStatus();
            RunVars = null;
            RunVarContext = null;

            handledPlan.Clear();
            handledPlan.Add(Plan);
            Plan.BreakOffered += Plan_BreakOffered;
            settingView.CanEdit = false;
            runVariableControl.Visibility = Visibility.Visible;
            var uiListener = new UIListener(SeqEditorUI.Instance.logControl, this);

            testPlanThread = TapThread.Start(() =>
            {
                try
                {
                    var s = ResultSettings.Current;
                    ResultSettings.Current.Add(uiListener);
                    if (StationSettings.Current.ReportType == ReportType.TXT)
                    {
                        ResultSettings.Current.Add(new TxtReportListener("Report"));
                    }
                    else
                    {
                        ResultSettings.Current.Add(new HtmlReportListener("Report"));
                    }
                    var res = ResultSettings.Current;
                    var run = Plan.Execute(startedSeqName, res, null, null, null);
                }
                catch (Exception ex)
                {
                    SeqEditorUI.Log.Error("Start TestPlan Error. {0}", ex);
                }
                finally
                {
                    ResultSettings.Current.Remove(uiListener);
                    RunVarContext?.Release();
                    Dispatcher.BeginInvoke(() =>
                    {
                        RunningFinished?.Invoke(this, new EventArgs());
                        RuningMode = RuningMode.Stop;
                        Plan.BreakOffered -= Plan_BreakOffered;
                        treeView.DebugStepId = Guid.Empty;
                        treeView.RunningStepId = Guid.Empty;
                        settingView.CanEdit = true;
                        IsRunning = false;
                        foreach (var handled in handledPlan)
                        {
                            handled.BreakOffered -= Plan_BreakOffered;
                        }
                        handledPlan.Clear();
                    });
                }
            }, "UI_Start");
        }
        catch (Exception ex)
        {
            SeqEditorUI.Log.Error("Run TestPlan Error. {0}", ex);
        }
    }

    [ObservableProperty]
    private RunningVarContext runVarContext;

    [ObservableProperty]
    private ObservableCollection<RunningVar> runVars;

    private readonly List<TestPlan> handledPlan = new List<TestPlan>();


    private string currentSeqId = null;

    private void Plan_BreakOffered(object? sender, BreakOfferedEventArgs e)
    {
        try
        {
            var stepRun = e.TestStepRun;
            var planRun = stepRun.testPlanRun;
            var step = stepRun.CurrentStep;
            var plan = step.Root;
            var seqId = $"{plan.VisualPath}_{planRun.RunningSeqName}";
            TestStepList list = plan.GetStepsByName(planRun.RunningSeqName);

            Dispatcher.BeginInvoke(() =>
            {
                treeView.DebugStepId = e.TestStepRun.TestStepId;
                if (RunVarContext == null)
                {
                    RunVarContext = new RunningVarContext()
                    {
                        PlanRun = planRun
                    };
                    RunVarContext.Children = RunningVar.FromTest(RunVarContext, null, false, new ObservableCollection<TestVariable>() {
                    new TestVariable(){
                        Name = "Locals",
                        Type = TestVariableType.Container,
                        Children = list.Variables
                    },
                    new TestVariable(){
                        Name = "Parameters",
                        Type = TestVariableType.Container,
                        Children = list.Parameters
                    },
                    new TestVariable(){
                        Name = "FileGlobals",
                        Type = TestVariableType.Container,
                        Children = plan.Variables
                    },
                    new TestVariable(){
                        Name = "StationGlobals",
                        Type = TestVariableType.Container,
                        Children = UIStationGlobalsManager.Instance.Datasource,
                    }});
                    RunVars = RunVarContext.Children;
                }

                RunVarContext.Children[0].ContextName = list.SequenceName;
                RunVarContext.Children[1].ContextName = list.SequenceName;
                RunVarContext.Children[2].ContextName = plan.VisualPath;

                if (currentSeqId != seqId)
                {
                    RunVarContext.RefreshPlan(planRun, plan, list);
                    treeView.Datasource = list;
                    currentSeqId = seqId;
                }
            }).Wait();

            if (step is SequenceCallStep scs)
            {
                //if (lastChildPlan != null)
                //{
                //    lastChildPlan.BreakOffered -= Plan_BreakOffered;
                //}
                if (!handledPlan.Contains(scs.runningPlan))
                {
                    scs.runningPlan.BreakOffered += Plan_BreakOffered;
                    handledPlan.Add(scs.runningPlan);
                }
            }

            if (RuningMode == RuningMode.RunningInStepMode || RuningMode == RuningMode.RunningInDebugModeButStep)
            {
                SingleStepHandle.Reset();
                WaitHandle.WaitAny(new[] { SingleStepHandle, testPlanThread.AbortToken.WaitHandle });
            }
            else if (RuningMode == RuningMode.RunningInDebugMode)
            {
                if (treeView.NeedBreak(e.TestStepRun.TestStepId))
                {
                    SingleStepHandle.Reset();
                    WaitHandle.WaitAny(new[] { SingleStepHandle, testPlanThread.AbortToken.WaitHandle });
                }
            }
        }
        catch (Exception ex)
        {
            SeqEditorUI.Log.Error($"Plan_BreakOffered Error: {ex}");
        }
    }

    private void StepRuning()
    {
        if (IsRunning && RuningMode != RuningMode.Running)
        {
            if (RuningMode == RuningMode.RunningInDebugMode)
            {
                RuningMode = RuningMode.RunningInDebugModeButStep;
            }
            SingleStepHandle.Set();
        }
        else
        {
            RunTestPlan(RuningMode.RunningInStepMode);
        }
    }

    public void StopRunTestPlan()
    {
        testPlanThread?.Abort();
    }

    public bool TrySaveTestStep(Func<string, bool> check)
    {
        if (!string.IsNullOrEmpty(Plan.Path))
        {
            Plan.Save(Plan.Path);
            HasChanged = false;
            OnPropertyChanged(nameof(TabName));
            return true;
        }
        return TrySaveAs(check);
    }

    public bool TrySaveAs(Func<string, bool> check)
    {
        SaveFileDialog sfd = new SaveFileDialog()
        {
            Filter = "Test Plan|*.TapPlan",
            DefaultExt = ".TapPlan"
        };
        if (sfd.ShowDialog() == true)
        {
            if (check.Invoke(sfd.FileName))
            {
                Plan.Save(sfd.FileName);
                HasChanged = false;
                OnPropertyChanged(nameof(TabName));
                return true;
            }
        }
        return false;
    }

    private void treeView_SelectedItemChanged(object sender, RoutedPropertyChangedEventArgs<object> e)
    {
        if (e.NewValue != null)
        {
            settingView.UpdateSource((ITestStep)e.NewValue);
            SelectedTestStep = (ITestStep)e.NewValue;
        }
    }

    private void variableControl_SelectedSequenceChanged(object sender, TestStepList e)
    {
        treeView.Datasource = e;
        settingView.Seq = e;
    }

    public void ComplatedStepId(Guid id)
    {
        Dispatcher.BeginInvoke(() =>
        {
            treeView.ComplatedIds[id] = true;
            treeView.UpdateStepStatus();
        });
    }

    public void CurrentStepId(Guid id)
    {
        Dispatcher.BeginInvoke(() =>
        {
            treeView.ComplatedIds.TryRemove(id, out _);
            treeView.UpdateStepStatus();
            treeView.RunningStepId = id;
        });
    }

    public void Close()
    {
        RunVarContext = null;
        RunVars = null;
        settingView = null;
        Plan = null;
        PlanRun = null;
        treeView.Unload();
    }
}