"""Phase 7 FastAPI application: LLM End-to-End Integration.

Features:
- Direct LLM integration (OpenAI, Anthropic, Local)
- Response streaming (Server-Sent Events)
- Redis caching with TTL
- RAG + LLM unified pipeline
- Multiple LLM provider support
"""

import asyncio
import hashlib
import json
import logging
import time
from typing import Optional, Dict, Any, AsyncGenerator
from datetime import datetime, timedelta

from fastapi import FastAPI, APIRouter, HTTPException, Query, Request, Depends
from fastapi.responses import StreamingResponse, JSONResponse
from pydantic import BaseModel, Field

try:
    import redis.asyncio as redis
    REDIS_AVAILABLE = True
except ImportError:
    REDIS_AVAILABLE = False

from ont_platform.core.graph.neo4j_adapter import Neo4jAdapter, Neo4jConfig
from ont_platform.core.graph.entity_resolver import EntityResolver
from ont_platform.core.graph.subgraph_retriever import SubgraphRetriever
from ont_platform.core.graph.pattern_matcher import PatternMatcher
from ont_platform.core.graph.graph_analytics import GraphAnalytics
from ont_platform.llm.llm_integration import LLMManager, LLMConfig, LLMProvider

logger = logging.getLogger(__name__)

# ============================================================================
# Request/Response Models
# ============================================================================


class AskRequest(BaseModel):
    """LLM query request."""
    query: str = Field(..., description="사용자 질문")
    context_hops: int = Field(2, description="그래프 컨텍스트 깊이")
    use_cache: bool = Field(True, description="캐시 사용 여부")
    temperature: Optional[float] = Field(None, description="LLM 온도 (0~1)")
    max_tokens: Optional[int] = Field(None, description="최대 토큰 수")


class AskResponse(BaseModel):
    """LLM query response."""
    query: str
    answer: str
    context_size: int
    relevant_entities: list[str]
    latency_ms: float
    cached: bool = False
    model: str
    provider: str


class StreamingAskRequest(BaseModel):
    """Streaming LLM query request."""
    query: str
    context_hops: int = 2
    temperature: Optional[float] = None
    max_tokens: Optional[int] = None


class RAGMetadata(BaseModel):
    """RAG metadata."""
    query: str
    context_nodes: int
    relevant_entities: list[str]
    extraction_time_ms: float
    llm_provider: str
    llm_model: str


# ============================================================================
# Global Instances
# ============================================================================

_neo4j_adapter: Optional[Neo4jAdapter] = None
_entity_resolver: Optional[EntityResolver] = None
_subgraph_retriever: Optional[SubgraphRetriever] = None
_pattern_matcher: Optional[PatternMatcher] = None
_graph_analytics: Optional[GraphAnalytics] = None
_llm_manager: Optional[LLMManager] = None
_redis_client: Optional[redis.Redis] = None

# ============================================================================
# FastAPI App
# ============================================================================

app = FastAPI(
    title="Ontology Platform - Phase 7 LLM Integration",
    description="LLM End-to-End Integration with Streaming & Caching",
    version="0.7.0",
)

llm_router = APIRouter(prefix="/api/v1/llm", tags=["llm"])


# ============================================================================
# Initialization Functions
# ============================================================================


async def get_neo4j_adapter() -> Neo4jAdapter:
    """Get or create Neo4j adapter instance."""
    global _neo4j_adapter
    if _neo4j_adapter is None:
        config = Neo4jConfig(
            uri="bolt://localhost:7687",
            username="neo4j",
            password="ontology123",
        )
        _neo4j_adapter = Neo4jAdapter(config)
        if not await _neo4j_adapter.connect():
            logger.warning("Neo4j not available")
        else:
            try:
                await _neo4j_adapter.initialize_embedder()
            except Exception as e:
                logger.warning(f"Failed to initialize embedder: {e}")
    return _neo4j_adapter


async def get_components():
    """Initialize all graph components."""
    global (
        _entity_resolver,
        _subgraph_retriever,
        _pattern_matcher,
        _graph_analytics,
    )

    adapter = await get_neo4j_adapter()

    if _entity_resolver is None:
        _entity_resolver = EntityResolver()
        await _entity_resolver.initialize_embedder()

    if _subgraph_retriever is None:
        _subgraph_retriever = SubgraphRetriever(adapter)

    if _pattern_matcher is None:
        _pattern_matcher = PatternMatcher(adapter)

    if _graph_analytics is None:
        _graph_analytics = GraphAnalytics(adapter)

    return {
        "adapter": adapter,
        "resolver": _entity_resolver,
        "retriever": _subgraph_retriever,
        "matcher": _pattern_matcher,
        "analytics": _graph_analytics,
    }


