using CommunityToolkit.Mvvm.ComponentModel;
using CommunityToolkit.Mvvm.Input;
using LehrerApp.Core.Interfaces;
using LehrerApp.Core.Models;
using LehrerApp.Core.Services;
using System.Collections.ObjectModel;

namespace LehrerApp.Desktop.ViewModels.Groups;

// ── Gruppenliste ──────────────────────────────────────────────────────────────

public partial class GroupListViewModel : ObservableObject
{
    private readonly IGroupRepository _groups;
    private readonly SchoolYearService _sy;

    public Action<Guid, int>? OnNavigateToDetail { get; set; }
    public Func<Task>? OnAddGroup { get; set; }

    [ObservableProperty] private string _selectedSchoolYear = "";
    [ObservableProperty] private string _searchText = "";
    [ObservableProperty] private GroupListItem? _selectedGroup;

    public string SelectedGroupDisplayName => SelectedGroup?.DisplayName ?? "";
    public string SelectedGroupSubtitle => SelectedGroup?.Subtitle ?? "";

    public ObservableCollection<string> SchoolYears { get; } = [];
    public ObservableCollection<GroupListItem> Groups { get; } = [];

    public GroupListViewModel(IGroupRepository groups, SchoolYearService sy)
    {
        _groups = groups; _sy = sy;
        foreach (var y in sy.RecentSchoolYears()) SchoolYears.Add(y);
        SelectedSchoolYear = sy.CurrentSchoolYear();
    }

    partial void OnSelectedSchoolYearChanged(string value) => LoadGroups();
    partial void OnSearchTextChanged(string value)          => LoadGroups();
    partial void OnSelectedGroupChanged(GroupListItem? value)
    {
        OnPropertyChanged(nameof(SelectedGroupDisplayName));
        OnPropertyChanged(nameof(SelectedGroupSubtitle));
        NavigateToSectionCommand.NotifyCanExecuteChanged();
    }

    public void LoadGroups()
    {
        Groups.Clear();
        var all = _groups.GetBySchoolYear(SelectedSchoolYear);
        var filtered = string.IsNullOrWhiteSpace(SearchText) ? all
            : all.Where(g => g.Name.Contains(SearchText, StringComparison.OrdinalIgnoreCase)
                          || (g.Subject?.Contains(SearchText, StringComparison.OrdinalIgnoreCase) ?? false));
        foreach (var g in filtered.OrderBy(g => g.Name))
            Groups.Add(new GroupListItem(g));
    }

    [RelayCommand]
    private async Task AddGroup()
    {
        if (OnAddGroup is null) return;
        await OnAddGroup();
        LoadGroups();
    }
    [RelayCommand] private void Refresh()   => LoadGroups();

    [RelayCommand(CanExecute = nameof(HasSelectedGroup))]
    private void NavigateToSection(string? tabIndex)
    {
        if (SelectedGroup is null || !int.TryParse(tabIndex, out var tab)) return;
        OnNavigateToDetail?.Invoke(SelectedGroup.Id, tab);
    }

    private bool HasSelectedGroup() => SelectedGroup is not null;
}

public class GroupListItem
{
    public Guid Id { get; }
    public string Name { get; }
    public string Subject { get; }
    public string DisplayName { get; }
    public string TypeLabel { get; }
    public string GradingLabel { get; }
    public string Subtitle { get; }

    public GroupListItem(LearningGroup g)
    {
        Id           = g.Id;
        Name         = g.Name;
        Subject      = g.Subject ?? "";
        TypeLabel    = g.Type == GroupType.Class ? "Klasse" : "Kurs";
        GradingLabel = g.GradingSystem == GradingSystem.Grades1To6 ? "1–6" : "0–15";
        DisplayName  = string.IsNullOrEmpty(g.Subject) ? g.Name : $"{g.Name} · {g.Subject}";
        Subtitle     = $"{TypeLabel} · Stufe {g.GradeLevel} · Noten {GradingLabel} · {g.SchoolYear}";
    }
}

// ── Gruppendetail ─────────────────────────────────────────────────────────────

public partial class GroupDetailViewModel : ObservableObject
{
    private readonly IGroupRepository _groups;
    private readonly IStudentRepository _students;
    private readonly IEnrollmentRepository _enrollments;
    private readonly IExamRepository _exams;
    private readonly IGradeRepository _grades;

