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

using Google.Protobuf;
using MaterialDesignThemes.Wpf;
using System;
using System.Collections.Generic;
using System.Collections.ObjectModel;
using System.IO;
using System.Linq;
using System.Reflection;
using System.Text;
using System.Threading;
using System.Threading.Tasks;
using System.Windows;
using System.Windows.Input;
using System.Windows.Threading;
using Tango.BL.Entities;
using Tango.Core;
using Tango.Core.Commands;
using Tango.Core.ExtensionMethods;
using Tango.FSE.Common;
using Tango.FSE.Common.Navigation;
using Tango.FSE.Stubs.Contracts;
using Tango.FSE.Stubs.Dialogs;
using Tango.FSE.Stubs.Messages;
using Tango.Integration.Operation;
using Tango.Scripting.Basic;
using Tango.Scripting.Editors;
using Tango.SharedUI.Components;
using Tango.SharedUI.Helpers;
using Tango.Transport;
using static Tango.FSE.Stubs.ViewModels.TestDesignerViewVM;

namespace Tango.FSE.Stubs.ViewModels
{
    public class TestDesignerViewVM : FSEViewModel<ITestDesignerView>, ITestLogger, INavigationObjectReceiver<NavigationObject>
    {
        public class NavigationObject
        {
            public PublishedTestProject Project { get; set; }
        }

        public enum ToolWindows
        {
            Output,
            Errors,
            Inputs,
            Results,
            Publish
        }

        private System.Timers.Timer _compileTimer;
        private String _projectFile;
        private String PROJECT_FILE_EXTENSION = ".tproj";
        private String PROJECT_DIALOG_FILTER = $"Test Project Files|*.tproj";
        private bool _isProjectChanged;

        #region Properties

