Jugenddienst-Stunden/Jugenddienst Stunden/ViewModels/StundeViewModel.cs

using CommunityToolkit.Mvvm.ComponentModel;
using CommunityToolkit.Mvvm.Input;
using Jugenddienst_Stunden.Types;
using System.Collections.ObjectModel;
using System.Windows.Input;
using static System.Runtime.InteropServices.JavaScript.JSType;

namespace Jugenddienst_Stunden.ViewModels;
internal class StundeViewModel : ObservableObject, IQueryAttributable
{

    public int id { get; set; }

    public string SubTitle { get; set; } = DateTime.Today.ToString("dddd, d. MMMM yyyy");

    private Settings _settings;
    public Settings Settings
    {
        get => _settings; set
        {
            if (_settings != value)
            {
                _settings = value;
            }
        }
    }

    private DayTime _stunde;
    public DayTime Stunde
    {
        get => _stunde;
        set
        {
            if (_stunde != value)
            {
                _stunde = value;
                OnPropertyChanged(nameof(Stunde));
            }
        }
    }

    public string Title { get; set; } = "Eintrag bearbeiten";

    public event EventHandler<string> AlertEvent;
    public event EventHandler<string> InfoEvent;
    public event Func<string, string, Task<bool>> ConfirmEvent;


    public ObservableCollection<Gemeinde> OptionsGemeinde { get; private set; }
    public ObservableCollection<Projekt> OptionsProjekt { get; private set; }
    public ObservableCollection<Freistellung> OptionsFreistellung { get; private set; }
    public ObservableCollection<DayTime> DayTimes { get; set; }

    //private Gemeinde _selectedGemeinde;
    public Gemeinde SelectedOptionGemeinde
    {
        get => _stunde.GemeindeAktiv;
        set
        {
            if (_stunde.GemeindeAktiv != value)
            {
                //_selectedGemeinde = value;
                _stunde.GemeindeAktiv = value;
                OnPropertyChanged(nameof(SelectedOptionGemeinde));
            }
        }
    }

    //private Projekt _selectedProjekt;
    public Projekt SelectedOptionProjekt
    {
        get => _stunde.ProjektAktiv;
        set
        {
            if (_stunde.ProjektAktiv != value)
            {
                //_selectedProjekt = value;
                _stunde.ProjektAktiv = value;
                OnPropertyChanged(nameof(SelectedOptionProjekt));
            }
        }
    }

    //private Freistellung _selectedFreistellung;
    public Freistellung SelectedOptionFreistellung
    {
        get => _stunde.FreistellungAktiv;
        set
        {
            if (_stunde.FreistellungAktiv != value)
            {
                _stunde.FreistellungAktiv = value;
                OnPropertyChanged(nameof(SelectedOptionFreistellung));
            }
        }
    }




    public ICommand SaveCommand { get; private set; }
    public ICommand DeleteCommand { get; private set; }
    public ICommand DeleteConfirmCommand { get; private set; }
    //public ICommand LoadDataCommand { get; private set; }


    public StundeViewModel()
    {
        _stunde = new DayTime();

        SaveCommand = new AsyncRelayCommand(Save);
        //DeleteCommand = new AsyncRelayCommand(Delete);
        DeleteConfirmCommand = new Command(async () => await DeleteConfirm());

    }

    public StundeViewModel(DayTime stunde)
    {
        _stunde = stunde;

        SaveCommand = new AsyncRelayCommand(Save);
        DeleteConfirmCommand = new AsyncRelayCommand(DeleteConfirm);
    }

    private async Task LoadData()
    {
        try
        {
            Hours _hours = await Models.Stunde.LoadBasicData();
            OptionsProjekt = new ObservableCollection<Projekt>(_hours.Projekte);
            OptionsGemeinde = new ObservableCollection<Gemeinde>(_hours.Gemeinden);
            OptionsFreistellung = new ObservableCollection<Freistellung>(_hours.Freistellungen);
            OnPropertyChanged(nameof(OptionsGemeinde));
            OnPropertyChanged(nameof(OptionsProjekt));
            OnPropertyChanged(nameof(OptionsFreistellung));
            _stunde.EmployeeId = _hours.EmployeeId;
        }
        catch (Exception e)
        {
            AlertEvent?.Invoke(this, e.Message);
        }
    }

