import json
import xbmcgui
import xbmcplugin
from wcs import user_data, ui, utils
from wcs.ai.AIProvider import send_prompt, check_ai_api_key_and_handle_error
from wcs.ai.response_json import clean_response as _clean_ai_response
import xbmc, re, requests, datetime
from wcs.metadata.TMDbClient import get_tmdb_api_key, handle_tmdb_api_error
from wcs.ui.ContextMenu import create_movie_context_menu
import xbmcaddon

def _is_web_search_enabled():
    """Vrací True pokud je povoleno použití web search nástroje v nastavení."""
    addon = xbmcaddon.Addon()
    return addon.getSettingBool('ai_use_web_search')

def _get_recomm_limit(addon):
    """Vrací limit počtu doporučení z nastavení."""
    try:
        return int(addon.getSetting('ai_recommendation_count') or 11)
    except:
        return 11

def _check_tmdb_api_key_and_handle_error(addon, handle):
    """
    Kontroluje TMDb API klíč a v případě chyby zobrazí dialog.
    Vrací True pokud je klíč v pořádku, False pokud nastala chyba.
    """
    try:
        get_tmdb_api_key()
        return True
    except ValueError as e:
        handle_tmdb_api_error(e, addon, handle)
        return False

def _check_ai_api_key_and_handle_error(addon, handle):
    """
    Kontroluje AI API klíč a v případě chyby zobrazí dialog.
    Vrací True pokud je klíč v pořádku, False pokud nastala chyba.
    """
    try:
        return check_ai_api_key_and_handle_error()
    except Exception as e:
        xbmc.log(f"[plugin.video.milionar] Error checking AI API key: {e}", level=xbmc.LOGERROR)
        ui.popinfo('Chyba při kontrole AI API klíče.', addon.getAddonInfo('name'))
        return False

def start_text_game(movie_title, movie_plot="", movie_genre=""):
    """
    Spustí novou textovou hru na základě filmu.
    
    Args:
        movie_title (str): Název filmu
        movie_plot (str): Děj filmu (volitelné)
        movie_genre (str): Žánr filmu (volitelné)
    
    Returns:
        tuple: (intro_text, [choice_a, choice_b, choice_c], usage)
    """
    prompt = (
        f"Jsi vypravěč interaktivní textové adventury inspirované filmem '{movie_title}'.\n\n"
        f"KONTEXT FILMU:\n"
        f"Název: {movie_title}\n"
        f"Žánr: {movie_genre if movie_genre else 'Neurčen'}\n"
        f"Děj: {movie_plot[:300] if movie_plot else 'Využij své znalosti o tomto filmu'}\n\n"
        "INSTRUKCE:\n"
        "1. Využij VŠECHNY své znalosti o tomto filmu - postavy, děj, lokace, atmosféru, klíčové momenty\n"
        "2. Vytvoř úvodní situaci (2-3 věty) zasazenou do světa filmu\n"
        "3. Nabídni hráčovi výběr ze 3 hlavních postav filmu jako volby a), b), c)\n"
        "4. Každá volba: 'Hrát jako [Jméno postavy]'\n"
        "5. Toto je začátek 5-dílné adventure, kde volba postavy ovlivní celý příběh\n\n"
        "FORMÁT ODPOVĚDI MUSÍ BÝT PŘESNĚ TAKTO:\n"
        "{\n"
        '  "intro": "Úvodní text příběhu",\n'
        '  "choices": {\n'
        '    "a": "Hrát jako [Hlavní postava 1]",\n'
        '    "b": "Hrát jako [Hlavní postava 2]",\n'
        '    "c": "Hrát jako [Hlavní postava 3]"\n'
        '  }\n'
        "}"
    )
    
    try:
        # Pro textové hry nepoužíváme tools
        response_text, usage = send_prompt(prompt, usage_type='text_game')
        
        # Zpracování odpovědi
        if isinstance(response_text, list):
            parts = [evt.get('text', str(evt)) if isinstance(evt, dict) else str(evt) for evt in response_text]
            response_raw = ''.join(parts)
        else:
            response_raw = str(response_text)
        
        try:
            response_json = json.loads(response_raw)
            intro_text = response_json.get('intro', '')
            choices_dict = response_json.get('choices', {})
            choices = [choices_dict.get('a', ''), choices_dict.get('b', ''), choices_dict.get('c', '')]
            if not intro_text or not all(choices):
                raise ValueError("Neplatná struktura JSON odpovědi")
            return intro_text, choices[:3], usage
        except Exception as e:
            xbmc.log(f"[plugin.video.milionar] Error parsing JSON response in start_text_game: {e}", level=xbmc.LOGERROR)
            # Fallback odpověď
            fallback_intro = f"Vítej ve světě filmu {movie_title}! Příběh začíná...\n\nKterou postavu si vybereš?"
            fallback_choices = ["Hrát jako hlavní hrdina", "Hrát jako vedlejší postava", "Hrát jako antagonista"]
            return fallback_intro, fallback_choices, None
    except Exception as e:
        xbmc.log(f"[plugin.video.milionar] Error in start_text_game: {e}", level=xbmc.LOGERROR)
        # Fallback odpověď
        fallback_intro = f"Vítej ve světě filmu {movie_title}! Příběh začíná...\n\nKterou postavu si vybereš?"
        fallback_choices = ["Hrát jako hlavní hrdina", "Hrát jako vedlejší postava", "Hrát jako antagonista"]
        return fallback_intro, fallback_choices, None

