using GalaSoft.MvvmLight.Ioc;
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.DAL.Observables;
using Tango.MachineStudio.Common.Notifications;
using Tango.MachineStudio.Common.StudioApplication;
using Tango.SharedUI;

namespace Tango.MachineStudio.Developer.ViewModels
{
    public class MainViewVM : ViewModel
    {
        private INotificationProvider _notification;

        public IStudioApplicationManager ApplicationManager { get; set; }

        public ObservablesEntitiesAdapter Adapter { get; set; }

        private Machine _selectedMachine;

        public Machine SelectedMachine
        {
            get { return _selectedMachine; }
            set { _selectedMachine = value; RaisePropertyChangedAuto(); OnMachineChanged(); InvalidateRelayCommands(); }
        }

        private List<LiquidTypesRml> _liquidTypesRmls;

        public List<LiquidTypesRml> LiquidTypesRmls
        {
            get { return _liquidTypesRmls; }
            set { _liquidTypesRmls = value; RaisePropertyChangedAuto(); }
        }

        private ProcessParametersTablesGroup _rmlProcessParametersTablesGroup;

        public ProcessParametersTablesGroup RmlProcessParametersTableGroup
        {
            get { return _rmlProcessParametersTablesGroup; }
            set { _rmlProcessParametersTablesGroup = value; RaisePropertyChangedAuto(); }
        }

        private ProcessParametersTablesGroup _selectedGroupHistory;

        public ProcessParametersTablesGroup SelectedGroupHistory
        {
            get { return _selectedGroupHistory; }
            set { _selectedGroupHistory = value; RaisePropertyChangedAuto(); OnSelectedGroupHistoryChanged(); }
        }

        private void OnSelectedGroupHistoryChanged()
        {
            if (SelectedGroupHistory != null)
            {
                RmlProcessParametersTableGroup = SelectedGroupHistory.CloneGroup();
            }
        }

        private ObservableCollection<ProcessParametersTablesGroup> _groupsHistory;

        public ObservableCollection<ProcessParametersTablesGroup> GroupsHistory
        {
            get { return _groupsHistory; }
            set { _groupsHistory = value; RaisePropertyChangedAuto(); }
        }

        private Job _selectedJob;

        public Job SelectedJob
        {
            get { return _selectedJob; }
            set { _selectedJob = value; RaisePropertyChangedAuto(); }
        }


        private Rml _selectedRML;

        public Rml SelectedRML
        {
            get { return _selectedRML; }
            set { _selectedRML = value; RaisePropertyChangedAuto(); InvalidateLiquidFactorsAndProcessTables(); InvalidateRelayCommands(); }
        }

        private bool _isSideBarOpened;

        public bool IsSideBarOpened
        {
            get { return _isSideBarOpened; }
            set { _isSideBarOpened = value; RaisePropertyChangedAuto(); }
        }


        public RelayCommand EditMachineCommand { get; set; }

        public RelayCommand EditRMLCommand { get; set; }

        public RelayCommand ToggleSideBarCommand { get; set; }

        public RelayCommand SaveProcessParametersCommand { get; set; }

        public RelayCommand SaveLiquidFactorsCommand { get; set; }

        public MainViewVM()
        {
            IsSideBarOpened = true;
        }

        [PreferredConstructor]
        public MainViewVM(IStudioApplicationManager applicationManager, INotificationProvider notificationProvider)
        {
            _notification = notificationProvider;
            Adapter = ObservablesEntitiesAdapter.Instance;
            EditMachineCommand = new RelayCommand(EditMachine, (x) => SelectedMachine != null);
            ApplicationManager = applicationManager;
            EditRMLCommand = new RelayCommand(EditRML, (x) => SelectedRML != null);
            ToggleSideBarCommand = new RelayCommand(() => IsSideBarOpened = !IsSideBarOpened);
            SaveProcessParametersCommand = new RelayCommand(SaveProcessParameters);
            SaveLiquidFactorsCommand = new RelayCommand(SaveLiquidFactors);
            IsSideBarOpened = true;
        }

        private async void SaveLiquidFactors()
        {
            if (SelectedRML != null)
            {
                using (_notification.PushTaskItem("Saving Liquid Factors..."))
                {
                    String machineGuid = SelectedMachine.Guid;
                    String rmlGuid = SelectedRML.Guid;

                    await SelectedRML.SaveAsync();

                    SelectedMachine = Adapter.Machines.SingleOrDefault(x => x.Guid == machineGuid);
                    SelectedRML = Adapter.Rmls.SingleOrDefault(x => x.Guid == rmlGuid);
                }
            }
        }

        private void EditRML()
        {
            ApplicationManager.RequestModule("Data Base", SelectedRML);
        }

        private void EditMachine()
        {
            ApplicationManager.RequestModule("Machine Designer", SelectedMachine);
        }

        private void OnMachineChanged()
        {
            InvalidateLiquidFactorsAndProcessTables();
        }

        private async void SaveProcessParameters()
        {
            var response = _notification.ShowTextInput("Enter Group Name", "Group Name");

            if (response == null) return;

            using (_notification.PushTaskItem("Saving Parameters Group..."))
            {
                ProcessParametersTablesGroup group = new ProcessParametersTablesGroup();

                List<ProcessParametersTable> tables = new List<ProcessParametersTable>();
                foreach (var table in RmlProcessParametersTableGroup.ProcessParametersTables)
                {
                    var newTable = table.CloneEntity();
                    newTable.ProcessParametersTablesGroups = group;
                    tables.Add(newTable);
                }

                group.Active = true;
                group.ProcessParametersTables = tables.ToObservableCollection();
                group.Rml = SelectedRML;
                group.Name = response;
                group.SaveDate = DateTime.UtcNow;

                foreach (var g in SelectedRML.ProcessParametersTablesGroups)
                {
                    g.Active = false;
                }

                String machineGuid = SelectedMachine.Guid;
                String rmlGuid = SelectedRML.Guid;

                SelectedRML.ProcessParametersTablesGroups.Add(group);
                await SelectedRML.SaveAsync();

                SelectedMachine = Adapter.Machines.SingleOrDefault(x => x.Guid == machineGuid);
                SelectedRML = Adapter.Rmls.SingleOrDefault(x => x.Guid == rmlGuid);
            }
        }

        private void InvalidateLiquidFactorsAndProcessTables()
        {
            if (SelectedRML != null && SelectedMachine != null)
            {
                LiquidTypesRmls = SelectedMachine.Configuration.IdsPacks.OrderBy(x => x.PackIndex).Select(x => x.LiquidTypes).SelectMany(x => x.LiquidTypesRmls).Where(x => x.Rml.Guid == SelectedRML.Guid).ToList();
                RmlProcessParametersTableGroup = SelectedRML.ProcessParametersTablesGroups.SingleOrDefault(x => x.Active);

                if (RmlProcessParametersTableGroup != null)
                {
                    RmlProcessParametersTableGroup = RmlProcessParametersTableGroup.CloneGroup();
                    RmlProcessParametersTableGroup.ProcessParametersTables = RmlProcessParametersTableGroup.ProcessParametersTables.OrderBy(x => x.TableIndex).ToObservableCollection();
                }

                GroupsHistory = SelectedRML.ProcessParametersTablesGroups.OrderByDescending(x => x.SaveDate).OrderBy(x => !x.Active).ToObservableCollection();
            }
        }
    }
}