package repositories

import (
	"errors"
	"lost-and-found/internal/models"

	"gorm.io/gorm"
)

type UserRepository struct {
	db *gorm.DB
}

func NewUserRepository(db *gorm.DB) *UserRepository {
	return &UserRepository{db: db}
}

// Create creates a new user
func (r *UserRepository) Create(user *models.User) error {
	return r.db.Create(user).Error
}

// FindByID finds user by ID
func (r *UserRepository) FindByID(id uint) (*models.User, error) {
	var user models.User
	err := r.db.Preload("Role").First(&user, id).Error
	if err != nil {
		if errors.Is(err, gorm.ErrRecordNotFound) {
			return nil, errors.New("user not found")
		}
		return nil, err
	}
	return &user, nil
}

// FindByEmail finds user by email
func (r *UserRepository) FindByEmail(email string) (*models.User, error) {
	var user models.User
	err := r.db.Preload("Role").Where("email = ?", email).First(&user).Error
	if err != nil {
		if errors.Is(err, gorm.ErrRecordNotFound) {
			return nil, errors.New("user not found")
		}
		return nil, err
	}
	return &user, nil
}

// FindByNRP finds user by NRP
func (r *UserRepository) FindByNRP(nrp string) (*models.User, error) {
	var user models.User
	err := r.db.Preload("Role").Where("nrp = ?", nrp).First(&user).Error
	if err != nil {
		if errors.Is(err, gorm.ErrRecordNotFound) {
			return nil, nil
		}
		return nil, err
	}
	return &user, nil
}

// FindAll returns all users
func (r *UserRepository) FindAll(page, limit int) ([]models.User, int64, error) {
	var users []models.User
	var total int64

	// Count total
	if err := r.db.Model(&models.User{}).Count(&total).Error; err != nil {
		return nil, 0, err
	}

	// Get paginated results
	offset := (page - 1) * limit
	err := r.db.Preload("Role").Offset(offset).Limit(limit).Find(&users).Error
	if err != nil {
		return nil, 0, err
	}

	return users, total, nil
}

// Update updates user data
func (r *UserRepository) Update(user *models.User) error {
	return r.db.Save(user).Error
}

// UpdateRole updates user role
func (r *UserRepository) UpdateRole(userID, roleID uint) error {
	return r.db.Model(&models.User{}).Where("id = ?", userID).Update("role_id", roleID).Error
}

// UpdateStatus updates user status
func (r *UserRepository) UpdateStatus(userID uint, status string) error {
	return r.db.Model(&models.User{}).Where("id = ?", userID).Update("status", status).Error
}

// Delete soft deletes a user
func (r *UserRepository) Delete(id uint) error {
	return r.db.Delete(&models.User{}, id).Error
}

// BlockUser blocks a user
func (r *UserRepository) BlockUser(id uint) error {
	return r.UpdateStatus(id, "blocked")
}

// UnblockUser unblocks a user
func (r *UserRepository) UnblockUser(id uint) error {
	return r.UpdateStatus(id, "active")
}

// CountByRole counts users by role
func (r *UserRepository) CountByRole(roleID uint) (int64, error) {
	var count int64
	err := r.db.Model(&models.User{}).Where("role_id = ?", roleID).Count(&count).Error
	return count, err
}

// GetUserStats gets user statistics
func (r *UserRepository) GetUserStats(userID uint) (map[string]interface{}, error) {
	var stats map[string]interface{} = make(map[string]interface{})

	// Count items reported
	var itemCount int64
	if err := r.db.Model(&models.Item{}).Where("reporter_id = ?", userID).Count(&itemCount).Error; err != nil {
		return nil, err
	}
	stats["items_reported"] = itemCount

	// Count lost items reported
	var lostItemCount int64
	if err := r.db.Model(&models.LostItem{}).Where("user_id = ?", userID).Count(&lostItemCount).Error; err != nil {
		return nil, err
	}
	stats["lost_items_reported"] = lostItemCount

	// Count claims made
	var claimCount int64
	if err := r.db.Model(&models.Claim{}).Where("user_id = ?", userID).Count(&claimCount).Error; err != nil {
		return nil, err
	}
	stats["claims_made"] = claimCount

	// Count approved claims
	var approvedClaimCount int64
	if err := r.db.Model(&models.Claim{}).Where("user_id = ? AND status = ?", userID, models.ClaimStatusApproved).Count(&approvedClaimCount).Error; err != nil {
		return nil, err
	}
	stats["claims_approved"] = approvedClaimCount

	return stats, nil
}