async def get_llm_manager() -> LLMManager:
    """Get or create LLM manager instance."""
    global _llm_manager
    if _llm_manager is None:
        # Default to OpenAI, but can be overridden via environment
        config = LLMConfig(
            provider=LLMProvider.OPENAI,
            api_key=None,  # Will use OPENAI_API_KEY env
            model="gpt-4",
            temperature=0.7,
            max_tokens=500,
        )
        _llm_manager = LLMManager(config)
    return _llm_manager


async def get_redis_client() -> Optional[redis.Redis]:
    """Get or create Redis client instance."""
    global _redis_client
    if not REDIS_AVAILABLE:
        return None

    if _redis_client is None:
        try:
            _redis_client = await redis.from_url(
                "redis://localhost:6379",
                decode_responses=True
            )
            await _redis_client.ping()
            logger.info("Redis connected successfully")
        except Exception as e:
            logger.warning(f"Redis not available: {e}")
            _redis_client = None
    return _redis_client


# ============================================================================
# Cache Utilities
# ============================================================================


def _generate_cache_key(query: str, context_hops: int) -> str:
    """Generate cache key from query and context."""
    key_data = f"{query}:{context_hops}"
    key_hash = hashlib.sha256(key_data.encode()).hexdigest()[:16]
    return f"phase7:rag:{key_hash}"


async def _get_cached_response(
    redis_client: Optional[redis.Redis],
    cache_key: str
) -> Optional[Dict[str, Any]]:
    """Retrieve cached response from Redis."""
    if not redis_client:
        return None

    try:
        cached = await redis_client.get(cache_key)
        if cached:
            logger.info(f"Cache hit: {cache_key}")
            return json.loads(cached)
    except Exception as e:
        logger.warning(f"Cache retrieval failed: {e}")

    return None


async def _cache_response(
    redis_client: Optional[redis.Redis],
    cache_key: str,
    response: Dict[str, Any],
    ttl_hours: int = 1
) -> bool:
    """Cache response in Redis."""
    if not redis_client:
        return False

    try:
        ttl_seconds = ttl_hours * 3600
        await redis_client.setex(
            cache_key,
            ttl_seconds,
            json.dumps(response, default=str)
        )
        logger.info(f"Cached response: {cache_key} (TTL: {ttl_hours}h)")
        return True
    except Exception as e:
        logger.warning(f"Cache storage failed: {e}")
        return False


# ============================================================================
# RAG Context Extraction
# ============================================================================


async def extract_rag_context(
    query: str,
    context_hops: int = 2,
    max_entities: int = 100,
) -> Dict[str, Any]:
    """Extract RAG context from knowledge graph."""
    start_time = time.time()
    components = await get_components()

    try:
        # 1. Find relevant entities by semantic similarity
        # Using entity resolver's embedding capability
        retriever = components["retriever"]

        # For now, retrieve a default context
        # In production, would search by query semantic similarity
        context_data = {
            "query": query,
            "nodes": [],
            "edges": [],
            "relevant_entities": [],
        }

        # Try to get context from first few entities as example
        try:
            # Get graph statistics to find some entities
            analytics = components["analytics"]
            stats = await analytics.get_graph_statistics()

            if stats.get("total_nodes", 0) > 0:
                # Get influential entities as relevant context
                influential = await analytics.find_influential_entities(top_n=5)
                context_data["relevant_entities"] = [
                    e.get("label", f"Entity_{e.get('entity_id')}")
                    for e in influential
                ]
                context_data["nodes"] = influential[:max_entities]
        except Exception as e:
            logger.warning(f"Failed to extract context: {e}")
            context_data["relevant_entities"] = []

        extraction_time = (time.time() - start_time) * 1000
        context_data["extraction_time_ms"] = extraction_time

        return context_data
    except Exception as e:
        logger.error(f"RAG context extraction failed: {e}")
        raise


# ============================================================================
# RAG Prompt Building
# ============================================================================