def continue_text_game(movie_title, story_history, choice_made, turn_number=1):
    """
    Pokračuje v textové hře na základě hráčovy volby.
    
    Args:
        movie_title (str): Název filmu
        story_history (list): Historie příběhu
        choice_made (str): Volba kterou hráč udělal
        turn_number (int): Číslo aktuálního tahu (1-5)
    
    Returns:
        tuple: (new_text, [choice_a, choice_b, choice_c], is_ending, usage)
    """
    # Sestavení kontextu z historie
    context = "\n".join(story_history[-4:]) if story_history else ""
    
    # Určení fáze hry
    if turn_number == 1:
        phase_instruction = "Hráč si vybral postavu. Nyní začni první herní situaci - umísti ho do klíčové scény z filmu."
    elif turn_number <= 3:
        phase_instruction = f"Toto je {turn_number}. kolo z 5. Pokračuj v napínavém příběhu s akcí a dilematem."
    elif turn_number == 4:
        phase_instruction = "Toto je 4. kolo z 5. Blížíme se ke klimaxu - vytvoř dramatickou situaci."
    else:  # turn_number >= 5
        phase_instruction = "Toto je finální 5. kolo. Doved příběh k logickému konci podle hráčových voleb."
    
    prompt = (
        f"Pokračuj v textové adventuře na téma filmu '{movie_title}'.\n\n"
        f"KONTEXT HRÁČOVÝCH VOLEB:\n{context}\n\n"
        f"AKTUÁLNÍ VOLBA HRÁČE: {choice_made}\n\n"
        f"FÁZE HRY: {phase_instruction}\n\n"
        "INSTRUKCE:\n"
        "1. Využij své znalosti o filmu - postavy, lokace, zápletka, atmosféra\n"
        "2. Reaguj na hráčovu volbu logicky v kontextu filmu\n"
        "3. Vytvoř pokračování příběhu (2-3 věty)\n"
        "4. Nabídni 3 smysluplné volby související s filmem\n"
    )
    
    if turn_number >= 5:
        prompt += (
            "5. DŮLEŽITÉ: Toto je poslední kolo - jako volbu c) napiš 'KONEC PŘÍBĚHU'\n\n"
            "FORMÁT ODPOVĚDI MUSÍ BÝT PŘESNĚ TAKTO:\n"
            "{\n"
            '  "story": "Finální pokračování příběhu - zakončení podle hráčových voleb",\n'
            '  "choices": {\n'
            '    "a": "finální volba A",\n'
            '    "b": "finální volba B",\n'
            '    "c": "KONEC PŘÍBĚHU"\n'
            '  }\n'
            "}\n"
            "DŮLEŽITÉ: Nevkládej žádný text před ani za JSON, pouze čistý JSON!"
        )
    else:
        prompt += (
            "5. Každá volba max 8-10 slov\n\n"
            "FORMÁT ODPOVĚDI MUSÍ BÝT PŘESNĚ TAKTO:\n"
            "{\n"
            '  "story": "Pokračování příběhu",\n'
            '  "choices": {\n'
            '    "a": "akční volba",\n'
            '    "b": "diplomatická volba",\n'
            '    "c": "kreativní volba"\n'
            '  }\n'
            "}\n"
            "DŮLEŽITÉ: Nevkládej žádný text před ani za JSON, pouze čistý JSON!"
        )
    
    try:
        # Pro textové hry nepoužíváme tools
        response_text, usage = send_prompt(prompt, usage_type='text_game')
        
        if isinstance(response_text, list):
            parts = [evt.get('text', str(evt)) if isinstance(evt, dict) else str(evt) for evt in response_text]
            response_raw = ''.join(parts)
        else:
            response_raw = str(response_text)
        
        try:
            # Robustní extrakce JSON: najdi první { a poslední }
            start = response_raw.find('{')
            end = response_raw.rfind('}')
            if start != -1 and end != -1 and end > start:
                json_str = response_raw[start:end+1]
            else:
                json_str = response_raw
            
            # Parsování JSON odpovědi
            response_json = json.loads(json_str)
            story_text = response_json.get('story', '')
            choices_dict = response_json.get('choices', {})
            choices = [choices_dict.get('a', ''), choices_dict.get('b', ''), choices_dict.get('c', '')]
            is_ending = (turn_number >= 5) or (len(choices) > 2 and 'KONEC' in choices[2].upper())
            if not story_text or not all(choices):
                raise ValueError("Neplatná struktura JSON odpovědi")
            return story_text, choices[:3], is_ending, usage
        except Exception as e:
            xbmc.log(f"[plugin.video.milionar] Error parsing JSON response in continue_text_game: {e}", level=xbmc.LOGERROR)
            xbmc.log(f"[plugin.video.milionar] AI response_raw: {response_raw}", level=xbmc.LOGERROR)
            # Fallback odpověď
            if turn_number >= 5:
                fallback_text = "Příběh se chýlí ke konci..."
                fallback_choices = ["Dokončit cestu", "Užít si okamžik", "KONEC PŘÍBĚHU"]
                return fallback_text, fallback_choices, True, None
            else:
                fallback_text = "Dobrodružství pokračuje..."
                fallback_choices = ["Jdi vpřed", "Buď opatrný", "Zkus něco jiného"]
                return fallback_text, fallback_choices, False, None
    except Exception as e:
        xbmc.log(f"[plugin.video.milionar] Error in continue_text_game: {e}", level=xbmc.LOGERROR)
        # Fallback odpověď
        if turn_number >= 5:
            fallback_text = "Příběh se chýlí ke konci..."
            fallback_choices = ["Dokončit cestu", "Užít si okamžik", "KONEC PŘÍBĚHU"]
            return fallback_text, fallback_choices, True, None
        else:
            fallback_text = "Dobrodružství pokračuje..."
            fallback_choices = ["Jdi vpřed", "Buď opatrný", "Zkus něco jiného"]
    except Exception as e:
        xbmc.log(f"[plugin.video.milionar] Error in continue_text_game: {e}", level=xbmc.LOGERROR)
        # Fallback odpověď
        if turn_number >= 5:
            fallback_text = "Příběh se chýlí ke konci..."
            fallback_choices = ["Dokončit cestu", "Užít si okamžik", "KONEC PŘÍBĚHU"]
            return fallback_text, fallback_choices, True, None
        else:
            fallback_text = "Dobrodružství pokračuje..."
            fallback_choices = ["Jdi vpřed", "Buď opatrný", "Zkus něco jiného"]
            return fallback_text, fallback_choices, False, None

