# resources/lib/background_enrich.py (UPRAVENÝ KÓD)
# Zajišťuje, že ADDON_ID souhlasí s ADDON_ID v service.py

import xbmc
import xbmcgui
import time
import threading
import xbmcaddon
from requests.exceptions import HTTPError
import xbmcvfs
import os

from resources.lib.database.metadata_db import db
from resources.lib.tmdb.omdb import get_omdb_info, extract_metrics
from resources.lib.tmdb.tmdb_module import TMDb, API_URL
from resources.lib.utils.log_utils import get_logger

log = get_logger()

ADDON_ID = 'plugin.video.mmirousek_v3'
ADDON = xbmcaddon.Addon(ADDON_ID)

# === UTILITY FUNKCE PRO ČASOVÁNÍ (Stejná logika jako u Trakt) ===
def get_last_omdb_enrich_time() -> float:
    """Načte čas poslední OMDb synchronizace (Unix timestamp)."""
    try:
        ts = float(ADDON.getSetting('omdb_last_enrich_ts') or '0.0')
        return ts
    except Exception:
        return 0.0

def set_last_omdb_enrich_time():
    """Uloží aktuální Unix timestamp jako čas poslední OMDb synchronizace."""
    ADDON.setSetting('omdb_last_enrich_ts', str(time.time()))

def get_last_tmdb_audit_time() -> float:
    """Načte čas poslední TMDb audit synchronizace (Unix timestamp)."""
    try:
        return float(ADDON.getSetting('tmdb_audit_last_ts') or '0.0')
    except Exception:
        return 0.0

def set_last_tmdb_audit_time():
    """Uloží aktuální Unix timestamp jako čas posledního TMDb auditu."""
    ADDON.setSetting('tmdb_audit_last_ts', str(time.time()))
# ================================================================

# Lock zabraňující spuštění více instancí TMDb auditu současně
_tmdb_audit_lock = threading.Lock()

def background_enrich_omdb_ratings():
    """
    Hlavní funkce pro spouštění doplňování OMDb ratingů.
    Používá DialogProgressBG.
    """
    
    # Pauza zůstává kvůli respektování limitů OMDb API.
    
    log.info("Background OMDb enrich: STARTING PROCESS")

    try:
        rows = db.conn.execute("""
            SELECT tmdb_id, imdb_id FROM media 
            WHERE imdb_id IS NOT NULL AND imdb_id != ''
              AND (imdb_rating IS NULL OR imdb_rating = '' OR imdb_rating = 0)
              AND (cz_unavailable IS NULL OR cz_unavailable = 0)
            LIMIT 400
        """).fetchall()

        if not rows:
            log.info("Background enrich: nic k doplnění")
            return

        total = len(rows)
        progress = xbmcgui.DialogProgressBG()
        progress.create("Aktualizace OMDb hodnocení", f"Doplňuji OMDb ratingy... ({total})")

        for idx, (tmdb_id, imdb_id) in enumerate(rows):
            progress.update(int((idx+1)/total*100), message=f"{idx+1}/{total}")
            
            try:
                data = get_omdb_info(imdb_id=imdb_id, timeout=10)
                if data:
                    m = extract_metrics(data)
                    db.update(tmdb_id, {
                        'media_type': 'movie',
                        'imdb_rating': m.get('imdbRating'),
                        'imdb_votes': m.get('imdbVotes'),
                        'metascore': m.get('Metascore'),
                        'rt_rating': m.get('RottenTomatoes'),
                        'box_office': m.get('BoxOffice')
                    }, source='bg_omdb')
                else:
                    # Pokud OMDb nic nevrátilo (např. Incorrect IMDb ID), 
                    # označíme jako cz_unavailable, aby se nezkoušelo pořád dokola
                    log.info(f"Background OMDb enrich: Nenalezeno na OMDb -> tmdb_id={tmdb_id}, imdb_id={imdb_id}")
                    db.update(tmdb_id, {'cz_unavailable': 1}, source='bg_omdb_notfound')
            except Exception as e:
                log.warning(f"Chyba pro {imdb_id}: {e}")
                
            xbmc.sleep(1200) # Pauza 1.2 sekundy mezi API voláními
            
        progress.close()
        log.info("Background OMDb enrich: FINISHED")

    except Exception as e:
        log.error(f"Background enrich FATAL ERROR: {e}")

