GES_PAC

using GES_PAC.Model;

using GES_PAC.View;

using Microsoft.EntityFrameworkCore;

using System.Collections.ObjectModel;

using System.Windows.Input;

namespace GES_PAC.ViewModel

{

    [QueryProperty(nameof(PhaseName), "phase")]

    public class CreateCalibrationViewModel : BaseViewModel

    {

        #region Attributs

        public string _phaseName;

        private ObservableCollection<TypeCalibration> _typeCalibrations;

        private TypeCalibration _selectedType;

        private double? _conc_o2;

        private double? _conc_co2;

        private double? _conc_ch4;

        private string _refBouteille;

        private bool _isRefBouteilleVisible;

        private Calibration _lastCalibration;

        private bool _hasLastMeasure;

        private double? _lastO2;

        private double? _lastCO2;

        private double? _lastCH4;

        private bool _isFormValid;

        #endregion

        #region Commandes

        public ICommand CreateCalibrationCommand { get; }

        #endregion

        #region Propriétés

        public PhaseCalibration Phase { get; private set; }

        public string PhaseName

        {

            get => _phaseName;

            set

            {

                if (_phaseName == value) return;

                _phaseName = value;

                Phase = PhaseCalibration.All.FirstOrDefault(p => p.Name == value) ?? PhaseCalibration.DEBUT;

                OnPropertyChanged();

                OnPhaseChanged();

            }

        }

        public ObservableCollection<TypeCalibration> TypeCalibrations

        {

            get => _typeCalibrations;

            set

            {

                _typeCalibrations = value;

                OnPropertyChanged();

            }

        }

        public TypeCalibration SelectedType

        {

            get => _selectedType;

            set

            {

                _selectedType = value;

                IsRefBouteilleVisible = _selectedType != TypeCalibration.AIR;

                OnPropertyChanged();

                OnTypeChanged();

                ValidateForm();

            }

        }

        public double? ConcO2

        {

            get => _conc_o2;

            set

            {

                _conc_o2 = value;

                OnPropertyChanged();

                ValidateForm();

            }

        }

        public double? ConcCO2

        {

            get => _conc_co2;

            set

            {

                _conc_co2 = value;

                OnPropertyChanged();

                ValidateForm();

            }

        }

        public double? ConcCH4

        {

            get => _conc_ch4;

            set

            {

                _conc_ch4 = value;

                OnPropertyChanged();

                ValidateForm();

            }

        }

        public string RefBouteille

        {

            get => _refBouteille;

            set

            {

                _refBouteille = value;

                OnPropertyChanged();

                ValidateForm();

            }

        }

        public bool IsRefBouteilleVisible

        {

            get => _isRefBouteilleVisible;

            set

            {

                _isRefBouteilleVisible = value;

                OnPropertyChanged();

            }

        }

        public Calibration LastCalibration

        {

            get => _lastCalibration;

            set

            {

                _lastCalibration = value;

                OnPropertyChanged();

            }

        }

        public bool HasLastMeasure

        {

            get => _hasLastMeasure;

            set

            {

                _hasLastMeasure = value;

                OnPropertyChanged();

            }

        }

        public double? LastO2

        {

            get => _lastO2;

            set

            {

                _lastO2 = value;

                OnPropertyChanged();

            }

        }

        public double? LastCO2

        {

            get => _lastCO2;

            set

            {

                _lastCO2 = value;

                OnPropertyChanged();

            }

        }

        public double? LastCH4

        {

            get => _lastCH4;

            set

            {

                _lastCH4 = value;

                OnPropertyChanged();

            }

        }

        public bool IsFormValid

        {

            get => _isFormValid;

            set

            {

                _isFormValid = value;

                OnPropertyChanged();

            }

        }

        public bool TypeError { get; private set; } = true;

        public bool ConcO2Error { get; private set; } = true;

        public bool ConcCO2Error { get; private set; } = true;

        public bool ConcCH4Error { get; private set; } = true;

        public bool RefBouteilleError { get; private set; } = true;

        #endregion

        #region Constructeurs

        public CreateCalibrationViewModel()

        {

            CreateCalibrationCommand = new Command(async () => await CreateCalibration());

        }

        #endregion

        #region Méthodes

        public void OnPhaseChanged()

        {

            var journeeActuelle = JourneeViewModel.Instance.GetCurrentDay();

            var typesManquants = journeeActuelle.GetMissingCalibrationByPhase(Phase);

            TypeCalibrations = new ObservableCollection<TypeCalibration>(typesManquants);

            SelectedType = TypeCalibrations[0];

            if (Phase == PhaseCalibration.FIN)

            {

                LastCalibration = journeeActuelle.GetDebutCalibration();

                HasLastMeasure = true;

                OnTypeChanged();

            }

        }

        private async Task CreateCalibration()

        {

            if (IsBusy) return;

            IsBusy = true;

            var journee = JourneeViewModel.Instance.GetCurrentDay();

            var date = DateTime.Now;

            var newCalib = new MesureCalibration(date, ConcO2 ?? 0, ConcCO2 ?? 0, ConcCH4 ?? 0, SelectedType, RefBouteille);

            var calibration = journee.Calibrations.FirstOrDefault(c => c.Phase == Phase);

            if (calibration == null)

            {

                calibration = new Calibration(Phase, newCalib);

                journee.AddCalibration(calibration);

                App.Db.Calibration.Add(calibration);

            }

            else

            {

                calibration.AddMesure(newCalib);

            }

            App.Db.MesureCalibration.Add(newCalib);

            await App.Db.SaveChangesAsync();

            var isComplete = calibration.IsComplete();

            var targetView = $"{nameof(CreateCalibrationView)}?phase={PhaseName}";

            if (isComplete) {

                targetView = Phase == PhaseCalibration.DEBUT ? nameof(SetListView) : nameof(MainView);

            }

            await Shell.Current.GoToAsync(targetView);

            IsBusy = false;

        }

        private void ValidateForm()

        {

            TypeError = SelectedType == null;

            ConcO2Error = ConcO2 == null;

            ConcCO2Error = ConcCO2 == null;

            ConcCH4Error = ConcCH4 == null;

            RefBouteilleError = IsRefBouteilleVisible && (RefBouteille == null || RefBouteille.Length < 5);

            OnPropertyChanged(nameof(TypeError));

            OnPropertyChanged(nameof(ConcO2Error));

            OnPropertyChanged(nameof(ConcCO2Error));

            OnPropertyChanged(nameof(ConcCH4Error));

            OnPropertyChanged(nameof(RefBouteilleError));

            IsFormValid = !TypeError && !ConcO2Error && !ConcCO2Error && !ConcCH4Error && !RefBouteilleError;

            (CreateCalibrationCommand as Command)?.ChangeCanExecute();

        }

        private void OnTypeChanged()

        {

            if (!HasLastMeasure)

                return;

            var mesureCalibration = LastCalibration.getMesureCalibrationByType(SelectedType);

            LastCH4 = mesureCalibration.Conc_CH4;

            LastO2 = mesureCalibration.Conc_O2;

            LastCO2 = mesureCalibration.Conc_CO2;

        }

        #endregion

    }

}