path: root/Software/Visual_Studio/MachineStudio/Modules/Tango.MachineStudio.MachineDesigner/ViewModels/MainViewVM.cs

using System;
using System.Collections.Generic;
using System.Collections.ObjectModel;
using System.ComponentModel;
using System.Linq;
using System.Reflection;
using System.Text;
using System.Threading.Tasks;
using System.Windows.Data;
using Tango.Core.Commands;
using Tango.Core.Helpers;
using Tango.DAL.Observables;
using Tango.MachineStudio.Common.Notifications;
using Tango.SharedUI;
using SimpleValidator.Extensions;

namespace Tango.MachineStudio.MachineDesigner.ViewModels
{
    public class MainViewVM : ViewModel
    {
        private bool _isSaving;
        private INotificationProvider _notification;

        private ObservablesEntitiesAdapter _adapter;
        /// <summary>
        /// Gets or sets the db adapter.
        /// </summary>
        public ObservablesEntitiesAdapter Adapter
        {
            get { return _adapter; }
            set { _adapter = value; RaisePropertyChangedAuto(); }
        }

        private Machine _machine;
        /// <summary>
        /// Gets or sets the machine.
        /// </summary>
        public Machine Machine
        {
            get { return _machine; }
            set { _machine = value; RaisePropertyChangedAuto(); }
        }

        private Machine _selectedMachine;
        public Machine SelectedMachine
        {
            get { return _selectedMachine; }
            set { _selectedMachine = value; RaisePropertyChangedAuto(); OnSelectedMachineChanged(); }
        }

        private Configuration _configuration;
        /// <summary>
        /// Gets or sets the configuration.
        /// </summary>
        public Configuration Configuration
        {
            get { return _configuration; }
            set { _configuration = value; RaisePropertyChangedAuto(); }
        }

        private IdsPack _selectedIds;
        /// <summary>
        /// Gets or sets the selected ids pack.
        /// </summary>
        public IdsPack SelectedIds
        {
            get { return _selectedIds; }
            set { _selectedIds = value; RaisePropertyChangedAuto(); InvalidateRelayCommands(); }
        }

        private ObservableCollection<Configuration> _history;

        public ObservableCollection<Configuration> History
        {
            get { return _history; }
            set { _history = value; RaisePropertyChangedAuto(); }
        }


        private Configuration _selectedHistoryConfiguration;
        /// <summary>
        /// Gets or sets the selected history configuration.
        /// </summary>
        public Configuration SelectedHistoryConfiguration
        {
            get { return _selectedHistoryConfiguration; }
            set { _selectedHistoryConfiguration = value; RaisePropertyChangedAuto(); OnHistoryConfigurationSelected(); }
        }

        private String _filter;

        public String Filter
        {
            get { return _filter; }
            set { _filter = value; RaisePropertyChangedAuto(); OnFilterChanged(); }
        }

        public RelayCommand SaveCommand { get; set; }

        public RelayCommand AddIdsCommand { get; set; }

        public RelayCommand RemoveIdsCommand { get; set; }

        /// <summary>
        /// Initializes a new instance of the <see cref="MainViewVM"/> class.
        /// </summary>
        public MainViewVM(INotificationProvider notification)
        {
            _notification = notification;

            Adapter = ObservablesEntitiesAdapter.Instance;
            Configuration = new Configuration();
            Configuration.Name = "Untitled";
            Machine = new Machine();
            Machine.Configuration = Configuration;

            SaveCommand = new RelayCommand(Save, (x) => !_isSaving);
            AddIdsCommand = new RelayCommand(AddIds, (x) => !_isSaving && Configuration.IdsPacks.Count < 8);
            RemoveIdsCommand = new RelayCommand(RemoveIds, (x) => !_isSaving && SelectedIds != null);
        }

        private void OnSelectedMachineChanged()
        {
            if (SelectedMachine != null)
            {
                Machine = SelectedMachine.CloneEntity();
                Configuration = Machine.Configuration.CloneConfiguration();
                History = SelectedMachine.MachinesConfigurations.Select(x => x.Configuration).ToObservableCollection();
            }
            else
            {
                History = new ObservableCollection<Configuration>();
            }
        }

        public void DropIdsPack(IdsPack idsPack1, IdsPack idsPack2)
        {
            Configuration.IdsPacks.Swap(idsPack1, idsPack2);
        }

        private void OnHistoryConfigurationSelected()
        {
            if (SelectedHistoryConfiguration != null)
            {
                Configuration = SelectedHistoryConfiguration.CloneConfiguration();
            }
        }

        public void DropTouchPanel(ApplicationDisplayPanelVersion applicationDisplayPanelVersion)
        {
            Configuration.ApplicationDisplayPanelVersions = applicationDisplayPanelVersion;
            Configuration.ApplicationDisplayPanelVersionGuid = applicationDisplayPanelVersion.Guid;
        }

