package repository

import (
	"fmt"
	"github.com/rs/zerolog"
	"go-humas-be/app/database"
	"go-humas-be/app/database/entity"
	"go-humas-be/app/database/entity/users"
	"go-humas-be/app/module/users/request"
	"go-humas-be/utils/paginator"
	"strings"
)

type usersRepository struct {
	DB  *database.Database
	Log zerolog.Logger
}

// UsersRepository define interface of IUsersRepository
type UsersRepository interface {
	GetAll(req request.UsersQueryRequest) (userss []*users.Users, paging paginator.Pagination, err error)
	FindOne(id uint) (users *users.Users, err error)
	FindByKeycloakId(keycloakId string) (users *users.Users, err error)
	FindByUsername(username string) (users *users.Users, err error)
	Create(users *users.Users) (userReturn *users.Users, err error)
	Update(id uint, users *users.Users) (err error)
	Delete(id uint) (err error)
	CreateForgotPassword(forgotPasswords *entity.ForgotPasswords) (err error)
	UpdateForgotPassword(id uint, forgotPasswords *entity.ForgotPasswords) (err error)
	FindForgotPassword(keycloakId string, code string) (forgotPasswords *entity.ForgotPasswords, err error)
	CreateRegistrationOtps(registrationOtps *entity.RegistrationOtps) (err error)
	FindRegistrationOtps(email string, code string) (registrationOtps *entity.RegistrationOtps, err error)
}

func NewUsersRepository(db *database.Database, log zerolog.Logger) UsersRepository {
	return &usersRepository{
		DB:  db,
		Log: log,
	}
}

// implement interface of IUsersRepository
func (_i *usersRepository) GetAll(req request.UsersQueryRequest) (userss []*users.Users, paging paginator.Pagination, err error) {
	var count int64

	query := _i.DB.DB.Model(&users.Users{})
	query = query.Where("is_active = ?", true)

	if req.Username != nil && *req.Username != "" {
		username := strings.ToLower(*req.Username)
		query = query.Where("LOWER(username) LIKE ?", "%"+strings.ToLower(username)+"%")
	}
	if req.Fullname != nil && *req.Fullname != "" {
		fullname := strings.ToLower(*req.Fullname)
		query = query.Where("LOWER(fullname) LIKE ?", "%"+strings.ToLower(fullname)+"%")
	}
	if req.Email != nil && *req.Email != "" {
		query = query.Where("email = ?", req.Email)
	}
	if req.PhoneNumber != nil && *req.PhoneNumber != "" {
		query = query.Where("phone_number = ?", req.PhoneNumber)
	}
	if req.WorkType != nil && *req.WorkType != "" {
		query = query.Where("work_type = ?", req.WorkType)
	}
	if req.GenderType != nil && *req.GenderType != "" {
		query = query.Where("gender_type = ?", req.GenderType)
	}
	if req.IdentityType != nil && *req.IdentityType != "" {
		query = query.Where("identity_type = ?", req.IdentityType)
	}
	if req.IdentityGroup != nil && *req.IdentityGroup != "" {
		query = query.Where("identity_group = ?", req.IdentityGroup)
	}
	if req.IdentityGroupNumber != nil && *req.IdentityGroupNumber != "" {
		query = query.Where("identity_group_number = ?", req.IdentityGroupNumber)
	}
	if req.IdentityNumber != nil && *req.IdentityNumber != "" {
		query = query.Where("identity_number = ?", req.IdentityNumber)
	}
	if req.UserRoleId != nil {
		query = query.Where("user_role_id = ?", req.UserRoleId)
	}
	if req.StatusId != nil {
		query = query.Where("status_id = ?", req.StatusId)
	}
	query.Count(&count)

	if req.Pagination.SortBy != "" {
		direction := "ASC"
		if req.Pagination.Sort == "desc" {
			direction = "DESC"
		}
		query.Order(fmt.Sprintf("%s %s", req.Pagination.SortBy, direction))
	}

	req.Pagination.Count = count
	req.Pagination = paginator.Paging(req.Pagination)

	err = query.Offset(req.Pagination.Offset).Limit(req.Pagination.Limit).Find(&userss).Error
	if err != nil {
		return
	}

	paging = *req.Pagination

	return
}

func (_i *usersRepository) FindOne(id uint) (users *users.Users, err error) {
	if err := _i.DB.DB.First(&users, id).Error; err != nil {
		return nil, err
	}

	return users, nil
}

func (_i *usersRepository) FindByKeycloakId(keycloakId string) (users *users.Users, err error) {
	if err := _i.DB.DB.Where("keycloak_id = ?", keycloakId).Preload("UserLevel").First(&users).Error; err != nil {
		return nil, err
	}

	return users, nil
}

func (_i *usersRepository) FindByUsername(username string) (users *users.Users, err error) {
	if err := _i.DB.DB.Where("username = ?", username).First(&users).Error; err != nil {
		return nil, err
	}

	return users, nil
}

func (_i *usersRepository) Create(users *users.Users) (userReturn *users.Users, err error) {
	result := _i.DB.DB.Create(users)
	return users, result.Error
}

func (_i *usersRepository) Update(id uint, usersReturn *users.Users) (err error) {
	return _i.DB.DB.Model(&users.Users{}).
		Where(&users.Users{ID: id}).
		Updates(usersReturn).Error
}

func (_i *usersRepository) Delete(id uint) error {
	return _i.DB.DB.Delete(&users.Users{}, id).Error
}

func (_i *usersRepository) CreateForgotPassword(forgotPasswords *entity.ForgotPasswords) (err error) {
	result := _i.DB.DB.Create(forgotPasswords)
	return result.Error
}

func (_i *usersRepository) UpdateForgotPassword(id uint, forgotPasswords *entity.ForgotPasswords) (err error) {
	_i.Log.Info().Interface("forgotPasswords", id).Msg("")
	_i.Log.Info().Interface("forgotPasswords", forgotPasswords).Msg("")

	return _i.DB.DB.Model(&entity.ForgotPasswords{}).
		Where(&entity.ForgotPasswords{ID: id}).
		Updates(forgotPasswords).Error
}

func (_i *usersRepository) FindForgotPassword(keycloakId string, code string) (forgotPasswords *entity.ForgotPasswords, err error) {
	if err := _i.DB.DB.Where("keycloak_id = ?", keycloakId).Where("code_request = ?", code).Where("is_active = ?", true).First(&forgotPasswords).Error; err != nil {
		return nil, err
	}

	return forgotPasswords, nil
}

func (_i *usersRepository) CreateRegistrationOtps(registrationOtps *entity.RegistrationOtps) (err error) {
	result := _i.DB.DB.Create(registrationOtps)
	return result.Error
}

func (_i *usersRepository) FindRegistrationOtps(email string, code string) (registrationOtps *entity.RegistrationOtps, err error) {
	if err := _i.DB.DB.Where("email = ?", email).Where("otp_code = ?", code).First(&registrationOtps).Error; err != nil {
		return nil, err
	}

	return registrationOtps, nil
}