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
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)
        
        # 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)
        
        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, 
            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,
        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)

    # Track usage
    from wcs.ai.UsageTracker import track_ai_usage
    from wcs.ai.AIProvider import ai_provider
    provider = ai_provider.get_current_provider()
    model = ai_provider.get_current_model()
    track_ai_usage(provider, model, usage, "millionaire_chat", session_id=session_id)

    # 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_millionaire_easy_questions(media_type="movie", title="", plot="", genre="", episode_title="", season_number=None, episode_number=None):
    """
    Generuje 3 snadné otázky pro Filmový Milionář - základní porozumění příběhu.
    Témata: Hlavní zápletka, klíčové události, základní postavy.
    """
    # Sestavení kontextu podle typu média
    if media_type == "series":
        if episode_title:
            media_context = f'seriál "{title}", epizoda "{episode_title}"'
            if season_number and episode_number:
                media_context += f" (série {season_number}, epizoda {episode_number})"
        else:
            media_context = f'seriál "{title}"'
    else:
        media_context = f'film "{title}"'
    
    plot_info = f"\n\nDěj: {plot}" if plot else ""
    genre_info = f"\nŽánr: {genre}" if genre else ""
    
    difficulty_header = get_millionaire_difficulty_header()
    difficulty_instruction = get_millionaire_difficulty_instruction()
    moderator_block = _get_moderator_prompt_block(include_welcome=True, media_context=media_context, level_label="SNADNÁ")
    prompt = f"""{difficulty_header}Jsi expert na filmové kvízy. Vytvoř přesně 3 SNADNÉ otázky pro kvíz typu "Chcete být milionářem" o {media_context}.{plot_info}{genre_info}

OBTÍŽNOST: SNADNÁ - "Základní porozumění příběhu"
TÉMATA: Hlavní zápletka, klíčové události, základní postavy
CÍLOVÁ SKUPINA: Každý divák, kdo film/seriál sledoval

{difficulty_instruction}

PŘÍKLADY TÉMAT:
- Kdo je hlavní postava?
- Kde se odehrává příběh?
- Co je hlavní cíl protagonisty?
- Jak film/epizoda končí? (základní koncovka)
- Kdo je hlavní antagonista?
{moderator_block}
DŮLEŽITÉ:
- Přesně 3 otázky
- Každá otázka má 4 možnosti (A, B, C, D)
- Správná odpověď jako písmeno (A, B, C nebo D)
- Otázky musí být JEDNODUCHÉ pro běžného diváka
- Zaměř se POUZE na základní děj a hlavní postavy
- KAŽDÁ MOŽNOST ODPOVĚDI MÁ MAXIMÁLNĚ 25 ZNAKŮ (včetně mezer) - buď stručná a jasná"""

    try:
        response_text, usage = send_prompt(prompt)
        questions, moderator_welcome = _parse_millionaire_response(response_text, usage, "millionaire_easy_questions")
        return questions, moderator_welcome
        
    except Exception as e:
        xbmc.log(f"[plugin.video.milionar] Error generating millionaire easy questions: {e}", level=xbmc.LOGERROR)
        return [], None

def generate_millionaire_medium_questions(media_type="movie", title="", plot="", genre="", episode_title="", season_number=None, episode_number=None):
    """
    Generuje 3 střední otázky pro Filmový Milionář - pozornost k detailům.
    Témata: Vztahy postav, motivace, charakterový vývoj, vedlejší postavy.
    """
    # Sestavení kontextu podle typu média
    if media_type == "series":
        if episode_title:
            media_context = f'seriál "{title}", epizoda "{episode_title}"'
            if season_number and episode_number:
                media_context += f" (série {season_number}, epizoda {episode_number})"
        else:
            media_context = f'seriál "{title}"'
    else:
        media_context = f'film "{title}"'
    
    plot_info = f"\n\nDěj: {plot}" if plot else ""
    genre_info = f"\nŽánr: {genre}" if genre else ""
    
    difficulty_header = get_millionaire_difficulty_header()
    difficulty_instruction = get_millionaire_difficulty_instruction()
    moderator_block = _get_moderator_prompt_block(include_welcome=False, level_label="STŘEDNÍ")
    prompt = f"""{difficulty_header}Jsi expert na filmové kvízy. Vytvoř přesně 3 STŘEDNÍ otázky pro kvíz typu "Chcete být milionářem" o {media_context}.{plot_info}{genre_info}

OBTÍŽNOST: STŘEDNÍ - "Pozornost k detailům"
TÉMATA: Vztahy postav, motivace, charakterový vývoj, vedlejší postavy
CÍLOVÁ SKUPINA: Pozorný divák si všimne

{difficulty_instruction}

PŘÍKLADY TÉMAT:
- Jaký je vztah mezi [postava A] a [postava B]?
- Co motivuje [vedlejší postavu] k jednání?
- Jak se změní [hlavní postava] během příběhu?
- Kdo je [specifická vedlejší postava]?
- Jaké tajemství skrývá [postava]?
{moderator_block}
DŮLEŽITÉ:
- Přesně 3 otázky
- Každá otázka má 4 možnosti (A, B, C, D)
- Správná odpověď jako písmeno (A, B, C nebo D)
- Otázky musí být STŘEDNÍ obtížnosti
- Zaměř se na DETAILY postav a jejich vztahy
- Vyžadují pozorné sledování, ne jen základní děj
- KAŽDÁ MOŽNOST ODPOVĚDI MÁ MAXIMÁLNĚ 25 ZNAKŮ (včetně mezer) - buď stručná a jasná"""

    try:
        response_text, usage = send_prompt(prompt)
        questions, _ = _parse_millionaire_response(response_text, usage, "millionaire_medium_questions")
        return questions
        
    except Exception as e:
        xbmc.log(f"[plugin.video.milionar] Error generating millionaire medium questions: {e}", level=xbmc.LOGERROR)
        return []

