"""
LLM Client - Handles all LLM interactions
"""
import json
import time
from typing import List, Dict, Any, Optional
import httpx
from openai import OpenAI
import config
from utils.benchmark_logging import current_call_context, log_api_call, now_iso


class LLMClient:
    """
    Unified LLM client interface
    """
    def __init__(
        self,
        api_key: Optional[str] = None,
        model: Optional[str] = None,
        base_url: Optional[str] = None,
        enable_thinking: Optional[bool] = None,
        use_streaming: Optional[bool] = None,
    ):
        self.api_key = api_key or config.OPENAI_API_KEY
        self.model = model or config.LLM_MODEL
        self.base_url = base_url or config.OPENAI_BASE_URL
        self.enable_thinking = enable_thinking if enable_thinking is not None else config.ENABLE_THINKING
        self.use_streaming = use_streaming if use_streaming is not None else config.USE_STREAMING

        if not self.api_key:
            raise ValueError("OPENAI_API_KEY or DASHSCOPE_API_KEY must be set for LLMClient")

        # Initialize OpenAI client with optional base_url
        client_kwargs = {"api_key": self.api_key}
        if self.base_url:
            client_kwargs["base_url"] = self.base_url
            print(f"Using custom OpenAI base URL: {self.base_url}")

        if self.enable_thinking:
            print(f"Deep thinking mode enabled")

        self.client = OpenAI(
            base_url=self.base_url,
            api_key=self.api_key,
            http_client=httpx.Client(
                trust_env=False,
                timeout=httpx.Timeout(180.0, connect=30.0),
            ),
        )

    def chat_completion(
        self,
        messages: List[Dict[str, str]],
        temperature: float = 0.2,
        response_format: Optional[Dict[str, str]] = None,
        max_retries: Optional[int] = None,
        max_tokens: Optional[int] = None,
    ) -> str:
        """
        Standard chat completion with optional thinking mode and retry mechanism
        """
        result = self.chat_completion_full(
            messages=messages,
            temperature=temperature,
            response_format=response_format,
            max_retries=max_retries,
            max_tokens=max_tokens,
        )
        return result["text"]

    def chat_completion_full(
        self,
        messages: List[Dict[str, str]],
        temperature: float = 0.2,
        response_format: Optional[Dict[str, str]] = None,
        max_retries: Optional[int] = None,
        max_tokens: Optional[int] = None,
    ) -> Dict[str, Any]:
        """
        Chat completion returning text plus usage metadata for benchmark logging.
        """
        effective_retries = max_retries or getattr(config, "LLM_MAX_RETRIES", 3)
        kwargs = {
            "model": self.model,
            "messages": messages,
            "temperature": temperature,
        }

        if response_format:
            kwargs["response_format"] = response_format
        if max_tokens is not None:
            kwargs["max_tokens"] = max_tokens

        # Enable thinking mode if configured (for Qwen and compatible models only)
        # Only add enable_thinking parameter for Qwen API (identified by base_url)
        is_qwen_api = self.base_url and "dashscope.aliyuncs.com" in self.base_url
        
        if is_qwen_api:
            # Qwen API requires explicit enable_thinking parameter
            # - Streaming + thinking: enable_thinking=True
            # - Non-streaming: enable_thinking=False (required, not optional)
            # - JSON format: enable_thinking=False (incompatible with thinking mode)
            if self.use_streaming and self.enable_thinking and not response_format:
                kwargs["extra_body"] = {"enable_thinking": True}
            else:
                # Explicitly set to False for non-streaming calls or JSON format
                kwargs["extra_body"] = {"enable_thinking": False}
        # For OpenAI and other APIs, don't add extra_body parameters

        # Retry mechanism
        last_exception = None
        for attempt in range(effective_retries):
            try:
                # Use streaming if configured
                if self.use_streaming:
                    kwargs["stream"] = True
                    text = self._handle_streaming_response(**kwargs)
                    usage = {}
                    request_id = None
                    model_name = self.model
                else:
                    response = self.client.chat.completions.create(**kwargs)
                    text = response.choices[0].message.content or ""
                    usage = self._usage_to_dict(getattr(response, "usage", None))
                    request_id = getattr(response, "id", None)
                    model_name = getattr(response, "model", self.model)

                self._log_success(
                    messages=messages,
                    response_text=text,
                    usage=usage,
                    request_id=request_id,
                    response_format=response_format,
                    temperature=temperature,
                    max_tokens=max_tokens,
                    model_name=model_name,
                    attempt=attempt + 1,
                )
                return {
                    "text": text,
                    "usage": usage,
                    "request_id": request_id,
                    "model": model_name,
                }
            except Exception as e:
                last_exception = e
                self._log_failure(
                    messages=messages,
                    error=e,
                    response_format=response_format,
                    temperature=temperature,
                    max_tokens=max_tokens,
                    attempt=attempt + 1,
                )
                if attempt < effective_retries - 1:
                    wait_time = (2 ** attempt)  # Exponential backoff: 1s, 2s, 4s
                    print(f"LLM API call failed (attempt {attempt + 1}/{effective_retries}): {e}")
                    print(f"Retrying in {wait_time} seconds...")
                    time.sleep(wait_time)
                else:
                    print(f"LLM API call failed after {effective_retries} attempts: {e}")
        
        # If all retries failed, raise the last exception
        raise last_exception

    def _handle_streaming_response(self, **kwargs) -> str:
        """
        Handle streaming response and collect full content
        """
        full_content = []
        stream = self.client.chat.completions.create(**kwargs)

        # for chunk in stream:
        #     if chunk.choices is not None:
        #         print(chunk.choices[0].delta.content)
        
        # print('---------')

        for chunk in stream:
            # print(chunk)
            # fix list index out of range
            if len(chunk.choices) > 0 and chunk.choices[0].delta.content is not None:
                content = chunk.choices[0].delta.content
                full_content.append(content)
                # print(full_content)
                # Optional: print streaming content in real-time
                # print(content, end='', flush=True)
        # print(full_content)
        print()
        return ''.join(full_content)

    def _usage_to_dict(self, usage: Any) -> Dict[str, Any]:
        if usage is None:
            return {}
        if hasattr(usage, "model_dump"):
            return usage.model_dump()
        if isinstance(usage, dict):
            return dict(usage)
        result = {}
        for key in ("prompt_tokens", "completion_tokens", "total_tokens"):
            value = getattr(usage, key, None)
            if value is not None:
                result[key] = value
        return result

    def _log_success(
        self,
        *,
        messages: List[Dict[str, str]],
        response_text: str,
        usage: Dict[str, Any],
        request_id: Optional[str],
        response_format: Optional[Dict[str, str]],
        temperature: float,
        max_tokens: Optional[int],
        model_name: str,
        attempt: int,
    ) -> None:
        context = current_call_context()
        log_api_call(
            {
                "timestamp": now_iso(),
                "success": True,
                "provider": "dashscope" if self.base_url and "dashscope.aliyuncs.com" in self.base_url else "openai_compatible",
                "api_kind": "chat_completion",
                "stage": context.get("stage"),
                "token_stage": context.get("llm_stage") or context.get("stage"),
                "patient_id": context.get("patient_id"),
                "question_no": context.get("question_no"),
                "text_id": context.get("text_id"),
                "operation_id": context.get("operation_id"),
                "attempt": attempt,
                "model": model_name,
                "base_url": self.base_url,
                "request_id": request_id,
                "temperature": temperature,
                "max_tokens": max_tokens,
                "response_format": response_format,
                "message_count": len(messages),
                "messages": messages,
                "response_text": response_text,
                "usage": usage,
            }
        )

    def _log_failure(
        self,
        *,
        messages: List[Dict[str, str]],
        error: Exception,
        response_format: Optional[Dict[str, str]],
        temperature: float,
        max_tokens: Optional[int],
        attempt: int,
    ) -> None:
        context = current_call_context()
        log_api_call(
            {
                "timestamp": now_iso(),
                "success": False,
                "provider": "dashscope" if self.base_url and "dashscope.aliyuncs.com" in self.base_url else "openai_compatible",
                "api_kind": "chat_completion",
                "stage": context.get("stage"),
                "token_stage": context.get("llm_stage") or context.get("stage"),
                "patient_id": context.get("patient_id"),
                "question_no": context.get("question_no"),
                "text_id": context.get("text_id"),
                "operation_id": context.get("operation_id"),
                "attempt": attempt,
                "model": self.model,
                "base_url": self.base_url,
                "temperature": temperature,
                "max_tokens": max_tokens,
                "response_format": response_format,
                "message_count": len(messages),
                "messages": messages,
                "error": repr(error),
            }
        )

    def extract_json(self, text: str) -> Any:
        """
        Extract JSON from LLM response with robust parsing
        Supports multiple formats:
        1. Pure JSON
        2. ```json ... ```
        3. ``` ... ``` (generic code block)
        4. JSON embedded in text with common prefixes
        5. Multiple JSON objects (returns first valid one)
        """
        if not text or not text.strip():
            raise ValueError("Empty response received")

        text = text.strip()

        # Remove common LLM prefixes/suffixes
        common_prefixes = [
            "Here's the JSON:",
            "Here is the JSON:",
            "The JSON is:",
            "JSON:",
            "Result:",
            "Output:",
            "Answer:",
        ]
        for prefix in common_prefixes:
            if text.lower().startswith(prefix.lower()):
                text = text[len(prefix):].strip()

        # Try direct parsing first
        try:
            return json.loads(text)
        except json.JSONDecodeError:
            pass

        # Try extracting JSON from ```json ... ``` block
        if "```json" in text.lower():
            # Case insensitive search for ```json
            start_marker = "```json"
            start_idx = text.lower().find(start_marker)
            if start_idx != -1:
                start = start_idx + len(start_marker)
                # Find the closing ```
                end = text.find("```", start)
                if end != -1:
                    json_str = text[start:end].strip()
                    try:
                        return json.loads(json_str)
                    except json.JSONDecodeError as e:
                        # Try to clean up common issues
                        json_str = self._clean_json_string(json_str)
                        try:
                            return json.loads(json_str)
                        except json.JSONDecodeError:
                            pass

        # Try extracting from generic ``` ... ``` code block
        if "```" in text:
            start = text.find("```") + 3
            # Skip language identifier if present
            newline = text.find("\n", start)
            if newline != -1 and newline - start < 20:
                start = newline + 1
            end = text.find("```", start)
            if end != -1:
                json_str = text[start:end].strip()
                try:
                    return json.loads(json_str)
                except json.JSONDecodeError:
                    # Try to clean up
                    json_str = self._clean_json_string(json_str)
                    try:
                        return json.loads(json_str)
                    except json.JSONDecodeError:
                        pass

        # Try finding balanced JSON object/array by scanning for { or [
        for start_char in ['{', '[']:
            result = self._extract_balanced_json(text, start_char)
            if result is not None:
                return result

        # Last resort: try to find any JSON-like structure and clean it
        for start_char in ['{', '[']:
            start_idx = text.find(start_char)
            if start_idx != -1:
                # Extract a large chunk and try to parse
                chunk = text[start_idx:]
                cleaned = self._clean_json_string(chunk)
                try:
                    return json.loads(cleaned)
                except json.JSONDecodeError:
                    pass

        raise ValueError(f"Failed to extract valid JSON from response. First 300 chars: {text[:300]}...")

    def _clean_json_string(self, json_str: str) -> str:
        """
        Clean common issues in JSON strings from LLM output
        """
        # Remove trailing commas before } or ]
        import re
        json_str = re.sub(r',(\s*[}\]])', r'\1', json_str)

        # Remove comments (// and /* */)
        json_str = re.sub(r'//.*?$', '', json_str, flags=re.MULTILINE)
        json_str = re.sub(r'/\*.*?\*/', '', json_str, flags=re.DOTALL)

        return json_str.strip()

    def _extract_balanced_json(self, text: str, start_char: str) -> Any:
        """
        Extract a balanced JSON object or array starting with start_char
        """
        end_char = '}' if start_char == '{' else ']'
        start_idx = text.find(start_char)

        if start_idx == -1:
            return None

        # Track depth to find matching closing bracket
        depth = 0
        in_string = False
        escape_next = False

        for i in range(start_idx, len(text)):
            char = text[i]

            # Handle string escaping
            if escape_next:
                escape_next = False
                continue

            if char == '\\':
                escape_next = True
                continue

            # Handle strings (don't count brackets inside strings)
            if char == '"':
                in_string = not in_string
                continue

            if in_string:
                continue

            # Count depth
            if char == start_char:
                depth += 1
            elif char == end_char:
                depth -= 1
                if depth == 0:
                    json_str = text[start_idx:i+1]
                    try:
                        return json.loads(json_str)
                    except json.JSONDecodeError:
                        # Try cleaning and parsing again
                        cleaned = self._clean_json_string(json_str)
                        try:
                            return json.loads(cleaned)
                        except json.JSONDecodeError:
                            # Continue searching for next occurrence
                            break

        return None