        public void DropApplicationFirmwareVersion(ApplicationFirmwareVersion applicationFirmwareVersion)
        {
            Configuration.ApplicationFirmwareVersions = applicationFirmwareVersion;
            Configuration.ApplicationFirmwareVersionGuid = applicationFirmwareVersion.Guid;
        }

        public void DropApplicationVersion(ApplicationVersion applicationVersion)
        {
            Configuration.ApplicationVersions = applicationVersion;
            Configuration.ApplicationVersionGuid = applicationVersion.Guid;
        }

        public void DropHardwareVersion(HardwareVersion hardwareVersion)
        {
            Configuration.HardwareVersions = hardwareVersion;
            Configuration.HardwareVersionGuid = hardwareVersion.Guid;
        }

        public void DropEmbeddedFirmware(EmbeddedFirmwareVersion embeddedFirmwareVersion)
        {
            Configuration.EmbeddedFirmwareVersions = embeddedFirmwareVersion;
            Configuration.EmbeddedFirmwareVersionGuid = embeddedFirmwareVersion.Guid;
        }

        public void DropEmbeddedSoftware(EmbeddedSoftwareVersion embeddedSoftwareVersion)
        {
            Configuration.EmbeddedSoftwareVersions = embeddedSoftwareVersion;
            Configuration.EmbeddedSoftwareVersionGuid = embeddedSoftwareVersion.Guid;
        }

        public void DropApplicationOsVersion(ApplicationOsVersion applicationOsVersion)
        {
            Configuration.ApplicationOsVersions = applicationOsVersion;
            Configuration.ApplicationVersionGuid = applicationOsVersion.Guid;
        }

        private void RemoveIds()
        {
            Configuration.IdsPacks.Remove(SelectedIds);
            SelectedIds = null;
        }

        private void AddIds()
        {
            Configuration.IdsPacks.Add(new IdsPack() { Configuration = Configuration });
            InvalidateRelayCommands();
        }

        public void DropCartridgeType(CartridgeType cartridgeType, IdsPack idsPack)
        {
            idsPack.CartridgeTypes = cartridgeType;
            idsPack.CartridgeTypeGuid = cartridgeType.Guid;
        }

        public void DropDispenser(Dispenser dispenser, IdsPack idsPack)
        {
            idsPack.Dispenser = dispenser;
            idsPack.DispenserGuid = dispenser.Guid;
        }

        public void DropMidTankType(MidTankType midTankType, IdsPack idsPack)
        {
            idsPack.MidTankTypes = midTankType;
            idsPack.MidTankTypeGuid = midTankType.Guid;
        }

        public void DropLiquidType(LiquidType liquidType, IdsPack idsPack)
        {
            idsPack.LiquidTypes = liquidType;
            idsPack.LiquidTypeGuid = liquidType.Guid;
        }

        private void OnFilterChanged()
        {


            List<ICollectionView> collections = new List<ICollectionView>();
            collections.Add(Adapter.ApplicationDisplayPanelVersionsViewSource);
            collections.Add(Adapter.ApplicationVersionsViewSource);
            collections.Add(Adapter.EmbeddedSoftwareVersionsViewSource);
            collections.Add(Adapter.EmbeddedFirmwareVersionsViewSource);
            collections.Add(Adapter.ApplicationOsVersionsViewSource);
            collections.Add(Adapter.ApplicationVersionsViewSource);
            collections.Add(Adapter.DispensersViewSource);
            collections.Add(Adapter.CartridgeTypesViewSource);
            collections.Add(Adapter.LiquidTypesViewSource);
            collections.Add(Adapter.MidTankTypesViewSource);
            collections.Add(Adapter.HardwareVersionsViewSource);

            foreach (var collection in collections)
            {
                collection.Filter = (x) =>
                {
                    foreach (var prop in x.GetType().GetProperties(BindingFlags.Public | BindingFlags.Instance).Where(y => y.PropertyType == typeof(String)))
                    {
                        String value = prop.GetValue(x).ToStringSafe();

                        if (value != null)
                        {
                            if (value.ToLower().Contains(Filter.ToLower()))
                            {
                                return true;
                            }
                        }
                    }

                    return false;
                };
            }
        }

