"""AI chat service - uses emergentintegrations with Emergent LLM key.

Supports switching between OpenAI GPT-5 and Google Gemini providers based on
settings stored in the DB. Retrieves site context (services, doctors, projects)
so responses are grounded in the actual site data.
"""
from __future__ import annotations
import os
import logging
from typing import Optional, Dict, List
from sqlalchemy import select
from sqlalchemy.ext.asyncio import AsyncSession

from models import Setting, Service, Doctor, Project, BlogPost

logger = logging.getLogger(__name__)

EMERGENT_LLM_KEY = os.environ.get("EMERGENT_LLM_KEY", "")


async def _get_settings(session: AsyncSession) -> Dict[str, str]:
    res = await session.execute(select(Setting))
    return {row.key: row.value for row in res.scalars().all()}


async def _build_context(session: AsyncSession) -> str:
    """Compact site context so the model can answer grounded questions."""
    parts: List[str] = []

    services = (await session.execute(select(Service).order_by(Service.order))).scalars().all()
    if services:
        parts.append("XİDMƏTLƏR:")
        for s in services[:20]:
            parts.append(f"- {s.title}")

    doctors = (await session.execute(select(Doctor).order_by(Doctor.order))).scalars().all()
    if doctors:
        parts.append("\nHƏKİMLƏR:")
        for d in doctors[:10]:
            parts.append(f"- {d.name} ({d.specialty})")

    projects = (await session.execute(select(Project).order_by(Project.order))).scalars().all()
    if projects:
        parts.append("\nLAYİHƏLƏR:")
        seen = set()
        for p in projects[:10]:
            key = (p.title, p.address, p.street)
            if key in seen:
                continue
            seen.add(key)
            parts.append(f"- {p.title} — {p.address} {p.street}")

    blog = (await session.execute(select(BlogPost).order_by(BlogPost.order))).scalars().all()
    if blog:
        parts.append("\nBLOQ MÖVZULARI:")
        for b in blog[:10]:
            parts.append(f"- {b.title}")

    return "\n".join(parts) if parts else ""


async def generate_reply(session: AsyncSession, session_id: str, user_message: str) -> Optional[str]:
    """Generate an AI reply for the given user_message.

    Returns None if AI is disabled or if generation fails.
    """
    settings = await _get_settings(session)
    if settings.get("ai_enabled", "true").lower() != "true":
        return None
    if not EMERGENT_LLM_KEY:
        logger.warning("EMERGENT_LLM_KEY not set — skipping AI reply")
        return None

    provider = settings.get("ai_provider", "gemini").lower()
    model = settings.get("ai_model") or ("gemini-2.5-flash" if provider == "gemini" else "gpt-5")
    base_prompt = settings.get("ai_system_prompt", "")

    context = await _build_context(session)
    system_message = base_prompt
    if context:
        system_message = f"{base_prompt}\n\n---\nSAYT MƏLUMATI:\n{context}\n---"

    try:
        # Lazy import to avoid slow startup if unused
        from emergentintegrations.llm.chat import LlmChat, UserMessage
        chat = LlmChat(
            api_key=EMERGENT_LLM_KEY,
            session_id=session_id,
            system_message=system_message,
        ).with_model(provider, model)

        response = await chat.send_message(UserMessage(text=user_message))
        text = str(response).strip() if response else ""
        return text or None
    except Exception as e:  # pylint: disable=broad-except
        logger.error(f"AI generation failed ({provider}/{model}): {e}")
        return None