Jugenddienst-Stunden/Jugenddienst Stunden/ViewModels/StundenViewModel.cs

using CommunityToolkit.Mvvm.ComponentModel;
using CommunityToolkit.Mvvm.Input;
using Jugenddienst_Stunden.Types;
using Newtonsoft.Json.Linq;
using System.Collections.ObjectModel;
using System.ComponentModel;
using System.Runtime.CompilerServices;
using System.Windows.Input;


namespace Jugenddienst_Stunden.ViewModels;
internal class StundenViewModel : ObservableObject, IQueryAttributable, INotifyPropertyChanged {
	public string Name => AppInfo.Name;
	public string Surname => AppInfo.VersionString;
	public string MoreInfoUrl => "https://aka.ms/maui";
	public string Message => "Hier werden deine geleisteten Arbeitsstunden aufgelistet";
	public string LoadOverview => "Lade Summen für " + DateTime.Today.ToString("MMMM");
	//public static DateTime GetDay = DateTime.Today;
	//public string ShowDay => "Zeit an Tag " + GetDay.ToString("ddd d. MMM") + ": ";

	public ICommand NewEntryCommand { get; }
	public ICommand SelectEntryCommand { get; }
	public ICommand LoadDataCommand { get; private set; }
	public ICommand LoadDayCommand { get; private set; }
	public ICommand RefreshListCommand { get; }
    public ICommand RefreshCommand { get; }

    public event EventHandler<string> AlertEvent;
	public event EventHandler<string> InfoEvent;

    private bool isRefreshing;
    public bool IsRefreshing {
        get => isRefreshing;
        set {
            if (isRefreshing != value) {
                isRefreshing = value;
                OnPropertyChanged();
            }
        }
    }

    private string _title = Preferences.Default.Get("name", "") + " " + Preferences.Default.Get("surname", "");
	public string Title {
		get => _title;
		set => SetProperty(ref _title, value);
	}

	private Hours _hour;
	public Hours Hours {
		get => _hour;
	}

	/// <summary>
	/// Gesamtstunden an einem Tag
	/// </summary>
	public TimeOnly DayTotal { get; set; }

	/// <summary>
	/// Liste der Tageszeiten
	/// </summary>
	private ObservableCollection<DayTime> _dayTimes = new ObservableCollection<DayTime>();
	public ObservableCollection<DayTime> DayTimes {
		get => _dayTimes;
		set => SetProperty(ref _dayTimes, value);
	}

	/// <summary>
	/// Mindest-Datum für den Datepicker
	/// </summary>
	public DateTime MinimumDate {
		get => DateTime.Today.AddDays(-365);
	}

	/// <summary>
	/// Höchst-Datum für den Datepicker
	/// </summary>
	public DateTime MaximumDate {
		get => DateTime.Today.AddDays(60);
	}

	/// <summary>
	/// Heutiges Datum, wenn das Datum geändert wird, wird auch der Tag geladen
	/// </summary>
	private DateTime dateToday = DateTime.Today;
	public DateTime DateToday {
		get => dateToday;
		set {
			if (dateToday != value) {
				dateToday = value;
				//GetDay = value;
				//OnPropertyChanged();
				Task.Run(() => LoadDay(value));
            }
		}
	}


	/// <summary>
	/// Monatsübersicht: Geleistete Stunden
	/// </summary>
	public string? ZeitCalculated {
		get => _hour.zeit_total;
	}

	/// <summary>
	/// Monatsübersicht: Sollstunden
	/// </summary>
	public string? Nominal {
		get => _hour.nominal;
	}

	/// <summary>
	/// Monatsübersicht: Differenz zwischen Soll und geleisteten Stunden
	/// </summary>
	public string? Overtime {
		get => _hour.overtime;
	}

	/// <summary>
	/// Monatsübersicht: Restüberstunden insgesamt
	/// </summary>
	public string OvertimeMonth {
		get => _hour.overtime_month;
	}

	/// <summary>
	/// Monatsübersicht: Resturlaub
	/// </summary>
	public string Holiday {
		get => _hour.holiday;
	}

	


	


	/// <summary>
	/// CTOR
	/// </summary>
	public StundenViewModel() {

		_hour = new Types.Hours();
		LoadDataCommand = new AsyncRelayCommand(LoadData);

		NewEntryCommand = new AsyncRelayCommand(NewEntryAsync);
		SelectEntryCommand = new AsyncRelayCommand<DayTime>(SelectEntryAsync);

		RefreshListCommand = new AsyncRelayCommand(RefreshList);

		Task task = LoadDay(DateTime.Today);

        RefreshCommand = new Command(async () => await RefreshItemsAsync());

    }


