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

log = get_logger()
ADDON_ID_V2 = "plugin.video.mmirousek_v2"
ADDON_ID_V3 = "plugin.video.mmirousek_v3"
PROFILE_V2 = xbmcvfs.translatePath(f"special://profile/addon_data/{ADDON_ID_V2}")
PROFILE_V3 = xbmcvfs.translatePath(f"special://profile/addon_data/{ADDON_ID_V3}")

def perform_migration_v2_to_v3():
    """
    Spustí se jen při prvním startu v3 (pokud 'v3_migration_done' není true).
    Ověří existenci starého profilu v2 a zeptá se uživatele na převod dat do v3.
    """
    addon = xbmcaddon.Addon(ADDON_ID_V3)
    
    if addon.getSetting('v3_migration_done') == 'true':
        return  # Migrace už byla nabídnuta nebo provedena

    if not (os.path.exists(PROFILE_V2) or xbmcvfs.exists(PROFILE_V2)):
        # Nikde není co migrovat, čistá instalace v3
        addon.setSetting('v3_migration_done', 'true')
        return

    # Pokud najdeme profil V2, nabídneme migraci
    dialog = xbmcgui.Dialog()
    answer = dialog.yesno(
        "Nová verze pluginu (v3)",
        "Byla nalezena data ze starší verze doplňku (v2).\n"
        "Chcete nyní přenést svou historii sledování, rozehrané seriály a cache,\n"
        "abyste navázali tam, kde jste skončili?",
        yeslabel="Ano, přenést data", nolabel="Ne, začít s čistým štítem"
    )

    if answer:
        _run_migration()
    else:
        log.info("[V3 Migration] Uživatel odmítl migraci dat.")
    
    # Uložíme si, že dotaz už proběhl
    addon.setSetting('v3_migration_done', 'true')


