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

using System;
using System.Collections;
using System.Collections.Generic;
using System.ComponentModel;
using System.Linq;
using System.Reflection;
using System.Text;
using System.Threading.Tasks;
using Tango.BL.Entities;
using Tango.Core;
using Tango.Core.Commands;
using Tango.CSV;
using Tango.FSE.Common;
using Tango.FSE.Procedures.CSV;
using Tango.FSE.Procedures.Dialogs;
using Tango.FSE.Procedures.Messages;
using Tango.FSE.Procedures.Views;

namespace Tango.FSE.Procedures.ViewModels
{
    public class ProcedureRunnerViewVM : FSEViewModel, IProcedureLogger
    {
        public enum RunnerView
        {
            ProcedureRunnerCatalogView,
            ProcedureRunnerExecutionView
        }

        private bool _requiresReloadingOfProjects;

        private RunnerView _selectedView;
        public RunnerView SelectedView
        {
            get { return _selectedView; }
            set { _selectedView = value; RaisePropertyChangedAuto(); }
        }

        private List<PublishedProcedureProject> _publishedProcedureProjects;
        public List<PublishedProcedureProject> PublishedProcedureProjects
        {
            get { return _publishedProcedureProjects; }
            set { _publishedProcedureProjects = value; RaisePropertyChangedAuto(); }
        }

        private ProcedureProject _runningProcedureProject;
        public ProcedureProject RunningProcedureProject
        {
            get { return _runningProcedureProject; }
            set { _runningProcedureProject = value; RaisePropertyChangedAuto(); }
        }

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

        private bool _isLoadingProjects;
        public bool IsLoadingProjects
        {
            get { return _isLoadingProjects; }
            set { _isLoadingProjects = value; RaisePropertyChangedAuto(); }
        }

        public bool HasProcedureInputs
        {
            get { return RunningProcedureProject != null && RunningProcedureProject.Inputs.Count > 0; }
        }

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

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

        private String _failedError;
        public String FailedError
        {
            get { return _failedError; }
            set { _failedError = value; RaisePropertyChangedAuto(); }
        }

        private bool _isRunning;
        public bool IsRunning
        {
            get { return _isRunning; }
            set { _isRunning = value; RaisePropertyChangedAuto(); }
        }

        private TangoProgress<double> _procedureProgress;
        public TangoProgress<double> ProcedureProgress
        {
            get { return _procedureProgress; }
            set { _procedureProgress = value; RaisePropertyChangedAuto(); }
        }


        public RelayCommand<PublishedProcedureProject> EditProjectCommand { get; set; }
        public RelayCommand<PublishedProcedureProject> RunProjectCommand { get; set; }
        public RelayCommand StartProjectCommand { get; set; }
        public RelayCommand StopProjectCommand { get; set; }
        public RelayCommand<Result> DisplayResultGridCommand { get; set; }
        public RelayCommand<Result> ExportResultGridCommand { get; set; }

        public ProcedureRunnerViewVM()
        {
            EditProjectCommand = new RelayCommand<PublishedProcedureProject>(EditProject);
            RunProjectCommand = new RelayCommand<PublishedProcedureProject>(RunProject);
            StartProjectCommand = new RelayCommand(StartProject, () => ProjectRunner != null && ProjectRunner.CanRun);
            StopProjectCommand = new RelayCommand(StopProject, () => ProjectRunner != null && ProjectRunner.IsRunning);
            DisplayResultGridCommand = new RelayCommand<Result>(DisplayResultGrid);
            ExportResultGridCommand = new RelayCommand<Result>(ExportResultGrid);

            _requiresReloadingOfProjects = true;
            RegisterForMessage<ProcedureProjectPublishedOrSuppressed>((x) => _requiresReloadingOfProjects = true);
        }

        private async void StartProject()
        {
            try
            {
                IsRunning = true;
                FailedError = null;
                Results = new List<Result>();
                Status = "Running...";
                var context = new ProcedureContext(RunningProcedureProject, this);
                ProcedureProgress = new TangoProgress<double>(null);
                context.Progress += Context_Progress;
                await ProjectRunner.Run(context);
                Status = "Completed";
                Results = context.Results.ToList();
            }
            catch (OperationCanceledException)
            {
                Status = "Stopped";
            }
            catch (Exception ex)
            {
                Status = "Failed";
                FailedError = ex.FlattenMessage();
            }
            finally
            {
                IsRunning = false;
                ProcedureProgress = new TangoProgress<double>(null, false, 0, 100);
            }
        }

        private void Context_Progress(object sender, TangoProgressChangedEventArgs<double> e)
        {
            ProcedureProgress = e.Progress;
        }

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

        private void EditProject(PublishedProcedureProject project)
        {
            if (project != null)
            {
                NavigationManager.NavigateWithObject<
                    ProceduresModule,
                    ProcedureDesignerView,
                    ProcedureDesignerViewVM.NavigationObject>(
                    new ProcedureDesignerViewVM.NavigationObject()
                    {
                        Project = project
                    });
            }
        }

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

