package repository

import (
	"context"

	dbgen "Yimaru-Backend/gen/db"
)

func (s *Store) LmsGetPreviousProgram(ctx context.Context, programID int64) (dbgen.Program, error) {
	return s.queries.GetPreviousProgram(ctx, programID)
}

func (s *Store) LmsGetPreviousCourseInProgram(ctx context.Context, courseID int64) (dbgen.Course, error) {
	return s.queries.GetPreviousCourseInProgram(ctx, courseID)
}

func (s *Store) LmsGetPreviousModuleInCourse(ctx context.Context, moduleID int64) (dbgen.Module, error) {
	return s.queries.GetPreviousModuleInCourse(ctx, moduleID)
}

func (s *Store) LmsGetPreviousLessonInModule(ctx context.Context, lessonID int64) (dbgen.Lesson, error) {
	return s.queries.GetPreviousLessonInModule(ctx, lessonID)
}

func (s *Store) LmsUserHasProgramProgress(ctx context.Context, userID, programID int64) (bool, error) {
	return s.queries.UserHasProgramProgress(ctx, dbgen.UserHasProgramProgressParams{UserID: userID, ProgramID: programID})
}

func (s *Store) LmsUserHasCourseProgress(ctx context.Context, userID, courseID int64) (bool, error) {
	return s.queries.UserHasCourseProgress(ctx, dbgen.UserHasCourseProgressParams{UserID: userID, CourseID: courseID})
}

func (s *Store) LmsUserHasModuleProgress(ctx context.Context, userID, moduleID int64) (bool, error) {
	return s.queries.UserHasModuleProgress(ctx, dbgen.UserHasModuleProgressParams{UserID: userID, ModuleID: moduleID})
}

func (s *Store) LmsUserHasLessonProgress(ctx context.Context, userID, lessonID int64) (bool, error) {
	return s.queries.UserHasLessonProgress(ctx, dbgen.UserHasLessonProgressParams{UserID: userID, LessonID: lessonID})
}

// LmsUserLessonProgressInModule returns combined completed/total counts for lessons + published practices in a module.
func (s *Store) LmsUserLessonProgressInModule(ctx context.Context, userID, moduleID int64) (completed, total int32, err error) {
	lessonTotal, err := s.queries.CountLessonsInModule(ctx, moduleID)
	if err != nil {
		return 0, 0, err
	}
	lessonCompleted, err := s.queries.CountUserCompletedLessonsInModule(ctx, dbgen.CountUserCompletedLessonsInModuleParams{
		ModuleID: moduleID,
		UserID:   userID,
	})
	if err != nil {
		return 0, 0, err
	}
	practiceTotal, err := s.queries.CountPublishedPracticesInModule(ctx, toPgInt8(&moduleID))
	if err != nil {
		return 0, 0, err
	}
	practiceCompleted, err := s.queries.CountUserCompletedPublishedPracticesInModule(ctx, dbgen.CountUserCompletedPublishedPracticesInModuleParams{
		ModuleID: toPgInt8(&moduleID),
		UserID:   userID,
	})
	if err != nil {
		return 0, 0, err
	}
	total = lessonTotal + practiceTotal
	completed = lessonCompleted + practiceCompleted
	return completed, total, nil
}

// LmsUserLessonProgressInCourse returns combined completed/total counts for lessons + published practices in a course.
func (s *Store) LmsUserLessonProgressInCourse(ctx context.Context, userID, courseID int64) (completed, total int32, err error) {
	lessonTotal, err := s.queries.CountLessonsInCourse(ctx, courseID)
	if err != nil {
		return 0, 0, err
	}
	lessonCompleted, err := s.queries.CountUserCompletedLessonsInCourse(ctx, dbgen.CountUserCompletedLessonsInCourseParams{
		CourseID: courseID,
		UserID:   userID,
	})
	if err != nil {
		return 0, 0, err
	}
	practiceTotal, err := s.queries.CountPublishedPracticesInCourse(ctx, toPgInt8(&courseID))
	if err != nil {
		return 0, 0, err
	}
	practiceCompleted, err := s.queries.CountUserCompletedPublishedPracticesInCourse(ctx, dbgen.CountUserCompletedPublishedPracticesInCourseParams{
		CourseID: toPgInt8(&courseID),
		UserID:   userID,
	})
	if err != nil {
		return 0, 0, err
	}
	total = lessonTotal + practiceTotal
	completed = lessonCompleted + practiceCompleted
	return completed, total, nil
}

// LmsUserLessonProgressInProgram returns combined completed/total counts for lessons + published practices in a program.
func (s *Store) LmsUserLessonProgressInProgram(ctx context.Context, userID, programID int64) (completed, total int32, err error) {
	lessonTotal, err := s.queries.CountLessonsInProgram(ctx, programID)
	if err != nil {
		return 0, 0, err
	}
	lessonCompleted, err := s.queries.CountUserCompletedLessonsInProgram(ctx, dbgen.CountUserCompletedLessonsInProgramParams{
		ProgramID: programID,
		UserID:    userID,
	})
	if err != nil {
		return 0, 0, err
	}
	practiceTotal, err := s.queries.CountPublishedPracticesInProgram(ctx, programID)
	if err != nil {
		return 0, 0, err
	}
	practiceCompleted, err := s.queries.CountUserCompletedPublishedPracticesInProgram(ctx, dbgen.CountUserCompletedPublishedPracticesInProgramParams{
		ProgramID: programID,
		UserID:    userID,
	})
	if err != nil {
		return 0, 0, err
	}
	total = lessonTotal + practiceTotal
	completed = lessonCompleted + practiceCompleted
	return completed, total, nil
}