def background_enrich_tmdb_titles():
    """Doplňuje chybějící české názvy, přehledy a imdb_id z TMDb, voláno před OMDb enrichem."""

    tmdb_api_key = ADDON.getSetting('tmdb_api_key')
    if not tmdb_api_key:
        log.warning("Background TMDb Title Enrich: Chybí TMDb API klíč")
        return

    tmdb_client = TMDb(tmdb_api_key)
    log.info("Background TMDb Title Enrich: STARTING PROCESS")

    try:
        # Záznamy kde chybí title_cs NEBO chybí imdb_id, a nejsou označené jako nedostupné
        rows = db.conn.execute("""
            SELECT tmdb_id, media_type, imdb_id, trakt_full_data, cz_unavailable FROM media
            WHERE (cz_unavailable IS NULL OR cz_unavailable = 0)
              AND (
                  (title_cs IS NULL OR title_cs = '') OR
                  (imdb_id IS NULL OR imdb_id = '')
              )
            LIMIT 500
        """).fetchall()

        if not rows:
            log.info("Background TMDb Title Enrich: nic k doplnění")
            return

        total = len(rows)
        progress = xbmcgui.DialogProgressBG()
        progress.create("Aktualizace TMDb metadat", f"Doplňuji TMDb data... ({total})")

        for idx, (tmdb_id, media_type, imdb_id, trakt_full_data_str, cz_unavailable) in enumerate(rows):

            progress.update(int((idx+1)/total*100), message=f"{idx+1}/{total}")

            update_data = {}

            try:
                # --- Krok 1: imdb_id z trakt_full_data (bez API volání) ---
                if not imdb_id:
                    try:
                        if trakt_full_data_str:
                            import json as _json
                            trakt_data = _json.loads(trakt_full_data_str)
                            # trakt_full_data může mít různé obaly podle toho odkud pochází
                            ids = (trakt_data.get('ids')
                                   or trakt_data.get('movie', {}).get('ids')
                                   or trakt_data.get('show', {}).get('ids')
                                   or {})
                            found_imdb = ids.get('imdb')
                            if found_imdb:
                                imdb_id = found_imdb
                                update_data['imdb_id'] = found_imdb
                                log.debug(f"imdb_id z trakt_full_data: tmdb={tmdb_id} → {found_imdb}")
                    except Exception as _e:
                        log.debug(f"Nelze parsovat trakt_full_data pro {tmdb_id}: {_e}")

                # --- Krok 2: imdb_id z TMDb /external_ids (fallback, pokud stále chybí) ---
                if not imdb_id:
                    try:
                        ext_url = API_URL + f"/{media_type}/{tmdb_id}/external_ids"
                        resp_ext = tmdb_client._call_api_raw(ext_url, {})
                        if resp_ext:
                            ext_data = resp_ext.json()
                            found_imdb = ext_data.get('imdb_id')
                            if found_imdb:
                                imdb_id = found_imdb
                                update_data['imdb_id'] = found_imdb
                                log.debug(f"imdb_id z TMDb external_ids: tmdb={tmdb_id} → {found_imdb}")
                    except HTTPError as e:
                        if e.response is not None and e.response.status_code == 404:
                            log.info(f"Background Title Enrich: 404 Not Found (ext_ids) -> tmdb_id={tmdb_id}")
                            db.update(tmdb_id, {'media_type': media_type, 'cz_unavailable': 1}, source='bg_tmdb_title_404')
                            continue
                        log.warning(f"Chyba external_ids pro {tmdb_id}: {e}")
                    except Exception as _e:
                        log.warning(f"Chyba external_ids pro {tmdb_id}: {_e}")
                    xbmc.sleep(300)  # throttle pro external_ids call

                # --- Krok 3: title_cs / overview_cs z TMDb (přeskočí pokud je cz_unavailable) ---
                if not cz_unavailable:
                    try:
                        url_path = f"/{media_type}/{tmdb_id}"
                        response = tmdb_client._call_api_raw(API_URL + url_path, {'language': 'cs-CZ'})
                        details_cs = response.json()

                        title_cs = details_cs.get('title') or details_cs.get('name')
                        overview_cs = details_cs.get('overview')

                        if title_cs and title_cs.strip():
                            update_data['title_cs'] = title_cs
                        if overview_cs:
                            update_data['overview_cs'] = overview_cs
                        
                        # Pokud API odpovědělo, ale CZ data v něm nejsou, označíme jako cz_unavailable
                        if not title_cs:
                            update_data['cz_unavailable'] = 1
                            log.info(f"Background Title Enrich: Titul nemá CZ data -> tmdb_id={tmdb_id}")
                            
                    except HTTPError as e:
                        if e.response is not None and e.response.status_code == 404:
                            log.info(f"Background Title Enrich: 404 Not Found (detail) -> tmdb_id={tmdb_id}")
                            db.update(tmdb_id, {'media_type': media_type, 'cz_unavailable': 1}, source='bg_tmdb_title_404')
                            continue
                        log.warning(f"Chyba title_cs pro {tmdb_id}: {e}")
                    except Exception as _e:
                        log.warning(f"Chyba title_cs pro {tmdb_id}: {_e}")

                # --- Zápis do DB (jen pokud máme co zapsat) ---
                if update_data:
                    update_data['media_type'] = media_type
                    db.update(tmdb_id, update_data, source='bg_tmdb_title')

            except Exception as e:
                log.warning(f"Chyba pro {tmdb_id}: {e}")

            xbmc.sleep(500)  # pauza mezi záznamy

        progress.close()
        log.info("Background TMDb Title Enrich: FINISHED")

    except Exception as e:
        log.error(f"Background TMDb Title Enrich FATAL ERROR: {e}")




