from typing import Any

from fastapi import APIRouter, Depends, HTTPException
from common_logging import get_logger
from sqlalchemy.orm import Session

from app.api.deps import get_current_user
from app.config import settings
from app.db.session import get_db
from app.models.knowledge_base import KnowledgeBase
from app.models.user import User
from app.services.storage.milvus import get_vector_store
from common_logging import get_logger

logger = get_logger(__name__)

router = APIRouter()
logger = get_logger(__name__)


@router.get("/milvus/health")
async def check_milvus_health(
    db: Session = Depends(get_db), current_user: User = Depends(get_current_user)
) -> dict[str, Any]:
    logger.info(f"Checking Milvus health, user={current_user.id}")
    try:
        vector_store = get_vector_store(db)
        stats = vector_store.get_collection_stats()
        logger.info(f"Milvus health check passed: {stats.get('total_vectors', 0)} vectors")
        return {
            "status": "healthy",
            "vector_store_type": settings.VECTOR_STORE_TYPE,
            "milvus_host": settings.MILVUS_HOST,
            "milvus_port": settings.MILVUS_PORT,
            "use_milvus_lite": settings.USE_MILVUS_LITE,
            "collection_name": stats.get("collection_name"),
            "total_vectors": stats.get("total_vectors", 0),
        }
    except Exception as e:
        logger.error(f"Milvus health check failed: {e}")
        return {
            "status": "unhealthy",
            "error": str(e),
            "vector_store_type": settings.VECTOR_STORE_TYPE,
        }


@router.get("/milvus/stats")
async def get_milvus_stats(
    db: Session = Depends(get_db), current_user: User = Depends(get_current_user)
) -> dict[str, Any]:
    try:
        knowledge_bases = db.query(KnowledgeBase).all()
        kb_stats = []
        total_vectors = 0
        for kb in knowledge_bases:
            try:
                vector_store = get_vector_store(db, kb.id)
                stats = vector_store.get_collection_stats()
                kb_stats.append(
                    {
                        "knowledge_base_id": kb.id,
                        "knowledge_base_name": kb.name,
                        "vector_count": stats.get("total_vectors", 0),
                        "status": kb.status,
                    }
                )
                total_vectors += stats.get("total_vectors", 0)
            except Exception as e:
                logger.error(f"Failed to get statistics for knowledge base {kb.id}: {e}")
                kb_stats.append(
                    {"knowledge_base_id": kb.id, "knowledge_base_name": kb.name, "error": str(e)}
                )
        return {
            "vector_store_type": settings.VECTOR_STORE_TYPE,
            "total_knowledge_bases": len(knowledge_bases),
            "total_vectors": total_vectors,
            "knowledge_bases": kb_stats,
            "milvus_config": {
                "host": settings.MILVUS_HOST,
                "port": settings.MILVUS_PORT,
                "use_lite": settings.USE_MILVUS_LITE,
            },
        }
    except Exception as e:
        logger.error(f"Failed to get Milvus statistics: {e}")
        raise HTTPException(status_code=500, detail=str(e)) from None


@router.get("/milvus/knowledge-base/{knowledge_base_id}/stats")
async def get_knowledge_base_vector_stats(
    knowledge_base_id: int,
    db: Session = Depends(get_db),
    current_user: User = Depends(get_current_user),
) -> dict[str, Any]:
    try:
        kb = db.query(KnowledgeBase).filter(KnowledgeBase.id == knowledge_base_id).first()
        if not kb:
            raise HTTPException(status_code=404, detail="知识库不存在")
        vector_store = get_vector_store(db, knowledge_base_id)
        stats = vector_store.get_collection_stats()
        return {
            "knowledge_base_id": knowledge_base_id,
            "knowledge_base_name": kb.name,
            "vector_count": stats.get("total_vectors", 0),
            "collection_name": stats.get("collection_name"),
            "status": kb.status,
            "doc_count": kb.doc_count,
        }
    except HTTPException:
        raise
    except Exception as e:
        logger.error(f"Failed to get vector statistics for knowledge base {knowledge_base_id}: {e}")
        raise HTTPException(status_code=500, detail=str(e)) from None


@router.post("/milvus/knowledge-base/{knowledge_base_id}/reindex")
async def reindex_knowledge_base(
    knowledge_base_id: int,
    db: Session = Depends(get_db),
    current_user: User = Depends(get_current_user),
) -> dict[str, Any]:
    try:
        kb = db.query(KnowledgeBase).filter(KnowledgeBase.id == knowledge_base_id).first()
        if not kb:
            raise HTTPException(status_code=404, detail="知识库不存在")
        get_vector_store(db, knowledge_base_id)
        logger.info(f"Index for knowledge base {kb.name} is automatically managed by Milvus")
        return {
            "success": True,
            "message": f"知识库 {kb.name} 的索引由 Milvus 自动管理",
            "knowledge_base_id": knowledge_base_id,
        }
    except HTTPException:
        raise
    except Exception as e:
        logger.error(f"Failed to rebuild index for knowledge base {knowledge_base_id}: {e}")
        raise HTTPException(status_code=500, detail=str(e)) from None