using CommunityToolkit.Mvvm.ComponentModel;
using LehrerApp.Core.Interfaces;
using LehrerApp.Core.Models;
using LehrerApp.Core.Services;
using LehrerApp.Desktop.Services;
using LehrerApp.Desktop.ViewModels.Students;
using LehrerApp.Templating;
using System.Collections.ObjectModel;

namespace LehrerApp.Desktop.ViewModels.Groups;

/// <summary>Erzeugt zu einer Klausur einen Satz individueller Deckblätter als ein Sammel-PDF.
/// Zur Auswahl stehen nur Vorlagen mit <c>report-type=exam-cover</c>, egal in welcher der beiden
/// Vorlagenbibliotheken sie importiert wurden. Mit <see cref="FillResults"/> trägt dieselbe
/// Vorlage Punkte und Note ein oder bleibt als Blanko-Deckblatt zum Ausfüllen von Hand.</summary>
public partial class ExamCoverSheetDialogViewModel : ObservableObject
{
    private readonly Exam _exam;
    private readonly LearningGroup _group;
    private readonly string _subjectName;
    private readonly GradingService _grading;
    private readonly TemplateStore _loader;
    private readonly ITemplateBatchRenderer _renderer;
    private readonly Exam? _original;
    private readonly Dictionary<Guid, ExamResult> _originalResults;
    [ObservableProperty] private ReportInterimRunChoice? _selectedInterimRun;
    [ObservableProperty] private bool _usesInterimGrades;
    public ObservableCollection<ReportInterimRunChoice> InterimRuns { get; } = [];

    partial void OnSelectedTemplateChanged(LetterTemplateChoice? value)
    {
        UsesInterimGrades = value is not null &&
            DrawingBoxLocator.Find(_loader.Load(value.Model), ReportTextDrawing.InterimGrades) is not null;
    }

    [ObservableProperty] private LetterTemplateChoice? _selectedTemplate;
    [ObservableProperty] private bool _fillResults;
    [ObservableProperty] private string _statusMessage = "";
    /// <summary>Vorbelegt aus den Einstellungen, hier nur für diesen Druck änderbar (z. B. zwei
    /// Kürzel bei einem gemeinsam unterrichteten Kurs) — die Einstellung bleibt unberührt.</summary>
    [ObservableProperty] private string _teacherAbbreviation;
    /// <summary>Vorbelegt mit dem internen Klausurtitel, hier nur für diesen Druck änderbar — der
    /// Titel der Klausur bleibt unberührt. Leer gelassen gilt wieder der interne Titel.</summary>
    [ObservableProperty] private string _coverTitle;
    [ObservableProperty, NotifyPropertyChangedFor(nameof(CanGenerate))] private bool _isGenerating;
    [ObservableProperty] private int _progressValue;
    [ObservableProperty] private int _progressMaximum = 1;
    /// <summary>Alle Deckblätter sind gesetzt, das Sammel-PDF entsteht — dieser Schritt meldet
    /// keinen Zwischenstand, der Balken läuft deshalb unbestimmt.</summary>
    [ObservableProperty] private bool _isMerging;
    [ObservableProperty] private string _progressText = "";

    public string ExamTitle => _exam.Title;
    public string ExamLabel => $"{_exam.Title} · {_group.Name} · {_exam.Date:dd.MM.yyyy}";
    public ObservableCollection<LetterTemplateChoice> Templates { get; } = [];
    public ObservableCollection<ExamCoverStudentChoice> Students { get; } = [];
    public bool HasNoTemplates => Templates.Count == 0;
    public bool CanGenerate => !HasNoTemplates && !IsGenerating;
    public string SuggestedFileName => SanitizeFileName($"Deckblätter_{_group.Name}_{_exam.Title}.pdf");

    public ExamCoverSheetDialogViewModel(Exam exam, LearningGroup group, string subjectName,
        IStudentRepository students, IGroupMembershipRepository memberships, IExamResultRepository results,
        GradingService grading, IReadOnlyList<TemplateStore> templateStores, ITemplateBatchRenderer renderer,
        string teacherAbbreviation = "", IExamRepository? exams = null, IInterimGradeRepository? interims = null)
    {
        _teacherAbbreviation = teacherAbbreviation;
        _coverTitle = exam.Title;
        _exam = exam; _group = group; _subjectName = subjectName; _grading = grading; _renderer = renderer;
        _loader = templateStores[0];
        _original = exam.RepeatOfExamId is { } originalId ? exams?.GetById(originalId) : null;
        _originalResults = exam.RepeatOfExamId is { } firstId
            ? results.GetByExam(firstId).ToDictionary(r => r.StudentId) : [];
        foreach (var run in (interims?.GetByGroup(group.Id) ?? [])
                     .GroupBy(g => (g.Date, g.Occasion)).OrderByDescending(g => g.Key.Date).ThenBy(g => g.Key.Occasion))
            InterimRuns.Add(new(run.Key.Date, run.Key.Occasion, run.ToList()));
        // Bewusste Auswahl statt stillschweigend den neuesten Zwischenstand zu drucken.
        foreach (var template in templateStores.SelectMany(x => x.GetTemplates()).Where(x => x.IsExamCover)
                     .DistinctBy(x => x.Id).OrderBy(x => x.Name, StringComparer.CurrentCultureIgnoreCase))
            Templates.Add(new(template));
        SelectedTemplate = Templates.FirstOrDefault();

        var membershipList = memberships.GetByGroup(group.Id);
        var existing = results.GetByExam(exam.Id).ToDictionary(r => r.StudentId);
        var wroteOriginal = ExamParticipantService.WroteOriginal(exam, results.GetByExam);
        foreach (var student in students.GetByGroup(group.Id).OrderBy(s => s.LastName).ThenBy(s => s.FirstName))
        {
            var membership = membershipList.FirstOrDefault(m => m.StudentId == student.Id);
            existing.TryGetValue(student.Id, out var result);
            if (!ExamParticipantService.Includes(exam, membership, result is not null, wroteOriginal.Contains(student.Id)))
                continue;
            Students.Add(new(student, result, membership?.Niveau));
        }
        // Vor der Korrektur ist das Blanko-Deckblatt der Normalfall, danach das ausgefüllte.
        FillResults = Students.Any(s => s.IsCorrected);
    }

