authService.go

package services

import (
	"errors"
	"time"

	"github.com/Arjuna-Ragil/Localbase/Internal/adapters/repository"
	"github.com/Arjuna-Ragil/Localbase/Internal/config"
	"github.com/Arjuna-Ragil/Localbase/Internal/core/domain"
	"github.com/golang-jwt/jwt/v5"
	"github.com/google/uuid"
	"golang.org/x/crypto/bcrypt"
)

type AuthService struct {
	AuthRepo *repository.AuthRepo
	SysRepo  *repository.SystemRepo
}

type RegisterInput struct {
	Username string `json:"username" binding:"required"`
	Email    string `json:"email" binding:"required,email"`
	Password string `json:"password" binding:"required,min=6"`
	Role     string `json:"role" binding:"required"`
	Token    string `json:"token"`
}

type LoginInput struct {
	Email    string `json:"email" binding:"required,email"`
	Password string `json:"password" binding:"required,min=6"`
}

func NewAuthService(auth *repository.AuthRepo, sys *repository.SystemRepo) *AuthService {
	return &AuthService{AuthRepo: auth, SysRepo: sys}
}

func (as *AuthService) RegisterService(input *RegisterInput) error {
	isInitialized, err := as.SysRepo.IsAppInitialized()
	if err != nil {
		return err
	}

	if !isInitialized {
		user := domain.User{
			Username: input.Username,
			Email:    input.Email,
			Password: input.Password,
			Role:     "admin",
		}

		if err := as.AuthRepo.RegisterRepo(&user); err != nil {
			return err
		}

	} else {
		if input.Token == "" {
			return errors.New("token is required")
		}

		invite, err := as.VerifyInviteService(input.Token)
		if err != nil {
			return err
		}

		if invite.Email == "" && invite.Email != input.Email {
			return errors.New("email does not match")
		}

		user := domain.User{
			Username: input.Username,
			Email:    invite.Email,
			Password: input.Password,
			Role:     invite.Role,
		}

		if err := as.AuthRepo.MarkInviteUsed(input.Token); err != nil {
			return err
		}

		if err := as.AuthRepo.RegisterRepo(&user); err != nil {
			return err
		}
	}
	return nil
}

func (as *AuthService) LoginService(input *LoginInput) (string, error) {
	cfg := config.LoadConfig()

	user, err := as.AuthRepo.LoginRepo(input.Email)
	if err != nil {
		return "", err
	}
	if err := bcrypt.CompareHashAndPassword([]byte(user.Password), []byte(input.Password)); err != nil {
		return "", err
	}
	token := jwt.NewWithClaims(jwt.SigningMethodHS256, jwt.MapClaims{
		"sub": user.Id,
		"exp": time.Now().Add(time.Hour * 48).Unix(),
	})
	tokenString, err := token.SignedString([]byte(cfg.SecretKey))
	if err != nil {
		return "", err
	}
	return tokenString, nil
}

func (as *AuthService) GenerateInviteService(email string, role string) (string, error) {
	token := uuid.NewString()
	expiresAt := time.Now().Add(time.Hour * 24)
	invite := domain.Invitation{
		Email:     email,
		Token:     token,
		Role:      role,
		Used:      false,
		ExpiresAt: expiresAt,
	}
	if err := as.AuthRepo.CreateInvite(&invite); err != nil {
		return "", err
	}
	linkInvite := "http://localhost:5173/registerinvite?token=" + token //Change link if different
	return linkInvite, nil
}

func (as *AuthService) VerifyInviteService(token string) (*domain.Invitation, error) {
	invite, err := as.AuthRepo.FindInviteByToken(token)
	if err != nil {
		return nil, err
	}
	if invite.Used == true {
		return nil, errors.New("invite already used")
	}
	if time.Now().After(invite.ExpiresAt) {
		return nil, errors.New("invite expired")
	}
	return invite, nil
}