package repository

import (
	"time"

	"homework-manager/internal/database"
	"homework-manager/internal/models"

	"gorm.io/gorm"
)

type AssignmentRepository struct {
	db *gorm.DB
}

func NewAssignmentRepository() *AssignmentRepository {
	return &AssignmentRepository{db: database.GetDB()}
}

func (r *AssignmentRepository) Create(assignment *models.Assignment) error {
	return r.db.Create(assignment).Error
}

func (r *AssignmentRepository) FindByID(id uint) (*models.Assignment, error) {
	var assignment models.Assignment
	err := r.db.First(&assignment, id).Error
	if err != nil {
		return nil, err
	}
	return &assignment, nil
}

func (r *AssignmentRepository) FindByUserID(userID uint) ([]models.Assignment, error) {
	var assignments []models.Assignment
	err := r.db.Where("user_id = ?", userID).Order("due_date ASC").Find(&assignments).Error
	return assignments, err
}

func (r *AssignmentRepository) FindPendingByUserID(userID uint, limit, offset int) ([]models.Assignment, error) {
	var assignments []models.Assignment
	query := r.db.Where("user_id = ? AND is_completed = ?", userID, false).
		Order("due_date ASC")
	if limit > 0 {
		query = query.Limit(limit).Offset(offset)
	}
	err := query.Find(&assignments).Error
	return assignments, err
}

func (r *AssignmentRepository) FindCompletedByUserID(userID uint, limit, offset int) ([]models.Assignment, error) {
	var assignments []models.Assignment
	query := r.db.Where("user_id = ? AND is_completed = ?", userID, true).
		Order("completed_at DESC")
	if limit > 0 {
		query = query.Limit(limit).Offset(offset)
	}
	err := query.Find(&assignments).Error
	return assignments, err
}

func (r *AssignmentRepository) FindDueTodayByUserID(userID uint) ([]models.Assignment, error) {
	now := time.Now()
	startOfDay := time.Date(now.Year(), now.Month(), now.Day(), 0, 0, 0, 0, now.Location())
	endOfDay := startOfDay.AddDate(0, 0, 1)

	var assignments []models.Assignment
	err := r.db.Where("user_id = ? AND is_completed = ? AND due_date >= ? AND due_date < ?",
		userID, false, startOfDay, endOfDay).
		Order("due_date ASC").Find(&assignments).Error
	return assignments, err
}

func (r *AssignmentRepository) FindDueThisWeekByUserID(userID uint) ([]models.Assignment, error) {
	now := time.Now()
	startOfDay := time.Date(now.Year(), now.Month(), now.Day(), 0, 0, 0, 0, now.Location())
	weekLater := startOfDay.AddDate(0, 0, 7)

	var assignments []models.Assignment
	err := r.db.Where("user_id = ? AND is_completed = ? AND due_date >= ? AND due_date < ?",
		userID, false, startOfDay, weekLater).
		Order("due_date ASC").Find(&assignments).Error
	return assignments, err
}

func (r *AssignmentRepository) FindOverdueByUserID(userID uint, limit, offset int) ([]models.Assignment, error) {
	now := time.Now()

	var assignments []models.Assignment
	query := r.db.Where("user_id = ? AND is_completed = ? AND due_date < ?",
		userID, false, now).
		Order("due_date ASC")
	if limit > 0 {
		query = query.Limit(limit).Offset(offset)
	}
	err := query.Find(&assignments).Error
	return assignments, err
}

func (r *AssignmentRepository) Update(assignment *models.Assignment) error {
	return r.db.Save(assignment).Error
}

func (r *AssignmentRepository) Delete(id uint) error {
	return r.db.Delete(&models.Assignment{}, id).Error
}

func (r *AssignmentRepository) CountByUserID(userID uint) (int64, error) {
	var count int64
	err := r.db.Model(&models.Assignment{}).Where("user_id = ?", userID).Count(&count).Error
	return count, err
}

func (r *AssignmentRepository) CountPendingByUserID(userID uint) (int64, error) {
	var count int64
	err := r.db.Model(&models.Assignment{}).
		Where("user_id = ? AND is_completed = ?", userID, false).Count(&count).Error
	return count, err
}

func (r *AssignmentRepository) GetSubjectsByUserID(userID uint) ([]string, error) {
	var subjects []string
	err := r.db.Model(&models.Assignment{}).
		Where("user_id = ? AND subject != ''", userID).
		Distinct("subject").
		Pluck("subject", &subjects).Error
	return subjects, err
}

func (r *AssignmentRepository) CountCompletedByUserID(userID uint) (int64, error) {
	var count int64
	err := r.db.Model(&models.Assignment{}).
		Where("user_id = ? AND is_completed = ?", userID, true).Count(&count).Error
	return count, err
}

func (r *AssignmentRepository) Search(userID uint, queryStr, priority, filter string, page, pageSize int) ([]models.Assignment, int64, error) {
	var assignments []models.Assignment
	var totalCount int64

	dbQuery := r.db.Model(&models.Assignment{}).Where("user_id = ?", userID)

	if queryStr != "" {
		dbQuery = dbQuery.Where("title LIKE ? OR description LIKE ?", "%"+queryStr+"%", "%"+queryStr+"%")
	}

	if priority != "" {
		dbQuery = dbQuery.Where("priority = ?", priority)
	}

	now := time.Now()
	switch filter {
	case "completed":
		dbQuery = dbQuery.Where("is_completed = ?", true)
	case "overdue":
		dbQuery = dbQuery.Where("is_completed = ? AND due_date < ?", false, now)
	default: // pending
		dbQuery = dbQuery.Where("is_completed = ?", false)
	}

	if err := dbQuery.Count(&totalCount).Error; err != nil {
		return nil, 0, err
	}

	if filter == "completed" {
		dbQuery = dbQuery.Order("completed_at DESC")
	} else {
		dbQuery = dbQuery.Order("due_date ASC")
	}

	if page < 1 {
		page = 1
	}
	if pageSize < 1 {
		pageSize = 10
	}
	offset := (page - 1) * pageSize

	err := dbQuery.Limit(pageSize).Offset(offset).Find(&assignments).Error
	return assignments, totalCount, err
}

func (r *AssignmentRepository) CountOverdueByUserID(userID uint) (int64, error) {
	var count int64
	now := time.Now()
	err := r.db.Model(&models.Assignment{}).
		Where("user_id = ? AND is_completed = ? AND due_date < ?", userID, false, now).Count(&count).Error
	return count, err
}