def _build_rag_prompt_for_llm(
    query: str,
    context: Dict[str, Any]
) -> str:
    """Build structured prompt with RAG context for LLM."""
    relevant_entities = context.get("relevant_entities", [])
    nodes = context.get("nodes", [])

    # Build context section
    context_str = ""
    if relevant_entities:
        context_str += "관련 엔티티:\n"
        for entity in relevant_entities[:10]:
            if isinstance(entity, dict):
                label = entity.get("label", "Unknown")
                entity_type = entity.get("type", "Unknown")
            else:
                label = str(entity)
                entity_type = "Unknown"
            context_str += f"- {label} ({entity_type})\n"

    if nodes:
        context_str += "\n그래프 정보:\n"
        for node in nodes[:5]:
            if isinstance(node, dict):
                label = node.get("label", "Unknown")
                context_str += f"- {label}\n"

    # Build system prompt with context
    prompt = f"""당신은 지식 그래프 기반 질문 답변 어시스턴트입니다.
다음 지식 그래프 정보를 참고하여 질문에 답변해주세요.

=== 지식 그래프 컨텍스트 ===
{context_str if context_str else "컨텍스트 없음"}

=== 사용자 질문 ===
{query}

위의 지식 그래프 정보를 바탕으로 명확하고 정확한 답변을 제공해주세요."""

    return prompt


# ============================================================================
# LLM Endpoints
# ============================================================================


@llm_router.post("/ask", response_model=AskResponse)
async def ask_llm(request: AskRequest) -> AskResponse:
    """
    LLM에 질문을 하고 캐시된 응답을 반환합니다.

    - RAG 컨텍스트 자동 추출
    - Redis 캐싱 (기본 1시간 TTL)
    - 단일 응답 반환
    """
    start_time = time.time()

    # 캐시 확인
    redis_client = await get_redis_client()
    cache_key = _generate_cache_key(request.query, request.context_hops)

    if request.use_cache:
        cached = await _get_cached_response(redis_client, cache_key)
        if cached:
            cached["cached"] = True
            cached["latency_ms"] = (time.time() - start_time) * 1000
            return AskResponse(**cached)

    try:
        # RAG 컨텍스트 추출
        context_start = time.time()
        context = await extract_rag_context(
            request.query,
            context_hops=request.context_hops
        )
        context_time = (time.time() - context_start) * 1000

        # 프롬프트 생성
        prompt = _build_rag_prompt_for_llm(request.query, context)

        # LLM 호출
        llm_manager = await get_llm_manager()
        llm_start = time.time()

        # LLM 설정 업데이트 (요청으로부터)
        if request.temperature is not None:
            llm_manager.config.temperature = request.temperature
        if request.max_tokens is not None:
            llm_manager.config.max_tokens = request.max_tokens

        answer = await llm_manager.generate(prompt, stream=False)
        llm_time = (time.time() - llm_start) * 1000

        # 응답 생성
        response_data = {
            "query": request.query,
            "answer": answer,
            "context_size": len(context.get("nodes", [])),
            "relevant_entities": context.get("relevant_entities", []),
            "latency_ms": (time.time() - start_time) * 1000,
            "cached": False,
            "model": llm_manager.config.model,
            "provider": llm_manager.config.provider.value,
        }

        # 응답 캐시
        if request.use_cache:
            await _cache_response(redis_client, cache_key, response_data)

        logger.info(
            f"LLM query completed. "
            f"Context: {context_time:.1f}ms, "
            f"LLM: {llm_time:.1f}ms, "
            f"Total: {response_data['latency_ms']:.1f}ms"
        )

        return AskResponse(**response_data)

    except Exception as e:
        logger.error(f"LLM query failed: {e}")
        raise HTTPException(status_code=500, detail=str(e))