    async Task Save()
    {
        bool exceptionOccurred = false;
        try
        {
            await Models.Stunde.SaveEntry(_stunde);
        }
        catch (Exception e)
        {
            AlertEvent?.Invoke(this, e.Message);
            exceptionOccurred = true;
        }
        if (!exceptionOccurred)
        {
            if (_stunde.id != null)
            {
                await Shell.Current.GoToAsync($"..?saved={_stunde.id}");
            }
            else
            {
                await Shell.Current.GoToAsync($"..?date={_stunde.day.ToString("yyyy-MM-dd")}");
            }
        }
    }

    private async Task Delete()
    {
        await Models.Stunde.DeleteEntry(_stunde);
        await Shell.Current.GoToAsync($"..?date={_stunde.day.ToString("yyyy-MM-dd")}");
    }

    private async Task DeleteConfirm()
    {
        if (ConfirmEvent != null)
        {
            bool answer = await ConfirmEvent.Invoke("Achtung", "Löschen kann nicht ungeschehen gemacht werden. Fortfahren?");
            if (answer)
            {
                //Löschen
                await Models.Stunde.DeleteEntry(_stunde);
                await Shell.Current.GoToAsync($"..?date={_stunde.day.ToString("yyyy-MM-dd")}");
            }
            else
            { //nicht Löschen
            }
        }

    }


    private async Task LoadSettings()
    {
        Settings = await Models.Stunde.LoadSettings();
    }

    /// <summary>
    /// Anwenden der Query-Parameter
    /// </summary>
    async void IQueryAttributable.ApplyQueryAttributes(IDictionary<string, object> query)
    {
        await LoadSettings();
        var probe = query;
        if (query.ContainsKey("load"))
        {

            //DateTime heute = DateTime.Now;
            Stunde = await Models.Stunde.LoadEntry(Convert.ToInt32(query["load"]));
            if (System.String.IsNullOrEmpty(Stunde.description))
            {
                AlertEvent?.Invoke(this, "Eintrag hat keine Daten zurückgegeben");
            }
            SubTitle = Stunde.day.ToString("dddd, d. MMMM yyyy");

            OptionsProjekt = new ObservableCollection<Projekt>(Stunde.Projekte);
            OptionsGemeinde = new ObservableCollection<Gemeinde>(Stunde.Gemeinden);
            OptionsFreistellung = new ObservableCollection<Freistellung>(Stunde.Freistellungen);
            OnPropertyChanged(nameof(OptionsGemeinde));
            OnPropertyChanged(nameof(OptionsProjekt));
            OnPropertyChanged(nameof(OptionsFreistellung));

            //OptionsProjekt.FirstOrDefault(x => x.Id == _stunde.projekt);

            SelectedOptionGemeinde = OptionsGemeinde.FirstOrDefault(item => item.Id == Stunde.gemeinde) ?? new Gemeinde();
            OnPropertyChanged(nameof(SelectedOptionGemeinde));

            SelectedOptionProjekt = OptionsProjekt.FirstOrDefault(Projekt => Projekt.Id == Stunde.projekt) ?? new Projekt();
            OnPropertyChanged(nameof(SelectedOptionProjekt));

            SelectedOptionFreistellung = OptionsFreistellung.FirstOrDefault(Freistellung => Freistellung.Id == Stunde.free) ?? new Freistellung();
            OnPropertyChanged(nameof(SelectedOptionFreistellung));


            OnPropertyChanged(nameof(SubTitle));

        }
        if (query.ContainsKey("date"))
        {
            Title = "Neuer Eintrag";

            DateTime _date = DateTime.ParseExact((string)query["date"], "yyyy-MM-dd", System.Globalization.CultureInfo.InvariantCulture);

            //Bei neuem Eintrag die vorhandenen des gleichen Tages anzeigen
            try
            {
                DayTimes = await Models.Stunde.LoadDay(_date);
            }
            catch (Exception)
            {
                //Ein Tag ohne Einträge gibt eine Fehlermeldung,
                //die soll aber ignoriert werden, weil beim Neueintrag ist das ja Wurscht
            }

            _stunde.day = _date;
            SubTitle = _date.ToString("dddd, d. MMMM yyyy");

            _ = LoadData();
            OnPropertyChanged(nameof(Title));
            OnPropertyChanged(nameof(SubTitle));
            OnPropertyChanged(nameof(DayTimes));
        }

    }


}