package services

import (
	"fmt"
	"os"
	"time"

	"github.com/golang-jwt/jwt/v5"
	"github.com/google/uuid"
	"veza-backend-api/internal/models"
)

// Claims représente les claims JWT
// MIGRATION UUID: UserID est maintenant un UUID (string dans JSON)
type Claims struct {
	UserID       uuid.UUID `json:"sub"` // UUID serialized as string in JSON
	Email        string    `json:"email"`
	Role         string    `json:"role"`
	TokenVersion int       `json:"token_version"`
	jwt.RegisteredClaims
}

type JWTService struct {
	secretKey []byte
}

func NewJWTService(secret string) *JWTService {
	if secret == "" {
		// Fallback to env for safety during transition, or panic if strict
		secret = os.Getenv("JWT_SECRET")
		if secret == "" {
			panic("JWT secret is required")
		}
	}
	return &JWTService{secretKey: []byte(secret)}
}

func (s *JWTService) GenerateAccessToken(user *models.User) (string, error) {
	claims := Claims{
		UserID:       user.ID,
		Email:        user.Email,
		Role:         user.Role,
		TokenVersion: user.TokenVersion,
		RegisteredClaims: jwt.RegisteredClaims{
			ExpiresAt: jwt.NewNumericDate(time.Now().Add(15 * time.Minute)),
			IssuedAt:  jwt.NewNumericDate(time.Now()),
			Issuer:    "veza-api",
		},
	}

	token := jwt.NewWithClaims(jwt.SigningMethodHS256, claims)
	return token.SignedString(s.secretKey)
}

func (s *JWTService) GenerateRefreshToken(user *models.User) (string, error) {
	claims := Claims{
		UserID:       user.ID,
		TokenVersion: user.TokenVersion,
		RegisteredClaims: jwt.RegisteredClaims{
			ExpiresAt: jwt.NewNumericDate(time.Now().Add(30 * 24 * time.Hour)), // T0163: 30 days instead of 7
			IssuedAt:  jwt.NewNumericDate(time.Now()),
			Issuer:    "veza-api",
		},
	}

	token := jwt.NewWithClaims(jwt.SigningMethodHS256, claims)
	return token.SignedString(s.secretKey)
}

// GenerateTokenPair génère une paire de tokens (access + refresh) en une seule opération
// T0163: Génère access token (15min) et refresh token (30 jours) avec claims user_id, email, role
func (s *JWTService) GenerateTokenPair(user *models.User) (*TokenPair, error) {
	// Generate access token
	accessToken, err := s.GenerateAccessToken(user)
	if err != nil {
		return nil, fmt.Errorf("failed to generate access token: %w", err)
	}

	// Generate refresh token
	refreshToken, err := s.GenerateRefreshToken(user)
	if err != nil {
		return nil, fmt.Errorf("failed to generate refresh token: %w", err)
	}

	return &TokenPair{
		AccessToken:  accessToken,
		RefreshToken: refreshToken,
	}, nil
}

// VerifyToken valide et parse un token JWT
// T0171: Méthode de validation complète du token
func (s *JWTService) VerifyToken(tokenString string) (*Claims, error) {
	return s.ValidateToken(tokenString)
}

// ValidateToken valide un token JWT et retourne les claims
// T0171: Méthode de validation du token (alias de VerifyToken pour cohérence)
func (s *JWTService) ValidateToken(tokenString string) (*Claims, error) {
	token, err := jwt.ParseWithClaims(tokenString, &Claims{}, func(token *jwt.Token) (interface{}, error) {
		if _, ok := token.Method.(*jwt.SigningMethodHMAC); !ok {
			return nil, fmt.Errorf("unexpected signing method: %v", token.Header["alg"])
		}
		return s.secretKey, nil
	})

	if err != nil {
		return nil, fmt.Errorf("failed to parse token: %w", err)
	}

	if claims, ok := token.Claims.(*Claims); ok && token.Valid {
		// Token version check: vérifier la version du token
		// Note: La vérification complète nécessitera de comparer avec user.TokenVersion en DB
		// Pour l'instant, on retourne les claims si le token est valide
		return claims, nil
	}

	return nil, fmt.Errorf("invalid token")
}

// ParseToken parse un token JWT sans validation complète (utilise ValidateToken)
// T0171: Méthode de parsing du token
func (s *JWTService) ParseToken(tokenString string) (*Claims, error) {
	return s.ValidateToken(tokenString)
}

// ExtractClaims extrait les claims d'un token JWT
// T0171: Méthode d'extraction des claims (alias de ValidateToken)
func (s *JWTService) ExtractClaims(tokenString string) (*Claims, error) {
	return s.ValidateToken(tokenString)
}

// ExtractUserID extrait l'ID utilisateur depuis un token JWT
// T0171: Méthode d'extraction de l'UserID
// MIGRATION UUID: Retourne maintenant un UUID
func (s *JWTService) ExtractUserID(tokenString string) (uuid.UUID, error) {
	claims, err := s.ValidateToken(tokenString)
	if err != nil {
		return uuid.Nil, fmt.Errorf("failed to extract user ID: %w", err)
	}
	return claims.UserID, nil
}

// VerifyTokenVersion vérifie si la version du token correspond à celle de l'utilisateur
// Cette fonction doit être appelée après VerifyToken pour une vérification complète
func (s *JWTService) VerifyTokenVersion(claims *Claims, userTokenVersion int) error {
	if claims.TokenVersion != userTokenVersion {
		return fmt.Errorf("token version mismatch: token version %d does not match user version %d", claims.TokenVersion, userTokenVersion)
	}
	return nil
}

