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

using System;
using System.Collections.Generic;
using System.Collections.ObjectModel;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using Tango.Core.Commands;
using Tango.BL.Entities;
using Tango.MachineStudio.Common.Notifications;
using Tango.SharedUI;
using Tango.BL;
using Tango.SharedUI.Components;

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

        private ObservablesEntitiesAdapter _adapter;
        public ObservablesEntitiesAdapter Adapter
        {
            get { return _adapter; }
            set { _adapter = value; RaisePropertyChangedAuto(); }
        }

        private SelectedObjectCollection<HardwareMotorType> _motorTypes;
        public SelectedObjectCollection<HardwareMotorType> MotorTypes
        {
            get { return _motorTypes; }
            set { _motorTypes = value; RaisePropertyChangedAuto(); }
        }

        private ObservableCollection<HardwareMotorType> _selectedMotorTypes;
        public ObservableCollection<HardwareMotorType> SelectedMotorTypes
        {
            get { return _selectedMotorTypes; }
            set { _selectedMotorTypes = value; RaisePropertyChangedAuto(); }
        }

        private SelectedObjectCollection<HardwareDancerType> _dancerTypes;
        public SelectedObjectCollection<HardwareDancerType> DancerTypes
        {
            get { return _dancerTypes; }
            set { _dancerTypes = value; RaisePropertyChangedAuto(); }
        }

        private ObservableCollection<HardwareDancerType> _selectedDancerTypes;
        public ObservableCollection<HardwareDancerType> SelectedDancerTypes
        {
            get { return _selectedDancerTypes; }
            set { _selectedDancerTypes = value; RaisePropertyChangedAuto(); }
        }

        private SelectedObjectCollection<HardwarePidControlType> _pidControlTypes;
        public SelectedObjectCollection<HardwarePidControlType> PidControlTypes
        {
            get { return _pidControlTypes; }
            set { _pidControlTypes = value; RaisePropertyChangedAuto(); }
        }

        private ObservableCollection<HardwarePidControlType> _selectedPidControlTypes;
        public ObservableCollection<HardwarePidControlType> SelectedPidControlTypes
        {
            get { return _selectedPidControlTypes; }
            set { _selectedPidControlTypes = value; RaisePropertyChangedAuto(); }
        }

        private SelectedObjectCollection<HardwareWinderType> _winderTypes;
        public SelectedObjectCollection<HardwareWinderType> WinderTypes
        {
            get { return _winderTypes; }
            set { _winderTypes = value; RaisePropertyChangedAuto(); }
        }

        private ObservableCollection<HardwareWinderType> _selectedWinderTypes;
        public ObservableCollection<HardwareWinderType> SelectedWinderTypes
        {
            get { return _selectedWinderTypes; }
            set { _selectedWinderTypes = value; RaisePropertyChangedAuto(); }
        }

        private HardwareVersion _selectedVersion;
        public HardwareVersion SelectedVersion
        {
            get { return _selectedVersion; }
            set { _selectedVersion = value; RaisePropertyChangedAuto(); OnSelectedVersionChanged(); }
        }

        private HardwareVersion _currentVersion;
        public HardwareVersion CurrentVersion
        {
            get { return _currentVersion; }
            set { _currentVersion = value; RaisePropertyChangedAuto(); InvalidateRelayCommands(); }
        }

        private IObservableEntity _selectedHardwareObject;
        public IObservableEntity SelectedHardwareObject
        {
            get { return _selectedHardwareObject; }
            set
            {
                _selectedHardwareObject = null;
                RaisePropertyChangedAuto();
                _selectedHardwareObject = value;
                RaisePropertyChangedAuto();
            }
        }

        private Object _selectedHardwareObjectType;
        public Object SelectedHardwareObjectType
        {
            get { return _selectedHardwareObjectType; }
            set
            {
                _selectedHardwareObjectType = null;
                RaisePropertyChangedAuto();
                _selectedHardwareObjectType = value;
                RaisePropertyChangedAuto();
                OnSelectedHardwareObjectTypeChanged();
            }
        }

        public RelayCommand SaveCommand { get; set; }

        public RelayCommand DeleteCommand { get; set; }

        public RelayCommand NewCommand { get; set; }

        public MainViewVM(INotificationProvider notification)
        {
            _notification = notification;

            Adapter = ObservablesEntitiesAdapter.Instance;
            SaveCommand = new RelayCommand(Save, () => CurrentVersion != null);
            NewCommand = new RelayCommand(New);
            DeleteCommand = new RelayCommand(Delete, () => !_isNew && CurrentVersion != null);

            CurrentVersion = new HardwareVersion();
            CreateTemplate(CurrentVersion);
        }

        private void OnSelectedHardwareObjectTypeChanged()
        {
            if (SelectedHardwareObjectType != null)
            {
                if (SelectedHardwareObjectType is SelectedObject<HardwareMotorType>)
                {
                    var type = (SelectedHardwareObjectType as SelectedObject<HardwareMotorType>).Data;
                    var hardwareObj = CurrentVersion.HardwareMotors.SingleOrDefault(x => x.HardwareMotorType == type);

                    if (hardwareObj != null)
                    {
                        SelectedHardwareObject = hardwareObj;
                    }
                    else
                    {
                        hardwareObj = new HardwareMotor() { HardwareMotorType = type };
                        CurrentVersion.HardwareMotors.Add(hardwareObj);
                        SelectedHardwareObject = hardwareObj;
                    }
                }
                else if (SelectedHardwareObjectType is SelectedObject<HardwareDancerType>)
                {
                    var type = (SelectedHardwareObjectType as SelectedObject<HardwareDancerType>).Data;
                    var hardwareObj = CurrentVersion.HardwareDancers.SingleOrDefault(x => x.HardwareDancerType == type);

                    if (hardwareObj != null)
                    {
                        SelectedHardwareObject = hardwareObj;
                    }
                    else
                    {
                        hardwareObj = new HardwareDancer() { HardwareDancerType = type };
                        CurrentVersion.HardwareDancers.Add(hardwareObj);
                        SelectedHardwareObject = hardwareObj;
                    }
                }
                else if (SelectedHardwareObjectType is SelectedObject<HardwarePidControlType>)
                {
                    var type = (SelectedHardwareObjectType as SelectedObject<HardwarePidControlType>).Data;
                    var hardwareObj = CurrentVersion.HardwarePidControls.SingleOrDefault(x => x.HardwarePidControlType == type);

                    if (hardwareObj != null)
                    {
                        SelectedHardwareObject = hardwareObj;
                    }
                    else
                    {
                        hardwareObj = new HardwarePidControl() { HardwarePidControlType = type };
                        CurrentVersion.HardwarePidControls.Add(hardwareObj);
                        SelectedHardwareObject = hardwareObj;
                    }
                }
                else if (SelectedHardwareObjectType is SelectedObject<HardwareWinderType>)
                {
                    var type = (SelectedHardwareObjectType as SelectedObject<HardwareWinderType>).Data;
                    var hardwareObj = CurrentVersion.HardwareWinders.SingleOrDefault(x => x.HardwareWinderType == type);

                    if (hardwareObj != null)
                    {
                        SelectedHardwareObject = hardwareObj;
                    }
                    else
                    {
                        hardwareObj = new HardwareWinder() { HardwareWinderType = type };
                        CurrentVersion.HardwareWinders.Add(hardwareObj);
                        SelectedHardwareObject = hardwareObj;
                    }
                }
            }
        }

        private void CreateTemplate(HardwareVersion version)
        {
            if (version == null)
            {
                SelectedMotorTypes = new ObservableCollection<HardwareMotorType>();
                SelectedDancerTypes = new ObservableCollection<HardwareDancerType>();
                SelectedPidControlTypes = new ObservableCollection<HardwarePidControlType>();
                SelectedWinderTypes = new ObservableCollection<HardwareWinderType>();
            }
            else
            {
                SelectedMotorTypes = version.HardwareMotors.Select(x => x.HardwareMotorType).ToObservableCollection();
                SelectedDancerTypes = version.HardwareDancers.Select(x => x.HardwareDancerType).ToObservableCollection();
                SelectedPidControlTypes = version.HardwarePidControls.Select(x => x.HardwarePidControlType).ToObservableCollection();
                SelectedWinderTypes = version.HardwareWinders.Select(x => x.HardwareWinderType).ToObservableCollection();
            }

            MotorTypes = new SelectedObjectCollection<HardwareMotorType>(Adapter.HardwareMotorTypes, SelectedMotorTypes);
            DancerTypes = new SelectedObjectCollection<HardwareDancerType>(Adapter.HardwareDancerTypes, SelectedDancerTypes);
            PidControlTypes = new SelectedObjectCollection<HardwarePidControlType>(Adapter.HardwarePidControlTypes, SelectedPidControlTypes);
            WinderTypes = new SelectedObjectCollection<HardwareWinderType>(Adapter.HardwareWinderTypes, SelectedWinderTypes);
        }

        private void OnSelectedVersionChanged()
        {
            if (SelectedVersion != null)
            {
                _isNew = false;
                CurrentVersion = SelectedVersion.Clone();
                CreateTemplate(CurrentVersion);
            }

            InvalidateRelayCommands();
        }

        private bool CheckCurrentVersionNull()
        {
            if (CurrentVersion == null)
            {
                _notification.ShowInfo("Please select a hardware version before attempting to insert any components.");
                return true;
            }

            return false;
        }

        private void New()
        {
            String name = _notification.ShowTextInput("Enter hardware version name", "Name");

            if (!String.IsNullOrWhiteSpace(name))
            {
                SelectedVersion = null;
                CurrentVersion = new HardwareVersion();
                CurrentVersion.Version = Adapter.HardwareVersions.Max(x => x.Version) + 1;
                CurrentVersion.Name = name;
                CreateTemplate(CurrentVersion);
                _isNew = true;
                InvalidateRelayCommands();
            }
        }

        private async void Save()
        {
            if (CurrentVersion != null)
            {
                using (_notification.PushTaskItem("Saving hardware version..."))
                {
                    HardwareVersion realVersion = null;

                    if (_isNew)
                    {
                        realVersion = CurrentVersion.Clone();

                        realVersion.HardwareMotors.ToList().Where(x => !SelectedMotorTypes.Contains(x.HardwareMotorType)).ToList().ForEach(x => realVersion.HardwareMotors.Remove(x));
                        realVersion.HardwareDancers.ToList().Where(x => !SelectedDancerTypes.Contains(x.HardwareDancerType)).ToList().ForEach(x => realVersion.HardwareDancers.Remove(x));
                        realVersion.HardwarePidControls.ToList().Where(x => !SelectedPidControlTypes.Contains(x.HardwarePidControlType)).ToList().ForEach(x => realVersion.HardwarePidControls.Remove(x));
                        realVersion.HardwareWinders.ToList().Where(x => !SelectedWinderTypes.Contains(x.HardwareWinderType)).ToList().ForEach(x => realVersion.HardwareWinders.Remove(x));
                    }
                    else
                    {
                        realVersion = Adapter.HardwareVersions.SingleOrDefault(x => x.Guid == SelectedVersion.Guid);

                        realVersion.Version = CurrentVersion.Version;
                        realVersion.Name = CurrentVersion.Name;
                        realVersion.HardwareDancers.ToList().ForEach(x => x.DefferedDelete(Adapter.Context));
                        realVersion.HardwareMotors.ToList().ForEach(x => x.DefferedDelete(Adapter.Context));
                        realVersion.HardwarePidControls.ToList().ForEach(x => x.DefferedDelete(Adapter.Context));
                        realVersion.HardwareWinders.ToList().ForEach(x => x.DefferedDelete(Adapter.Context));

                        realVersion.HardwareDancers.Clear();
                        realVersion.HardwareMotors.Clear();
                        realVersion.HardwarePidControls.Clear();
                        realVersion.HardwareWinders.Clear();

                        foreach (var type in SelectedDancerTypes)
                        {
                            var item = CurrentVersion.HardwareDancers.SingleOrDefault(x => x.HardwareDancerType == type);
                            if (item != null)
                            {
                                item.HardwareVersionGuid = realVersion.Guid;
                                realVersion.HardwareDancers.Add(item);
                            }
                            else
                            {
                                realVersion.HardwareDancers.Add(new HardwareDancer()
                                {
                                    HardwareVersionGuid = realVersion.Guid,
                                    HardwareDancerType = type
                                });
                            }
                        }

                        foreach (var type in SelectedMotorTypes)
                        {
                            var item = CurrentVersion.HardwareMotors.SingleOrDefault(x => x.HardwareMotorType == type);
                            if (item != null)
                            {
                                item.HardwareVersionGuid = realVersion.Guid;
                                realVersion.HardwareMotors.Add(item);
                            }
                            else
                            {
                                realVersion.HardwareMotors.Add(new HardwareMotor()
                                {
                                    HardwareVersionGuid = realVersion.Guid,
                                    HardwareMotorType = type
                                });
                            }
                        }

                        foreach (var type in SelectedPidControlTypes)
                        {
                            var item = CurrentVersion.HardwarePidControls.SingleOrDefault(x => x.HardwarePidControlType == type);
                            if (item != null)
                            {
                                item.HardwareVersionGuid = realVersion.Guid;
                                realVersion.HardwarePidControls.Add(item);
                            }
                            else
                            {
                                realVersion.HardwarePidControls.Add(new HardwarePidControl()
                                {
                                    HardwareVersionGuid = realVersion.Guid,
                                    HardwarePidControlType = type
                                });
                            }
                        }

                        foreach (var type in SelectedWinderTypes)
                        {
                            var item = CurrentVersion.HardwareWinders.SingleOrDefault(x => x.HardwareWinderType == type);
                            if (item != null)
                            {
                                item.HardwareVersionGuid = realVersion.Guid;
                                realVersion.HardwareWinders.Add(item);
                            }
                            else
                            {
                                realVersion.HardwareWinders.Add(new HardwareWinder()
                                {
                                    HardwareVersionGuid = realVersion.Guid,
                                    HardwareWinderType = type
                                });
                            }
                        }
                    }



                    if (_isNew)
                    {
                        Adapter.Context.HardwareVersions.Add(realVersion);
                    }

                    await realVersion.SaveAsync(Adapter.Context);

                    SelectedVersion = Adapter.HardwareVersions.SingleOrDefault(x => x.Guid == realVersion.Guid);
                }
            }
        }

        private void Delete()
        {
            if (_notification.ShowQuestion("Are you sure you want to delete this hardware version?"))
            {
                using (_notification.PushTaskItem("Deleting hardware version..."))
                {
                    SelectedVersion.DeleteAsync(Adapter.Context);
                    SelectedVersion = null;
                    CurrentVersion = null;
                }
            }
        }
    }
}