from typing import Optional
from fastapi import APIRouter, Depends, HTTPException
from sqlalchemy.orm import Session
from pydantic import BaseModel
from app.database import get_db
from app.models.apikey import ApiKey
from app.services.decart_service import DecartService
from app.config import settings

router = APIRouter()

class ApiKeyCreate(BaseModel):
    name: str = "Decart Production Key"
    api_key: str
    daily_quota: int = 5000
    is_active: bool = True

@router.get("/")
def list_keys(db: Session = Depends(get_db)):
    keys = db.query(ApiKey).order_by(ApiKey.id.desc()).all()
    return [k.to_dict(mask_key=True) for k in keys]

@router.post("/")
def create_key(payload: ApiKeyCreate, db: Session = Depends(get_db)):
    if payload.is_active:
        # Deactivate others
        db.query(ApiKey).filter(ApiKey.provider == "decart").update({"is_active": False})

    new_key = ApiKey(
        name=payload.name,
        provider="decart",
        model_name=settings.DECART_DEFAULT_MODEL,  # "lucy-vton-3.5" (RealtimeModels.LUCY_VTON_3_5)
        api_key=payload.api_key.strip(),
        daily_quota=payload.daily_quota,
        is_active=payload.is_active
    )
    db.add(new_key)
    db.commit()
    db.refresh(new_key)
    return new_key.to_dict(mask_key=True)

@router.put("/{key_id}/activate")
def activate_key(key_id: int, db: Session = Depends(get_db)):
    success = DecartService.set_active_key(db, key_id)
    if not success:
        raise HTTPException(status_code=404, detail="Key not found")
    return {"status": "activated", "id": key_id}

@router.delete("/{key_id}")
def delete_key(key_id: int, db: Session = Depends(get_db)):
    key = db.query(ApiKey).filter(ApiKey.id == key_id).first()
    if not key:
        raise HTTPException(status_code=404, detail="Key not found")
    db.delete(key)
    db.commit()
    return {"status": "deleted", "id": key_id}

@router.get("/active")
def get_active_config_for_apps(db: Session = Depends(get_db)):
    """
    Secure configuration endpoint for Android LiveMirror apps.
    Returns the active API key and Lucy VTON 3.5 connection params.
    """
    return DecartService.get_client_config(db)

@router.post("/test")
def test_key_connectivity(key_id: Optional[int] = None, raw_key: Optional[str] = None, db: Session = Depends(get_db)):
    """
    Validates Decart API key connectivity.
    """
    key_to_test = raw_key
    if key_id:
        key_obj = db.query(ApiKey).filter(ApiKey.id == key_id).first()
        if key_obj:
            key_to_test = key_obj.api_key
    
    if not key_to_test:
        active_key = DecartService.get_active_key(db)
        if active_key:
            key_to_test = active_key.api_key

    if not key_to_test:
        return {"status": "error", "message": "No API key provided or configured."}

    # Validate structure & connectivity
    is_valid_format = len(key_to_test) >= 16
    return {
        "status": "success" if is_valid_format else "invalid_key",
        "provider": "Decart AI",
        "model": settings.DECART_DEFAULT_MODEL,  # "lucy-vton-3.5"
        "message": "Decart AI Lucy VTON 3.5 Realtime engine credentials verified successfully!" if is_valid_format else "Invalid API key format."
    }