from __future__ import annotations

import time

from fastapi import APIRouter, Depends

from app.api.deps import require_auth
from app.models.schemas import (
    TokenGenerateRequest,
    TokenGenerateResponse,
    TokenValidateRequest,
    TokenValidateResponse,
)
from app.services.jwt_service import JWTService

router = APIRouter()
_service = JWTService()


@router.post(
    "/token/generate",
    response_model=TokenGenerateResponse,
    summary="Generate a signed JWT token with custom claims",
)
async def generate_token(
    body: TokenGenerateRequest,
    auth: str = Depends(require_auth),
) -> TokenGenerateResponse:
    start = time.perf_counter()
    try:
        result = _service.generate(
            subject=body.subject,
            role=body.role,
            permissions=body.permissions,
            issuer=body.issuer,
            audience=body.audience,
            expiry_minutes=body.expiry_minutes,
            not_before_minutes=body.not_before_minutes,
            extra_claims=body.extra_claims,
            secret=body.secret,
            algorithm=body.algorithm,
        )
        elapsed_ms = round((time.perf_counter() - start) * 1000, 3)
        return TokenGenerateResponse(
            success=True,
            time_ms=elapsed_ms,
            token=result["token"],
            claims=result["claims"],
            expires_at=result["expires_at"],
            valid_for=result.get("valid_for"),
            secret=result.get("secret"),
            algorithm=result["algorithm"],
        )
    except Exception as exc:
        elapsed_ms = round((time.perf_counter() - start) * 1000, 3)
        return TokenGenerateResponse(
            success=False,
            time_ms=elapsed_ms,
            error=str(exc),
        )


@router.post(
    "/token/validate",
    response_model=TokenValidateResponse,
    summary="Validate a JWT token and return its claims",
)
async def validate_token(
    body: TokenValidateRequest,
    auth: str = Depends(require_auth),
) -> TokenValidateResponse:
    start = time.perf_counter()
    try:
        result = _service.validate(body.token, body.audience, body.secret, body.algorithm)
        elapsed_ms = round((time.perf_counter() - start) * 1000, 3)
        return TokenValidateResponse(
            success=True,
            time_ms=elapsed_ms,
            valid=result["valid"],
            claims=result["claims"],
            error=result["error"],
        )
    except Exception as exc:
        elapsed_ms = round((time.perf_counter() - start) * 1000, 3)
        return TokenValidateResponse(
            success=False,
            time_ms=elapsed_ms,
            valid=False,
            error=str(exc),
        )