def generate_millionaire_hard_questions(media_type="movie", title="", plot="", genre="", episode_title="", season_number=None, episode_number=None):
    """
    Generuje 3 těžké otázky pro Filmový Milionář - filmová erudice.
    Témata: Produkce, herci, režie, skryté detaily, trivia, easter eggs.
    """
    # Sestavení kontextu podle typu média
    if media_type == "series":
        if episode_title:
            media_context = f'seriál "{title}", epizoda "{episode_title}"'
            if season_number and episode_number:
                media_context += f" (série {season_number}, epizoda {episode_number})"
        else:
            media_context = f'seriál "{title}"'
    else:
        media_context = f'film "{title}"'
    
    plot_info = f"\n\nDěj: {plot}" if plot else ""
    genre_info = f"\nŽánr: {genre}" if genre else ""
    
    difficulty_header = get_millionaire_difficulty_header()
    difficulty_instruction = get_millionaire_difficulty_instruction()
    moderator_block = _get_moderator_prompt_block(include_welcome=False, level_label="TĚŽKÁ")
    prompt = f"""{difficulty_header}Jsi expert na filmové kvízy. Vytvoř přesně 3 TĚŽKÉ otázky pro kvíz typu "Chcete být milionářem" o {media_context}.{plot_info}{genre_info}

OBTÍŽNOST: TĚŽKÁ - "Filmová erudice"
TÉMATA: Produkce, herci, režie, skryté detaily, trivia, easter eggs
CÍLOVÁ SKUPINA: Skutečný fanoušek pozná

{difficulty_instruction}

PŘÍKLADY TÉMAT:
- Kdo režíroval tento film/epizodu?
- Který herec hrál [specifickou roli]?
- V jakém roce byl film natočen?
- Jaký easter egg se objevuje v [konkrétní scéně]?
- Kdo složil hudbu k filmu?
- Jaké jsou zajímavosti ze zákulisí?
- Originální název nebo lokace natáčení
{moderator_block}
DŮLEŽITÉ:
- Přesně 3 otázky
- Každá otázka má 4 možnosti (A, B, C, D)
- Správná odpověď jako písmeno (A, B, C nebo D)
- Otázky musí být TĚŽKÉ - pro skutečné znalce
- Zaměř se na PRODUKCI, HERCE, REŽII a TRIVIA
- Kombinace znalosti díla + filmové kultury
- KAŽDÁ MOŽNOST ODPOVĚDI MÁ MAXIMÁLNĚ 25 ZNAKŮ (včetně mezer) - buď stručná a jasná"""

    try:
        response_text, usage = send_prompt(prompt)
        questions, _ = _parse_millionaire_response(response_text, usage, "millionaire_hard_questions")
        return questions
        
    except Exception as e:
        xbmc.log(f"[plugin.video.milionar] Error generating millionaire hard questions: {e}", level=xbmc.LOGERROR)
        return []

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)
        
        # 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()
        
        # Tracking AI usage
        from wcs.ai.UsageTracker import track_ai_usage
        from wcs.ai.AIProvider import ai_provider
        provider = ai_provider.get_current_provider()
        model = ai_provider.get_current_model()
        track_ai_usage(provider, model, usage, "director_tip", session_id=session_id)
        
        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 _clean_ai_response(response_text):
    """Vyčistí AI odpověď pro JSON parsing."""
    if isinstance(response_text, list):
        # Spojit všechny části odpovědi
        parts = []
        for part in response_text:
            if isinstance(part, dict):
                parts.append(part.get('text', str(part)))
            else:
                parts.append(str(part))
        response_text = ''.join(parts)
    
    # Najít JSON blok
    json_start = response_text.find('{')
    json_end = response_text.rfind('}') + 1
    
    if json_start != -1 and json_end > json_start:
        return response_text[json_start:json_end]
    else:
        return response_text


def _get_moderator_prompt_block(include_welcome=False, media_context="", level_label=""):
    """Vrátí prompt blok pro generování moderátorských textů.
    
    DŮLEŽITÉ: Vrací normální string (ne f-string) protože výstup se vkládá
    do f-stringu v promptu. Braces musí být normální { } ne escaped {{ }}.
    
    Args:
        include_welcome: True pro easy sadu (první call) -- generuje welcome
        media_context: Kontext díla pro welcome (např. 'seriál "Zaklínač"')
        level_label: Label obtížnosti (SNADNÁ/STŘEDNÍ/TĚŽKÁ)
    """
    welcome_field = ""
    welcome_instruction = ""
    if include_welcome:
        welcome_field = '  "moderator_welcome": "Uvítací text moderátora s konkrétním kontextem díla (' + media_context + '). 2-3 věty.",\n'
        welcome_instruction = '- "moderator_welcome": Uvítací text moderátora. Musí zmínit konkrétní dílo a vytvořit atmosféru. Přátelský, nadšený tón. 2-3 věty.\n'

    # Sestavení JSON ukázky s normálními braces
    # (string se vkládá do f-stringu v promptu přes {moderator_block})
    result = (
        "\n"
        "MODERÁTOR:\n"
        'Jsi moderátor kvízu "Chcete být milionářem". Ke každé otázce přidej:\n'
        "- Krátký úvod moderátora (1-2 věty) -- uvede kolo, vytvoří napětí, zmíní kontext\n"
        "- Reakci na správnou odpověď (1-2 věty) -- pochvala, komentář, postup\n"
        "- Reakci na špatnou odpověď (1-2 věty) -- soucit, vysvětlení, povzbuzení\n"
        "\n"
        "Styl moderátora:\n"
        "- Přátelský, vtipný, napínavý jako skutečný moderátor Milionáře\n"
        "- Zná dílo a odkazuje na něj v komentářích\n"
        "- Stupňuje napětí s rostoucí obtížností (" + level_label + ")\n"
        "- Mluví česky, oslovuje hráče vykáním\n"
        "\n"
        "FORMÁT ODPOVĚDI (PŘESNĚ):\n"
        "{\n"
        + welcome_field +
        '  "questions": [\n'
        "    {\n"
        '      "moderator_intro": "Krátký úvod moderátora k této otázce. 1-2 věty.",\n'
        '      "question": "Text otázky",\n'
        '      "options": {"A": "Možnost A", "B": "Možnost B", "C": "Možnost C", "D": "Možnost D"},\n'
        '      "correct": "A|B|C|D",\n'
        '      "explanation": "Krátké vysvětlení správné odpovědi",\n'
        '      "correct_feedback": "Reakce moderátora na správnou odpověď. 1-2 věty.",\n'
        '      "wrong_feedback": "Reakce moderátora na špatnou odpověď. 1-2 věty."\n'
        "    }\n"
        "  ]\n"
        "}\n"
        "\n"
        "PRAVIDLA MODERÁTOROVÝCH TEXTŮ:\n"
        + welcome_instruction +
        '- "moderator_intro": Uvede konkrétní kolo a částku, zmíní kontext otázky. Vytvoří napětí.\n'
        '- "correct_feedback": Pochválí hráče, zmíní postup na další úroveň. Může odkazovat na dílo.\n'
        '- "wrong_feedback": Projeví soucit, zmíní správnou odpověď v kontextu díla. Povzbudí.\n'
    )
    return result