            if (_requiresReloadingOfProjects)
            {
                LoadPublishedProcedureProjects();
            }
        }

        private async void LoadPublishedProcedureProjects()
        {
            try
            {
                IsFree = false;
                IsLoadingProjects = true;
                PublishedProcedureProjects = new List<PublishedProcedureProject>();
                PublishedProcedureProjects = await Services.PublishedProcedureProjectsService.GetPublishedProcedureProjects();
                _requiresReloadingOfProjects = false;
                IsFree = true;
            }
            catch (Exception ex)
            {
                IsFree = false;
                LogManager.Log(ex, "Error retrieving published procedure projects.");
                await NotificationProvider.ShowError($"Error occurred while trying to retrieve the procedures collection.\n{ex.FlattenMessage()}");
            }
            finally
            {
                IsLoadingProjects = false;
            }
        }

        private void RunProject(PublishedProcedureProject project)
        {
            RunningProcedureProject = ProcedureProject.FromJson(project.CurrentVersion.ProjectJsonString);
            RaisePropertyChanged(nameof(HasProcedureInputs));
            ProjectRunner = new ProjectRunner(RunningProcedureProject);
            ProjectRunner.StateChanged += (x, e) => InvalidateRelayCommands();
            Status = "Ready";
            InvalidateRelayCommands();
            SelectedView = RunnerView.ProcedureRunnerExecutionView;
        }

        public override Task<bool> OnNavigateBackRequest()
        {
            if (SelectedView == RunnerView.ProcedureRunnerExecutionView && !IsRunning)
            {
                SelectedView = RunnerView.ProcedureRunnerCatalogView;
                return Task.FromResult(false);
            }

            return base.OnNavigateBackRequest();
        }

        public void WriteLine(string text)
        {
            Status = text;
        }

        public void Write(string text)
        {
            Status = text;
        }

        public void Clear()
        {
            //Do nothing
        }

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

        private async void ExportResultGrid(Result result)
        {
            if (result != null && result.IsValueArray && (result.Value as IList).Count > 0)
            {
                var r = await StorageProvider.SaveFile("Export procedure result", "CSV Files|*.csv", result.Name + ".csv", ".csv");
                if (r.Confirmed)
                {
                    using (NotificationProvider.PushTaskItem("Exporting csv file..."))
                    {
                        try
                        {
                            await Task.Factory.StartNew(() =>
                            {
                                List<Object> values = (result.Value as IEnumerable).Cast<Object>().ToList();

                                var model = values.First();

                                if (model.GetType().IsValueTypeOrString())
                                {
                                    CsvFile<CsvRow> csvFile = new CsvFile<CsvRow>(new CsvDestination(r.SelectedItem), new CsvDefinition() { Columns = new List<String>() { "Values" } });

                                    foreach (var value in values)
                                    {
                                        csvFile.Append(new CsvRow()
                                        {
                                            V0 = value
                                        });
                                    }

                                    csvFile.Dispose();
                                }
                                else
                                {
                                    List<CsvColumn> columns = new List<CsvColumn>();

                                    //prop columns
                                    foreach (var prop in model.GetType().GetProperties(BindingFlags.Public | BindingFlags.Instance))
                                    {
                                        var att = prop.GetCustomAttribute<DescriptionAttribute>();
                                        columns.Add(new CsvColumn()
                                        {
                                            Name = prop.Name,
                                            Description = att != null ? att.Description : prop.Name,
                                            IsProperty = true,
                                            PropertyInfo = prop
                                        });
                                    }

                                    //field columns
                                    foreach (var field in model.GetType().GetFields(BindingFlags.Public | BindingFlags.Instance))
                                    {
                                        var att = field.GetCustomAttribute<DescriptionAttribute>();
                                        columns.Add(new CsvColumn()
                                        {
                                            Name = field.Name,
                                            Description = att != null ? att.Description : field.Name,
                                            FieldInfo = field
                                        });
                                    }

                                    CsvFile<CsvRow> csvFile = new CsvFile<CsvRow>(new CsvDestination(r.SelectedItem), new CsvDefinition() { Columns = columns.Select(x => x.Description).ToList() });

                                    List<PropertyInfo> rowProps = typeof(CsvRow).GetProperties().ToList();

                                    foreach (var value in values)
                                    {
                                        CsvRow row = new CsvRow();

                                        for (int i = 0; i < columns.Count; i++)
                                        {
                                            var column = columns[i];
                                            rowProps[i].SetValue(row, column.GetValue(value));
                                        }

                                        csvFile.Append(row);
                                    }

                                    csvFile.Dispose();
                                }
                            });

                            await NotificationProvider.ShowSuccess("File exported successfully.");
                        }
                        catch (Exception ex)
                        {
                            LogManager.Log(ex, "Error exporting csv file.");
                            await NotificationProvider.ShowError($"Error occurred while exporting the csv file.\n{ex.FlattenMessage()}");
                        }
                    }
                }
            }
        }
    }
}