# -*- coding: utf-8 -*-
import json
import xbmcaddon
import xbmcvfs
import os
import xbmc
import time
from resources.lib.tmdb import tmdb_utils
import xbmcgui
from resources.lib.utils.log_utils import get_logger

try:
    from urllib.parse import urlencode
except ImportError:
    from urllib import urlencode  # Py2 fallback

# --- KONSTANTY ---
ADDON_ID = 'plugin.video.mmirousek_v3'
PLUGIN_BASE = f"plugin://{ADDON_ID}"
# LOG_TAG removed, using logger

# Inicializace loggeru
logger = get_logger()

# Cesta k profilu doplňku (e.g., .../userdata/addon_data/plugin.video.mmirousek_v3/)
PROFILE_PATH = xbmcvfs.translatePath(xbmcaddon.Addon(ADDON_ID).getAddonInfo('profile'))
HISTORY_FILE = os.path.join(PROFILE_PATH, 'watch_history.json')


def set_video_info(li, info_labels: dict):
    """Lokální setter metadata přes InfoTagVideo (bez importu tmdb_kodi)."""
    if not isinstance(info_labels, dict):
        return
    try:
        tag = li.getVideoInfoTag()
    except Exception:
        return

    title = info_labels.get('title')
    originaltitle = info_labels.get('originaltitle')
    plot = info_labels.get('plot')
    year = info_labels.get('year')
    genre = info_labels.get('genre')
    rating = info_labels.get('rating')
    mediatype = info_labels.get('mediatype')
    playcount = info_labels.get('playcount')

    if title:
        tag.setTitle(str(title))
    if originaltitle:
        try:
            tag.setOriginalTitle(str(originaltitle))
        except Exception:
            pass
    if plot:
        tag.setPlot(str(plot))

    try:
        if isinstance(year, int):
            tag.setYear(year)
        elif isinstance(year, str) and year.isdigit():
            tag.setYear(int(year))
    except Exception:
        pass

    if genre:
        try:
            if isinstance(genre, str):
                tag.setGenres([g.strip() for g in genre.split(',') if g.strip()])
            elif isinstance(genre, (list, tuple)):
                tag.setGenres([str(g) for g in genre if g])
        except Exception:
            pass

    try:
        if rating is not None:
            tag.setRating(float(rating))
    except Exception:
        pass

    if isinstance(mediatype, str) and mediatype:
        try:
            tag.setMediaType(mediatype)
        except Exception:
            pass

    if playcount is not None:
        try:
            tag.setPlaycount(int(playcount))
        except Exception:
            pass


# ---------------------------------------------------------------------------
# FUNKCE PRO PRÁCI S DATABÁZÍ
# ---------------------------------------------------------------------------

def load_history():
    """Zpětná kompatibilita - vrací jen filmy pro starší scripty."""
    try:
        from resources.lib.database.metadata_db import db
        return {"filmy": db.get_local_history('movie', limit=200)}
    except Exception as e:
        logger.error(f'Chyba při načítání lokální DB historie: {e}')
        return {"filmy": []}

def store_history(data):
    """Zpětná kompatibilita - nic nedělá, DB se ukládá průběžně."""
    pass


# ---------------------------------------------------------------------------
# HLAVNÍ FUNKCE (Business Logic)
# ---------------------------------------------------------------------------

def store_item(item_data):
    """
    Uloží nebo aktualizuje položku v lokální SQLite historii.
    item_data by ideálně obsahovala: tmdb_id, progress, media_type, name, stream_url.
    """
    try:
        from resources.lib.database.metadata_db import db
        # Předáme item_data rovnou do db, která řeší deduplikaci podle tmdb_id nebo URL.
        db.add_local_history(item_data)
        logger.debug(f'Historie úspěšně uložena do SQLite: {item_data.get("name")}')
    except Exception as e:
        logger.error(f'Chyba při ukládání do DB: {e}')


