using LehrerApp.Core.Interfaces;
using LehrerApp.Core.Models;

namespace LehrerApp.Data.Repositories;

public class GroupRepository(LiteDbContext db) : IGroupRepository
{
    public LearningGroup? GetById(Guid id) =>
        db.Groups.FindById(id);

    public List<LearningGroup> GetAll() =>
        db.Groups.FindAll()
            .OrderBy(g => g.SchoolYear)
            .ThenBy(g => g.Name)
            .ToList();

    public List<LearningGroup> GetBySchoolYear(string schoolYear) =>
        db.Groups.Find(g => g.SchoolYear == schoolYear)
            .OrderBy(g => g.Name)
            .ToList();

    public void Save(LearningGroup group)
    {
        group.UpdatedAt = DateTime.UtcNow;
        db.Groups.Upsert(group);
    }

    public void Delete(Guid id) =>
        db.Groups.Delete(id);
}

public class EnrollmentRepository(LiteDbContext db) : IEnrollmentRepository
{
    public List<Enrollment> GetByStudent(Guid studentId) =>
        db.Enrollments.Find(e => e.StudentId == studentId).ToList();

    public List<Enrollment> GetByGroup(Guid groupId) =>
        db.Enrollments.Find(e => e.GroupId == groupId).ToList();

    public List<Enrollment> GetByGroupAndYear(Guid groupId, string schoolYear) =>
        db.Enrollments
            .Find(e => e.GroupId == groupId && e.SchoolYear == schoolYear)
            .ToList();

    public void Save(Enrollment enrollment) =>
        db.Enrollments.Upsert(enrollment);

    public void Delete(Guid id) =>
        db.Enrollments.Delete(id);
}

public class ExamRepository(LiteDbContext db) : IExamRepository
{
    public Exam? GetById(Guid id) =>
        db.Exams.FindById(id);

    public List<Exam> GetByGroup(Guid groupId) =>
        db.Exams.Find(e => e.GroupId == groupId)
            .OrderByDescending(e => e.Date)
            .ToList();

    public void Save(Exam exam)
    {
        exam.UpdatedAt = DateTime.UtcNow;
        db.Exams.Upsert(exam);
    }

    public void Delete(Guid id) =>
        db.Exams.Delete(id);
}

public class ExamResultRepository(LiteDbContext db) : IExamResultRepository
{
    public List<ExamResult> GetByExam(Guid examId) =>
        db.ExamResults.Find(r => r.ExamId == examId).ToList();

    public List<ExamResult> GetByStudent(Guid studentId) =>
        db.ExamResults.Find(r => r.StudentId == studentId).ToList();

    public ExamResult? GetByExamAndStudent(Guid examId, Guid studentId) =>
        db.ExamResults.FindOne(r => r.ExamId == examId && r.StudentId == studentId);

    public void Save(ExamResult result)
    {
        result.UpdatedAt = DateTime.UtcNow;
        db.ExamResults.Upsert(result);
    }

    public void SaveMany(List<ExamResult> results)
    {
        var now = DateTime.UtcNow;
        foreach (var r in results) r.UpdatedAt = now;
        db.ExamResults.Upsert(results);
    }
}