def send_chat_recommendation(system_prompt: str, messages: list, context_titles: list = None, context_limit: int = None) -> tuple:
    """
    Odešle chat recommendation request do LLM API s nativním multi-turn messages.
    
    Args:
        system_prompt (str): Session-stable system prompt
        messages (list): Pole messages [{"role": "user/assistant", "content": "..."}]
        context_titles (list, optional): Seznam titulů z Kodi knihovny pro debug
        context_limit (int, optional): Limit počtu titulů
        
    Returns:
        tuple: (response_data, usage, raw_response, latency)
        response_data je dict s klíči: message, buttons, recommendations
    """
    try:
        # === LOGGING: FORMÁTOVANÝ TEXT (čitelný) ===
        xbmc.log("=" * 80, xbmc.LOGINFO)
        xbmc.log("[plugin.video.milionar][AI Chat] ========== REQUEST (FORMÁTOVANÝ) ==========", xbmc.LOGINFO)
        xbmc.log("[plugin.video.milionar][AI Chat] --- SYSTEM PROMPT ---", xbmc.LOGINFO)
        # Logovat system prompt po řádcích
        for line in system_prompt.split('\n'):
            xbmc.log(f"[plugin.video.milionar][AI Chat] {line}", xbmc.LOGINFO)
        xbmc.log("[plugin.video.milionar][AI Chat] --- MESSAGES ({} zpráv) ---".format(len(messages)), xbmc.LOGINFO)
        for i, msg in enumerate(messages):
            role = msg['role'].upper()
            xbmc.log(f"[plugin.video.milionar][AI Chat] [{i+1}] {role}:", xbmc.LOGINFO)
            # Logovat content po řádcích
            for line in msg['content'].split('\n'):
                xbmc.log(f"[plugin.video.milionar][AI Chat]     {line}", xbmc.LOGINFO)
        xbmc.log("=" * 80, xbmc.LOGINFO)
        
        # === LOGGING: RAW JSON (přesně co se posílá) ===
        raw_payload = {
            "system_prompt": system_prompt,
            "messages": messages,
            "json_mode": True
        }
        xbmc.log("[plugin.video.milionar][AI Chat] ========== REQUEST (RAW JSON) ==========", xbmc.LOGINFO)
        xbmc.log(f"[plugin.video.milionar][AI Chat] {json.dumps(raw_payload, ensure_ascii=False)}", xbmc.LOGINFO)
        xbmc.log("=" * 80, xbmc.LOGINFO)
        
        # Volání AI s odděleným system promptem a multi-turn messages
        # Použijeme poslední user message jako prompt pro kompatibilitu,
        # ale předáme celou historii jako messages kwarg
        last_user_msg = ""
        for msg in reversed(messages):
            if msg['role'] == 'user':
                last_user_msg = msg['content']
                break
        
        response_text, usage, raw_response, latency = send_prompt(
            last_user_msg, 
            usage_type='recommendation',
            use_tools=_is_web_search_enabled(), 
            system_prompt=system_prompt,
            messages=messages,  # Multi-turn messages
            json_mode=True,  # Vynutit JSON response formát
            include_raw=True, # Vyžádat raw data a latenci
            context_titles=context_titles,  # Pro debug dialog
            context_limit=context_limit  # Pro debug dialog
        )
        
        # === LOGGING: RESPONSE ===
        xbmc.log("[plugin.video.milionar][AI Chat] === RESPONSE ===", xbmc.LOGINFO)
        if usage:
            prompt_tokens = usage.get('input_tokens', usage.get('prompt_tokens', 0))
            completion_tokens = usage.get('output_tokens', usage.get('completion_tokens', 0))
            total = prompt_tokens + completion_tokens
            xbmc.log(f"[plugin.video.milionar][AI Chat] Tokens: {prompt_tokens} in / {completion_tokens} out = {total} total", xbmc.LOGINFO)
        xbmc.log("=" * 60, xbmc.LOGINFO)
        
        # Sjednocení odpovědi
        if isinstance(response_text, list):
            parts = [evt.get('text', str(evt)) if isinstance(evt, dict) else str(evt) for evt in response_text]
            response_raw = ''.join(parts)
        else:
            response_raw = str(response_text)
            
        # Extrakce JSON
        try:
            start = response_raw.find('{')
            end = response_raw.rfind('}')
            if start != -1 and end != -1 and end > start:
                json_str = response_raw[start:end+1]
            else:
                json_str = response_raw
                
            data = json.loads(json_str)
            
            # Validace struktury
            if 'message' not in data:
                data['message'] = "Omlouvám se, došlo k chybě ve zpracování."
            if 'buttons' not in data:
                data['buttons'] = []
            if 'recommendations' not in data:
                data['recommendations'] = []
                

                
            return data, usage, raw_response, latency
            
        except json.JSONDecodeError as e:
            xbmc.log(f"[plugin.video.milionar] JSON parse error: {e}", level=xbmc.LOGERROR)
            xbmc.log(f"[plugin.video.milionar] Raw response: {response_raw[:500]}", level=xbmc.LOGWARNING)
            return {
                'message': 'Omlouvám se, nepodařilo se zpracovat odpověď.',
                'buttons': [],
                'recommendations': []

            }, usage, raw_response, latency
            
    except Exception as e:
        xbmc.log(f"[plugin.video.milionar] AI request error: {e}", level=xbmc.LOGERROR)
        return {
            'message': f'Chyba komunikace s AI: {str(e)}',
            'buttons': [],
            'recommendations': []

        }, {}, None, 0


# =========================
# MILLIONAIRE CONTINUOUS CHAT
# =========================

def generate_millionaire_chat(system_prompt, messages, session_id=None):
    """Send a continuous chat inference for the Millionaire game.

    Uses send_prompt with multi-turn messages and JSON mode.
    Parses the JSON response and tracks usage.

    Args:
        system_prompt (str): Fixed system prompt for the entire game session.
        messages (list): Full chat history [{\"role\": \"user/assistant\", \"content\": \"...\"}].
        session_id (str): Optional game session ID for cumulative tracking.

    Returns:
        tuple: (parsed_json_dict, usage) or raises Exception on failure.
    """
    # Log request
    xbmc.log("[plugin.video.milionar][Millionaire Chat] --- REQUEST ---", xbmc.LOGINFO)
    xbmc.log("[plugin.video.milionar][Millionaire Chat] Messages: {} zpráv".format(len(messages)), xbmc.LOGINFO)
    for i, msg in enumerate(messages):
        role = msg['role'].upper()
        content_preview = msg['content'][:200]
        xbmc.log("[plugin.video.milionar][Millionaire Chat] [{}] {}: {}".format(i + 1, role, content_preview), xbmc.LOGINFO)

    # Find last user message for send_prompt compatibility
    last_user_msg = ""
    for msg in reversed(messages):
        if msg['role'] == 'user':
            last_user_msg = msg['content']
            break

    response_text, usage = send_prompt(
        last_user_msg,
        usage_type='millionaire_chat',
        session_id=session_id,
        use_tools=False,
        system_prompt=system_prompt,
        messages=messages,
        json_mode=True,
    )

    # Clean and parse response
    clean_response = _clean_ai_response(response_text)
    xbmc.log("[plugin.video.milionar][Millionaire Chat] Response (first 500): {}".format(clean_response[:500]), xbmc.LOGINFO)

    data = json.loads(clean_response)

    # Log tokens
    if usage:
        prompt_tokens = usage.get('input_tokens', usage.get('prompt_tokens', 0))
        completion_tokens = usage.get('output_tokens', usage.get('completion_tokens', 0))
        xbmc.log("[plugin.video.milionar][Millionaire Chat] Tokens: {} in / {} out".format(prompt_tokens, completion_tokens), xbmc.LOGINFO)

    return data, usage


# =========================
# MILLIONAIRE GAME FUNCTIONS (LEGACY -- batch generation)
# =========================