def background_audit_fill_tmdb_metadata_worker(full_mode=False):
    """
    Projde celou DB (tabulka 'media') a:
      - validuje title_cs/title_en na latinku (odstraní KO/ZH apod. 'čtverečky'),
      - doplní/napraví title_cs (z TMDb 'language=cs-CZ') pokud chybí nebo je ne-latinkou,
      - doplní/napraví title_en (z TMDb 'language=en-US') pokud chybí nebo je ne-latinkou,
      - doplní overview_cs/overview_en, year, poster_path, backdrop_path (jen pokud chybí),
      - zapisuje pouze změněná pole (minimální UPDATE),
            - v auto režimu si pamatuje neúspěšně doplnitelné položky přes tmdb_audit_skip,
      - průběžně zobrazuje pozadí progress a commituje po dávkách.

        Args:
                full_mode (bool):
                        False = standardní/automatický audit (respektuje cz_unavailable + tmdb_audit_skip),
                        True = kompletní audit (ignoruje cz_unavailable + tmdb_audit_skip).
    """
    import time

    mode_name = "FULL" if full_mode else "AUTO"
    LOG_PFX = f"[TMDb AUDIT {mode_name}]"
    log.info(f"{LOG_PFX} START")

    # --- helper: latinka (shodná logika jako v show_tmdb_discover_list) ---
    def is_latinish(s: str) -> bool:
        if not s:
            return False
        total_letters = 0
        latin_letters = 0
        strong_nonlatin = 0
        for ch in s:
            code = ord(ch)
            is_latin = (0x0041 <= code <= 0x005A) or (0x0061 <= code <= 0x007A) or \
                       (0x00C0 <= code <= 0x00FF) or (0x0100 <= code <= 0x024F)
            is_hangul = (0xAC00 <= code <= 0xD7AF) or (0x1100 <= code <= 0x11FF) or (0x3130 <= code <= 0x318F)
            is_cjk    = (0x4E00 <= code <= 0x9FFF) or (0x3400 <= code <= 0x4DBF)
            is_kata   = (0x30A0 <= code <= 0x30FF)
            is_hira   = (0x3040 <= code <= 0x309F)
            is_cyr    = (0x0400 <= code <= 0x04FF)
            is_arab   = (0x0600 <= code <= 0x06FF)
            if ch.isalpha():
                total_letters += 1
                if is_latin:
                    latin_letters += 1
                if is_hangul or is_cjk or is_kata or is_hira or is_cyr or is_arab:
                    strong_nonlatin += 1
        if total_letters == 0:
            return False
        if strong_nonlatin > 0:
            return False
        return (latin_letters / float(total_letters)) >= 0.70

    # --- API key + klient ---
    tmdb_api_key = ADDON.getSetting('tmdb_api_key')
    if not tmdb_api_key:
        log.warning(f"Chybí TMDb API klíč – audit zrušen.")
        return
    tmdb_client = TMDb(tmdb_api_key)

    # --- načti celou DB (jen movie/tv) ---
    try:
        if full_mode:
            # Full audit: projede vše bez ohledu na skip flagy.
            rows = db.conn.execute("""
                SELECT tmdb_id, media_type, title_cs, title_en, title_original,
                       overview_cs, overview_en, year, poster_path, backdrop_path,
                       cz_unavailable, tmdb_audit_skip
                FROM media
                WHERE tmdb_id IS NOT NULL
                  AND media_type IN ('movie','tv')
                ORDER BY tmdb_id
            """).fetchall()
        else:
            # Auto audit: jen kandidáti, kteří mají něco chybějícího a nejsou označení ke skipu.
            rows = db.conn.execute("""
                SELECT tmdb_id, media_type, title_cs, title_en, title_original,
                       overview_cs, overview_en, year, poster_path, backdrop_path,
                       cz_unavailable, tmdb_audit_skip
                FROM media
                WHERE tmdb_id IS NOT NULL
                  AND media_type IN ('movie','tv')
                  AND (cz_unavailable IS NULL OR cz_unavailable = 0)
                  AND (tmdb_audit_skip IS NULL OR tmdb_audit_skip = 0)
                  AND (
                      title_cs IS NULL OR title_cs = '' OR
                      title_en IS NULL OR title_en = '' OR
                      year IS NULL OR year = 0 OR
                      poster_path IS NULL OR poster_path = '' OR
                      backdrop_path IS NULL OR backdrop_path = ''
                  )
                ORDER BY tmdb_id
                LIMIT 1000
            """).fetchall()
    except Exception as e:
        log.error(f"DB SELECT FATAL: {e}")
        return

    total = len(rows or [])
    if total == 0:
        log.info(f"Nic k auditování.")
        return

    progress = xbmcgui.DialogProgressBG()
    progress.create("TMDb Audit metadat", f"Audit & doplnění TMDb metadat… ({total})")

    changed_count = 0
    batch = 0

    def _fetch_detail(media_type: str, tmdb_id: int, lang: str):
        """
        Bezpečné volání TMDb detailu s daným jazykem ('cs-CZ' / 'en-US').
        Vrátí (data_dict, is_404, call_ok). Throttle ~350 ms per call.
        """
        try:
            url_path = f"/{media_type}/{tmdb_id}"
            resp = tmdb_client._call_api_raw(API_URL + url_path, {'language': lang})
            data = resp.json() if resp is not None else {}
            return (data if isinstance(data, dict) else {}), False, True
        except HTTPError as e:
            if e.response is not None and e.response.status_code == 404:
                return {}, True, True
            log.warning(f"TMDb detail HTTP FAIL tmdb_id={tmdb_id} lang={lang}: {e}")
            return {}, False, False
        except Exception as e:
            log.warning(f"TMDb detail FAIL tmdb_id={tmdb_id} lang={lang}: {e}")
            return {}, False, False
        finally:
            xbmc.sleep(350)  # jemné škrcení API

    def _year_from(detail: dict, media_type: str, fallback_year: int) -> int:
        try:
            if media_type == 'movie':
                ds = (detail.get('release_date') or '')[:4]
            else:
                ds = (detail.get('first_air_date') or '')[:4]
            if ds.isdigit():
                return int(ds)
        except Exception:
            pass
        # zachovej původní
        try:
            return int(fallback_year) if fallback_year not in (None, '', 0, '0') else 0
        except Exception:
            return 0

    for idx, (tmdb_id, media_type, title_cs, title_en, title_original,
              overview_cs, overview_en, year, poster_path, backdrop_path,
              cz_unavailable, tmdb_audit_skip) in enumerate(rows, start=1):
        try:
            progress.update(int(idx / float(total) * 100), message=f"{idx}/{total}")

            # --- co je potřeba doplnit/napravit? ---
            # cz_unavailable=1 → přeskočíme CZ pole, TMDb CZ data prokazatelně chybí
            ignore_cz_flag = bool(full_mode)
            need_fix_title_cs = (ignore_cz_flag or not cz_unavailable) and ((not title_cs) or (isinstance(title_cs, str) and not is_latinish(title_cs)))
            need_fix_title_en = (not title_en) or (isinstance(title_en, str) and not is_latinish(title_en))
            need_overview_cs  = (ignore_cz_flag or not cz_unavailable) and not overview_cs
            need_overview_en  = not overview_en
            need_year         = (year in (None, '', 0, '0'))
            need_poster       = not poster_path
            need_backdrop     = not backdrop_path

            # Když není co řešit, běž dál
            if not (need_fix_title_cs or need_fix_title_en or need_overview_cs or need_overview_en
                    or need_year or need_poster or need_backdrop):
                continue

            # stáhni jen to, co je potřeba
            cz_fetch_attempted = bool(need_fix_title_cs or need_overview_cs)
            detail_cs, cz_is_404, cz_call_ok = _fetch_detail(media_type, tmdb_id, 'cs-CZ') if cz_fetch_attempted else ({}, False, False)
            
            # Pokud je 404, znamená to, že titul na TMDb už neexistuje (smazán/sloučen)
            if cz_is_404:
                log.info(f"{LOG_PFX} TMDb 404 (Not Found) -> tmdb_id={tmdb_id} (media_type={media_type})")
                db.update(tmdb_id, {'media_type': media_type, 'cz_unavailable': 1}, source='bg_tmdb_audit_404')
                changed_count += 1
                continue

            cz_api_succeeded = cz_fetch_attempted and cz_call_ok
            en_fetch_attempted = bool(need_fix_title_en or need_overview_en or need_year or need_poster or need_backdrop)
            detail_en, en_is_404, en_call_ok = _fetch_detail(media_type, tmdb_id, 'en-US') if en_fetch_attempted else ({}, False, False)

            if en_is_404:
                log.info(f"{LOG_PFX} TMDb 404 (Not Found) -> tmdb_id={tmdb_id} (media_type={media_type})")
                db.update(tmdb_id, {'media_type': media_type, 'cz_unavailable': 1}, source='bg_tmdb_audit_404')
                changed_count += 1
                continue

            # --- pole z detailů (bezpečně podle typu) ---
            def _pick_title(d: dict) -> str:
                return (d.get('title') or d.get('name') or '').strip()

            new_title_cs = _pick_title(detail_cs) if detail_cs else None
            new_title_en = _pick_title(detail_en) if detail_en else None

            # validace latinky (title_cs nesmí být KO/ZH apod.)
            if new_title_cs and not is_latinish(new_title_cs):
                new_title_cs = None
            if new_title_en and not is_latinish(new_title_en):
                new_title_en = None

            # overview
            new_overview_cs = (detail_cs.get('overview') or '').strip() if detail_cs else None
            new_overview_en = (detail_en.get('overview') or '').strip() if detail_en else None

            # artwork (stejné v obou jazycích – vezmeme cokoliv, co přijde k dispozici)
            # preferuj EN detail (často kompletnější), jinak CZ
            def _pick_val(*vals):
                for v in vals:
                    if v:
                        return v
                return None

            d_art = detail_en if detail_en else detail_cs
            new_poster = _pick_val(d_art.get('poster_path') if d_art else None)
            new_backdrop = _pick_val(d_art.get('backdrop_path') if d_art else None)

            # year
            d_year_src = detail_en if detail_en else detail_cs
            new_year = _year_from(d_year_src, media_type, year) if (need_year and (detail_en or detail_cs)) else None

            # --- sestav změny (pouze co dává smysl a co se má měnit) ---
            update_data = {}

            # title_cs: oprav pouze, když chybí/neplatný → pokud máme validní nový CZ title
            if need_fix_title_cs and new_title_cs:
                update_data['title_cs'] = new_title_cs

            # title_en: oprav pouze, když chybí/neplatný → pokud máme validní nový EN title
            if need_fix_title_en and new_title_en:
                update_data['title_en'] = new_title_en

            # overviews – jen doplň chybějící
            if need_overview_cs and new_overview_cs:
                update_data['overview_cs'] = new_overview_cs
            if need_overview_en and new_overview_en:
                update_data['overview_en'] = new_overview_en

            # year – jen doplň
            if need_year and isinstance(new_year, int) and new_year > 0:
                update_data['year'] = new_year

            # artwork – jen doplň
            if need_poster and new_poster:
                update_data['poster_path'] = new_poster
            if need_backdrop and new_backdrop:
                update_data['backdrop_path'] = new_backdrop

            # --- cz_unavailable flag: označení záznamů kde TMDb CZ data skutečně neexistují ---
            # Nastaví se jen pokud API odpovědělo úspěšně (ne při síťové chybě)
            cz_data_obtained = 'title_cs' in update_data or 'overview_cs' in update_data
            if cz_api_succeeded and not cz_data_obtained:
                update_data['cz_unavailable'] = 1
                log.info(f"{LOG_PFX} cz_unavailable=1 → tmdb_id={tmdb_id} (TMDb nemá CZ data)")
            elif cz_data_obtained and cz_unavailable:
                update_data['cz_unavailable'] = 0  # CZ data se na TMDb mezitím objevila → reset flagu
                log.debug(f"{LOG_PFX} cz_unavailable reset → tmdb_id={tmdb_id}")

            # Při úspěšném doplnění vždy resetni auto-skip flag.
            if update_data and tmdb_audit_skip:
                update_data['tmdb_audit_skip'] = 0

            # Pokud jsme nic nevymysleli, v AUTO režimu položku označíme ke skipu,
            # ale jen pokud skutečně proběhlo alespoň jedno API volání bez chyby.
            if not update_data:
                if not full_mode:
                    had_successful_call = (
                        (cz_fetch_attempted and cz_call_ok)
                        or (en_fetch_attempted and en_call_ok)
                    )
                    if had_successful_call:
                        try:
                            db.update(
                                tmdb_id,
                                {'media_type': media_type, 'tmdb_audit_skip': 1},
                                source='bg_tmdb_audit_skip'
                            )
                            batch += 1
                        except Exception as e:
                            log.warning(f"DB UPDATE skip-flag error tmdb_id={tmdb_id}: {e}")
                continue

            # nezapomeň uložit media_type (pro jistotu, pokud by řádek vznikl starou migrací)
            if media_type in ('movie', 'tv') and 'media_type' not in update_data:
                update_data['media_type'] = media_type

            # zápis
            try:
                db.update(tmdb_id, update_data, source='bg_tmdb_audit')
                changed_count += 1
                batch += 1
            except Exception as e:
                log.warning(f"DB UPDATE error tmdb_id={tmdb_id}: {e}")

            # dávkový commit (omez růst WAL + viditelnost pro ostatní vlákna)
            if batch >= 50:
                try:
                    db.conn.commit()
                except Exception as e:
                    log.error(f"COMMIT error: {e}")
                finally:
                    batch = 0

        except Exception as e:
            log.error(f"LOOP item fail tmdb_id={tmdb_id}: {e}")
            continue

    # finální commit + progress close
    try:
        db.conn.commit()
    except Exception as e:
        log.error(f"Final COMMIT error: {e}")

    try:
        progress.close()
    except Exception:
        pass

    log.info(f"{LOG_PFX} FINISHED • changed={changed_count} / scanned={total}")
    xbmcgui.Dialog().notification(
        "TMDb audit",
        f"{mode_name}: změněno {changed_count} / prohlédnuto {total}",
        xbmcgui.NOTIFICATION_INFO,
        3500,
    )