    [ObservableProperty] private LearningGroup? _group;
    [ObservableProperty] private string _groupTitle = "";
    [ObservableProperty] private string _groupSubtitle = "";
    [ObservableProperty] private int _studentCount;
    [ObservableProperty] private int _activeTabIndex = 0;
    [ObservableProperty] private StudentSummary? _selectedStudent;

    public ObservableCollection<StudentSummary> Students { get; } = [];
    public ObservableCollection<ExamSummary> Exams { get; } = [];

    public ParticipationTabViewModel ParticipationTab { get; }
    public Func<Task<bool>>? OnAddStudent { get; set; }

    public GroupDetailViewModel(IGroupRepository groups, IStudentRepository students,
        IEnrollmentRepository enrollments, IExamRepository exams, IGradeRepository grades,
        ParticipationTabViewModel participationTab)
    {
        _groups = groups; _students = students; _enrollments = enrollments;
        _exams = exams; _grades = grades;
        ParticipationTab = participationTab;
    }

    public void LoadGroup(Guid id)
    {
        Group = _groups.GetById(id);
        if (Group is null) return;
        GroupTitle    = Group.Name;
        GroupSubtitle = $"{Group.SchoolYear} · " +
                        $"{(Group.Type == GroupType.Class ? "Klasse" : "Kurs")} · " +
                        $"Stufe {Group.GradeLevel} · Noten {(Group.GradingSystem == GradingSystem.Grades1To6 ? "1–6" : "0–15")}";
        LoadStudents();
        Exams.Clear();
        foreach (var e in _exams.GetByGroup(Group.Id)) Exams.Add(new ExamSummary(e));
        ParticipationTab.Initialize(Group.Id, Group.SchoolYear);
    }

    public void LoadStudents()
    {
        if (Group is null) return;
        Students.Clear();
        var enrolled    = _students.GetByGroup(Group.Id, Group.SchoolYear);
        var enrollments = _enrollments.GetByGroupAndYear(Group.Id, Group.SchoolYear)
                          .ToDictionary(e => e.StudentId);
        StudentCount = enrolled.Count;
        foreach (var s in enrolled)
        {
            enrollments.TryGetValue(s.Id, out var enr);
            Students.Add(new StudentSummary(s, enr));
        }
    }

    [RelayCommand]
    private async Task AddStudent()
    {
        if (OnAddStudent is null) return;
        var confirmed = await OnAddStudent();
        if (confirmed)
        {
            LoadStudents();
            ParticipationTab.RefreshCurrentGrid();
        }
    }

    [RelayCommand(CanExecute = nameof(HasSelectedStudent))]
    private void RemoveStudent()
    {
        if (Group is null || SelectedStudent is null) return;
        var enrollment = _enrollments.GetByGroupAndYear(Group.Id, Group.SchoolYear)
            .FirstOrDefault(e => e.StudentId == SelectedStudent.Id);
        if (enrollment is null) return;
        _enrollments.Delete(enrollment.Id);
        LoadStudents();
        SelectedStudent = null;
        ParticipationTab.RefreshCurrentGrid();
    }

    partial void OnSelectedStudentChanged(StudentSummary? value) =>
        RemoveStudentCommand.NotifyCanExecuteChanged();

    private bool HasSelectedStudent() => SelectedStudent is not null;

    [RelayCommand] private void AddExam()  { /* TODO */ }
    [RelayCommand] private void Refresh()  { if (Group is not null) LoadGroup(Group.Id); }
}

public class StudentSummary
{
    public Guid   Id          { get; }
    public string FullName    { get; }
    public string PeriodLabel { get; }

    public StudentSummary(Core.Models.Student s, Enrollment? e)
    {
        Id     = s.Id;
        FullName = s.FullName;
        PeriodLabel = e?.Period switch
        {
            EnrollmentPeriod.H1Only => "H1",
            EnrollmentPeriod.H2Only => "H2",
            EnrollmentPeriod.Custom => BuildCustomLabel(e),
            _                       => "",
        };
    }

    private static string BuildCustomLabel(Enrollment e)
    {
        if (e.JoinedAt.HasValue && e.LeftAt.HasValue) return $"{e.JoinedAt:dd.MM.}–{e.LeftAt:dd.MM.}";
        if (e.JoinedAt.HasValue) return $"ab {e.JoinedAt:dd.MM.}";
        if (e.LeftAt.HasValue)   return $"bis {e.LeftAt:dd.MM.}";
        return "Datum";
    }
}