def generate_director_tip(media_type="movie", title="", question="", options=[], plot="", genre="", episode_title="", season_number=None, episode_number=None, session_id=None):
    """
    Generuje osobní radu od režiséra/tvůrce k aktuální otázce v millionaire hře.
    
    Args:
        media_type (str): "movie" nebo "series"
        title (str): Název filmu/seriálu
        question (str): Text aktuální otázky
        options (list): Seznam 4 možností odpovědí [A, B, C, D]
        plot (str): Děj filmu/epizody (volitelné)
        genre (str): Žánr (volitelné)
        episode_title (str): Název epizody (jen pro seriály)
        season_number (int): Číslo sezóny (jen pro seriály)
        episode_number (int): Číslo epizody (jen pro seriály)
    
    Returns:
        str: Osobní rada od režiséra/tvůrce nebo None při chybě
    """
    if media_type == "series":
        director_role = "tvůrce seriálu"
        context = f"seriálu {title}"
        if episode_title:
            context += f", konkrétně epizody '{episode_title}'"
            if season_number and episode_number:
                context += f" (S{season_number:02d}E{episode_number:02d})"
            character_note = "Odpověz jako tvůrce, který zná každou scénu a každý detail této epizody."
        else:
            character_note = "Odpověz jako tvůrce, který zná celý seriál, všechny postavy a dějové linky."
    elif media_type == "actor":
        director_role = "herec"
        context = f"herce {title}"
        character_note = "Odpověz jako herec, který zná svůj životopis, kariéru a všechny své role."
    elif media_type == "director":
        director_role = "režisér"
        context = f"režiséra {title}"
        character_note = "Odpověz jako režisér, který zná svůj životopis, kariéru a všechny své filmy."
    elif media_type == "creator":
        director_role = "tvůrce"
        context = f"tvůrce {title}"
        character_note = "Odpověz jako tvůrce, který zná svůj životopis, kariéru a všechny své seriály."
    else:
        director_role = "režiséra filmu"
        context = f"filmu {title}"
        character_note = "Odpověz jako režisér, který zná každou scénu a každý detail tohoto filmu."
    
    # Sestavení kontextu
    context_info = f"Kontext {context}"
    if plot:
        context_info += f"\nDěj: {plot[:300]}"
    if genre:
        context_info += f"\nŽánr: {genre}"
    
    # Sestavení možností pro lepší orientaci
    options_text = ""
    if len(options) >= 4:
        options_text = f"""
MOŽNOSTI ODPOVĚDÍ:
A) {options[0]}
B) {options[1]}
C) {options[2]}
D) {options[3]}"""
    
    prompt = f"""Jsi {director_role} {context}. Hráč se tě ptá na tip k této otázce:

{context_info}

OTÁZKA: {question}{options_text}

{character_note}

Poskytni krátký, užitečný tip (maximálně 2-3 věty), který:
- Neodhalí přímo správnou odpověď
- Nasměruje k správnému uvažování nebo poskytne relevantní kontext
- Použije tvoje znalosti jako {director_role}
- Bude v charakteru a stylu {director_role}
- Pomůže hráči lépe se rozhodnout

Odpověz POUZE tipem, bez úvodu či závěru."""

    try:
        # Pro tipy nepoužíváme tools
        response_text, usage = send_prompt(prompt, usage_type='director_tip', session_id=session_id)
        
        # Zpracování odpovědi
        if isinstance(response_text, list):
            parts = [evt.get('text', str(evt)) if isinstance(evt, dict) else str(evt) for evt in response_text]
            tip_text = ''.join(parts).strip()
        else:
            tip_text = str(response_text).strip()
        
        return tip_text if tip_text else None
        
    except Exception as e:
        xbmc.log(f"[plugin.video.milionar] Error generating director tip: {e}", level=xbmc.LOGERROR)
        return None

