import json
import secrets
from fastapi import APIRouter, Depends, HTTPException, Request
from sqlalchemy.orm import Session

from ..database import get_db
from .. import models
from ..auth import get_current_user, encrypt_api_key
from ..schemas import ProxyCreate, ProxyUpdate, ProxyOut

router = APIRouter(prefix="/proxies", tags=["Proxy Management"])


def _proxy_out_with_url(proxy: models.ProxyConfig, request: Request) -> dict:
    base = str(request.base_url).rstrip("/")
    return {
        **ProxyOut.model_validate(proxy).model_dump(),
        "proxy_url": f"{base}/{proxy.proxy_token}",
    }


@router.post("", status_code=201)
def create_proxy(
    payload: ProxyCreate,
    request: Request,
    db: Session = Depends(get_db),
    current_user: models.User = Depends(get_current_user),
):
    token = secrets.token_urlsafe(24)
    proxy = models.ProxyConfig(
        user_id=current_user.id,
        proxy_token=token,
        name=payload.name,
        openai_base_url=payload.openai_base_url.rstrip("/"),
        encrypted_api_key=encrypt_api_key(payload.openai_api_key),
        model_mapping=json.dumps(payload.model_mapping or {}),
    )
    db.add(proxy)
    db.commit()
    db.refresh(proxy)
    return _proxy_out_with_url(proxy, request)


@router.get("", response_model=list)
def list_proxies(
    request: Request,
    db: Session = Depends(get_db),
    current_user: models.User = Depends(get_current_user),
):
    proxies = db.query(models.ProxyConfig).filter(
        models.ProxyConfig.user_id == current_user.id
    ).all()
    return [_proxy_out_with_url(p, request) for p in proxies]


@router.get("/{proxy_id}")
def get_proxy(
    proxy_id: int,
    request: Request,
    db: Session = Depends(get_db),
    current_user: models.User = Depends(get_current_user),
):
    proxy = db.query(models.ProxyConfig).filter(
        models.ProxyConfig.id == proxy_id,
        models.ProxyConfig.user_id == current_user.id,
    ).first()
    if not proxy:
        raise HTTPException(status_code=404, detail="Proxy not found")
    return _proxy_out_with_url(proxy, request)


@router.patch("/{proxy_id}")
def update_proxy(
    proxy_id: int,
    payload: ProxyUpdate,
    request: Request,
    db: Session = Depends(get_db),
    current_user: models.User = Depends(get_current_user),
):
    proxy = db.query(models.ProxyConfig).filter(
        models.ProxyConfig.id == proxy_id,
        models.ProxyConfig.user_id == current_user.id,
    ).first()
    if not proxy:
        raise HTTPException(status_code=404, detail="Proxy not found")

    if payload.name is not None:
        proxy.name = payload.name
    if payload.openai_base_url is not None:
        proxy.openai_base_url = payload.openai_base_url.rstrip("/")
    if payload.openai_api_key is not None:
        proxy.encrypted_api_key = encrypt_api_key(payload.openai_api_key)
    if payload.model_mapping is not None:
        proxy.model_mapping = json.dumps(payload.model_mapping)

    db.commit()
    db.refresh(proxy)
    return _proxy_out_with_url(proxy, request)


@router.delete("/{proxy_id}", status_code=204)
def delete_proxy(
    proxy_id: int,
    db: Session = Depends(get_db),
    current_user: models.User = Depends(get_current_user),
):
    proxy = db.query(models.ProxyConfig).filter(
        models.ProxyConfig.id == proxy_id,
        models.ProxyConfig.user_id == current_user.id,
    ).first()
    if not proxy:
        raise HTTPException(status_code=404, detail="Proxy not found")
    db.delete(proxy)
    db.commit()