def _parse_millionaire_response(response_text, usage, usage_type):
    """Parsuje AI odpověď s moderátorskými texty pro millionaire hru.
    
    Returns:
        tuple: (questions_list, moderator_welcome_or_None)
    """
    clean_response = _clean_ai_response(response_text)
    questions_data = json.loads(clean_response)
    
    # Extrahovat moderator_welcome (jen u easy sady)
    moderator_welcome = questions_data.get("moderator_welcome", None)
    
    # Převedení do standardního formátu
    questions = []
    for q_data in questions_data.get("questions", []):
        question_text = q_data.get('question', '')
        options_dict = q_data.get('options', {})
        correct_answer = q_data.get('correct', 'A')
        explanation = q_data.get('explanation', '')
        
        # Sestavení seznamu možností v pořadí A, B, C, D (bez prefixu -- XML layout přidává vlastní)
        options = [
            options_dict.get('A', ''),
            options_dict.get('B', ''),
            options_dict.get('C', ''),
            options_dict.get('D', '')
        ]
        
        # Převedení písmena na index
        correct_index = {'A': 0, 'B': 1, 'C': 2, 'D': 3}.get(correct_answer.upper(), 0)
        
        questions.append({
            'question': question_text,
            'options': options,
            'correct': correct_index,
            'explanation': explanation,
            'moderator_intro': q_data.get('moderator_intro', ''),
            'correct_feedback': q_data.get('correct_feedback', ''),
            'wrong_feedback': q_data.get('wrong_feedback', ''),
        })
    
    # Tracking AI usage
    from wcs.ai.UsageTracker import track_ai_usage
    from wcs.ai.AIProvider import ai_provider
    provider = ai_provider.get_current_provider()
    model = ai_provider.get_current_model()
    track_ai_usage(provider, model, usage, usage_type)
    
    return questions, moderator_welcome

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)
        
        # 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 ===

def generate_actor_millionaire_easy_questions(actor_name: str, bio: str = "", known_for=None):
    """
    Generuje 3 snadné otázky o herci pro hru Milionář - základní znalosti kariéry.
    Témata: Narození, nejslavnější role, základní ocenění, kariérní fakta.
    """
    known_for = known_for or []
    roles_info = "\nZnámé role: " + ", ".join(known_for[:10]) if known_for else ""
    bio_info = f"\n\nŽivotopis: {bio[:500]}" if bio else ""

    difficulty_header = get_millionaire_difficulty_header()
    difficulty_instruction = get_millionaire_difficulty_instruction()
    moderator_block = _get_moderator_prompt_block(include_welcome=True, media_context="herci", level_label="SNADNÁ")
    prompt = f"""{difficulty_header}Jsi expert na filmové kvízy. Vytvoř přesně 3 SNADNÉ otázky pro kvíz typu "Chcete být milionářem" o herci {actor_name}.{bio_info}{roles_info}

OBTÍŽNOST: SNADNÁ - "Základní znalosti kariéry"
TÉMATA: Narození, nejslavnější role, základní ocenění, kariérní fakta
CÍLOVÁ SKUPINA: Každý fanoušek filmů pozná

{difficulty_instruction}

PŘÍKLADY TÉMAT:
- Kdy se herec narodil?
- Ve kterém filmu hrál hlavní roli?
- Za jaký film získal Oscar?
- Jaké je jeho nejslavnější dílo?
- V jakém roce debutoval v kině?
- Jaké je jeho rodné město?
- Který film ho proslavil?

{moderator_block}
DŮLEŽITÉ:
- Přesně 3 otázky
- Každá otázka má 4 možnosti (A, B, C, D)
- Správná odpověď jako písmeno (A, B, C nebo D)
- Otázky musí být JEDNODUCHÉ pro běžného fanouška
- Zaměř se POUZE na základní fakta a nejslavnější díla
- KAŽDÁ MOŽNOST ODPOVĚDI MÁ MAXIMÁLNĚ 25 ZNAKŮ (včetně mezer) - buď stručná a jasná"""
    try:
        response_text, usage = send_prompt(prompt)
        questions, moderator_welcome = _parse_millionaire_response(response_text, usage, "actor_millionaire_easy")
        return questions, moderator_welcome
    except Exception as e:
        xbmc.log(f"[plugin.video.milionar] Error generating actor_millionaire_easy: {e}", xbmc.LOGERROR)
        return [], None