def generate_quiz_batch(media_type="movie", title="", plot="", genre="", episode_title="", season_number=None, episode_number=None, total_questions=5):
    """
    Generuje všech 5 kvízových otázek najednou pro prevenci opakování.
    
    Args:
        media_type (str): "movie" nebo "series"
        title (str): Název filmu/seriálu
        plot (str): Děj filmu/epizody (volitelné)
        genre (str): Žánr (volitelné)
        episode_title (str): Název epizody (jen pro seriály)
        season_number (int): Číslo sezóny (jen pro seriály)
        episode_number (int): Číslo epizody (jen pro seriály)
        total_questions (int): Celkový počet otázek (default 5)
    
    Returns:
        tuple: (list_of_questions, usage) kde list_of_questions obsahuje dictionary pro každou otázku
    """
    categories = ["trivia", "děj", "postavy", "herci", "režie", "produkce"]
    
    if media_type == "series":
        if episode_title:
            # Pro seriály se zaměřit na konkrétní epizodu
            prompt = (
                f"Jsi tvůrce televizního kvízu. Vytvoř {total_questions} různých kvízových otázek o seriálu '{title}' specificky o epizodě '{episode_title}' (S{season_number}E{episode_number}).\n\n"
                f"KONTEXT EPIZODY:\n"
                f"Seriál: {title}\n"
                f"Epizoda: {episode_title}\n"
                f"Sezóna: {season_number}, Epizoda: {episode_number}\n"
                f"Děj epizody: {plot[:200] if plot else 'Využij své znalosti o této konkrétní epizodě'}\n\n"
                
                "KRITICKÉ INSTRUKCE:\n"
                "1. Využij VŠECHNY své znalosti o TÉTO KONKRÉTNÍ EPIZODĚ (ne celém seriálu)\n"
                "2. Každá otázka musí být z JINÉ kategorie nebo aspektu epizody\n"
                f"3. Pokryj různé kategorie: {', '.join(categories)}\n"
                "4. Žádné dvě otázky se nesmí opakovat ani podobat\n"
                "5. Otázky ať testují skutečné znalosti této epizody\n"
                "6. Každá otázka 3 možnosti odpovědi (A, B, C)\n"
                "7. Pouze JEDNA odpověď je správná u každé otázky\n"
                "8. Ostatní odpovědi ať jsou věrohodné ale špatné\n"
                "9. Stupňuj obtížnost: 1-2 lehké, 3-4 střední, 5 těžká\n\n"
                
                "FORMÁT ODPOVĚDI MUSÍ BÝT PŘESNĚ TAKTO:\n"
                "{\n"
                '  "questions": [\n'
                '    {\n'
                '      "question": "Text otázky 1",\n'
                '      "options": {"A": "Možnost A", "B": "Možnost B", "C": "Možnost C"},\n'
                '      "correct": "A|B|C"\n'
                '    },\n'
                '    {\n'
                '      "question": "Text otázky 2",\n'
                '      "options": {"A": "Možnost A", "B": "Možnost B", "C": "Možnost C"},\n'
                '      "correct": "A|B|C"\n'
                '    }\n'
                '    // ... další otázky až do 5\n'
                '  ]\n'
                "}"
            )
        else:
            # Pro seriály bez konkrétní epizody
            prompt = (
                f"Jsi tvůrce televizního kvízu. Vytvoř {total_questions} různých kvízových otázek o seriálu '{title}'.\n\n"
                f"KONTEXT SERIÁLU:\n"
                f"Seriál: {title}\n"
                f"Žánr: {genre if genre else 'Využij své znalosti'}\n"
                f"Děj: {plot[:200] if plot else 'Využij své znalosti o tomto seriálu'}\n\n"
                
                "KRITICKÉ INSTRUKCE:\n"
                "1. Využij VŠECHNY své znalosti o tomto seriálu\n"
                "2. Každá otázka musí být z JINÉ kategorie nebo aspektu seriálu\n"
                f"3. Pokryj různé kategorie: {', '.join(categories)}\n"
                "4. Žádné dvě otázky se nesmí opakovat ani podobat\n"
                "5. Otázky ať testují skutečné znalosti o seriálu\n"
                "6. Každá otázka 3 možnosti odpovědi (A, B, C)\n"
                "7. Pouze JEDNA odpověď je správná u každé otázky\n"
                "8. Ostatní odpovědi ať jsou věrohodné ale špatné\n"
                "9. Stupňuj obtížnost: 1-2 lehké, 3-4 střední, 5 těžká\n\n"
                
                "FORMÁT ODPOVĚDI MUSÍ BÝT PŘESNĚ TAKTO:\n"
                "{\n"
                '  "questions": [\n'
                '    {\n'
                '      "question": "Text otázky 1",\n'
                '      "options": {"A": "Možnost A", "B": "Možnost B", "C": "Možnost C"},\n'
                '      "correct": "A|B|C"\n'
                '    },\n'
                '    {\n'
                '      "question": "Text otázky 2",\n'
                '      "options": {"A": "Možnost A", "B": "Možnost B", "C": "Možnost C"},\n'
                '      "correct": "A|B|C"\n'
                '    }\n'
                '    // ... další otázky až do 5\n'
                '  ]\n'
                "}"
            )
    else:
        # Pro filmy
        prompt = (
            f"Jsi tvůrce filmového kvízu. Vytvoř {total_questions} různých kvízových otázek o filmu '{title}'.\n\n"
            f"KONTEXT FILMU:\n"
            f"Název: {title}\n"
            f"Žánr: {genre if genre else 'Využij své znalosti'}\n"
            f"Děj: {plot[:200] if plot else 'Využij své znalosti o tomto filmu'}\n\n"
            
            "KRITICKÉ INSTRUKCE:\n"
            "1. Využij VŠECHNY své znalosti o tomto filmu\n"
            "2. Každá otázka musí být z JINÉ kategorie nebo aspektu filmu\n"
            f"3. Pokryj různé kategorie: {', '.join(categories)}\n"
            "4. Žádné dvě otázky se nesmí opakovat ani podobat\n"
            "5. Otázky ať testují skutečné znalosti o filmu\n"
            "6. Každá otázka 3 možnosti odpovědi (A, B, C)\n"
            "7. Pouze JEDNA odpověď je správná u každé otázky\n"
            "8. Ostatní odpovědi ať jsou věrohodné ale špatné\n"
            "9. Stupňuj obtížnost: 1-2 lehké, 3-4 střední, 5 těžká\n\n"
            
            "FORMÁT ODPOVĚDI MUSÍ BÝT PŘESNĚ TAKTO:\n"
            "{\n"
            '  "questions": [\n'
            '    {\n'
            '      "question": "Text otázky 1",\n'
            '      "options": {"A": "Možnost A", "B": "Možnost B", "C": "Možnost C"},\n'
            '      "correct": "A|B|C"\n'
            '    },\n'
            '    {\n'
            '      "question": "Text otázky 2",\n'
            '      "options": {"A": "Možnost A", "B": "Možnost B", "C": "Možnost C"},\n'
            '      "correct": "A|B|C"\n'
            '    }\n'
            '    // ... další otázky až do 5\n'
            '  ]\n'
            "}"
        )
    
    try:
        # Pro kvízy nepoužíváme tools
        response_text, usage = send_prompt(prompt, usage_type='quiz')
        
        # Zpracování odpovědi
        if isinstance(response_text, list):
            parts = [evt.get('text', str(evt)) if isinstance(evt, dict) else str(evt) for evt in response_text]
            response_raw = ''.join(parts)
        else:
            response_raw = str(response_text)
        
        try:
            # Robustní extrakce JSON: najdi první { a poslední }
            start = response_raw.find('{')
            end = response_raw.rfind('}')
            if start != -1 and end != -1 and end > start:
                json_str = response_raw[start:end+1]
            else:
                json_str = response_raw
            
            # Parsování JSON odpovědi
            response_json = json.loads(json_str)
            questions_data = response_json.get('questions', [])
            
            if len(questions_data) != total_questions:
                raise ValueError(f"Očekáváno {total_questions} otázek, získáno {len(questions_data)}")
            
            # Převedení do standardního formátu
            questions = []
            for i, q_data in enumerate(questions_data):
                question_text = q_data.get('question', '')
                options_dict = q_data.get('options', {})
                correct_answer = q_data.get('correct', 'A')
                
                # Sestavení seznamu možností v pořadí A, B, C
                options = [
                    options_dict.get('A', ''),
                    options_dict.get('B', ''),
                    options_dict.get('C', '')
                ]
                
                # Převedení písmena na index
                correct_index = {'A': 0, 'B': 1, 'C': 2}.get(correct_answer.upper(), 0)
                
                # Validace dat
                if not question_text or not all(options):
                    raise ValueError(f"Neplatná struktura otázky {i+1}")
                
                questions.append({
                    'question': question_text,
                    'options': options,
                    'correct_index': correct_index
                })
            
            return questions, usage
            
        except json.JSONDecodeError as e:
            xbmc.log(f"[plugin.video.milionar] Error parsing JSON response in generate_quiz_batch: {e}", level=xbmc.LOGERROR)
            raise ValueError("Neplatný JSON formát odpovědi")
            
    except Exception as e:
        xbmc.log(f"[plugin.video.milionar] Error in generate_quiz_batch: {e}", level=xbmc.LOGERROR)
        # Fallback - vytvořit základní otázky
        questions = []
        for i in range(total_questions):
            if media_type == "series":
                fallback_question = f"Obecná otázka {i+1} o epizodě '{episode_title}' ze seriálu {title}"
                fallback_options = [f"Možnost A", f"Možnost B", f"Možnost C"]
            else:
                fallback_question = f"Obecná otázka {i+1} o filmu {title}"
                fallback_options = [f"Možnost A", f"Možnost B", f"Možnost C"]
            
            questions.append({
                'question': fallback_question,
                'options': fallback_options,
                'correct_index': 0
            })
        return questions, None

# === NOVÉ FUNKCE PRO MILIONÁŘE NA TÉMA HERCE ===

# === NOVÉ FUNKCE PRO QUIZ NA TÉMA HERCE ===

