package middlewares

import (
	"GoMembership/internal/config"
	"GoMembership/pkg/logger"
	"fmt"
	"net/http"
	"time"

	"github.com/gin-gonic/gin"
	"github.com/golang-jwt/jwt/v5"
)

var (
	jwtKey           = []byte(config.Auth.JWTSecret)
	jwtSigningMethod = jwt.SigningMethodHS256
	jwtParser        = jwt.NewParser(jwt.WithValidMethods([]string{jwtSigningMethod.Alg()}))
)

func GenerateToken(userID int64) (string, error) {
	token := jwt.NewWithClaims(jwtSigningMethod, jwt.MapClaims{
		"user_id": userID,
		"exp":     time.Now().Add(time.Minute * 10).Unix(), // Token expires in 10 Minutes
	})

	logger.Error.Printf("token generated: %#v", token)
	return token.SignedString(jwtKey)
}

func verifyToken(tokenString string) (*jwt.Token, error) {
	token, err := jwtParser.Parse(tokenString, func(_ *jwt.Token) (interface{}, error) {
		return jwtKey, nil
	})

	if err != nil {
		return nil, err
	}

	return token, nil
}
func GetUserIDFromContext(c *gin.Context) (int64, error) {

	tokenString, err := c.Cookie("jwt")
	if err != nil {

		logger.Error.Printf("Error getting cookie: %v\n", err)
		return 0, err
	}
	if tokenString == "" {
		logger.Error.Printf("Token is empty: %v\n", err)
		return 0, fmt.Errorf("Authorization token is required")
	}

	token, err := verifyToken(tokenString)
	if err != nil || !token.Valid {

		logger.Error.Printf("Token is invalid: %v\n", err)
		return 0, fmt.Errorf("Token not valid!")
	}

	claims, ok := token.Claims.(jwt.MapClaims)

	logger.Error.Printf("claims userid: %v", claims["user_id"].(float64))
	if !ok {
		logger.Error.Printf("Invalid Token claims")
		return 0, fmt.Errorf("Invalid token claims")
	}
	userID, ok := claims["user_id"].(float64)

	if !ok {
		logger.Error.Printf("Invalid user ID: %v", userID)
		return 0, fmt.Errorf("Invalid user ID")
	}

	return int64(userID), nil
}

func AuthMiddleware() gin.HandlerFunc {
	return func(c *gin.Context) {

		userID, err := GetUserIDFromContext(c)
		if err != nil {
			c.JSON(http.StatusUnauthorized, gin.H{"error": err.Error()})
			c.Abort()
			return
		}

		// Generate a new token
		newToken, err := GenerateToken(int64(userID))
		if err != nil {
			c.JSON(http.StatusInternalServerError, gin.H{"error": "Failed to refresh token"})
			c.Abort()
			return
		}

		c.SetCookie(
			"jwt",
			newToken,
			10*60, // 10 minutes
			"/",
			"",
			true,
			true,
		)
		c.Set("user_id", userID)
		c.Next()
	}
}