using CommunityToolkit.Mvvm.ComponentModel;
using CommunityToolkit.Mvvm.Input;
using Jugenddienst_Stunden.Models;
using Jugenddienst_Stunden.Types;
using System.ComponentModel;
using System.Runtime.CompilerServices;
using System.Windows.Input;
using CommunityToolkit.Maui.Alerts;
using CommunityToolkit.Maui.Core;
using static System.Runtime.InteropServices.JavaScript.JSType;


namespace Jugenddienst_Stunden.ViewModels;
/// <summary>
/// ViewModel für die Stundenliste
/// </summary>
internal partial class StundenViewModel : ObservableObject, IQueryAttributable, INotifyPropertyChanged {

    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;


    /// <summary>
    /// Beschriftung Button Monatsübersicht
    /// </summary>
    [ObservableProperty]
    private string loadOverview;

    //private HoursBase HoursBase = new HoursBase();
    internal Settings Settings = new Settings();

    /// <summary>
    /// Zu leistende Stunden
    /// </summary>
    [ObservableProperty]
    private TimeOnly sollstunden;

    /// <summary>
    /// Geleistete Stunden an einem Tag
    /// </summary>
    [ObservableProperty]
    private TimeOnly dayTotal;

    /// <summary>
    /// Liste der Tageszeiten
    /// </summary>
    [ObservableProperty]
    private List<DayTime> dayTimes = new List<DayTime>();

    public string Title { get; set; } = GlobalVar.Name + " " + GlobalVar.Surname;

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

    /// <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;
                LoadOverview = "Lade Summen für " + dateToday.ToString("MMMM yy");
                //OnPropertyChanged();
                Task.Run(() => LoadDay(value));
            }
        }
    }

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

    /// <summary>
    /// Monatsübersicht: Sollstunden
    /// </summary>
    public int? Nominal {
        get => Hours.Nominal;
    }

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

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

    public int Zeitausgleich {
        get => Hours.zeitausgleich;
    }
    public int ZeitausgleichMonth {
        get => Hours.zeitausgleich_month;
    }

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

    /// <summary>
    /// Seite neu laden
    /// </summary>
    [ObservableProperty]
    private bool isRefreshing;


    /// <summary>
    /// Dürfen Gemeinden verwendet werden?
    /// </summary>
    public bool GemeindeAktivSet { get; set; }

    /// <summary>
    /// Dürfen Projekte verwendet werden?
    /// </summary>
    public bool ProjektAktivSet { get; set; }

    private bool doContinue = true;



    /// <summary>
    /// CTOR
    /// </summary>
    public StundenViewModel() {
        _hour = new Hours();

        LoadOverview = "Lade Summen für " + DateToday.ToString("MMMM");

        LoadDataCommand = new AsyncRelayCommand(LoadData);
        NewEntryCommand = new AsyncRelayCommand(NewEntryAsync);
        SelectEntryCommand = new AsyncRelayCommand<DayTime>(SelectEntryAsync);
        RefreshListCommand = new AsyncRelayCommand(RefreshList);
        RefreshCommand = new Command(async () => await RefreshItemsAsync());

        Task task = LoadDay(DateTime.Today);
    }


    /// <summary>
    /// Öffnet eine neue Stundeneingabe
    /// </summary>
    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>
    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>
    private async Task LoadData() {
        try {
            BaseResponse dat = await HoursBase.LoadBase("hours&year="+ DateToday.ToString("yyyy") + "&month=" + DateToday.ToString("MM"));
            _hour = dat.hour;

            if (dat.settings.Version != AppInfo.Current.VersionString) {
                InfoEvent?.Invoke(this, "Du solltest deine Programmversion: " + AppInfo.Current.VersionString + " auf Version: " + dat.settings.Version + " updaten");
            }
            //_hour = await HoursBase.LoadData();
            RefreshProperties();
        } catch (Exception e) {
            AlertEvent?.Invoke(this, e.Message);
        }
    }


    /// <summary>
    /// Lädt die Arbeitszeiten für einen Tag
    /// </summary>
    public async Task LoadDay(DateTime date) {
        DayTotal = new TimeOnly(0);
        Sollstunden = new TimeOnly(0);
        try {
            //_dayTimes = await HoursBase.LoadDay(date);
            BaseResponse dat = await HoursBase.LoadBase("date=" + date.ToString("yyyy-MM-dd"));

            DayTimes = dat.daytimes;
            Settings = dat.settings;
            GemeindeAktivSet = Settings.GemeindeAktivSet;
            ProjektAktivSet = Settings.ProjektAktivSet;

            OnPropertyChanged(nameof(GemeindeAktivSet));
            OnPropertyChanged(nameof(ProjektAktivSet));

            List<Sollstunden> _soll;
            TimeSpan span = TimeSpan.Zero;
            bool merker = false;
            foreach (DayTime dt in DayTimes) {
                span += dt.End - dt.Begin;
                //Nachtstunden dazurechnen
                if (dt.Night.Ticks > 0 && !merker) {
                    span += dt.Night.ToTimeSpan() * .5;
                    merker = true;
                }
                _soll = Settings.Nominal.Where(w => w.Timetable == dt.TimeTable && w.Wochentag == dt.Wday).ToList();
                if (_soll.Count > 0)
                    Sollstunden = TimeOnly.FromTimeSpan(TimeSpan.FromHours(_soll[0].Zeit));
            }
            DayTotal = TimeOnly.FromTimeSpan(span);

            //Nach der Tagessumme die anderen Tage anhängen
            if (DayTimes != null) {
                BaseResponse dat1 = await HoursBase.LoadBase("date=" + date.ToString("yyyy-MM-dd") + "&tilldate=" + date.AddDays(3).ToString("yyyy-MM-dd"));
                if (dat1.daytimes != null)
                    DayTimes = dat.daytimes.Concat(dat1.daytimes).ToList();
            }

        } catch (Exception e) {
            DayTimes = new List<DayTime>();
            //TODO: hier könnte auch ein Fehler kommen, dann wäre InfoEvent falsch.
            
            if (Settings.Version != AppInfo.Current.VersionString) {
                InfoEvent?.Invoke(this, "Du solltest deine Programmversion: " + AppInfo.Current.VersionString + " auf Version: " + Settings.Version + " updaten");
            } else { InfoEvent?.Invoke(this, e.Message); }
        } finally {
            OnPropertyChanged(nameof(DayTotal));
            OnPropertyChanged(nameof(Sollstunden));
            OnPropertyChanged(nameof(DateToday));
            OnPropertyChanged(nameof(LoadOverview));
            //OnPropertyChanged(nameof(DayTimes));
        }

    }

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

    /// <summary>
    /// Seite aktualisieren
    /// </summary>
    private async Task RefreshItemsAsync() {
        IsRefreshing = true;

        //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(Zeitausgleich));
        OnPropertyChanged(nameof(ZeitCalculated));
        OnPropertyChanged(nameof(Holiday));
        OnPropertyChanged(nameof(Hours));
        OnPropertyChanged(nameof(Title));
        OnPropertyChanged(nameof(MinimumDate));
        OnPropertyChanged(nameof(MaximumDate));
        OnPropertyChanged(nameof(LoadOverview));
    }

    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}");  
        }
    }


}