package usecase

import (
    "time"
    "users_management/m/model/entity"
    "users_management/m/repository"

    "github.com/google/uuid"
)

type UsersUsecase interface {
    GetRoleByDepartment(departmentName string) (uuid.UUID, error)
    GetUserByUsername(username string) (entity.User, error)
    GetUserByNomorInduk(nomorInduk string) (entity.User, error)     // Add this
    CreateUserFromExternal(nomorInduk, name, roleName string) error // Add this
    UpdateUserRole(nomorInduk, roleName string) error              // Add this
    GetAllUsers() ([]entity.User, error)                          // Add this
}

type usersUsecase struct {
    userRepo repository.UsersRepo
}

func NewUsersUsecase(userRepo repository.UsersRepo) UsersUsecase {
    return &usersUsecase{
        userRepo: userRepo,
    }
}

func (u *usersUsecase) GetRoleByDepartment(departmentName string) (uuid.UUID, error) {
    role, err := u.userRepo.GetRoleByDepartment(departmentName)
    if err != nil {
        return uuid.Nil, err
    }
    return role.Id, nil
}

func (u *usersUsecase) GetUserByUsername(username string) (entity.User, error) {
    users, err := u.userRepo.GetUserByUsername(username)
    if err != nil {
        return users, err
    }
    return users, nil
}

// New methods for RBAC
func (u *usersUsecase) GetUserByNomorInduk(nomorInduk string) (entity.User, error) {
    return u.userRepo.GetUserByNomorInduk(nomorInduk)
}

func (u *usersUsecase) CreateUserFromExternal(nomorInduk, name, roleName string) error {
    // Get role ID
    roleID, err := u.GetRoleByDepartment(roleName)
    if err != nil {
        return err
    }

    // Create user
    user := entity.User{
        ID:         uuid.New(),
        NomorInduk: &nomorInduk,
        RoleID:     roleID,
        Name:       name,
        Username:   nomorInduk, // Use nomor_induk as username
        Password:   "",         // External auth, no local password needed
        CreatedAt:  time.Now(),
        UpdatedAt:  time.Now(),
    }

    return u.userRepo.CreateUserFromExternal(user)
}

func (u *usersUsecase) UpdateUserRole(nomorInduk, roleName string) error {
    roleID, err := u.GetRoleByDepartment(roleName)
    if err != nil {
        return err
    }

    return u.userRepo.UpdateUserRole(nomorInduk, roleID)
}

func (u *usersUsecase) GetAllUsers() ([]entity.User, error) {
    return u.userRepo.GetAllUsers()
}