def generate_actor_millionaire_medium_questions(actor_name: str, bio: str = "", known_for=None):
    """
    Generuje 3 střední otázky o herci - pozornost k detailům kariéry.
    Témata: Konkrétní role, spolupráce, méně známá díla, citované výroky.
    """
    known_for = known_for or []
    roles_info = "\nZnámé role: " + ", ".join(known_for[:10]) if known_for else ""
    bio_info = f"\n\nŽivotopis: {bio[:500]}" if bio else ""

    difficulty_header = get_millionaire_difficulty_header()
    difficulty_instruction = get_millionaire_difficulty_instruction()
    moderator_block = _get_moderator_prompt_block(include_welcome=False, level_label="STŘEDNÍ")
    prompt = f"""{difficulty_header}Jsi expert na filmové kvízy. Vytvoř přesně 3 STŘEDNÍ otázky pro kvíz typu "Chcete být milionářem" o herci {actor_name}.{bio_info}{roles_info}

OBTÍŽNOST: STŘEDNÍ - "Pozornost k detailům kariéry"
TÉMATA: Konkrétní role, spolupráce s dalšími osobnostmi, méně známá díla, citované výroky
CÍLOVÁ SKUPINA: Pozorný fanoušek si všimne

{difficulty_instruction}

PŘÍKLADY TÉMAT:
- Jakou roli hrál v [konkrétním filmu]?
- S kým spolupracoval v [rok]?
- Jaký slavný výrok pronesl?
- V kterém méně známém filmu hrál?
- Jakou postavu ztvárnil v [seriálu]?
- S jakým režisérem spolupracoval?
- Jaké má herecké vzdělání?

{moderator_block}
DŮLEŽITÉ:
- Přesně 3 otázky
- Každá otázka má 4 možnosti (A, B, C, D)
- Správná odpověď jako písmeno (A, B, C nebo D)
- Otázky musí být STŘEDNÍ obtížnosti
- Zaměř se na DETAILY kariéry a spolupráce
- Vyžadují lepší znalost herce, ne jen základní fakta
- KAŽDÁ MOŽNOST ODPOVĚDI MÁ MAXIMÁLNĚ 25 ZNAKŮ (včetně mezer) - buď stručná a jasná"""
    try:
        response_text, usage = send_prompt(prompt)
        questions, _ = _parse_millionaire_response(response_text, usage, "actor_millionaire_medium")
        return questions
    except Exception as e:
        xbmc.log(f"[plugin.video.milionar] Error generating actor_millionaire_medium: {e}", xbmc.LOGERROR)
        return []

def generate_actor_millionaire_hard_questions(actor_name: str, bio: str = "", known_for=None):
    """
    Generuje 3 těžké otázky o herci - herecká erudice.
    Témata: Detailní trivia, specifická ocenění, méně známé projekty, historické souvislosti.
    """
    known_for = known_for or []
    roles_info = "\nZnámé role: " + ", ".join(known_for[:10]) if known_for else ""
    bio_info = f"\n\nŽivotopis: {bio[:500]}" if bio else ""

    difficulty_header = get_millionaire_difficulty_header()
    difficulty_instruction = get_millionaire_difficulty_instruction()
    moderator_block = _get_moderator_prompt_block(include_welcome=False, level_label="TĚŽKÁ")
    prompt = f"""{difficulty_header}Jsi filmový historik. Vytvoř přesně 3 TĚŽKÉ otázky pro kvíz typu "Chcete být milionářem" o herci {actor_name}.{bio_info}{roles_info}

OBTÍŽNOST: TĚŽKÁ - "Herecká erudice"
TÉMATA: Detailní trivia, specifická ocenění, méně známé projekty, historické souvislosti
CÍLOVÁ SKUPINA: Skutečný znalec herce pozná

{difficulty_instruction}

PŘÍKLADY TÉMAT:
- Za jakou roli byl nominován na [konkrétní rok]?
- V kterém divadelním představení hrál?
- Jaké má konkrétní ocenění z [festival]?
- V jakém roce debutoval v televizi?
- Jaké má vzdělání v herectví?
- Který méně známý film režíroval?
- Jaké má konkrétní hobby nebo zájmy?
- V kterém roce získal [konkrétní cenu]?

{moderator_block}
DŮLEŽITÉ:
- Přesně 3 otázky
- Každá otázka má 4 možnosti (A, B, C, D)
- Správná odpověď jako písmeno (A, B, C nebo D)
- Otázky musí být TĚŽKÉ - pro skutečné znalce
- Zaměř se na DETAILNÍ TRIVIA a méně známé fakta
- Kombinace znalosti herce + filmové kultury
- KAŽDÁ MOŽNOST ODPOVĚDI MÁ MAXIMÁLNĚ 25 ZNAKŮ (včetně mezer) - buď stručná a jasná"""
    try:
        response_text, usage = send_prompt(prompt)
        questions, _ = _parse_millionaire_response(response_text, usage, "actor_millionaire_hard")
        return questions
    except Exception as e:
        xbmc.log(f"[plugin.video.milionar] Error generating actor_millionaire_hard: {e}", xbmc.LOGERROR)
        return []

# === 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)
        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)
            })
        from wcs.ai.UsageTracker import track_ai_usage
        from wcs.ai.AIProvider import ai_provider
        track_ai_usage(ai_provider.get_current_provider(), ai_provider.get_current_model(), usage, "actor_quiz")
        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)
        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)
        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_millionaire_easy_questions(director_name: str, bio: str = "", known_for=None):
    """
    Generuje 3 snadné otázky o režisérovi pro hru Milionář - základní znalosti kariéry.
    Témata: Narození, nejslavnější filmy, základní ocenění, kariérní fakta.
    """
    known_for = known_for or []
    films_info = "\nZnámé filmy: " + ", ".join(known_for[:10]) if known_for else ""
    bio_info = f"\n\nŽivotopis: {bio[:500]}" if bio else ""

    difficulty_header = get_millionaire_difficulty_header()
    difficulty_instruction = get_millionaire_difficulty_instruction()
    moderator_block = _get_moderator_prompt_block(include_welcome=True, media_context="režisérovi", level_label="SNADNÁ")
    prompt = f"""{difficulty_header}Jsi expert na filmové kvízy. Vytvoř přesně 3 SNADNÉ otázky pro kvíz typu "Chcete být milionářem" o režisérovi {director_name}.{bio_info}{films_info}

OBTÍŽNOST: SNADNÁ - "Základní znalosti kariéry"
TÉMATA: Narození, nejslavnější filmy, základní ocenění, kariérní fakta
CÍLOVÁ SKUPINA: Každý fanoušek filmů pozná

{difficulty_instruction}

PŘÍKLADY TÉMAT:
- Kdy se režisér narodil?
- Jaký je jeho nejslavnější film?
- Za jaký film získal Oscar?
- V jakém roce debutoval?
- Jaké je jeho rodné město?
- Který film ho proslavil?
- Jaké má základní vzdělání?

{moderator_block}
DŮLEŽITÉ:
- Přesně 3 otázky
- Každá otázka má 4 možnosti (A, B, C, D)
- Správná odpověď jako písmeno (A, B, C nebo D)
- Otázky musí být JEDNODUCHÉ pro běžného fanouška
- Zaměř se POUZE na základní fakta a nejslavnější díla
- KAŽDÁ MOŽNOST ODPOVĚDI MÁ MAXIMÁLNĚ 25 ZNAKŮ (včetně mezer) - buď stručná a jasná"""
    try:
        response_text, usage = send_prompt(prompt)
        questions, moderator_welcome = _parse_millionaire_response(response_text, usage, "director_millionaire_easy")
        return questions, moderator_welcome
    except Exception as e:
        xbmc.log(f"[plugin.video.milionar] Error generating director_millionaire_easy: {e}", xbmc.LOGERROR)
        return [], None

