"""
🇨🇭 Apertus Dialekt-Konsil - Simplified Version
Ein AI-Konsil mit Schweizerdeutsch, Bayrisch und Schwäbisch Sprechern
Vereinfachte Version ohne Roundtable-Komponente
"""

import gradio as gr
import os
from huggingface_hub import InferenceClient
import time
from datetime import datetime

# Configuration
HF_TOKEN = os.environ.get('HF_TOKEN', '')

# Initialize Apertus client with publicai provider
client = None
if HF_TOKEN:
    client = InferenceClient(
        provider="publicai",
        api_key=HF_TOKEN
    )

# Dialekt-Persönlichkeiten
COUNCIL_MEMBERS = {
    "Ueli": {
        "emoji": "🇨🇭",
        "dialect": "Baseldytsch",
        "location": "Basel",
        "system_prompt": """Du bist Ueli aus Basel und sprichst Baseldytsch.
Du bist kultiviert, humorvoll und liebst die Basler Fasnacht.
Verwende typische Basler Ausdrücke und Redewendungen.
Beispiele: 'Sali zämme', 'Das isch e gueti Sach, gäll', 'Mir Baasler wisse was guet isch'"""
    },
    "Sepp": {
        "emoji": "🥨",
        "dialect": "Bayrisch",
        "location": "München",
        "system_prompt": """Du bist Sepp aus München und sprichst Bayrisch.
Du bist gesellig, direkt und traditionsbewusst.
Verwende typische bayrische Ausdrücke und Redewendungen.
Beispiele: 'Servus beinand', 'Des is fei a guade Idee', 'A bisserl was geht immer'"""
    },
    "Karl": {
        "emoji": "🏰",
        "dialect": "Schwäbisch",
        "location": "Stuttgart",
        "system_prompt": """Du bist Karl aus Stuttgart und sprichst Schwäbisch.
Du bist sparsam, fleißig und erfinderisch.
Verwende typische schwäbische Ausdrücke und Redewendungen.
Beispiele: 'Griaß Godd mitanand', 'Des isch hald so a Sach', 'Mir müsset schaffe'"""
    }
}

# Moderator
MODERATOR_PROMPT = """Du bist Dr. Müller, ein neutraler Moderator.
Fasse die Diskussion zusammen und bewerte den Konsensgrad von 1-10.
Sei präzise und neutral."""

class SimpleKonsil:
    def __init__(self):
        self.history = []
        self.round = 0
        self.consensus_score = 0
        self.topic = ""

    def generate_response(self, member_name, context=""):
        """Generate response for a member"""
        if not client:
            return f"{COUNCIL_MEMBERS[member_name]['emoji']} {member_name}: *API nicht verfügbar*"

        member = COUNCIL_MEMBERS[member_name]
        prompt = f"{member['system_prompt']}\n\nThema: {self.topic}\n{context}\n\nDeine kurze Antwort (2-3 Sätze):"

        try:
            completion = client.chat.completions.create(
                model="swiss-ai/Apertus-8B-Instruct-2509",
                messages=[
                    {"role": "system", "content": member['system_prompt']},
                    {"role": "user", "content": f"Thema: {self.topic}\n{context}\nDeine kurze Antwort:"}
                ],
                max_tokens=100,
                temperature=0.8
            )
            response = completion.choices[0].message.content.strip()
            return f"{member['emoji']} **{member_name}** ({member['location']}): {response}"
        except Exception as e:
            return f"{member['emoji']} **{member_name}**: *Denkt nach... ({str(e)})*"

    def run_round(self, topic):
        """Run one discussion round"""
        self.round += 1
        self.topic = topic
        round_output = f"\n### 🔄 Runde {self.round}\n\n"
        context = ""

        # Each member speaks
        for member_name in COUNCIL_MEMBERS.keys():
            response = self.generate_response(member_name, context)
            round_output += f"{response}\n\n"
            context += f"{member_name}: {response}\n"
            self.history.append(response)
            time.sleep(0.5)

        # Moderator summary
        if client:
            try:
                mod_prompt = f"{MODERATOR_PROMPT}\n\nDiskussion:\n{context}\n\nBewerte Konsens (1-10) und fasse zusammen:"
                completion = client.chat.completions.create(
                    model="swiss-ai/Apertus-8B-Instruct-2509",
                    messages=[{"role": "user", "content": mod_prompt}],
                    max_tokens=150,
                    temperature=0.7
                )
                mod_response = completion.choices[0].message.content.strip()

                # Extract consensus score
                import re
                score_match = re.search(r'\b([1-9]|10)\b', mod_response)
                if score_match:
                    self.consensus_score = int(score_match.group())

                round_output += f"🎓 **Moderator Dr. Müller**:\n> {mod_response}\n\n"
                round_output += f"**Konsensgrad: {self.consensus_score}/10** "

                if self.consensus_score >= 8:
                    round_output += "🟢"
                elif self.consensus_score >= 5:
                    round_output += "🟡"
                else:
                    round_output += "🔴"

            except Exception as e:
                round_output += f"🎓 **Moderator**: *Technische Schwierigkeiten*\n"

        return round_output

