package persistence

import (
	domainUser "RenewCMS/internal/domain/user"
	"RenewCMS/internal/infrastructure/persistence/mappers"
	entity "RenewCMS/internal/infrastructure/persistence/models"
	"time"

	"gorm.io/gorm"
)

type UserRepository struct {
	db *gorm.DB
}

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

func (u *UserRepository) Get(id uint32) (domainUser.User, error) {
	var localUser entity.User
	err := u.db.Model(&entity.User{}).First(&localUser, id).Error
	if err != nil {
		return domainUser.User{}, mapNotFoundErr(err, domainUser.ErrUserNotFound)
	}

	return mappers.UserToDomain(localUser), nil
}

func (u *UserRepository) Create(user domainUser.User) (domainUser.User, error) {
	createdUser := entity.User{
		Username:               user.Username,
		Password:               user.Password,
		PasswordResetCode:      mappers.DomainToNullableString(user.PasswordResetCode),
		Email:                  user.Email,
		IsVerified:             user.IsVerified,
		Role:                   string(user.Role),
		VerificationCode:       mappers.DomainToNullableString(user.VerificationCode),
		VerificationExpiration: user.VerificationExpiration,
	}
	if err := u.db.Create(&createdUser).Error; err != nil {
		return domainUser.User{}, err
	}

	return mappers.UserToDomain(createdUser), nil
}

func (u *UserRepository) Delete(id uint32) error {
	result := u.db.Delete(&entity.User{}, id)
	return deleteOrNotFound(result, domainUser.ErrUserNotFound)
}

func (u *UserRepository) GetAll() []domainUser.User {
	var users []entity.User
	u.db.Model(&entity.User{}).Find(&users)

	var domainUsers []domainUser.User
	for _, localUser := range users {
		domainUsers = append(domainUsers, mappers.UserToDomain(localUser))
	}

	return domainUsers
}

func (u *UserRepository) GetByUsername(username string) (domainUser.User, error) {
	var localUser entity.User
	err := u.db.Model(&entity.User{}).Where("username = ?", username).First(&localUser).Error
	if err != nil {
		return domainUser.User{}, mapNotFoundErr(err, domainUser.ErrUserNotFound)
	}

	return mappers.UserToDomain(localUser), nil
}

func (u *UserRepository) GetByEmail(email string) (domainUser.User, error) {
	var localUser entity.User
	err := u.db.Model(&entity.User{}).Where("email = ?", email).First(&localUser).Error
	if err != nil {
		return domainUser.User{}, mapNotFoundErr(err, domainUser.ErrUserNotFound)
	}

	return mappers.UserToDomain(localUser), nil
}

func (u *UserRepository) UpdateVerificationStatus(userId uint32, isVerified bool) (domainUser.User, error) {
	var localUser entity.User
	err := u.db.Model(&entity.User{}).First(&localUser, userId).Error
	if err != nil {
		return domainUser.User{}, mapNotFoundErr(err, domainUser.ErrUserNotFound)
	}

	localUser.IsVerified = isVerified
	err = u.db.Save(&localUser).Error
	if err != nil {
		return domainUser.User{}, err
	}

	return mappers.UserToDomain(localUser), nil
}

func (u *UserRepository) UpdatePassword(userId uint32, password string) (domainUser.User, error) {
	var localUser entity.User
	err := u.db.Model(&entity.User{}).First(&localUser, userId).Error
	if err != nil {
		return domainUser.User{}, mapNotFoundErr(err, domainUser.ErrUserNotFound)
	}

	localUser.Password = password
	err = u.db.Save(&localUser).Error
	if err != nil {
		return domainUser.User{}, err
	}

	return mappers.UserToDomain(localUser), nil
}

func (u *UserRepository) UpdatePasswordResetCode(userId uint32, code string, expiration time.Time) (domainUser.User, error) {
	var localUser entity.User
	err := u.db.Model(&entity.User{}).First(&localUser, userId).Error
	if err != nil {
		return domainUser.User{}, mapNotFoundErr(err, domainUser.ErrUserNotFound)
	}

	localUser.PasswordResetCode = mappers.DomainToNullableString(code)
	localUser.PasswordResetExpiration = expiration
	err = u.db.Save(&localUser).Error
	if err != nil {
		return domainUser.User{}, err
	}

	return mappers.UserToDomain(localUser), nil
}

func (u *UserRepository) ClearVerificationCode(userId uint32) (domainUser.User, error) {
	var localUser entity.User
	err := u.db.Model(&entity.User{}).First(&localUser, userId).Error
	if err != nil {
		return domainUser.User{}, mapNotFoundErr(err, domainUser.ErrUserNotFound)
	}

	localUser.IsVerified = true
	localUser.VerificationCode = mappers.DomainToNullableString("")
	err = u.db.Save(&localUser).Error
	if err != nil {
		return domainUser.User{}, err
	}

	return mappers.UserToDomain(localUser), nil
}

func (u *UserRepository) ResetPassword(userId uint32, hashedPassword string) (domainUser.User, error) {
	var localUser entity.User
	err := u.db.Model(&entity.User{}).First(&localUser, userId).Error
	if err != nil {
		return domainUser.User{}, mapNotFoundErr(err, domainUser.ErrUserNotFound)
	}

	localUser.Password = hashedPassword
	localUser.PasswordResetCode = mappers.DomainToNullableString("")
	localUser.PasswordResetExpiration = time.Time{}
	localUser.TokenVersion++
	err = u.db.Save(&localUser).Error
	if err != nil {
		return domainUser.User{}, err
	}

	return mappers.UserToDomain(localUser), nil
}

func (u *UserRepository) UpdateDisplayName(userId uint32, displayName string) (domainUser.User, error) {
	var localUser entity.User
	err := u.db.Model(&entity.User{}).First(&localUser, userId).Error
	if err != nil {
		return domainUser.User{}, mapNotFoundErr(err, domainUser.ErrUserNotFound)
	}

	localUser.DisplayName = displayName
	err = u.db.Save(&localUser).Error
	if err != nil {
		return domainUser.User{}, err
	}

	return mappers.UserToDomain(localUser), nil
}

var _ domainUser.Repository = &UserRepository{}