def generate_director_millionaire_medium_questions(director_name: str, bio: str = "", known_for=None):
    """
    Generuje 3 střední otázky o režisérovi - pozornost k detailům kariéry.
    Témata: Konkrétní filmy, spolupráce, technika, méně známá díla.
    """
    known_for = known_for or []
    films_info = "\nZnámé filmy: " + ", ".join(known_for[:10]) if known_for else ""
    bio_info = f"\n\nŽivotopis: {bio[:500]}" if bio else ""

    difficulty_header = get_millionaire_difficulty_header()
    difficulty_instruction = get_millionaire_difficulty_instruction()
    moderator_block = _get_moderator_prompt_block(include_welcome=False, level_label="STŘEDNÍ")
    prompt = f"""{difficulty_header}Jsi expert na filmové kvízy. Vytvoř přesně 3 STŘEDNÍ otázky pro kvíz typu "Chcete být milionářem" o režisérovi {director_name}.{bio_info}{films_info}

OBTÍŽNOST: STŘEDNÍ - "Pozornost k detailům kariéry"
TÉMATA: Konkrétní filmy, spolupráce s herci, technika natáčení, méně známá díla
CÍLOVÁ SKUPINA: Pozorný fanoušek si všimne

{difficulty_instruction}

PŘÍKLADY TÉMAT:
- Jakou techniku použil v [konkrétním filmu]?
- S jakým hercem spolupracoval nejčastěji?
- Jaký je jeho charakteristický styl?
- V kterém roce natočil [film]?
- Jaké má vzdělání v režii?
- S jakým kameramanem spolupracoval?
- Jaký žánr preferuje?

{moderator_block}
DŮLEŽITÉ:
- Přesně 3 otázky
- Každá otázka má 4 možnosti (A, B, C, D)
- Správná odpověď jako písmeno (A, B, C nebo D)
- Otázky musí být STŘEDNÍ obtížnosti
- Zaměř se na DETAILY kariéry a spolupráce
- Vyžadují lepší znalost režiséra, ne jen základní fakta
- KAŽDÁ MOŽNOST ODPOVĚDI MÁ MAXIMÁLNĚ 25 ZNAKŮ (včetně mezer) - buď stručná a jasná"""
    try:
        response_text, usage = send_prompt(prompt)
        questions, _ = _parse_millionaire_response(response_text, usage, "director_millionaire_medium")
        return questions
    except Exception as e:
        xbmc.log(f"[plugin.video.milionar] Error generating director_millionaire_medium: {e}", xbmc.LOGERROR)
        return []

