path: root/Software/Visual_Studio/FSE/Modules/Tango.FSE.Stubs/ViewModels/TestDesignerViewVM.cs

using Google.Protobuf;
using System;
using System.Collections.Generic;
using System.Collections.ObjectModel;
using System.Linq;
using System.Reflection;
using System.Text;
using System.Threading.Tasks;
using System.Windows.Input;
using System.Windows.Threading;
using Tango.Core;
using Tango.Core.Commands;
using Tango.Core.ExtensionMethods;
using Tango.FSE.Common;
using Tango.FSE.Stubs.Dialogs;
using Tango.Integration.Operation;
using Tango.Scripting.Basic;
using Tango.Scripting.Editors;
using Tango.SharedUI.Components;
using Tango.SharedUI.Helpers;
using Tango.Transport;

namespace Tango.FSE.Stubs.ViewModels
{
    public class TestDesignerViewVM : FSEViewModel, ITestLogger
    {
        public enum ToolWindows
        {
            Output,
            Errors,
            Results
        }

        private DispatcherTimer _compileTimer;

        #region Properties

        private ToolWindows _selectedToolWindow;
        public ToolWindows SelectedToolWindow
        {
            get { return _selectedToolWindow; }
            set { _selectedToolWindow = value; RaisePropertyChangedAuto(); }
        }

        private TestProject _project;
        public TestProject Project
        {
            get { return _project; }
            set { _project = value; RaisePropertyChangedAuto(); OnProjectChanged(); }
        }

        private ProjectRunner _projectRunner;
        public ProjectRunner ProjectRunner
        {
            get { return _projectRunner; }
            set { _projectRunner = value; RaisePropertyChangedAuto(); }
        }

        private List<CompilationError> _compilationErrors;
        public List<CompilationError> CompilationErrors
        {
            get { return _compilationErrors; }
            set { _compilationErrors = value; RaisePropertyChangedAuto(); }
        }

        private List<Result> _results;
        public List<Result> Results
        {
            get { return _results; }
            set { _results = value; RaisePropertyChangedAuto(); }
        }

        public ObservableCollection<Script> OpenScripts { get; set; }

        private Script _selectedScript;
        public Script SelectedScript
        {
            get { return _selectedScript; }
            set { _selectedScript = value; RaisePropertyChangedAuto(); }
        }

        public TextController Logger { get; set; }

        private String _status;
        public String Status
        {
            get { return _status; }
            set { _status = value; RaisePropertyChangedAuto(); }
        }

        private TangoProgress<int> _cacheProgress;
        public TangoProgress<int> SymbolsLoadingProgress
        {
            get { return _cacheProgress; }
            set { _cacheProgress = value; RaisePropertyChangedAuto(); }
        }

        private bool _isLoadingSymbols;
        public bool IsLoadingSymbols
        {
            get { return _isLoadingSymbols; }
            set { _isLoadingSymbols = value; RaisePropertyChangedAuto(); }
        }

        private ObservableCollection<Assembly> _loadedAssemblies;
        public ObservableCollection<Assembly> LoadedAssemblies
        {
            get { return _loadedAssemblies; }
            set { _loadedAssemblies = value; RaisePropertyChangedAuto(); }
        }

        #endregion

        #region Commands

        public RelayCommand<Script> OpenScriptCommand { get; set; }
        public RelayCommand<Script> CloseScriptCommand { get; set; }
        public RelayCommand RunProjectCommand { get; set; }
        public RelayCommand StopProjectCommand { get; set; }
        public RelayCommand CompileProjectCommand { get; set; }
        public RelayCommand AddReferenceAssemblyCommand { get; set; }
        public RelayCommand<ReferenceAssembly> RemoveReferenceAssemblyCommand { get; set; }

        #endregion

        #region Constructors

        public TestDesignerViewVM()
        {
            Status = "Ready";

            LoadedAssemblies = new ObservableCollection<Assembly>();

            CompilationErrors = new List<CompilationError>();
            Logger = new TextController();
            ScriptEditor.LoadingSymbolsProgress += ScriptEditor_LoadingSymbolsProgress;
            ScriptEditor.LoadingSymbolsStarted += ScriptEditor_LoadingSymbolsStarted;
            ScriptEditor.LoadingSymbolsCompleted += ScriptEditor_LoadingSymbolsCompleted;
            ScriptEditor.BlockedUsingsCache.Add("Tango.FSE.Stubs");
            ScriptEditor.BlockedUsingsCache.Add("Tango.PMR.Stubs");

            OpenScripts = new ObservableCollection<Script>();
            OpenScriptCommand = new RelayCommand<Script>(OpenScript);
            CloseScriptCommand = new RelayCommand<Script>(CloseScript);
            RunProjectCommand = new RelayCommand(RunProject, () => ProjectRunner != null && ProjectRunner.CanRun);
            StopProjectCommand = new RelayCommand(StopProject, () => ProjectRunner != null && ProjectRunner.IsRunning);
            CompileProjectCommand = new RelayCommand(async () => await CompileProject(), () => ProjectRunner != null && ProjectRunner.CanCompile);
            AddReferenceAssemblyCommand = new RelayCommand(AddReferenceAssembly);
            RemoveReferenceAssemblyCommand = new RelayCommand<ReferenceAssembly>(RemoveReferenceAssembly);

            _compileTimer = new DispatcherTimer(DispatcherPriority.ApplicationIdle);
            _compileTimer.Interval = TimeSpan.FromSeconds(2);
            _compileTimer.Tick += _compileTimer_Tick;
            _compileTimer.Start();

            CreateNewProject();
        }

