# intent_classifier.py — классификация запроса клиента
import json
from pydantic import BaseModel
from openai import AsyncOpenAI

class Intent(BaseModel):
    category: str   # faq | billing | technical | escalation
    confidence: float  # 0.0 – 1.0
    reason: str

async def classify_intent(client: AsyncOpenAI, text: str) -> Intent:
    prompt = f"""Классифицируй запрос клиента в JSON:
Категории: faq, billing, technical, escalation.
Запрос: "{text}"
Верни ТОЛЬКО JSON: {{"category":"...","confidence":0.0,"reason":"..."}}"""

    resp = await client.chat.completions.create(
        model="gpt-4o-mini",
        messages=[{"role": "system", "content": prompt}],
        temperature=0.0,
        response_format={"type": "json_object"}
    )
    data = json.loads(resp.choices[0].message.content)
    return Intent(**data)

# Порог: всё, что ниже 0.7 — эскалация на оператора
ESCALATION_THRESHOLD = 0.7

# rag_engine.py — поиск по базе знаний
import chromadb
from openai import AsyncOpenAI

class RAGEngine:
    def __init__(self, client: AsyncOpenAI, collection_name="knowledge_base"):
        self.client = client
        self.chroma = chromadb.PersistentClient(path="./chroma_data")
        self.collection = self.chroma.get_or_create_collection(collection_name)

    async def embed(self, text: str) -> list[float]:
        resp = await self.client.embeddings.create(
            model="text-embedding-3-small", input=text
        )
        return resp.data[0].embedding

    async def search(self, query: str, top_k=5) -> list[str]:
        q_embed = await self.embed(query)
        results = self.collection.query(
            query_embeddings=[q_embed], n_results=top_k
        )
        return results["documents"][0]  # top-K чанков

    async def index_docs(self, documents: list[dict]):
        """Индексация: {id, text} → эмбеддинг → chromadb"""
        for i in range(0, len(documents), 20):  # батчи по 20
            batch = documents[i:i+20]
            texts = [d["text"] for d in batch]
            ids = [d["id"] for d in batch]
            embeds = [await self.embed(t) for t in texts]
            self.collection.add(embeddings=embeds, documents=texts, ids=ids)

# answer_generator.py — генерация ответа с guardrails
from openai import AsyncOpenAI

SYSTEM_PROMPT = """Ты — агент поддержки компании. Правила:
1. Отвечай ТОЛЬКО на основе переданного контекста.
2. Если в контексте нет ответа — скажи "Уточню у коллег" и предложи оператора.
3. Не извиняйся без причины. Будь конкретным и полезным.
4. Максимум 3 предложения. Без маркдауна."""

async def generate_answer(
    client: AsyncOpenAI, query: str, context_chunks: list[str]
) -> str:
    context = "\n\n".join(
        f"ДОКУМЕНТ {i+1}:\n{c}" for i, c in enumerate(context_chunks)
    )
    resp = await client.chat.completions.create(
        model="gpt-4o-mini",
        messages=[
            {"role": "system", "content": SYSTEM_PROMPT},
            {"role": "user", "content": f"Контекст:\n{context}\n\nВопрос: {query}"}
        ],
        temperature=0.3,
        max_tokens=300
    )
    return resp.choices[0].message.content.strip()

# Fallback: если RAG не нашёл релевантных чанков
FALLBACK_ANSWER = "Пока не могу ответить точно. Хотите, подключу оператора?"

# escalation.py — эскалация на живого оператора
import httpx
from datetime import datetime, timezone

ESCALATION_TRIGGERS = ["оператор", "человек", "позовите", "живой"]

def should_escalate(intent, user_text: str) -> bool:
    if intent.category == "escalation":
        return True
    if intent.confidence < ESCALATION_THRESHOLD:
        return True
    if any(t in user_text.lower() for t in ESCALATION_TRIGGERS):
        return True
    return False

async def escalate_to_operator(
    user_id: str, user_text: str, history: list, crm_webhook: str
):
    ticket = {
        "user_id": user_id,
        "query": user_text,
        "history": history,
        "created_at": datetime.now(timezone.utc).isoformat(),
        "source": "ai-agent-escalation"
    }
    async with httpx.AsyncClient() as hc:
        await hc.post(crm_webhook, json=ticket, timeout=10)

    # Уведомление оператору в Telegram
    alert = f"🔔 Эскалация!\nUser: {user_id}\nЗапрос: {user_text[:200]}"
    await hc.post(
        f"https://api.telegram.org/bot{OPERATOR_BOT_TOKEN}/sendMessage",
        json={"chat_id": OPERATOR_CHAT_ID, "text": alert}
    )
    return ticket

# main.py — FastAPI + aiogram + полный пайплайн
from fastapi import FastAPI, Request
from aiogram import Bot, Dispatcher, types
from aiogram.webhook.aiohttp_server import SimpleRequestHandler
from contextlib import asynccontextmanager

from intent_classifier import classify_intent, ESCALATION_THRESHOLD
from rag_engine import RAGEngine
from answer_generator import generate_answer, FALLBACK_ANSWER
from escalation import should_escalate, escalate_to_operator

bot = Bot(token="YOUR_BOT_TOKEN")
dp = Dispatcher()
llm = AsyncOpenAI(api_key="sk-...")
rag = RAGEngine(llm)

@dp.message()
async def handle_message(message: types.Message):
    text = message.text
    intent = await classify_intent(llm, text)

    if should_escalate(intent, text):
        await escalate_to_operator(
            str(message.from_user.id), text, [], CRM_WEBHOOK
        )
        await message.answer(
            "Переключаю на оператора. Ожидайте ответа в течение 5 минут."
        )
        return

    chunks = await rag.search(text, top_k=5)
    if not chunks:
        await message.answer(FALLBACK_ANSWER)
        return

    answer = await generate_answer(llm, text, chunks)
    await message.answer(answer)

# FastAPI-приложение с webhook для Telegram
@asynccontextmanager
async def lifespan(app: FastAPI):
    await bot.set_webhook(f"https://your-domain.com/webhook")
    yield
    await bot.delete_webhook()

app = FastAPI(lifespan=lifespan)

@app.post("/webhook")
async def tg_webhook(request: Request):
    update = await request.json()
    await dp.feed_update(bot, types.Update(**update))
    return {"ok": True}

# Запуск: uvicorn main:app --port 8000

# metrics.py — логирование и расчёт метрик
import json, time
from pathlib import Path

LOG_PATH = Path("./logs/conversations.jsonl")

def log_conversation(user_id: str, intent: str, answer: str,
                     latency_ms: float, tokens_used: int, escalated: bool):
    entry = {
        "ts": time.time(),
        "user_id": user_id,
        "intent": intent,
        "answer_len": len(answer),
        "latency_ms": round(latency_ms, 1),
        "tokens": tokens_used,
        "escalated": escalated
    }
    with open(LOG_PATH, "a") as f:
        f.write(json.dumps(entry, ensure_ascii=False) + "\n")

# Быстрый отчёт за сегодня (jq-стиль, без БД)
def daily_report() -> dict:
    lines = LOG_PATH.read_text().strip().split("\n")
    today = [json.loads(l) for l in lines]
    return {
        "total": len(today),
        "avg_latency_ms": sum(d["latency_ms"] for d in today) / len(today),
        "escalation_rate": sum(1 for d in today if d["escalated"]) / len(today),
        "total_tokens": sum(d["tokens"] for d in today)
    }

# Подключите в main.py:
# t0 = time.time()
# answer = await generate_answer(...)
# log_conversation(user_id, intent.category, answer,
#                  (time.time()-t0)*1000, tokens, escalated)