def generate_director_millionaire_hard_questions(director_name: str, bio: str = "", known_for=None):
    """
    Generuje 3 těžké otázky o režisérovi - režisérská erudice.
    Témata: Detailní trivia, specifická ocenění, méně známé projekty, historické souvislosti.
    """
    known_for = known_for or []
    films_info = "\nZnámé filmy: " + ", ".join(known_for[:10]) if known_for else ""
    bio_info = f"\n\nŽivotopis: {bio[:500]}" if bio else ""

    difficulty_header = get_millionaire_difficulty_header()
    difficulty_instruction = get_millionaire_difficulty_instruction()
    moderator_block = _get_moderator_prompt_block(include_welcome=False, level_label="TĚŽKÁ")
    prompt = f"""{difficulty_header}Jsi filmový historik. Vytvoř přesně 3 TĚŽKÉ otázky pro kvíz typu "Chcete být milionářem" o režisérovi {director_name}.{bio_info}{films_info}

OBTÍŽNOST: TĚŽKÁ - "Režisérská erudice"
TÉMATA: Detailní trivia, specifická ocenění, méně známé projekty, historické souvislosti
CÍLOVÁ SKUPINA: Skutečný znalec režiséra pozná

{difficulty_instruction}

PŘÍKLADY TÉMAT:
- Za jaký film byl nominován na [konkrétní rok]?
- V kterém divadle režíroval?
- Jaké má konkrétní ocenění z [festival]?
- V jakém roce debutoval v televizi?
- Jaké má vzdělání v režii?
- Který méně známý film produkoval?
- Jaké má konkrétní hobby nebo zájmy?
- V kterém roce získal [konkrétní cenu]?

{moderator_block}
DŮLEŽITÉ:
- Přesně 3 otázky
- Každá otázka má 4 možnosti (A, B, C, D)
- Správná odpověď jako písmeno (A, B, C nebo D)
- Otázky musí být TĚŽKÉ - pro skutečné znalce
- Zaměř se na DETAILNÍ TRIVIA a méně známé fakta
- Kombinace znalosti režiséra + filmové kultury
- KAŽDÁ MOŽNOST ODPOVĚDI MÁ MAXIMÁLNĚ 25 ZNAKŮ (včetně mezer) - buď stručná a jasná"""
    try:
        response_text, usage = send_prompt(prompt)
        questions, _ = _parse_millionaire_response(response_text, usage, "director_millionaire_hard")
        return questions
    except Exception as e:
        xbmc.log(f"[plugin.video.milionar] Error generating director_millionaire_hard: {e}", xbmc.LOGERROR)
        return []

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)
        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)
            })
        from wcs.ai.UsageTracker import track_ai_usage
        from wcs.ai.AIProvider import ai_provider
        track_ai_usage(ai_provider.get_current_provider(), ai_provider.get_current_model(), usage, "director_quiz")
        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)
        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)
        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_millionaire_easy_questions(creator_name: str, bio: str = "", known_for=None):
    """
    Generuje 3 snadné otázky o tvůrci seriálů pro hru Milionář - základní znalosti kariéry.
    Témata: Narození, nejslavnější seriály, základní ocenění, kariérní fakta.
    """
    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: {bio[:500]}" if bio else ""

    difficulty_header = get_millionaire_difficulty_header()
    difficulty_instruction = get_millionaire_difficulty_instruction()
    moderator_block = _get_moderator_prompt_block(include_welcome=True, media_context="tvůrci", level_label="SNADNÁ")
    prompt = f"""{difficulty_header}Jsi expert na seriálové kvízy. Vytvoř přesně 3 SNADNÉ otázky pro kvíz typu "Chcete být milionářem" o tvůrci seriálů {creator_name}.{bio_info}{shows_info}

OBTÍŽNOST: SNADNÁ - "Základní znalosti kariéry"
TÉMATA: Narození, nejslavnější seriály, základní ocenění, kariérní fakta
CÍLOVÁ SKUPINA: Každý fanoušek seriálů pozná

{difficulty_instruction}

PŘÍKLADY TÉMAT:
- Kdy se tvůrce narodil?
- Jaký je jeho nejslavnější seriál?
- Za jaký seriál získal ocenění?
- V jakém roce debutoval?
- Jaké je jeho rodné město?
- Který seriál ho proslavil?
- Jaké má základní vzdělání?

{moderator_block}
DŮLEŽITÉ:
- Přesně 3 otázky
- Každá otázka má 4 možnosti (A, B, C, D)
- Správná odpověď jako písmeno (A, B, C nebo D)
- Otázky musí být JEDNODUCHÉ pro běžného fanouška
- Zaměř se POUZE na základní fakta a nejslavnější díla
- KAŽDÁ MOŽNOST ODPOVĚDI MÁ MAXIMÁLNĚ 25 ZNAKŮ (včetně mezer) - buď stručná a jasná"""
    try:
        response_text, usage = send_prompt(prompt)
        questions, moderator_welcome = _parse_millionaire_response(response_text, usage, "creator_millionaire_easy")
        return questions, moderator_welcome
    except Exception as e:
        xbmc.log(f"[plugin.video.milionar] Error generating creator_millionaire_easy: {e}", xbmc.LOGERROR)
        return [], None

def generate_creator_millionaire_medium_questions(creator_name: str, bio: str = "", known_for=None):
    """
    Generuje 3 střední otázky o tvůrci seriálů - pozornost k detailům kariéry.
    Témata: Konkrétní seriály, spolupráce, technika, méně známá díla.
    """
    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: {bio[:500]}" if bio else ""

    difficulty_header = get_millionaire_difficulty_header()
    difficulty_instruction = get_millionaire_difficulty_instruction()
    moderator_block = _get_moderator_prompt_block(include_welcome=False, level_label="STŘEDNÍ")
    prompt = f"""{difficulty_header}Jsi expert na seriálové kvízy. Vytvoř přesně 3 STŘEDNÍ otázky pro kvíz typu "Chcete být milionářem" o tvůrci seriálů {creator_name}.{bio_info}{shows_info}

OBTÍŽNOST: STŘEDNÍ - "Pozornost k detailům kariéry"
TÉMATA: Konkrétní seriály, spolupráce s herci a režiséry, technika tvorby, méně známá díla
CÍLOVÁ SKUPINA: Pozorný fanoušek si všimne

{difficulty_instruction}

PŘÍKLADY TÉMAT:
- Jakou techniku použil v [konkrétním seriálu]?
- S jakým hercem spolupracoval nejčastěji?
- Jaký je jeho charakteristický styl?
- V kterém roce vytvořil [seriál]?
- Jaké má vzdělání v tvorbě?
- S jakým režisérem spolupracoval?
- Jaký žánr preferuje?

{moderator_block}
DŮLEŽITÉ:
- Přesně 3 otázky
- Každá otázka má 4 možnosti (A, B, C, D)
- Správná odpověď jako písmeno (A, B, C nebo D)
- Otázky musí být STŘEDNÍ obtížnosti
- Zaměř se na DETAILY kariéry a spolupráce
- Vyžadují lepší znalost tvůrce, ne jen základní fakta
- KAŽDÁ MOŽNOST ODPOVĚDI MÁ MAXIMÁLNĚ 25 ZNAKŮ (včetně mezer) - buď stručná a jasná"""
    try:
        response_text, usage = send_prompt(prompt)
        questions, _ = _parse_millionaire_response(response_text, usage, "creator_millionaire_medium")
        return questions
    except Exception as e:
        xbmc.log(f"[plugin.video.milionar] Error generating creator_millionaire_medium: {e}", xbmc.LOGERROR)
        return []