# 💡 NOVÁ FUNKCE pro načtení pro Kodi list
def get_list_items(media_type='movie', **kwargs):
    """
    Naposledy sledované – s pěknými daty z DB (cz_title, poster, rok, rating…).
    """
    items = []
    if media_type != 'movie':
        return items
    
    # 1. Načteme historii přímo z SQLite DB
    try:
        from resources.lib.database.metadata_db import db
        all_items = db.get_local_history('movie', limit=200)
    except Exception as e:
        logger.error(f"[get_list_items] Nelze dotázat DB: {e}")
        all_items = []
        db = None

    for idx, item in enumerate(all_items):
        tmdb_id = item.get('tmdb_id')
        if not tmdb_id or tmdb_id in ('0', 'None'):
            tmdb_id = None

        # ------------------------------------------------------------------
        # 2. Načteme data z DB (db.conn)
        # ------------------------------------------------------------------
        db_data = None
        title_cs = title_en = year = overview_cs = overview_en = None
        poster_path = backdrop_path = vote_average = genres_json = None

        if db and tmdb_id:
            try:
                cursor = db.conn.cursor()
                cursor.execute("""
                    SELECT title_cs, title_en, year, overview_cs, overview_en,
                           poster_path, backdrop_path, vote_average, genres
                    FROM media WHERE tmdb_id = ?
                """, (int(tmdb_id),))
                db_data = cursor.fetchone()
                cursor.close()
            except Exception as e:
                logger.warning(f"[get_list_items] DB error pro tmdb_id {tmdb_id}: {e}")

        if db_data:
            (title_cs, title_en, year, overview_cs, overview_en,
             poster_path, backdrop_path, vote_average, genres_json) = db_data

        # ------------------------------------------------------------------
        # 3. Fallback data
        # ------------------------------------------------------------------
        title = item.get('title') or item.get('name') or 'Neznámý film'
        if title_cs or title_en:
            title = title_cs or title_en or title

        if year is None:
            import re
            m = re.search(r'\b(19|20)\d{2}\b', title)
            if m:
                year = int(m.group(0))

        plot = overview_cs or overview_en or ""
        genres = ""
        if genres_json:
            try:
                genres = ", ".join(json.loads(genres_json))
            except:
                genres = genres_json

        # ------------------------------------------------------------------
        # 4. Label + status
        # ------------------------------------------------------------------
        status = add_status(item)
        label = title
        if year:
            label += f" ({year})"
        label += f" {status}"

        li = xbmcgui.ListItem(label=label)

        # ------------------------------------------------------------------
        # 5. Artwork
        # ------------------------------------------------------------------
        if poster_path:
            poster_url = f"https://image.tmdb.org/t/p/w500{poster_path}"
            li.setArt({
                'thumb': poster_url,
                'poster': poster_url,
                'icon': poster_url
            })
            if backdrop_path:
                li.setArt({'fanart': f"https://image.tmdb.org/t/p/original{backdrop_path}"})

        # ------------------------------------------------------------------
        # 6. InfoLabels
        # ------------------------------------------------------------------
        info_labels = {
            'title': title,
            'originaltitle': title_en or title,
            'plot': plot or "Položka z lokální historie.",
            'year': year,
            'genre': genres,
            'rating': float(vote_average) if vote_average else None,
            'mediatype': 'movie',
            'playcount': 1 if item.get('progress', 0) >= 90 else 0
        }
        info_labels = {k: v for k, v in info_labels.items() if v is not None}
        set_video_info(li, info_labels)

        # ------------------------------------------------------------------
        # 7. Tvoje kontextové menu – beze změny
        # ------------------------------------------------------------------
        from resources.lib.utils.context_builder import build_context_menu
        # Nechceme použít generickou get_url, jelikož local_history tady natvrdo skládá vlastní query s PLUGIN_BASE
        # Udělám wrapper funkci `local_get_url` speciálně pro tento případ.
        def local_get_url(**kwargs):
            return f"{PLUGIN_BASE}?{urlencode(kwargs, encoding='utf-8')}"

        item_data = {
            'tmdb_id': item.get('tmdb_id'),
            'media_type': 'movie',
            'index': idx
        }
        cm = build_context_menu(local_get_url, item_data, contexts=['local_history_item'])
        if cm:
            li.addContextMenuItems(cm, replaceItems=True)

        # ------------------------------------------------------------------
        # 8. Přehrávání – tvoje akce
        # ------------------------------------------------------------------
        play_qs = urlencode({
            'action': 'play_history_item',
            'url': item.get('stream_url', ''),
            'tmdb_id': item.get('tmdb_id'),
            'media_type': item.get('media_type'),
        }, encoding='utf-8')
        play_url = f"{PLUGIN_BASE}?{play_qs}"

        li.setProperty('IsPlayable', 'true')
        items.append((play_url, li, False))

    return items

# 💡 NOVÁ FUNKCE pro mazání
def remove_item(tmdb_id, media_type='movie'):
    """Odstraní film z historie podle ID."""
    try:
        from resources.lib.database.metadata_db import db
        db.remove_local_history(int(tmdb_id), 'movie')
        logger.info(f'Film {tmdb_id} smazán z historie.')
        return True
    except Exception as e:
        logger.error(f'Chyba při mazání položky z historie: {e}')
        return False

def get_single_item(tmdb_id, media_type='movie'):
    """Získá jednu položku z historie podle ID."""
    history = load_history()
    tmdb_id_str = str(tmdb_id)
    for item in history.get('filmy', []):
        if str(item.get('tmdb_id')) == tmdb_id_str:
            return item
    return None