    /// <summary>Schreibt das Sammel-PDF und meldet den Erfolg. Gesetzt wird im Hintergrund, damit
    /// der Dialog bei einem Klassensatz bedienbar bleibt und den Fortschritt zeigen kann.</summary>
    public async Task<bool> GenerateAsync(string outputPath)
    {
        StatusMessage = "";
        if (SelectedTemplate is null || IsGenerating) return false;
        var included = Students.Where(s => s.IsIncluded).ToList();
        if (included.Count == 0) { StatusMessage = "Kein Schüler ausgewählt."; return false; }
        try
        {
            var loaded = _loader.Load(SelectedTemplate.Model);
            if (UsesInterimGrades && SelectedInterimRun is null)
            { StatusMessage = "Bitte einen gespeicherten Notenzwischenstand auswählen."; return false; }
            if (UsesInterimGrades)
            {
                var missing = included.Where(s => !SelectedInterimRun!.Grades.Any(g => g.StudentId == s.Model.Id)).ToList();
                if (missing.Count > 0)
                { StatusMessage = "Im gewählten Zwischenstand fehlen: " + string.Join(", ", missing.Select(s => s.FullName)) + ". Bitte Schüler abwählen oder einen anderen Durchgang wählen."; return false; }
            }
            var today = DateOnly.FromDateTime(DateTime.Now);
            var data = included.Select(s => (ITemplateDataProvider)new LetterDataProvider(
                ExamCoverPlaceholderBuilder.Build(_exam, _group, _subjectName, s.Model, s.Result, FillResults,
                    _grading, loaded, today, s.Niveau, TeacherAbbreviation, CoverTitle,
                    _original, _originalResults.GetValueOrDefault(s.Model.Id),
                    UsesInterimGrades ? SelectedInterimRun!.Grades.Single(g => g.StudentId == s.Model.Id) : null))).ToList();
            ReportProgress(0, included.Count);
            IsGenerating = true;
            var progress = new Progress<int>(done => ReportProgress(done, included.Count));
            var result = await Task.Run(() =>
            {
                var rendered = _renderer.RenderBatchToPdf(loaded, data, progress);
                File.WriteAllBytes(outputPath, rendered.Pdf);
                return rendered;
            });

            var message = $"{included.Count} Deckblätter erzeugt.";
            var blank = FillResults ? included.Count(s => !s.IsCorrected) : 0;
            if (blank > 0) message += $" {blank} davon ohne Punkte und Note (noch nicht korrigiert).";
            var overflowing = result.PageCounts.Count(pages => pages > 1);
            if (overflowing > 0)
                message += $" Achtung: {overflowing} Deckblätter passen nicht auf eine Seite — die Punktetabelle braucht mehr Platz, als die Vorlage lässt.";
            StatusMessage = message;
            return true;
        }
        catch (Exception ex) when (ex is IOException or InvalidDataException or UnauthorizedAccessException or TemplateValidationException or QuestPDF.Drawing.Exceptions.DocumentLayoutException)
        { StatusMessage = $"Deckblätter konnten nicht erzeugt werden: {ex.Message}"; return false; }
        finally { IsGenerating = false; }
    }

    private void ReportProgress(int done, int total)
    {
        ProgressMaximum = total;
        ProgressValue = done;
        IsMerging = done >= total && total > 1;
        ProgressText = IsMerging
            ? "Sammel-PDF wird zusammengefügt …"
            : $"{done} von {total} Deckblättern gesetzt …";
    }

    private static string SanitizeFileName(string value)
    { foreach (var character in Path.GetInvalidFileNameChars()) value = value.Replace(character, '_'); return value; }
}

public partial class ExamCoverStudentChoice : ObservableObject
{
    public Student Model { get; }
    public ExamResult? Result { get; }
    public Niveau? Niveau { get; }
    public string FullName => Model.FullName;
    public bool IsCorrected => ExamCoverSheetService.IsCorrected(Result);
    public string Hint => Result is { Absent: true } ? "abwesend" : "";
    [ObservableProperty] private bool _isIncluded;

    public ExamCoverStudentChoice(Student model, ExamResult? result, Niveau? niveau = null)
    {
        Model = model; Result = result; Niveau = niveau;
        // Wer gefehlt hat, bekommt kein Deckblatt — lässt sich im Dialog wieder anhaken.
        _isIncluded = result is not { Absent: true };
    }
}

public sealed record ReportInterimRunChoice(DateOnly Date, string Occasion, IReadOnlyList<InterimGrade> Grades)
{
    public string Label => $"{Date:dd.MM.yyyy} · {Occasion}";
}