@llm_router.post("/ask/stream")
async def ask_llm_stream(request: StreamingAskRequest):
    """
    LLM에 질문을 하고 스트리밍 응답을 반환합니다.

    - Server-Sent Events (SSE) 기반 스트리밍
    - 실시간 토큰 전달
    - 메타데이터 포함
    """

    async def stream_generator() -> AsyncGenerator[str, None]:
        """Stream LLM response tokens."""
        try:
            # RAG 컨텍스트 추출
            context = await extract_rag_context(
                request.query,
                context_hops=request.context_hops
            )

            # 메타데이터 전송
            metadata = {
                "type": "metadata",
                "query": request.query,
                "context_nodes": len(context.get("nodes", [])),
                "relevant_entities": context.get("relevant_entities", []),
                "extraction_time_ms": context.get("extraction_time_ms", 0),
            }
            yield f"data: {json.dumps(metadata)}\n\n"

            # 프롬프트 생성
            prompt = _build_rag_prompt_for_llm(request.query, context)

            # LLM 스트리밍 호출
            llm_manager = await get_llm_manager()

            if request.temperature is not None:
                llm_manager.config.temperature = request.temperature
            if request.max_tokens is not None:
                llm_manager.config.max_tokens = request.max_tokens

            # 토큰 스트리밍
            token_count = 0
            async for token in llm_manager.generate_stream(prompt):
                token_data = {
                    "type": "token",
                    "content": token,
                    "token_index": token_count,
                }
                yield f"data: {json.dumps(token_data)}\n\n"
                token_count += 1

            # 완료 신호
            completion = {
                "type": "complete",
                "total_tokens": token_count,
                "timestamp": datetime.now().isoformat(),
            }
            yield f"data: {json.dumps(completion)}\n\n"

        except Exception as e:
            error_data = {
                "type": "error",
                "message": str(e),
            }
            yield f"data: {json.dumps(error_data)}\n\n"
            logger.error(f"Streaming error: {e}")

    return StreamingResponse(
        stream_generator(),
        media_type="text/event-stream",
        headers={
            "Cache-Control": "no-cache",
            "X-Accel-Buffering": "no",
        }
    )


@llm_router.post("/ask/metadata")
async def get_rag_metadata(request: AskRequest) -> RAGMetadata:
    """
    RAG 추출 메타데이터만 반환 (LLM 호출 없음).

    - 컨텍스트 추출 시간만 측정
    - 응답 최소화 (메타데이터만)
    """
    try:
        context_start = time.time()
        context = await extract_rag_context(
            request.query,
            context_hops=request.context_hops
        )
        extraction_time = (time.time() - context_start) * 1000

        llm_manager = await get_llm_manager()

        return RAGMetadata(
            query=request.query,
            context_nodes=len(context.get("nodes", [])),
            relevant_entities=context.get("relevant_entities", []),
            extraction_time_ms=extraction_time,
            llm_provider=llm_manager.config.provider.value,
            llm_model=llm_manager.config.model,
        )
    except Exception as e:
        logger.error(f"Metadata retrieval failed: {e}")
        raise HTTPException(status_code=500, detail=str(e))


@llm_router.post("/configure")
async def configure_llm(
    provider: str = Query(..., description="LLM Provider: openai, anthropic, local"),
    model: str = Query(..., description="Model name"),
    api_key: Optional[str] = Query(None, description="API key (optional)"),
    temperature: float = Query(0.7, ge=0.0, le=2.0),
    max_tokens: int = Query(500, ge=1, le=4000),
) -> Dict[str, Any]:
    """
    LLM 설정 변경.

    - Provider 변경 (OpenAI, Anthropic, Local)
    - 모델 선택
    - 온도/토큰 조정
    """
    global _llm_manager

    try:
        provider_enum = LLMProvider[provider.upper()]
    except KeyError:
        raise HTTPException(
            status_code=400,
            detail=f"Unknown provider: {provider}. "
                   f"Choose from: {[p.value for p in LLMProvider]}"
        )

    try:
        config = LLMConfig(
            provider=provider_enum,
            api_key=api_key,
            model=model,
            temperature=temperature,
            max_tokens=max_tokens,
            base_url="http://localhost:1234/v1" if provider_enum == LLMProvider.LOCAL else None,
        )
        _llm_manager = LLMManager(config)

        return {
            "status": "configured",
            "provider": provider,
            "model": model,
            "temperature": temperature,
            "max_tokens": max_tokens,
        }
    except Exception as e:
        logger.error(f"LLM configuration failed: {e}")
        raise HTTPException(status_code=500, detail=str(e))


@llm_router.get("/info")
async def get_llm_info() -> Dict[str, Any]:
    """Get current LLM configuration and status."""
    try:
        llm_manager = await get_llm_manager()
        redis_client = await get_redis_client()

        return {
            "llm_provider": llm_manager.config.provider.value,
            "llm_model": llm_manager.config.model,
            "temperature": llm_manager.config.temperature,
            "max_tokens": llm_manager.config.max_tokens,
            "redis_available": redis_client is not None,
            "timestamp": datetime.now().isoformat(),
        }
    except Exception as e:
        logger.error(f"Failed to get LLM info: {e}")
        raise HTTPException(status_code=500, detail=str(e))


