package services

import (
	"GoMembership/internal/constants"
	"GoMembership/internal/models"
	"GoMembership/internal/repositories"
	"GoMembership/internal/utils"
	"GoMembership/pkg/logger"
	"github.com/go-playground/validator/v10"
	// "crypto/rand"
	// "encoding/base64"
	// "golang.org/x/crypto/bcrypt"
	"time"
)

type UserServiceInterface interface {
	RegisterUser(user *models.User) (int64, string, error)
	// AuthenticateUser(email, password string) (*models.User, error)A
	VerifyUser(token *string) (*models.User, error)
}

type UserService struct {
	Repo repositories.UserRepositoryInterface
}

func (service *UserService) RegisterUser(user *models.User) (int64, string, error) {
	/* salt := make([]byte, 16)
	if _, err := rand.Read(salt); err != nil {
		return -1, err
	}
	user.Salt = base64.StdEncoding.EncodeToString(salt)
	*/
	err := validateRegistrationData(user)
	if err != nil {
		return -1, "", err
	}

	user.Status = constants.UnverifiedStatus
	user.CreatedAt = time.Now()
	user.UpdatedAt = time.Now()

	id, err := service.Repo.CreateUser(user)
	if err != nil {
		return -1, "", err
	}

	user.ID = id

	token, err := utils.GenerateVerificationToken()
	if err != nil {
		return -1, "", err
	}

	logger.Info.Printf("TOKEN: %v", token)

	_, err = service.Repo.SetVerificationToken(user, &token)
	if err != nil {
		return -1, "", err
	}

	return id, token, nil
}

func (service *UserService) VerifyUser(token *string) (*models.User, error) {
	user, err := service.Repo.VerifyUserOfToken(token)
	if err != nil {
		return nil, err
	}
	return user, nil
}

func validateRegistrationData(user *models.User) error {
	validate := validator.New()
	validate.RegisterValidation("age", utils.AgeValidator)
	validate.RegisterValidation("bic", utils.BICValidator)
	validate.RegisterValidation("iban", utils.IBANValidator)
	validate.RegisterValidation("subscriptionModel", utils.SubscriptionModelValidator)

	return validate.Struct(user)
}

/* func HashPassword(password string, salt string) (string, error) {
	saltedPassword := password + salt
	hashedPassword, err := bcrypt.GenerateFromPassword([]byte(saltedPassword), bcrypt.DefaultCost)
	if err != nil {

		return "", err
	}
	return base64.StdEncoding.EncodeToString(hashedPassword), nil
} */

/* func (s *UserService) AuthenticateUser(email, password string) (*models.User, error) {
	user, err := s.repo.FindUserByEmail(email)
	if err != nil {
		return nil, errors.ErrUserNotFound
	}

	if !verifyPassword(password, user.Password, user.Salt) {
		return nil, errors.ErrInvalidCredentials
	}

	return user, nil
}
*/
/* func verifyPassword(password string, storedPassword string, salt string) bool {

	saltedPassword := password + salt
	decodedStoredPassword, err := base64.StdEncoding.DecodeString(storedPassword)
	if err != nil {
		return false
	}
	err = bcrypt.CompareHashAndPassword([]byte(decodedStoredPassword), []byte(saltedPassword))
	return err == nil
} */