"""
Langfuse tracing integration for the agentic RAG pipeline.

Provides:
  get_langfuse_client()  — lazy singleton Langfuse client (self-hosted)
  get_langfuse_handler() — LangChain CallbackHandler for LangGraph node tracing
  traced_llm_call()      — context manager that wraps llm_client.generate()
                            into a GENERATION observation with token estimates
  push_score()           — attach eval scores to a trace

Gracefully degrades to no-op if LANGFUSE_ENABLED=false or langfuse not installed.
"""

from __future__ import annotations

import logging
import time
from contextlib import contextmanager
from typing import Any, Optional

from src.agents.agent_config import (
    LANGFUSE_ENABLED, LANGFUSE_PUBLIC_KEY, LANGFUSE_SECRET_KEY,
    LANGFUSE_HOST, LANGFUSE_PROMPT_LIMIT,
)

logger = logging.getLogger(__name__)

_langfuse_client: Any = None
_langfuse_handler: Any = None
_langfuse_import_error: Optional[str] = None


def get_langfuse_client():
    """Lazy-singleton Langfuse client. Returns None if disabled or unavailable."""
    global _langfuse_client, _langfuse_import_error

    if _langfuse_client is not None:
        return _langfuse_client
    if not LANGFUSE_ENABLED:
        return None
    if not LANGFUSE_PUBLIC_KEY or not LANGFUSE_SECRET_KEY:
        logger.debug("Langfuse keys not set — tracing disabled")
        return None
    try:
        from langfuse import Langfuse
        _langfuse_client = Langfuse(
            public_key=LANGFUSE_PUBLIC_KEY,
            secret_key=LANGFUSE_SECRET_KEY,
            host=LANGFUSE_HOST,
        )
        logger.info("Langfuse client connected (host=%s)", LANGFUSE_HOST)
    except ImportError:
        _langfuse_import_error = "langfuse package not installed — pip install langfuse"
        logger.debug(_langfuse_import_error)
    except Exception as e:
        _langfuse_import_error = str(e)
        logger.warning("Langfuse client init failed: %s", e)
    return _langfuse_client


def get_langfuse_handler():
    """Lazy-singleton LangChain CallbackHandler for LangGraph node tracing."""
    global _langfuse_handler

    if _langfuse_handler is not None:
        return _langfuse_handler
    client = get_langfuse_client()
    if client is None:
        return None
    try:
        from langfuse.langchain import CallbackHandler
        _langfuse_handler = CallbackHandler()
        logger.debug("Langfuse CallbackHandler created")
    except ImportError:
        logger.debug("langfuse.langchain.CallbackHandler not available")
    except Exception as e:
        logger.warning("CallbackHandler creation failed: %s", e)
    return _langfuse_handler


class _TracedGeneration:
    """Wraps llm_client.generate() — callable, with token/timing accessors."""

    def __init__(self, llm_client: Any, prompt: str, node_name: str, gen_kwargs: dict):
        self._llm_client = llm_client
        self._prompt = prompt
        self._node_name = node_name
        self._gen_kwargs = gen_kwargs
        self._start_ns: int = 0
        self._response: str = ""

    def __call__(self) -> str:
        self._start_ns = time.perf_counter_ns()
        self._response = self._llm_client.generate(self._prompt, **self._gen_kwargs)
        return self._response

    # ── read-only properties (valid after __call__) ──────────────────────────
    @property
    def response(self) -> str:   return self._response

    @property
    def elapsed_ms(self) -> float:
        if self._start_ns == 0:
            return 0.0
        return (time.perf_counter_ns() - self._start_ns) / 1e6

    @property
    def input_tokens(self) -> int:
        try:
            return self._llm_client.count_tokens(self._prompt)
        except Exception:
            return len(self._prompt) // 4

    @property
    def output_tokens(self) -> int:
        try:
            return self._llm_client.count_tokens(self._response)
        except Exception:
            return len(self._response) // 4

    @property
    def model_name(self) -> str:
        try:
            return self._llm_client.get_model_info().get("model_name", "llm")
        except Exception:
            return "llm"


@contextmanager
def traced_llm_call(llm_client: Any, prompt: str, node_name: str,
                    trace_id: str = "", **gen_kwargs):
    """
    Context manager wrapping an LLM call for Langfuse tracing.

    Usage:
        with traced_llm_call(llm_client, prompt, "route",
                             trace_id=state.get("tracing_trace_id", ""),
                             max_tokens=200) as gen:
            response = gen()

    On exit, records input/output, estimated token counts, model, and latency
    as a GENERATION observation under the given trace_id.

    No-op when LANGFUSE_ENABLED=false, trace_id is empty, or langfuse unavailable.
    """
    client = get_langfuse_client()
    gen = _TracedGeneration(llm_client, prompt, node_name, gen_kwargs)

    yield gen

    if client is None or not trace_id:
        return
    if gen._start_ns == 0:  # gen() was never called
        return

    try:
        input_text = (gen._prompt or "")[:LANGFUSE_PROMPT_LIMIT]
        output_text = (gen.response or "")[:LANGFUSE_PROMPT_LIMIT]
        usage = {
            "input": gen.input_tokens,
            "output": gen.output_tokens,
            "total": gen.input_tokens + gen.output_tokens,
        }
        metadata = {
            "latency_ms": round(gen.elapsed_ms, 1),
            "max_tokens": gen_kwargs.get("max_tokens"),
            "temperature": gen_kwargs.get("temperature"),
        }
        client.create_generation(
            trace_id=trace_id,
            name=node_name,
            model=gen.model_name,
            input=input_text,
            output=output_text,
            usage=usage,
            metadata=metadata,
        )
    except Exception as e:
        logger.debug("Failed to create Langfuse generation: %s", e)


def get_current_trace_id() -> Optional[str]:
    """Return the current Langfuse trace ID, or None."""
    client = get_langfuse_client()
    if client is None:
        return None
    try:
        return client.get_trace_id()
    except Exception:
        return None


def push_score(trace_id: str, name: str, value: float, data_type: str = "NUMERIC") -> None:
    """Push an evaluation score to a Langfuse trace."""
    client = get_langfuse_client()
    if client is None or not trace_id:
        return
    try:
        client.create_score(
            trace_id=trace_id,
            name=name,
            value=value,
            data_type=data_type,
        )
        logger.debug("Pushed score %s=%s → trace %s", name, value, trace_id[:8])
    except Exception as e:
        logger.debug("Failed to push score: %s", e)