"""Copilot service: chat via OpenRouter, action execution, history retrieval, voice transcription.

The service:
1. Calls OpenRouter chat completions with the ERP system prompt
2. Parses the AI response for text + action proposals
3. Persists user and assistant messages to the DB
4. Executes confirmed actions via copilot_actions registry
5. Provides paginated chat history per user
6. Accepts voice audio and transcribes (stub for now, OpenRouter-compatible)
"""

from __future__ import annotations

import base64
import json
import logging
import uuid
from typing import Any

import httpx
from sqlalchemy import and_, func, select
from sqlalchemy.ext.asyncio import AsyncSession

from app.config import settings
from app.models.copilot import CopilotChat, CopilotRole, CopilotSession
from app.utils.copilot_actions import execute_action
from app.utils.copilot_prompt import build_system_prompt

logger = logging.getLogger(__name__)

# Model for chat completions (text-only, cheaper than vision model)
CHAT_MODEL = "qwen/qwen2.5-72b-instruct"


def _parse_ai_response(raw_content: str) -> dict[str, Any]:
    """Parse the AI response into text + actions.

    Handles markdown code fences and extracts the JSON object.
    Falls back to treating the entire content as text response with no actions.
    """
    text = raw_content.strip()

    # Strip markdown code fences if present
    if text.startswith("```"):
        lines = text.split("\n")
        lines = [l for l in lines if not l.strip().startswith("```")]
        text = "\n".join(lines).strip()

    try:
        data = json.loads(text)
    except json.JSONDecodeError:
        # Try to find JSON object within the text
        start = text.find("{")
        end = text.rfind("}")
        if start != -1 and end != -1 and end > start:
            try:
                data = json.loads(text[start : end + 1])
            except json.JSONDecodeError:
                logger.warning("Failed to parse AI response as JSON, using raw text")
                return {"response": raw_content.strip(), "actions": []}
        else:
            logger.warning("No JSON found in AI response, using raw text")
            return {"response": raw_content.strip(), "actions": []}

    response_text = data.get("response", "")
    actions = data.get("actions", [])

    if not isinstance(response_text, str):
        response_text = str(response_text)
    if not isinstance(actions, list):
        actions = []

    # Validate action structure
    valid_actions = []
    for action in actions:
        if isinstance(action, dict) and "type" in action:
            valid_actions.append({
                "type": action["type"],
                "params": action.get("params", {}),
            })

    return {"response": response_text, "actions": valid_actions}


async def _call_openrouter_chat(
    messages: list[dict[str, Any]],
    api_key: str | None = None,
    model: str | None = None,
) -> str:
    """Call OpenRouter chat completions endpoint.

    Returns the raw content string from the model.
    Raises httpx.HTTPStatusError on API failure.
    """
    key = api_key or settings.OPENROUTER_API_KEY
    if not key:
        raise ValueError("OPENROUTER_API_KEY is not configured")

    model_name = model or CHAT_MODEL

    headers = {
        "Authorization": f"Bearer {key}",
        "Content-Type": "application/json",
    }
    payload: dict[str, Any] = {
        "model": model_name,
        "messages": messages,
        "temperature": 0.3,
        "max_tokens": 2048,
    }

    base_url = settings.OPENROUTER_BASE_URL.rstrip("/")
    url = f"{base_url}/chat/completions"

    async with httpx.AsyncClient(timeout=httpx.Timeout(60.0)) as client:
        response = await client.post(url, headers=headers, json=payload)
        response.raise_for_status()

    body = response.json()
    content = body.get("choices", [{}])[0].get("message", {}).get("content", "")
    return content


async def _get_or_create_session(
    db: AsyncSession,
    user_id: uuid.UUID,
    session_id: str | None = None,
    first_message: str | None = None,
) -> CopilotSession:
    """Get an existing session or create a new one.

    If creating a new session, uses the first message as title (truncated).
    """
    if session_id:
        try:
            sid = uuid.UUID(session_id)
            stmt = select(CopilotSession).where(
                and_(CopilotSession.id == sid, CopilotSession.user_id == user_id)
            )
            result = await db.execute(stmt)
            session = result.scalar_one_or_none()
            if session:
                return session
        except (ValueError, TypeError):
            pass  # Invalid UUID, create new session

    # Create new session
    title = "Neue Konversation"
    if first_message:
        title = first_message[:100] if len(first_message) > 100 else first_message

    session = CopilotSession(user_id=user_id, title=title)
    db.add(session)
    await db.flush()
    return session


async def chat(
    db: AsyncSession,
    user_id: uuid.UUID,
    message: str,
    session_id: str | None = None,
    api_key: str | None = None,
) -> dict[str, Any]:
    """Process a user message through the Copilot.

    1. Get or create a session
    2. Save the user message
    3. Build conversation context from recent history
    4. Call OpenRouter with system prompt
    5. Parse response for text + actions
    6. Save the assistant message
    7. Return response with actions and IDs
    """
    session = await _get_or_create_session(db, user_id, session_id, first_message=message)

    # Save user message
    user_msg = CopilotChat(
        session_id=session.id,
        user_id=user_id,
        role=CopilotRole.user,
        content=message,
        actions=None,
    )
    db.add(user_msg)
    await db.flush()

    # Build conversation context from recent messages in this session
    stmt = (
        select(CopilotChat)
        .where(CopilotChat.session_id == session.id)
        .order_by(CopilotChat.created_at.asc())
        .limit(20)  # Keep last 20 messages for context
    )
    result = await db.execute(stmt)
    recent_messages = list(result.scalars().all())

    # Build messages for OpenRouter
    system_prompt = build_system_prompt()
    messages: list[dict[str, Any]] = [{"role": "system", "content": system_prompt}]

    for msg in recent_messages:
        messages.append({"role": msg.role.value, "content": msg.content})

    # Call OpenRouter
    raw_content = await _call_openrouter_chat(messages, api_key=api_key)
    parsed = _parse_ai_response(raw_content)

    # Save assistant message
    assistant_msg = CopilotChat(
        session_id=session.id,
        user_id=user_id,
        role=CopilotRole.assistant,
        content=parsed["response"],
        actions=parsed["actions"] if parsed["actions"] else None,
    )
    db.add(assistant_msg)
    await db.flush()

    return {
        "response": parsed["response"],
        "actions": parsed["actions"],
        "session_id": str(session.id),
        "message_id": str(assistant_msg.id),
    }


