package services

import (
	"lokideploy/models"
	"lokideploy/pkg/crypto"
	"lokideploy/pkg/jwt"
	"lokideploy/repository"
	"lokideploy/utils"
)

type AuthService struct{}

func NewAuthService() *AuthService {
	return &AuthService{}
}

func (s *AuthService) Login(username, password string) (*models.User, *jwt.TokenPair, error) {
	db := repository.GetDB()
	db.RLock()
	defer db.RUnlock()
	for i := range db.Users {
		if db.Users[i].Username == username {
			if !crypto.VerifyPassword(password, db.Users[i].Password) {
				return nil, nil, utils.ErrInvalidCredentials
			}
			tokenPair, err := jwt.GenerateTokenPair(db.Users[i].ID, db.Users[i].Username, db.Users[i].Role)
			if err != nil {
				return nil, nil, err
			}
			return &db.Users[i], tokenPair, nil
		}
	}
	return nil, nil, utils.ErrInvalidCredentials
}

func (s *AuthService) Register(username, password, nickname, role string) (*models.User, error) {
	hash, err := crypto.HashPassword(password)
	if err != nil {
		return nil, err
	}
	user := &models.User{
		ID:       repository.GetDB().NextID("users"),
		Username: username,
		Password: hash,
		Nickname: nickname,
		Role:     role,
	}
	if err := repository.GetDB().CreateUser(user); err != nil {
		return nil, err
	}
	return user, nil
}

func (s *AuthService) GetUserByID(id uint) (*models.User, error) {
	db := repository.GetDB()
	db.RLock()
	defer db.RUnlock()
	for i := range db.Users {
		if db.Users[i].ID == id {
			u := db.Users[i]
			return &u, nil
		}
	}
	return nil, utils.ErrNotFound
}

func (s *AuthService) ChangePassword(userID uint, oldPassword, newPassword string) error {
	db := repository.GetDB()
	db.Lock()
	defer db.Unlock()
	for i := range db.Users {
		if db.Users[i].ID == userID {
			if !crypto.VerifyPassword(oldPassword, db.Users[i].Password) {
				return utils.ErrInvalidCredentials
			}
			hash, err := crypto.HashPassword(newPassword)
			if err != nil {
				return err
			}
			db.Users[i].Password = hash
			db.RequestSave()
			return nil
		}
	}
	return utils.ErrNotFound
}