def background_audit_fill_tmdb_metadata():
    """
    Veřejné API: spustí audit synchronně (manuální volání z menu).
    Používá lock, aby se zabránilo souběžnému běhu se schedulovaným vláknem.
    """
    if not _tmdb_audit_lock.acquire(blocking=False):
        log.info("[TMDb AUDIT] Audit již probíhá – přeskočeno (manuální volání)")
        xbmcgui.Dialog().notification("TMDb audit", "Audit již probíhá na pozadí.", xbmcgui.NOTIFICATION_WARNING, 2500)
        return
    try:
        background_audit_fill_tmdb_metadata_worker(full_mode=False)
    finally:
        _tmdb_audit_lock.release()


def background_audit_fill_tmdb_metadata_full():
    """
    Veřejné API: spustí kompletní audit synchronně (manuální volání z menu).
    Ignoruje auto-skip logiku i cz_unavailable filtr.
    """
    if not _tmdb_audit_lock.acquire(blocking=False):
        log.info("[TMDb AUDIT FULL] Audit již probíhá – přeskočeno (manuální volání)")
        xbmcgui.Dialog().notification("TMDb audit", "Audit již probíhá na pozadí.", xbmcgui.NOTIFICATION_WARNING, 2500)
        return
    try:
        background_audit_fill_tmdb_metadata_worker(full_mode=True)
    finally:
        _tmdb_audit_lock.release()