async def execute_confirmed_action(
    db: AsyncSession,
    action_type: str,
    params: dict[str, Any],
) -> dict[str, Any]:
    """Execute a user-confirmed action.

    Returns {action, result, success}.
    Raises ValueError for unknown actions.
    """
    try:
        result = await execute_action(db, action_type, params)
        return {
            "action": action_type,
            "result": result,
            "success": True,
        }
    except ValueError:
        raise
    except Exception as exc:
        logger.error("Action execution failed: %s", exc)
        return {
            "action": action_type,
            "result": {"error": str(exc)},
            "success": False,
        }


async def get_history(
    db: AsyncSession,
    user_id: uuid.UUID,
    page: int = 1,
    page_size: int = 20,
    session_id: str | None = None,
) -> tuple[list[CopilotChat], int]:
    """Get paginated chat history for a user.

    Optionally filtered by session_id.
    Returns (messages, total_count).
    """
    conditions = [CopilotChat.user_id == user_id]

    if session_id:
        try:
            sid = uuid.UUID(session_id)
            conditions.append(CopilotChat.session_id == sid)
        except (ValueError, TypeError):
            pass  # Ignore invalid session_id

    # Count
    count_stmt = select(func.count(CopilotChat.id)).where(and_(*conditions))
    total_result = await db.execute(count_stmt)
    total = total_result.scalar_one()

    # Data
    offset = (page - 1) * page_size
    data_stmt = (
        select(CopilotChat)
        .where(and_(*conditions))
        .order_by(CopilotChat.created_at.desc())
        .offset(offset)
        .limit(page_size)
    )
    result = await db.execute(data_stmt)
    messages = list(result.scalars().all())

    return messages, total


async def get_sessions(
    db: AsyncSession,
    user_id: uuid.UUID,
    page: int = 1,
    page_size: int = 20,
) -> tuple[list[CopilotSession], int]:
    """Get paginated chat sessions for a user.

    Returns (sessions, total_count).
    """
    count_stmt = select(func.count(CopilotSession.id)).where(
        CopilotSession.user_id == user_id
    )
    total_result = await db.execute(count_stmt)
    total = total_result.scalar_one()

    offset = (page - 1) * page_size
    data_stmt = (
        select(CopilotSession)
        .where(CopilotSession.user_id == user_id)
        .order_by(CopilotSession.updated_at.desc())
        .offset(offset)
        .limit(page_size)
    )
    result = await db.execute(data_stmt)
    sessions = list(result.scalars().all())

    return sessions, total


async def transcribe_audio(
    audio_bytes: bytes,
    mime_type: str = "audio/webm",
    api_key: str | None = None,
) -> str:
    """Transcribe audio bytes to text.

    Uses OpenRouter with a multimodal model if available.
    Falls back to a simple stub that returns a placeholder.
    """
    key = api_key or settings.OPENROUTER_API_KEY

    if not key:
        # Stub: return placeholder when no API key configured
        logger.warning("No OPENROUTER_API_KEY configured, using stub transcription")
        return "[Audio-Transkription nicht verfügbar — OPENROUTER_API_KEY fehlt]"

    # Encode audio as base64 data URI
    b64 = base64.b64encode(audio_bytes).decode("utf-8")
    audio_data_uri = f"data:{mime_type};base64,{b64}"

    messages = [
        {
            "role": "system",
            "content": (
                "Du bist ein Transkriptions-Assistent. Transkribiere das "
                "gesprochene Audio exakt wie es gesagt wurde. Gib NUR den "
                "transkribierten Text zurück, keine Erklärungen."
            ),
        },
        {
            "role": "user",
            "content": [
                {
                    "type": "text",
                    "text": "Bitte transkribiere dieses Audio.",
                },
                {
                    "type": "input_audio",
                    "input_audio": {"data": audio_data_uri},
                },
            ],
        },
    ]

    try:
        raw = await _call_openrouter_chat(
            messages, api_key=key, model="qwen/qwen2.5-vl-72b-instruct"
        )
        return raw.strip()
    except Exception as exc:
        logger.error("Audio transcription failed: %s", exc)
        return f"[Transkription fehlgeschlagen: {exc}]"


async def voice_chat(
    db: AsyncSession,
    user_id: uuid.UUID,
    audio_b64: str,
    mime_type: str = "audio/webm",
    session_id: str | None = None,
    api_key: str | None = None,
) -> dict[str, Any]:
    """Process a voice message: transcribe audio, then run chat.

    Returns transcription + chat response + actions + IDs.
    """
    audio_bytes = base64.b64decode(audio_b64)
    transcription = await transcribe_audio(audio_bytes, mime_type, api_key=api_key)

    chat_result = await chat(db, user_id, transcription, session_id, api_key=api_key)

    return {
        "transcription": transcription,
        "response": chat_result["response"],
        "actions": chat_result["actions"],
        "session_id": chat_result["session_id"],
        "message_id": chat_result["message_id"],
    }