public class ExamSummary
{
    public Guid Id { get; }
    public string Title { get; }
    public string Date { get; }
    public string StatusLabel { get; }
    public ExamSummary(Core.Models.Exam e)
    {
        Id = e.Id; Title = e.Title; Date = e.Date.ToString("dd.MM.yyyy");
        StatusLabel = e.Status switch
        {
            ExamStatus.Planned   => "Geplant",
            ExamStatus.Conducted => "Durchgeführt",
            ExamStatus.Graded    => "Korrigiert",
            ExamStatus.Returned  => "Zurückgegeben",
            _ => "",
        };
    }
}

// ── Dialog: Schüler zur Gruppe hinzufügen ─────────────────────────────────────

public partial class AddStudentToGroupDialogViewModel : ObservableObject
{
    private readonly IStudentRepository    _students;
    private readonly IEnrollmentRepository _enrollments;
    private readonly Guid   _groupId;
    private readonly string _schoolYear;

    [ObservableProperty] private string            _searchText        = "";
    [ObservableProperty] private StudentPickerItem? _selectedStudent;
    [ObservableProperty] private string            _validationMessage  = "";
    [ObservableProperty] private EnrollmentPeriod  _period             = EnrollmentPeriod.FullYear;
    [ObservableProperty] private string            _joinedAtText       = "";
    [ObservableProperty] private string            _leftAtText         = "";

    public bool IsFullYear { get => Period == EnrollmentPeriod.FullYear; set { if (value) Period = EnrollmentPeriod.FullYear; } }
    public bool IsH1Only   { get => Period == EnrollmentPeriod.H1Only;   set { if (value) Period = EnrollmentPeriod.H1Only; } }
    public bool IsH2Only   { get => Period == EnrollmentPeriod.H2Only;   set { if (value) Period = EnrollmentPeriod.H2Only; } }
    public bool IsCustom   { get => Period == EnrollmentPeriod.Custom;   set { if (value) Period = EnrollmentPeriod.Custom; } }
    public bool IsCustomPeriod => Period == EnrollmentPeriod.Custom;

    public ObservableCollection<StudentPickerItem> AvailableStudents { get; } = [];
    public Enrollment? Result { get; private set; }

    public AddStudentToGroupDialogViewModel(IStudentRepository students,
        IEnrollmentRepository enrollments, Guid groupId, string schoolYear)
    {
        _students = students; _enrollments = enrollments;
        _groupId = groupId; _schoolYear = schoolYear;
        LoadAvailableStudents();
    }

    partial void OnPeriodChanged(EnrollmentPeriod value)
    {
        OnPropertyChanged(nameof(IsFullYear));
        OnPropertyChanged(nameof(IsH1Only));
        OnPropertyChanged(nameof(IsH2Only));
        OnPropertyChanged(nameof(IsCustom));
        OnPropertyChanged(nameof(IsCustomPeriod));
    }

    partial void OnSearchTextChanged(string value) => LoadAvailableStudents();

    private void LoadAvailableStudents()
    {
        var alreadyEnrolled = _enrollments.GetByGroupAndYear(_groupId, _schoolYear)
            .Select(e => e.StudentId).ToHashSet();
        var all = _students.GetAll();
        var available = all
            .Where(s => !alreadyEnrolled.Contains(s.Id))
            .Where(s => string.IsNullOrWhiteSpace(SearchText) ||
                        s.FullName.Contains(SearchText, StringComparison.OrdinalIgnoreCase));
        AvailableStudents.Clear();
        foreach (var s in available) AvailableStudents.Add(new StudentPickerItem(s));
    }