        private PublishedTestProject _publishedTestProject;
        public PublishedTestProject PublishedTestProject
        {
            get { return _publishedTestProject; }
            set { _publishedTestProject = value; RaisePropertyChangedAuto(); InvalidateRelayCommands(); }
        }

        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(); }
        }

        private bool _isPublishPanelOpened;
        public bool IsPublishPanelOpened
        {
            get { return _isPublishPanelOpened; }
            set { _isPublishPanelOpened = value; RaisePropertyChangedAuto(); }
        }

        private List<CreateGroup> _createGroups;
        public List<CreateGroup> CreateGroups
        {
            get { return _createGroups; }
            set { _createGroups = 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; }
        public RelayCommand AddProjectInputCommand { get; set; }
        public RelayCommand<TestInput> RemoveProjectInputCommand { get; set; }
        public RelayCommand FormatCodeCommand { get; set; }
        public RelayCommand<CompilationError> HighlightErrorCommand { get; set; }
        public RelayCommand NewProjectCommand { get; set; }
        public RelayCommand SaveProjectCommand { get; set; }
        public RelayCommand SaveAsProjectCommand { get; set; }
        public RelayCommand OpenProjectCommand { get; set; }
        public RelayCommand AddLibraryCommand { get; set; }
        public RelayCommand<Script> DeleteLibraryCommand { get; set; }
        public RelayCommand ClearOutputCommand { get; set; }
        public RelayCommand PublishProjectCommand { get; set; }
        public RelayCommand LoadPublishedProjectCommand { get; set; }
        public RelayCommand UnPublishProjectCommand { get; set; }
        public RelayCommand TogglePublishPanelCommand { get; set; }
        public RelayCommand<Script> RenameLibraryCommand { get; set; }
        public RelayCommand<CreateItem> CreateItemCommand { get; set; }
        public RelayCommand<Result> DisplayResultGridCommand { get; set; }

        #endregion

        #region Constructors

        public TestDesignerViewVM()
        {
            Status = "Ready";

            LoadedAssemblies = new ObservableCollection<Assembly>();
            Results = new List<Result>();
            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);
            AddProjectInputCommand = new RelayCommand(AddProjectInput);
            RemoveProjectInputCommand = new RelayCommand<TestInput>(RemoveProjectInput);
            FormatCodeCommand = new RelayCommand(FormatCode);
            HighlightErrorCommand = new RelayCommand<CompilationError>(HighlightError);
            NewProjectCommand = new RelayCommand(CreateNewProject, () => ProjectRunner == null || !ProjectRunner.IsRunning);
            SaveProjectCommand = new RelayCommand(SaveProject);
            SaveAsProjectCommand = new RelayCommand(SaveAsProject);
            OpenProjectCommand = new RelayCommand(OpenProject);
            AddLibraryCommand = new RelayCommand(AddNewLibrary);
            ClearOutputCommand = new RelayCommand(Clear);
            DeleteLibraryCommand = new RelayCommand<Script>(DeleteLibrary);
            PublishProjectCommand = new RelayCommand(PublishProject);
            LoadPublishedProjectCommand = new RelayCommand(LoadPublishedProject);
            UnPublishProjectCommand = new RelayCommand(UnPublishProject);
            TogglePublishPanelCommand = new RelayCommand(() => IsPublishPanelOpened = !IsPublishPanelOpened);
            RenameLibraryCommand = new RelayCommand<Script>(RenameLibrary);
            CreateItemCommand = new RelayCommand<CreateItem>(AutoCreateItem);
            DisplayResultGridCommand = new RelayCommand<Result>(DisplayResultGrid);
        }

        #endregion

        #region Auto Creation

        private void InitCreateGroups()
        {
            var groups = new List<CreateGroup>();

            foreach (var typesGroup in typeof(PMR.Common.MessageContainer).Assembly.GetTypes().Where(x => x.IsClass && !x.IsGenericType && !x.Name.Contains("Reflection") && typeof(IMessage).IsAssignableFrom(x)).GroupBy(x => x.Namespace))
            {
                CreateGroup group = new CreateGroup();
                group.Name = typesGroup.First().Namespace.Split('.').Last();

                foreach (var type in typesGroup)
                {
                    group.Items.Add(new CreateItem()
                    {
                        Name = type.Name,
                        Type = type,
                    });
                }

                groups.Add(group);
            }

            CreateGroups = groups;
        }

        private void AutoCreateItem(CreateItem item)
        {
            if (item != null)
            {
                try
                {
                    String code = String.Empty;
                    FormatProperties(item.Type, ref code);
                    View.InsertCode(code);
                }
                catch (Exception ex)
                {
                    LogManager.Log(ex, $"Error generating code for {item.Type.Name}.");
                    NotificationProvider.ShowError($"Error generating code for {item.Type.Name}.");
                }
            }
        }

        private void FormatProperties(Type type, ref String code)
        {
            code += Environment.NewLine + String.Format("{0} {1} = new {0}();", type.Name, type.Name.ToCamelCase()) + Environment.NewLine;

            foreach (var prop in type.GetProperties(BindingFlags.Instance | BindingFlags.Public))
            {
                if (prop.PropertyType == typeof(String))
                {
                    code += String.Format("{0}.{1} = {2};", type.Name.ToCamelCase(), prop.Name, "null") + Environment.NewLine;
                }
                else if (prop.PropertyType.IsEnum)
                {
                    code += String.Format("{0}.{1} = {2};", type.Name.ToCamelCase(), prop.Name, Activator.CreateInstance(prop.PropertyType).GetType().FullName + "." + Activator.CreateInstance(prop.PropertyType).ToString()) + Environment.NewLine;
                }
                else if (!prop.PropertyType.IsClass)
                {
                    code += String.Format("{0}.{1} = {2};", type.Name.ToCamelCase(), prop.Name, Activator.CreateInstance(prop.PropertyType).ToString().ToLower()) + Environment.NewLine;
                }
                else if (prop.PropertyType.IsGenericType)
                {
                    Type genericType = prop.PropertyType.GenericTypeArguments[0];
                    FormatProperties(genericType, ref code);
                    code += String.Format("{0}.{1}.Add({2});", type.Name.ToCamelCase(), prop.Name, genericType.Name.ToCamelCase()) + Environment.NewLine;
                }
                else
                {
                    FormatProperties(prop.PropertyType, ref code);
                    code += Environment.NewLine + String.Format("{0}.{1} = {2};", type.Name.ToCamelCase(), prop.Name, prop.Name.ToCamelCase()) + Environment.NewLine;
                }
            }
        }

        #endregion

        #region Override Methods

        public override void OnApplicationStarted()
        {
            _compileTimer = new System.Timers.Timer(2000);
            _compileTimer.Elapsed += _compileTimer_Tick;
            _compileTimer.Start();

            Task.Factory.StartNew(() =>
            {
                try
                {
                    InitCreateGroups();
                }
                catch (Exception ex)
                {
                    LogManager.Log(ex, "Error generating test designer auto creation groups.");
                }
            });
        }

        public override void OnNavigatedTo()
        {
            base.OnNavigatedTo();

            if (Project == null)
            {
                CreateStartupProject();
            }
        }

        #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(Project, this);
                    await ProjectRunner.Run(context);

                    Results = context.Results.ToList();

                    if (Results.Count > 0)
                    {
                        Logger.WriteLine("Project ran to completion with test result:");
                        Logger.WriteLine(Results.ToJsonString());
                        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;
        }

        private void ClearOpenedScripts()
        {
            OpenScripts.Clear();
            SelectedScript = null;
        }

        #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.Output || SelectedToolWindow == ToolWindows.Results))
                {
                    SelectedToolWindow = ToolWindows.Errors;
                }
            }

            _compileTimer.Start();
        }

        #endregion

        #region Reference Assemblies

        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);
                }

                _isProjectChanged = true;

                LoadReferenceAssemblies();
            }
        }

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

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

        #endregion

        #region Project Management

        private async void CreateNewProject()
        {
            if (await CheckDiscardProjectChanges())
            {
                var result = await NotificationProvider.ShowInputBox("New Project", "Please specify the project name", PackIconKind.TestTube, "untitled", "Project Name", 100, "CREATE");
                if (result.Confirmed)
                {
                    Project = TestProject.New(result.Input);
                    _projectFile = null;
                    PublishedTestProject = null;
                }
            }
        }

        private void CreateStartupProject()
        {
            Project = TestProject.New("untitled");
            _projectFile = null;
        }

        private void SaveProject()
        {
            if (Project != null)
            {
                if (_projectFile == null)
                {
                    SaveAsProject();
                    return;
                }

                try
                {
                    Status = "Saving project...";

                    File.WriteAllText(_projectFile, Project.ToJson());

                    Status = "Project saved.";

                    Project.Scripts.ToList().ForEach(x => x.IsChanged = false);
                    _isProjectChanged = false;
                }
                catch (Exception ex)
                {
                    NotificationProvider.ShowError($"Error saving project\n{ex.FlattenMessage()}");
                    Status = "Ready";
                }
            }
        }

        private async void SaveAsProject()
        {
            if (Project != null)
            {
                var result = await StorageProvider.SaveFile("Save As Project", PROJECT_DIALOG_FILTER, Project.Name, PROJECT_FILE_EXTENSION);

                if (result)
                {
                    try
                    {
                        Status = "Saving project...";

                        File.WriteAllText(result.SelectedItem, Project.ToJson());
                        _projectFile = result.SelectedItem;

                        Status = "Project saved.";

                        Project.Scripts.ToList().ForEach(x => x.IsChanged = false);
                        _isProjectChanged = false;
                    }
                    catch (Exception ex)
                    {
                        await NotificationProvider.ShowError($"Error saving project\n{ex.FlattenMessage()}");
                        Status = "Ready";
                    }
                }
            }
        }

        private void OnProjectChanged()
        {
            if (Project != null)
            {
                _isProjectChanged = false;
                LoadReferenceAssemblies();
                ProjectRunner = new ProjectRunner(Project);
                ProjectRunner.StateChanged += ProjectRunner_StateChanged;
                ClearOpenedScripts();

                var programScript = Project.Scripts.SingleOrDefault(x => x.IsEntryPoint);

                if (programScript != null)
                {
                    OpenScript(programScript);
                }
            }
            else
            {
                ProjectRunner = null;
            }

            InvalidateRelayCommands();

            View.InvalidateHighlighting();
        }

        private async void OpenProject()
        {
            if (await CheckDiscardProjectChanges())
            {
                var result = await StorageProvider.OpenFile("Open Test Project", PROJECT_DIALOG_FILTER);

                if (result)
                {
                    OpenProject(result.SelectedItem);
                }
            }
        }

        private void OpenProject(String file)
        {
            try
            {
                Project = TestProject.FromJson(File.ReadAllText(file));
                _projectFile = file;
                PublishedTestProject = null;
                Status = "Project loaded.";
            }
            catch (Exception ex)
            {
                LogManager.Log(ex, "Error opening test project.");
                NotificationProvider.ShowError($"Error occurred while trying to open the project.\n{ex.FlattenMessage()}");
            }
        }

        private async Task<bool> CheckDiscardProjectChanges()
        {
            if (Project != null && (Project.Scripts.Any(x => x.IsChanged) || _isProjectChanged))
            {
                return await NotificationProvider.ShowWarningQuestion("The current project contains unsaved changes. Discard the changes?");
            }
            else
            {
                return true;
            }
        }

        #endregion

        #region Libraries

        private async void AddNewLibrary()
        {
            var result = await NotificationProvider.ShowInputBox("New Library File", "Please specify the library name", PackIconKind.Script, "MyLibrary", "Library Name", 100, "ADD LIBRARY");

            if (result.Confirmed)
            {
                if (Project.Scripts.Any(x => x.Name.ToLower() == result.Input.ToLower() + ".csx"))
                {
                    await NotificationProvider.ShowError($"The project already contains a file named '{result.Input}'.");
                    return;
                }

                try
                {
                    var lib = Script.New(result.Input + ".csx", Encoding.UTF8.GetString(Properties.Resources.lib_template).Replace("@LibraryName", result.Input));
                    Project.Scripts.Add(lib);
                    _isProjectChanged = true;
                    OpenScript(lib);
                }
                catch (Exception ex)
                {
                    LogManager.Log(ex, "Error adding new library to test project.");
                    await NotificationProvider.ShowError($"Could not add a new script to the project.\n{ex.FlattenMessage()}");
                }
            }
        }

        private async void DeleteLibrary(Script script)
        {
            if (script.IsEntryPoint)
            {
                await NotificationProvider.ShowWarning("Entry point file cannot be deleted.");
                return;
            }

            if (await NotificationProvider.ShowWarningQuestion($"Are you sure you want to delete '{script.Name}'?"))
            {
                CloseScript(script);
                Project.Scripts.Remove(script);
                _isProjectChanged = true;
            }
        }

        private async void RenameLibrary(Script script)
        {
            var result = await NotificationProvider.ShowInputBox("Rename Library File", "Please specify a new library name", PackIconKind.Rename, Path.GetFileNameWithoutExtension(script.Name), "Library Name", 100, "RENAME");

            if (result.Confirmed)
            {
                script.Name = result.Input + ".csx";
                script.IsChanged = true;
            }
        }

        #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

        #region Inputs

        private void AddProjectInput()
        {
            Project.Inputs.Add(new TestInput()
            {
                Key = "param" + (Project.Inputs.Count + 1),
                Value = "0",
                DisplayName = "Parameter " + (Project.Inputs.Count + 1),
                Description = "Controls the " + (Project.Inputs.Count + 1 + " parameter."),
            });
        }

        private void RemoveProjectInput(TestInput input)
        {
            Project.Inputs.Remove(input);
        }

        #endregion

        #region Publish

        private async void LoadPublishedProject()
        {
            try
            {
                IsFree = false;

                List<PublishedTestProject> projects = new List<PublishedTestProject>();

                using (NotificationProvider.PushTaskItem("Retrieving published projects..."))
                {
                    projects = await Services.PublishedTestProjectsService.GetPublishedTestProjects(false);
                }

                if (projects.Count == 0)
                {
                    await NotificationProvider.ShowInfo("No published test projects found. Please publish a test project before trying to load one.");
                    return;
                }

                var vm = await NotificationProvider.ShowDialog<LoadPublishedProjectViewVM>(new LoadPublishedProjectViewVM(projects));

                if (vm.DialogResult)
                {
                    await LoadPublishedProject(vm.SelectedProject);
                    await NotificationProvider.ShowSuccess("Project loaded successfully.");
                }
            }
            catch (Exception ex)
            {
                LogManager.Log(ex, "Error retrieving published test projects.");
                await NotificationProvider.ShowError($"Error occurred while trying to fetch published test projects.\n{ex.FlattenMessage()}");
            }
            finally
            {
                IsFree = true;
            }
        }

        private async Task LoadPublishedProject(PublishedTestProject project)
        {
            try
            {
                if (project == null)
                {
                    throw new NullReferenceException("No project provided.");
                }

                if (!await CheckDiscardProjectChanges()) return;

                using (NotificationProvider.PushTaskItem("Loading published project..."))
                {
                    await Task.Delay(1000);
                    Project = TestProject.FromJson(project.CurrentVersion.ProjectJsonString);
                    PublishedTestProject = project;
                    _projectFile = null;
                    await Task.Delay(1000);
                }
            }
            catch (Exception ex)
            {
                LogManager.Log(ex, "Error loading published test project.");
                await NotificationProvider.ShowError($"Error loading published test project.\n{ex.FlattenMessage()}");
            }
        }

        private async void PublishProject()
        {
            try
            {
                if (!Project.Name.IsNotNullOrEmpty())
                {
                    await NotificationProvider.ShowError("Please provide a project name.");
                    return;
                }

                if (PublishedTestProject == null || !PublishedTestProject.IsVisible)
                {
                    if (!await NotificationProvider.ShowWarningQuestion("Publishing this project will make it available for all users via the Test Runner module.", "PUBLISH"))
                    {
                        return;
                    }
                }
                else
                {
                    if (!await NotificationProvider.ShowWarningQuestion("This project is already published. Do you want to update the published project?", "UPDATE"))
                    {
                        return;
                    }
                }

                IsFree = false;

                using (NotificationProvider.PushTaskItem("Publishing test project..."))
                {
                    PublishedTestProject = await Services.PublishedTestProjectsService.PublishTestProject(
                        PublishedTestProject?.Guid,
                        Project.Name,
                        Project.Description,
                        Project.ToJson());

                    RaiseMessage<TestProjectPublishedOrSuppressed>();
                }

                await NotificationProvider.ShowSuccess("Your test project is now published!\nNow you can execute this project from the Test Runner module.");
            }
            catch (Exception ex)
            {
                LogManager.Log(ex, "Error publishing test project.");
                await NotificationProvider.ShowError($"Error publishing test project.\n{ex.FlattenMessage()}");
            }
            finally
            {
                IsFree = true;
            }
        }

        private async void UnPublishProject()
        {
            if (!await NotificationProvider.ShowWarningQuestion("Suppressing this project will make it unavailable on the Test Runner module.\nAre you sure?", "SUPPRESS"))
            {
                return;
            }

            try
            {
                using (NotificationProvider.PushTaskItem("Suppressing test project..."))
                {
                    PublishedTestProject = await Services.PublishedTestProjectsService.UnPublishTestProject(PublishedTestProject);
                    RaiseMessage<TestProjectPublishedOrSuppressed>();
                }

                await NotificationProvider.ShowInfo("This test project will no longer be available on the Test Runner module.");
            }
            catch (Exception ex)
            {
                LogManager.Log(ex, "Error suppressing test project.");
                await NotificationProvider.ShowError($"Error occurred while trying to suppress this test project.\n{ex.FlattenMessage()}");
            }
        }

        #endregion

        #region View

        private void HighlightError(CompilationError error)
        {
            var errorScript = Project.Scripts.SingleOrDefault(x => x.Name == error.File);

            if (errorScript != null)
            {
                OpenScript(errorScript);
                View.HighlightCode(error.Position, error.Length);
            }
        }

        private void FormatCode()
        {
            View.FormatCode();
        }

        #endregion

        #region Results

        private void DisplayResultGrid(Result result)
        {
            if (result != null)
            {
                ResultGridViewVM vm = new ResultGridViewVM(result);
                NotificationProvider.ShowDialog(vm);
            }
        }

        #endregion

        #region INavigationObjectReceiver

        public async void OnNavigatedToWithObject(NavigationObject obj)
        {
            await Task.Delay(500);
            await LoadPublishedProject(obj.Project);
        }

        #endregion
    }
}