        #endregion

        #region Script Editor Symbols Loading Handlers

        private void ScriptEditor_LoadingSymbolsCompleted(object sender, EventArgs e)
        {
            IsLoadingSymbols = false;
        }

        private void ScriptEditor_LoadingSymbolsStarted(object sender, EventArgs e)
        {
            IsLoadingSymbols = true;
        }

        private void ScriptEditor_LoadingSymbolsProgress(object sender, Core.TangoProgressChangedEventArgs<int> e)
        {
            SymbolsLoadingProgress = e.Progress;
        }

        #endregion

        #region Project Start/Stop Compile

        private void StopProject()
        {
            ProjectRunner.Stop();
        }

        private async Task<bool> CompileProject()
        {
            try
            {
                Mouse.OverrideCursor = Cursors.AppStarting;
                IsFree = false;
                Logger.Clear();
                SelectedToolWindow = ToolWindows.Output;
                Logger.WriteLine("Compiling project...");
                Status = "Compiling project...";
                UIHelper.DoEvents();

                var result = await ProjectRunner.Compile();
                CompilationErrors = result.Errors;

                if (CompilationErrors.Count > 0)
                {
                    Logger.WriteLine("Project compiled with errors.");
                    Status = "Project compiled with errors.";
                    SelectedToolWindow = ToolWindows.Errors;
                    return false;
                }
                else
                {
                    SelectedToolWindow = ToolWindows.Output;
                    Status = "Project compiled successfully.";
                    Logger.WriteLine("Project compiled successfully.");
                    return true;
                }
            }
            catch (Exception ex)
            {
                Logger.WriteLine($"Error compiling the project.\n{ex.FlattenMessage()}");
                await NotificationProvider.ShowError($"Error compiling the project.\n{ex.FlattenMessage()}");
                return false;
            }
            finally
            {
                Mouse.OverrideCursor = null;
                Status = "Ready";
                IsFree = true;
            }
        }

        private async void RunProject()
        {
            try
            {
                if (await CompileProject())
                {
                    SelectedToolWindow = ToolWindows.Output;
                    Results = new List<Result>();
                    Logger.Clear();
                    Logger.WriteLine("Running project...");
                    var context = new TestContext(this);
                    await ProjectRunner.Run(context);
                    Logger.WriteLine("Project ran to completion with test result:");
                    Logger.WriteLine(context.Results.ToJsonString());
                    Results = context.Results.ToList();
                    SelectedToolWindow = ToolWindows.Results;
                }
            }
            catch (OperationCanceledException)
            {
                Logger.WriteLine("Project terminated by user.");
            }
            catch (Exception ex)
            {
                SelectedToolWindow = ToolWindows.Output;
                Logger.WriteLine("Project terminated with error:");
                Logger.WriteLine(ex.FlattenMessage());
            }
        }

        #endregion

        #region Open/Close Script Tabs

        private void CloseScript(Script script)
        {
            script.IsSelected = false;
            OpenScripts.Remove(script);
            SelectedScript = OpenScripts.FirstOrDefault();
        }

        internal void OpenScript(Script script)
        {
            if (!OpenScripts.Contains(script))
            {
                OpenScripts.Add(script);
            }

            SelectedScript = script;
        }

        #endregion

        #region Event Handlers

        private void ProjectRunner_StateChanged(object sender, ProjectRunnerState e)
        {
            InvalidateRelayCommands();
        }

        private async void _compileTimer_Tick(object sender, EventArgs e)
        {
            if (!IsVisible) return;

            _compileTimer.Stop();

            if (Project != null)
            {
                CompilationErrors = (await Project.Compile()).Errors;

                if (CompilationErrors.Count > 0)
                {
                    SelectedToolWindow = ToolWindows.Errors;
                }
            }

            _compileTimer.Start();
        }

        #endregion

        #region Private Methods

        private async void AddReferenceAssembly()
        {
            var vm = await NotificationProvider.ShowDialog<AddReferenceAssemblyViewVM>(new AddReferenceAssemblyViewVM(Project.ReferenceAssemblies.ToList()));
            if (vm.DialogResult)
            {
                Project.ReferenceAssemblies.Clear();

                foreach (var asm in vm.ReferenceAssemblies.SynchedSource)
                {
                    Project.ReferenceAssemblies.Add(asm);
                }

                LoadReferenceAssemblies();
            }
        }

        private void CreateNewProject()
        {
            Project = TestProject.New("test1");
            LoadReferenceAssemblies();
        }

        private void OnProjectChanged()
        {
            if (Project != null)
            {
                ProjectRunner = new ProjectRunner(Project);
                ProjectRunner.StateChanged += ProjectRunner_StateChanged;
            }
            else
            {
                ProjectRunner = null;
            }

            InvalidateRelayCommands();
        }

        private void LoadReferenceAssemblies()
        {
            LoadedAssemblies = Project.LoadReferenceAssemblies().ToObservableCollection();
        }

        private void RemoveReferenceAssembly(ReferenceAssembly assembly)
        {
            Project.ReferenceAssemblies.Remove(assembly);
            LoadedAssemblies = Project.LoadReferenceAssemblies().ToObservableCollection();
        }

        #endregion

        #region ITestLogger

        public void WriteLine(string text)
        {
            Logger.WriteLine(text);
        }

        public void Write(string text)
        {
            Logger.Write(text);
        }

        public void Clear()
        {
            Logger.Clear();
        }

        #endregion
    }
}