package repositories

import (
	"time"

	"lv8girl/internal/models"

	"golang.org/x/crypto/bcrypt"
)

type UserRepository struct{}

func NewUserRepository() *UserRepository {
	return &UserRepository{}
}

func (r *UserRepository) FindByID(id uint) (*models.User, error) {
	var user models.User
	err := DB.First(&user, id).Error
	return &user, err
}

func (r *UserRepository) FindByUsernameOrEmail(login string) (*models.User, error) {
	var user models.User
	err := DB.Where("username = ? OR email = ?", login, login).First(&user).Error
	return &user, err
}

func (r *UserRepository) FindByUsername(username string) (*models.User, error) {
	var user models.User
	err := DB.Where("username = ?", username).First(&user).Error
	return &user, err
}

func (r *UserRepository) FindByEmail(email string) (*models.User, error) {
	var user models.User
	err := DB.Where("email = ?", email).First(&user).Error
	return &user, err
}

func (r *UserRepository) ExistsByUsernameOrEmail(username, email string) bool {
	var count int64
	DB.Model(&models.User{}).Where("username = ? OR email = ?", username, email).Count(&count)
	return count > 0
}

func (r *UserRepository) Create(user *models.User) error {
	return DB.Create(user).Error
}

func (r *UserRepository) Update(user *models.User) error {
	return DB.Save(user).Error
}

func (r *UserRepository) UpdateField(id uint, field string, value interface{}) error {
	return DB.Model(&models.User{}).Where("id = ?", id).Update(field, value).Error
}

func (r *UserRepository) UpdateLastActive(id uint) error {
	now := time.Now()
	return r.UpdateField(id, "last_active", now)
}

func (r *UserRepository) Delete(id uint) error {
	return DB.Delete(&models.User{}, id).Error
}

func (r *UserRepository) Count() (int64, error) {
	var count int64
	err := DB.Model(&models.User{}).Count(&count).Error
	return count, err
}

func (r *UserRepository) CountOnline() (int64, error) {
	var count int64
	fiveMinutesAgo := time.Now().Add(-5 * time.Minute)
	err := DB.Model(&models.User{}).Where("last_active > ?", fiveMinutesAgo).Count(&count).Error
	return count, err
}

func (r *UserRepository) CountByRole(role string) (int64, error) {
	var count int64
	err := DB.Model(&models.User{}).Where("role = ?", role).Count(&count).Error
	return count, err
}

func (r *UserRepository) FindPending() ([]models.User, error) {
	var users []models.User
	err := DB.Where("status = ?", "pending").Order("created_at ASC").Find(&users).Error
	return users, err
}

func (r *UserRepository) FindAll() ([]models.User, error) {
	var users []models.User
	err := DB.Order("id").Find(&users).Error
	return users, err
}

func (r *UserRepository) HashPassword(password string) (string, error) {
	bytes, err := bcrypt.GenerateFromPassword([]byte(password), bcrypt.DefaultCost)
	return string(bytes), err
}

func (r *UserRepository) CheckPassword(password, hash string) bool {
	err := bcrypt.CompareHashAndPassword([]byte(hash), []byte(password))
	return err == nil
}

func (r *UserRepository) CreateAdminIfNotExists() error {
	var count int64
	DB.Model(&models.User{}).Where("role = ?", "admin").Count(&count)
	if count == 0 {
		passwordHash, _ := r.HashPassword("admin123")
		admin := models.User{
			Username:     "admin",
			Email:        "admin@lv8girl.local",
			PasswordHash: passwordHash,
			Role:         "admin",
			Status:       "approved",
		}
		return DB.Create(&admin).Error
	}
	return nil
}