        private async void Save()
        {
            //Validate

            List<String> errors = new List<string>();

            if (Machine.MachineVersions == null)
            {
                errors.Add("Machine Version is required.");
            }

            if (Machine.Name.IsNullOrWhiteSpace())
            {
                errors.Add("Machine name is required.");
            }

            if (Machine.Organization == null)
            {
                errors.Add("Machine organization is required.");
            }

            if (Machine.SerialNumber.IsNullOrWhiteSpace())
            {
                errors.Add("Machine serial number is required.");
            }

            if (Configuration.Name.IsNullOrWhiteSpace())
            {
                errors.Add("Configuration name is required.");
            }

            if (Configuration.ApplicationDisplayPanelVersions == null)
            {
                errors.Add("Touch Panel is required.");
            }

            if (Configuration.ApplicationFirmwareVersions == null)
            {
                errors.Add("Application Firmware is required.");
            }

            if (Configuration.ApplicationOsVersions == null)
            {
                errors.Add("Application OS Version is required.");
            }

            if (Configuration.ApplicationVersions == null)
            {
                errors.Add("Application Version is required.");
            }

            if (Configuration.EmbeddedFirmwareVersions == null)
            {
                errors.Add("Embedded Firmware is required.");
            }

            if (Configuration.EmbeddedSoftwareVersions == null)
            {
                errors.Add("Embedded Software is required.");
            }

            if (Configuration.HardwareVersions == null)
            {
                errors.Add("Hardware Version is required.");
            }

            foreach (var pack in Configuration.IdsPacks)
            {
                if (pack.Name.IsNullOrWhiteSpace())
                {
                    errors.Add(String.Format("Name is required on IDS pack number {0}.", Configuration.IdsPacks.IndexOf(pack) + 1));
                    continue;
                }
                if (pack.CartridgeTypes == null)
                {
                    errors.Add(String.Format("Cartridge type is required on IDS pack {0}.", pack.Name));
                }
                if (pack.Dispenser == null)
                {
                    errors.Add(String.Format("Dispenser is required on IDS pack {0}.", pack.Name));
                }
                if (pack.LiquidTypes == null)
                {
                    errors.Add(String.Format("Liquid type is required on IDS pack {0}.", pack.Name));
                }
                if (pack.MidTankTypes == null)
                {
                    errors.Add(String.Format("Mid Tank type is required on IDS pack {0}.", pack.Name));
                }
            }

            if (errors.Count > 0)
            {
                String errorsString = "Please fix the following validation errors before trying to save." + Environment.NewLine + Environment.NewLine;
                errorsString += String.Join(Environment.NewLine, errors);
                _notification.ShowError(errorsString);
                return;
            }

            //Validate

            _isSaving = true;
            InvalidateRelayCommands();

            foreach (var ids in Configuration.IdsPacks)
            {
                ids.PackIndex = Configuration.IdsPacks.IndexOf(ids);
                ids.Configuration = Configuration;
                ids.ConfigurationGuid = Configuration.Guid;
            }

            try
            {
                using (_notification.PushTaskItem("Saving Machine Configuration..."))
                {
                    if (!Adapter.Machines.ToList().Exists(x => x.SerialNumber.ToLower() == Machine.SerialNumber.ToLower()))
                    {
                        if (!_notification.ShowQuestion("The specified machine serial number does not exist. Do you wish to create a new machine?"))
                        {
                            return;
                        }
                        else
                        {
                            Machine.Configuration = Configuration;
                            Configuration.CreationDate = DateTime.UtcNow;
                            Machine.ProductionDate = DateTime.UtcNow;
                            Machine.MachinesConfigurations.Add(new MachinesConfiguration()
                            {
                                Configuration = Configuration,
                                Machine = Machine,
                            });
                            await Machine.SaveAsync();

                            Machine = Adapter.Machines.SingleOrDefault(x => x.Guid == Machine.Guid);
                            Configuration = Machine.Configuration.CloneConfiguration();
                        }
                    }
                    else
                    {
                        var machine = Adapter.Machines.Single(x => x.SerialNumber.ToLower() == Machine.SerialNumber.ToLower());

                        //Set 'Real machine' parameters...

                        bool add_history = History.Count == 0 || History.First().Name != Configuration.Name;

                        machine.Name = Machine.Name;
                        machine.SerialNumber = Machine.SerialNumber;
                        machine.Configuration = Configuration;
                        machine.Organization = Machine.Organization;


                        if (add_history)
                        {
                            machine.MachinesConfigurations.Add(new MachinesConfiguration()
                            {
                                Configuration = Configuration,
                                Machine = machine
                            });
                        }

                        await machine.SaveAsync();

                        Machine = Adapter.Machines.SingleOrDefault(x => x.Guid == machine.Guid);
                        Configuration = Machine.Configuration.CloneConfiguration();
                    }

                    SetHistory(Machine);
                    Machine = Machine.CloneEntity();
                }
            }
            catch (Exception ex)
            {
                _notification.ShowError("An error occurred while trying to save the configuration" + Environment.NewLine + ex.Message);
            }
            finally
            {
                _isSaving = false;
                InvalidateRelayCommands();
            }
        }

        private void SetHistory(Machine machine)
        {
            History = machine.MachinesConfigurations.Select(x => x.Configuration).ToObservableCollection();
            History.Insert(0, machine.Configuration);
        }
    }
}