package authentication

import (
	"errors"
	"netina/database"
	Role_repository "netina/repositories/role"
	User_repository "netina/repositories/user"
	"os"
	"time"

	"netina/models"

	"github.com/dgrijalva/jwt-go"
	"github.com/joho/godotenv"
)

// Load the environment variables from the .env file
func loadEnv() {
    err := godotenv.Load("./config/.env")
    if err != nil {
        panic("Error loading .env file")
    }
}

// GenerateJWT generates a new JWT token.
func GenerateJWT(claims *models.JWTClaims) (string, error) {
    loadEnv()
    secretKey := os.Getenv("SECRET_KEY")
    if secretKey == "" {
        return "", errors.New("SECRET_KEY is not set in the environment variables")
    }

    token := jwt.NewWithClaims(jwt.SigningMethodHS256, claims)
    tokenString, err := token.SignedString([]byte(secretKey))
    if err != nil {
        return "", err
    }

    return tokenString, nil
}

// ValidateJWT validates a given JWT token.
func ValidateJWT(tokenString string) (*models.JWTClaims, error) {
    loadEnv()
    secretKey := os.Getenv("SECRET_KEY")
    if secretKey == "" {
        return nil, errors.New("SECRET_KEY is not set in the environment variables")
    }

    token, err := jwt.ParseWithClaims(tokenString, &models.JWTClaims{}, func(token *jwt.Token) (interface{}, error) {
        if _, ok := token.Method.(*jwt.SigningMethodHMAC); !ok {
            return nil, errors.New("unexpected signing method")
        }
        return []byte(secretKey), nil
    })
    if err != nil {
        return nil, err
    }

    if claims, ok := token.Claims.(*models.JWTClaims); ok && token.Valid {
        return claims, nil
    }

    return nil, errors.New("invalid token")
}

// GenerateClaims creates JWT claims.
func GenerateClaims(userID uint) (*models.JWTClaims , error) {
    db := database.Db()
	role_query := Role_repository.RoleQueryRepository{DB: &db}
    user_query := User_repository.UserQueryRepository{DB: &db}

    user , err := user_query.GetUser(userID)
    if err != nil {
        return nil , err
    }

    role , err := role_query.GetRole(user.Role_id)
    if err != nil {
        return nil , err
    }

    cliams := &models.JWTClaims{
        ID: user.User_id,
        Role: role.Name,
        StandardClaims: jwt.StandardClaims{
            ExpiresAt: time.Now().Add(time.Hour * 2).Unix(),

        },
    }

    return cliams , nil

}