# ============================================================================
# Cache Management
# ============================================================================


@llm_router.delete("/cache")
async def clear_cache() -> Dict[str, str]:
    """모든 RAG 캐시 삭제."""
    redis_client = await get_redis_client()
    if not redis_client:
        return {"status": "redis_unavailable"}

    try:
        cursor = 0
        deleted = 0

        while True:
            cursor, keys = await redis_client.scan(
                cursor,
                match="phase7:rag:*",
                count=100
            )

            if keys:
                await redis_client.delete(*keys)
                deleted += len(keys)

            if cursor == 0:
                break

        return {
            "status": "success",
            "deleted_keys": str(deleted),
        }
    except Exception as e:
        logger.error(f"Cache clearing failed: {e}")
        raise HTTPException(status_code=500, detail=str(e))


@llm_router.get("/cache/info")
async def get_cache_info() -> Dict[str, Any]:
    """캐시 통계."""
    redis_client = await get_redis_client()
    if not redis_client:
        return {"redis_available": False}

    try:
        info = await redis_client.info()
        cursor = 0
        cache_keys = 0

        while True:
            cursor, keys = await redis_client.scan(
                cursor,
                match="phase7:rag:*",
                count=100
            )
            cache_keys += len(keys)

            if cursor == 0:
                break

        return {
            "redis_available": True,
            "used_memory_mb": info.get("used_memory", 0) / (1024 * 1024),
            "cache_keys": cache_keys,
            "redis_version": info.get("redis_version", "unknown"),
        }
    except Exception as e:
        logger.error(f"Cache info retrieval failed: {e}")
        return {"redis_available": False, "error": str(e)}


# ============================================================================
# Health & Info Endpoints
# ============================================================================


@app.get("/health")
async def health_check() -> Dict[str, Any]:
    """헬스 체크."""
    try:
        adapter = await get_neo4j_adapter()
        neo4j_ok = adapter is not None and adapter.driver is not None

        redis_client = await get_redis_client()
        redis_ok = redis_client is not None

        llm_manager = await get_llm_manager()

        return {
            "status": "healthy",
            "version": "0.7.0",
            "neo4j": "connected" if neo4j_ok else "disconnected",
            "redis": "available" if redis_ok else "unavailable",
            "llm_provider": llm_manager.config.provider.value,
            "timestamp": datetime.now().isoformat(),
        }
    except Exception as e:
        logger.error(f"Health check failed: {e}")
        return {
            "status": "unhealthy",
            "error": str(e),
        }


@app.get("/info")
async def get_platform_info() -> Dict[str, Any]:
    """플랫폼 정보."""
    try:
        adapter = await get_neo4j_adapter()
        components = await get_components()
        llm_manager = await get_llm_manager()

        # Graph stats
        analytics = components.get("analytics")
        try:
            stats = await analytics.get_graph_statistics() if analytics else {}
        except:
            stats = {}

        return {
            "platform": "Ontology System Construction Platform",
            "phase": "7 (LLM Integration)",
            "version": "0.7.0",
            "components": {
                "neo4j": "ok" if adapter else "unavailable",
                "entity_resolver": "ok" if components.get("resolver") else "unavailable",
                "subgraph_retriever": "ok" if components.get("retriever") else "unavailable",
                "pattern_matcher": "ok" if components.get("matcher") else "unavailable",
                "graph_analytics": "ok" if components.get("analytics") else "unavailable",
                "llm_manager": "ok" if llm_manager else "unavailable",
            },
            "graph_stats": stats,
            "llm_config": {
                "provider": llm_manager.config.provider.value,
                "model": llm_manager.config.model,
                "temperature": llm_manager.config.temperature,
                "max_tokens": llm_manager.config.max_tokens,
            },
        }
    except Exception as e:
        logger.error(f"Info retrieval failed: {e}")
        raise HTTPException(status_code=500, detail=str(e))


# ============================================================================
# Router Registration
# ============================================================================

app.include_router(llm_router)


if __name__ == "__main__":
    import uvicorn
    uvicorn.run(app, host="0.0.0.0", port=8001)