def start_tmdb_audit_thread():
    """
    Spustí TMDb audit v samostatném vlákně (volat z service.py).
    Pokud audit již běží, nové vlákno se nespustí.
    """
    if not _tmdb_audit_lock.acquire(blocking=False):
        log.info("[TMDb AUDIT] Vlákno již běží – scheduler přeskočen")
        return

    def _run():
        try:
            background_audit_fill_tmdb_metadata_worker(full_mode=False)
        except Exception as e:
            log.error(f"[TMDb AUDIT] Chyba ve vlákně: {e}")
        finally:
            _tmdb_audit_lock.release()

    t = threading.Thread(target=_run, daemon=True, name="TMDbAuditThread")
    t.start()
    log.info("[TMDb AUDIT] Vlákno spuštěno")


def check_and_show_news():
    """
    Zkontroluje, zda proběhla aktualizace doplňku, a pokud ano,
    zobrazí uživateli vyskakovací okno s obsahem souboru news.txt.
    """
    addon = xbmcaddon.Addon('plugin.video.mmirousek_v3')
    addon_name = addon.getAddonInfo('name')
    current_version = addon.getAddonInfo('version')
    
    # Získání cesty k profilu doplňku
    profile_path = xbmcvfs.translatePath(addon.getAddonInfo('profile'))
    
    if not xbmcvfs.exists(profile_path):
        xbmcvfs.mkdirs(profile_path)
        
    version_file = os.path.join(profile_path, 'last_version.txt')
    last_version = ""
    
    # Přečtení naposledy uložené verze
    if xbmcvfs.exists(version_file):
        with xbmcvfs.File(version_file, 'r') as f:
            last_version = f.read().strip()
            
    # Pokud se verze liší, zobrazíme novinky
    if current_version != last_version:
        addon_path = xbmcvfs.translatePath(addon.getAddonInfo('path'))
        news_path = os.path.join(addon_path, 'news.txt')
        
        news_text = f"Doplněk byl úspěšně aktualizován na verzi {current_version}.\n\n"
        
        if xbmcvfs.exists(news_path):
            with xbmcvfs.File(news_path, 'r') as f:
                news_text += f.read()
        else:
            news_text += "Žádné podrobnější informace o aktualizaci nejsou k dispozici."
            
        # Zobrazení okna
        xbmcgui.Dialog().textviewer(f"{addon_name} - Aktualizace", news_text)
        
        # Uložení nové verze pro příště
        with xbmcvfs.File(version_file, 'w') as f:
            f.write(current_version)