def generate_actor_quiz_batch(actor_name: str, actor_bio: str = "", known_for=None, total_questions: int = 5):
    """Generuje dávku kvízových otázek o herci."""
    known_for = known_for or []
    roles_info = "\nZnámé role: " + ", ".join(known_for[:10]) if known_for else ""
    bio_info = f"\n\nŽivotopis: {actor_bio[:400]}" if actor_bio else ""

    prompt = f"""Jsi tvůrce filmových kvízů. Vytvoř {total_questions} otázek (A, B, C) o herci {actor_name}.{bio_info}{roles_info}

KRITÉRIA:
1. Pokryj různé oblasti: životopis, filmy, ocenění, zajímavosti, spolupráce.
2. Obtížnost stupňuj: 1-2 lehké, 3-4 střední, 5 těžká.
3. Každá otázka 3 možnosti (A, B, C) a jedna správná.
4. Žádné opakování témat.

FORMÁT:
{{
  "questions": [{{"question": "", "options": {{"A":"","B":"","C":""}}, "correct":"A"}}]
}}
"""
    try:
        resp, usage = send_prompt(prompt, usage_type='quiz')
        if isinstance(resp, list):
            resp = ''.join([str(r.get('text', r)) if isinstance(r, dict) else str(r) for r in resp])
        start = resp.find('{'); end = resp.rfind('}')
        json_str = resp[start:end+1] if start!=-1 and end!=-1 else resp
        data = json.loads(json_str)
        questions = []
        for q in data.get('questions', []):
            opts = q.get('options', {})
            correct_letter = q.get('correct', 'A').upper()
            questions.append({
                'question': q.get('question',''),
                'options': [opts.get('A',''), opts.get('B',''), opts.get('C','')],
                'correct_index': {'A':0,'B':1,'C':2}.get(correct_letter,0)
            })
        return questions, usage
    except Exception as e:
        xbmc.log(f"[plugin.video.milionar] actor quiz error: {e}", xbmc.LOGERROR)
        # fallback simple questions
        q=[]
        for i in range(total_questions):
            q.append({'question':f'Obecná otázka {i+1} o herci {actor_name}','options':['A','B','C'],'correct_index':0})
        return q, None

# === TEXT GAME PRO HERCE ===

def start_actor_text_game(actor_name: str, actor_bio: str = "", known_for=None):
    known_for = known_for or []
    roles = ", ".join(known_for[:5]) if known_for else "jeho kariéry"
    prompt = f"""Jsi vypravěč. Vytvoř úvod interaktivního příběhu ze života herce {actor_name}. Hráč si vybere, zda chce hrát období A) začátky kariéry, B) vrchol kariéry, C) osobní život. FORMÁT: {{\n  \"intro\": \"text\",\n  \"choices\":{{\"a\":\"Začátky kariéry\",\"b\":\"Vrchol kariéry\",\"c\":\"Osobní život\"}}\n}}"""
    try:
        resp, usage = send_prompt(prompt, usage_type='text_game')
        if isinstance(resp, list):
            resp = ''.join([r.get('text', str(r)) if isinstance(r, dict) else str(r) for r in resp])
        data = json.loads(resp[resp.find('{'):resp.rfind('}')+1])
        intro = data.get('intro','')
        ch = data.get('choices',{})
        choices=[ch.get('a',''), ch.get('b',''), ch.get('c','')]
        return intro, choices, usage
    except Exception as e:
        xbmc.log(f"[plugin.video.milionar] start_actor_text_game error: {e}", xbmc.LOGERROR)
        return f"Příběh herce {actor_name} začíná...", ["Začátky kariéry","Vrchol kariéry","Osobní život"], None

def continue_actor_text_game(actor_name: str, story_history, choice_made, turn_number=1):
    context = "\n".join(story_history[-4:])
    phase = "pokračuj" if turn_number<5 else "dokonči příběh"
    prompt = f"""Pokračuj v příběhu herce {actor_name}. Kontekst:\n{context}\nVolba hráče: {choice_made}\nInstrukce: {phase}. Dej 3 možnosti a),b),c). Pokud konec, volba c) = KONEC PŘÍBĚHU. FORMÁT stejný jako dříve."""
    try:
        resp, usage = send_prompt(prompt, usage_type='text_game')
        if isinstance(resp, list):
            resp = ''.join([r.get('text', str(r)) if isinstance(r, dict) else str(r) for r in resp])
        data = json.loads(resp[resp.find('{'):resp.rfind('}')+1])
        story=data.get('story','')
        ch=data.get('choices',{})
        choices=[ch.get('a',''), ch.get('b',''), ch.get('c','')]
        is_end = (turn_number>=5) or ('KONEC' in choices[2].upper())
        return story, choices, is_end, usage
    except Exception as e:
        xbmc.log(f"[plugin.video.milionar] continue_actor_text_game error: {e}", xbmc.LOGERROR)
        return "Příběh pokračuje...", ["Volba A","Volba B","KONEC PŘÍBĚHU"], turn_number>=5, None

# === FUNKCE PRO MILIONÁŘE S REŽISÉREM ===

def generate_director_quiz_batch(director_name: str, director_bio: str = "", known_for=None, total_questions: int = 5):
    """Generuje dávku kvízových otázek o režisérovi."""
    known_for = known_for or []
    films_info = "\nZnámé filmy: " + ", ".join(known_for[:10]) if known_for else ""
    bio_info = f"\n\nŽivotopis: {director_bio[:400]}" if director_bio else ""

    prompt = f"""Jsi tvůrce filmových kvízů. Vytvoř {total_questions} otázek (A, B, C) o režisérovi {director_name}.{bio_info}{films_info}

KRITÉRIA:
1. Pokryj různé oblasti: životopis, filmy, ocenění, zajímavosti, spolupráce.
2. Obtížnost stupňuj: 1-2 lehké, 3-4 střední, 5 těžká.
3. Každá otázka 3 možnosti (A, B, C) a jedna správná.
4. Žádné opakování témat.

FORMÁT:
{{
  "questions": [{{"question": "", "options": {{"A":"","B":"","C":""}}, "correct":"A"}}]
}}
"""
    try:
        resp, usage = send_prompt(prompt, usage_type='quiz')
        if isinstance(resp, list):
            resp = ''.join([str(r.get('text', r)) if isinstance(r, dict) else str(r) for r in resp])
        start = resp.find('{'); end = resp.rfind('}')
        json_str = resp[start:end+1] if start!=-1 and end!=-1 else resp
        data = json.loads(json_str)
        questions = []
        for q in data.get('questions', []):
            opts = q.get('options', {})
            correct_letter = q.get('correct', 'A').upper()
            questions.append({
                'question': q.get('question',''),
                'options': [opts.get('A',''), opts.get('B',''), opts.get('C','')],
                'correct_index': {'A':0,'B':1,'C':2}.get(correct_letter,0)
            })
        return questions, usage
    except Exception as e:
        xbmc.log(f"[plugin.video.milionar] director quiz error: {e}", xbmc.LOGERROR)
        # fallback simple questions
        q=[]
        for i in range(total_questions):
            q.append({'question':f'Obecná otázka {i+1} o režisérovi {director_name}','options':['A','B','C'],'correct_index':0})
        return q, None