	/// <summary>
	/// Öffnet eine neue Stundeneingabe
	/// </summary>
	/// <returns></returns>
	private async Task NewEntryAsync() {
		//Hier muss das Datum übergeben werden
		//await Shell.Current.GoToAsync(nameof(Views.StundePage));
		await Shell.Current.GoToAsync($"{nameof(Views.StundePage)}?date={dateToday:yyyy-MM-dd}");
	}

	/// <summary>
	/// Öffnet eine bestehende Stundeneingabe
	/// </summary>
	/// <param name="entry"></param>
	/// <returns></returns>
	private async Task SelectEntryAsync(DayTime entry) {
		if (entry != null && entry.id != null) {
			//var navigationParameters = new Dictionary<string, object> { { "load", entry.id } };
			//await Shell.Current.GoToAsync($"{nameof(Views.StundePage)}", navigationParameters);
			await Shell.Current.GoToAsync($"{nameof(Views.StundePage)}?load={entry.id}");
		} else AlertEvent?.Invoke(this, "Auswahl enthält keine Daten");
	}

	private async Task RefreshList() {
		OnPropertyChanged(nameof(DayTimes));
	}

	/// <summary>
	/// Lädt die Monatssummen für die Übersicht
	/// </summary>
	/// <returns></returns>
	private async Task LoadData() {
		try {
			_hour = await Models.Stunde.LoadData();
			RefreshProperties();
		} catch (Exception e) {
			AlertEvent?.Invoke(this, e.Message);
		}
	}

	/// <summary>
	/// Lädt die Arbeitszeiten für einen Tag
	/// </summary>
	/// <param name="date"></param>
	/// <returns></returns>
	public async Task LoadDay(DateTime date) {
		DayTotal = new TimeOnly(0);

		try {
			DayTimes = await Models.Stunde.LoadDay(date);

			//TODO: Hier muss noch die Berechnung der Stunden erfolgen
			//Hier werden im Moment noch nur die eingetragenen Stunden gezählt
			//Auf der Website bekommt der Benutzer die berechneten Stunden angezeigt (Nachstunden außerhalb des Stundenplanes zählen mehr ...)

			TimeSpan span = TimeSpan.Zero;
			foreach (DayTime dt in DayTimes) {
				span += dt.end - dt.begin;
			}
			DayTotal = TimeOnly.FromTimeSpan(span);

		} catch (Exception e) {
			DayTimes = new ObservableCollection<DayTime>();
			//TODO: hier könnte auch ein Fehler kommen, dann wäre InfoEvent falsch.
			InfoEvent?.Invoke(this, e.Message);
		} finally {
			OnPropertyChanged(nameof(DayTotal));
			//OnPropertyChanged(nameof(DayTimes));
		}

	}


	async void IQueryAttributable.ApplyQueryAttributes(IDictionary<string, object> query) {
		if (query.ContainsKey("date")) {
			await LoadDay(Convert.ToDateTime(query["date"]));
		}
	}


    private async Task RefreshItemsAsync() {
        IsRefreshing = true;

        // Fügen Sie hier die Logik zum Aktualisieren der Daten hinzu
        //await Task.Delay(2000); // Simuliert eine Datenaktualisierung
        await LoadDay(DateToday);

        IsRefreshing = false;
    }

    /// <summary>
    /// Refreshes all properties
    /// </summary>
    private void RefreshProperties() {
		OnPropertyChanged(nameof(Nominal));
		OnPropertyChanged(nameof(Overtime));
		OnPropertyChanged(nameof(OvertimeMonth));
		OnPropertyChanged(nameof(ZeitCalculated));
		OnPropertyChanged(nameof(Holiday));
		OnPropertyChanged(nameof(Hours));
		OnPropertyChanged(nameof(Title));
		OnPropertyChanged(nameof(MinimumDate));
		OnPropertyChanged(nameof(MaximumDate));
	}

	protected void OnPropertyChanged([CallerMemberName] string propertyName = null) {
		try {
			base.OnPropertyChanged(new PropertyChangedEventArgs(propertyName));
		} catch (Exception ex) {
			AlertEvent?.Invoke(this, ex.Message);
			//Console.WriteLine($"Fehler bei OnPropertyChanged: {ex.Message}");  
		}
	}


}