# Create interface
def create_interface():
    konsil = SimpleKonsil()

    with gr.Blocks(title="Apertus Dialekt-Konsil", theme=gr.themes.Soft()) as demo:
        gr.Markdown("""
        # 🇨🇭🥨🏰 Apertus Dialekt-Konsil (Vereinfacht)

        **Teilnehmer:**
        - 🇨🇭 **Ueli** aus Basel (Baseldytsch)
        - 🥨 **Sepp** aus München (Bayrisch)
        - 🏰 **Karl** aus Stuttgart (Schwäbisch)
        - 🎓 **Dr. Müller** als Moderator
        """)

        with gr.Row():
            topic_input = gr.Textbox(
                label="💭 Diskussionsthema",
                placeholder="z.B. 'Was ist das beste Essen?'",
                lines=2
            )

        with gr.Row():
            start_btn = gr.Button("🚀 Diskussion starten", variant="primary")
            next_round_btn = gr.Button("➡️ Nächste Runde", variant="secondary")
            clear_btn = gr.Button("🔄 Neu starten")

        output_display = gr.Markdown(value="*Bereit für Diskussion...*")

        status_display = gr.Textbox(
            label="Status",
            value="Warten auf Thema...",
            interactive=False
        )

        def start_discussion(topic):
            if not topic:
                return "*Bitte Thema eingeben!*", "❌ Kein Thema"

            konsil.history = []
            konsil.round = 0
            konsil.consensus_score = 0
            konsil.topic = topic

            output = f"## 💬 Diskussion: {topic}\n"
            output += konsil.run_round(topic)

            status = f"Runde {konsil.round} - Konsens: {konsil.consensus_score}/10"
            return output, status

        def continue_discussion():
            if not konsil.topic:
                return "*Keine aktive Diskussion*", "❌ Starte zuerst eine Diskussion"

            if konsil.consensus_score >= 8:
                return "*Konsens erreicht!*", f"✅ Konsens bei {konsil.consensus_score}/10"

            if konsil.round >= 5:
                return "*Maximale Rundenzahl erreicht*", "🏁 Diskussion beendet"

            output = konsil.run_round(konsil.topic)
            status = f"Runde {konsil.round} - Konsens: {konsil.consensus_score}/10"

            return output, status

        def clear_all():
            konsil.history = []
            konsil.round = 0
            konsil.consensus_score = 0
            konsil.topic = ""
            return "*Bereit für neue Diskussion...*", "Warten auf Thema..."

        start_btn.click(
            start_discussion,
            inputs=[topic_input],
            outputs=[output_display, status_display]
        )

        next_round_btn.click(
            continue_discussion,
            outputs=[output_display, status_display]
        )

        clear_btn.click(
            clear_all,
            outputs=[output_display, status_display]
        )

        gr.Examples(
            examples=[
                ["Was ist das beste Essen?"],
                ["Sollten wir mehr Ferien haben?"],
                ["Wie wichtig ist Pünktlichkeit?"]
            ],
            inputs=topic_input
        )

    return demo

if __name__ == "__main__":
    print(f"Dialekt-Konsil (Vereinfacht)")
    print(f"HF_TOKEN konfiguriert: {bool(HF_TOKEN)}")

    demo = create_interface()
    demo.launch()