    [RelayCommand]
    private void Save()
    {
        if (SelectedStudent is null) { ValidationMessage = "Bitte einen Schüler auswählen."; return; }

        DateOnly? joinedAt = null, leftAt = null;
        if (Period == EnrollmentPeriod.Custom)
        {
            if (!string.IsNullOrWhiteSpace(JoinedAtText) &&
                DateOnly.TryParseExact(JoinedAtText, "dd.MM.yyyy",
                    null, System.Globalization.DateTimeStyles.None, out var j))
                joinedAt = j;
            if (!string.IsNullOrWhiteSpace(LeftAtText) &&
                DateOnly.TryParseExact(LeftAtText, "dd.MM.yyyy",
                    null, System.Globalization.DateTimeStyles.None, out var l))
                leftAt = l;
        }

        Result = new Enrollment
        {
            StudentId  = SelectedStudent.Id,
            GroupId    = _groupId,
            SchoolYear = _schoolYear,
            Period     = Period,
            JoinedAt   = joinedAt,
            LeftAt     = leftAt,
        };
        _enrollments.Save(Result);
    }
}

public class StudentPickerItem
{
    public Guid   Id       { get; }
    public string FullName { get; }
    public StudentPickerItem(Student s) { Id = s.Id; FullName = s.FullName; }
}

// ── Dialog: Neue Lerngruppe anlegen ──────────────────────────────────────────

public partial class AddGroupDialogViewModel : ObservableObject
{
    private readonly IGroupRepository   _groups;
    private readonly ISubjectRepository _subjects;
    private readonly SchoolYearService  _sy;
    private List<Subject> _allSubjects = [];

    public List<string> TypeOptions { get; } = ["Klasse", "Kurs"];
    [ObservableProperty] private string _selectedTypeName = "Kurs";

    public bool IsKurs       => SelectedTypeName == "Kurs";
    public string NameLabel  => IsKurs ? "Kursname *" : "Klassenname *";
    public string NameHint   => IsKurs ? "z.B. Q1, LK, GK" : "z.B. 10E, 5a, 11b";

    partial void OnSelectedTypeNameChanged(string value)
    {
        OnPropertyChanged(nameof(IsKurs));
        OnPropertyChanged(nameof(NameLabel));
        OnPropertyChanged(nameof(NameHint));
    }

    [ObservableProperty] private string _name = "";
    [ObservableProperty] private string _subject = "";
    [ObservableProperty] private int _gradeLevel = 10;
    [ObservableProperty] private GradingSystem _gradingSystem = GradingSystem.Grades1To6;
    [ObservableProperty] private string _selectedSchoolYear = "";
    [ObservableProperty] private string _validationMessage = "";

    public List<string> SchoolYears { get; }
    public List<string> KnownSubjectNames { get; private set; } = [];
    public LearningGroup? Result { get; private set; }

    public AddGroupDialogViewModel(IGroupRepository groups, ISubjectRepository subjects, SchoolYearService sy)
    {
        _groups = groups; _subjects = subjects; _sy = sy;
        _allSubjects      = subjects.GetAll();
        KnownSubjectNames = _allSubjects.Select(s => s.Name).ToList();
        SchoolYears       = sy.RecentSchoolYears(3);
        SelectedSchoolYear = sy.CurrentSchoolYear();
        PropertyChanged += (_, e) =>
        {
            if (e.PropertyName == nameof(GradeLevel))
                GradingSystem = GradeLevel >= 11 ? GradingSystem.Points0To15
                                                 : GradingSystem.Grades1To6;
        };
    }

    [RelayCommand]
    private void Save()
    {
        if (string.IsNullOrWhiteSpace(Name)) { ValidationMessage = "Bezeichnung erforderlich."; return; }
        if (GradeLevel is < 1 or > 13)       { ValidationMessage = "Klassenstufe 1–13."; return; }

        string? subjectName = IsKurs && !string.IsNullOrWhiteSpace(Subject) ? Subject.Trim() : null;
        Guid?   subjectId   = null;

        if (subjectName is not null)
        {
            var existing = _allSubjects.FirstOrDefault(
                s => s.Name.Equals(subjectName, StringComparison.OrdinalIgnoreCase));
            if (existing is not null)
            {
                subjectId = existing.Id;
            }
            else
            {
                var newSubject = new Subject { Name = subjectName };
                _subjects.Save(newSubject);
                subjectId = newSubject.Id;
            }
        }

        Result = new LearningGroup
        {
            Name          = Name.Trim(),
            Subject       = subjectName,
            SubjectId     = subjectId,
            Type          = IsKurs ? GroupType.Course : GroupType.Class,
            GradeLevel    = GradeLevel,
            GradingSystem = GradingSystem,
            SchoolYear    = SelectedSchoolYear,
        };
        _groups.Save(Result);
    }
}