def generate_creator_millionaire_hard_questions(creator_name: str, bio: str = "", known_for=None):
    """
    Generuje 3 těžké otázky o tvůrci seriálů - tvůrčí erudice.
    Témata: Detailní trivia, specifická ocenění, méně známé projekty, historické souvislosti.
    """
    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: {bio[:500]}" if bio else ""

    difficulty_header = get_millionaire_difficulty_header()
    difficulty_instruction = get_millionaire_difficulty_instruction()
    moderator_block = _get_moderator_prompt_block(include_welcome=False, level_label="TĚŽKÁ")
    prompt = f"""{difficulty_header}Jsi televizní historik. Vytvoř přesně 3 TĚŽKÉ otázky pro kvíz typu "Chcete být milionářem" o tvůrci seriálů {creator_name}.{bio_info}{shows_info}

OBTÍŽNOST: TĚŽKÁ - "Tvůrčí erudice"
TÉMATA: Detailní trivia, specifická ocenění, méně známé projekty, historické souvislosti
CÍLOVÁ SKUPINA: Skutečný znalec tvůrce pozná

{difficulty_instruction}

PŘÍKLADY TÉMAT:
- Za jaký seriál byl nominován na [konkrétní rok]?
- V kterém divadle působil?
- Jaké má konkrétní ocenění z [festival]?
- V jakém roce debutoval v televizi?
- Jaké má vzdělání v tvorbě?
- Který méně známý projekt vytvořil?
- Jaké má konkrétní hobby nebo zájmy?
- V kterém roce získal [konkrétní cenu]?

{moderator_block}
DŮLEŽITÉ:
- Přesně 3 otázky
- Každá otázka má 4 možnosti (A, B, C, D)
- Správná odpověď jako písmeno (A, B, C nebo D)
- Otázky musí být TĚŽKÉ - pro skutečné znalce
- Zaměř se na DETAILNÍ TRIVIA a méně známé fakta
- Kombinace znalosti tvůrce + televizní kultury
- KAŽDÁ MOŽNOST ODPOVĚDI MÁ MAXIMÁLNĚ 25 ZNAKŮ (včetně mezer) - buď stručná a jasná"""
    try:
        response_text, usage = send_prompt(prompt)
        questions, _ = _parse_millionaire_response(response_text, usage, "creator_millionaire_hard")
        return questions
    except Exception as e:
        xbmc.log(f"[plugin.video.milionar] Error generating creator_millionaire_hard: {e}", xbmc.LOGERROR)
        return []

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)
        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)
            })
        from wcs.ai.UsageTracker import track_ai_usage
        from wcs.ai.AIProvider import ai_provider
        track_ai_usage(ai_provider.get_current_provider(), ai_provider.get_current_model(), usage, "creator_quiz")
        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)
        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)
        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

def get_millionaire_difficulty_header():
    """
    Vrací text hlavní obtížnosti podle nastavení addonu.
    Tento text se přidá na začátek promptů pro milionář hru.
    """
    addon = xbmcaddon.Addon()
    difficulty_setting = addon.getSetting("millionaire_difficulty")
    
    # Mapování hodnot na obtížnost (0=snadná, 1=střední, 2=těžká)
    if difficulty_setting == "0":  # Snadná
        return "HLAVNÍ OBTÍŽNOST: SNADNÁ - Formuluj otázky jednoduše z obecně známých informací. Vyhýbej se detailům a insider faktům. Možnosti odpovědí musí být zřetelně odlišitelné.\n\n"
    elif difficulty_setting == "2":  # Těžká
        return "HLAVNÍ OBTÍŽNOST: TĚŽKÁ - Opírej otázky o hlubší znalosti a přesné kontexty. Využívej odbornější pojmy, pokud jsou relevantní. Možnosti odpovědí musí být velmi věrohodné a pečlivě odlišitelné až po důkladném uvážení.\n\n"
    else:  # Střední (default) nebo "1"
        return "HLAVNÍ OBTÍŽNOST: STŘEDNÍ - Pracuj s mírnou mírou detailu nad mainstream. Můžeš použít méně známé souvislosti, ale zachovej srozumitelnost. Možnosti odpovědí musí být věrohodné, nikoli zavádějící.\n\n"

def get_millionaire_difficulty_instruction():
    """
    Vrací doplňující instrukci podle nastavení obtížnosti.
    Tato instrukce se vkládá doprostřed promptů.
    """
    addon = xbmcaddon.Addon()
    difficulty_setting = addon.getSetting("millionaire_difficulty")
    
    # Mapování hodnot na obtížnost (0=snadná, 1=střední, 2=těžká)
    if difficulty_setting == "0":  # Snadná
        return "DOPLŇUJÍCÍ INSTRUKCE: Uplatni hlavní obtížnost v duchu základů bez detailů."
    elif difficulty_setting == "2":  # Těžká
        return "DOPLŇUJÍCÍ INSTRUKCE: Uplatni hlavní obtížnost s důrazem na hlubší znalosti a věrohodné distraktory."
    else:  # Střední (default) nebo "1"
        return "DOPLŇUJÍCÍ INSTRUKCE: Uplatni hlavní obtížnost s mírným navýšením detailu, zároveň zachovej srozumitelnost."

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

def generate_writer_millionaire_easy_questions(writer_name: str, bio: str = "", known_for=None):
    """
    Generuje 3 snadné otázky o scénáristovi pro hru Milionář - základní znalosti kariéry.
    Témata: Narození, nejslavnější filmy, základní ocenění, kariérní fakta.
    """
    known_for = known_for or []
    movies_info = "\nZnámé filmy: " + ", ".join(known_for[:10]) if known_for else ""
    bio_info = f"\n\nŽivotopis: {bio[:500]}" if bio else ""

    difficulty_header = get_millionaire_difficulty_header()
    difficulty_instruction = get_millionaire_difficulty_instruction()
    moderator_block = _get_moderator_prompt_block(include_welcome=True, media_context="scenáristovi", level_label="SNADNÁ")
    prompt = f"""{difficulty_header}Jsi expert na filmové kvízy. Vytvoř přesně 3 SNADNÉ otázky pro kvíz typu "Chcete být milionářem" o scénáristovi {writer_name}.{bio_info}{movies_info}

OBTÍŽNOST: SNADNÁ - "Základní znalosti kariéry"
TÉMATA: Narození, nejslavnější filmy, základní ocenění, kariérní fakta
CÍLOVÁ SKUPINA: Každý fanoušek filmů pozná

{difficulty_instruction}

PŘÍKLADY TÉMAT:
- Kdy se scénárista narodil?
- Jaký je jeho nejslavnější film?
- Za jaký film získal ocenění?
- V jakém roce debutoval?
- Jaké je jeho rodné město?
- Který film ho proslavil?
- Jaké má základní vzdělání?

{moderator_block}
DŮLEŽITÉ:
- Přesně 3 otázky
- Každá otázka má 4 možnosti (A, B, C, D)
- Správná odpověď jako písmeno (A, B, C nebo D)
- Otázky musí být JEDNODUCHÉ pro běžného fanouška
- Zaměř se POUZE na základní fakta a nejslavnější díla
- KAŽDÁ MOŽNOST ODPOVĚDI MÁ MAXIMÁLNĚ 25 ZNAKŮ (včetně mezer) - buď stručná a jasná"""
    try:
        response_text, usage = send_prompt(prompt)
        questions, moderator_welcome = _parse_millionaire_response(response_text, usage, "writer_millionaire_easy")
        return questions, moderator_welcome
    except Exception as e:
        xbmc.log(f"[plugin.video.milionar] Error generating writer_millionaire_easy: {e}", xbmc.LOGERROR)
        return [], None