def _run_migration():
    """Fyzicky provede kopírování starých DB/JSON do nové struktury."""
    log.info("[V3 Migration] Spouštím migraci dat z v2 -> v3")
    
    if not xbmcvfs.exists(PROFILE_V3):
        xbmcvfs.mkdirs(PROFILE_V3)

    dialog = xbmcgui.DialogProgressBG()
    dialog.create("Migrace dat na verzi v3", "Kopírují se data, prosím čekejte...")

    try:
        dialog.update(10, message="Převod hlavní databáze")
        # 1. Zkopíruje metadata.db z V2 jako main.db do V3
        db_v2_path = os.path.join(PROFILE_V2, 'metadata.db')
        main_db_v3_path = os.path.join(PROFILE_V3, 'main.db')
        
        if os.path.exists(db_v2_path):
            shutil.copy2(db_v2_path, main_db_v3_path)
            log.info("[V3 Migration] metadata.db (v2) zkopírována jako main.db (v3)")
        
        dialog.update(40, message="Přenos historie a hledání")
        # 2. Převod watch_history.json a search_history.json přímo do SQLite main.db
        from resources.lib.database.metadata_db import db
        watch_json_v2 = os.path.join(PROFILE_V2, 'watch_history.json')
        if os.path.exists(watch_json_v2):
            try:
                with open(watch_json_v2, 'r', encoding='utf-8') as f:
                    history_data = json.load(f)
                
                # Filmy
                for item in reversed(history_data.get('filmy', [])):
                    item['media_type'] = 'movie'
                    if 'progress' not in item: item['progress'] = 100.0
                    db.add_local_history(item)
                
                # Seriály
                for item in reversed(history_data.get('serialy', [])):
                    item['media_type'] = 'episode'
                    if 'progress' not in item: item['progress'] = 100.0
                    db.add_local_history(item)
                    
                log.info("[V3 Migration] Historie sledování převedena z JSON do DB")
            except Exception as e:
                log.warning(f"[V3 Migration] Chyba při převodu watch_history: {e}")

        search_json_v2 = os.path.join(PROFILE_V2, 'search_history')
        if os.path.exists(search_json_v2):
            try:
                with open(search_json_v2, 'r', encoding='utf-8') as f:
                    search_data = json.load(f)
                if isinstance(search_data, list):
                    # Pro zachovani historicke posloupnosti iterujeme od konce a ukladame
                    for q in reversed(search_data):
                        db.save_search_query(q)
                log.info("[V3 Migration] Historie hledání převedena z JSON do DB")
            except Exception as e:
                log.warning(f"[V3 Migration] Chyba při převodu search_history: {e}")

        dialog.update(60, message="Přenos rozehraných seriálů")
        # 3. Import JSON seriálů (series_db) do SQLite main.db -> Fáze 3
        series_v2_dir = os.path.join(PROFILE_V2, 'series_db')
        if os.path.exists(series_v2_dir):
            try:
                success_count = 0
                for fname in os.listdir(series_v2_dir):
                    if not fname.endswith('.json'):
                        continue
                        
                    fpath = os.path.join(series_v2_dir, fname)
                    series_name = fname.replace('.json', '')
                    
                    try:
                        with open(fpath, 'r', encoding='utf-8') as f:
                            series_dict = json.load(f)
                            
                        # Ulozime do nove spolecne SQLite (tabulka series_data zavedena ve V10)
                        db.save_series_data(series_name, series_dict)
                        success_count += 1
                    except Exception as inn_e:
                        log.debug(f"[V3 Migration] Nelze nacist dilci serial {fname}: {inn_e}")
                        
                log.info(f"[V3 Migration] Přeneseno {success_count} seriálů ze series_db do DB.")
            except Exception as e:
                log.warning(f"[V3 Migration] Celkova chyba u prenosu series_db: {e}")

        dialog.update(80, message="Přenos Trakt/TMDb Cache")
        
        # 4. Migrace cache do SQLite (cache.db)
        cache_db_path = os.path.join(PROFILE_V3, 'cache.db')
        conn = sqlite3.connect(cache_db_path)
        conn.execute("PRAGMA journal_mode = WAL")
        conn.execute("PRAGMA synchronous = NORMAL")
        conn.execute("""
        CREATE TABLE IF NOT EXISTS api_cache (
            namespace TEXT,
            key_hash TEXT,
            ts INTEGER,
            ttl INTEGER,
            hdr TEXT,
            data TEXT,
            PRIMARY KEY (namespace, key_hash)
        )
        """)
        conn.commit()
        
        # 4a) Migrace starého tmdb_cache.json
        tmdb_json_v2 = os.path.join(PROFILE_V2, 'tmdb_cache.json')
        if os.path.exists(tmdb_json_v2):
            try:
                import hashlib, time
                with open(tmdb_json_v2, 'r', encoding='utf-8') as f:
                    old_tmdb = json.load(f)
                
                ts = int(time.time())
                ttl = 30 * 24 * 60 * 60  # 30 dni fake ttl pro migrovana data
                hdr_str = "{}"
                
                for k, v in old_tmdb.items():
                    key_hash = hashlib.md5(k.encode('utf-8')).hexdigest()
                    data_str = json.dumps(v, ensure_ascii=False)
                    conn.execute("""
                        INSERT OR IGNORE INTO api_cache (namespace, key_hash, ts, ttl, hdr, data)
                        VALUES (?, ?, ?, ?, ?, ?)
                    """, ('tmdb', key_hash, ts, ttl, hdr_str, data_str))
                conn.commit()
            except Exception as e:
                log.warning(f"[V3 Migration] Nepovedlo se zmigrovat tmdb_cache.json: {e}")
                
        # 4b) Migrace gz složek trakt_cache
        import gzip, hashlib, time
        trakt_cache_dir_v2 = os.path.join(PROFILE_V2, 'trakt_cache')
        if os.path.exists(trakt_cache_dir_v2):
            try:
                for fname in os.listdir(trakt_cache_dir_v2):
                    if not fname.endswith('.json.gz'):
                        continue
                        
                    gz_path = os.path.join(trakt_cache_dir_v2, fname)
                    key_hash = fname.replace('.json.gz', '')
                    
                    try:
                        with gzip.open(gz_path, 'rt', encoding='utf-8') as gf:
                            obj = json.load(gf)
                            
                        ts = obj.get('ts', int(time.time()))
                        ttl = obj.get('ttl', 3600)
                        hdr_str = json.dumps(obj.get('hdr', {}), ensure_ascii=False)
                        data_str = json.dumps(obj.get('data'), ensure_ascii=False)
                        
                        conn.execute("""
                            INSERT OR IGNORE INTO api_cache (namespace, key_hash, ts, ttl, hdr, data)
                            VALUES (?, ?, ?, ?, ?, ?)
                        """, ('trakt', key_hash, ts, ttl, hdr_str, data_str))
                    except Exception as inn_e:
                        log.debug(f"[V3 Migration] Chyba cteni {fname}: {inn_e}")
                
                conn.commit()
            except Exception as e:
                log.warning(f"[V3 Migration] Nepovedlo se zmigrovat trakt_cache: {e}")
                
        conn.close()

        # 5. Migrace playlist_index.json
        dialog.update(90, message="Přenos IPTV/Lokálního Playlist Indexu")
        playlist_idx_v2 = os.path.join(PROFILE_V2, 'playlist_index.json')
        if os.path.exists(playlist_idx_v2):
            try:
                with open(playlist_idx_v2, 'r', encoding='utf-8') as f:
                    pl_data = json.load(f)
                
                meta = pl_data.get('meta', {})
                items = pl_data.get('items', [])
                
                db.save_playlist_meta(meta)
                db.save_playlist_items(items)
                log.info(f"[V3 Migration] Přenesen playlist_index.json (položek {len(items)}) do databáze.")
            except Exception as e:
                log.warning(f"[V3 Migration] Nelze převést playlist_index.json: {e}")

        dialog.update(100, message="Hotovo")
        xbmcgui.Dialog().notification("Migrace na v3", "Veškerá data úspěšně migrována!", xbmcgui.NOTIFICATION_INFO, 5000)
    except Exception as e:
        log.error(f"[V3 Migration] Chyba při migraci dat: {e}")
        xbmcgui.Dialog().notification("Chyba migrace", "Některá data se nezdařilo zkopírovat.", xbmcgui.NOTIFICATION_ERROR, 5000)
    finally:
        dialog.close()