# === TEXT GAME PRO REŽISÉRA ===

def start_director_text_game(director_name: str, director_bio: str = "", known_for=None):
    known_for = known_for or []
    films = ", ".join(known_for[:5]) if known_for else "jeho kariéry"
    prompt = f"""Jsi vypravěč. Vytvoř úvod interaktivního příběhu ze života režiséra {director_name}. Hráč si vybere, zda chce hrát období A) začátky kariéry, B) vrchol kariéry, C) osobní život. FORMÁT: {{\n  \"intro\": \"text\",\n  \"choices\":{{\"a\":\"Začátky kariéry\",\"b\":\"Vrchol kariéry\",\"c\":\"Osobní život\"}}\n}}"""
    try:
        resp, usage = send_prompt(prompt, usage_type='text_game')
        if isinstance(resp, list):
            resp = ''.join([r.get('text', str(r)) if isinstance(r, dict) else str(r) for r in resp])
        data = json.loads(resp[resp.find('{'):resp.rfind('}')+1])
        intro = data.get('intro','')
        ch = data.get('choices',{})
        choices=[ch.get('a',''), ch.get('b',''), ch.get('c','')]
        return intro, choices, usage
    except Exception as e:
        xbmc.log(f"[plugin.video.milionar] start_director_text_game error: {e}", xbmc.LOGERROR)
        return f"Příběh režiséra {director_name} začíná...", ["Začátky kariéry","Vrchol kariéry","Osobní život"], None

def continue_director_text_game(director_name: str, story_history, choice_made, turn_number=1):
    context = "\n".join(story_history[-4:])
    phase = "pokračuj" if turn_number<5 else "dokonči příběh"
    prompt = f"""Pokračuj v příběhu režiséra {director_name}. Kontekst:\n{context}\nVolba hráče: {choice_made}\nInstrukce: {phase}. Dej 3 možnosti a),b),c). Pokud konec, volba c) = KONEC PŘÍBĚHU. FORMÁT stejný jako dříve."""
    try:
        resp, usage = send_prompt(prompt, usage_type='text_game')
        if isinstance(resp, list):
            resp = ''.join([r.get('text', str(r)) if isinstance(r, dict) else str(r) for r in resp])
        data = json.loads(resp[resp.find('{'):resp.rfind('}')+1])
        story=data.get('story','')
        ch=data.get('choices',{})
        choices=[ch.get('a',''), ch.get('b',''), ch.get('c','')]
        is_end = (turn_number>=5) or ('KONEC' in choices[2].upper())
        return story, choices, is_end, usage
    except Exception as e:
        xbmc.log(f"[plugin.video.milionar] continue_director_text_game error: {e}", xbmc.LOGERROR)
        return "Příběh pokračuje...", ["Volba A","Volba B","KONEC PŘÍBĚHU"], turn_number>=5, None

# === FUNKCE PRO MILIONÁŘE S TVŮRCEM ===

def generate_creator_quiz_batch(creator_name: str, creator_bio: str = "", known_for=None, total_questions: int = 5):
    """Generuje dávku kvízových otázek o tvůrci."""
    known_for = known_for or []
    shows_info = "\nZnámé seriály: " + ", ".join(known_for[:10]) if known_for else ""
    bio_info = f"\n\nŽivotopis: {creator_bio[:400]}" if creator_bio else ""

    prompt = f"""Jsi tvůrce televizních kvízů. Vytvoř {total_questions} otázek (A, B, C) o tvůrci seriálů {creator_name}.{bio_info}{shows_info}

KRITÉRIA:
1. Pokryj různé oblasti: životopis, seriály, ocenění, zajímavosti, spolupráce s herci a režiséry.
2. Obtížnost stupňuj: 1-2 lehké, 3-4 střední, 5 těžká.
3. Každá otázka 3 možnosti (A, B, C) a jedna správná.
4. Žádné opakování témat.

FORMÁT:
{{
  "questions": [{{"question": "", "options": {{"A":"","B":"","C":""}}, "correct":"A"}}]
}}
"""
    try:
        resp, usage = send_prompt(prompt, usage_type='quiz')
        if isinstance(resp, list):
            resp = ''.join([str(r.get('text', r)) if isinstance(r, dict) else str(r) for r in resp])
        start = resp.find('{'); end = resp.rfind('}')
        json_str = resp[start:end+1] if start!=-1 and end!=-1 else resp
        data = json.loads(json_str)
        questions = []
        for q in data.get('questions', []):
            opts = q.get('options', {})
            correct_letter = q.get('correct', 'A').upper()
            questions.append({
                'question': q.get('question',''),
                'options': [opts.get('A',''), opts.get('B',''), opts.get('C','')],
                'correct_index': {'A':0,'B':1,'C':2}.get(correct_letter,0)
            })
        return questions, usage
    except Exception as e:
        xbmc.log(f"[plugin.video.milionar] creator quiz error: {e}", xbmc.LOGERROR)
        # fallback simple questions
        q=[]
        for i in range(total_questions):
            q.append({'question':f'Obecná otázka {i+1} o tvůrci {creator_name}','options':['A','B','C'],'correct_index':0})
        return q, None

# === TEXT GAME PRO TVŮRCE ===

def start_creator_text_game(creator_name: str, creator_bio: str = "", known_for=None):
    known_for = known_for or []
    shows = ", ".join(known_for[:5]) if known_for else "jeho kariéry"
    prompt = f"""Jsi vypravěč. Vytvoř úvod interaktivního příběhu ze života tvůrce seriálů {creator_name}. Hráč si vybere, zda chce hrát období A) začátky kariéry, B) vrchol kariéry, C) osobní život. FORMÁT: {{\n  \"intro\": \"text\",\n  \"choices\":{{\"a\":\"Začátky kariéry\",\"b\":\"Vrchol kariéry\",\"c\":\"Osobní život\"}}\n}}"""
    try:
        resp, usage = send_prompt(prompt, usage_type='text_game')
        if isinstance(resp, list):
            resp = ''.join([r.get('text', str(r)) if isinstance(r, dict) else str(r) for r in resp])
        data = json.loads(resp[resp.find('{'):resp.rfind('}')+1])
        intro = data.get('intro','')
        ch = data.get('choices',{})
        choices=[ch.get('a',''), ch.get('b',''), ch.get('c','')]
        return intro, choices, usage
    except Exception as e:
        xbmc.log(f"[plugin.video.milionar] start_creator_text_game error: {e}", xbmc.LOGERROR)
        return f"Příběh tvůrce {creator_name} začíná...", ["Začátky kariéry","Vrchol kariéry","Osobní život"], None