def generate_writer_millionaire_medium_questions(writer_name: str, bio: str = "", known_for=None):
    """
    Generuje 3 střední otázky o scénáristovi - pozornost k detailům kariéry.
    Témata: Konkrétní filmy, spolupráce, technika psaní, méně známá díla.
    """
    known_for = known_for or []
    movies_info = "\nZnámé filmy: " + ", ".join(known_for[:10]) if known_for else ""
    bio_info = f"\n\nŽivotopis: {bio[:500]}" if bio else ""

    difficulty_header = get_millionaire_difficulty_header()
    difficulty_instruction = get_millionaire_difficulty_instruction()
    moderator_block = _get_moderator_prompt_block(include_welcome=False, level_label="STŘEDNÍ")
    prompt = f"""{difficulty_header}Jsi expert na filmové kvízy. Vytvoř přesně 3 STŘEDNÍ otázky pro kvíz typu "Chcete být milionářem" o scénáristovi {writer_name}.{bio_info}{movies_info}

OBTÍŽNOST: STŘEDNÍ - "Pozornost k detailům kariéry"
TÉMATA: Konkrétní filmy, spolupráce s režiséry a herci, technika psaní, méně známá díla
CÍLOVÁ SKUPINA: Pozorný fanoušek si všimne

{difficulty_instruction}

PŘÍKLADY TÉMAT:
- Jakou techniku psaní použil v [konkrétním filmu]?
- S jakým režisérem spolupracoval nejčastěji?
- Jaký je jeho charakteristický styl?
- V kterém roce napsal [film]?
- Jaké má vzdělání v psaní?
- S jakým hercem spolupracoval?
- Jaký žánr preferuje?

{moderator_block}
DŮLEŽITÉ:
- Přesně 3 otázky
- Každá otázka má 4 možnosti (A, B, C, D)
- Správná odpověď jako písmeno (A, B, C nebo D)
- Otázky musí být STŘEDNÍ obtížnosti
- Zaměř se na DETAILY kariéry a spolupráce
- Vyžadují lepší znalost scénáristy, ne jen základní fakta
- KAŽDÁ MOŽNOST ODPOVĚDI MÁ MAXIMÁLNĚ 25 ZNAKŮ (včetně mezer) - buď stručná a jasná"""
    try:
        response_text, usage = send_prompt(prompt)
        questions, _ = _parse_millionaire_response(response_text, usage, "writer_millionaire_medium")
        return questions
    except Exception as e:
        xbmc.log(f"[plugin.video.milionar] Error generating writer_millionaire_medium: {e}", xbmc.LOGERROR)
        return []

def generate_writer_millionaire_hard_questions(writer_name: str, bio: str = "", known_for=None):
    """
    Generuje 3 těžké otázky o scénáristovi - scénáristická erudice.
    Témata: Detailní trivia, specifická ocenění, méně známé projekty, historické souvislosti.
    """
    known_for = known_for or []
    movies_info = "\nZnámé filmy: " + ", ".join(known_for[:10]) if known_for else ""
    bio_info = f"\n\nŽivotopis: {bio[:500]}" if bio else ""

    difficulty_header = get_millionaire_difficulty_header()
    difficulty_instruction = get_millionaire_difficulty_instruction()
    moderator_block = _get_moderator_prompt_block(include_welcome=False, level_label="TĚŽKÁ")
    prompt = f"""{difficulty_header}Jsi filmový historik. Vytvoř přesně 3 TĚŽKÉ otázky pro kvíz typu "Chcete být milionářem" o scénáristovi {writer_name}.{bio_info}{movies_info}

OBTÍŽNOST: TĚŽKÁ - "Scénáristická erudice"
TÉMATA: Detailní trivia, specifická ocenění, méně známé projekty, historické souvislosti
CÍLOVÁ SKUPINA: Skutečný znalec scénáristy pozná

{difficulty_instruction}

PŘÍKLADY TÉMAT:
- Za jaký film byl nominován na [konkrétní rok]?
- V kterém divadle působil?
- Jaké má konkrétní ocenění z [festival]?
- V jakém roce debutoval v televizi?
- Jaké má vzdělání v psaní?
- Který méně známý projekt napsal?
- Jaké má konkrétní hobby nebo zájmy?
- V kterém roce získal [konkrétní cenu]?

{moderator_block}
DŮLEŽITÉ:
- Přesně 3 otázky
- Každá otázka má 4 možnosti (A, B, C, D)
- Správná odpověď jako písmeno (A, B, C nebo D)
- Otázky musí být TĚŽKÉ - pro skutečné znalce
- Zaměř se na DETAILNÍ TRIVIA a méně známé fakta
- Kombinace znalosti scénáristy + filmové kultury
- KAŽDÁ MOŽNOST ODPOVĚDI MÁ MAXIMÁLNĚ 25 ZNAKŮ (včetně mezer) - buď stručná a jasná"""
    try:
        response_text, usage = send_prompt(prompt)
        questions, _ = _parse_millionaire_response(response_text, usage, "writer_millionaire_hard")
        return questions
    except Exception as e:
        xbmc.log(f"[plugin.video.milionar] Error generating writer_millionaire_hard: {e}", xbmc.LOGERROR)
        return []

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)
        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)
            })
        from wcs.ai.UsageTracker import track_ai_usage
        from wcs.ai.AIProvider import ai_provider
        track_ai_usage(ai_provider.get_current_provider(), ai_provider.get_current_model(), usage, "writer_quiz")
        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)
        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)
        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