# ===================================================================
# NOVÉ FUNKCE (pouze do local_history.py)
# ===================================================================
def add_status(item):
    """
    Vrátí status jako string: [ok] / [75%] / [Nový] + T OK / T ne / T —.

    Progress část plyne čistě z uloženého `progress`, Trakt část z `trakt_ok`:
        trakt_ok == 1    → T OK (Trakt STOP skutečně vrácen 201/409)
        trakt_ok == 0    → T ne (odesláno neproběhlo / Trakt vypnutý / <90 %)
        trakt_ok is None → T —  (úvodní zápis, nevyhodnoceno)
    """
    try:
        progress = float(item.get('progress', 0.0) or 0.0)
    except (TypeError, ValueError):
        progress = 0.0

    trakt_ok = item.get('trakt_ok')

    if progress >= 90.0:
        prog_status = u'[COLOR lime]ok[/COLOR]'
    elif progress > 5.0:
        prog_status = f'[{progress:.0f}%]'
    else:
        prog_status = '[Nový]'

    if trakt_ok == 1:
        trakt_status = '[COLOR lime]T OK[/COLOR]'
    elif trakt_ok == 0:
        trakt_status = '[COLOR red]T ne[/COLOR]'
    else:
        trakt_status = '[COLOR grey]T —[/COLOR]'

    return f"{prog_status} {trakt_status}"


def fix_and_scrobble_item(item_index, _media_type='movie'):
    """
    Opraví položku (film) v lokální historii (doplní TMDb ID, název, plakát, děj),
    uloží ji zpět a ihned ji odešle na Trakt jako zhlédnutou.
    """
    history = load_history()
    items = history.get('filmy', [])
    if item_index < 0 or item_index >= len(items):
        xbmcgui.Dialog().ok("Chyba", "Položka nenalezena.")
        return

    item = items[item_index]
    current_name = item.get('name', 'Neznámý název')

    # --- Zadání správného názvu od uživatele ---
    kb = xbmc.Keyboard(current_name, 'Opravit název pro TMDb')
    kb.doModal()
    if not kb.isConfirmed():
        return
    search_name = (kb.getText() or '').strip()
    if not search_name:
        xbmcgui.Dialog().ok("Chyba", "Název nesmí být prázdný.")
        return

    # --- Hledání na TMDb ---
    xbmc.executebuiltin('ActivateWindow(busydialognocancel)')
    try:
        result = tmdb_utils.search_tmdb_movie(search_name)
    finally:
        xbmc.executebuiltin('Dialog.Close(busydialognocancel)')

    if not result:
        xbmcgui.Dialog().ok("Chyba", f"Nenašel jsem na TMDb:\n{search_name}")
        return

    # --- Sestavení nové (opravené) položky ---
    fixed_item = {
        'tmdb_id': str(result['tmdb_id']),
        'name': result.get('title', search_name),
        'media_type': 'movie',
        'progress': item.get('progress', 0.0),
        'stream_url': item.get('stream_url', ''),  # pro přehrání z historie
        'poster_path': result.get('poster_path'),  # může být None (OK)
        'plot': result.get('overview', ''),        # může být prázdné
        'watched_at': item.get('watched_at', time.strftime('%Y-%m-%dT%H:%M:%S', time.localtime())),
    }

    # Film – čisté scrobble schema
    try:
        movie_tmdb_id = int(result['tmdb_id'])
    except Exception:
        movie_tmdb_id = int(fixed_item['tmdb_id']) if fixed_item['tmdb_id'].isdigit() else 0
        
    fixed_item['trakt_payload'] = {
        "movie": {"ids": {"tmdb": movie_tmdb_id}}
    }

    # --- Přepsání položky v historii ---
    try:
        del items[item_index]
        from resources.lib.database.metadata_db import db
        db.remove_local_history(int(item.get('tmdb_id', 0)), 'movie')
    except Exception as e:
        logger.warning(f'WARN: Nelze odstranit původní položku: {e}')

    store_item(fixed_item)  # idempotentní: ve store_item jsou ošetřené duplicity

    # --- Odeslání na Trakt jako "zhlédnuto" ---
    try:
        from resources.lib.trakt.trakt_bulk import mark_movie_watched
        mark_movie_watched(movie_tmdb_id)
    except Exception as e:
        logger.error(f'Odeslání na Trakt selhalo: {e}')
        xbmcgui.Dialog().ok(
            "Upozornění",
            "ID bylo opraveno a uloženo,\n"
            "ale odeslání na Trakt se nezdařilo.\n"
            "Zkontroluj autorizaci v Nastavení.",
        )

    # --- Obnovení UI ---
    xbmc.executebuiltin('Container.Refresh')