def continue_creator_text_game(creator_name: str, story_history, choice_made, turn_number=1):
    context = "\n".join(story_history[-4:])
    phase = "pokračuj" if turn_number<5 else "dokonči příběh"
    prompt = f"""Pokračuj v příběhu tvůrce seriálů {creator_name}. Kontekst:\n{context}\nVolba hráče: {choice_made}\nInstrukce: {phase}. Dej 3 možnosti a),b),c). Pokud konec, volba c) = KONEC PŘÍBĚHU. FORMÁT stejný jako dříve."""
    try:
        resp, usage = send_prompt(prompt, usage_type='text_game')
        if isinstance(resp, list):
            resp = ''.join([r.get('text', str(r)) if isinstance(r, dict) else str(r) for r in resp])
        data = json.loads(resp[resp.find('{'):resp.rfind('}')+1])
        story=data.get('story','')
        ch=data.get('choices',{})
        choices=[ch.get('a',''), ch.get('b',''), ch.get('c','')]
        is_end = (turn_number>=5) or ('KONEC' in choices[2].upper())
        return story, choices, is_end, usage
    except Exception as e:
        xbmc.log(f"[plugin.video.milionar] continue_creator_text_game error: {e}", xbmc.LOGERROR)
        return "Příběh pokračuje...", ["Volba A","Volba B","KONEC PŘÍBĚHU"], turn_number>=5, None

# === NOVÉ FUNKCE PRO SCÉNÁRISTY (WRITER) ===

def generate_writer_quiz_batch(writer_name: str, writer_bio: str = "", known_for=None, total_questions: int = 5):
    """Generuje dávku kvízových otázek o scénáristovi."""
    known_for = known_for or []
    movies_info = "\nZnámé filmy: " + ", ".join(known_for[:10]) if known_for else ""
    bio_info = f"\n\nŽivotopis: {writer_bio[:400]}" if writer_bio else ""

    prompt = f"""Jsi tvůrce filmových kvízů. Vytvoř {total_questions} otázek (A, B, C) o scénáristovi {writer_name}.{bio_info}{movies_info}

KRITÉRIA:
1. Pokryj různé oblasti: životopis, filmy, ocenění, zajímavosti, spolupráce s režiséry a herci.
2. Obtížnost stupňuj: 1-2 lehké, 3-4 střední, 5 těžká.
3. Každá otázka 3 možnosti (A, B, C) a jedna správná.
4. Žádné opakování témat.

FORMÁT:
{{
  "questions": [{{"question": "", "options": {{"A":"","B":"","C":""}}, "correct":"A"}}]
}}
"""
    try:
        resp, usage = send_prompt(prompt, usage_type='quiz')
        if isinstance(resp, list):
            resp = ''.join([str(r.get('text', r)) if isinstance(r, dict) else str(r) for r in resp])
        start = resp.find('{'); end = resp.rfind('}')
        json_str = resp[start:end+1] if start!=-1 and end!=-1 else resp
        data = json.loads(json_str)
        questions = []
        for q in data.get('questions', []):
            opts = q.get('options', {})
            correct_letter = q.get('correct', 'A').upper()
            questions.append({
                'question': q.get('question',''),
                'options': [opts.get('A',''), opts.get('B',''), opts.get('C','')],
                'correct_index': {'A':0,'B':1,'C':2}.get(correct_letter,0)
            })
        return questions, usage
    except Exception as e:
        xbmc.log(f"[plugin.video.milionar] writer quiz error: {e}", xbmc.LOGERROR)
        # fallback simple questions
        q=[]
        for i in range(total_questions):
            q.append({'question':f'Obecná otázka {i+1} o scénáristovi {writer_name}','options':['A','B','C'],'correct_index':0})
        return q, None

# === TEXT GAME PRO SCÉNÁRISTY ===

def start_writer_text_game(writer_name: str, writer_bio: str = "", known_for=None):
    known_for = known_for or []
    movies = ", ".join(known_for[:5]) if known_for else "jeho kariéry"
    prompt = f"""Jsi vypravěč. Vytvoř úvod interaktivního příběhu ze života scénáristy {writer_name}. Hráč si vybere, zda chce hrát období A) začátky kariéry, B) vrchol kariéry, C) osobní život. FORMÁT: {{\n  \"intro\": \"text\",\n  \"choices\":{{\"a\":\"Začátky kariéry\",\"b\":\"Vrchol kariéry\",\"c\":\"Osobní život\"}}\n}}"""
    try:
        resp, usage = send_prompt(prompt, usage_type='text_game')
        if isinstance(resp, list):
            resp = ''.join([r.get('text', str(r)) if isinstance(r, dict) else str(r) for r in resp])
        data = json.loads(resp[resp.find('{'):resp.rfind('}')+1])
        intro = data.get('intro','')
        ch = data.get('choices',{})
        choices=[ch.get('a',''), ch.get('b',''), ch.get('c','')]
        return intro, choices, usage
    except Exception as e:
        xbmc.log(f"[plugin.video.milionar] start_writer_text_game error: {e}", xbmc.LOGERROR)
        return f"Příběh scénáristy {writer_name} začíná...", ["Začátky kariéry","Vrchol kariéry","Osobní život"], None

def continue_writer_text_game(writer_name: str, story_history, choice_made, turn_number=1):
    context = "\n".join(story_history[-4:])
    phase = "pokračuj" if turn_number<5 else "dokonči příběh"
    prompt = f"""Pokračuj v příběhu scénáristy {writer_name}. Kontekst:\n{context}\nVolba hráče: {choice_made}\nInstrukce: {phase}. Dej 3 možnosti a),b),c). Pokud konec, volba c) = KONEC PŘÍBĚHU. FORMÁT stejný jako dříve."""
    try:
        resp, usage = send_prompt(prompt, usage_type='text_game')
        if isinstance(resp, list):
            resp = ''.join([r.get('text', str(r)) if isinstance(r, dict) else str(r) for r in resp])
        data = json.loads(resp[resp.find('{'):resp.rfind('}')+1])
        story=data.get('story','')
        ch=data.get('choices',{})
        choices=[ch.get('a',''), ch.get('b',''), ch.get('c','')]
        is_end = (turn_number>=5) or ('KONEC' in choices[2].upper())
        return story, choices, is_end, usage
    except Exception as e:
        xbmc.log(f"[plugin.video.milionar] continue_writer_text_game error: {e}", xbmc.LOGERROR)
        return "Příběh pokračuje...", ["Volba A","Volba B","KONEC PŘÍBĚHU"], turn_number>=5, None