import secrets
import json
import uuid
from datetime import datetime, timedelta
from fastapi import APIRouter, Depends, HTTPException, status
from sqlalchemy.orm import Session
from app.models.database import get_db
from app.models.client import Client
from app.models.audit import AuditLog
from app.security.auth import hash_api_key
from app.security.dependencies import verify_admin
from app.schemas.api import ClientCreate, ClientResponse, ClientCreateResponse, AuditLogResponse, PackageGrant

router = APIRouter(tags=["admin"])


@router.post("/admin/clients", response_model=ClientCreateResponse)
def create_client(
    body: ClientCreate,
    db: Session = Depends(get_db),
    _: bool = Depends(verify_admin),
):
    api_key = "sk_live_" + secrets.token_urlsafe(32)
    client = Client(
        id=str(uuid.uuid4()),
        name=body.name,
        email=body.email,
        api_key_hash=hash_api_key(api_key),
        rate_limit_per_min=body.rate_limit_per_min,
        scopes=json.dumps(body.scopes),
        active=True,
    )
    db.add(client)
    db.commit()
    db.refresh(client)

    return ClientCreateResponse(
        id=client.id,
        name=client.name,
        email=client.email,
        rate_limit_per_min=client.rate_limit_per_min,
        scopes=client.scopes,
        active=client.active,
        created_at=client.created_at,
        api_key=api_key,
    )


@router.get("/admin/clients", response_model=list[ClientResponse])
def list_clients(
    db: Session = Depends(get_db),
    _: bool = Depends(verify_admin),
):
    return db.query(Client).filter(Client.deleted_at == None).all()  # noqa: E711


@router.get("/admin/clients/{client_id}/logs", response_model=list[AuditLogResponse])
def get_client_logs(
    client_id: str,
    page: int = 1,
    limit: int = 50,
    db: Session = Depends(get_db),
    _: bool = Depends(verify_admin),
):
    client = db.query(Client).filter(Client.id == client_id).first()
    if not client:
        raise HTTPException(status_code=status.HTTP_404_NOT_FOUND, detail="Cliente no encontrado")

    offset = (page - 1) * limit
    logs = (
        db.query(AuditLog)
        .filter(AuditLog.client_id == client_id)
        .order_by(AuditLog.timestamp.desc())
        .offset(offset)
        .limit(limit)
        .all()
    )
    return logs


@router.post("/admin/clients/{client_id}/package", response_model=ClientResponse)
def grant_package(
    client_id: str,
    body: PackageGrant,
    db: Session = Depends(get_db),
    _: bool = Depends(verify_admin),
):
    client = db.query(Client).filter(
        Client.id == client_id,
        Client.deleted_at == None,  # noqa: E711
    ).first()
    if not client:
        raise HTTPException(status_code=status.HTTP_404_NOT_FOUND, detail="Cliente no encontrado")

    if body.credits <= 0 or body.days_valid <= 0:
        raise HTTPException(
            status_code=status.HTTP_422_UNPROCESSABLE_ENTITY,
            detail="credits y days_valid deben ser mayores a 0",
        )

    client.credits_remaining = (client.credits_remaining or 0) + body.credits
    client.credits_expire_at = datetime.utcnow() + timedelta(days=body.days_valid)
    db.commit()
    db.refresh(client)
    return client


@router.delete("/admin/clients/{client_id}", status_code=status.HTTP_204_NO_CONTENT)
def delete_client(
    client_id: str,
    db: Session = Depends(get_db),
    _: bool = Depends(verify_admin),
):
    client = db.query(Client).filter(
        Client.id == client_id,
        Client.deleted_at == None,  # noqa: E711
    ).first()
    if not client:
        raise HTTPException(status_code=status.HTTP_404_NOT_FOUND, detail="Cliente no encontrado")

    client.active = False
    client.deleted_at = datetime.utcnow()
    db.commit()