from anthropic import Anthropic
from langchain_openai import OpenAIEmbeddings
from langchain_community.vectorstores import Chroma
from datetime import datetime, timedelta
import json
import asyncio

client = Anthropic()
emveddings = OpenAIEmbeddings(model="text-embedding-3-small")

class EventKnowledgeBase:
    """Event knowledge base for the AI assistant"""

    def __init__(self, event_id: str):
        self.vectorstore = Chroma(
            collection_name=f"event_{event_id}",
            embedding_function=embeddings,
        )

    def index_event_data(self, event_data: dict):
        """Index event data"""
        texts = []
        metadatas = []

        # Program
        for session in event_data.get("sessions", []):
            text = f"""Section: {session['title']}
Speaker: {session['speaker']} ({session['speaker_bio']})
Time: {session['start_time']} — {session['end_time']}
Description: {session['description']}
Room/Track: {session.get('track', 'general')}"""
            texts.append(text)
            metadatas.append({"type": "session", "session_id": session["id"]})

        # FAQ
        for item in event_data.get("faq", []):
            texts.append(f"Question: {item['q']}\nAnswer: {item['a']}")
            metadatas.append({"type": "faq"})

        # Speakers
        for speaker in event_data.get("speakers", []):
            text = f"""Speaker: {speaker['name']}
Position: {speaker['title']} at {speaker['company']}
Bio: {speaker['bio']}
Topics: {', '.join(speaker.get('topics', []))}"""
            texts.append(text)
            metadatas.append({"type": "speaker", "speaker_name": speaker["name"]})

        self.vectorstore.add_texts(texts=texts, metadatas=metadatas)


class EventAssistant:
    """AI assistant for attendees"""

    def __init__(self, event_id: str, event_name: str):
        self.event_name = event_name
        self.kb = EventKnowledgeBase(event_id)
        self.sessions: dict[str, list] = {}  # dialog history

    def answer(self, participant_id: str, question: str, current_time: datetime = None) -> str:
        results = self.kb.vectorstore.similarity_search_with_score(question, k=5)
        context = "\n\n".join([doc.page_content for doc, score in results if (1 - score) > 0.5])

        time_context = f"Current time: {current_time.strftime('%H:%M')}" if current_time else ""

        history = self.sessions.get(participant_id, [])
        messages = history + [{
            "role": "user",
            "content": f"{time_context}\n\nAttendee question: {question}\n\nEvent information:\n{context}"
        }]

        response = client.messages.create(
            model="claude-haiku-4-5",
            max_tokens=512,
            system=f"""You are an assistant for attendees of the event "{self.event_name}".
Be concise and specific. If information is not available, say so honestly.""",
            messages=messages,
        )

        answer = response.content[0].text
        history.append({"role": "user", "content": question})
        history.append({"role": "assistant", "content": answer})
        self.sessions[participant_id] = history[-10:]

        return answer


class QAModerator:
    """AI moderation for Q&A sessions"""

    def __init__(self):
        self.question_queue: list[dict] = []
        self.answered: list[dict] = []

    def moderate_question(self, question: str, participant: dict) -> dict:
        """Moderate question: relevance, duplicates, quality"""
        # Check duplicate
        if self.question_queue or self.answered:
            existing = [q["question"] for q in self.question_queue + self.answered[-20:]]
            existing_text = "\n".join(f"- {q}" for q in existing[-15:])
        else:
            existing_text = "none"

        response = client.messages.create(
            model="claude-haiku-4-5",
            max_tokens=256,
            messages=[{
                "role": "user",
                "content": f"""Evaluate the question for Q&A session:

Question: "{question}"
Existing questions: {existing_text}

Return JSON:
{{
  "approve": true/false,
  "is_duplicate": true/false,
  "duplicate_of": "similar question or null",
  "quality_score": 1-5,
  "category": "technical|business|personal|off_topic",
  "cleaned_question": "edited version (remove rudeness, typos)",
  "reject_reason": "rejection reason or null"
}}

Approve on-topic questions, not spam or rudeness. Only JSON."""
            }],
        )

        text = response.content[0].text
        result = json.loads(text[text.find("{"):text.rfind("}") + 1])

        if result.get("approve"):
            self.question_queue.append({
                "question": result.get("cleaned_question", question),
                "original": question,
                "participant": participant,
                "quality": result.get("quality_score", 3),
                "category": result.get("category"),
                "submitted_at": datetime.now().isoformat(),
            })

        return result

    def get_top_questions(self, n: int = 5) -> list[dict]:
        """Return top questions by quality score"""
        sorted_queue = sorted(
            self.question_queue,
            key=lambda q: q.get("quality", 3),
            reverse=True
        )
        return sorted_queue[:n]

    def get_summary_for_speaker(self, session_topic: str) -> str:
        """Prepare a summary for the speaker before Q&A"""
        if not self.question_queue:
            return "No questions yet."

        questions_text = "\n".join([
            f"{i+1}. [{q['category']}] {q['question']}"
            for i, q in enumerate(self.get_top_questions(10))
        ])

        response = client.messages.create(
            model="claude-haiku-4-5",
            max_tokens=512,
            messages=[{
                "role": "user",
                "content": f"""Session topic: {session_topic}

Audience questions:
{questions_text}

Group them by theme, highlight the most common ones — help the speaker prepare for Q&A.
Be concise and to the point."""
            }],
        )

        return response.content[0].text