extto_web.py

#!/usr/bin/env python3
"""
EXTTO Web Interface v1.4 - FULL RESTORED (Original Features + Killswitch + Smart Search)
Backend Flask per la gestione via web di EXTTO
"""

from flask import Flask, render_template, jsonify, request, Response, stream_with_context
from flask_cors import CORS
import sqlite3
import os
import json
import re
import shutil
import time
import requests
import psutil
import socket
import threading  # <--- AGGIUNGI QUESTA RIGA QUI
from urllib.parse import unquote
from datetime import datetime
from typing import List, Dict, Optional, Tuple
from threading import Thread
import queue
# ... resto degli import
try:
    # Riusa parser/quality dell'engine per coerenza di riconoscimento
    from core.models import Parser, Quality
except Exception as e:
    print(f"⚠️  import core.models fallback: {e}")
    Parser = None
    Quality = None
import subprocess
import warnings

try:
    from core.models import Parser, Quality
    from core.constants import PORT as DEFAULT_ENGINE_PORT
    import core.config_db as _cdb
except Exception as e:
    print(f"⚠️  import core.constants fallback: {e}")
    Parser = None
    Quality = None
    DEFAULT_ENGINE_PORT = 8889

def get_engine_port():
    """Legge la porta del motore dal file di configurazione, con salvagente."""
    try:
        cfg = parse_series_config()
        return int(cfg.get('settings', {}).get('engine_port', DEFAULT_ENGINE_PORT))
    except Exception as e:
        logger.debug(f"get_engine_port: {e}")
        return DEFAULT_ENGINE_PORT

app = Flask(__name__)
CORS(app)

RENAME_PROGRESS = {"status": "idle", "current": 0, "total": 0, "msg": ""}
_rename_progress_lock = threading.Lock()
_config_write_lock = threading.Lock()  # Protegge operazioni read-modify-write sulla config

# Configurazione

# --- CONFIGURAZIONE PERCORSI ASSOLUTI ---
BASE_DIR     = os.path.dirname(os.path.abspath(__file__))
DB_FILE      = os.path.join(BASE_DIR, "extto_series.db")
ARCHIVE_FILE = os.path.join(BASE_DIR, "extto_archive.db")
CONFIG_FILE  = os.path.join(BASE_DIR, "extto.conf")
SERIES_FILE  = os.path.join(BASE_DIR, "series.txt")
MOVIES_FILE  = os.path.join(BASE_DIR, "movies.txt")
LOG_FILE     = os.path.join(BASE_DIR, "extto.log")
_LEGACY_FILE = os.path.join(BASE_DIR, "series_config.txt")
LANGUAGES_DIR = os.path.join(BASE_DIR, "languages")
POSTERS_DIR  = os.path.join(BASE_DIR, "static", "posters")

TMDB_IMAGE_BASE = "https://image.tmdb.org/t/p/w300"

def _poster_file(item_type: str, item_id: int) -> str:
    """Restituisce il path assoluto del file poster su disco."""
    prefix = {'series': 's', 'movie': 'm', 'comic': 'c'}.get(item_type, 'x')
    return os.path.join(POSTERS_DIR, f"{prefix}_{item_id}.jpg")

def _poster_url(item_type: str, item_id: int) -> str:
    """Restituisce l'URL relativo del poster da servire al browser."""
    prefix = {'series': 's', 'movie': 'm', 'comic': 'c'}.get(item_type, 'x')
    return f"/static/posters/{prefix}_{item_id}.jpg"

def _save_poster(item_type: str, item_id: int, tmdb_poster_path: str) -> bool:
    """Scarica e salva il poster da TMDB se non esiste già. Ritorna True se salvato."""
    if not tmdb_poster_path or not item_id:
        return False
    dest = _poster_file(item_type, item_id)
    if os.path.exists(dest):
        return True  # già presente, non riscaricare
    try:
        os.makedirs(POSTERS_DIR, exist_ok=True)
        url = f"{TMDB_IMAGE_BASE}{tmdb_poster_path}"
        resp = requests.get(url, timeout=10)
        if resp.status_code == 200 and resp.content:
            with open(dest, 'wb') as f:
                f.write(resp.content)
            logger.debug(f"🖼️ Poster salvato: {dest}")
            return True
    except Exception as e:
        logger.debug(f"_save_poster {item_type}/{item_id}: {e}")
    return False

def _delete_poster(item_type: str, item_id: int) -> None:
    """Elimina il poster dal disco quando si cancella la serie/film."""
    dest = _poster_file(item_type, item_id)
    try:
        if os.path.exists(dest):
            os.remove(dest)
            logger.debug(f"🗑️ Poster eliminato: {dest}")
    except Exception as e:
        logger.debug(f"_delete_poster {item_type}/{item_id}: {e}")

def _default_lang() -> str:
    """
    Restituisce la lingua audio di default per nuove serie/film.
    Legge 'default_language' dalla config DB.
    Se non impostata (stringa vuota o assente) restituisce '' = nessun filtro lingua.
    Configurabile dalla pagina Configurazione → Avanzate.
    """
    try:
        v = str(_cdb.get_setting('default_language', '')).strip().lower()
        return v if v else 'ita'
    except Exception:
        return 'ita'

BACKUP_DIR = "backups"

# Queue per log streaming
log_queue = queue.Queue()

# ============================================================================
# DATABASE UTILITIES
# ============================================================================

import threading
import logging

# ---------------------------------------------------------------------------
# LOGGING SETUP — configura root logger + propaga a tutti i sottomoduli
# (core.comics, core.models, ecc.) così i loro logger.info/error appaiono
# ---------------------------------------------------------------------------
_log_formatter = logging.Formatter(
    '[%(asctime)s] %(levelname)s %(name)s: %(message)s',
    datefmt='%H:%M:%S'
)
_root_logger = logging.getLogger()
if not _root_logger.handlers:
    # stderr — visibile in terminale/journalctl/supervisord
    _sh = logging.StreamHandler()
    _sh.setFormatter(_log_formatter)
    _root_logger.addHandler(_sh)
# File handler aggiunto separatamente (sempre, anche se c'erano già handler)
# WatchedFileHandler: rileva se il file viene rinominato (es. da logrotate o dall'altro
# processo) e riapre extto.log, evitando che i log finiscano nel file rinominato.
_log_file_path = os.path.join(os.path.dirname(os.path.abspath(__file__)), 'extto.log')
if not any(isinstance(h, logging.FileHandler) and getattr(h, 'baseFilename', '') == _log_file_path
           for h in _root_logger.handlers):
    try:
        from logging.handlers import WatchedFileHandler as _WFH
        _fh = _WFH(_log_file_path, encoding='utf-8')
        _fh.setFormatter(_log_formatter)
        _root_logger.addHandler(_fh)
    except Exception as e:
        print(f"⚠️  WatchedFileHandler setup: {e}")
        pass
# Assicura che tutti i logger figli (core.*) propaghino al root
logging.getLogger('core').setLevel(logging.DEBUG)
logging.getLogger('core').propagate = True
_root_logger.setLevel(logging.INFO)

logger = logging.getLogger(__name__)

class ExtToDB:
    """Gestione database EXTTO - thread-safe via threading.local()

    Ogni thread Flask ottiene la propria connessione SQLite, evitando
    la condivisione di una singola connessione tra thread multipli.
    WAL mode permette letture concorrenti senza bloccare le scritture.
    """

    _local = threading.local()

    def _get_conn(self):
        if not getattr(self._local, 'conn', None):
            if not os.path.exists(DB_FILE):
                self._local.conn = None
                return None
            # Fix Bolla Temporale: aggiunto isolation_level=None
            conn = sqlite3.connect(DB_FILE, check_same_thread=False, isolation_level=None)
            conn.row_factory = sqlite3.Row
            conn.execute("PRAGMA journal_mode=WAL")
            conn.execute("PRAGMA busy_timeout=5000")
            conn.execute("PRAGMA synchronous=NORMAL")
            self._local.conn = conn
        return self._local.conn

    def _get_conn_archive(self):
        """Restituisce la connessione archivio del thread corrente."""
        if not getattr(self._local, 'conn_archive', None):
            if not os.path.exists(ARCHIVE_FILE):
                self._local.conn_archive = None
                return None
            try:
                # Fix Bolla Temporale: aggiunto isolation_level=None
                conn = sqlite3.connect(ARCHIVE_FILE, check_same_thread=False, isolation_level=None)
                conn.row_factory = sqlite3.Row
                conn.execute("PRAGMA journal_mode=WAL")
                conn.execute("PRAGMA busy_timeout=5000")
                conn.execute("PRAGMA synchronous=NORMAL")
                def regexp(expr, item):
                    try:
                        return 1 if re.search(expr, str(item), re.IGNORECASE) else 0
                    except Exception:
                        return 0  # regex malformata, tratta come no-match
                conn.create_function("REGEXP", 2, regexp)
                self._local.conn_archive = conn
            except Exception as e:
                logger.debug(f"conn_archive REGEXP setup: {e}")
                logger.exception("Unable to open Archive DB")
                self._local.conn_archive = None
        return self._local.conn_archive

    @property
    def conn(self):
        return self._get_conn()

    @property
    def conn_archive(self):
        return self._get_conn_archive()

    def __init__(self):
        pass  # Connessione creata al primo uso per thread

    def connect(self):
        """Mantenuto per compatibilita', non fa nulla."""
        pass
    
    def get_stats(self) -> dict:
        """Statistiche generali"""
        if not self.conn:
            return {}
        
        c = self.conn.cursor()
        stats = {}
        
        c.execute("SELECT COUNT(*) FROM series")
        stats['series'] = c.fetchone()[0]
        
        c.execute("SELECT COUNT(*) FROM movies WHERE removed_at IS NULL")
        stats['movies'] = c.fetchone()[0]
        
        c.execute("SELECT COUNT(*) FROM episodes")
        stats['episodes'] = c.fetchone()[0]
        
        c.execute("SELECT COUNT(*) FROM movies WHERE magnet_link IS NOT NULL")
        stats['movie_downloads'] = c.fetchone()[0]
        
        stats['downloads'] = stats['episodes'] + stats['movie_downloads']
        
        # Ultima attività
        c.execute("""
            SELECT MAX(d) FROM (
                SELECT MAX(downloaded_at) as d FROM episodes
                UNION
                SELECT MAX(downloaded_at) as d FROM movies
            )
        """)
        last = c.fetchone()[0]
        stats['last_activity'] = last if last else "N/A"
        
        # Archivio
        if self.conn_archive:
            c_arch = self.conn_archive.cursor()
            c_arch.execute("SELECT COUNT(*) FROM archive")
            stats['archive_size'] = c_arch.fetchone()[0]
        else:
            stats['archive_size'] = 0
        
        return stats
    
    def get_all_series(self) -> List[dict]:
        """Lista di tutte le serie"""
        if not self.conn:
            return []
        
        c = self.conn.cursor()
        c.execute("""
            SELECT s.id, s.name, s.quality_requirement,
            COUNT(e.id) as episodes_count, 
            MAX(e.downloaded_at) as last_download,
            (SELECT season FROM episodes 
             WHERE series_id=s.id 
             ORDER BY downloaded_at DESC LIMIT 1) as last_season,
            (SELECT episode FROM episodes 
             WHERE series_id=s.id 
             ORDER BY downloaded_at DESC LIMIT 1) as last_episode
            FROM series s 
            LEFT JOIN episodes e ON s.id = e.series_id
            GROUP BY s.id 
            ORDER BY s.name COLLATE NOCASE
        """)
        return [dict(row) for row in c.fetchall()]
    
    def get_series_episodes(self, series_id: int) -> List[dict]:
        """Episodi di una serie"""
        if not self.conn:
            return []
        
        c = self.conn.cursor()
        c.execute(
            """
            SELECT e.id, e.season, e.episode, e.title, e.quality_score,
                   e.downloaded_at, e.is_repack, e.magnet_link,
                   CASE WHEN ap.series_id IS NOT NULL THEN 1 ELSE 0 END AS present_in_archive,
                   ap.best_quality_score AS archive_quality_score
            FROM episodes e
            LEFT JOIN episode_archive_presence ap
              ON ap.series_id = e.series_id
             AND ap.season = e.season
             AND ap.episode = e.episode
            WHERE e.series_id = ? AND e.episode > 0
            ORDER BY e.season DESC, e.episode DESC
            """,
            (series_id,)
        )
        return [dict(row) for row in c.fetchall()]
        
        
    
    def get_all_movies(self) -> List[dict]:
        """Lista di tutti i film scaricati/storico"""
        if not self.conn:
            return []
        
        try:
            c = self.conn.cursor()
            c.execute("""
                SELECT m.id, m.name, m.year, m.title,
                CASE WHEN m.magnet_link IS NOT NULL THEN 1 ELSE 0 END as downloaded, 
                m.downloaded_at, m.quality_score
                FROM movies m
                WHERE m.removed_at IS NULL
                ORDER BY m.downloaded_at DESC NULLS LAST, m.name COLLATE NOCASE
            """)
            return [dict(row) for row in c.fetchall()]
        except Exception as e:
            logger.error(f"Error reading movies table (old schema?): {e}")
            # Fallback in caso manchi la colonna magnet_link in vecchi DB
            try:
                c.execute("SELECT * FROM movies ORDER BY id DESC")
                return [dict(row) for row in c.fetchall()]
            except Exception as e:
                logger.debug(f"get_all_movies: {e}")
                return []
    
    def search_archive(self, query: str = "", offset: int = 0, limit: int = 50) -> Tuple[List[dict], int]:
        """Ricerca nell'archivio con supporto filtri avanzati (+/-)"""
        if not self.conn_archive:
            return [], 0
        
        c = self.conn_archive.cursor()
        conditions = []
        params = []
        
        if query:
            query = query.strip()
            
            # OPZIONE 1: Regex pura (se inizia con "rx:")
            if query.startswith("rx:"):
                conditions.append("title REGEXP ?")
                params.append(query[3:].strip())
            
            # OPZIONE 2: Ricerca "Smart" (+/- e Wildcards)
            else:
                keywords = query.split()
                for kw in keywords:
                    exclude = False
                    if kw.startswith('-') and len(kw) > 1:
                        exclude = True
                        kw = kw[1:]
                    elif kw.startswith('+') and len(kw) > 1:
                        kw = kw[1:]
                    
                    if '*' in kw or '?' in kw:
                        clean_kw = kw.replace('*', '%').replace('?', '_')
                        if exclude:
                            conditions.append("title NOT LIKE ?")
                        else:
                            conditions.append("title LIKE ?")
                        params.append(clean_kw)
                    else:
                        if exclude:
                            conditions.append("title NOT LIKE ?")
                        else:
                            conditions.append("title LIKE ?")
                        params.append(f"%{kw}%")
        
        where_clause = ("WHERE " + " AND ".join(conditions)) if conditions else ""
        
        try:
            # 1. Conta totale
            count_sql = f"SELECT COUNT(*) FROM archive {where_clause}"
            c.execute(count_sql, tuple(params))
            total = c.fetchone()[0]
            
            # 2. Prendi risultati paginati
            data_sql = f"""
                SELECT id, title, magnet, added_at 
                FROM archive 
                {where_clause}
                ORDER BY added_at DESC 
                LIMIT ? OFFSET ?
            """
            query_params = tuple(params) + (limit, offset)
            
            c.execute(data_sql, query_params)
            items = [dict(row) for row in c.fetchall()]
            
            return items, total
            
        except Exception as e:
            print(f"Errore ricerca archivio: {e}")
            return [], 0
    
    def delete_episode(self, episode_id: int):
        """Elimina un episodio"""
        if not self.conn:
            return
        c = self.conn.cursor()
        c.execute("DELETE FROM episodes WHERE id=?", (episode_id,))
        self.conn.commit()
    
    def delete_series(self, series_id: int):
        """Elimina una serie e tutti i suoi episodi"""
        if not self.conn:
            return
        c = self.conn.cursor()
        c.execute("DELETE FROM episodes WHERE series_id=?", (series_id,))
        c.execute("DELETE FROM series WHERE id=?", (series_id,))
        self.conn.commit()
    
    def delete_movie(self, movie_id: int):
        """Soft-delete: marca il film come rimosso senza cancellarlo fisicamente,
        così rimane visibile in Ultimi Download con il badge 'Rimosso dall'archivio'."""
        if not self.conn:
            return
        from datetime import datetime, timezone
        c = self.conn.cursor()
        c.execute("UPDATE movies SET removed_at=? WHERE id=?",
                  (datetime.now(timezone.utc).isoformat(), movie_id))
        self.conn.commit()

    def get_series_stats(self) -> dict:
        """Statistiche aggregate per serie: ep scaricati, ultimo episodio, is_ended, is_completed."""
        if not self.conn:
            return {}
        try:
            from core.database import Database
            with Database() as _db:
                return _db.get_series_stats()
        except Exception as e:
            logger.error(f"get_series_stats: {e}")
            return {}

    def record_feed_match(self, series_id: int, season: int, episode: int,
                          title: str, quality_score: int,
                          fail_reason, magnet: str):
        """Delega a core.database.Database.record_feed_match."""
        if not self.conn:
            return
        try:
            from core.database import Database as _CoreDB
            _CoreDB().record_feed_match(series_id, season, episode,
                                        title, quality_score, fail_reason, magnet)
        except Exception as e:
            logger.warning(f"ExtToDB.record_feed_match: {e}")

    def get_feed_matches(self, series_id: int, season: int, episode: int):
        """Delega a core.database.Database.get_feed_matches."""
        try:
            from core.database import Database as _CoreDB
            return _CoreDB().get_feed_matches(series_id, season, episode)
        except Exception as e:
            logger.warning(f"ExtToDB.get_feed_matches: {e}")
            return []

    def record_movie_feed_match(self, movie_id: int, title: str,
                                quality_score: int, lang_bonus: int,
                                fail_reason, magnet: str):
        """Delega a core.database.Database.record_movie_feed_match."""
        if not self.conn:
            return
        try:
            from core.database import Database as _CoreDB
            _CoreDB().record_movie_feed_match(movie_id, title, quality_score,
                                              lang_bonus, fail_reason, magnet)
        except Exception as e:
            logger.warning(f"ExtToDB.record_movie_feed_match: {e}")

    def get_movie_feed_matches(self, movie_name: str):
        """Delega a core.database.Database.get_movie_feed_matches."""
        try:
            from core.database import Database as _CoreDB
            return _CoreDB().get_movie_feed_matches(movie_name)
        except Exception as e:
            logger.warning(f"ExtToDB.get_movie_feed_matches: {e}")
            return []

    def has_movie_feed_matches(self, movie_name: str):
        """Delega a core.database.Database.has_movie_feed_matches."""
        try:
            from core.database import Database as _CoreDB
            return _CoreDB().has_movie_feed_matches(movie_name)
        except Exception as e:
            logger.warning(f"ExtToDB.has_movie_feed_matches: {e}")
            return False

db = ExtToDB()

# ============================================================================
# CONFIG MANAGEMENT
# ============================================================================

def parse_series_config() -> dict:
    """Legge la configurazione da extto_config.db e dalla tabella series del DB operativo.
    Mantiene l'interfaccia originale: restituisce {'settings': {...}, 'series': [...]}.
    """
    settings = _cdb.get_all_settings()
    series   = _load_series_from_db_web()
    return {'settings': settings, 'series': series}


def _load_series_from_db_web() -> list:
    """Carica le serie dalla tabella series del DB operativo."""
    import sqlite3 as _sq
    try:
        with _sq.connect(DB_FILE) as conn:
            conn.row_factory = _sq.Row
            rows = conn.execute(
                """SELECT name, quality_requirement, seasons, language, enabled,
                          archive_path, timeframe, aliases, ignored_seasons,
                          tmdb_id, subtitle, season_subfolders, exclude
                   FROM series ORDER BY name"""
            ).fetchall()
        result = []
        for r in rows:
            try:
                aliases = json.loads(r['aliases'] or '[]')
            except Exception:
                aliases = []
            try:
                ignored = json.loads(r['ignored_seasons'] or '[]')
            except Exception:
                ignored = []
            result.append({
                'name':              r['name'],
                'seasons':           r['seasons'] or '1+',
                'quality':           r['quality_requirement'] or 'any',
                'language':          r['language'] or _default_lang(),
                'enabled':           bool(r['enabled']) if r['enabled'] is not None else True,
                'archive_path':      r['archive_path'] or '',
                'timeframe':         int(r['timeframe'] or 0),
                'aliases':           aliases,
                'ignored_seasons':   ignored,
                'tmdb_id':           r['tmdb_id'] or '',
                'subtitle':          r['subtitle'] or '',
                'season_subfolders': bool(r['season_subfolders']) if r['season_subfolders'] is not None else False,
                'exclude':           r['exclude'] or '',
            })
        return result
    except Exception as e:
        logger.warning(f"_load_series_from_db_web: {e}")
        return []


def _save_series_to_db(series_list: list, sync_delete: bool = False) -> None:
    """Salva/aggiorna le serie nel DB operativo (tabella series).
    sync_delete=True: rimuove anche le serie non presenti nella lista.
                      Usare SOLO per operazioni di eliminazione esplicita.
    """
    import sqlite3 as _sq
    conn = _sq.connect(DB_FILE)
    conn.row_factory = _sq.Row
    try:
        for s in series_list:
            aliases_json = json.dumps(s.get('aliases', []), ensure_ascii=False)
            ignored_json = json.dumps(s.get('ignored_seasons', []), ensure_ascii=False)
            conn.execute(
                """INSERT INTO series
                       (name, quality_requirement, seasons, language, enabled,
                        archive_path, timeframe, aliases, ignored_seasons, tmdb_id, subtitle,
                        season_subfolders, exclude)
                   VALUES (?,?,?,?,?,?,?,?,?,?,?,?,?)
                   ON CONFLICT(name) DO UPDATE SET
                       quality_requirement = excluded.quality_requirement,
                       seasons             = excluded.seasons,
                       language            = excluded.language,
                       enabled             = excluded.enabled,
                       archive_path        = excluded.archive_path,
                       timeframe           = excluded.timeframe,
                       aliases             = excluded.aliases,
                       ignored_seasons     = excluded.ignored_seasons,
                       tmdb_id             = excluded.tmdb_id,
                       subtitle            = excluded.subtitle,
                       season_subfolders   = excluded.season_subfolders,
                       exclude             = excluded.exclude
                """,
                (
                    s['name'],
                    s.get('quality', s.get('qual', 'any')),
                    s.get('seasons', '1+'),
                    s.get('language', s.get('lang', 'ita')),
                    1 if s.get('enabled', True) else 0,
                    s.get('archive_path', ''),
                    int(s.get('timeframe', 0) or 0),
                    aliases_json,
                    ignored_json,
                    str(s.get('tmdb_id', '') or ''),
                    str(s.get('subtitle', '') or ''),
                    1 if s.get('season_subfolders', False) else 0,
                    str(s.get('exclude', '') or ''),
                )
            )
        # Rimuove le serie non più presenti (solo se sync_delete=True)
        if sync_delete and series_list:
            names_in_list = [s['name'] for s in series_list]
            placeholders  = ','.join('?' * len(names_in_list))
            conn.execute(
                f"DELETE FROM series WHERE name NOT IN ({placeholders})",
                names_in_list
            )
        conn.commit()
    finally:
        conn.close()


def _parse_series_line_into(line: str, series_list: list):
    """Parsa una riga serie e la appende a series_list."""
    parts = [p.strip() for p in line.split('|')]
    if len(parts) < 5:
        return
    item = {
        'name':     parts[0],
        'seasons':  parts[1],
        'quality':  parts[2],
        'language': parts[3],
        'enabled':  parts[4] == 'yes',
    }
    for ex in parts[5:]:
        ex = ex.strip()
        if not ex:
            continue
        if ex.startswith('timeframe:'):
            m = re.search(r'timeframe:(\d+)h', ex)
            if m:
                try:
                    item['timeframe'] = int(m.group(1))
                except Exception:
                    pass  # timeframe non numerico, ignorato
        elif ex.startswith('alias='):
            item['aliases'] = [a.strip() for a in ex.split('=', 1)[1].split(',') if a.strip()]
        elif ex.startswith('ignored:'):
            item['ignored_seasons'] = [
                int(x.strip()) for x in ex.split(':', 1)[1].split(',')
                if x.strip().isdigit()
            ]
        # AGGIUNGI QUESTE DUE RIGHE:
        elif ex.startswith('tmdb='):
            item['tmdb_id'] = ex.split('=', 1)[1].strip()
        elif ex.startswith('subtitle='):
            item['subtitle'] = ex.split('=', 1)[1].strip()
        # -------------------------
        elif 'archive_path' not in item:
            item['archive_path'] = ex
    series_list.append(item)


def save_series_config(config: dict) -> bool:
    """Salva la configurazione su extto_config.db e sulla tabella series del DB operativo.
    NON scrive più su extto.conf o series.txt (migrazione a DB completata in v40).
    """
    try:
        settings = config.get('settings', {})
        _cdb.set_settings_bulk(settings)
    except Exception as e:
        logger.error(f"save_series_config settings: {e}")
        return False
    try:
        _save_series_to_db(config.get('series', []))
    except Exception as e:
        logger.error(f"save_series_config series: {e}")
        return False
    return True


def _qbt_ok(r) -> bool:
    """Verifica che una risposta qBittorrent indichi successo.

    Compatibile con tutte le versioni:
    - qBittorrent < 5.2.0: HTTP 200 con body 'Ok.'
    - qBittorrent ≥ 5.2.0: HTTP 204 con body vuoto (WEBAPI: Send 204 when WebAPI
      response contains no data — introdotto in 5.2.0)
    """
    if r is None:
        return False
    if r.status_code == 204:
        return True
    if r.status_code == 200 and r.text.strip() in ('Ok.', 'Ok', ''):
        return True
    return False


def _atomic_write(path: str, content: str) -> None:
    """Scrive content su path in modo atomico tramite file temporaneo."""
    import tempfile
    dir_path = os.path.dirname(os.path.abspath(path))
    fd, tmp = tempfile.mkstemp(dir=dir_path, prefix='.extto_', suffix='.tmp')
    try:
        with os.fdopen(fd, 'w', encoding='utf-8') as f:
            f.write(content)
            f.flush()
            os.fsync(f.fileno())
        os.replace(tmp, path)
    except Exception as e:
        logger.warning(f"safe_save_config: {e}")
        try:
            os.unlink(tmp)
        except OSError:
            pass
        raise


def _save_extto_conf(config: dict) -> bool:
    """Scrive extto.conf con tutte le impostazioni (senza le serie)."""
    try:
        settings = config.get('settings', {})
        written_keys = set()
        lines = []

        lines.append("# " + "=" * 76)
        lines.append("# EXTTO - Configurazione")
        lines.append("# " + "=" * 76)
        lines.append("")

        groups = [
            ("CLIENT TORRENT: LIBTORRENT (EMBEDDED)", ["libtorrent_"]),
            ("CLIENT ESTERNI: QBITTORRENT, TRANSMISSION, ARIA2, RQBIT",
             ["qbittorrent_", "transmission_", "aria2_", "rqbit_"]),
            ("NOTIFICHE: TELEGRAM & EMAIL", ["notify_", "telegram_", "email_"]),
            ("NOTIFICHE: JELLYFIN, PLEX & EMBY", ["jellyfin_", "plex_", "emby_"]),
            ("MOTORE: JACKETT, RICERCA E AVANZATE",
             ["jackett_", "prowlarr_", "flaresolverr_", "websearch_", "min_free_space", "gap_filling", "max_age",
              "stop_on_", "debug_", "archive_", "rename_episodes", "rename_format", "move_episodes",
              "jackett_save_to_archive", "prowlarr_save_to_archive", "tmdb_language",
              "backup_dir", "backup_retention", "backup_schedule", "refresh_interval",
              "comics_", "web_port", "engine_port", "cleanup_upgrades", "trash_path", "cleanup_min_score_diff", "trash_retention_days"]),
              ("PUNTEGGI E QUALITÀ (SCORES)", ["score_", "auto_remove_completed"]), # <--- AGGIUNGI QUESTA RIGA
        ]

        for group_name, prefixes in groups:
            # Abbiamo rimosso 'and k in KNOWN_SETTINGS' per permettere il salvataggio
            # dinamico di opzioni nuove inviate dall'interfaccia web.
            keys_to_write = sorted(
                k for k, v in settings.items()
                if k not in written_keys
                and not isinstance(v, list)
                and any(k.startswith(p) for p in prefixes)
            )
            if keys_to_write:
                lines.append(f"# --- {group_name} ---")
                for k in keys_to_write:
                    lines.append(f"@{k} = {settings[k]}")
                lines.append("")
                written_keys.update(keys_to_write)

        # Qualsiasi altra opzione che non rientra nei prefissi precedenti finisce qui,
        # senza essere scartata, grazie alla rimozione di 'KNOWN_SETTINGS'
        leftover = sorted(
            k for k, v in settings.items()
            if k not in written_keys
            and not isinstance(v, list)
        )
        if leftover:
            lines.append("# --- ALTRE IMPOSTAZIONI ---")
            for k in leftover:
                lines.append(f"@{k} = {settings[k]}")
            lines.append("")

        lines.append("# " + "=" * 76)
        lines.append("# SORGENTI, REGOLE E CARTELLE RADICE")
        lines.append("# " + "=" * 76)

        list_keys = [
            ("archive_root", "Cartelle radice dell'archivio (opzionali)"),
            ("archive_cred", "Credenziali per montaggi remoti (PREFIX|user|pass)"),
            ("url",          "URL Sorgenti (ExtTo, Corsaro)"),
            ("blacklist",       "Parole vietate nei titoli (es: cam, ts)"),
            ("wantedlist",      "Parole obbligatorie nei titoli"),
            ("content_filter",  "Filtro categorie contenuti (es: xxx, anime, hentai)"),
            ("custom_score",    "Punteggi Personalizzati (Parola:Punti)"),
        ]
        for key, desc in list_keys:
            vals = settings.get(key, [])
            if isinstance(vals, list) and vals:
                lines.append(f"\n# {desc}")
                for item in vals:
                    lines.append(f"@{key} = {item}")

        lines.append("")
        # NON scrive più su file — configurazione migrata a extto_config.db (v40)
        # _atomic_write(CONFIG_FILE, "\n".join(lines) + "\n")
        return True
    except Exception as e:
        logger.error(f"Error saving extto.conf: {e}")
        return False


def _save_series_list(config: dict) -> bool:
    """Scrive series.txt con il solo elenco delle serie TV."""
    try:
        lines = []
        lines.append("# " + "=" * 76)
        lines.append("# EXTTO - Serie TV monitorate")
        lines.append("# Formato: Nome | Stagioni | Qualità | Lingua | Enabled"
                     " | Path (opzionale) | timeframe:Xh | alias=... | ignored:N,M | tmdb=ID | subtitle=SIGLA")
        lines.append("# " + "=" * 76)
        lines.append("")

        for serie in sorted(config.get('series', []), key=lambda s: s.get('name', '').lower()):
            enabled      = 'yes' if serie.get('enabled', True) else 'no'
            archive_path = serie.get('archive_path', '').strip()
            timeframe    = int(serie.get('timeframe', 0) or 0)
            aliases      = serie.get('aliases', [])
            ignored      = serie.get('ignored_seasons', [])

            line = (f"{serie['name']} | {serie['seasons']} | "
                    f"{serie['quality']} | {serie['language']} | {enabled}")
            if archive_path:
                line += f" | {archive_path}"
            if timeframe > 0:
                line += f" | timeframe:{timeframe}h"
            if aliases:
                line += f" | alias={','.join(aliases)}"
            if ignored:
                line += f" | ignored:{','.join(map(str, ignored))}"
            # AGGIUNGI QUESTE DUE RIGHE:
            if serie.get('tmdb_id'):
                line += f" | tmdb={serie['tmdb_id']}"
            if serie.get('subtitle'):
                line += f" | subtitle={serie['subtitle']}"
            # -------------------------
            lines.append(line)

        lines.append("")
        # NON scrive più su file — serie migrate a extto_series.db (v40)
        # _atomic_write(SERIES_FILE, "\n".join(lines) + "\n")

        # Sync aliases nel DB
        try:
            import sqlite3 as _sqlite3
            _conn = _sqlite3.connect(DB_FILE)
            _c2 = _conn.cursor()
            for serie in config.get('series', []):
                _aliases_json = json.dumps(serie.get('aliases', []), ensure_ascii=False)
                _c2.execute(
                    "UPDATE series SET aliases=? WHERE LOWER(name)=LOWER(?)",
                    (_aliases_json, serie['name'])
                )
            _conn.commit()
        except Exception as _e:
            logger.warning(f"Sync aliases DB: {_e}")
        finally:
            try: _conn.close()
            except Exception: pass

        return True
    except Exception as e:
        logger.error(f"Error saving series.txt: {e}")
        return False


def parse_movies_config() -> List[dict]:
    """Legge i film configurati da extto_config.db."""
    raw = _cdb.get_movies_config()
    return [
        {
            'name':     m['name'],
            'year':     m['year'],
            'quality':  m['quality'],
            'language': m['language'],
            'enabled':  bool(m['enabled']),
            'subtitle': m['subtitle'],
            'exclude':  m.get('exclude', ''),
        }
        for m in raw
    ]

def save_movies_config(movies: List[dict]) -> bool:
    """Salva i film in extto_config.db."""
    try:
        _cdb.save_movies_config(movies)
        return True
    except Exception as e:
        logger.error(f"save_movies_config: {e}")
        return False

# ============================================================================
# LOG STREAMING & UTILS
# ============================================================================

def tail_log_file():
    """Tail del file di log per streaming"""
    if not os.path.exists(LOG_FILE):
        return
    
    with open(LOG_FILE, 'r', encoding='utf-8') as f:
        # Vai alla fine
        f.seek(0, 2)
        
        while True:
            line = f.readline()
            if line:
                log_queue.put(line)
            else:
                time.sleep(0.5)

# --- MODIFICA: API per interfacce di rete (Killswitch) ---

@app.route('/api/network/interfaces')
def get_network_interfaces():
    """Rileva le interfacce di rete del sistema (Cross-Platform)"""
    interfaces = {}
    try:
        # Usa psutil che funziona su Windows, Mac e Linux!
        net_if_addrs = psutil.net_if_addrs()
        
        for iface_name, addrs in net_if_addrs.items():
            itype = 'Ethernet'
            iface_lower = iface_name.lower()
            
            # Deduzione del tipo dal nome (valido per la maggior parte dei sistemi)
            if iface_lower.startswith(('wl', 'wi-fi', 'airport')): itype = 'WiFi'
            elif iface_lower.startswith(('tun', 'wg', 'ppp', 'utun')): itype = 'VPN'
            elif iface_lower.startswith('lo'): itype = 'Loopback'
            
            ip = 'N/A'
            # Cerca l'indirizzo IPv4 (AF_INET)
            for addr in addrs:
                if addr.family == socket.AF_INET:
                    ip = addr.address
                    break
            
            if ip != 'N/A' and itype != 'Loopback': # Opzionale: puoi escludere il Loopback
                interfaces[iface_name] = {'ip': ip, 'type': itype}
                
    except Exception as e:
        logger.exception("Error detecting network interfaces")
        return jsonify({'error': str(e)}), 500
    
    return jsonify({'interfaces': interfaces})

@app.route('/api/manual-search', methods=['GET'])
def manual_search():
    try:
        query = request.args.get('q', '').strip()
        if not query:
            return jsonify({'success': False, 'error': 'Query vuota'}), 400
            
        from core.engine import Engine
        from core.config import Config
        from core.models import Parser as _Parser
        _parser = Parser or _Parser
        eng = Engine()
        cfg = Config()
        
        # 1. Ricerca Live (Jackett/Scraper esterni)
        live_results = eng.perform_manual_search(query, cfg.urls)
        
        # 2. Ricerca "Smart" nell'Archivio Locale (Supporto +/-)
        archive_items, _ = db.search_archive(query, limit=100)
        archive_results = []
        for row in archive_items:
            # Calcola il quality score dal titolo (evita score=0 fisso che
            # impedisce l'inserimento in episode_feed_matches quando i 4 slot sono pieni)
            try:
                _aq = _Parser.parse_quality(row['title'])
                _ascore = _aq.score() if _aq else 0
            except Exception as e:
                logger.debug(f"parse_quality archive row: {e}")
                _ascore = 0
            archive_results.append({
                'title': row['title'],
                'magnet': row['magnet'],
                'source': 'Archivio Locale',
                'score': _ascore
            })
        
        # 3. Unione e Deduplicazione (evita che lo stesso magnet compaia due volte)
        seen_magnets = set()
        results = []
        
        for item in archive_results + live_results:
            mag = item.get('magnet')
            if mag and mag not in seen_magnets:
                seen_magnets.add(mag)
                # Diamo un'etichetta se proviene dal database
                if 'source' not in item:
                    item['source'] = item.get('uploader') or 'Archivio Locale'
                results.append(item)
        
        # --- FASE 3: VALUTAZIONE SCARTI (BLINDATA) ---
        if _parser:
            for res in results:
                try: # <--- SCUDO: Se un singolo titolo fallisce, non blocca gli altri 254!
                    reasons = []
                    t_lower = res.get('title', '').lower()
                    
                    # 1. Controllo Blacklist
                    for b in _parser.BLACKLIST:
                        if b and b in t_lower:
                            reasons.append(f"Blacklist ({b})")
                    
                    # 2. Controllo Limiti Serie TV
                    ep = _parser.parse_series_episode(res['title'])
                    if ep:
                        match = cfg.find_series_match(ep['name'], ep['season'])
                        if match:
                            qual_req = match.get('qual', match.get('quality', ''))
                            min_rank = cfg._min_res_from_qual_req(qual_req)
                            max_rank = cfg._max_res_from_qual_req(qual_req)
                            this_rank = cfg._res_rank_from_title(res['title'])
                            
                            if this_rank < min_rank: reasons.append(f"Qualità bassa (Richiesta: {qual_req})")
                            if this_rank > max_rank: reasons.append("Qualità oltre limite max")
                            
                            lang_req = match.get('lang', match.get('language', 'ita'))
                            if not cfg._lang_ok(res['title'], lang_req): 
                                reasons.append(f"Manca Lingua ({lang_req})")
                        else:
                            _dl = _default_lang()
                            if not cfg._lang_ok(res['title'], _dl): reasons.append(f"Manca Lingua ({_dl})")
                    else:
                        # 3. Controllo Limiti Film
                        mov = _parser.parse_movie(res['title'])
                        if mov:
                            match = cfg.find_movie_match(mov['name'], mov.get('year', ''))
                            if match:
                                qual_req = match.get('qual', match.get('quality', ''))
                                min_rank = cfg._min_res_from_qual_req(qual_req)
                                this_rank = cfg._res_rank_from_title(res['title'])
                                
                                if this_rank < min_rank: reasons.append(f"Qualità bassa (Richiesta: {qual_req})")
                                
                                lang_req = match.get('lang', match.get('language', 'ita'))
                                if not cfg._lang_ok(res['title'], lang_req): 
                                    reasons.append(f"Manca Lingua ({lang_req})")
                            else:
                                _dl = _default_lang()
                                if not cfg._lang_ok(res['title'], _dl): reasons.append(f"Manca Lingua ({_dl})")
                        else:
                            _dl = _default_lang()
                            if not cfg._lang_ok(res['title'], _dl): reasons.append(f"Manca Lingua ({_dl})")

                    # Applica i punti bonus/malus
                    bonus = cfg.get_custom_score(res['title']) if hasattr(cfg, 'get_custom_score') else 0
                    res['score'] = res.get('score', 0) + bonus
                    
                    res['rejections'] = reasons
                    
                except Exception as item_err:
                    # Registra l'errore del singolo titolo ma continua con gli altri
                    logger.warning(f"Parse error on title '{res.get('title')}': {item_err}")
        # ----------------------------------

        # --- SALVATAGGIO IN episode_feed_matches ---
        # Per ogni risultato che riguarda una serie TV con S/E riconoscibili,
        # registra il match nel DB in modo che compaia nei "Ultimi trovati" e nel popup 📋
        try:
            from core.models import Parser as _ParserFM, normalize_series_name, _series_name_matches
            _pfm = Parser or _ParserFM
            if not _pfm:
                logger.warning("⚠️  feed_match: Parser not available, skip")
            else:
                _c = db.conn.cursor()
                _all_series = _c.execute('SELECT id, name, aliases FROM series').fetchall()
                logger.info(f"📋 Salvataggio in 'Ultimi trovati': {len(results)} risultati dalla ricerca manuale da abbinare a {len(_all_series)} serie in DB")
                _fm_saved = 0
                _fm_no_ep = 0
                _fm_no_series = 0
                _fm_no_magnet = 0
                for res in results:
                    try:
                        _title = res.get('title', '')
                        ep = _pfm.parse_series_episode(_title)
                        if not ep or not ep.get('season') or not ep.get('episode'):
                            _fm_no_ep += 1
                            logger.debug(f"   feed_match skip (no S/E): '{_title[:70]}'")
                            continue
                        _norm_ep = normalize_series_name(ep['name'])
                        _sid = None
                        for _srow in _all_series:
                            if _series_name_matches(normalize_series_name(_srow['name']), _norm_ep):
                                _sid = _srow['id']
                                break
                            try:
                                _aliases = json.loads(_srow['aliases'] or '[]')
                            except Exception:
                                _aliases = []  # aliases malformati, ignorati
                            if any(_series_name_matches(normalize_series_name(a), _norm_ep) for a in _aliases):
                                _sid = _srow['id']
                                logger.debug(f"   feed_match: alias match for '{ep['name']}' → series id={_srow['id']} ({_srow['name']})")
                                break
                        if not _sid:
                            _fm_no_series += 1
                            logger.debug(f"   feed_match skip (series not found): ep_name='{ep['name']}' norm='{_norm_ep}' | '{_title[:60]}'")
                            continue
                        _magnet = res.get('magnet', '')
                        if not _magnet:
                            _fm_no_magnet += 1
                            logger.debug(f"   feed_match skip (no magnet): '{_title[:70]}'")
                            continue
                        _score = int(res.get('score', 0))
                        _rejections = res.get('rejections', [])
                        if not _rejections:
                            _fail = None
                        elif any('Blacklist' in r for r in _rejections):
                            _fail = 'blacklisted'
                        elif any('Lingua' in r for r in _rejections):
                            _fail = 'lang_mismatch'
                        elif any('bassa' in r for r in _rejections):
                            _fail = 'below_quality'
                        elif any('limite max' in r or 'troppo alta' in r.lower() for r in _rejections):
                            _fail = 'above_quality'
                        else:
                            _fail = 'below_quality'
                        db.record_feed_match(_sid, ep['season'], ep['episode'],
                                             _title, _score, _fail, _magnet)
                        _fm_saved += 1
                        logger.debug(f"   feed_match OK: S{ep['season']:02d}E{ep['episode']:02d} score={_score} fail={_fail} | '{_title[:60]}'")
                    except Exception as _fm_err:
                        logger.warning(f"   feed_match error on '{res.get('title','')[:60]}': {_fm_err}")
                logger.info(f"📋 Ultimi trovati: {_fm_saved} episodi salvati" +
                            (f", {_fm_no_ep} scartati (nessun S/E riconoscibile)" if _fm_no_ep else "") +
                            (f", {_fm_no_series} scartati (serie non in DB)" if _fm_no_series else "") +
                            (f", {_fm_no_magnet} scartati (nessun magnet)" if _fm_no_magnet else ""))
        except Exception as _fm_outer_err:
            logger.error(f"❌ feed_match critical error: {_fm_outer_err}")
        return jsonify({'success': True, 'results': results})
        
    except Exception as e:
        # LOG DETTAGLIATO IN CASO DI CRASH TOTALE
        import traceback
        err_details = traceback.format_exc()
        logger.error(f"❌ Critical error in manual_search:\n{err_details}")
        return jsonify({'success': False, 'error': f"Errore server. Controlla i log."}), 500

@app.route('/api/manual-search-ed2k', methods=['GET'])
def manual_search_ed2k():
    """
    Ricerca su aMule/eD2k per una query libera.
    Restituisce i risultati con idx, name, size, sources usabili da download_result.
    """
    try:
        query = request.args.get('q', '').strip()
        if not query:
            return jsonify({'success': False, 'error': 'Query vuota'}), 400

        import core.config_db as _cdb_ed2k
        _am_en = str(_cdb_ed2k.get_setting('amule_enabled', 'no')).lower() in ('yes', 'true', '1')
        if not _am_en:
            return jsonify({'success': False, 'error': 'aMule non abilitato nelle impostazioni'}), 400

        from core.clients.amule import AmuleClient
        from core.config import Config
        cfg = Config()

        with AmuleClient(cfg) as client:
            results = client.search(query, network='global')

        if results is None:
            return jsonify({'success': False, 'error': 'Nessuna risposta da amuled (è in esecuzione?)'}), 503

        results = sorted(results, key=lambda r: r.get('sources', 0), reverse=True)

        return jsonify({'success': True, 'results': results, 'count': len(results)})

    except Exception as e:
        logger.error(f"manual_search_ed2k: {e}")
        return jsonify({'success': False, 'error': str(e)}), 500


@app.route('/api/manual-search-ed2k-download', methods=['POST'])
def manual_search_ed2k_download():
    """
    Avvia il download di un risultato eD2k tramite il suo idx.
    Body JSON: { idx: int }
    """
    try:
        data = request.json or {}
        idx  = data.get('idx')
        if idx is None:
            return jsonify({'success': False, 'error': 'idx mancante'}), 400

        import core.config_db as _cdb_ed2k
        _am_en = str(_cdb_ed2k.get_setting('amule_enabled', 'no')).lower() in ('yes', 'true', '1')
        if not _am_en:
            return jsonify({'success': False, 'error': 'aMule non abilitato'}), 400

        from core.clients.amule import AmuleClient
        from core.config import Config
        cfg = Config()

        with AmuleClient(cfg) as client:
            ok = client.download_result(int(idx))

        if ok:
            return jsonify({'success': True})
        else:
            return jsonify({'success': False, 'error': 'aMule non ha accettato il download'}), 500

    except Exception as e:
        logger.error(f"manual_search_ed2k_download: {e}")
        return jsonify({'success': False, 'error': str(e)}), 500


@app.route('/api/logs/stream')
def stream_logs():
    """Stream dei log in tempo reale via SSE"""
    def generate():
        # Invia le ultime 50 righe
        if os.path.exists(LOG_FILE):
            with open(LOG_FILE, 'r', encoding='utf-8') as f:
                lines = f.readlines()
                for line in lines[-50:]:
                    yield f"data: {json.dumps({'line': line})}\n\n"
        
        # Stream nuove righe
        while True:
            try:
                line = log_queue.get(timeout=1)
                yield f"data: {json.dumps({'line': line})}\n\n"
            except GeneratorExit:
                # Il client ha chiuso la connessione: termina senza errori
                return
            except BrokenPipeError:
                return
            except Exception as e:
                logger.debug(f"stream event: {e}")
                # Ping periodico per mantenere vivo lo stream
                yield f"data: {json.dumps({'ping': True})}\n\n"
    
    return Response(stream_with_context(generate()), mimetype='text/event-stream')

# Trigger file per avviare immediatamente un ciclo del motore senza systemd
TRIGGER_FILE = '/tmp/extto_run_now'
TRIGGER_DOMAIN_MAP = {
    'all':    '/tmp/extto_run_now',
    'series': '/tmp/extto_run_series',
    'movies': '/tmp/extto_run_movies',
    'comics': '/tmp/extto_run_comics',
}

@app.route('/api/run-now', methods=['POST'])
def run_now():
    """Endpoint esistente (compatibilità) — forza ciclo completo."""
    try:
        with open(TRIGGER_FILE, 'w') as f:
            f.write(str(time.time()))
        return jsonify({'success': True, 'message': 'Ciclo richiesto (trigger creato)'})
    except Exception as e:
        return jsonify({'success': False, 'error': str(e)}), 500

@app.route('/api/run_now', methods=['GET', 'POST'])
def run_now_domain():
    """Forza un ciclo immediato limitato al dominio specificato.
    Parametro: domain = all | series | movies | comics (default: all)
    Usato dai pulsanti Ricontrolla nella dashboard.
    """
    try:
        domain = request.args.get('domain', 'all').lower()
        if domain not in TRIGGER_DOMAIN_MAP:
            domain = 'all'
        tf = TRIGGER_DOMAIN_MAP[domain]
        with open(tf, 'w') as f:
            f.write(str(time.time()))
        logger.info(f"⏭️  Run-now requested via Web UI: domain='{domain}'")
        return jsonify({'ok': True, 'domain': domain, 'trigger': tf})
    except Exception as e:
        return jsonify({'ok': False, 'error': str(e)}), 500

@app.route('/api/config/add_all_from_archive', methods=['POST'])
def add_all_from_archive():
    """Scansiona la radice archivio (@archive_root) e aggiunge al series_config
    tutte le serie mancanti (una riga per cartella), impostando:
    - seasons = *
    - quality = 1080p
    - language = ita
    - enabled = yes
    - archive_path = <archive_root>/<cartella>
    """
    try:
        cfg = parse_series_config()
        settings = cfg.get('settings', {})
        payload = request.get_json(silent=True) or {}
        # Supporta piu' radici: se nel payload e' specificata 'root', usala; altrimenti:
        # - se c'e' una sola @archive_root, usa quella; se piu' di una, richiedi selezione esplicita
        roots = settings.get('archive_root', []) if isinstance(settings.get('archive_root'), list) else ([settings.get('archive_root')] if settings.get('archive_root') else [])
        sel = (payload.get('root') or '').strip()
        if not sel:
            if len(roots) == 1:
                sel = roots[0]
            else:
                return jsonify({'success': False, 'error': 'Specifica la radice con il parametro root o configura una sola @archive_root'}), 400
        root = sel.strip()
        if not os.path.isdir(root):
            return jsonify({'success': False, 'error': f"Percorso non valido: {root}"}), 400

        existing_names_lower = set([s['name'].strip().lower() for s in cfg.get('series', [])])
        added = 0
        try:
            for entry in sorted(os.listdir(root)):
                full = os.path.join(root, entry)
                if not os.path.isdir(full):
                    continue
                name = entry.strip()
                if not name:
                    continue
                if name.lower() in existing_names_lower:
                    continue
                cfg['series'].append({
                    'name': name,
                    'seasons': '*',
                    'quality': '1080p',
                    'language': _default_lang(),
                    'enabled': True,
                    'archive_path': full
                })
                existing_names_lower.add(name.lower())
                added += 1
        except Exception as e:
            return jsonify({'success': False, 'error': f"Errore scansione archivio: {e}"}), 500

        if not save_series_config(cfg):
            return jsonify({'success': False, 'error': 'Salvataggio series_config fallito'}), 500
        return jsonify({'success': True, 'added': added, 'message': f"Aggiunte {added} serie dal percorso archivio"})
    except Exception as e:
        return jsonify({'success': False, 'error': str(e)}), 500

@app.route('/api/series/<int:series_id>/path', methods=['POST'])
def update_series_archive_path(series_id: int):
    """Aggiorna l'archive_path per una serie in series_config (match per nome)."""
    try:
        data = request.get_json(force=True)
        new_path = (data.get('archive_path') or '').strip()
        if not new_path:
            return jsonify({'success': False, 'error': 'Percorso vuoto'}), 400
        # Prendi il nome serie dal DB
        if not db.conn:
            return jsonify({'success': False, 'error': 'DB non disponibile'}), 500
        c = db.conn.cursor()
        c.execute('SELECT name FROM series WHERE id=?', (series_id,))
        row = c.fetchone()
        if not row:
            return jsonify({'success': False, 'error': 'Serie non trovata'}), 404
        series_name = row['name'] if isinstance(row, sqlite3.Row) else row[0]
        # Aggiorna in config
        cfg = parse_series_config()
        updated = False
        for s in cfg.get('series', []):
            if s.get('name', '').strip().lower() == series_name.strip().lower():
                s['archive_path'] = new_path
                updated = True
                break
        if not updated:
            return jsonify({'success': False, 'error': 'Serie non presente in series_config'}), 404
        if not save_series_config(cfg):
            return jsonify({'success': False, 'error': 'Salvataggio fallito'}), 500
        return jsonify({'success': True, 'message': 'Percorso aggiornato'})
    except Exception as e:
        return jsonify({'success': False, 'error': str(e)}), 500


@app.route('/api/series/<int:series_id>/update', methods=['POST'])
def update_series_fields(series_id: int):
    """Aggiorna tutti i campi configurabili di una serie direttamente nel DB.
    Evita il roundtrip GET-tutto → modifica → POST-tutto che può perdere dati.
    """
    try:
        data = request.get_json(force=True) or {}
        import sqlite3 as _sq5

        # Leggi riga corrente per merge
        conn5 = _sq5.connect(DB_FILE)
        conn5.row_factory = _sq5.Row
        row = conn5.execute("SELECT * FROM series WHERE id=?", (series_id,)).fetchone()
        if not row:
            conn5.close()
            return jsonify({'success': False, 'error': 'Serie non trovata'}), 404

        # Merge: usa i valori dal payload, fallback su quelli attuali nel DB
        def _get(key, fallback):
            return data[key] if key in data else fallback

        aliases_raw  = _get('aliases', json.loads(row['aliases'] or '[]'))
        ignored_raw  = _get('ignored_seasons', json.loads(row['ignored_seasons'] or '[]'))
        aliases_json = json.dumps(aliases_raw if isinstance(aliases_raw, list) else [], ensure_ascii=False)
        ignored_json = json.dumps(ignored_raw if isinstance(ignored_raw, list) else [], ensure_ascii=False)

        conn5.execute("""
            UPDATE series SET
                name                = ?,
                quality_requirement = ?,
                seasons             = ?,
                language            = ?,
                enabled             = ?,
                archive_path        = ?,
                timeframe           = ?,
                aliases             = ?,
                ignored_seasons     = ?,
                tmdb_id             = ?,
                subtitle            = ?,
                season_subfolders   = ?,
                exclude             = ?
            WHERE id = ?
        """, (
            _get('name',              row['name']),
            _get('quality',           row['quality_requirement'] or 'any'),
            _get('seasons',           row['seasons'] or '1+'),
            _get('language',          row['language'] or 'ita'),
            1 if _get('enabled',      bool(row['enabled'])) else 0,
            _get('archive_path',      row['archive_path'] or ''),
            int(_get('timeframe',     row['timeframe'] or 0) or 0),
            aliases_json,
            ignored_json,
            str(_get('tmdb_id',       row['tmdb_id'] or '') or ''),
            str(_get('subtitle',      row['subtitle'] or '') or ''),
            1 if _get('season_subfolders', bool(row['season_subfolders'] if 'season_subfolders' in row.keys() else 0)) else 0,
            str(_get('exclude',       row['exclude'] if 'exclude' in row.keys() else '') or ''),
            series_id,
        ))
        conn5.commit()
        conn5.close()

        # Se tmdb_id è cambiato, aggiorna anche series_metadata.tvdb_id
        # (usato da get_tmdb_id_for_series e da extto-details come cache)
        new_tmdb_id = _get('tmdb_id', row['tmdb_id'] or '')
        old_tmdb_id = str(row['tmdb_id'] or '')
        if new_tmdb_id and str(new_tmdb_id) != old_tmdb_id:
            try:
                conn6 = _sq5.connect(DB_FILE)
                conn6.execute(
                    "UPDATE series_metadata SET tvdb_id=? WHERE series_id=?",
                    (int(new_tmdb_id), series_id)
                )
                conn6.commit()
                conn6.close()
                logger.info(f"Series #{series_id}: tmdb_id updated {old_tmdb_id} → {new_tmdb_id} (series_metadata)")

                # Invalida cache file TMDB se esiste (file JSON nella cache dir)
                try:
                    import glob as _glob
                    cache_dirs = [
                        os.path.join(BASE_DIR, 'core', 'tmdb_cache'),
                        os.path.join(BASE_DIR, 'tmdb_cache'),
                    ]
                    for cdir in cache_dirs:
                        for f_old in _glob.glob(os.path.join(cdir, f'{old_tmdb_id}*.json')):
                            os.remove(f_old)
                            logger.debug(f"TMDB cache removed: {f_old}")
                except Exception as ce:
                    logger.debug(f"Cache TMDB cleanup: {ce}")
            except Exception as me:
                logger.warning(f"update series_metadata tmdb_id: {me}")

        logger.info(f"Series #{series_id} updated: aliases={aliases_raw}")
        return jsonify({'success': True})
    except Exception as e:
        logger.error(f"update_series_fields: {e}")
        return jsonify({'success': False, 'error': str(e)}), 500

@app.route('/api/series/<int:series_id>/scan-archive', methods=['POST'])
def scan_one_series_archive(series_id: int):
    """Scansiona il percorso archivio: usa le RegEx elastiche e legge il nome delle cartelle."""
    import os
    import re as _re
    from collections import defaultdict

    try:
        if not db.conn:
            return jsonify({'success': False, 'error': 'DB non disponibile'}), 500
        c = db.conn.cursor()
        c.execute('SELECT name FROM series WHERE id=?', (series_id,))
        r = c.fetchone()
        if not r:
            return jsonify({'success': False, 'error': 'Serie non trovata'}), 404
        series_name = r['name'] if isinstance(r, sqlite3.Row) else r[0]
        
        cfg = parse_series_config()
        apath = ''
        for s in cfg.get('series', []):
            if s.get('name', '').strip().lower() == series_name.strip().lower():
                apath = s.get('archive_path', '')
                break
        if not apath:
            return jsonify({'success': False, 'error': 'Percorso archivio non impostato per la serie'}), 400
        
        base = apath
        if not os.path.isdir(base):
            log_maintenance(f"❌ Errore Scansione {series_name}: Il percorso {base} non esiste sul disco!")
            return jsonify({'success': False, 'error': f'Percorso non valido: {base}'}), 400
            
        log_maintenance(f"📂 Avvio scansione per '{series_name}' in: {base}")
        
        found = defaultdict(int)
        video_exts = {'.mkv', '.mp4', '.avi', '.ts', '.m4v'}
        file_count = 0

        for root, _, files in os.walk(base):
            # Leggiamo la Stagione dal nome della cartella genitore!
            folder_season = None
            folder_name = os.path.basename(root)
            folder_match = _re.search(r'(?i)(?:stagione|season|serie|s)\s*[._\-]*0*(\d+)', folder_name)
            if folder_match:
                folder_season = int(folder_match.group(1))

            for fn in files:
                ext = os.path.splitext(fn)[1].lower()
                if ext not in video_exts or 'sample' in fn.lower():
                    continue
                    
                file_count += 1
                sea = epi = 0
                
                # METODO 1: Match Standard Universale (S01E01, 1x01, s01.e01)
                m_std = _re.search(r'(?i)[Ss]0*(\d{1,2})[._\-\s]*[Ee]0*(\d{1,3})|0*(\d{1,2})x0*(\d{1,3})', fn)
                if m_std:
                    if m_std.group(1): # Formato S01E01
                        sea = int(m_std.group(1))
                        epi = int(m_std.group(2))
                    else:              # Formato 1x01
                        sea = int(m_std.group(3))
                        epi = int(m_std.group(4))
                else:
                    # METODO 2: Usa la stagione della cartella
                    if folder_season is not None:
                        m_ep = _re.search(r'(?i)(?:ep|episodio|episode|e)[._\-\s]*0*(\d{1,3})|^0*(\d{1,3})(?:[\s\.\-]|$)', fn)
                        if m_ep:
                            sea = folder_season
                            epi = int(m_ep.group(1) or m_ep.group(2))
                
                if sea > 0 and epi > 0:
                    q = Parser.parse_quality(fn)
                    score = q.score() or 20000 # Score base se non riconosce nulla
                    
                    if score >= found[(sea,epi)]:
                        found[(sea,epi)] = score

        log_maintenance(f"   ↳ Esaminati {file_count} file video. Identificati {len(found)} episodi validi.")

        upserts = 0
        now_iso = datetime.now().isoformat()
        for (sea, epi), best in found.items():
            fake_title = f"{series_name} S{sea:02d}E{epi:02d}"
                
            c.execute('SELECT id, quality_score, magnet_hash FROM episodes WHERE series_id=? AND season=? AND episode=?', (series_id, sea, epi))
            row = c.fetchone()
            if row:
                # Se l'episodio è stato scaricato via torrent (magnet_hash valido), non
                # sovrascrivere: il DB è autorevole. Solo le entry scan-archive (hash=NULL)
                # vengono aggiornate se il file su disco ha uno score migliore.
                if not row['magnet_hash'] and (row['quality_score'] or 0) <= int(best):
                    c.execute('UPDATE episodes SET title=?, quality_score=?, downloaded_at=? WHERE id=?', (fake_title, int(best), now_iso, row['id']))
                    upserts += 1
            else:
                c.execute('INSERT INTO episodes (series_id, season, episode, title, quality_score, is_repack, magnet_hash, magnet_link, downloaded_at) VALUES (?, ?, ?, ?, ?, 0, NULL, NULL, ?)', (series_id, sea, epi, fake_title, int(best), now_iso))
                upserts += 1
                
            c.execute('''
                INSERT INTO episode_archive_presence (series_id, season, episode, best_quality_score, at)
                VALUES (?, ?, ?, ?, ?)
                ON CONFLICT(series_id,season,episode) DO UPDATE SET best_quality_score=excluded.best_quality_score, at=excluded.at
            ''', (series_id, sea, epi, int(best), now_iso))
            
        db.conn.commit()
        log_maintenance(f"✅ Scansione EXTTO Terminata: {upserts} episodi allineati nel database per {series_name}.")
        return jsonify({'success': True, 'updated': upserts, 'message': f'Trovati {upserts} episodi!'})
    except Exception as e:
        log_maintenance(f"❌ Errore critico scansione {series_id}: {str(e)}")
        return jsonify({'success': False, 'error': str(e)}), 500
        
# ============================================================================
# API ENDPOINTS
# ============================================================================

@app.route('/')
def index():
    """Home page"""
    return render_template('index.html')

@app.route('/api/license', methods=['GET'])
def get_license():
    """Restituisce il contenuto di LICENSE.txt dalla root del progetto"""
    license_path = os.path.join(BASE_DIR, 'LICENSE.txt')
    if not os.path.exists(license_path):
        return jsonify({'error': 'File LICENSE.txt non trovato'}), 404
    try:
        with open(license_path, 'r', encoding='utf-8') as f:
            content = f.read()
        return jsonify({'content': content})
    except Exception as e:
        return jsonify({'error': str(e)}), 500

@app.route('/api/rename-progress', methods=['GET'])
def get_rename_progress():
    """Restituisce lo stato di avanzamento della rinomina/preview"""
    return jsonify(RENAME_PROGRESS)    
    
@app.route('/api/log_level', methods=['GET', 'POST'])
def handle_log_level():
    """Legge o imposta il livello di log globale (debug, info, warning, error)"""
    from core.constants import get_log_level, set_log_level
    try:
        if request.method == 'GET':
            # Legge il livello attuale attivo in memoria
            return jsonify({'ok': True, 'level': get_log_level()})
        else:
            # Imposta il nuovo livello
            data = request.json or {}
            new_level = data.get('level', 'info').lower()
            
            # Applica immediatamente alla sessione corrente
            set_log_level(new_level)
            
            # Salva nel file di configurazione per renderlo permanente
            cfg = parse_series_config()
            if 'settings' not in cfg:
                cfg['settings'] = {}
            cfg['settings']['log_level'] = new_level
            save_series_config(cfg)
            
            log_maintenance(f"🔧 Livello Log modificato a: {new_level.upper()}")
            return jsonify({'ok': True})
    except Exception as e:
        return jsonify({'ok': False, 'error': str(e)}), 500    

@app.route('/api/stats')
def get_stats():
    """Statistiche generali"""
    stats = db.get_stats()
    
    # Aggiungi info consumo GB
    try:
        from core.database import Database as _CoreDB
        with _CoreDB() as _cdb:
            stats["consumption"] = _cdb.get_consumption_stats()
    except Exception as e:
        logger.warning(f"get_consumption_stats: {e}")
        stats['consumption'] = {'total_gb': 0, 'last_30_days_gb': 0, 'last_7_days_gb': 0}

    # Aggiungi info configurazione
    config = parse_series_config()
    stats['series_configured'] = len(config['series'])
    stats['series_enabled'] = sum(1 for s in config['series'] if s['enabled'])
    
    movies = parse_movies_config()
    stats['movies_configured'] = len(movies)
    stats['movies_enabled'] = sum(1 for m in movies if m['enabled'])
    
    # --- NUOVO: Calcolo Spazio Libero sul disco ---
    try:
        import shutil
        import os
        # Controlla lo spazio nella cartella di download, se non la trova usa la directory corrente
        target_path = config.get('settings', {}).get('libtorrent_dir', '/')
        if not os.path.exists(target_path):
            target_path = os.getcwd()
            
        total, used, free = shutil.disk_usage(target_path)
        stats['disk_free_gb'] = round(free / (1024 ** 3), 1)
    except Exception as e:
        stats['disk_free_gb'] = 0
        # --- NUOVO: Statistiche Fumetti ---
    try:
        from core.comics import ComicsDB
        cdb = ComicsDB(os.path.join(BASE_DIR, 'comics.db'))
        comics_list = cdb.get_comics()
        stats['comics_configured'] = len(comics_list)
        # Conta tutti gli elementi nello storico
        history = cdb.get_history(limit=10000)
        stats['comics_downloads'] = len(history)
    except Exception as e:
        logger.debug(f"comics stats: {e}")
        stats['comics_configured'] = 0
        stats['comics_downloads'] = 0
    # ----------------------------------
        
    return jsonify(stats)

@app.route('/api/health')
def get_health():
    """Report salute del sistema"""
    try:
        from core.health import HealthMonitor
        from core.config import Config
        cfg = Config()
        monitor = HealthMonitor(cfg)
        return jsonify(monitor.get_full_report())
    except Exception as e:
        return jsonify({'error': str(e)}), 500

@app.route('/api/series')
def get_series():
    """Lista serie TV con ordinamento opzionale: ?sort=name|episodes|last&order=asc|desc"""
    series = db.get_all_series()
    sort_by = request.args.get('sort', 'name')
    order   = request.args.get('order', 'asc').lower()
    reverse = (order == 'desc')

    sort_keys = {
        'name':     lambda x: (x.get('name') or '').lower(),
        'episodes': lambda x: x.get('episodes_count') or 0,
        'last':     lambda x: x.get('last_download') or '',
    }
    key_fn = sort_keys.get(sort_by, sort_keys['name'])
    series.sort(key=key_fn, reverse=reverse)
    return jsonify(series)

@app.route('/api/series/<int:series_id>/episodes')
def get_series_episodes(series_id):
    """Episodi di una serie"""
    episodes = db.get_series_episodes(series_id)
    return jsonify(episodes)

@app.route('/api/series/<int:series_id>/feed-matches/<int:season>/<int:episode>')
def get_episode_feed_matches(series_id, season, episode):
    """Restituisce i top-5 feed matches per un episodio."""
    try:
        matches = db.get_feed_matches(series_id, season, episode)
        return jsonify(matches)
    except Exception as e:
        return jsonify([]), 200

@app.route('/api/series/<int:series_id>/last-found')
def get_series_last_found(series_id):
    """Restituisce gli ultimi N match trovati nel feed per una serie (tutti gli episodi)."""
    try:
        limit = int(request.args.get('limit', 5))
        if not db.conn:
            return jsonify([])
        c = db.conn.cursor()
        c.execute('''
            SELECT season, episode, title, quality_score, fail_reason, magnet, found_at
            FROM episode_feed_matches
            WHERE series_id = ?
            ORDER BY found_at DESC
            LIMIT ?
        ''', (series_id, limit))
        rows = [dict(r) for r in c.fetchall()]
        return jsonify(rows)
    except Exception as e:
        logger.warning(f"last-found error: {e}")
        return jsonify([]), 200
    
@app.route('/api/series/completeness', methods=['GET'])
def get_series_completeness():
    """Restituisce dal DB quali serie sono marcate come completate o terminate dal motore."""
    try:
        c = db.conn.cursor()
        c.execute('SELECT name, is_completed, is_ended FROM series WHERE is_completed=1 OR is_ended=1')
        results = {row['name']: {'is_completed': bool(row['is_completed']), 'is_ended': bool(row['is_ended'])}
                   for row in c.fetchall()}
        return jsonify(results)
    except Exception as e:
        logger.debug(f"get_series_completeness: {e}")
        return jsonify({})
    
@app.route('/api/series/stats', methods=['GET'])
def get_series_stats():
    """Statistiche aggregate per serie: ep scaricati, ultimo episodio, is_ended, is_completed."""
    try:
        return jsonify(db.get_series_stats())
    except Exception as e:
        return jsonify({'error': str(e)}), 500



def _get_own_port() -> int:
    """Porta su cui sta girando Flask (per chiamate interne)"""
    try:
        cfg = parse_series_config()
        return int(cfg.get('settings', {}).get('web_port', 5000))
    except Exception:
        return 5000


@app.route('/api/series/all-missing', methods=['GET'])
def get_all_missing_episodes():
    """Episodi mancanti: presenti nella config ma con quality_score=0 o assenti nel DB."""
    try:
        import re as _re
        import json as _j
        cfg = parse_series_config()
        c   = db.conn.cursor()
        results = []

        for serie in cfg.get('series', []):
            if not serie.get('enabled', True):
                continue
            c.execute('SELECT id, ignored_seasons FROM series WHERE name=? COLLATE NOCASE', (serie['name'],))
            row = c.fetchone()
            if not row:
                continue
            series_id = row['id']
            try:
                ignored = _j.loads(row['ignored_seasons'] or '[]')
            except Exception:
                ignored = []

            # Espande stagioni richieste (es. "1+", "1-3", "1,2,3")
            seasons_str = str(serie.get('seasons', '1+'))
            requested_seasons = set()
            for part in seasons_str.split(','):
                part = part.strip()
                if part.endswith('+'):
                    start = int(_re.sub(r'\D', '', part) or '1')
                    c.execute('SELECT MAX(season) FROM episodes WHERE series_id=?', (series_id,))
                    max_s = c.fetchone()[0] or start
                    requested_seasons.update(range(start, max(max_s, start) + 1))
                elif '-' in part:
                    a, b = part.split('-', 1)
                    requested_seasons.update(range(int(a), int(b) + 1))
                elif _re.match(r'^\d+$', part):
                    requested_seasons.add(int(part))

            requested_seasons -= set(ignored)
            if not requested_seasons:
                continue

            # Episodi presenti con quality_score > 0
            c.execute(
                'SELECT season, episode FROM episodes WHERE series_id=? AND quality_score > 0',
                (series_id,)
            )
            present = {(r['season'], r['episode']) for r in c.fetchall()}

            for season in sorted(requested_seasons):
                c.execute(
                    'SELECT MAX(episode) as max_ep FROM episodes WHERE series_id=? AND season=?',
                    (series_id, season)
                )
                max_row = c.fetchone()
                max_ep = max_row['max_ep'] if max_row and max_row['max_ep'] else 0
                for ep in range(1, max_ep + 1):
                    if (season, ep) not in present:
                        results.append({
                            'series_id':   series_id,
                            'series_name': serie['name'],
                            'season':      season,
                            'episode':     ep
                        })

        results.sort(key=lambda x: (x['series_name'].lower(), x['season'], x['episode']))
        return jsonify(results)
    except Exception as e:
        logger.error(f'all-missing: {e}')
        return jsonify({'error': str(e)}), 500


@app.route('/api/series/calendar', methods=['GET'])
def get_series_calendar():
    """Prossimi episodi in uscita (30 giorni) per le serie monitorate, via TMDB."""
    try:
        from core.config import Config as _CalCfg
        from core.tmdb import TMDBClient
        from datetime import datetime as _dt, timedelta as _td

        api_key = getattr(_CalCfg(), 'tmdb_api_key', '').strip()
        if not api_key:
            return jsonify([])

        tmdb     = TMDBClient(api_key)
        cfg      = parse_series_config()
        c        = db.conn.cursor()
        today    = _dt.utcnow().date()
        deadline = today + _td(days=30)
        results  = []

        for serie in cfg.get('series', []):
            if not serie.get('enabled', True):
                continue
            c.execute('SELECT id, tmdb_id FROM series WHERE name=? COLLATE NOCASE', (serie['name'],))
            row = c.fetchone()
            if not row:
                continue
            tmdb_id   = str(row['tmdb_id'] or serie.get('tmdb_id', '') or '').strip()
            series_id = row['id']
            if not tmdb_id:
                continue
            try:
                details = tmdb.fetch_series_details(tmdb_id)
                if not details:
                    continue
                next_ep = details.get('next_episode_to_air')
                if not next_ep:
                    continue
                air_str = next_ep.get('air_date', '')
                if not air_str:
                    continue
                air_date = _dt.strptime(air_str, '%Y-%m-%d').date()
                if today <= air_date <= deadline:
                    results.append({
                        'series_id':   series_id,
                        'series_name': serie['name'],
                        'season':      next_ep.get('season_number', 0),
                        'episode':     next_ep.get('episode_number', 0),
                        'name':        next_ep.get('name', ''),
                        'air_date':    air_str
                    })
            except Exception as _ce:
                logger.debug(f'calendar tmdb {tmdb_id}: {_ce}')

        results.sort(key=lambda x: x['air_date'])
        return jsonify(results)
    except Exception as e:
        logger.error(f'calendar: {e}')
        return jsonify({'error': str(e)}), 500


@app.route('/api/scan-all-archives', methods=['POST'])
def scan_all_archives():
    """Scansiona gli archivi NAS di tutte le serie configurate che hanno un archive_path."""
    try:
        import requests as _req
        cfg   = parse_series_config()
        c     = db.conn.cursor()
        port  = _get_own_port()
        total = 0
        errors = []

        for serie in cfg.get('series', []):
            if not serie.get('archive_path', '').strip():
                continue
            c.execute('SELECT id FROM series WHERE name=? COLLATE NOCASE', (serie['name'],))
            row = c.fetchone()
            if not row:
                continue
            sid = row['id']
            try:
                r = _req.post(
                    f'http://127.0.0.1:{port}/api/series/{sid}/scan-archive',
                    timeout=120
                )
                if r.status_code == 200:
                    total += r.json().get('updated', 0)
                else:
                    errors.append(serie['name'])
            except Exception as _se:
                errors.append(f"{serie['name']}: {_se}")

        msg = f'Scansione completa: {total} episodi allineati.'
        if errors:
            msg += f' Errori ({len(errors)}): {", ".join(errors[:5])}'
        log_maintenance(f'📂 scan-all-archives — {msg}')
        return jsonify({'success': True, 'updated': total, 'message': msg, 'errors': errors})
    except Exception as e:
        logger.error(f'scan-all-archives: {e}')
        return jsonify({'success': False, 'error': str(e)}), 500


@app.route('/api/torrents/remove_completed', methods=['POST'])
def remove_completed_torrents():
    """Rimuove FORZATAMENTE tutti i torrent al 100% (anche se in pausa) e quelli finti-completati sul NAS."""
    try:
        import requests, re, os
        from urllib.parse import unquote_plus
        from core.models import normalize_series_name, _series_name_matches

        # 1. Recupera la lista reale dal motore
        resp = requests.get(f'http://127.0.0.1:{get_engine_port()}/api/torrents', timeout=10)
        if resp.status_code == 200:
            data = resp.json()
            torrents = data.get('torrents', []) if isinstance(data, dict) else data
            if isinstance(torrents, dict): torrents = list(torrents.values())

            cfg_data = parse_series_config()
            configured_series = cfg_data.get('series', [])

            hashes_to_remove = []
            for t in torrents:
                t_hash = t.get('hash', '')
                t_name = unquote_plus(t.get('name', ''))
                t_prog = float(t.get('progress', 0))
                t_paused = t.get('paused', False)
                
                is_completed = False

                # CASO 3: Torrent "fantasma" — in attesa metadati ma già completato in passato
                # (completed_time > 0 significa che era già finito, ha perso i metadati dopo riavvio)
                if 'metadat' in str(t.get('state', '')).lower() and int(t.get('completed_time', 0)) > 0:
                    is_completed = True

                # CASO 2: Finti-completati bloccati sullo 0%
                elif t_paused and (t_prog == 0.0 or t.get('total_size', 0) == 0):
                    m_ep = re.search(r'(?i)[.\s_-]*S(\d{1,2})[.\s_-]*E(\d{1,3})', t_name)
                    if m_ep:
                        norm_t_name = normalize_series_name(t_name[:m_ep.start()])
                        s_num, e_num = int(m_ep.group(1)), int(m_ep.group(2))
                        
                        target_path = next((s.get('archive_path', '').strip() for s in configured_series if _series_name_matches(normalize_series_name(s.get('name', '')), norm_t_name)), None)
                        if target_path and os.path.isdir(target_path):
                            found = False
                            try:
                                for root, _, files in os.walk(target_path):
                                    if root[len(target_path):].count(os.sep) > 2: continue
                                    for f in files:
                                        if not f.lower().endswith(('.mkv', '.mp4', '.avi', '.ts')): continue
                                        if re.search(rf'(?i)s0*{s_num}[._\-\s]*e0*{e_num}', f):
                                            is_completed = True
                                            found = True; break
                                    if found: break
                            except: pass
                    else:
                        # Controllo fisico per fumetti e film
                        final_dir = cfg_data.get('settings', {}).get('libtorrent_dir', '').strip()
                        if t_name and t_name != 'Tutto' and final_dir and os.path.exists(final_dir):
                            clean_tname = re.sub(r'[._-]+', ' ', t_name).strip().lower()
                            if clean_tname:
                                try:
                                    for f_name in os.listdir(final_dir):
                                        clean_fname = re.sub(r'[._-]+', ' ', f_name).strip().lower()
                                        if clean_tname in clean_fname or clean_fname in clean_tname:
                                            is_completed = True
                                            break
                                except Exception as e:
                                    logger.debug(f"is_completed scan disco: {e}")
                                    pass

                if is_completed:
                    hashes_to_remove.append(t_hash)
                    total_b = t.get('total_size', 0)
                    if total_b > 0:
                        try:
                            # 1. Fumetti
                            from core.comics import ComicsDB
                            cdb = ComicsDB()
                            cdb.conn.execute("UPDATE comics_history SET size_bytes=? WHERE title LIKE ? AND size_bytes=0", (total_b, f"%{t_name}%"))
                            cdb.conn.execute("UPDATE comics_weekly SET size_bytes=? WHERE magnet LIKE ? AND size_bytes=0", (total_b, f"%{t_hash}%"))
                            cdb.conn.commit()
                            # 2. Serie TV e Film (extto_series.db)
                            db.conn.execute("UPDATE episodes SET size_bytes=? WHERE magnet_hash=? AND size_bytes=0", (total_b, t_hash))
                            db.conn.execute("UPDATE movies SET size_bytes=? WHERE magnet_hash=? AND size_bytes=0", (total_b, t_hash))
                            db.conn.commit()
                        except Exception as e:
                            logger.warning(f"size_bytes update: {e}")

            # 3. Elimina fisicamente i torrent dalla lista (senza cancellare i file su disco!)
            for h in set(hashes_to_remove):
                try:
                    requests.post(f'http://127.0.0.1:{get_engine_port()}/api/torrents/remove', json={'hash': h, 'delete_files': False}, timeout=5)
                except: pass

        # 4. Esegue la pulizia standard come fallback
        resp_clean = requests.post(f'http://127.0.0.1:{get_engine_port()}/api/torrents/remove_completed', timeout=10)
        return jsonify(resp_clean.json())
        
    except Exception as e:
        return jsonify({'success': False, 'error': str(e)}), 500


@app.route('/api/http-downloads/remove-completed', methods=['POST'])
def remove_completed_http_downloads():
    """Rimuove da ACTIVE_HTTP_DOWNLOADS le voci in stato Terminato, Errore o simili."""
    try:
        from core.comics import ACTIVE_HTTP_DOWNLOADS
        # Stati terminali reali da comics.py:
        #   HTTP  → 'Finished'  |  Mega → 'Terminato'  |  Errori → 'Errore' o 'Errore: ...'
        terminal_states = {'terminato', 'errore', 'salvato', 'completato',
                           'finished', 'saved', 'done', 'error'}
        keys_to_remove = [
            k for k, v in list(ACTIVE_HTTP_DOWNLOADS.items())
            if str(v.get('state', '')).lower().split(':')[0].strip() in terminal_states
        ]
        for k in keys_to_remove:
            ACTIVE_HTTP_DOWNLOADS.pop(k, None)
        return jsonify({'removed': len(keys_to_remove), 'keys': keys_to_remove})
    except Exception as e:
        return jsonify({'error': str(e)}), 500


@app.route('/api/http-downloads/remove', methods=['POST'])
def remove_single_http_download():
    """Rimuove una singola voce da ACTIVE_HTTP_DOWNLOADS dato il suo dl_id (hash fittizio)."""
    try:
        from core.comics import ACTIVE_HTTP_DOWNLOADS
        data   = request.get_json(force=True) or {}
        dl_key = data.get('hash', '').strip()
        if not dl_key:
            return jsonify({'ok': False, 'error': 'hash mancante'}), 400
        if dl_key in ACTIVE_HTTP_DOWNLOADS:
            ACTIVE_HTTP_DOWNLOADS.pop(dl_key, None)
            return jsonify({'ok': True, 'removed': dl_key})
        return jsonify({'ok': False, 'error': 'chiave non trovata'}), 404
    except Exception as e:
        return jsonify({'ok': False, 'error': str(e)}), 500


# ──────────────────────────────────────────────────────────────────────────────
# BACKUP
# ──────────────────────────────────────────────────────────────────────────────
import zipfile, glob, fnmatch, subprocess as _subprocess

def _load_backup_settings() -> dict:
    """Legge impostazioni backup da extto.conf (via parse_series_config).
    Fallback ai valori di default se non configurati.
    """
    defaults = {
        'backup_dir':       os.path.join(BASE_DIR, 'backups'),
        'retention':        5,
        'schedule':         'manual',   # manual | daily | weekly
    }
    try:
        cfg = parse_series_config()
        s = cfg.get('settings', {})
        if s.get('backup_dir'):       defaults['backup_dir']   = s['backup_dir']
        if s.get('backup_retention'): defaults['retention']    = int(s['backup_retention'])
        if s.get('backup_schedule'):  defaults['schedule']     = s['backup_schedule']
    except Exception as e:
        logger.debug(f"backup defaults: {e}")
        pass
    return defaults

@app.route('/api/backup/settings', methods=['GET', 'POST'])
def backup_settings():
    if request.method == 'GET':
        defaults = _load_backup_settings()
        # Aggiungi default per cloud e Telegram
        cfg_full = parse_series_config()
        s = cfg_full.get('settings', {})
        defaults['cloud_type']     = s.get('backup_cloud_type', 'none') # none | ftp
        defaults['cloud_host']     = s.get('backup_cloud_host', '')
        defaults['cloud_user']     = s.get('backup_cloud_user', '')
        defaults['cloud_pass']     = s.get('backup_cloud_pass', '')
        defaults['cloud_path']     = s.get('backup_cloud_path', '/')
        defaults['send_telegram']  = str(s.get('backup_send_telegram', 'false')).lower() in ('true', '1', 'yes')
        return jsonify(defaults)
    try:
        data = request.json or {}
        cfg_full = parse_series_config()
        s = cfg_full.setdefault('settings', {})
        if 'backup_dir'  in data: s['backup_dir']       = data['backup_dir'].strip()
        if 'retention'   in data: s['backup_retention'] = str(int(data['retention']))
        if 'schedule'    in data: s['backup_schedule']  = data['schedule']
        
        # Cloud settings
        if 'cloud_type' in data: s['backup_cloud_type'] = data['cloud_type']
        if 'cloud_host' in data: s['backup_cloud_host'] = data['cloud_host']
        if 'cloud_user' in data: s['backup_cloud_user'] = data['cloud_user']
        if 'cloud_pass' in data: s['backup_cloud_pass'] = data['cloud_pass']
        if 'cloud_path' in data: s['backup_cloud_path'] = data['cloud_path']
        if 'send_telegram' in data: s['backup_send_telegram'] = 'true' if data['send_telegram'] else 'false'
        
        save_series_config(cfg_full)
        import logging as _l; _l.getLogger('extto.backup').info(f"💾 Backup settings salvati nel Database")
        try:
            from core.config import Config as _Cfg; _Cfg.invalidate()
        except Exception:
            pass
        return jsonify({'success': True})
    except Exception as e:
        import logging as _l; _l.getLogger('extto.backup').error(f"❌ Errore salvataggio backup settings: {e}")
        return jsonify({'success': False, 'error': str(e)}), 500
@app.route('/api/scores/settings', methods=['GET', 'POST'])
def scores_settings():
    try:
        cfg_data = parse_series_config()
        s = cfg_data.get('settings', {})

        if request.method == 'POST':
            data = request.json or {}
            
            # 1. Salva i valori singoli (Bonus e Opzioni)
            for key in ['bonus_dv', 'bonus_real', 'bonus_proper', 'bonus_repack', 'auto_remove_completed']:
                if key in data:
                    if key == 'auto_remove_completed':
                        s[key] = 'yes' if data[key] else 'no'
                    else:
                        s[f'score_{key}'] = str(data[key])
            
            # 2. Salva le tabelle dinamiche (Risoluzione, Sorgente, Codec, Audio, Gruppi)
            for map_name in ['res_pref', 'source_pref', 'codec_pref', 'audio_pref', 'group_pref']:
                if map_name in data:
                    prefix = map_name.split('_')[0]
                    for k, v in data[map_name].items():
                        s[f'score_{prefix}_{k}'] = str(v)
                        
            save_series_config(cfg_data)
            try:
                from core.config import Config as _Cfg; _Cfg.invalidate()
            except Exception:
                pass
            return jsonify({'success': True})

        # LOGICA DINAMICA: Prende tutto ciò che esiste nel file
        def _extract_map(prefix):
            result = {}
            full_prefix = f"score_{prefix}_"
            for k, v in s.items():
                if k.startswith(full_prefix):
                    clean_key = k.replace(full_prefix, "").strip()
                    try: result[clean_key] = int(float(str(v).strip()))
                    except: result[clean_key] = 0
            return result

        # Se una mappa è vuota (es. primo avvio), mette dei default minimi per non lasciare i riquadri vuoti
        res_map = _extract_map('res') or {'2160p':1000, '1080p':500, '720p':250}
        src_map = _extract_map('source') or {'bluray':300, 'webdl':200}
        
        data = {
            'res_pref':    res_map,
            'source_pref': src_map,
            'codec_pref':  _extract_map('codec'),
            'audio_pref':  _extract_map('audio'),
            'group_pref':  _extract_map('group'),
            'bonus_dv': int(float(str(s.get('score_bonus_dv', 300)))),
            'bonus_real': int(float(str(s.get('score_bonus_real', 100)))),
            'bonus_proper': int(float(str(s.get('score_bonus_proper', 75)))),
            'bonus_repack': int(float(str(s.get('score_bonus_repack', 50)))),
            'auto_remove_completed': str(s.get('auto_remove_completed', 'no')).lower() in ('yes', 'true', '1')
        }
        return jsonify(data)
    except Exception as e:
        return jsonify({'error': str(e)}), 500


@app.route('/api/backup/run', methods=['POST'])
def run_backup():
    """Crea uno ZIP completo di tutto EXTTO nella cartella configurata."""
    import shutil
    import logging as _logging
    _blog = _logging.getLogger('extto.backup')
    # Se il frontend gestisce già l'invio Telegram, non inviarlo anche dal backend
    _body = request.get_json(silent=True) or {}
    _skip_notify = bool(_body.get('skip_notify', False))
    try:
        cfg = _load_backup_settings()
        backup_dir = cfg['backup_dir'].strip()
        retention  = int(cfg.get('retention', 5))
        os.makedirs(backup_dir, exist_ok=True)

        ts       = datetime.now().strftime('%Y-%m-%d--%H-%M-%S')
        zip_name = f'extto-backup-{ts}.7z'
        zip_path = os.path.abspath(os.path.join(backup_dir, zip_name))

        EXCLUDE_PATTERNS = [
            '__pycache__', '*.pyc', '*.pyo',
            'backups/', '*.log', '*.log.*', '.git/', '.venv/', '.claude/',
            'extto_torrents_state/',   # dati resume libtorrent: non portabili
            '*.db-wal', '*.db-shm',   # SQLite WAL/SHM: temporanei, possono superare 60 MB
            'corsaro_cache.json',      # cache RSS Corsaro: rigenerabile
            'static/posters/',         # poster TMDB: pesanti, rigenerabili
        ]

        def _should_exclude(rel_path: str) -> bool:
            rel_norm = rel_path.replace(os.sep, '/')
            for pat in EXCLUDE_PATTERNS:
                if pat.endswith('/'):
                    if ('/' + pat.rstrip('/') + '/') in ('/' + rel_norm) or rel_norm.startswith(pat.rstrip('/') + '/'):
                        return True
                elif fnmatch.fnmatch(os.path.basename(rel_norm), pat):
                    return True
            return False

        file_count = 0
        total_size = 0

        # Conta file e dimensione sorgente prima di comprimere
        for root, dirs, files in os.walk(BASE_DIR):
            dirs[:] = [d for d in dirs if not _should_exclude(os.path.relpath(os.path.join(root, d), BASE_DIR))]
            for fname in files:
                fpath = os.path.join(root, fname)
                rel   = os.path.relpath(fpath, BASE_DIR)
                if _should_exclude(rel):
                    continue
                file_count += 1
                total_size += os.path.getsize(fpath)

        # Costruisce la lista di esclusioni per 7z
        _7z_excludes = [
            '-xr!backups', '-xr!__pycache__', '-xr!*.pyc', '-xr!*.pyo',
            '-xr!.git', '-xr!.venv', '-xr!.claude',
            '-xr!extto_torrents_state',
            '-xr!*.db-wal', '-xr!*.db-shm',
            '-xr!corsaro_cache.json',
            '-xr!static/posters',
            '-xr!*.log', '-xr!*.log.*',
        ]
        _7z_cmd = ['7z', 'a', '-t7z', '-mx=5', '-v45m', zip_path, '.'] + _7z_excludes
        _res = _subprocess.run(_7z_cmd, cwd=BASE_DIR, capture_output=True, text=True)
        if _res.returncode != 0:
            raise RuntimeError(f'7z fallito: {_res.stderr.strip()}')

        # Con -v45m i volumi si chiamano .7z.001, .7z.002, …
        vol_paths = sorted(glob.glob(zip_path + '.*'))
        if not vol_paths and os.path.exists(zip_path):
            vol_paths = [zip_path]  # fallback: archivio singolo senza split
        n_vols   = len(vol_paths)
        zip_size = sum(os.path.getsize(v) for v in vol_paths)

        # --- CLOUD BACKUP (FTP) ---
        cloud_info = ""
        try:
            cfg_full = parse_series_config()
            s = cfg_full.get('settings', {})
            ctype = s.get('backup_cloud_type', 'none')
            if ctype == 'ftp':
                host = s.get('backup_cloud_host')
                user = s.get('backup_cloud_user')
                pw   = s.get('backup_cloud_pass')
                rem  = s.get('backup_cloud_path', '/')
                if host and user and pw:
                    _blog.info(f"☁️ Caricamento backup su FTP: {host}...")
                    import ftplib
                    with ftplib.FTP(host) as ftp:
                        ftp.login(user, pw)
                        try: ftp.cwd(rem)
                        except: pass
                        for _vp in vol_paths:
                            with open(_vp, 'rb') as f:
                                ftp.storbinary(f'STOR {os.path.basename(_vp)}', f)
                    cloud_info = f" (Caricato su FTP: {host})"
                    _blog.info(f"✅ Cloud backup completato!")
            elif ctype == 'dropbox':
                token = s.get('backup_cloud_pass') # Usiamo il campo pass per il token
                path  = s.get('backup_cloud_path', '/')
                if token:
                    _blog.info("☁️ Caricamento backup su Dropbox...")
                    for _vp in vol_paths:
                        _vname = os.path.basename(_vp)
                        _cp = (path.rstrip('/') + '/' + _vname).lstrip('/')
                        if not _cp.startswith('/'): _cp = '/' + _cp
                        _hdrs = {
                            "Authorization": f"Bearer {token}",
                            "Dropbox-API-Arg": json.dumps({"path": _cp, "mode": "overwrite"}),
                            "Content-Type": "application/octet-stream"
                        }
                        with open(_vp, 'rb') as f:
                            r = requests.post("https://content.dropboxapi.com/2/files/upload", headers=_hdrs, data=f, timeout=600)
                            r.raise_for_status()
                    cloud_info = " (Caricato su Dropbox)"
                    _blog.info(f"✅ Cloud backup completato!")
        except Exception as ce:
            _blog.warning(f"⚠️ Errore Cloud Backup: {ce}")
            cloud_info = f" (Errore Cloud: {ce})"

        # Retention: tieni solo gli ultimi N backup.
        # I backup multi-volume sono rappresentati dal primo volume (.7z.001);
        # i backup legacy a file singolo (.zip) sono trattati direttamente.
        existing_sets = sorted(
            glob.glob(os.path.join(backup_dir, 'extto-backup-*.7z.001')) +
            glob.glob(os.path.join(backup_dir, 'extto-backup-*.zip'))
        )
        while len(existing_sets) > retention:
            old_first = existing_sets.pop(0)
            if old_first.endswith('.001'):
                base = old_first[:-4]  # rimuove '.001', ottiene '.7z'
                for old_vol in glob.glob(base + '.*'):
                    try: os.remove(old_vol)
                    except Exception as e: logger.debug(f"remove old backup vol: {e}")
            else:
                try: os.remove(old_first)
                except Exception as e: logger.debug(f"remove old backup: {e}")

        kept = len(
            glob.glob(os.path.join(backup_dir, 'extto-backup-*.7z.001')) +
            glob.glob(os.path.join(backup_dir, 'extto-backup-*.zip'))
        )
        tg_sent = False
        try:
            cfg_full = parse_series_config().get('settings', {})
            send_tg  = str(cfg_full.get('backup_send_telegram', 'false')).lower() in ('true', '1', 'yes')
            if send_tg and not _skip_notify:
                from core.notifier import Notifier as _Notifier
                _n = _Notifier(cfg_full)
                if _n.tg_enabled:
                    _n.notify_backup_complete(zip_name, round(zip_size/1024**2, 1), file_count, kept, cloud_info, volume_paths=vol_paths)
                    tg_sent = True
                else:
                    logger.warning("backup notify: Telegram abilitato nelle impostazioni backup ma token/chat_id mancanti")
        except Exception as _ne:
            logger.warning(f"backup notify: {_ne}")
        tg_str = " 📨 Telegram ✓" if tg_sent else ""
        vol_str = f", {n_vols} volumi" if n_vols > 1 else ""
        _blog.info(f"✅ Backup completato: {zip_name} ({round(zip_size/1024**2,1)} MB{vol_str}, {file_count} file, {kept} backup conservati){tg_str}")
        return jsonify({
            'success':    True,
            'filename':   zip_name,
            'path':       zip_path,
            'files':      file_count,
            'source_mb':  round(total_size / 1024**2, 1),
            'zip_mb':     round(zip_size / 1024**2, 1),
            'volumes':    n_vols,
            'kept':       kept,
        })
    except Exception as e:
        import traceback
        tb = traceback.format_exc()
        _blog.error(f"❌ Errore backup: {e}\n{tb}")
        return jsonify({'success': False, 'error': str(e)}), 500


@app.route('/api/backup/list', methods=['GET'])
def list_backups():
    """Lista i backup esistenti nella cartella configurata."""
    try:
        cfg  = _load_backup_settings()
        bdir = cfg['backup_dir'].strip()
        files = sorted(glob.glob(os.path.join(bdir, 'extto-backup-*.7z')), reverse=True)
        result = []
        for fp in files:
            stat = os.stat(fp)
            result.append({
                'name':     os.path.basename(fp),
                'path':     fp,
                'size_mb':  round(stat.st_size / 1024**2, 1),
                'date':     datetime.fromtimestamp(stat.st_mtime).strftime('%d/%m/%Y %H:%M'),
            })
        return jsonify({'backups': result, 'dir': bdir})
    except Exception as e:
        return jsonify({'backups': [], 'dir': '', 'error': str(e)})

# Dizionario condiviso per lo stato degli upload Telegram in background
# { job_id: {'status': 'pending'|'ok'|'error', 'message': str} }
_tg_upload_jobs: dict = {}
_tg_upload_lock = __import__('threading').Lock()


def _do_telegram_upload(job_id: str, file_path: str, token: str, chat_id: str):
    """Esegue l'upload verso Telegram in un thread separato."""
    import requests as _req
    try:
        file_size_mb = os.path.getsize(file_path) / (1024 * 1024)
        fname = os.path.basename(file_path)
        log_maintenance(f"📤 Upload backup {fname} su Telegram ({file_size_mb:.1f} MB)...")
        url = f"https://api.telegram.org/bot{token}/sendDocument"
        caption = f"📦 *Backup EXTTO*\n`{fname}` — {file_size_mb:.1f} MB"
        with open(file_path, 'rb') as doc:
            r = _req.post(
                url,
                data={'chat_id': chat_id, 'caption': caption, 'parse_mode': 'Markdown'},
                files={'document': (fname, doc, 'application/x-7z-compressed')},
                timeout=300,   # 5 minuti: abbondante anche per connessioni lente
                stream=False,
            )
        if r.status_code == 200:
            log_maintenance("✅ Backup inviato su Telegram.")
            with _tg_upload_lock:
                _tg_upload_jobs[job_id] = {'status': 'ok', 'message': 'Backup inviato su Telegram!'}
        else:
            desc = r.json().get('description', 'Errore sconosciuto')
            log_maintenance(f"❌ Telegram API error: {desc}")
            with _tg_upload_lock:
                _tg_upload_jobs[job_id] = {'status': 'error', 'message': f'Errore API Telegram: {desc}'}
    except Exception as e:
        log_maintenance(f"❌ Errore upload Telegram: {e}")
        with _tg_upload_lock:
            _tg_upload_jobs[job_id] = {'status': 'error', 'message': str(e)}


@app.route('/api/backup/send-telegram', methods=['POST'])
def send_backup_telegram():
    """Avvia l'upload del backup su Telegram in background e ritorna subito un job_id.
    Il client fa polling su /api/backup/send-telegram/status?job=<id> per il risultato.
    """
    import threading, uuid
    data      = request.get_json(silent=True) or {}
    file_path = data.get('path', '').strip()

    if not file_path or not os.path.exists(file_path):
        return jsonify({'success': False, 'error': 'File di backup non trovato sul disco.'})

    file_size_mb = os.path.getsize(file_path) / (1024 * 1024)
    if file_size_mb > 49.9:
        return jsonify({'success': False,
                        'error': f'File troppo grande ({file_size_mb:.1f} MB). Limite bot Telegram: 50 MB.'})

    try:
        import core.config_db as _cdb_tg
        token   = str(_cdb_tg.get_setting('telegram_bot_token', '') or '').strip()
        chat_id = str(_cdb_tg.get_setting('telegram_chat_id',   '') or '').strip()
    except Exception:
        cfg     = parse_series_config()
        s       = cfg.get('settings', {})
        token   = str(s.get('telegram_bot_token', '')).strip()
        chat_id = str(s.get('telegram_chat_id',   '')).strip()

    if not token or not chat_id:
        return jsonify({'success': False,
                        'error': 'Token Bot o Chat ID Telegram non configurati.'})

    job_id = str(uuid.uuid4())
    with _tg_upload_lock:
        _tg_upload_jobs[job_id] = {'status': 'pending', 'message': 'Upload in corso...'}

    t = threading.Thread(
        target=_do_telegram_upload,
        args=(job_id, file_path, token, chat_id),
        daemon=True,
        name=f'tg-upload-{job_id[:8]}'
    )
    t.start()
    return jsonify({'success': True, 'job_id': job_id, 'async': True})


@app.route('/api/backup/send-telegram/status', methods=['GET'])
def send_backup_telegram_status():
    """Ritorna lo stato di un job di upload Telegram avviato in background."""
    job_id = request.args.get('job', '').strip()
    if not job_id:
        return jsonify({'success': False, 'error': 'job_id mancante'})
    with _tg_upload_lock:
        job = _tg_upload_jobs.get(job_id)
    if job is None:
        return jsonify({'success': False, 'error': 'Job non trovato'})
    # Pulizia job completati dopo la lettura (evita accumulo in memoria)
    if job['status'] in ('ok', 'error'):
        with _tg_upload_lock:
            _tg_upload_jobs.pop(job_id, None)
    return jsonify({'success': True, **job})


@app.route('/api/series/<int:series_id>/extto-details')
def get_extto_details(series_id):
    """Genera i dettagli completi per la vista stile EXTTO (TMDB + NAS + DB)."""
    try:
        # 1. Recupera la serie dal DB e dalla Configurazione
        c = db.conn.cursor()
        # Legge nome E tmdb_id direttamente dal DB operativo (fonte più affidabile)
        c.execute('SELECT name, tmdb_id, archive_path, ignored_seasons FROM series WHERE id=?', (series_id,))
        row = c.fetchone()
        if not row: return jsonify({'error': 'Serie non trovata'}), 404
        series_name   = row['name']
        db_tmdb_id    = str(row['tmdb_id']).strip() if row['tmdb_id'] else ''
        db_archive    = row['archive_path'] or ''
        try:
            import json as _json_ig
            db_ignored = _json_ig.loads(row['ignored_seasons'] or '[]')
        except Exception:
            db_ignored = []

        cfg = parse_series_config()
        from core.models import normalize_series_name as _nsn_cfg
        _norm_sname = _nsn_cfg(series_name)
        serie_cfg = next((s for s in cfg['series'] if _nsn_cfg(s['name']) == _norm_sname), {})
        # Priorità: DB operativo > config (il DB è aggiornato da /update, la config può essere stale)
        archive_path    = db_archive or serie_cfg.get('archive_path', '')
        ignored_seasons = db_ignored or serie_cfg.get('ignored_seasons', [])

        # 2. Richiama TMDB per la grafica (leggerissimo grazie alla cache)
        from core.config import Config as CoreConfig
        from core.tmdb import TMDBClient
        core_cfg = CoreConfig()
        api_key = getattr(core_cfg, 'tmdb_api_key', '').strip()
        
        meta = {'poster': '', 'backdrop': '', 'overview': 'Nessuna trama disponibile.', 'year': '', 'network': ''}
        tmdb_seasons = {}
        
        if api_key:
            tmdb = TMDBClient(api_key)
            # MODIFICA QUESTA RIGA: PRIMA CERCA IN CONFIG, POI NEL DB, INFINE PER NOME
            # Priorità: 1) DB operativo (series.tmdb_id) 2) config 3) series_metadata 4) ricerca per nome
            tmdb_id = db_tmdb_id or serie_cfg.get('tmdb_id') or tmdb.get_tmdb_id_for_series(db, series_name) or tmdb.resolve_series_id(series_name)
            if tmdb_id:
                meta['tmdb_id'] = tmdb_id
                details = tmdb.fetch_series_details(tmdb_id)
                if details:
                    meta['poster'] = details.get('poster_path', '')
                    meta['backdrop'] = details.get('backdrop_path', '')
                    meta['overview'] = details.get('overview', meta['overview'])
                    meta['year'] = details.get('first_air_date', '')[:4]
                    networks = details.get('networks', [])
                    meta['network'] = networks[0]['name'] if networks else ''
                    _save_poster('series', series_id, meta['poster'])
                    meta['status'] = details.get('status', '') # <-- Aggiunto per sapere se è 'Ended'
                    
                    for s in details.get('seasons', []):
                        if s['season_number'] > 0:
                            tmdb_seasons[s['season_number']] = s['episode_count']

        # 3. Legge il Database Locale per capire cosa abbiamo "cercato/trovato"
        episodes_db = db.get_series_episodes(series_id)
        
        # 4. Legge il NAS (se esiste) per calcolare il peso in GB e NOME dei file
        import os, re
        file_sizes = {}
        file_names = {} # <--- NUOVO: Raccoglitore nomi file
        video_exts = {'.mkv', '.mp4', '.avi', '.ts', '.m4v'} # <-- SCUDO ANTI IMMAGINI/SUB
        
        
        if archive_path and os.path.exists(archive_path):
            for root, _, files in os.walk(archive_path):
                folder_season = None
                folder_name = os.path.basename(root)
                folder_match = re.search(r'(?i)(?:stagione|season|serie|s)\s*[._\-]*0*(\d+)', folder_name)
                if folder_match:
                    folder_season = int(folder_match.group(1))

                for f in files:
                    ext = os.path.splitext(f)[1].lower()
                    if ext not in video_exts or 'sample' in f.lower():
                        continue # IGNORA SUB, JPG E SAMPLE
                        
                    s_num = e_num = 0
                    m_std = re.search(r'(?i)[Ss]0*(\d{1,2})[._\-\s]*[Ee]0*(\d{1,3})|0*(\d{1,2})x0*(\d{1,3})', f)
                    if m_std:
                        s_num = int(m_std.group(1) or m_std.group(3))
                        e_num = int(m_std.group(2) or m_std.group(4))
                    elif folder_season is not None:
                        m_ep = re.search(r'(?i)(?:ep|episodio|episode|e)[._\-\s]*0*(\d{1,3})|^0*(\d{1,3})(?:[\s\.\-]|$)', f)
                        if m_ep:
                            s_num = folder_season
                            e_num = int(m_ep.group(1) or m_ep.group(2))
                    
                    if s_num > 0 and e_num > 0:
                        file_path = os.path.join(root, f)
                        try:
                            size = os.path.getsize(file_path)
                            # Prende il file più pesante e ne salva il nome
                            if size > file_sizes.get((s_num, e_num), 0):
                                file_sizes[(s_num, e_num)] = size
                                file_names[(s_num, e_num)] = f # <--- Salva il nome fisico
                        except: pass
        
        # 4b. Legge la cartella di download locale per lo stato "Scaricato"
        local_sizes = {}
        from core.config import Config as _CoreCfg2
        _local_cfg = _CoreCfg2()
        local_dir = getattr(_local_cfg, 'libtorrent_dir', '').strip()
        if local_dir and os.path.exists(local_dir) and local_dir != archive_path:
            for root, _, files in os.walk(local_dir):
                folder_name = os.path.basename(root)
                folder_match = re.search(r'(?i)(?:stagione|season|serie|s)\s*[._\-]*0*(\d+)', folder_name)
                folder_season = int(folder_match.group(1)) if folder_match else None
                for f in files:
                    ext = os.path.splitext(f)[1].lower()
                    if ext not in video_exts or 'sample' in f.lower():
                        continue
                    s_num = e_num = 0
                    m_std = re.search(r'(?i)[Ss]0*(\d{1,2})[._\-\s]*[Ee]0*(\d{1,3})|0*(\d{1,2})x0*(\d{1,3})', f)
                    if m_std:
                        s_num = int(m_std.group(1) or m_std.group(3))
                        e_num = int(m_std.group(2) or m_std.group(4))
                    elif folder_season is not None:
                        m_ep = re.search(r'(?i)(?:ep|episodio|episode|e)[._\-\s]*0*(\d{1,3})|^0*(\d{1,3})(?:[\s\.\-]|$)', f)
                        if m_ep:
                            s_num = folder_season
                            e_num = int(m_ep.group(1) or m_ep.group(2))
                    if s_num > 0 and e_num > 0:
                        try:
                            size = os.path.getsize(os.path.join(root, f))
                            if size > local_sizes.get((s_num, e_num), 0):
                                local_sizes[(s_num, e_num)] = size
                        except: pass
        
        # 5. Struttura i dati unendo TMDB, DB e NAS
        seasons_data = {}
        
        # Inserisce gli episodi previsti da TMDB come "Mancanti" di base
        for s_num, ep_count in tmdb_seasons.items():
            seasons_data[s_num] = {}
            for e_num in range(1, ep_count + 1):
                seasons_data[s_num][e_num] = {
                    'status': 'Mancante', 'id': None, 'title': f"Episodio {e_num}", 
                    'score': 0, 'size': file_sizes.get((s_num, e_num), 0),
                    'file_name': file_names.get((s_num, e_num), '') # <--- Inserisce il nome
                }

        # Sovrascrive con i dati reali del Database
        for ep in episodes_db:
            s_num, e_num = ep['season'], ep['episode']
            if e_num <= 0: continue # Ulteriore scudo per nascondere i Season Pack

            _fs_val = file_sizes.get((s_num, e_num), 0)
            _ls_val = local_sizes.get((s_num, e_num), 0)
            if s_num not in seasons_data: seasons_data[s_num] = {}
            if e_num not in seasons_data[s_num]:
                seasons_data[s_num][e_num] = {'size': 0, 'file_name': ''}
                
            seasons_data[s_num][e_num].update({
                'id': ep['id'],
                'status': (
                    'NAS'        if file_sizes.get((s_num, e_num), 0) > 0 else
                    'Scaricato'  if local_sizes.get((s_num, e_num), 0) > 0 else
                    'In DB'      if ep['downloaded_at'] else
                    'In DB'      if ep['magnet_link'] else
                    'Mancante'
                ),
                'title': ep['title'],
                'score': ep['quality_score'],
                'size': file_sizes.get((s_num, e_num), 0),
                'file_name': file_names.get((s_num, e_num), ''),
                'downloaded_at': ep['downloaded_at']
            })

        # Raccoglie i feed matches per episodi non ancora scaricati
        # (usato per lo stato "In feed")
        try:
            c_fm = db.conn.cursor()
            c_fm.execute('''
                SELECT DISTINCT season, episode FROM episode_feed_matches
                WHERE series_id=?
            ''', (series_id,))
            feed_match_set = {(r['season'], r['episode']) for r in c_fm.fetchall()}
        except Exception as e:
            logger.debug(f"feed_match_set: {e}")
            feed_match_set = set()

        # Imposta lo stato "In feed" per episodi Mancanti che hanno feed matches
        for s_num, eps in seasons_data.items():
            for e_num, ep_info in eps.items():
                if ep_info['status'] == 'Mancante' and (s_num, e_num) in feed_match_set:
                    ep_info['status'] = 'In feed'
                # Aggiunge flag per mostrare il pulsante feed_matches
                ep_info['has_feed_matches'] = (s_num, e_num) in feed_match_set

        # Controlla i torrent attivi nel client per marcare episodi "In scarico"
        # anche se aggiunti manualmente (non presenti nel DB di EXTTO)
        try:
            lt_resp = requests.get(f'http://127.0.0.1:{get_engine_port()}/api/torrents', timeout=3)
            if lt_resp.ok:
                _lt_data = lt_resp.json()
                # Il motore può restituire {'torrents': [...]} oppure direttamente [...]
                if isinstance(_lt_data, dict):
                    active_torrents = _lt_data.get('torrents', [])
                    if isinstance(active_torrents, dict):
                        active_torrents = list(active_torrents.values())
                elif isinstance(_lt_data, list):
                    active_torrents = _lt_data
                else:
                    active_torrents = []
                from core.models import normalize_series_name as _nsn
                norm_series = _nsn(series_name)
                for t in active_torrents:
                    t_name = t.get('name', '') or ''
                    # Salta torrent già completati
                    # NOTA: progress è 0-100 (non 0-1), state può essere 'seeding_t'/'finished_t'
                    progress = t.get('progress', 0)
                    state    = t.get('state', '')
                    if progress >= 100.0 or 'seeding' in state or 'finished' in state:
                        continue
                    # Prova a parsare S##E## dal nome del torrent
                    m_ep = re.search(r'(?i)[Ss]0*(\d{1,2})[._\-\s]*[Ee]0*(\d{1,3})', t_name)
                    if not m_ep:
                        continue
                    t_season  = int(m_ep.group(1))
                    t_episode = int(m_ep.group(2))
                    # Estrae la parte prima di S##E##, sostituisce punti/underscore con spazi
                    raw_prefix = re.sub(r'(?i)[Ss]\d+[Ee]\d+.*', '', t_name).strip(' ._-')
                    raw_prefix = re.sub(r'[._]', ' ', raw_prefix).strip()
                    norm_t = _nsn(raw_prefix)
                    # Usa _series_name_matches (gestisce possessivo) + fallback sottostringa
                    # per varianti con anno (es. "Brilliant Minds 2024" vs "Brilliant Minds")
                    from core.models import _series_name_matches as _snm
                    # Rimuove trattini per gestire "Monarch - Legacy" vs "Monarch Legacy"
                    norm_series_nd = norm_series.replace('-', ' ').replace('  ', ' ').strip()
                    norm_t_nd      = norm_t.replace('-', ' ').replace('  ', ' ').strip()
                    _matched = (_snm(norm_series, norm_t) or
                                _snm(norm_series_nd, norm_t_nd) or
                                norm_series_nd in norm_t_nd or
                                norm_t_nd in norm_series_nd)
                    if not _matched:
                        continue
                    # Marca l'episodio come In scarico se non è già Scaricato
                    ep_info = seasons_data.get(t_season, {}).get(t_episode)
                    if ep_info and ep_info['status'] not in ('Scaricato', 'NAS'):
                        ep_info['status'] = 'In scarico'
        except Exception as e:
            logger.debug(f"downloading state: {e}")
            pass  # Se libtorrent non risponde, non bloccare il caricamento

        # Prepara l'output formattato per il frontend
        output_seasons = []
        for s_num in sorted(seasons_data.keys(), reverse=True):
            eps = []
            total_size = 0
            downloaded_count = 0
            total_eps = len(seasons_data[s_num])
            
            for e_num in sorted(seasons_data[s_num].keys()):
                ep_info = seasons_data[s_num][e_num]
                total_size += ep_info['size']
                if ep_info['status'] in ['Scaricato', 'NAS']: downloaded_count += 1
                eps.append({'episode': e_num, **ep_info})
                
            output_seasons.append({
                'season': s_num,
                'monitored': s_num not in ignored_seasons, # <--- Aggiunto!
                'total_episodes': total_eps,
                'downloaded_episodes': downloaded_count,
                'total_size_bytes': total_size,
                'episodes': eps
            })

        # --- NUOVO: CONTROLLO COMPLETEZZA "AL VOLO" (Retroattivo) ---
        is_completed = False
        try:
            # Assicura che la colonna esista
            try: c.execute("ALTER TABLE series ADD COLUMN is_completed BOOLEAN DEFAULT 0"); db.conn.commit()
            except: pass
            
            c.execute("SELECT is_completed FROM series WHERE id=?", (series_id,))
            r_comp = c.fetchone()
            is_completed = bool(r_comp[0]) if r_comp else False
            
            # Se TMDB dice che è finita e non era segnata come completa...
            if not is_completed and meta.get('status') in ['Ended', 'Canceled']:
                # L'oggetto output_seasons ha già contato le stagioni "Monitorate" (il segnalibro acceso!)
                tot_exp = sum(s['total_episodes'] for s in output_seasons if s['monitored'])
                tot_down = sum(s['downloaded_episodes'] for s in output_seasons if s['monitored'])
                        
                if tot_exp > 0 and tot_down >= tot_exp:
                    # Promossa! Registra nel DB!
                    c.execute("UPDATE series SET is_completed=1 WHERE id=?", (series_id,))
                    db.conn.commit()
                    is_completed = True
        except Exception as e:
            logger.debug(f"is_completed libtorrent: {e}")
            pass
        # Calcola is_ended dal DB (aggiornato ogni ciclo da extto3.py)
        is_ended = False
        try:
            c.execute("SELECT is_ended FROM series WHERE id=?", (series_id,))
            r_end = c.fetchone()
            if r_end:
                is_ended = bool(r_end[0])
            # Fallback: se TMDB dice Ended/Canceled anche se il DB non è ancora aggiornato
            if not is_ended and meta.get('status') in ['Ended', 'Canceled']:
                is_ended = True
                c.execute("UPDATE series SET is_ended=1 WHERE id=?", (series_id,))
                db.conn.commit()
        except Exception as e:
            logger.debug(f"is_ended update: {e}")

        return jsonify({
            'success':      True,
            'series_name':  series_name,
            'archive_path': archive_path,
            'meta':         meta,
            'seasons':      output_seasons,
            'is_completed': is_completed,
            'is_ended':     is_ended,
            'tmdb_status':  meta.get('status', ''),
        })
    except Exception as e:
        import traceback, logging as _l
        _l.getLogger('extto.web').error(f"❌ Errore extto-details: {e}\n{traceback.format_exc()}")
        return jsonify({'success': False, 'error': str(e)}), 500

@app.route('/api/series/by-name/<path:series_name>', methods=['DELETE'])
def delete_series_by_name(series_name):
    """Elimina una serie per nome — usato quando l'ID non è disponibile."""
    try:
        import sqlite3 as _sq_n
        conn_n = _sq_n.connect(DB_FILE)
        conn_n.row_factory = _sq_n.Row
        row_n = conn_n.execute(
            "SELECT id FROM series WHERE LOWER(name)=LOWER(?)", (series_name,)
        ).fetchone()
        conn_n.close()

        if row_n:
            # Ha un ID — usa il metodo standard
            db.delete_series(row_n['id'])
            logger.info(f"🗑️ Series deleted by name: '{series_name}' (id={row_n['id']})")
        else:
            logger.warning(f"delete_series_by_name: '{series_name}' not found in operational DB")

        return jsonify({'success': True})
    except Exception as e:
        logger.error(f"delete_series_by_name: {e}")
        return jsonify({'success': False, 'error': str(e)}), 500


@app.route('/api/series/<int:series_id>', methods=['DELETE'])
def delete_series(series_id):
    """Elimina una serie dal DB operativo e dalla configurazione."""
    try:
        # 1. Leggi il nome prima di eliminare (serve per pulire extto_config.db)
        import sqlite3 as _sq_del
        conn_del = _sq_del.connect(DB_FILE)
        conn_del.row_factory = _sq_del.Row
        row_del = conn_del.execute("SELECT name FROM series WHERE id=?", (series_id,)).fetchone()
        series_name = row_del['name'] if row_del else None
        conn_del.close()

        # 2. Elimina da extto_series.db (episodi + serie)
        db.delete_series(series_id)
        _delete_poster('series', series_id)

        # 3. Elimina anche da extto_config.db (tabella interna serie config)
        if series_name:
            try:
                migrated = _cdb.get_setting('_migrated_series', [])
                if isinstance(migrated, list):
                    migrated = [s for s in migrated if s.get('name') != series_name]
                    _cdb.set_setting('_migrated_series', migrated)
            except Exception as ce:
                logger.debug(f"delete_series config_db: {ce}")

        logger.info(f"🗑️ Series deleted: '{series_name}' (id={series_id})")
        return jsonify({'success': True})
    except Exception as e:
        logger.error(f"delete_series: {e}")
        return jsonify({'success': False, 'error': str(e)}), 500

@app.route('/api/series/<int:sid>/rename', methods=['POST'])
def rename_series(sid):
    """Rinomina una serie nel DB"""
    try:
        new_name = (request.json or {}).get('new_name')
        if not new_name: return jsonify({'error': 'Name empty'}), 400
        c = db.conn.cursor()
        c.execute('UPDATE series SET name=? WHERE id=?', (new_name, sid))
        db.conn.commit()
        return jsonify({'success': True})
    except Exception as e: return jsonify({'error': str(e)}), 500

@app.route('/api/episodes/<int:episode_id>', methods=['DELETE'])
def delete_episode(episode_id):
    """Elimina un episodio"""
    try:
        db.delete_episode(episode_id)
        return jsonify({'success': True})
    except Exception as e:
        logger.exception(f"❌ Error delete_episode {episode_id}: {e}")
        return jsonify({'success': False, 'error': str(e)}), 500

@app.route('/api/episodes/<int:episode_id>/redownload', methods=['POST'])
def mark_episode_redownload(episode_id):
    """Marca episodio per riscarica (abbassa score)"""
    try:
        if not db.conn:
            return jsonify({'success': False, 'error': 'Database non disponibile'}), 500
        
        c = db.conn.cursor()
        # Abbassa drasticamente lo score e azzera l'hash per evitare il blocco su duplicate_hash
        c.execute(r"UPDATE episodes SET quality_score = 0, magnet_hash = NULL WHERE id=?", (episode_id,))
        db.conn.commit()
        
        return jsonify({'success': True, 'message': 'Episodio marcato per riscarica (score=0, hash azzerato)'})
    except Exception as e:
        return jsonify({'success': False, 'error': str(e)}), 500

@app.route('/api/episodes/<int:episode_id>/ignore', methods=['POST'])
def ignore_episode(episode_id):
    """Ignora episodio (alza score per evitare upgrade)"""
    try:
        if not db.conn:
            return jsonify({'success': False, 'error': 'Database non disponibile'}), 500
        
        c = db.conn.cursor()
        c.execute("UPDATE episodes SET quality_score = quality_score + 10000 WHERE id=?", (episode_id,))
        db.conn.commit()
        
        return jsonify({'success': True, 'message': 'Episodio ignorato'})
    except Exception as e:
        return jsonify({'success': False, 'error': str(e)}), 500

@app.route('/api/episodes/<int:episode_id>/force-missing', methods=['POST'])
def force_missing_episode(episode_id):
    """Forza episodio come mancante: elimina la riga dal DB così da essere considerato da gap-filling/ricerche."""
    try:
        if not db.conn:
            return jsonify({'success': False, 'error': 'Database non disponibile'}), 500
        c = db.conn.cursor()
        # Recupera info per pulizia completa
        c.execute(r"SELECT series_id, season, episode FROM episodes WHERE id=?", (episode_id,))
        row = c.fetchone()
        c.execute(r"DELETE FROM episodes WHERE id=?", (episode_id,))
        # Elimina anche da episode_archive_presence così check_series non blocca il re-download
        if row:
            c.execute(
                "DELETE FROM episode_archive_presence WHERE series_id=? AND season=? AND episode=?",
                (row['series_id'], row['season'], row['episode'])
            )
        db.conn.commit()
        return jsonify({'success': True, 'message': 'Episodio forzato come mancante (rimosso dal DB)'})
    except Exception as e:
        return jsonify({'success': False, 'error': str(e)}), 500

@app.route('/api/movies')
def get_movies():
    """Lista film"""
    movies = db.get_all_movies()
    return jsonify(movies)
    
@app.route('/api/movies/details/<path:movie_name>', methods=['GET'])
def get_radarr_details(movie_name):
    """Genera i dettagli completi per la vista stile Radarr dei Film."""
    try:
        import urllib.parse
        import requests
        movie_name = urllib.parse.unquote(movie_name)
        
        cfg = parse_movies_config()
        mov_cfg = next((m for m in cfg if m['name'].lower() == movie_name.lower()), None)
        
        c = db.conn.cursor()
        c.execute('SELECT * FROM movies WHERE name=? ORDER BY id DESC LIMIT 1', (movie_name,))
        row = c.fetchone()
        mov_db = dict(row) if row else None
        
        if not mov_cfg and not mov_db: return jsonify({'error': 'Film non trovato'}), 404
            
        year = (mov_cfg.get('year') if mov_cfg else (mov_db.get('year') if mov_db else '')) or ''
        
        from core.config import Config as CoreConfig
        core_cfg = CoreConfig()
        api_key = getattr(core_cfg, 'tmdb_api_key', '').strip()
        
        meta = {'poster': '', 'backdrop': '', 'overview': 'Nessuna trama disponibile.', 'year': year, 'tmdb_id': None, 'title': movie_name}
        
        if api_key:
            tmdb_lang = getattr(core_cfg, 'tmdb_language', 'it-IT').strip()
            search_url = f"https://api.themoviedb.org/3/search/movie?api_key={api_key}&query={urllib.parse.quote(movie_name)}&language={tmdb_lang}"
            if year: search_url += f"&year={year}"
            
            try:
                res = requests.get(search_url, timeout=5).json()
                if res.get('results'):
                    first = res['results'][0]
                    meta['tmdb_id'] = first.get('id')
                    meta['poster'] = first.get('poster_path', '')
                    meta['backdrop'] = first.get('backdrop_path', '')
                    meta['overview'] = first.get('overview', meta['overview'])
                    meta['year'] = first.get('release_date', '')[:4] if first.get('release_date') else year
                    meta['title'] = first.get('title', movie_name)
                    if mov_db and mov_db.get('id'):
                        _save_poster('movie', mov_db['id'], meta['poster'])
            except Exception as e:
                _l.debug(f"File check error: {e}")
        
        status = 'Scaricato' if (mov_db and mov_db.get('magnet_link')) else 'In Ricerca'
        if not mov_cfg: status = 'Solo Storico'
        elif not mov_cfg.get('enabled', True): status = 'In Pausa'

        has_feed = db.has_movie_feed_matches(movie_name)

        return jsonify({'success': True, 'name': movie_name, 'meta': meta, 'status': status,
                        'db_info': mov_db, 'cfg_info': mov_cfg,
                        'movie_name': movie_name, 'has_feed': has_feed})
    except Exception as e:
        return jsonify({'success': False, 'error': str(e)}), 500    

@app.route('/api/movies/feed-status')
def get_movies_feed_status():
    """Ritorna lista nomi film che hanno feed matches (per colorare l'icona nella lista)."""
    try:
        c = db.conn.cursor()
        c.execute("SELECT DISTINCT movie_name FROM movie_feed_matches")
        names = [row['movie_name'] for row in c.fetchall()]
        return jsonify(names)
    except Exception as e:
        return jsonify([]), 500

@app.route('/api/movies/feed-matches')
def get_movie_feed_matches_api():
    """Ritorna i feed matches per un film cercato per nome."""
    try:
        name = request.args.get('name', '').strip()
        if not name:
            return jsonify([])
        matches = db.get_movie_feed_matches(name)
        return jsonify(matches)
    except Exception as e:
        logger.exception(f"Error get_movie_feed_matches_api: {e}")
        return jsonify([]), 500

@app.route('/api/movies/<int:movie_id>', methods=['DELETE'])
def delete_movie(movie_id):
    """Elimina un film"""
    try:
        db.delete_movie(movie_id)
        _delete_poster('movie', movie_id)
        return jsonify({'success': True})
    except Exception as e:
        logger.exception(f"❌ Error delete_movie {movie_id}: {e}")
        return jsonify({'success': False, 'error': str(e)}), 500

@app.route('/api/movies/seen')
def movies_seen():
    """Tutti i film visti nei feed RSS (movie_feed_seen), con paginazione, filtro e ordinamento."""
    try:
        page      = int(request.args.get('page', 0))
        q         = request.args.get('q', '').strip()
        sort      = request.args.get('sort', 'found_at')
        direction = request.args.get('dir', 'desc')
        from core.database import Database as _CoreDB
        result    = _CoreDB().get_movies_seen(page=page, q=q, sort=sort,
                                              direction=direction, per_page=50)
        return jsonify(result)
    except Exception as e:
        logger.exception(f"❌ movies_seen: {e}")
        return jsonify({'items': [], 'total': 0, 'pages': 1}), 500

_mfs_migrated = False

@app.route('/api/movies/seen/grouped')
def movies_seen_grouped():
    """Film dai feed raggruppati per nome, con paginazione."""
    global _mfs_migrated
    try:
        page      = int(request.args.get('page', 0))
        q         = request.args.get('q', '').strip()
        sort      = request.args.get('sort', 'found_at')
        direction = request.args.get('dir', 'desc')
        from core.database import Database as _CoreDB
        _db = _CoreDB()
        if not _mfs_migrated:
            _db.migrate_movie_feed_names()
            _mfs_migrated = True
        result = _db.get_movies_seen_grouped(page=page, q=q, sort=sort,
                                             direction=direction, per_page=50)
        result['pending'] = _db.get_mfs_pending_count()
        return jsonify(result)
    except Exception as e:
        logger.exception(f"❌ movies_seen_grouped: {e}")
        return jsonify({'groups': [], 'total': 0, 'pages': 1}), 500

@app.route('/api/movies/seen/by-name')
def movies_seen_by_name():
    """Tutte le release di un film specifico (legacy: lookup per nome)."""
    try:
        name = request.args.get('name', '').strip()
        if not name:
            return jsonify([])
        from core.database import Database as _CoreDB
        items = _CoreDB().get_movies_seen_by_name(name)
        return jsonify(items)
    except Exception as e:
        logger.exception(f"❌ movies_seen_by_name: {e}")
        return jsonify([]), 500

@app.route('/api/movies/seen/by-key')
def movies_seen_by_key():
    """Tutte le release di un gruppo film (per group_key restituito da /grouped)."""
    try:
        key = request.args.get('key', '').strip()
        if not key:
            return jsonify([])
        from core.database import Database as _CoreDB
        db = _CoreDB()
        if key.startswith('tmdb:'):
            try:
                tmdb_id = int(key[5:])
                items = db.get_movies_seen_by_tmdb_id(tmdb_id)
            except ValueError:
                items = []
        else:
            items = db.get_movies_seen_by_condensed_key(key)
        return jsonify(items)
    except Exception as e:
        logger.exception(f"❌ movies_seen_by_key: {e}")
        return jsonify([]), 500

@app.route('/api/series/seen/grouped')
def series_seen_grouped():
    """Serie TV dai feed raggruppate per nome, con paginazione."""
    try:
        page      = int(request.args.get('page', 0))
        q         = request.args.get('q', '').strip()
        sort      = request.args.get('sort', 'found_at')
        direction = request.args.get('dir', 'desc')
        from core.database import Database as _CoreDB
        _db = _CoreDB()
        result = _db.get_series_seen_grouped(page=page, q=q, sort=sort,
                                             direction=direction, per_page=50)
        result['pending'] = _db.get_sfs_pending_count()
        return jsonify(result)
    except Exception as e:
        logger.exception(f"❌ series_seen_grouped: {e}")
        return jsonify({'groups': [], 'total': 0, 'pages': 1}), 500

@app.route('/api/series/seen/by-key')
def series_seen_by_key():
    """Tutte le release di un gruppo serie (per group_key restituito da /grouped)."""
    try:
        key = request.args.get('key', '').strip()
        if not key:
            return jsonify([])
        from core.database import Database as _CoreDB
        db = _CoreDB()
        if key.startswith('tmdb:'):
            try:
                tmdb_id = int(key[5:])
                items = db.get_series_seen_by_tmdb_id(tmdb_id)
            except ValueError:
                items = []
        else:
            items = db.get_series_seen_by_condensed_key(key)
        return jsonify(items)
    except Exception as e:
        logger.exception(f"❌ series_seen_by_key: {e}")
        return jsonify([]), 500

@app.route('/api/archive')
def get_archive():
    """Ricerca nell'archivio"""
    query = request.args.get('q', '')
    page = int(request.args.get('page', 0))
    limit = int(request.args.get('limit', 50))
    offset = page * limit
    
    items, total = db.search_archive(query, offset, limit)
    
    return jsonify({
        'items': items,
        'total': total,
        'page': page,
        'pages': (total + limit - 1) // limit
    })

@app.route('/api/archive/delete', methods=['POST'])
def archive_batch_delete():
    """Elimina una lista di ID dall'archivio."""
    try:
        ids = (request.json or {}).get('ids', [])
        if not ids:
            return jsonify({'success': False, 'error': 'Nessun ID fornito'}), 400
        if not os.path.exists(ARCHIVE_FILE):
            return jsonify({'success': False, 'error': 'Archivio non trovato'}), 404
        with sqlite3.connect(ARCHIVE_FILE) as conn:
            c = conn.cursor()
            placeholders = ','.join(['?'] * len(ids))
            c.execute(f"DELETE FROM archive WHERE id IN ({placeholders})", ids)
            deleted = c.rowcount
        return jsonify({'success': True, 'deleted': deleted})
    except Exception as e:
        return jsonify({'success': False, 'error': str(e)}), 500


@app.route('/api/archive/batch-download', methods=['POST'])
def archive_batch_download():
    """Restituisce i magnet link per una lista di ID (il client li invia uno per uno)."""
    try:
        ids = (request.json or {}).get('ids', [])
        if not ids:
            return jsonify({'success': False, 'error': 'Nessun ID fornito'}), 400
        if not db.conn_archive:
            return jsonify({'success': False, 'error': 'Archivio non disponibile'}), 503
        c = db.conn_archive.cursor()
        placeholders = ','.join(['?'] * len(ids))
        c.execute(f"SELECT id, title, magnet FROM archive WHERE id IN ({placeholders})", ids)
        rows = [{'id': r[0], 'title': r[1], 'magnet': r[2]} for r in c.fetchall()]
        return jsonify({'success': True, 'items': rows})
    except Exception as e:
        return jsonify({'success': False, 'error': str(e)}), 500


@app.route('/api/blocklist')
def get_blocklist():
    """Lista delle release fallite (magnet morto, download stallato, errore,
    o segnalate manualmente) mai più riproposte da check_series()/check_movie()."""
    try:
        from core.database import Database as _CoreDB
        with _CoreDB() as _cdb:
            items = _cdb.list_blocklist()
        return jsonify({'success': True, 'items': items})
    except Exception as e:
        logger.error(f'get_blocklist: {e}')
        return jsonify({'success': False, 'error': str(e)}), 500


@app.route('/api/blocklist/<hash_val>/remove', methods=['POST'])
def remove_blocklist_entry(hash_val):
    """Rimuove una voce dalla blocklist — la release torna riproponibile."""
    try:
        from core.database import Database as _CoreDB
        with _CoreDB() as _cdb:
            removed = _cdb.remove_from_blocklist(hash_val)
        return jsonify({'success': True, 'removed': removed})
    except Exception as e:
        logger.error(f'remove_blocklist_entry: {e}')
        return jsonify({'success': False, 'error': str(e)}), 500


@app.route('/api/torrents/<hash_val>/mark_failed', methods=['POST'])
def mark_torrent_failed(hash_val):
    """Segna manualmente un torrent come fallito: stessa gestione automatica
    (blocklist + rollback episodes/movies + rimozione + notifica) usata per
    stalli/magnet morti/errori, ma innescata a mano dall'utente."""
    try:
        from core.clients.libtorrent import LibtorrentClient
        h = LibtorrentClient._find(hash_val)
        if not h:
            return jsonify({'success': False, 'error': 'Torrent non trovato'}), 404
        LibtorrentClient._handle_download_failure(h, 'manual')
        return jsonify({'success': True})
    except Exception as e:
        logger.error(f'mark_torrent_failed: {e}')
        return jsonify({'success': False, 'error': str(e)}), 500


@app.route('/api/config')
def get_config():
    """Configurazione completa"""
    try:
        config = parse_series_config()
        movies = parse_movies_config()
        return jsonify({
            'settings': config['settings'],
            'series': config['series'],
            'movies': movies
        })
    except Exception as e:
        logger.error(f'get_config: {e}')
        return jsonify({'error': str(e)}), 500

@app.route('/api/config', methods=['POST'])
def save_full_config():
    """Salva l'intero config in una sola operazione atomica.
    
    Riceve {settings, series} e sovrascrive completamente series_config.txt.
    Le chiavi lista (url, blacklist, wantedlist, archive_root, archive_cred)
    devono essere incluse nel payload — se assenti vengono preservate dal file
    corrente per sicurezza.
    """
    try:
        data = request.json or {}
        new_settings = data.get('settings', {})
        new_series   = data.get('series',   None)

        with _config_write_lock:
            # Leggi il file corrente solo per le chiavi lista se non fornite
            current = parse_series_config()
            LIST_KEYS = {'url', 'blacklist', 'wantedlist', 'content_filter', 'archive_root', 'archive_cred', 'custom_score'}
            for k in current['settings']:
                # Protegge le liste e i punteggi dall'essere cancellati se non presenti nel payload
                if k in LIST_KEYS or k.startswith('score_'):
                    if k not in new_settings:
                        new_settings[k] = current['settings'][k]

            config = {
                'settings': new_settings,
                'series':   new_series if new_series is not None else current['series'],
            }
            if save_series_config(config):
                try:
                    from core.config import Config as _Cfg; _Cfg.invalidate()
                except Exception:
                    pass
                return jsonify({'success': True})
        return jsonify({'success': False, 'error': 'Errore salvataggio'}), 500
    except Exception as e:
        logger.error(f"save_full_config: {e}")
        return jsonify({'success': False, 'error': str(e)}), 500

@app.route('/api/config/series', methods=['POST'])
def update_series_config():
    """Aggiorna configurazione serie. sync_delete=True elimina le serie non in lista."""
    try:
        data        = request.json or {}
        new_series  = data.get('series', [])
        sync_delete = bool(data.get('sync_delete', False))

        with _config_write_lock:
            # Salva settings (invariati)
            try:
                current = parse_series_config()
                _cdb.set_settings_bulk(current.get('settings', {}))
            except Exception as e:
                logger.error(f"update_series_config settings: {e}")

            # Salva serie con sync_delete opzionale
            try:
                _save_series_to_db(new_series, sync_delete=sync_delete)
            except Exception as e:
                logger.error(f"update_series_config db: {e}")
                return jsonify({'success': False, 'error': str(e)}), 500

        try:
            from core.config import Config as _Cfg; _Cfg.invalidate()
        except Exception:
            pass
        return jsonify({'success': True})
    except Exception as e:
        return jsonify({'success': False, 'error': str(e)}), 500

@app.route('/api/config/movies', methods=['POST'])
def update_movies_config():
    """Aggiorna configurazione film"""
    try:
        data = request.json or {}
        movies = data.get('movies', [])
        
        if save_movies_config(movies):
            try:
                from core.config import Config as _Cfg; _Cfg.invalidate()
            except Exception:
                pass
            return jsonify({'success': True})
        else:
            return jsonify({'success': False, 'error': 'Errore salvataggio'}), 500
    except Exception as e:
        return jsonify({'success': False, 'error': str(e)}), 500

@app.route('/api/config/settings', methods=['POST'])
def update_settings():
    """Aggiorna impostazioni generali."""
    try:
        data = request.json or {}
        config = parse_series_config()
        new_settings = data.get('settings', {})

        # Validazione porte: devono essere nel range valido e diverse tra loro
        for port_key, default_val in [('web_port', 5000), ('engine_port', 8889)]:
            if port_key in new_settings:
                try:
                    p = int(new_settings[port_key])
                    if not (1024 <= p <= 65535):
                        return jsonify({'success': False,
                            'error': f'{port_key}: porta {p} non valida (range 1024-65535)'}), 400
                    new_settings[port_key] = str(p)
                except (ValueError, TypeError):
                    return jsonify({'success': False,
                        'error': f'{port_key}: valore non numerico'}), 400
        if 'web_port' in new_settings and 'engine_port' in new_settings:
            if new_settings['web_port'] == new_settings['engine_port']:
                return jsonify({'success': False,
                    'error': 'web_port e engine_port non possono essere uguali'}), 400

        LIST_KEYS = {'url', 'blacklist', 'wantedlist', 'content_filter', 'archive_root', 'archive_cred', 'custom_score'}
        # Merge: tutti i setting esistenti come base + overlay dei nuovi valori.
        # Per le chiavi lista (JSON array nel DB), non sovrascrivere con valori stringa dall'UI.
        merged = {**config['settings'], **new_settings}
        for k in LIST_KEYS:
            if k in config['settings'] and isinstance(config['settings'][k], list):
                if not isinstance(merged.get(k), list):
                    merged[k] = config['settings'][k]
        config['settings'] = merged

        if save_series_config(config):
            try:
                from core.config import Config as _Cfg; _Cfg.invalidate()
            except Exception:
                pass
            return jsonify({'success': True})
        else:
            return jsonify({'success': False, 'error': 'Errore salvataggio'}), 500
    except Exception as e:
        return jsonify({'success': False, 'error': str(e)}), 500
        
# --- NUOVO: Accumulatore di traffico isolato solo per libtorrent ---
_torrent_traffic = {'dl': 0, 'ul': 0}

def _traffic_monitor():
    """Sonda il motore torrent in background per accumulare i byte esatti (escludendo il traffico web)"""
    import requests
    import time
    while True:
        try:
            res = requests.get(f'http://127.0.0.1:{get_engine_port()}/api/torrents/stats', timeout=2)
            if res.status_code == 200:
                data = res.json()
                # Aggiunge (Velocità * 2 secondi) = Byte esatti transitati per i torrent
                _torrent_traffic['dl'] += data.get('dl_rate', 0) * 2
                _torrent_traffic['ul'] += data.get('ul_rate', 0) * 2
        except Exception as e:
            logger.debug(f"torrent traffic poll: {e}")
            pass
        time.sleep(2)

# Avvia thread di supporto solo nel processo principale (evita doppio avvio con Werkzeug reloader)
if os.environ.get('WERKZEUG_RUN_MAIN') != 'false':
    Thread(target=tail_log_file, daemon=True).start()
    threading.Thread(target=_traffic_monitor, daemon=True).start()

import threading

@app.route('/api/system/stats')
def system_stats():
    """Restituisce l'utilizzo di CPU, RAM, Disco e Traffico di Rete Totale."""
    try:
        import psutil
        import os
        import time
        
        # 1. Trova i processi EXTTO (questo server web + eventuale motore extto3.py)
        current_pid = os.getpid()
        extto_pids = [current_pid]
        
        for p in psutil.process_iter(['pid', 'cmdline']):
            try:
                if p.info['cmdline'] and any('extto3.py' in cmd for cmd in p.info['cmdline']):
                    extto_pids.append(p.info['pid'])
            except Exception:
                pass  # psutil: processo già terminato
        
        cpu_total = 0.0
        ram_total_pct = 0.0
        ram_total_bytes = 0
        oldest_time = time.time()
        
        # Raccogli CPU e RAM per i processi trovati
        for pid in set(extto_pids):
            try:
                proc = psutil.Process(pid)
                cpu_total += proc.cpu_percent(interval=0.05)
                ram_total_pct += proc.memory_percent()
                ram_total_bytes += proc.memory_info().rss
                if proc.create_time() < oldest_time:
                    oldest_time = proc.create_time()
            except Exception:
                pass  # psutil: processo già terminato
        
        # Calcola Uptime (Tempo di attività)
        uptime_sec = int(time.time() - oldest_time)
        days = uptime_sec // 86400
        hours = (uptime_sec % 86400) // 3600
        minutes = (uptime_sec % 3600) // 60
        uptime_str = f"{days}g {hours}h {minutes}m" if days > 0 else f"{hours}h {minutes}m"

        cpu_total = min(cpu_total, 100.0)
        ram_mb = ram_total_bytes / (1024 * 1024)
        disk = psutil.disk_usage(os.getcwd()).percent 
        
        # Calcolo Spazio RAM Disk (se abilitato)
        cfg = parse_series_config()
        settings = cfg.get('settings', {})
        ramdisk_enabled = str(settings.get('libtorrent_ramdisk_enabled', 'no')).lower() in ('yes', 'true', '1')
        ramdisk_dir = settings.get('libtorrent_ramdisk_dir', '').strip()
        ramdisk_pct = 0.0
        ramdisk_used_gb = 0.0
        ramdisk_total_gb = 0.0 # <--- Aggiunto il totale!

        if ramdisk_enabled and ramdisk_dir and os.path.exists(ramdisk_dir):
            try:
                rd_usage = psutil.disk_usage(ramdisk_dir)
                ramdisk_pct = rd_usage.percent
                ramdisk_used_gb = rd_usage.used / (1024**3)
                ramdisk_total_gb = rd_usage.total / (1024**3) # <--- Calcola il totale
            except Exception:
                pass

        # 3. Legge i totali isolati di libtorrent calcolati in background
        tot_dl_bytes = _torrent_traffic['dl']
        tot_ul_bytes = _torrent_traffic['ul']
        
        return jsonify({
            'success': True, 
            'cpu': round(cpu_total, 1), 
            'ram': round(ram_total_pct, 1), 
            'ram_mb': round(ram_mb, 1),
            'disk': round(disk, 1),
            'ramdisk': round(ramdisk_pct, 1),
            'ramdisk_gb': round(ramdisk_used_gb, 2),
            'ramdisk_total_gb': round(ramdisk_total_gb, 2), # <--- Lo inviamo alla grafica
            'uptime': uptime_str,
            'total_dl_bytes': tot_dl_bytes,
            'total_ul_bytes': tot_ul_bytes
        })
    except ImportError:
        return jsonify({'success': False, 'error': 'Libreria psutil mancante'}), 500
    except Exception as e:
        return jsonify({'success': False, 'error': str(e)}), 500
        
@app.route('/api/fetch-url', methods=['POST'])
def fetch_url():
    """Scarica un file .torrent gestendo i redirect verso i magnet link."""
    try:
        data = request.get_json(silent=True) or {}
        url = data.get('url', '').strip()
        
        if url.startswith('magnet:'):
            return jsonify({'success': False, 'is_magnet': True, 'magnet': url})
            
        import requests, base64
        
        # --- FIX: allow_redirects=False impedisce il crash se il tracker rimanda a un magnet ---
        res = requests.get(
            url, timeout=15, verify=False, allow_redirects=False,
            headers={'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64)'}
        )
        
        # Se il server risponde con un redirect (301, 302...), verifichiamo dove punta
        if res.status_code in (301, 302, 303, 307, 308):
            target = res.headers.get('Location', '')
            if target.startswith('magnet:'):
                return jsonify({'success': False, 'is_magnet': True, 'magnet': target})
            # Se è un redirect HTTP normale, lo seguiamo manualmente una volta
            res = requests.get(target, timeout=15, verify=False, headers={'User-Agent': 'Mozilla/5.0'})

        if res.status_code != 200:
            return jsonify({'success': False, 'error': f'Errore Tracker (Status: {res.status_code})'})
            
        b64_data = base64.b64encode(res.content).decode('utf-8')
        filename = 'downloaded.torrent'
        if 'Content-Disposition' in res.headers:
            import re
            m = re.search(r'filename="([^"]+)"', res.headers['Content-Disposition'])
            if m: filename = m.group(1)
            
        return jsonify({'success': True, 'data': b64_data, 'filename': filename})
    except Exception as e:
        logger.error(f"URL download error: {str(e)}")
        return jsonify({'success': False, 'error': str(e)}), 500
        
@app.route('/api/test-notification', methods=['POST'])
def test_notification():
    """Invia una notifica di test a Telegram o Email in base alla configurazione salvata."""
    try:
        config = parse_series_config()
        s = config.get('settings', {})
        success_msgs = []
        
        # Test Telegram
        if str(s.get('notify_telegram', 'no')).lower() == 'yes':
            token = str(s.get('telegram_bot_token', '')).strip()
            chat_id = str(s.get('telegram_chat_id', '')).strip()
            if token and chat_id:
                import urllib.request, json
                msg = "🔔 *Test Notifica EXTTO*\nSe leggi questo messaggio, le notifiche Telegram funzionano correttamente!"
                data = json.dumps({'chat_id': chat_id, 'text': msg, 'parse_mode': 'Markdown'}).encode()
                req = urllib.request.Request(f'https://api.telegram.org/bot{token}/sendMessage', data=data, headers={'Content-Type': 'application/json'})
                urllib.request.urlopen(req, timeout=10)
                success_msgs.append("Telegram")
        
        # Test Email
        if str(s.get('notify_email', 'no')).lower() == 'yes':
            smtp_server = str(s.get('email_smtp', '')).strip()
            email_from = str(s.get('email_from', '')).strip()
            email_to = str(s.get('email_to', '')).strip()
            email_pass = str(s.get('email_password', '')).strip()
            if smtp_server and email_from and email_to and email_pass:
                import smtplib
                from email.mime.text import MIMEText
                msg = MIMEText("Se leggi questa email, le notifiche di EXTTO funzionano correttamente!")
                msg['Subject'] = "🔔 Test Notifica EXTTO"
                msg['From'] = email_from
                msg['To'] = email_to
                port = 587
                if ':' in smtp_server:
                    smtp_server, port_str = smtp_server.split(':')
                    port = int(port_str)
                server = smtplib.SMTP(smtp_server, port, timeout=10)
                server.starttls()
                server.login(email_from, email_pass)
                server.send_message(msg)
                server.quit()
                success_msgs.append("Email")
        
        if success_msgs:
            return jsonify({'success': True, 'message': f'Test inviato con successo via: {", ".join(success_msgs)}'})
        else:
            return jsonify({'success': False, 'error': 'Nessun metodo di notifica configurato o abilitato.'})
    except Exception as e:
        return jsonify({'success': False, 'error': str(e)}), 500        


@app.route('/api/config/check-ports', methods=['POST'])
def check_ports():
    """Verifica se le porte richieste sono disponibili.
    Riceve {web_port, engine_port, current_web_port, current_engine_port}.
    Restituisce {ok: bool, conflicts: [{role, port, pid, process}]}.
    """
    import socket, re, subprocess
    try:
        data        = request.json or {}
        new_web     = int(data.get('web_port', 0))
        new_engine  = int(data.get('engine_port', 0))
        curr_web    = int(data.get('current_web_port', 0))
        curr_engine = int(data.get('current_engine_port', 0))

        def port_in_use(port):
            if not port or port < 1 or port > 65535:
                return None
            with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as s:
                s.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
                try:
                    s.bind(('127.0.0.1', port))
                    return None  # libera
                except OSError:
                    pass
            # Trova il processo che occupa la porta
            pid = None
            process = 'sconosciuto'
            try:
                result = subprocess.run(
                    ['ss', '-tlnp', f'sport = :{port}'],
                    capture_output=True, text=True, timeout=3
                )
                for line in result.stdout.splitlines():
                    if f':{port}' in line and 'pid=' in line:
                        m = re.search(r'pid=(\d+)', line)
                        if m:
                            pid = int(m.group(1))
                            try:
                                with open(f'/proc/{pid}/comm') as pf:
                                    process = pf.read().strip()
                            except Exception:
                                pass
                        break
            except Exception:
                pass
            return {'pid': pid, 'process': process}

        conflicts = []
        for role, new_port, curr_port in [
            ('web_port',    new_web,    curr_web),
            ('engine_port', new_engine, curr_engine),
        ]:
            if new_port and new_port != curr_port:
                result = port_in_use(new_port)
                if result is not None:
                    conflicts.append({
                        'role':    role,
                        'port':    new_port,
                        'pid':     result.get('pid'),
                        'process': result.get('process', 'sconosciuto'),
                    })

        return jsonify({'ok': len(conflicts) == 0, 'conflicts': conflicts})
    except Exception as e:
        return jsonify({'ok': True, 'conflicts': [], 'error': str(e)})


@app.route('/api/config/urls-filters', methods=['POST'])
def update_urls_filters():
    """Aggiorna URL, blacklist e wantedlist"""
    try:
        data = request.json or {}
        config = parse_series_config()
        
        # Aggiorna URL, blacklist, wantedlist, content_filter
        urls = data.get('urls', [])
        blacklist = data.get('blacklist', [])
        wantedlist = data.get('wantedlist', [])
        content_filter = data.get('content_filter', [])

        # Sostituisci gli array
        config['settings']['url'] = urls
        config['settings']['blacklist'] = blacklist
        config['settings']['wantedlist'] = wantedlist
        config['settings']['content_filter'] = content_filter
        
        if save_series_config(config):
            try:
                from core.config import Config as _Cfg; _Cfg.invalidate()
            except Exception:
                pass
            return jsonify({'success': True})
        else:
            return jsonify({'success': False, 'error': 'Errore salvataggio'}), 500
    except Exception as e:
        return jsonify({'success': False, 'error': str(e)}), 500

@app.route('/api/logs')
def get_logs():
    """Ultime righe del log"""
    lines = request.args.get('lines', 100, type=int)
    
    if not os.path.exists(LOG_FILE):
        return jsonify({'logs': []})
    
    with open(LOG_FILE, 'r', encoding='utf-8') as f:
        all_lines = f.readlines()
        return jsonify({'logs': all_lines[-lines:]})

@app.route('/api/recent-downloads')
def get_recent_downloads():
    """Ultimi eventi: download + cicli motore misti, con contatori per le card riepilogo."""
    try:
        events = []

        # 1. EPISODI (inclusi season pack E00)
        if db.conn:
            try:
                c = db.conn.cursor()
                c.execute("""
                    SELECT e.season, e.episode, e.quality_score, e.downloaded_at, s.name as series_name, s.id as series_id
                    FROM episodes e
                    JOIN series s ON e.series_id = s.id
                    WHERE e.downloaded_at IS NOT NULL AND e.episode >= 0
                    ORDER BY e.downloaded_at DESC
                    LIMIT 15
                """)
                for row in c.fetchall():
                    if row['episode'] == 0:
                        ep_str = f"S{row['season']:02d} Pack"
                        ep_type = 'pack'
                    else:
                        ep_str = f"S{row['season']:02d}E{row['episode']:02d}" if row['season'] and row['episode'] else ''
                        ep_type = 'episode'
                    events.append({
                        'kind':  'download',
                        'type':  ep_type,
                        'title': f"{row['series_name']} — {ep_str}" if ep_str else row['series_name'],
                        'series_name': row['series_name'],
                        'series_id': row['series_id'],
                        'poster_url': _poster_url('series', row['series_id']) if os.path.exists(_poster_file('series', row['series_id'])) else '',
                        'quality_score': row['quality_score'],
                        'date':  row['downloaded_at'],
                    })
            except Exception as e:
                logger.error(f"Recent episodes DB error: {e}")

        # 2. FILM
        if db.conn:
            try:
                c = db.conn.cursor()
                c.execute("""
                    SELECT id, name, year, quality_score, downloaded_at, removed_at
                    FROM movies
                    WHERE downloaded_at IS NOT NULL
                    ORDER BY downloaded_at DESC
                    LIMIT 10
                """)
                for row in c.fetchall():
                    year_str = f" ({row['year']})" if row['year'] else ''
                    events.append({
                        'kind':       'download',
                        'type':       'movie',
                        'title':      f"{row['name']}{year_str}",
                        'movie_id':   row['id'],
                        'poster_url': _poster_url('movie', row['id']) if os.path.exists(_poster_file('movie', row['id'])) else '',
                        'quality_score': row['quality_score'],
                        'date':       row['downloaded_at'],
                        'removed':    bool(row['removed_at']),
                    })
            except Exception as e:
                logger.error(f"Recent movies DB error: {e}")

        # 3. FUMETTI (singoli + weekly pack)
        try:
            from core.comics import ComicsDB
            _cdb_c = ComicsDB(os.path.join(BASE_DIR, 'comics.db'))

            # Carica mappa comic_title -> (id, cover_url) per il poster
            import sqlite3 as _sq_cm
            _comics_db_path = os.path.join(BASE_DIR, 'comics.db')
            _comic_cover_map = {}  # title.lower() -> (id, cover_url)
            if os.path.exists(_comics_db_path):
                try:
                    _cm_conn = _sq_cm.connect(_comics_db_path)
                    _cm_conn.row_factory = _sq_cm.Row
                    for _cm_row in _cm_conn.execute("SELECT id, title, cover_url FROM comics_monitored WHERE cover_url != ''").fetchall():
                        _comic_cover_map[_cm_row['title'].lower()] = (_cm_row['id'], _cm_row['cover_url'])
                    _cm_conn.close()
                except Exception as _cme:
                    logger.debug(f"comics cover_map: {_cme}")

            # 3a. Singoli fumetti monitorati
            for ch in _cdb_c.get_history(limit=8):
                if not ch.get('sent_at'):
                    continue
                series = ch.get('comic_title') or ''
                ep     = ch.get('title') or ''
                if series and ep and series.lower() not in ep.lower():
                    display = f"{series} — {ep}"
                elif ep:
                    display = ep
                else:
                    display = series or 'Fumetto'

                # Recupera poster dal fumetto monitorato
                _comic_poster_url = ''
                _cm_key = series.lower() if series else ''
                if _cm_key and _cm_key in _comic_cover_map:
                    _cm_id, _cm_cover = _comic_cover_map[_cm_key]
                    _cm_poster_file = _poster_file('comic', _cm_id)
                    if not os.path.exists(_cm_poster_file) and _cm_cover:
                        try:
                            os.makedirs(POSTERS_DIR, exist_ok=True)
                            _cm_resp = requests.get(_cm_cover, timeout=10)
                            if _cm_resp.status_code == 200:
                                with open(_cm_poster_file, 'wb') as _cmf:
                                    _cmf.write(_cm_resp.content)
                        except Exception as _cme2:
                            logger.debug(f"comic poster download: {_cme2}")
                    if os.path.exists(_cm_poster_file):
                        _comic_poster_url = _poster_url('comic', _cm_id)

                events.append({
                    'kind':          'download',
                    'type':          'comic',
                    'title':         display,
                    'poster_url':    _comic_poster_url,
                    'quality_score': None,
                    'date':          ch['sent_at'],
                })

            # 3b. Weekly pack inviati
            import sqlite3 as _sq_w
            _comics_db = os.path.join(BASE_DIR, 'comics.db')
            if os.path.exists(_comics_db):
                _cw = _sq_w.connect(_comics_db)
                _cw.row_factory = _sq_w.Row
                _weekly = _cw.execute("""
                    SELECT pack_date, sent_at
                    FROM comics_weekly
                    WHERE sent_at IS NOT NULL
                    ORDER BY sent_at DESC
                    LIMIT 5
                """).fetchall()
                _cw.close()
                for w in _weekly:
                    events.append({
                        'kind':          'download',
                        'type':          'comic',
                        'title':         f"Weekly Pack — {w['pack_date']}",
                        'quality_score': None,
                        'date':          w['sent_at'],
                    })
        except Exception as e:
            logger.debug(f"get_comics_history: {e}")

        # 4. CICLI MOTORE (ultimi 20)
        cycles_raw = []
        try:
            from core.database import Database as _CoreDB
            with _CoreDB() as _cdb:
                cycles_raw = _cdb.get_cycle_history(limit=20)
        except Exception as e:
            logger.debug(f"get_cycle_history activity: {e}")

        total_errors = 0
        for cy in cycles_raw:
            try:
                payload = json.loads(cy['payload']) if cy.get('payload') else {}
            except Exception:
                payload = {}
            dl  = payload.get('downloads', 0) or 0
            err = payload.get('errors', 0) or 0
            sc  = payload.get('scraped', 0) or 0
            total_errors += err
            events.append({
                'kind':      'cycle',
                'downloads': dl,
                'scraped':   sc,
                'errors':    err,
                'date':      cy['ts'],
            })

        # Ordina tutto per data decrescente
        events.sort(key=lambda x: x.get('date') or '', reverse=True)

        # Contatori 7gg per le card riepilogo
        from datetime import datetime, timezone, timedelta
        cutoff_7d = (datetime.now(timezone.utc) - timedelta(days=7)).isoformat()
        dl_7d  = sum(1 for e in events if e['kind'] == 'download' and (e.get('date') or '') >= cutoff_7d)
        cy_7d  = sum(1 for e in events if e['kind'] == 'cycle'    and (e.get('date') or '') >= cutoff_7d)
        err_7d = sum(e.get('errors', 0) for e in events if e['kind'] == 'cycle' and (e.get('date') or '') >= cutoff_7d)

        return jsonify({
            'events':   events[:30],
            'stats':    {'downloads_7d': dl_7d, 'cycles_7d': cy_7d, 'errors_7d': err_7d},
            # retrocompatibilità
            'downloads': [e for e in events if e['kind'] == 'download'][:10],
            'found': []
        })

    except Exception as e:
        logger.error(f"General recent-downloads error: {e}")
        return jsonify({'events': [], 'stats': {}, 'downloads': [], 'found': []})


@app.route('/api/last_cycle')
def get_last_cycle():
    """Restituisce info sull'ultimo ciclo per timer prossima esecuzione"""
    try:
        # --- MODIFICA: Leggiamo il timer salvato per passarlo al frontend ---
        cfg = parse_series_config()
        raw_ref = int(cfg.get('settings', {}).get('refresh_interval', 120))
        ref_sec = raw_ref * 60 if raw_ref < 1000 else raw_ref
        try:
            from core.database import Database
            with Database() as db_obj:
                cycles = db_obj.get_cycle_history(limit=1)
            
            if cycles and len(cycles) > 0:
                cycle = cycles[0]
                return jsonify({
                    'generated_at': cycle['ts'],
                    'refresh_interval': ref_sec, # Passa i secondi al frontend
                    'stats': json.loads(cycle['payload']) if cycle.get('payload') else {}
                })
        except (ImportError, Exception) as e:
            print(f"Database import error: {e}")
        
        if os.path.exists(LOG_FILE):
            mtime = os.path.getmtime(LOG_FILE)
            return jsonify({
                'generated_at': datetime.fromtimestamp(mtime).isoformat(),
                'refresh_interval': ref_sec, # Passa i secondi al frontend
                'stats': {}
            })
        
        return jsonify({'generated_at': None, 'refresh_interval': ref_sec, 'stats': {}})
        
    except Exception as e:
        print(f"Error get_last_cycle: {e}")
        return jsonify({'generated_at': None, 'error': str(e)}), 500

@app.route('/api/cycle-history')
def get_cycle_history():
    """Storico degli ultimi N cicli per il grafico nel dashboard"""
    try:
        limit = min(int(request.args.get('limit', 20)), 100)
        from core.database import Database
        with Database() as db_obj:
            cycles = db_obj.get_cycle_history(limit=limit)
        result = []
        for c in reversed(cycles):  # Cronologico (più vecchio prima)
            try:
                payload = json.loads(c['payload']) if c.get('payload') else {}
            except Exception:
                payload = {}  # payload malformato
            result.append({
                'ts': c['ts'],
                'scraped': payload.get('scraped', 0),
                'candidates': payload.get('candidates', 0),
                'downloads': payload.get('downloads', 0),
                'gaps': payload.get('gaps', 0),
                'errors': payload.get('errors', 0),
                'series_matched': payload.get('series_matched', 0),
                'movies_matched': payload.get('movies_matched', 0),
            })
        return jsonify(result)
    except (ImportError, Exception) as e:
        logger.exception("Error get_cycle_history")
        return jsonify([])


# Fan-out broadcast per notifiche SSE: ogni client ha la propria queue.
# Una singola queue.Queue() condivisa causerebbe il problema che solo UN client
# riceve ogni notifica (primo che chiama .get()). Con il fan-out tutti i client
# connessi ricevono ogni notifica.
_notify_subscribers: list = []
_notify_lock = threading.Lock()

def push_notification(type_: str, title: str, message: str, data: dict = None):
    """Broadcast notifica a tutti i client SSE connessi."""
    payload = {
        'type': type_,
        'title': title,
        'message': message,
        'data': data or {},
        'ts': datetime.now().isoformat()
    }
    with _notify_lock:
        # Rimuove client disconnessi (queue piena = client lento/disconnesso)
        dead = []
        for q in _notify_subscribers:
            try:
                q.put_nowait(payload)
            except queue.Full:
                dead.append(q)
        for q in dead:
            _notify_subscribers.remove(q)


@app.route('/api/notifications/stream')
def stream_notifications():
    """SSE stream per notifiche push in-browser — fan-out a tutti i client connessi."""
    client_q = queue.Queue(maxsize=50)  # buffer max 50 notifiche per client
    with _notify_lock:
        _notify_subscribers.append(client_q)
    def generate():
        try:
            yield "data: " + json.dumps({'type': 'connected', 'message': 'Stream notifiche attivo'}) + "\n\n"
            while True:
                try:
                    notif = client_q.get(timeout=25)
                    yield "data: " + json.dumps(notif) + "\n\n"
                except GeneratorExit:
                    return
                except BrokenPipeError:
                    return
                except Exception as e:
                    logger.debug(f"stream log: {e}")
                    # Keepalive ping ogni 25 secondi
                    yield "data: " + json.dumps({'type': 'ping'}) + "\n\n"
        finally:
            with _notify_lock:
                try:
                    _notify_subscribers.remove(client_q)
                except ValueError:
                    pass
    return Response(stream_with_context(generate()), mimetype='text/event-stream',
                    headers={'Cache-Control': 'no-cache', 'X-Accel-Buffering': 'no'})


@app.route('/api/amule/config', methods=['GET'])
def amule_config_get():
    """Legge la configurazione aMule da extto_config.db.
    Se amule_conf_path è configurato, legge anche i parametri direttamente
    da amule.conf (porte, cartelle) e li include nella risposta.
    """
    try:
        import os, configparser
        s    = _cdb.get_all_settings()
        home = os.path.expanduser('~')
        default_conf = os.path.join(home, '.aMule', 'amule.conf')

        resp = {
            'amule_enabled':   s.get('amule_enabled', 'no'),
            'amule_host':      s.get('amule_host', 'localhost'),
            'amule_port':      s.get('amule_port', '4712'),
            'amule_password':  s.get('amule_password', ''),
            'amule_service':   s.get('amule_service', 'amule-daemon'),
            'amule_conf_path': s.get('amule_conf_path', default_conf),
            'gap_fill_ed2k':   s.get('gap_fill_ed2k', 'no'),
            # campi letti da amule.conf (valori live)
            'amule_tcp_port':  '',
            'amule_udp_port':  '',
            'amule_incoming':  '',
            'amule_temp':      '',
        }

        # Prova a leggere i valori live dal amule.conf di amuled
        conf_path = resp['amule_conf_path']
        if conf_path and os.path.exists(conf_path):
            try:
                cfg = configparser.RawConfigParser()
                cfg.optionxform = str
                cfg.read(conf_path, encoding='utf-8')
                if cfg.has_option('eMule', 'Port'):
                    resp['amule_tcp_port'] = cfg.get('eMule', 'Port')
                if cfg.has_option('eMule', 'UDPPort'):
                    resp['amule_udp_port'] = cfg.get('eMule', 'UDPPort')
                if cfg.has_option('eMule', 'IncomingDir'):
                    resp['amule_incoming'] = cfg.get('eMule', 'IncomingDir')
                if cfg.has_option('eMule', 'TempDir'):
                    resp['amule_temp'] = cfg.get('eMule', 'TempDir')
            except Exception as e:
                logger.warning(f"amule_config_get: lettura amule.conf: {e}")

        return jsonify(resp)
    except Exception as e:
        return jsonify({'error': str(e)}), 500



@app.route('/api/amule/config', methods=['POST'])
def amule_config_save():
    """Salva la configurazione aMule in extto_config.db.
    Aggiorna anche amule.conf nel path configurato, preservando tutto
    il resto della configurazione di amuled.
    BLOCCA se amuled è in esecuzione: le modifiche a amule.conf vengono
    sovrascritte da amuled al riavvio, quindi è necessario che sia fermo.
    """
    try:
        import os, subprocess
        data = request.get_json(silent=True) or {}

        # Chiavi gestite da EXTTO nel DB
        db_keys = {
            'amule_enabled', 'amule_host', 'amule_port', 'amule_password',
            'amule_service', 'amule_conf_path',
            'gap_fill_ed2k',  # non tocca amule.conf — nessun bisogno di fermare amuled
        }
        # Chiavi che vanno scritte in amule.conf (non nel DB)
        conf_keys = {
            'amule_tcp_port', 'amule_udp_port', 'amule_incoming', 'amule_temp',
        }

        to_db   = {k: str(v).strip() for k, v in data.items() if k in db_keys}
        to_conf = {k: str(v).strip() for k, v in data.items() if k in conf_keys}

        if not to_db and not to_conf:
            return jsonify({'ok': False, 'error': 'Nessun parametro valido'}), 400

        # Salva SEMPRE i parametri sul DB, così le checkbox (es. gap_fill_ed2k) vengono salvate a prescindere
        if to_db:
            _cdb.set_settings_bulk(to_db)

        s = _cdb.get_all_settings()
        conf_path = to_db.get('amule_conf_path') or s.get('amule_conf_path', '')
        if not conf_path:
            conf_path = os.path.join(os.path.expanduser('~'), '.aMule', 'amule.conf')

        # Controlla se i parametri specifici per amule.conf sono EFFETTIVAMENTE cambiati rispetto al file su disco
        needs_conf_write = False
        if os.path.exists(conf_path):
            import configparser
            cfg = configparser.RawConfigParser()
            cfg.optionxform = str
            try:
                cfg.read(conf_path, encoding='utf-8')
                curr_tcp = cfg.get('eMule', 'Port') if cfg.has_option('eMule', 'Port') else ''
                curr_udp = cfg.get('eMule', 'UDPPort') if cfg.has_option('eMule', 'UDPPort') else ''
                curr_inc = cfg.get('eMule', 'IncomingDir') if cfg.has_option('eMule', 'IncomingDir') else ''
                curr_tmp = cfg.get('eMule', 'TempDir') if cfg.has_option('eMule', 'TempDir') else ''
                curr_prt = cfg.get('ExternalConnect', 'ECPort') if cfg.has_option('ExternalConnect', 'ECPort') else ''
                
                if 'amule_tcp_port' in to_conf and to_conf['amule_tcp_port'] != curr_tcp: needs_conf_write = True
                if 'amule_udp_port' in to_conf and to_conf['amule_udp_port'] != curr_udp: needs_conf_write = True
                if 'amule_incoming' in to_conf and to_conf['amule_incoming'] != curr_inc: needs_conf_write = True
                if 'amule_temp'     in to_conf and to_conf['amule_temp']     != curr_tmp: needs_conf_write = True
                if 'amule_port'     in to_db   and to_db['amule_port']       != curr_prt: needs_conf_write = True

                if to_db.get('amule_password'):
                    import hashlib
                    pwd_hash = hashlib.md5(to_db['amule_password'].encode('utf-8')).hexdigest()
                    curr_hash = cfg.get('ExternalConnect', 'ECPassword') if cfg.has_option('ExternalConnect', 'ECPassword') else ''
                    if pwd_hash != curr_hash:
                        needs_conf_write = True
            except Exception:
                needs_conf_write = True  # Se non riusciamo a leggere, forziamo la scrittura
        else:
            if to_conf or to_db.get('amule_port') or to_db.get('amule_password'):
                needs_conf_write = True

        if needs_conf_write:
            # ── Verifica che amuled sia SPENTO prima di toccare amule.conf ──────
            service_name = (to_db.get('amule_service') or s.get('amule_service', 'amule-daemon')).strip()
            try:
                res = subprocess.run(
                    ['systemctl', 'is-active', service_name],
                    capture_output=True, text=True, timeout=5
                )
                if res.stdout.strip() == 'active':
                    return jsonify({
                        'ok': True,
                        'service_running': True,
                        'warning': (f'Impostazioni DB salvate, MA per aggiornare amule.conf '
                                  f'devi prima fermare amuled: sudo systemctl stop {service_name}')
                    })
            except Exception:
                pass  # systemctl non disponibile o servizio non trovato: procedi comunque

            try:
                _amule_write_conf(conf_path, {**to_db, **to_conf})
                log_maintenance(f"✅ amule.conf aggiornato: {conf_path}")
            except Exception as e:
                log_maintenance(f"⚠️ Errore scrittura amule.conf: {e}")
                return jsonify({'ok': True, 'warning': str(e)})

        log_maintenance("✅ Configurazione aMule salvata")
        try:
            from core.config import Config as _Cfg; _Cfg.invalidate()
        except Exception:
            pass
        return jsonify({'ok': True})
    except Exception as e:
        log_maintenance(f"❌ Errore salvataggio config aMule: {e}")
        return jsonify({'ok': False, 'error': str(e)}), 500


@app.route('/api/amule/status-service', methods=['GET'])
def amule_service_status():
    """Controlla lo stato del servizio amuled via systemctl (system service)."""
    try:
        import subprocess
        s = _cdb.get_all_settings()
        service_name = s.get('amule_service', 'amule-daemon').strip()
        result = subprocess.run(
            ['systemctl', 'is-active', service_name],
            capture_output=True, text=True, timeout=5
        )
        status = result.stdout.strip()
        active = (status == 'active')
        return jsonify({'active': active, 'status': status, 'service': service_name})
    except Exception as e:
        return jsonify({'active': False, 'status': 'unknown', 'error': str(e)})


@app.route('/api/amule/bandwidth', methods=['GET'])
def amule_get_bandwidth():
    """Legge i limiti di banda correnti da amule.conf."""
    try:
        from core.clients.amule import AmuleClient
        from core.config import Config
        cfg = Config()
        with AmuleClient(cfg) as client:
            bw = client.get_bandwidth()
        return jsonify({'ok': True, **bw})
    except Exception as e:
        logger.error(f"amule_get_bandwidth: {e}")
        return jsonify({'ok': False, 'error': str(e)}), 500


@app.route('/api/amule/bandwidth', methods=['POST'])
def amule_set_bandwidth():
    """Imposta MaxDownload e MaxUpload in amule.conf (KB/s, 0=illimitato).
    Blocca se amuled è in esecuzione (le modifiche verrebbero sovrascritte).
    """
    try:
        import subprocess
        from core.clients.amule import AmuleClient
        from core.config import Config
        data = request.get_json(force=True) or {}

        # Verifica che amuled sia spento
        s = _cdb.get_all_settings()
        service_name = s.get('amule_service', 'amule-daemon').strip()
        try:
            res = subprocess.run(['systemctl', 'is-active', service_name],
                                 capture_output=True, text=True, timeout=5)
            if res.stdout.strip() == 'active':
                return jsonify({
                    'ok': False, 'service_running': True,
                    'error': f'Ferma amuled prima di modificare la banda: sudo systemctl stop {service_name}'
                }), 409
        except Exception:
            pass

        dl_kbs = int(data.get('max_download_kbs', 0))
        ul_kbs = int(data.get('max_upload_kbs', 0))
        cfg = Config()
        with AmuleClient(cfg) as client:
            ok = client.set_bandwidth(dl_kbs, ul_kbs)
        if ok:
            log_maintenance(f"✅ aMule: bandwidth DL={dl_kbs} KB/s UL={ul_kbs} KB/s")
            return jsonify({'ok': True, 'message': 'Limiti salvati.'})
        return jsonify({'ok': False, 'error': 'Scrittura amule.conf fallita'}), 500
    except Exception as e:
        logger.error(f"amule_set_bandwidth: {e}")
        return jsonify({'ok': False, 'error': str(e)}), 500


        
@app.route('/api/amule/log', methods=['GET'])
def amule_get_log():
    """Legge le ultime righe del log di aMule in modo ultra-veloce."""
    try:
        import os
        import core.config_db as _cdb
        s = _cdb.get_all_settings()
        
        conf_path = s.get('amule_conf_path', '')
        if not conf_path:
            conf_path = os.path.join(os.path.expanduser('~'), '.aMule', 'amule.conf')
            
        log_file = os.path.join(os.path.dirname(conf_path), 'logfile')
        
        if not os.path.exists(log_file):
            return jsonify({'success': False, 'error': f'File di log non trovato in {log_file}'})
            
        lines_to_read = int(request.args.get('lines', 200))
        
        # Lettura sicura e veloce dalla fine del file (evita blocchi su log giganti)
        with open(log_file, 'rb') as f:
            f.seek(0, 2) # Vai alla fine del file
            file_size = f.tell()
            chunk_size = min(file_size, lines_to_read * 250) # Leggi solo la fine (stima larga)
            f.seek(file_size - chunk_size)
            data = f.read().decode('utf-8', errors='replace')
            lines = data.splitlines()
            
        return jsonify({'success': True, 'logs': lines[-lines_to_read:]})
    except Exception as e:
        return jsonify({'success': False, 'error': str(e)})
        
@app.route('/api/amule/status', methods=['GET'])
def amule_status():
    """Stato della rete aMule (High ID, connessioni)."""
    try:
        from core.config import Config as _Cfg
        from core.clients.amule import AmuleClient
        _cfg_am = _Cfg()
        if str(_cfg_am.qbt.get('amule_enabled', 'no')).lower() in ('yes', 'true', '1'):
            try:
                with AmuleClient(_cfg_am.qbt) as _am:
                    return jsonify(_am.get_status())
            except Exception as auth_e:
                # Se aMule rifiuta momentaneamente l'autenticazione per flooding, ignora in silenzio
                return jsonify({'ed2k_connected': False, 'kad_connected': False, 'server_name': ''})
        else:
            return jsonify({'error': 'aMule non abilitato'}), 400
    except Exception as e:
        return jsonify({'ed2k_connected': False, 'kad_connected': False})
        
@app.route('/api/amule/statistics', methods=['GET'])
def amule_get_statistics():
    """Recupera le statistiche avanzate di aMule."""
    try:
        from core.clients.amule import AmuleClient
        from core.config import Config
        cfg = Config()
        with AmuleClient(cfg) as client:
            return jsonify({'success': True, 'stats': client.get_statistics()})
    except Exception as e:
        return jsonify({'success': False, 'error': str(e)}), 500        
        
@app.route('/api/amule/server/add', methods=['POST'])
def amule_add_server():
    try:
        from core.clients.amule import AmuleClient
        from core.config import Config
        data = request.get_json(force=True) or {}
        url = data.get("url")
        if not url:
            return jsonify({"error": "URL mancante"}), 400
        
        cfg = Config()
        with AmuleClient(cfg) as client:
            if client.add_server(url):
                return jsonify({"ok": True, "message": "Richiesta inviata ad aMule"})
        return jsonify({"error": "Fallito"}), 500
    except Exception as e:
        logger.error(f"amule_add_server: {e}")
        return jsonify({"error": str(e)}), 500


@app.route('/api/amule/server/update', methods=['POST'])
def amule_update_server_met():
    """Invia l'URL del server.met ad aMule e lo salva in addresses.dat"""
    try:
        from core.clients.amule import AmuleClient
        from core.config import Config
        import os

        data = request.get_json(force=True) or {}
        url = data.get("url", "").strip()
        if not url:
            return jsonify({"ok": False, "error": "URL mancante"}), 400

        # Salva l'URL nel DB di EXTTO per ricordarselo
        _cdb.set_settings_bulk({'amule_server_met_url': url})

        # Scrive l'URL in addresses.dat per aMule
        try:
            s = _cdb.get_all_settings()
            conf_path = s.get('amule_conf_path', '')
            if not conf_path:
                conf_path = os.path.join(os.path.expanduser('~'), '.aMule', 'amule.conf')
            addr_file = os.path.join(os.path.dirname(conf_path), 'addresses.dat')
            with open(addr_file, 'w', encoding='utf-8') as f:
                f.write(url + '\n')
        except Exception as e:
            logger.warning(f"Errore scrittura addresses.dat: {e}")

        cfg = Config()
        with AmuleClient(cfg) as client:
            if client.add_server(url):
                log_maintenance(f"✅ aMule: richiesta server.met inviata ({url})")
                return jsonify({"ok": True, "message": f"Richiesta inviata ad aMule: {url}"})
        return jsonify({"ok": False, "error": "aMule non ha accettato il comando"}), 500

    except Exception as e:
        logger.error(f"amule_update_server_met: {e}")
        return jsonify({"ok": False, "error": str(e)}), 500

@app.route('/api/amule/server/connect', methods=['POST'])
def amule_connect_server():
    try:
        from core.clients.amule import AmuleClient
        data = request.get_json() or {}
        ip = data.get('ip')
        port = data.get('port')
        
        with AmuleClient() as client:
            if client.connect_server(ip, port):
                return jsonify({"ok": True})
        return jsonify({"error": "Fallito"}), 500
    except Exception as e:
        return jsonify({"error": str(e)}), 500

@app.route('/api/amule/servers', methods=['GET'])
def amule_get_servers():
    try:
        from core.clients.amule import AmuleClient
        from core.config import Config
        import os, configparser

        # Legge l'URL dal DB
        s = _cdb.get_all_settings()
        met_url = s.get('amule_server_met_url', '')

        conf_path = s.get('amule_conf_path', '')
        if not conf_path:
            conf_path = os.path.join(os.path.expanduser('~'), '.aMule', 'amule.conf')
        amule_dir = os.path.dirname(conf_path)

        # BUG5 FIX: Legge met_url in ordine di priorità:
        # 1. addresses.dat (impostato dall'interfaccia web di amuled)
        # 2. amule.conf chiave Ed2kServersUrl (impostato dalla GUI aMule → Preferenze)
        # 3. amule.conf [WebServer] URL_2 (fallback)
        # 4. DB EXTTO
        addr_file = os.path.join(amule_dir, 'addresses.dat')
        try:
            if os.path.exists(addr_file):
                with open(addr_file, 'r', encoding='utf-8') as f:
                    for line in f:
                        stripped = line.strip()
                        if stripped and stripped.startswith('http'):
                            met_url = stripped
                            break
        except Exception:
            pass

        # Fallback: leggi Ed2kServersUrl / URL_2 da amule.conf
        if not met_url:
            try:
                if os.path.exists(conf_path):
                    cfg_parser = configparser.RawConfigParser()
                    cfg_parser.optionxform = str
                    cfg_parser.read(conf_path, encoding='utf-8')
                    # Campo principale: [eMule] Ed2kServersUrl
                    for key in ('Ed2kServersUrl', 'ed2kserversurl'):
                        if cfg_parser.has_option('eMule', key):
                            v = cfg_parser.get('eMule', key).strip()
                            if v.startswith('http'):
                                met_url = v
                                break
                    # Fallback: [WebServer] URL_2 (seconda URL configurata)
                    if not met_url and cfg_parser.has_section('WebServer'):
                        for key in ('URL_2', 'URL_1'):
                            if cfg_parser.has_option('WebServer', key):
                                v = cfg_parser.get('WebServer', key).strip()
                                if v.startswith('http') and 'server.met' in v:
                                    met_url = v
                                    break
            except Exception as e:
                logger.debug(f"amule_get_servers: lettura URL da amule.conf: {e}")

        cfg = Config()
        with AmuleClient(cfg) as client:
            servers = client.get_server_list()
            # Arricchisce il server connesso con users/files/ping da status
            try:
                st = client.get_status()
                conn_addr = st.get('server_address', '')
                if conn_addr:
                    for srv in servers:
                        if srv.get('address') == conn_addr:
                            srv['users']    = st.get('server_users', 0) or st.get('ed2k_users', 0)
                            srv['files']    = st.get('server_files', 0) or st.get('ed2k_files', 0)
                            srv['ping']     = st.get('server_ping', 0)
                            srv['connected'] = True
                            break
            except Exception:
                pass
            return jsonify({'servers': servers, 'met_url': met_url})
    except Exception as e:
        logger.error(f"amule_get_servers: {e}")
        return jsonify({'servers': [], 'error': str(e)}), 500



def _amule_write_conf(conf_path: str, settings: dict) -> None:
    """Aggiorna amule.conf nel path indicato.

    Tocca SOLO le sezioni EC e porte — tutto il resto viene preservato.
    Se il file non esiste non viene creato (amuled deve averlo già inizializzato).
    """
    import os, configparser, hashlib

    if not os.path.exists(conf_path):
        raise FileNotFoundError(
            f"amule.conf non trovato in {conf_path}. "
            f"Avvia amuled almeno una volta per generarlo, poi riprova."
        )

    cfg = configparser.RawConfigParser()
    cfg.optionxform = str   # preserva maiuscole/minuscole
    cfg.read(conf_path, encoding='utf-8')

    def _ensure(section):
        if not cfg.has_section(section):
            cfg.add_section(section)

    # ── ExternalConnect ──────────────────────────────────────────────────────
    _ensure('ExternalConnect')
    cfg.set('ExternalConnect', 'AcceptExternalConnections', '1')

    ec_port = str(settings.get('amule_port', '')).strip()
    if ec_port:
        cfg.set('ExternalConnect', 'ECPort', ec_port)

    ec_pass = str(settings.get('amule_password', '')).strip()
    if ec_pass:
        # aMule salva l'MD5 della password
        pwd_hash = hashlib.md5(ec_pass.encode('utf-8')).hexdigest()
        cfg.set('ExternalConnect', 'ECPassword', pwd_hash)

    # ── eMule: porte e cartelle (solo se forniti) ─────────────────────────────
    _ensure('eMule')

    tcp = str(settings.get('amule_tcp_port', '')).strip()
    if tcp:
        cfg.set('eMule', 'Port', tcp)

    udp = str(settings.get('amule_udp_port', '')).strip()
    if udp:
        cfg.set('eMule', 'UDPPort', udp)

    incoming = str(settings.get('amule_incoming', '')).strip()
    if incoming:
        cfg.set('eMule', 'IncomingDir', incoming)

    temp = str(settings.get('amule_temp', '')).strip()
    if temp:
        cfg.set('eMule', 'TempDir', temp)

    with open(conf_path, 'w', encoding='utf-8') as f:
        cfg.write(f)


@app.route('/api/amule/downloads', methods=['GET'])
def amule_get_downloads():
    """Lista download in corso."""
    try:
        from core.clients.amule import AmuleClient
        from core.config import Config
        cfg = Config()
        with AmuleClient(cfg) as client:
            return jsonify({'downloads': client.get_download_queue()})
    except Exception as e:
        logger.error(f"amule_get_downloads: {e}")
        return jsonify({'downloads': [], 'error': str(e)}), 500


@app.route('/api/amule/recover-parts', methods=['GET'])
def amule_recover_parts():
    """Scansiona la TempDir di aMule per file .part orfani e li re-inietta via amulecmd."""
    try:
        from core.clients.amule import AmuleClient
        from core.config import Config
        import configparser, struct, os

        s = _cdb.get_all_settings()
        conf_path = s.get('amule_conf_path', '')
        if not conf_path:
            conf_path = os.path.join(os.path.expanduser('~'), '.aMule', 'amule.conf')

        temp_dir = ''
        try:
            cfg_parser = configparser.RawConfigParser()
            cfg_parser.optionxform = str
            cfg_parser.read(conf_path, encoding='utf-8')
            if cfg_parser.has_option('eMule', 'TempDir'):
                temp_dir = cfg_parser.get('eMule', 'TempDir').strip()
        except Exception as e:
            logger.warning(f"recover-parts: lettura TempDir: {e}")

        if not temp_dir or not os.path.isdir(temp_dir):
            return jsonify({'ok': False, 'error': f'TempDir non trovata: {temp_dir!r}'}), 400

        def parse_part_met(path):
            """Legge (hash_hex_upper, filename, filesize) da .part.met di aMule.
            Supporta versioni 0x0e, 0x0f e 0xe0.
            """
            with open(path, 'rb') as f:
                data = f.read()
            if len(data) < 23:
                raise ValueError(f"file troppo corto ({len(data)} bytes)")
            version = data[0]
            if version not in (0x0e, 0x0f, 0xe0):
                raise ValueError(f"versione met sconosciuta: 0x{version:02x}")

            if version == 0xe0:
                # [0]=ver [1:5]=date [5:21]=hash [21:23]=hashset_count
                file_hash = data[5:21].hex().upper()
                hashset_count = struct.unpack_from('<H', data, 21)[0]
                offset = 23 + hashset_count * 16
            else:
                # [0]=ver [1:17]=hash [17:19]=hashset_count
                file_hash = data[1:17].hex().upper()
                hashset_count = struct.unpack_from('<H', data, 17)[0]
                offset = 19 + hashset_count * 16

            if offset + 4 > len(data):
                raise ValueError(f"offset tag fuori range: {offset} > {len(data)}")

            tag_count = struct.unpack_from('<I', data, offset)[0]
            offset += 4

            FT_FILENAME    = 0x01
            FT_FILESIZE    = 0x02
            FT_FILESIZE_HI = 0x3a
            TYPE_STRING    = 0x02
            TYPE_UINT64    = 0x09
            TYPE_UINT32    = 0x03
            TYPE_UINT16    = 0x05
            TYPE_UINT8     = 0x08

            filename = ''
            filesize_lo = 0
            filesize_hi = 0
            filesize64  = 0

            for _ in range(min(tag_count, 300)):
                if offset >= len(data):
                    break
                tag_type = data[offset]; offset += 1
                compressed = bool(tag_type & 0x80)
                tag_type &= 0x7f

                if compressed:
                    if offset >= len(data): break
                    tag_name = data[offset]; offset += 1
                else:
                    if offset + 2 > len(data): break
                    name_len = struct.unpack_from('<H', data, offset)[0]; offset += 2
                    if offset + name_len > len(data): break
                    tag_name_b = data[offset:offset+name_len]; offset += name_len
                    tag_name = tag_name_b[0] if name_len == 1 else -1

                if tag_type == TYPE_STRING:
                    if offset + 2 > len(data): break
                    slen = struct.unpack_from('<H', data, offset)[0]; offset += 2
                    if offset + slen > len(data): break
                    val_b = data[offset:offset+slen]; offset += slen
                    if tag_name == FT_FILENAME and not filename:
                        try:    filename = val_b.decode('utf-8')
                        except: filename = val_b.decode('latin-1', errors='replace')
                elif tag_type == TYPE_UINT64:
                    if offset + 8 > len(data): break
                    val = struct.unpack_from('<Q', data, offset)[0]; offset += 8
                    if tag_name == FT_FILESIZE: filesize64 = val
                elif tag_type == TYPE_UINT32:
                    if offset + 4 > len(data): break
                    val = struct.unpack_from('<I', data, offset)[0]; offset += 4
                    if tag_name == FT_FILESIZE:    filesize_lo = val
                    elif tag_name == FT_FILESIZE_HI: filesize_hi = val
                elif tag_type == TYPE_UINT16:
                    if offset + 2 > len(data): break
                    offset += 2
                elif tag_type == TYPE_UINT8:
                    if offset + 1 > len(data): break
                    offset += 1
                else:
                    break  # tipo sconosciuto, stop sicuro

            if filesize64:
                filesize = filesize64
            elif filesize_lo or filesize_hi:
                filesize = (filesize_hi << 32) | filesize_lo
            else:
                filesize = 0

            return file_hash, filename, filesize

        # Ottieni hash già in coda per non duplicare
        cfg = Config()
        active_hashes = set()
        try:
            with AmuleClient(cfg) as client:
                for d in client.get_download_queue():
                    active_hashes.add(d.get('hash', '').upper())
        except Exception:
            pass

        recovered = []
        skipped   = []
        errors    = []

        for fname in sorted(os.listdir(temp_dir)):
            if not fname.endswith('.part.met'):
                continue
            met_path  = os.path.join(temp_dir, fname)
            part_path = met_path[:-4]  # rimuove '.met'

            if not os.path.exists(part_path):
                errors.append(f'{fname}: file .part mancante su disco')
                continue

            try:
                file_hash, filename, filesize = parse_part_met(met_path)
            except Exception as e:
                errors.append(f'{fname}: {e}')
                continue

            if file_hash in active_hashes:
                skipped.append(filename or fname)
                continue

            # Fallback nome: usa il numero del .part se il tag era assente
            if not filename:
                filename = fname.replace('.part.met', '.part')

            # Dimensione: usa quella dal .part.met; se 0, usa dimensione file .part su disco
            if filesize == 0:
                filesize = os.path.getsize(part_path)

            safe_name = re.sub(r'[|]', '-', filename)
            ed2k = f'ed2k://|file|{safe_name}|{filesize}|{file_hash}|/'

            try:
                with AmuleClient(cfg) as client:
                    ok = client.add(ed2k)
                if ok:
                    recovered.append({'name': filename, 'hash': file_hash,
                                      'size': filesize, 'ed2k': ed2k})
                    active_hashes.add(file_hash)
                    log_maintenance(f'✅ aMule recover-parts: re-iniettato {filename}')
                else:
                    errors.append(f'{filename}: amulecmd Add rifiutato')
            except Exception as e:
                errors.append(f'{filename}: {e}')

        return jsonify({
            'ok': True, 'recovered': recovered,
            'skipped': skipped, 'errors': errors, 'temp_dir': temp_dir,
        })

    except Exception as e:
        logger.error(f'amule_recover_parts: {e}')
        return jsonify({'ok': False, 'error': str(e)}), 500


@app.route('/api/amule/add', methods=['POST'])
def amule_add_link():
    """Aggiunge un link ed2k://. Estrae size/hash dal link per mostrare subito la dimensione."""
    try:
        from core.clients.amule import AmuleClient
        from core.config import Config
        data = request.get_json(force=True) or {}
        link = data.get('link', '').strip()
        if not link.startswith('ed2k://'):
            return jsonify({'ok': False, 'error': 'Link non ed2k'}), 400
        size_from_link = 0
        hash_from_link = ''
        name_from_link = ''
        try:
            parts = link.rstrip('/').split('|')
            if len(parts) >= 5:
                name_from_link = parts[3]
                size_from_link = int(parts[4]) if parts[4].isdigit() else 0
            if len(parts) >= 6:
                hash_from_link = parts[5]
        except Exception:
            pass
        cfg = Config()
        with AmuleClient(cfg) as client:
            ok = client.add(link)
        return jsonify({'ok': ok, 'size': size_from_link,
                        'hash': hash_from_link, 'name': name_from_link})
    except Exception as e:
        return jsonify({'ok': False, 'error': str(e)}), 500


@app.route('/api/amule/pause', methods=['POST'])
def amule_pause():
    try:
        from core.clients.amule import AmuleClient
        from core.config import Config
        data = request.get_json(force=True) or {}
        file_hash = data.get('hash', '').strip()
        cfg = Config()
        with AmuleClient(cfg) as client:
            ok = client.pause_download(file_hash)
        return jsonify({'ok': ok})
    except Exception as e:
        return jsonify({'ok': False, 'error': str(e)}), 500


@app.route('/api/amule/resume', methods=['POST'])
def amule_resume():
    try:
        from core.clients.amule import AmuleClient
        from core.config import Config
        data = request.get_json(force=True) or {}
        file_hash = data.get('hash', '').strip()
        cfg = Config()
        with AmuleClient(cfg) as client:
            ok = client.resume_download(file_hash)
        return jsonify({'ok': ok})
    except Exception as e:
        return jsonify({'ok': False, 'error': str(e)}), 500


@app.route('/api/amule/cancel', methods=['POST'])
def amule_cancel():
    try:
        from core.clients.amule import AmuleClient
        from core.config import Config
        data = request.get_json(force=True) or {}
        file_hash = data.get('hash', '').strip()
        cfg = Config()
        with AmuleClient(cfg) as client:
            ok = client.cancel_download(file_hash)
        return jsonify({'ok': ok})
    except Exception as e:
        return jsonify({'ok': False, 'error': str(e)}), 500


@app.route('/api/amule/uploads', methods=['GET'])
def amule_get_uploads():
    try:
        from core.clients.amule import AmuleClient
        from core.config import Config
        cfg = Config()
        with AmuleClient(cfg) as client:
            return jsonify({'uploads': client.get_upload_queue()})
    except Exception as e:
        return jsonify({'uploads': [], 'error': str(e)}), 500


_AMULE_SHARED_FILES_CACHE = None

@app.route('/api/amule/shared', methods=['GET'])
def amule_get_shared():
    global _AMULE_SHARED_FILES_CACHE
    try:
        force = request.args.get('force', '0') == '1'
        if not force and _AMULE_SHARED_FILES_CACHE is not None:
            return jsonify({'shared': _AMULE_SHARED_FILES_CACHE})
        
        from core.clients.amule import AmuleClient
        from core.config import Config
        cfg = Config()
        with AmuleClient(cfg) as client:
            files = client.get_shared_files()
            _AMULE_SHARED_FILES_CACHE = files
            return jsonify({'shared': files})
    except Exception as e:
        return jsonify({'shared': [], 'error': str(e)}), 500


@app.route('/api/amule/shared/reload', methods=['POST'])
def amule_reload_shared():
    global _AMULE_SHARED_FILES_CACHE
    try:
        from core.clients.amule import AmuleClient
        from core.config import Config
        cfg = Config()
        with AmuleClient(cfg) as client:
            ok = client.reload_shared()
        _AMULE_SHARED_FILES_CACHE = None
        return jsonify({'ok': ok})
    except Exception as e:
        return jsonify({'ok': False, 'error': str(e)}), 500


@app.route('/api/amule/shared/add', methods=['POST'])
def amule_add_shared():
    try:
        import json, os
        from core.clients.amule import AmuleClient
        from core.config import Config
        data = request.get_json(force=True) or {}
        path = data.get('path', '').strip()
        
        # Lettura sicura del booleano (javascript a volte manda 'true' come testo)
        rec_val = data.get('recursive', False)
        recursive = str(rec_val).lower() in ('true', '1', 'yes') if isinstance(rec_val, str) else bool(rec_val)
        
        if not path:
            return jsonify({'ok': False, 'error': 'Percorso mancante'}), 400

        path_abs = os.path.abspath(path.rstrip('/'))

        # Lettura ultra-sicura dal DB
        settings = _cdb.get_all_settings()
        raw_rec = settings.get('amule_recursive_dirs', [])
        if isinstance(raw_rec, str):
            try: rec_dirs = json.loads(raw_rec)
            except: rec_dirs = []
        else:
            rec_dirs = list(raw_rec)

        # Salva in memoria
        if recursive:
            if path_abs not in rec_dirs:
                rec_dirs.append(path_abs)
                _cdb.set_settings_bulk({'amule_recursive_dirs': json.dumps(rec_dirs)})
        
        cfg = Config()
        with AmuleClient(cfg) as client:
            added_count = client.add_shared_dir(path_abs, recursive)
            
        global _AMULE_SHARED_FILES_CACHE
        _AMULE_SHARED_FILES_CACHE = None
        
        msg = f"Aggiunta {path_abs}" if not recursive else f"Aggiunte {added_count} cartelle da {path_abs}"
        log_maintenance(f"✅ aMule: {msg}")
        return jsonify({'ok': True, 'message': msg})
    except Exception as e:
        logger.error(f"amule_add_shared: {e}")
        return jsonify({'ok': False, 'error': str(e)}), 500

@app.route('/api/amule/shared/remove', methods=['POST'])
def amule_remove_shared():
    try:
        import json, os
        from core.clients.amule import AmuleClient
        from core.config import Config
        data = request.get_json(force=True) or {}
        path = data.get('path', '').strip()
        if not path:
            return jsonify({'ok': False, 'error': 'Percorso mancante'}), 400

        path_abs = os.path.abspath(path.rstrip('/'))

        # Lettura ultra-sicura dal DB
        settings = _cdb.get_all_settings()
        raw_rec = settings.get('amule_recursive_dirs', [])
        if isinstance(raw_rec, str):
            try: rec_dirs = json.loads(raw_rec)
            except: rec_dirs = []
        else:
            rec_dirs = list(raw_rec)
            
        if path_abs in rec_dirs:
            rec_dirs.remove(path_abs)
            _cdb.set_settings_bulk({'amule_recursive_dirs': json.dumps(rec_dirs)})

        cfg = Config()
        with AmuleClient(cfg) as client:
            client.remove_shared_dir(path_abs)
            
        global _AMULE_SHARED_FILES_CACHE
        _AMULE_SHARED_FILES_CACHE = None
        
        log_maintenance(f"✅ aMule: cartella rimossa: {path_abs}")
        return jsonify({'ok': True})
    except Exception as e:
        logger.error(f"amule_remove_shared: {e}")
        return jsonify({'ok': False, 'error': str(e)}), 500

@app.route('/api/amule/shared/dirs', methods=['GET'])
def amule_get_shared_dirs():
    try:
        import json, os
        from core.clients.amule import AmuleClient
        from core.config import Config

        # Lettura ultra-sicura dal DB
        settings = _cdb.get_all_settings()
        raw_rec = settings.get('amule_recursive_dirs', [])
        if isinstance(raw_rec, str):
            try: rec_dirs = json.loads(raw_rec)
            except: rec_dirs = []
        else:
            rec_dirs = list(raw_rec)

        cfg = Config()
        with AmuleClient(cfg) as client:
            raw_dirs = client.get_shared_dirs()

        final_dirs = []
        rec_abs_list = [os.path.abspath(r.rstrip('/')) for r in rec_dirs]

        for d in raw_dirs:
            p = os.path.abspath(d['path'].rstrip('/'))
            is_subfolder = False
            
            for r_dir_abs in rec_abs_list:
                if p != r_dir_abs and p.startswith(r_dir_abs + os.sep):
                    is_subfolder = True
                    break
            
            if is_subfolder:
                continue

            d['is_recursive'] = (p in rec_abs_list)
            final_dirs.append(d)

        return jsonify({'dirs': final_dirs})
    except Exception as e:
        logger.error(f"amule_get_shared_dirs: {e}")
        return jsonify({'dirs': [], 'error': str(e)}), 500


@app.route('/api/amule/search', methods=['POST'])
def amule_search():
    try:
        from core.clients.amule import AmuleClient
        from core.config import Config
        data = request.get_json(force=True) or {}
        query   = data.get('query', '').strip()
        network = data.get('network', 'global')
        ext     = data.get('extension', '')
        if not query:
            return jsonify({'results': [], 'error': 'Query vuota'}), 400
        cfg = Config()
        with AmuleClient(cfg) as client:
            results = client.search(query, network, ext)
        msg = None if results else 'Nessun risultato trovato (rete ed2k potrebbe non essere pronta)'
        return jsonify({'results': results, 'count': len(results), 'message': msg})
    except Exception as e:
        logger.error(f"amule_search: {e}")
        return jsonify({'results': [], 'error': str(e)}), 500


@app.route('/api/amule/search/download', methods=['POST'])
def amule_search_download():
    """Scarica il risultato N via 'amulecmd Download N'."""
    try:
        from core.clients.amule import AmuleClient
        from core.config import Config
        data = request.get_json(force=True) or {}
        idx  = int(data.get('idx', -1))
        if idx < 0:
            return jsonify({'ok': False, 'error': 'idx mancante'}), 400
        cfg = Config()
        with AmuleClient(cfg) as client:
            ok = client.download_result(idx)
        return jsonify({'ok': ok})
    except Exception as e:
        logger.error(f"amule_search_download: {e}")
        return jsonify({'ok': False, 'error': str(e)}), 500


@app.route('/api/amule/port-check', methods=['GET'])
def amule_port_check():
    """Verifica se le porte TCP/UDP di aMule sono aperte."""
    try:
        from core.clients.amule import AmuleClient
        from core.config import Config
        cfg = Config()
        with AmuleClient(cfg) as client:
            result = client.check_ports()
        return jsonify(result)
    except Exception as e:
        return jsonify({'error': str(e)}), 500


@app.route('/api/amule/all', methods=['GET'])
def amule_get_all():
    """Rotta consolidata: status + downloads + uploads.
    
    NOTA: _run_sections NON funziona con amulecmd perché i marker EXTTO_SEP_N
    sono comandi sconosciuti e amulecmd stampa solo "> Syntax error" senza
    ripetere il nome del comando — il marker non appare mai nell'output.
    Usiamo 3 subprocess separati. Il costo è accettabile (3 connessioni EC
    ogni 10s) e amuled non attiva il flood-protection a questa frequenza.
    """
    try:
        from core.clients.amule import AmuleClient
        from core.config import Config
        cfg = Config()
        with AmuleClient(cfg) as client:
            status    = client.get_status()
            downloads = client._parse_file_list(client._run('Show dl'), is_download=True)
            uploads   = client._parse_upload_list(client._run('Show ul'))
        return jsonify({'status': status, 'downloads': downloads, 'uploads': uploads})
    except Exception as e:
        logger.error(f"amule_get_all: {e}")
        return jsonify({'error': str(e)}), 500


@app.route('/api/amule/ed2k-handler', methods=['GET'])
def amule_ed2k_handler():
    """Riceve link ed2k:// da protocol handler del browser/OS.
    Chiamata da: http://localhost:PORT/api/amule/ed2k-handler?link=ed2k://...
    """
    try:
        from core.clients.amule import AmuleClient
        from core.config import Config
        link = request.args.get('link', '').strip()
        if not link or not link.startswith('ed2k://'):
            return f"Link non valido: {link}", 400
        cfg = Config()
        with AmuleClient(cfg) as client:
            ok = client.add(link)
        log_maintenance(f"✅ aMule: link ed2k aggiunto via handler: {link[:80]}")
        return (f"OK — Link aggiunto ad aMule: {link[:80]}", 200) if ok else ("Errore", 500)
    except Exception as e:
        return f"Errore: {e}", 500


@app.route('/api/browser-handlers/download', methods=['GET'])
def browser_handlers_download():
    """
    Serve gli script handler (extto-magnet, extto-torrent, .desktop, install.sh)
    con l'URL di EXTTO già iniettato dentro.
    Parametro: ?file=extto-magnet | extto-torrent | extto-magnet.desktop |
                       extto-torrent.desktop | install.sh
    """
    import os
    from flask import make_response

    requested = request.args.get('file', '').strip()
    allowed   = {'extto-magnet', 'extto-torrent',
                 'extto-magnet.desktop', 'extto-torrent.desktop',
                 'install.sh'}
    if requested not in allowed:
        return jsonify({'error': 'File non valido'}), 400

    try:
        # Ricava l'URL pubblico del server (quello che l'utente vede nel browser)
        s        = _cdb.get_all_settings()
        port     = int(s.get('flask_port', 5000))
        # Usa l'host della request se disponibile (funziona anche con IP LAN/hostname)
        req_host = request.host.split(':')[0]  # solo hostname, senza porta
        extto_url = f"http://{req_host}:{port}"

        # ── Contenuti ────────────────────────────────────────────────────────
        if requested == 'extto-magnet':
            content = f"""#!/bin/bash
# EXTTO — Handler protocollo magnet:
# Invia il link magnet all'endpoint /api/send-magnet di EXTTO.
# Installazione: esegui install.sh

EXTTO_URL="${{EXTTO_URL:-{extto_url}}}"
LOG="/tmp/extto-magnet.log"

MAGNET="${{*}}"

echo "$(date '+%F %T') --- CHIAMATA ---" >> "$LOG"
echo "  ARG1: ${{1}}" >> "$LOG"
echo "  ALL:  ${{*}}" >> "$LOG"
echo "  MAGNET: ${{MAGNET}}" >> "$LOG"

if [[ -z "$MAGNET" ]]; then
    echo "$(date '+%F %T') ERRORE: magnet vuoto" >> "$LOG"
    notify-send "EXTTO" "Nessun link magnet ricevuto" --icon=dialog-error 2>/dev/null
    exit 1
fi

notify-send "EXTTO" "Invio magnet in corso..." --icon=emblem-downloads 2>/dev/null

JSON=$(python3 -c "import json,sys; print(json.dumps({{'magnet': sys.argv[1]}}))" "$MAGNET")
echo "$(date '+%F %T') JSON: $JSON" >> "$LOG"

RESPONSE=$(curl -s -w "\\n%{{http_code}}" \\
    -X POST "${{EXTTO_URL}}/api/send-magnet" \\
    -H 'Content-Type: application/json' \\
    --data-raw "$JSON" \\
    --max-time 10 2>/dev/null)

HTTP_CODE=$(echo "$RESPONSE" | tail -1)
BODY=$(echo "$RESPONSE" | head -1)
echo "$(date '+%F %T') HTTP: $HTTP_CODE  BODY: $BODY" >> "$LOG"

if [[ "$HTTP_CODE" == "200" ]]; then
    SUCCESS=$(echo "$BODY" | python3 -c "import json,sys; d=json.load(sys.stdin); print(d.get('success',''))" 2>/dev/null)
    if [[ "$SUCCESS" == "True" ]]; then
        notify-send "EXTTO" "✅ Torrent aggiunto con successo" --icon=emblem-downloads 2>/dev/null
    else
        MSG=$(echo "$BODY" | python3 -c "import json,sys; d=json.load(sys.stdin); print(d.get('message','') or d.get('error','Errore sconosciuto'))" 2>/dev/null)
        notify-send "EXTTO" "⚠️ $MSG" --icon=dialog-warning 2>/dev/null
    fi
else
    notify-send "EXTTO" "❌ EXTTO non raggiungibile (${{EXTTO_URL}})" --icon=dialog-error 2>/dev/null
fi
"""
            mime = 'text/x-shellscript'

        elif requested == 'extto-torrent':
            content = f"""#!/bin/bash
# EXTTO — Handler file .torrent
# Scarica (se URL) o legge (se file locale) un .torrent e lo invia
# all'endpoint /api/upload-torrent di EXTTO.
# Installazione: esegui install.sh

EXTTO_URL="${{EXTTO_URL:-{extto_url}}}"
LOG="/tmp/extto-torrent.log"
INPUT="$1"

echo "$(date '+%F %T') --- CHIAMATA ---" >> "$LOG"
echo "  ARG1:  ${{1}}" >> "$LOG"
echo "  ALL:   ${{*}}" >> "$LOG"
echo "  INPUT: ${{INPUT}}" >> "$LOG"

if [[ -z "$INPUT" ]]; then
    echo "$(date '+%F %T') ERRORE: input vuoto" >> "$LOG"
    notify-send "EXTTO" "Nessun file .torrent ricevuto" --icon=dialog-error 2>/dev/null
    exit 1
fi

notify-send "EXTTO" "Invio .torrent in corso..." --icon=emblem-downloads 2>/dev/null

if [[ "$INPUT" == http://* ]] || [[ "$INPUT" == https://* ]]; then
    TMPFILE=$(mktemp /tmp/extto-XXXXXX.torrent)
    HTTP_DL=$(curl -s -w "%{{http_code}}" -L -o "$TMPFILE" \\
        -A "Mozilla/5.0" --max-time 30 "$INPUT" 2>/dev/null)
    echo "$(date '+%F %T') DL HTTP: $HTTP_DL  FILE: $TMPFILE" >> "$LOG"
    if [[ "$HTTP_DL" != "200" ]]; then
        rm -f "$TMPFILE"
        LOCATION=$(curl -s -w "%{{redirect_url}}" -o /dev/null -L "$INPUT" 2>/dev/null | tail -1)
        echo "$(date '+%F %T') REDIRECT: $LOCATION" >> "$LOG"
        if [[ "$LOCATION" == magnet:* ]]; then
            exec "$(dirname "$0")/extto-magnet" "$LOCATION"
        fi
        notify-send "EXTTO" "❌ Impossibile scaricare il file .torrent" --icon=dialog-error 2>/dev/null
        exit 1
    fi
    FILEPATH="$TMPFILE"
    FILENAME=$(basename "$INPUT" | sed 's/[?#].*//')
    [[ "$FILENAME" != *.torrent ]] && FILENAME="download.torrent"
    CLEANUP=1
else
    FILEPATH="${{INPUT#file://}}"
    FILENAME=$(basename "$FILEPATH")
    CLEANUP=0
fi

echo "$(date '+%F %T') FILEPATH: $FILEPATH  FILENAME: $FILENAME" >> "$LOG"

if [[ ! -f "$FILEPATH" ]]; then
    echo "$(date '+%F %T') ERRORE: file non trovato: $FILEPATH" >> "$LOG"
    notify-send "EXTTO" "❌ File non trovato: $FILEPATH" --icon=dialog-error 2>/dev/null
    exit 1
fi

B64=$(base64 -w 0 "$FILEPATH")
JSON=$(python3 -c "
import json, sys
print(json.dumps({{
    'filename': sys.argv[1],
    'data': sys.argv[2],
    'download_now': True
}}))
" "$FILENAME" "$B64")

RESPONSE=$(curl -s -w "\\n%{{http_code}}" \\
    -X POST "${{EXTTO_URL}}/api/upload-torrent" \\
    -H 'Content-Type: application/json' \\
    --data-raw "$JSON" \\
    --max-time 15 2>/dev/null)

HTTP_CODE=$(echo "$RESPONSE" | tail -1)
BODY=$(echo "$RESPONSE" | head -1)
echo "$(date '+%F %T') HTTP: $HTTP_CODE  BODY: $BODY" >> "$LOG"

[[ "$CLEANUP" == "1" ]] && rm -f "$FILEPATH"

if [[ "$HTTP_CODE" == "200" ]]; then
    SUCCESS=$(echo "$BODY" | python3 -c "import json,sys; d=json.load(sys.stdin); print(d.get('success',''))" 2>/dev/null)
    if [[ "$SUCCESS" == "True" ]]; then
        notify-send "EXTTO" "✅ $FILENAME aggiunto con successo" --icon=emblem-downloads 2>/dev/null
    else
        MSG=$(echo "$BODY" | python3 -c "import json,sys; d=json.load(sys.stdin); print(d.get('message','') or d.get('error','Errore sconosciuto'))" 2>/dev/null)
        notify-send "EXTTO" "⚠️ $MSG" --icon=dialog-warning 2>/dev/null
    fi
else
    notify-send "EXTTO" "❌ EXTTO non raggiungibile (${{EXTTO_URL}})" --icon=dialog-error 2>/dev/null
fi
"""
            mime = 'text/x-shellscript'

        elif requested == 'extto-magnet.desktop':
            content = """[Desktop Entry]
Name=EXTTO Magnet Handler
Comment=Invia link magnet a EXTTO torrent manager
Exec=/usr/local/bin/extto-magnet %U
Type=Application
MimeType=x-scheme-handler/magnet;
NoDisplay=true
StartupNotify=false
Terminal=false
"""
            mime = 'text/plain'

        elif requested == 'extto-torrent.desktop':
            content = """[Desktop Entry]
Name=EXTTO Torrent Handler
Comment=Invia file .torrent a EXTTO torrent manager
Exec=/usr/local/bin/extto-torrent %U
Type=Application
MimeType=application/x-bittorrent;x-scheme-handler/magnet;
NoDisplay=true
StartupNotify=false
Terminal=false
"""
            mime = 'text/plain'

        elif requested == 'install.sh':
            content = f"""#!/bin/bash
# ============================================================
# EXTTO — Installazione handler magnet: e .torrent
# Compatibile con: Firefox, Chrome, Chromium, Vivaldi
# Requisiti: curl, python3, xdg-utils, libnotify (notify-send)
#
# Generato automaticamente da EXTTO ({extto_url})
# ============================================================

set -e

EXTTO_URL="${{EXTTO_URL:-{extto_url}}}"
SCRIPT_DIR="$(cd "$(dirname "$0")" && pwd)"

echo "╔══════════════════════════════════════════════╗"
echo "║  EXTTO — Installazione handler torrent/magnet ║"
echo "╚══════════════════════════════════════════════╝"
echo ""
echo "▶ URL EXTTO: $EXTTO_URL"
echo ""

# ── Verifica dipendenze ──────────────────────────────────────
echo "→ Verifica dipendenze..."
for cmd in curl python3 xdg-mime xdg-open; do
    if ! command -v "$cmd" &>/dev/null; then
        echo "  ✗ Mancante: $cmd"
        echo "    Installa con: sudo apt install ${{cmd/xdg-mime/xdg-utils}}"
        exit 1
    fi
    echo "  ✓ $cmd"
done

if command -v notify-send &>/dev/null; then
    echo "  ✓ notify-send (notifiche desktop attive)"
else
    echo "  ⚠ notify-send non trovato — le notifiche desktop saranno silenti"
    echo "    Installa con: sudo apt install libnotify-bin"
fi
echo ""

# ── Copia script in /usr/local/bin ──────────────────────────
echo "→ Installazione script in /usr/local/bin ..."
for f in extto-magnet extto-torrent; do
    if [[ -f "$SCRIPT_DIR/$f" ]]; then
        sudo cp "$SCRIPT_DIR/$f" "/usr/local/bin/$f"
        sudo chmod +x "/usr/local/bin/$f"
        echo "  ✓ /usr/local/bin/$f"
    else
        echo "  ✗ File non trovato: $SCRIPT_DIR/$f"
        exit 1
    fi
done
echo ""

# ── Installa file .desktop ────────────────────────────────────
echo "→ Installazione file .desktop ..."
DESKTOP_DIR="$HOME/.local/share/applications"
mkdir -p "$DESKTOP_DIR"
for f in extto-magnet.desktop extto-torrent.desktop; do
    if [[ -f "$SCRIPT_DIR/$f" ]]; then
        cp "$SCRIPT_DIR/$f" "$DESKTOP_DIR/$f"
        echo "  ✓ $DESKTOP_DIR/$f"
    else
        echo "  ✗ File non trovato: $SCRIPT_DIR/$f"
        exit 1
    fi
done
echo ""

# ── Registra handler MIME ─────────────────────────────────────
echo "→ Registrazione handler MIME ..."
xdg-mime default extto-magnet.desktop x-scheme-handler/magnet
echo "  ✓ x-scheme-handler/magnet → extto-magnet"
xdg-mime default extto-torrent.desktop application/x-bittorrent
echo "  ✓ application/x-bittorrent → extto-torrent"
update-desktop-database "$DESKTOP_DIR" 2>/dev/null && echo "  ✓ database applicazioni aggiornato"
echo ""

# ── Configurazione Firefox ────────────────────────────────────
echo "→ Configurazione Firefox ..."
FIREFOX_PROFILES=$(find "$HOME/.mozilla/firefox" -name "prefs.js" 2>/dev/null)
if [[ -n "$FIREFOX_PROFILES" ]]; then
    for PREFS in $FIREFOX_PROFILES; do
        sed -i '/network.protocol-handler.expose.magnet/d' "$PREFS"
        sed -i '/network.protocol-handler.app.magnet/d' "$PREFS"
        echo 'user_pref("network.protocol-handler.expose.magnet", false);' >> "$PREFS"
        echo 'user_pref("network.protocol-handler.external.magnet", true);' >> "$PREFS"
        echo "  ✓ Firefox: $PREFS"
    done
else
    echo "  ⚠ Firefox: nessun profilo trovato"
fi
for browser in google-chrome chromium vivaldi; do
    command -v "$browser" &>/dev/null && echo "  ✓ $browser: usa xdg-open automaticamente"
done
echo ""

# ── Test connessione ──────────────────────────────────────────
echo "→ Test connessione EXTTO ($EXTTO_URL) ..."
if curl -s --max-time 3 "$EXTTO_URL/api/torrent-tags" &>/dev/null; then
    echo "  ✓ EXTTO raggiungibile"
else
    echo "  ⚠ EXTTO non raggiungibile — assicurati che sia in esecuzione"
fi
echo ""

echo "╔══════════════════════════════════════════════╗"
echo "║  ✅ Installazione completata!                 ║"
echo "╚══════════════════════════════════════════════╝"
echo ""
echo "⚠  Riavvia i browser aperti per applicare le modifiche."
echo ""
echo "Verifica:"
echo "  xdg-mime query default x-scheme-handler/magnet"
echo "  xdg-mime query default application/x-bittorrent"
"""
            mime = 'text/x-shellscript'

        else:
            return jsonify({'error': 'File non valido'}), 400

        resp = make_response(content)
        resp.headers['Content-Type']        = f'{mime}; charset=utf-8'
        resp.headers['Content-Disposition'] = f'attachment; filename="{requested}"'
        resp.headers['Cache-Control']       = 'no-cache'
        return resp

    except Exception as e:
        logger.error(f"browser_handlers_download: {e}")
        return jsonify({'error': str(e)}), 500


@app.route('/api/amule/ed2k-install', methods=['GET'])
def amule_ed2k_install():
    """Genera script per registrare ed2k:// come protocol handler su Linux."""
    import os, getpass
    try:
        s    = _cdb.get_all_settings()
        port = s.get('flask_port', '5000')
        host = s.get('flask_host', '127.0.0.1')
        base_url = f"http://{host}:{port}"
        handler_script = f"""#!/bin/bash
# extto-ed2k-handler.sh — Invia link ed2k:// ad EXTTO/aMule
LINK="$1"
curl -sf "{base_url}/api/amule/ed2k-handler?link=$(python3 -c 'import sys,urllib.parse; print(urllib.parse.quote(sys.argv[1]))' "$LINK")" \
    && notify-send "aMule" "Link ed2k aggiunto" 2>/dev/null || true
"""
        desktop_file = f"""[Desktop Entry]
Name=EXTTO ed2k Handler
Exec={os.path.expanduser('~')}/.local/bin/extto-ed2k-handler.sh %u
Type=Application
NoDisplay=true
MimeType=x-scheme-handler/ed2k;
"""
        install_cmds = f"""mkdir -p ~/.local/bin ~/.local/share/applications
cat > ~/.local/bin/extto-ed2k-handler.sh << 'SCRIPT'
{handler_script}SCRIPT
chmod +x ~/.local/bin/extto-ed2k-handler.sh
cat > ~/.local/share/applications/ed2k.desktop << 'DESKTOP'
{desktop_file}DESKTOP
update-desktop-database ~/.local/share/applications
xdg-mime default ed2k.desktop x-scheme-handler/ed2k
echo "✓ Protocol handler ed2k:// registrato. Riavvia il browser."
"""
        return jsonify({
            'success': True,
            'handler_script': handler_script,
            'desktop_file':   desktop_file,
            'install_cmds':   install_cmds,
            'base_url':       base_url,
        })
    except Exception as e:
        return jsonify({'success': False, 'error': str(e)}), 500


@app.route('/api/amule/generate-service', methods=['GET'])
def amule_generate_service():
    """Genera il contenuto del file .service systemd per amuled (user service)."""
    try:
        import os, getpass
        s = _cdb.get_all_settings()
        service_name = s.get('amule_service', 'amule-daemon').strip()
        amuled_bin   = '/usr/bin/amuled'
        content = f"""[Unit]
Description=aMule Daemon (gestito da EXTTO)
After=network.target

[Service]
Type=forking
ExecStart={amuled_bin} -f
Restart=on-failure
RestartSec=10s
TimeoutStopSec=30s

[Install]
WantedBy=default.target
"""
        install_cmd = (
            f'mkdir -p ~/.config/systemd/user/ && '
            f'cp {service_name}.service ~/.config/systemd/user/ && '
            f'systemctl --user daemon-reload && '
            f'systemctl --user enable {service_name}'
        )
        return jsonify({
            'success': True,
            'filename': f'{service_name}.service',
            'content': content,
            'install_cmd': install_cmd,
        })
    except Exception as e:
        return jsonify({'success': False, 'error': str(e)}), 500




@app.route('/api/restart-scrape', methods=['POST'])
def restart_scrape():
    """
    Riavvio Infallibile: Chiude brutalmente il processo.
    Grazie a 'Restart=always' nel file service, systemd lo riavvierà automaticamente.
    """
    try:
        log_maintenance("🔄 Riavvio richiesto dalla Web UI. Spegnimento in corso, systemd lo riavvierà tra 10 secondi...")
        
        def _kill_system():
            import time, os, signal
            # Aspetta 1.5 secondi per permettere al server di rispondere "OK" al browser
            time.sleep(1.5) 
            
            # 1. Invia il segnale di stop al processo padre (il motore extto3.py)
            try:
                os.kill(os.getppid(), signal.SIGTERM)
            except Exception as e:
                logger.warning(f"SIGTERM to parent: {e}")
                pass
                
            # 2. Chiude se stesso (la Web UI)
            os._exit(1)
            
        import threading
        threading.Thread(target=_kill_system, daemon=True).start()
        
        return jsonify({'success': True, 'message': 'Riavvio innescato con successo.'}), 200
    except Exception as e:
        return jsonify({'success': False, 'error': str(e)}), 500

@app.route('/api/set-speed-limits', methods=['POST'])
def set_speed_limits():
    """Imposta i limiti di velocità per il client attivo (universale)."""
    try:
        data = request.get_json(silent=True) or {}
        dl_kbps = int(data.get('dl_kbps', 0))
        ul_kbps = int(data.get('ul_kbps', 0))
        
        config = parse_series_config()
        settings = config.get('settings', {})
        
        # --- 1. GESTIONE LIBTORRENT (EMBEDDED) ---
        if str(settings.get('libtorrent_enabled', 'no')).lower() in ['yes', 'true', '1']:
            # SALVATAGGIO IN KB/s NEL FILE DI CONFIGURAZIONE
            config['settings']['libtorrent_dl_limit'] = str(dl_kbps)
            config['settings']['libtorrent_ul_limit'] = str(ul_kbps)
            save_series_config(config)
            
            # Applica immediatamente alla sessione libtorrent attiva
            import requests as _req
            try:
                r = _req.post(
                    f'http://127.0.0.1:{get_engine_port()}/api/torrents/apply_settings',
                    json={'dl_kbps': dl_kbps, 'ul_kbps': ul_kbps},
                    timeout=15
                )
                if r.status_code == 200:
                    return jsonify({'success': True, 'message': 'Limiti applicati a libtorrent e salvati'})
            except Exception as e:
                logger.warning(f"set_limits libtorrent: {e}")
            return jsonify({'success': True, 'message': 'Limiti salvati nel DB. Motore non raggiungibile, riavvia per applicarli.'})

        # --- 2. GESTIONE QBITTORRENT ---
        elif str(settings.get('qbittorrent_enabled', 'no')).lower() in ['yes', 'true', '1']:
            qb_url = settings.get('qbittorrent_url', '')
            qb_user = settings.get('qbittorrent_username', '')
            qb_pass = settings.get('qbittorrent_password', '')
            try:
                import requests
                session = requests.Session()
                r = session.post(f"{qb_url}/api/v2/auth/login", data={'username': qb_user, 'password': qb_pass}, timeout=5)
                if _qbt_ok(r):
                    # qBittorrent vuole i limiti in Bytes/s
                    dl_bytes = dl_kbps * 1024
                    ul_bytes = ul_kbps * 1024
                    session.post(f"{qb_url}/api/v2/transfer/setDownloadLimit", data={'limit': dl_bytes}, timeout=5)
                    session.post(f"{qb_url}/api/v2/transfer/setUploadLimit", data={'limit': ul_bytes}, timeout=5)
                    return jsonify({'success': True, 'message': 'Limiti inviati a qBittorrent'})
                return jsonify({'success': False, 'error': 'Login qBittorrent fallito'})
            except Exception as e:
                return jsonify({'success': False, 'error': f'Impossibile contattare qBit: {str(e)}'})

        # --- 3. GESTIONE TRANSMISSION ---
        elif str(settings.get('transmission_enabled', 'no')).lower() in ['yes', 'true', '1']:
            tr_url = settings.get('transmission_url', '')
            tr_user = settings.get('transmission_username', '')
            tr_pass = settings.get('transmission_password', '')
            try:
                import requests
                auth = (tr_user, tr_pass) if tr_user else None
                r = requests.post(tr_url, auth=auth, timeout=5)
                session_id = r.headers.get('X-Transmission-Session-Id', '')
                
                # Transmission vuole i limiti in KB/s
                payload = {
                    'method': 'session-set',
                    'arguments': {
                        'speed-limit-down': dl_kbps,
                        'speed-limit-down-enabled': dl_kbps > 0,
                        'speed-limit-up': ul_kbps,
                        'speed-limit-up-enabled': ul_kbps > 0
                    }
                }
                headers = {'X-Transmission-Session-Id': session_id}
                r = requests.post(tr_url, json=payload, headers=headers, auth=auth, timeout=5)
                if r.status_code == 409:
                    headers['X-Transmission-Session-Id'] = r.headers.get('X-Transmission-Session-Id', '')
                    r = requests.post(tr_url, json=payload, headers=headers, auth=auth, timeout=5)
                
                if r.status_code == 200:
                    return jsonify({'success': True, 'message': 'Limiti inviati a Transmission'})
                return jsonify({'success': False, 'error': 'Impossibile impostare limiti su Transmission'})
            except Exception as e:
                return jsonify({'success': False, 'error': f'Impossibile contattare Transmission: {str(e)}'})

        return jsonify({'success': False, 'error': 'Nessun client torrent supportato è abilitato.'})
    except Exception as e:
        return jsonify({'success': False, 'error': str(e)}), 500

@app.route('/api/send-magnet', methods=['POST'])
def send_magnet():
    """Invia magnet al client torrent configurato"""
    try:
        data = request.get_json(silent=True) or {}
        magnet = data.get('magnet', '')
        save_path = data.get('save_path', '').strip()
        
        if not magnet:
            return jsonify({'success': False, 'error': 'Magnet mancante'}), 400
        
        # Leggi configurazione per sapere quale client usare
        config = parse_series_config()
        settings = config.get('settings', {})
        
        # Prova qBittorrent
        if settings.get('qbittorrent_enabled') == 'yes':
            qb_url = settings.get('qbittorrent_url', '')
            qb_user = settings.get('qbittorrent_username', '')
            qb_pass = settings.get('qbittorrent_password', '')
            try:
                login_url = f"{qb_url}/api/v2/auth/login"
                session = requests.Session()
                r = session.post(login_url, data={'username': qb_user, 'password': qb_pass}, timeout=5)
                if _qbt_ok(r):
                    add_data = {'urls': magnet, 'paused': 'true'}
                    if save_path: add_data['savepath'] = save_path
                    r = session.post(f"{qb_url}/api/v2/torrents/add", data=add_data, timeout=5)
                    if _qbt_ok(r):
                        push_notification('download', 'Scarico avviato', 'Torrent inviato a qBittorrent', {'magnet': magnet[:80]})
                        _save_tag_for_magnet(magnet, 'Manuale')
                        return jsonify({'success': True, 'message': 'Inviato a qBittorrent'})
            except Exception as e:
                pass
        
        # Prova Transmission
        if settings.get('transmission_enabled') == 'yes':
            tr_url = settings.get('transmission_url', '')
            tr_user = settings.get('transmission_username', '')
            tr_pass = settings.get('transmission_password', '')
            try:
                auth = (tr_user, tr_pass) if tr_user else None
                r = requests.post(tr_url, auth=auth, timeout=5)
                session_id = r.headers.get('X-Transmission-Session-Id', '')
                payload = {'method': 'torrent-add', 'arguments': {'filename': magnet, 'paused': True}}
                if save_path: payload['arguments']['download-dir'] = save_path
                headers = {'X-Transmission-Session-Id': session_id}
                r = requests.post(tr_url, json=payload, headers=headers, auth=auth, timeout=5)
                if r.status_code == 409:
                    session_id = r.headers.get('X-Transmission-Session-Id', session_id)
                    headers['X-Transmission-Session-Id'] = session_id
                    r = requests.post(tr_url, json=payload, headers=headers, auth=auth, timeout=5)
                if r.status_code == 200:
                    push_notification('download', 'Scarico avviato', 'Torrent inviato a Transmission', {'magnet': magnet[:80]})
                    _save_tag_for_magnet(magnet, 'Manuale')
                    return jsonify({'success': True, 'message': 'Inviato a Transmission'})
            except Exception as e:
                pass
        
        # Prova libtorrent (embedded)
        if settings.get('libtorrent_enabled') == 'yes':
            try:
                # Se nessun save_path esplicito, cerca la temp_dir dalla regola del tag
                _lt_save = save_path
                if not _lt_save:
                    try:
                        _pending_tag = data.get('tag', '').strip()
                        if _pending_tag:
                            _rules = _cdb.get_setting('tag_dir_rules', [])
                            for _r in (_rules if isinstance(_rules, list) else []):
                                if isinstance(_r, dict) and _r.get('tag', '').strip().lower() == _pending_tag.lower():
                                    _td = _r.get('temp_dir', '').strip()
                                    if _td:
                                        _lt_save = _td
                                        logger.debug(f"send-magnet: tag='{_pending_tag}' → temp_dir={_lt_save}")
                                    break
                    except Exception as _te:
                        logger.debug(f"tag_dir temp lookup: {_te}")
                payload = {'magnet': magnet}
                if _lt_save: payload['save_path'] = _lt_save
                r = requests.post(
                    f'http://127.0.0.1:{get_engine_port()}/api/torrents/add',
                    json=payload,
                    timeout=10
                )
                if r.status_code == 200 and r.json().get('ok'):
                    push_notification('download', 'Scarico avviato', 'Torrent inviato a libtorrent', {'magnet': magnet[:80]})
                    _save_tag_for_magnet(magnet, 'Manuale')
                    _h = r.json().get('hash', '')
                    if _h: _save_tag_for_hash(_h, 'Manuale')
                    return jsonify({'success': True, 'message': 'Inviato a libtorrent'})
            except Exception as e:
                pass

        # Prova aria2 via RPC
        if settings.get('aria2_enabled') == 'yes':
            try:
                from core.clients.aria2 import Aria2Client
                a2 = Aria2Client(settings)
                if a2.rpc_url and a2._rpc_add(magnet):
                    push_notification('download', 'Scarico avviato', 'Torrent inviato a aria2c', {'magnet': magnet[:80]})
                    _save_tag_for_magnet(magnet, 'Manuale')
                    return jsonify({'success': True, 'message': 'Inviato a aria2c'})
            except Exception as e:
                logger.warning(f'send-magnet aria2 error: {e}')

        # Prova rqbit via HTTP API
        if settings.get('rqbit_enabled') == 'yes':
            try:
                from core.clients.rqbit import RqbitClient
                rq = RqbitClient(settings)
                if rq.enabled and rq.add(magnet, settings):
                    push_notification('download', 'Scarico avviato', 'Torrent inviato a rqbit', {'magnet': magnet[:80]})
                    _save_tag_for_magnet(magnet, 'Manuale')
                    return jsonify({'success': True, 'message': 'Inviato a rqbit'})
            except Exception as e:
                logger.warning(f'send-magnet rqbit error: {e}')

        return jsonify({'success': False, 'error': 'Nessun client torrent configurato o disponibile'}), 500

    except Exception as e:
        return jsonify({'success': False, 'error': str(e)}), 500

@app.route('/api/upload-torrent', methods=['POST'])
def upload_torrent():
    """Upload e invio file .torrent al client"""
    try:
        data = request.json or {}
        filename = data.get('filename', 'uploaded.torrent')
        file_data = data.get('data', '')
        download_now = data.get('download_now', True)
        save_path = data.get('save_path', '').strip()
        
        if not file_data:
            return jsonify({'success': False, 'error': 'File mancante'}), 400
        
        import base64
        torrent_bytes = base64.b64decode(file_data)
        config = parse_series_config()
        settings = config.get('settings', {})
        
        if not download_now:
            return jsonify({'success': True, 'message': 'File torrent ricevuto (non inviato al client)'})
        
        # Prova qBittorrent
        if settings.get('qbittorrent_enabled') == 'yes':
            qb_url = settings.get('qbittorrent_url', '')
            qb_user = settings.get('qbittorrent_username', '')
            qb_pass = settings.get('qbittorrent_password', '')
            try:
                login_url = f"{qb_url}/api/v2/auth/login"
                session = requests.Session()
                r = session.post(login_url, data={'username': qb_user, 'password': qb_pass}, timeout=5)
                if _qbt_ok(r):
                    add_url = f"{qb_url}/api/v2/torrents/add"
                    files = {'torrents': (filename, torrent_bytes, 'application/x-bittorrent')}
                    add_data = {'paused': 'true'}
                    if save_path: add_data['savepath'] = save_path
                    r = session.post(add_url, files=files, data=add_data, timeout=5)
                    if _qbt_ok(r):
                        return jsonify({'success': True, 'message': 'File .torrent inviato a qBittorrent'})
            except Exception as e:
                pass
        
        # Prova Transmission
        if settings.get('transmission_enabled') == 'yes':
            tr_url = settings.get('transmission_url', '')
            tr_user = settings.get('transmission_username', '')
            tr_pass = settings.get('transmission_password', '')
            try:
                r = requests.post(tr_url, auth=(tr_user, tr_pass), timeout=5)
                session_id = r.headers.get('X-Transmission-Session-Id', '')
                torrent_b64 = base64.b64encode(torrent_bytes).decode('utf-8')
                payload = {'method': 'torrent-add', 'arguments': {'metainfo': torrent_b64, 'paused': True}}
                if save_path: payload['arguments']['download-dir'] = save_path
                headers = {'X-Transmission-Session-Id': session_id}
                r = requests.post(tr_url, json=payload, headers=headers, auth=(tr_user, tr_pass), timeout=5)
                if r.status_code == 200:
                    return jsonify({'success': True, 'message': 'File .torrent inviato a Transmission'})
            except Exception as e:
                pass
        
        # Prova libtorrent (embedded)
        if settings.get('libtorrent_enabled', 'yes') in ('yes', 'true', '1'):
            try:
                import base64 as _b64
                logger.info(f"📤 Sending file packet to local libtorrent (Port {get_engine_port()})...")
                payload = {'data': _b64.b64encode(torrent_bytes).decode('utf-8'), 'filename': filename}
                if save_path: payload['save_path'] = save_path
                r = requests.post(
                    f'http://127.0.0.1:{get_engine_port()}/api/torrents/add_torrent_file',
                    json=payload,
                    timeout=10
                )
                if r.status_code == 200 and r.json().get('ok'):
                    _lt_hash = r.json().get('hash', '')
                    if _lt_hash:
                        _save_tag_for_hash(_lt_hash, 'Manuale')
                    return jsonify({'success': True, 'message': 'File .torrent inviato a libtorrent', 'hash': _lt_hash})
                else:
                    err_msg = r.json().get('error', 'Sconosciuto') if r.status_code == 200 else r.text
                    return jsonify({'success': False, 'error': f'Errore libtorrent: {err_msg}'})
            except Exception as e:
                pass

        # Prova aria2 via RPC (addTorrent con base64)
        if settings.get('aria2_enabled') == 'yes':
            try:
                import base64 as _b64
                from core.clients.aria2 import Aria2Client
                a2 = Aria2Client(settings)
                if a2.rpc_url:
                    torrent_b64 = _b64.b64encode(torrent_bytes).decode('utf-8')
                    opts = {}
                    if save_path:
                        opts['dir'] = save_path
                    elif a2.dir:
                        opts['dir'] = a2.dir
                    j = a2._rpc_post('aria2.addTorrent', torrent_b64, [], opts)
                    if 'result' in j:
                        gid = j['result']
                        with a2._gids_lock:
                            a2._pending_gids.add(gid)
                        push_notification('download', 'Scarico avviato', f'File .torrent inviato a aria2c (GID {gid})', {})
                        _save_tag_for_magnet(filename, 'Manuale')
                        return jsonify({'success': True, 'message': f'File .torrent inviato a aria2c'})
            except Exception as e:
                logger.warning(f'upload-torrent aria2 error: {e}')

        # Prova rqbit via HTTP API
        if settings.get('rqbit_enabled') == 'yes':
            try:
                from core.clients.rqbit import RqbitClient
                rq = RqbitClient(settings)
                if rq.enabled and rq.add_torrent_bytes(torrent_bytes, filename):
                    push_notification('download', 'Scarico avviato', f'File .torrent inviato a rqbit ({filename})', {})
                    _save_tag_for_magnet(filename, 'Manuale')
                    return jsonify({'success': True, 'message': 'File .torrent inviato a rqbit'})
            except Exception as e:
                logger.warning(f'upload-torrent rqbit error: {e}')

        return jsonify({'success': False, 'error': 'Nessun client torrent configurato o disponibile'}), 500

    except Exception as e:
        return jsonify({'success': False, 'error': str(e)}), 500

# Proxy per torrents (timeout aumentato a 30s)

# ---------------------------------------------------------------------------
# TORRENT META (tag + stato UI) — SQLite, tabella torrent_meta in extto_series.db
# Sostituisce torrent_tags.json — migrazione automatica al primo accesso
# ---------------------------------------------------------------------------

_HASH_RE_TAG = __import__('re').compile(r'btih:([a-fA-F0-9]{40})', __import__('re').I)

def _torrent_meta_db():
    """Connessione al DB serie; crea torrent_meta se non esiste e migra torrent_tags.json."""
    import sqlite3 as _sq
    conn = _sq.connect(DB_FILE, check_same_thread=False)
    conn.execute("""
        CREATE TABLE IF NOT EXISTS torrent_meta (
            hash        TEXT PRIMARY KEY,
            tag         TEXT DEFAULT '',
            ui_state    TEXT DEFAULT '',
            progress    REAL DEFAULT 0,
            paused      INTEGER DEFAULT 0,
            total_size  INTEGER DEFAULT 0,
            downloaded  INTEGER DEFAULT 0,
            name        TEXT DEFAULT '',
            updated_at  INTEGER DEFAULT 0,
            no_rename   INTEGER DEFAULT 0
        )
    """)
    conn.commit()
    # Migration: aggiunge no_rename se il DB è precedente
    try:
        conn.execute("ALTER TABLE torrent_meta ADD COLUMN no_rename INTEGER DEFAULT 0")
        conn.commit()
    except Exception:
        pass  # Colonna già esistente
    # Migration: aggiunge dl_source (sorgente download: ExtTo, Jackett, ThePirateBay, ...)
    try:
        conn.execute("ALTER TABLE torrent_meta ADD COLUMN dl_source TEXT DEFAULT ''")
        conn.commit()
    except Exception:
        pass
    # Migrazione una-tantum da torrent_tags.json
    _migrate_tags_json(conn)
    return conn

_tags_migrated = False
def _migrate_tags_json(conn):
    """Importa torrent_tags.json nel DB se non ancora migrato."""
    global _tags_migrated
    if _tags_migrated:
        return
    _tags_migrated = True
    try:
        import json as _json
        tags_file = os.path.join(os.path.dirname(os.path.abspath(__file__)), 'torrent_tags.json')
        if not os.path.exists(tags_file):
            return
        with open(tags_file, 'r', encoding='utf-8') as f:
            tags = _json.load(f)
        if not tags:
            return
        conn.executemany("""
            INSERT OR IGNORE INTO torrent_meta (hash, tag, updated_at)
            VALUES (?, ?, strftime('%s','now'))
        """, [(h.lower(), t) for h, t in tags.items() if t])
        conn.commit()
        # Rinomina il file originale come backup
        os.rename(tags_file, tags_file + '.migrated')
        logger.info(f"[torrent_meta] Migrati {len(tags)} tag da torrent_tags.json → DB")
    except Exception as e:
        logger.debug(f"_migrate_tags_json: {e}")

def _save_tag_for_hash(info_hash: str, tag: str) -> bool:
    """Salva il tag per un hash nella tabella torrent_meta."""
    if not info_hash or not tag:
        return False
    try:
        with _torrent_meta_db() as conn:
            conn.execute("""
                INSERT INTO torrent_meta (hash, tag, updated_at)
                VALUES (?, ?, strftime('%s','now'))
                ON CONFLICT(hash) DO UPDATE SET tag=excluded.tag, updated_at=excluded.updated_at
            """, (info_hash.lower(), str(tag).strip()))
        return True
    except Exception as e:
        logger.debug(f"_save_tag_for_hash: {e}")
        return False

def _save_tag_for_magnet(magnet: str, tag: str) -> bool:
    """Estrae l'hash dal magnet e chiama _save_tag_for_hash."""
    m = _HASH_RE_TAG.search(magnet or '')
    if not m:
        return False
    return _save_tag_for_hash(m.group(1).lower(), tag)

def _save_ui_state_db(snapshot: dict) -> None:
    """Salva snapshot {hash: {ui_state,progress,paused,total_size,downloaded,name}} nel DB."""
    if not snapshot:
        return
    try:
        import time as _t
        now = int(_t.time())
        with _torrent_meta_db() as conn:
            conn.executemany("""
                INSERT INTO torrent_meta (hash, ui_state, progress, paused, total_size, downloaded, name, updated_at)
                VALUES (?, ?, ?, ?, ?, ?, ?, ?)
                ON CONFLICT(hash) DO UPDATE SET
                    ui_state=excluded.ui_state, progress=excluded.progress,
                    paused=excluded.paused, total_size=excluded.total_size,
                    downloaded=excluded.downloaded, name=excluded.name,
                    updated_at=excluded.updated_at
            """, [
                (ih, v.get('state',''), v.get('progress',0), int(v.get('paused',0)),
                 v.get('total_size',0), v.get('downloaded',0), v.get('name',''), now)
                for ih, v in snapshot.items()
            ])
    except Exception as e:
        logger.debug(f"_save_ui_state_db: {e}")

def _load_ui_state_db() -> dict:
    """Carica tutti i record torrent_meta. Ritorna {hash: {state, progress, ...}}."""
    try:
        with _torrent_meta_db() as conn:
            rows = conn.execute(
                "SELECT hash, ui_state, progress, paused, total_size, downloaded, name FROM torrent_meta"
            ).fetchall()
        return {
            r[0]: {'state': r[1], 'progress': r[2], 'paused': bool(r[3]),
                   'total_size': r[4], 'downloaded': r[5], 'name': r[6]}
            for r in rows
        }
    except Exception as e:
        logger.debug(f"_load_ui_state_db: {e}")
        return {}


@app.route('/api/torrent-tags', methods=['GET'])
def get_torrent_tags():
    """Restituisce tutti i tag associati agli hash."""
    try:
        with _torrent_meta_db() as conn:
            rows = conn.execute("SELECT hash, tag FROM torrent_meta WHERE tag != ''").fetchall()
        return jsonify({r[0]: r[1] for r in rows})
    except Exception as e:
        logger.debug(f"get_tags: {e}")
        return jsonify({})

@app.route('/api/torrent-tags', methods=['POST'])
def set_torrent_tags():
    """Salva o rimuove tag. Riceve { "hash1": "NomeTag", "hash2": "" }."""
    try:
        data = request.json or {}
        with _torrent_meta_db() as conn:
            for h, t in data.items():
                h = h.lower()
                if t:
                    conn.execute("""
                        INSERT INTO torrent_meta (hash, tag, updated_at)
                        VALUES (?, ?, strftime('%s','now'))
                        ON CONFLICT(hash) DO UPDATE SET tag=excluded.tag, updated_at=excluded.updated_at
                    """, (h, str(t).strip()))
                else:
                    conn.execute("UPDATE torrent_meta SET tag='' WHERE hash=?", (h,))
        return jsonify({'success': True})
    except Exception as e:
        logger.warning(f"set_tags: {e}")
        return jsonify({'success': False, 'error': str(e)}), 500




@app.route('/api/tag-dir-rules', methods=['GET'])
def get_tag_dir_rules():
    """Restituisce la lista delle regole cartelle per tag: [{tag, temp_dir, final_dir}, ...]"""
    try:
        rules = _cdb.get_setting('tag_dir_rules', [])
        if not isinstance(rules, list):
            rules = []
        return jsonify(rules)
    except Exception as e:
        logger.exception(f"get_tag_dir_rules: {e}")
        return jsonify([]), 500


@app.route('/api/tag-dir-rules', methods=['POST'])
def save_tag_dir_rules():
    """Salva la lista delle regole cartelle per tag."""
    try:
        rules = request.get_json(silent=True)
        if not isinstance(rules, list):
            return jsonify({'success': False, 'error': 'Payload non valido'}), 400
        clean = []
        for r in rules:
            if not isinstance(r, dict):
                continue
            tag = r.get('tag', '').strip()
            if not tag:
                continue
            clean.append({
                'tag':       tag,
                'temp_dir':  r.get('temp_dir',  '').strip(),
                'final_dir': r.get('final_dir', '').strip(),
            })
        _cdb.set_setting('tag_dir_rules', clean)
        return jsonify({'success': True})
    except Exception as e:
        logger.exception(f"save_tag_dir_rules: {e}")
        return jsonify({'success': False, 'error': str(e)}), 500


@app.route('/api/torrent-no-rename', methods=['GET'])
def get_torrent_no_rename():
    """Restituisce il dizionario {hash: no_rename} per tutti i torrent con il flag attivo."""
    try:
        with _torrent_meta_db() as conn:
            rows = conn.execute("SELECT hash, no_rename FROM torrent_meta WHERE no_rename=1").fetchall()
        return jsonify({r[0]: bool(r[1]) for r in rows})
    except Exception as e:
        logger.debug(f"get_no_rename: {e}")
        return jsonify({})

@app.route('/api/torrent-no-rename', methods=['POST'])
def set_torrent_no_rename():
    """Imposta/rimuove il flag no_rename. Riceve { \"hash1\": true/false, ... }."""
    try:
        data = request.json or {}
        with _torrent_meta_db() as conn:
            for h, val in data.items():
                h = h.lower()
                flag = 1 if val else 0
                conn.execute("""
                    INSERT INTO torrent_meta (hash, no_rename, updated_at)
                    VALUES (?, ?, strftime('%s','now'))
                    ON CONFLICT(hash) DO UPDATE SET no_rename=excluded.no_rename, updated_at=excluded.updated_at
                """, (h, flag))
        return jsonify({'success': True})
    except Exception as e:
        logger.warning(f"set_no_rename: {e}")
        return jsonify({'success': False, 'error': str(e)}), 500


@app.route('/api/maintenance/clean-trash', methods=['POST'])
def clean_trash():
    """Elimina i file nel cestino più vecchi di trash_retention_days giorni."""
    try:
        from core.config import Config as _Cfg
        cfg = _Cfg()
        trash_path = str(getattr(cfg, 'trash_path', '')).strip()
        if not trash_path:
            return jsonify({'success': False, 'error': 'Cartella cestino non configurata'})
        if not os.path.exists(trash_path):
            return jsonify({'success': False, 'error': f'Cartella cestino non trovata: {trash_path}'})

        # trash_retention_days non è in Config — leggi da config_db
        try:
            import core.config_db as _cdb_tr
            days_raw = str(_cdb_tr.get_setting('trash_retention_days', '') or '').strip()
        except Exception:
            days_raw = str(getattr(cfg, 'trash_retention_days', '')).strip()
        if not days_raw:
            days = None  # Nessun limite: svuota tutto
        else:
            try:
                days = int(days_raw)
                if days < 0:
                    return jsonify({'success': False, 'error': 'Il numero di giorni deve essere >= 0'})
            except ValueError:
                return jsonify({'success': False, 'error': f'Valore giorni non valido: {days_raw}'})

        import time
        cutoff = (time.time() - days * 86400) if (days is not None and days > 0) else float('inf')
        deleted = 0
        freed = 0

        age_desc = f'più vecchi di {days} giorni' if (days is not None and days > 0) else 'tutti'
        log_maintenance(f"🗑️ Pulizia cestino: file {age_desc} in {trash_path}...")
        for fname in os.listdir(trash_path):
            fpath = os.path.join(trash_path, fname)
            if not os.path.isfile(fpath):
                continue
            try:
                mtime = os.path.getmtime(fpath)
                if mtime < cutoff:
                    size = os.path.getsize(fpath)
                    os.remove(fpath)
                    freed += size
                    deleted += 1
            except Exception as e:
                log_maintenance(f"⚠️ Errore rimozione {fname}: {e}")

        freed_mb = round(freed / 1024 / 1024, 2)
        age_label = f" più vecchi di {days} giorni" if (days is not None and days > 0) else ""
        msg = f"Rimossi {deleted} file ({freed_mb} MB liberati){age_label}"
        log_maintenance(f"✅ Pulizia cestino completata: {msg}")
        return jsonify({'success': True, 'deleted': deleted, 'freed_mb': freed_mb, 'message': msg})

    except Exception as e:
        return jsonify({'success': False, 'error': str(e)})

def log_maintenance(msg):
    """Scrive il log usando il logger principale che gestisce la rotazione automatica."""
    try:
        from core.constants import logger as core_logger
        # Invia il messaggio al logger rotante (che lo scrive nel file log e nel terminale)
        core_logger.info(msg)
    except Exception as e:
        print(f"log_maintenance fallback: {e}")
        # Fallback di super-emergenza: scrive solo sul terminale se il logger è rotto
        line = f"{datetime.now().strftime('%H:%M:%S')} - {msg}"
        print(line, flush=True)

@app.route('/api/db/info', methods=['GET'])
def get_db_info():
    """Restituisce le dimensioni e lo stato dei database SQLite."""
    try:
        log_maintenance("ℹ️ Database status info requested (UI Update)")
        
        def get_file_info(filepath):
            if not os.path.exists(filepath): return {"size_mb": 0, "frag": 0}
            size = os.path.getsize(filepath) / (1024 * 1024)
            try:
                with sqlite3.connect(filepath) as conn:
                    c = conn.cursor()
                    c.execute("PRAGMA page_count")
                    pages = c.fetchone()[0]
                    c.execute("PRAGMA freelist_count")
                    free = c.fetchone()[0]
                    frag = round((free / pages) * 100, 1) if pages > 0 else 0
                return {"size_mb": round(size, 2), "frag": frag}
            except Exception as e:
                logger.debug(f"db_stats sqlite: {e}")
                return {"size_mb": round(size, 2), "frag": 0}

        series_info = get_file_info(DB_FILE)
        archive_info = get_file_info(ARCHIVE_FILE)
        
        archive_count = 0
        if os.path.exists(ARCHIVE_FILE):
            try:
                with sqlite3.connect(ARCHIVE_FILE) as conn:
                    archive_count = conn.execute("SELECT COUNT(*) FROM archive").fetchone()[0]
            except: pass

        return jsonify({
            'success': True,
            'series_db': series_info,
            'archive_db': archive_info,
            'archive_count': archive_count
        })
    except Exception as e:
        return jsonify({'success': False, 'error': str(e)}), 500

@app.route('/api/db/action', methods=['POST'])
def run_db_action():
    """Esegue VACUUM o ANALYZE sui database e registra nel log con dettagli."""
    try:
        data = request.json or {}
        action = data.get('action', '').upper()
        target = data.get('target', 'both')
        
        if action not in ['VACUUM', 'ANALYZE', 'REINDEX']:
            return jsonify({'success': False, 'error': 'Azione non valida'}), 400

        targets = []
        if target in ['series', 'both'] and os.path.exists(DB_FILE): targets.append(DB_FILE)
        if target in ['archive', 'both'] and os.path.exists(ARCHIVE_FILE): targets.append(ARCHIVE_FILE)

        log_maintenance(f"🛠️ Starting DB maintenance: {action} on selected files...")
        
        # Calcolo peso prima dell'operazione
        size_before = sum(os.path.getsize(p) for p in targets if os.path.exists(p))

        # Esecuzione comando su tutti i DB selezionati
        for db_path in targets:
            with sqlite3.connect(db_path) as conn:
                conn.execute(action)

        # Calcolo peso dopo l'operazione
        size_after = sum(os.path.getsize(p) for p in targets if os.path.exists(p))
        saved_mb = max(0, (size_before - size_after) / (1024 * 1024))
        before_mb = size_before / (1024 * 1024)
        after_mb = size_after / (1024 * 1024)
        
        # Formattazione messaggi dettagliati
        msg = f"{action} completato."
        if action == 'VACUUM':
            msg += f" Space freed: {saved_mb:.2f} MB (Reduced from {before_mb:.2f} MB to {after_mb:.2f} MB)."
        elif action == 'ANALYZE':
            msg += " Internal index statistics recalculated to speed up search queries."
        elif action == 'REINDEX':
            msg += " All search indexes have been rebuilt from scratch."
            
        log_maintenance(f"✅ {msg}")

        return jsonify({'success': True, 'message': msg})
        
    except Exception as e:
        log_maintenance(f"❌ Errore {action}: {e}")
        return jsonify({'success': False, 'error': str(e)}), 500

@app.route('/api/db/rescore-episodes', methods=['POST'])
def rescore_episodes():
    """Ricalcola quality_score di tutti gli episodi dal titolo originale salvato nel DB.
    Strategia a cascata: original_title → feed_matches downloaded → feed_matches best
    → file fisico su disco → titolo rinominato (fallback).
    Aggiorna anche episode_archive_presence per evitare ridownload di episodi già sul NAS."""
    try:
        from core.models import Parser
        c = db.conn.cursor()
        # Recupera tutti i campi necessari, incluso series_name per la scansione disco
        try:
            rows = c.execute(
                """SELECT e.id, e.series_id, e.season, e.episode, e.title,
                          e.original_title, e.quality_score, e.archive_path,
                          s.name as series_name
                   FROM episodes e
                   JOIN series s ON e.series_id = s.id
                   WHERE e.title IS NOT NULL AND e.title != ''"""
            ).fetchall()
            has_original = True
        except Exception as e:
            logger.debug(f"upsert_series has_original: {e}")
            rows = c.execute(
                """SELECT e.id, e.series_id, e.season, e.episode, e.title,
                          e.quality_score, e.archive_path,
                          s.name as series_name
                   FROM episodes e
                   JOIN series s ON e.series_id = s.id
                   WHERE e.title IS NOT NULL AND e.title != ''"""
            ).fetchall()
            has_original = False

        # Costruisce mappa series_name → archive_path dalla config (series.txt)
        # così il disk scan funziona anche quando episodes.archive_path è vuoto
        series_path_map = {}
        # Apre core.database.Database una volta sola (ha _best_quality_in_path,
        # a differenza di ExtToDB che è la classe locale di extto_web)
        from core.database import Database as _CoreDB
        _coredb = _CoreDB()
        try:
            from core.models import normalize_series_name
            _scfg = parse_series_config()
            for _s in _scfg.get('series', []):
                _ap = (_s.get('archive_path') or '').strip()
                _sn = (_s.get('name') or '').strip()
                if _ap and _sn:
                    series_path_map[normalize_series_name(_sn)] = _ap
            logger.info(f"[RESCORE] Found {len(series_path_map)} series paths from config")
        except Exception as _me:
            logger.warning(f"[RESCORE] Error reading series config: {_me}")

        updated = 0
        skipped = 0
        no_original = 0
        archive_updated = 0
        from datetime import datetime, timezone
        now_iso = datetime.now(timezone.utc).isoformat()
        for row in rows:
            try:
                # Cascata per trovare il titolo più ricco di info qualità:
                # 1) original_title  2) feed 'downloaded'  3) feed best score
                # 4) file fisico NAS  5) title rinominato (fallback)
                score_title = None

                if has_original and row['original_title']:
                    score_title = row['original_title']

                if not score_title:
                    try:
                        fm = c.execute(
                            """SELECT title FROM episode_feed_matches
                               WHERE series_id=? AND season=? AND episode=? AND fail_reason='downloaded'
                               ORDER BY quality_score DESC LIMIT 1""",
                            (row['series_id'], row['season'], row['episode'])
                        ).fetchone()
                        if fm and fm['title']:
                            score_title = fm['title']
                    except Exception:
                        pass

                if not score_title:
                    try:
                        fm = c.execute(
                            """SELECT title FROM episode_feed_matches
                               WHERE series_id=? AND season=? AND episode=?
                               ORDER BY quality_score DESC LIMIT 1""",
                            (row['series_id'], row['season'], row['episode'])
                        ).fetchone()
                        if fm and fm['title']:
                            score_title = fm['title']
                    except Exception:
                        pass

                # Opzione 4: file fisico sul NAS
                # Priorità: archive_path dell'episodio → path dalla config (series.txt)
                # NOTA: db è ExtToDB (locale), non ha _best_quality_in_path.
                # Usiamo core.database.Database direttamente.
                if not score_title:
                    try:
                        series_name = row['series_name'] or ''
                        arch_path = row['archive_path'] or ''
                        if not arch_path and series_name and series_path_map:
                            from core.models import normalize_series_name
                            arch_path = series_path_map.get(normalize_series_name(series_name), '')
                        if arch_path and series_name:
                            disk_score = _coredb._best_quality_in_path(
                                series_name, row['season'], row['episode'], arch_path
                            )
                            if disk_score and disk_score > 0:
                                new_score = disk_score
                                if new_score != row['quality_score']:
                                    c.execute('UPDATE episodes SET quality_score=? WHERE id=?', (new_score, row['id']))
                                    updated += 1
                                    try:
                                        ap = c.execute(
                                            'SELECT best_quality_score FROM episode_archive_presence WHERE series_id=? AND season=? AND episode=?',
                                            (row['series_id'], row['season'], row['episode'])
                                        ).fetchone()
                                        if ap is not None and new_score >= (ap['best_quality_score'] or 0):
                                            c.execute(
                                                'UPDATE episode_archive_presence SET best_quality_score=?, at=? WHERE series_id=? AND season=? AND episode=?',
                                                (new_score, now_iso, row['series_id'], row['season'], row['episode'])
                                            )
                                            archive_updated += 1
                                    except Exception:
                                        pass
                                else:
                                    skipped += 1
                                continue
                    except Exception as de:
                        logger.debug(f"rescore disk scan: {de}")

                if not score_title:
                    score_title = row['title']
                    no_original += 1

                new_score = Parser.parse_quality(score_title).score()
                if new_score != row['quality_score']:
                    c.execute('UPDATE episodes SET quality_score=? WHERE id=?', (new_score, row['id']))
                    updated += 1
                    try:
                        ap = c.execute(
                            'SELECT best_quality_score FROM episode_archive_presence WHERE series_id=? AND season=? AND episode=?',
                            (row['series_id'], row['season'], row['episode'])
                        ).fetchone()
                        if ap is not None and new_score >= (ap['best_quality_score'] or 0):
                            c.execute(
                                'UPDATE episode_archive_presence SET best_quality_score=?, at=? WHERE series_id=? AND season=? AND episode=?',
                                (new_score, now_iso, row['series_id'], row['season'], row['episode'])
                            )
                            archive_updated += 1
                    except Exception as ae:
                        logger.debug(f"rescore archive_presence update: {ae}")
                else:
                    skipped += 1
            except Exception as e:
                logger.debug(f"upsert_series episode: {e}")
                skipped += 1

        db.conn.commit()
        note = f' ({no_original} senza titolo originale, usato titolo rinominato)' if no_original > 0 else ''
        arch_note = f', {archive_updated} archivi allineati' if archive_updated > 0 else ''
        msg = f'Ricalcolo completato: {updated} episodi aggiornati, {skipped} invariati (su {len(rows)} totali){note}{arch_note}.'
        log_maintenance(f'🔄 {msg}')
        return jsonify({'success': True, 'message': msg, 'updated': updated, 'skipped': skipped})
    except Exception as e:
        return jsonify({'success': False, 'error': str(e)}), 500



@app.route('/api/db/prune/preview', methods=['POST'])
def prune_archive_preview():
    """Anteprima dei record che verrebbero eliminati dalla pulizia archivio."""
    try:
        days = int((request.json or {}).get('days', 30))
        if not os.path.exists(ARCHIVE_FILE):
            return jsonify({'success': False, 'error': 'Archivio non trovato'})
        from datetime import timezone, timedelta
        cutoff = datetime.now(timezone.utc) - timedelta(days=days)
        cutoff_iso = cutoff.isoformat()
        with sqlite3.connect(ARCHIVE_FILE) as conn:
            conn.row_factory = sqlite3.Row
            c = conn.cursor()
            c.execute("SELECT COUNT(*) FROM archive")
            total = c.fetchone()[0]
            c.execute("SELECT COUNT(*) FROM archive WHERE added_at < ?", (cutoff_iso,))
            to_delete = c.fetchone()[0]
            c.execute("""SELECT source, COUNT(*) as cnt FROM archive
                         WHERE added_at < ? GROUP BY source ORDER BY cnt DESC LIMIT 10""", (cutoff_iso,))
            sources = [{'source': r['source'] or 'N/D', 'count': r['cnt']} for r in c.fetchall()]
            c.execute("""SELECT title, source, added_at FROM archive
                         WHERE added_at < ? ORDER BY added_at ASC LIMIT 5""", (cutoff_iso,))
            samples = [{'title': r['title'], 'source': r['source'] or '',
                        'added_at': (r['added_at'] or '')[:10]} for r in c.fetchall()]
        return jsonify({'success': True, 'total': total, 'to_delete': to_delete,
                        'keep': total - to_delete, 'cutoff_date': cutoff_iso[:10],
                        'sources': sources, 'samples': samples})
    except Exception as e:
        return jsonify({'success': False, 'error': str(e)}), 500


@app.route('/api/db/prune', methods=['POST'])
def prune_archive():
    """Elimina i record vecchi dall'archivio e registra nel log."""
    try:
        days = int((request.json or {}).get('days', 30))
        if not os.path.exists(ARCHIVE_FILE):
            return jsonify({'success': False, 'error': 'Archivio non trovato'})

        log_maintenance(f"🧹 Avvio pulizia Archivio (elementi più vecchi di {days} giorni)...")

        # Calcola il cutoff in Python: i valori added_at sono ISO con T+timezone,
        # datetime() di SQLite restituisce '2024-01-15 10:30:45' (spazio, no TZ),
        # la comparazione stringa fallirebbe sempre perché 'T' > ' '.
        from datetime import timezone, timedelta
        cutoff = datetime.now(timezone.utc) - timedelta(days=days)
        cutoff_iso = cutoff.isoformat()

        with sqlite3.connect(ARCHIVE_FILE) as conn:
            c = conn.cursor()
            c.execute("DELETE FROM archive WHERE added_at < ?", (cutoff_iso,))
            deleted = c.rowcount

        # Stessa pulizia su movie_feed_seen (extto_series.db)
        mfs_deleted = 0
        try:
            from core.database import Database as _CoreDB
            with _CoreDB() as _cdb:
                cur = _cdb.conn.cursor()
                cur.execute("DELETE FROM movie_feed_seen WHERE found_at < ?", (cutoff_iso,))
                mfs_deleted = cur.rowcount
                _cdb.conn.commit()
        except Exception as _mfs_e:
            log_maintenance(f"⚠️ Pulizia movie_feed_seen: {_mfs_e}")

        msg = f'Rimossi {deleted} elementi obsoleti dall\'archivio, {mfs_deleted} dal feed film'
        log_maintenance(f"✅ Pulizia completata: {msg}")

        return jsonify({'success': True, 'deleted': deleted, 'message': msg})

    except Exception as e:
        log_maintenance(f"❌ Errore Pulizia Archivio: {e}")
        return jsonify({'success': False, 'error': str(e)}), 500


# Range Unicode per i token script usati da prune_archive_keyword
_SCRIPT_RANGES = {
    '[cjk]':        [(0x4E00, 0x9FFF), (0x3400, 0x4DBF), (0xF900, 0xFAFF),
                     (0x3040, 0x30FF), (0xAC00, 0xD7AF), (0x3000, 0x303F)],
    '[cirillico]':  [(0x0400, 0x04FF), (0x0500, 0x052F)],
    '[arabo]':      [(0x0600, 0x06FF), (0x0750, 0x077F),
                     (0xFB50, 0xFDFF), (0xFE70, 0xFEFF)],
    '[ebraico]':    [(0x0590, 0x05FF), (0xFB00, 0xFB4F)],
    '[thai]':       [(0x0E00, 0x0E7F)],
    '[non-latino]': None,   # gestito a parte: qualsiasi lettera non latina
}

def _title_has_script(title: str, token: str) -> bool:
    """True se title contiene almeno un carattere del blocco Unicode indicato dal token."""
    ranges = _SCRIPT_RANGES.get(token)
    if token == '[non-latino]':
        import unicodedata as _ud
        return any(_ud.category(c)[0] == 'L' and ord(c) > 0x024F for c in title)
    if ranges is None:
        return False
    return any(any(lo <= ord(c) <= hi for lo, hi in ranges) for c in title)


@app.route('/api/db/prune-keyword', methods=['POST'])
def prune_archive_keyword():
    """
    Ricerca nell'archivio per parole chiave nel titolo.
    Supporta token script Unicode: [cjk] [cirillico] [arabo] [ebraico] [thai] [non-latino].
    Body JSON:
        keywords : str  — parole/token separati da virgola o spazio (OR implicito)
        limit    : int  — max risultati da restituire (default 500)
    """
    try:
        data  = request.json or {}
        raw   = str(data.get('keywords', '')).strip()
        limit = min(int(data.get('limit', 500)), 2000)

        if not raw:
            return jsonify({'success': False, 'error': 'Nessuna keyword specificata'})

        import re as _re
        all_parts     = [k.strip() for k in _re.split(r'[,\s]+', raw) if k.strip()]
        script_tokens = [p.lower() for p in all_parts if p.lower() in _SCRIPT_RANGES]
        _all_kws      = [k for k in all_parts if k.lower() not in _SCRIPT_RANGES and len(k) >= 2]
        # =keyword → word-boundary match (Python scan); plain keyword → LIKE substring
        exact_kws     = [k[1:] for k in _all_kws if k.startswith('=') and len(k) >= 3]
        regular_kws   = [k for k in _all_kws if not k.startswith('=')]

        if not script_tokens and not exact_kws and not regular_kws:
            return jsonify({'success': False, 'error': 'Keyword troppo corte (minimo 2 caratteri)'})

        if not os.path.exists(ARCHIVE_FILE):
            return jsonify({'success': False, 'error': 'Archivio non trovato'})

        with sqlite3.connect(ARCHIVE_FILE) as conn:
            conn.row_factory = sqlite3.Row
            c = conn.cursor()

            if not script_tokens and not exact_kws:
                # Fast path: solo SQL LIKE
                conditions = ' OR '.join(['title LIKE ?' for _ in regular_kws])
                params = [f'%{k}%' for k in regular_kws]
                c.execute(f"SELECT COUNT(*) FROM archive WHERE {conditions}", params)
                total = c.fetchone()[0]
                c.execute(
                    f"SELECT id, title, added_at FROM archive WHERE {conditions} ORDER BY added_at DESC LIMIT ?",
                    params + [limit]
                )
                rows = [{'id': r['id'], 'title': r['title'], 'added_at': r['added_at']} for r in c.fetchall()]
            else:
                # Scan Python: Unicode ranges o word-boundary (=keyword)
                c.execute("SELECT id, title, added_at FROM archive ORDER BY added_at DESC")
                matched = []
                for r in c:
                    title = r['title'] or ''
                    t_low = title.lower()
                    ok = any(kw.lower() in t_low for kw in regular_kws)
                    ok = ok or any(_re.search(rf'\b{_re.escape(kw.lower())}\b', t_low) for kw in exact_kws)
                    ok = ok or any(_title_has_script(title, tok) for tok in script_tokens)
                    if ok:
                        matched.append({'id': r['id'], 'title': title, 'added_at': r['added_at']})
                total = len(matched)
                rows  = matched[:limit]

        # Aggiunge risultati da movie_feed_seen (extto_series.db)
        try:
            from core.database import Database as _CoreDB
            with _CoreDB() as _cdb:
                _c2 = _cdb.conn.cursor()
                if not script_tokens and not exact_kws:
                    _cond = ' OR '.join(['(title LIKE ? OR name LIKE ?)' for _ in regular_kws])
                    _par  = [v for k in regular_kws for v in (f'%{k}%', f'%{k}%')]
                    _c2.execute(f"SELECT id, title, found_at FROM movie_feed_seen WHERE {_cond} ORDER BY found_at DESC LIMIT ?", _par + [limit])
                    mfs_rows = [{'id': r['id'], 'title': r['title'], 'added_at': r['found_at'], 'db': 'mfs'} for r in _c2.fetchall()]
                else:
                    _c2.execute("SELECT id, title, found_at FROM movie_feed_seen ORDER BY found_at DESC")
                    mfs_rows = []
                    for r in _c2:
                        _t = r['title'] or ''
                        _t_low = _t.lower()
                        ok = any(kw.lower() in _t_low for kw in regular_kws)
                        ok = ok or any(_re.search(rf'\b{_re.escape(kw.lower())}\b', _t_low) for kw in exact_kws)
                        ok = ok or any(_title_has_script(_t, tok) for tok in script_tokens)
                        if ok:
                            mfs_rows.append({'id': r['id'], 'title': _t, 'added_at': r['found_at'], 'db': 'mfs'})
                    mfs_rows = mfs_rows[:limit]
        except Exception as _mfs_e:
            log_maintenance(f"⚠️ keyword-search movie_feed_seen: {_mfs_e}")
            mfs_rows = []

        # Marca i record archivio con db='archive' e combina
        for row in rows:
            row['db'] = 'archive'
        combined     = rows + mfs_rows
        total_combined = total + len(mfs_rows)

        used_kws = regular_kws + ['=' + k for k in exact_kws] + script_tokens
        log_maintenance(f"🔍 Keyword-search '{', '.join(used_kws)}': {total} archivio + {len(mfs_rows)} feed film trovati")
        return jsonify({'success': True, 'total': total_combined, 'returned': len(combined),
                        'keywords': used_kws, 'rows': combined})

    except Exception as e:
        log_maintenance(f"❌ Errore keyword-search: {e}")
        return jsonify({'success': False, 'error': str(e)}), 500


@app.route('/api/db/prune-by-ids', methods=['POST'])
def prune_archive_by_ids():
    """
    Elimina dall'archivio i record con gli id specificati.
    Body JSON:
        ids : list[int]  — lista di id da eliminare
    """
    try:
        data = request.json or {}
        ids  = [int(i) for i in data.get('ids', []) if str(i).isdigit()]
        if not ids:
            return jsonify({'success': False, 'error': 'Nessun id specificato'})
        if not os.path.exists(ARCHIVE_FILE):
            return jsonify({'success': False, 'error': 'Archivio non trovato'})

        deleted = 0
        if ids:
            placeholders = ','.join('?' * len(ids))
            with sqlite3.connect(ARCHIVE_FILE) as conn:
                c = conn.cursor()
                c.execute(f"DELETE FROM archive WHERE id IN ({placeholders})", ids)
                deleted = c.rowcount

        mfs_deleted = 0
        movie_feed_ids = [int(i) for i in data.get('movie_feed_ids', []) if str(i).isdigit()]
        if movie_feed_ids:
            try:
                from core.database import Database as _CoreDB
                with _CoreDB() as _cdb:
                    _ph = ','.join('?' * len(movie_feed_ids))
                    _cdb.conn.execute(f"DELETE FROM movie_feed_seen WHERE id IN ({_ph})", movie_feed_ids)
                    mfs_deleted = _cdb.conn.execute("SELECT changes()").fetchone()[0]
                    _cdb.conn.commit()
            except Exception as _mfs_e:
                log_maintenance(f"⚠️ prune-by-ids movie_feed_seen: {_mfs_e}")

        total_deleted = deleted + mfs_deleted
        msg = f"Rimossi {deleted} dall'archivio, {mfs_deleted} dal feed film"
        log_maintenance(f"✅ Prune-by-ids: {msg}")
        return jsonify({'success': True, 'deleted': total_deleted, 'message': msg})

    except Exception as e:
        log_maintenance(f"❌ Errore prune-by-ids: {e}")
        return jsonify({'success': False, 'error': str(e)}), 500



PHYSICAL_FILE_CACHE = {}
CACHE_TTL = 15  # secondi — evita os.walk ripetuti ad ogni poll

_VIDEO_EXTS_PROXY = {'.mkv', '.mp4', '.avi', '.ts', '.m2ts', '.wmv'}

def _find_episode_on_disk(series_name: str, s_num: int, e_num: int,
                           archive_path: str, final_dir: str, temp_dir: str,
                           rename_fmt: str, rename_template: str) -> tuple:
    """
    Cerca un episodio SxxExx sul disco controllando ANCHE il nome della serie.
    """
    import os, re
    from core.models import normalize_series_name, _series_name_matches

    ep_re = re.compile(rf'(?i)s0*{s_num}[._\-\s]*e0*{e_num}(?!\d)')
    norm_series = normalize_series_name(series_name)

    def _scan_dir(base_dir: str, max_depth: int = 3) -> str:
        if not base_dir or not os.path.isdir(base_dir):
            return ''
        try:
            for root, dirs, files in os.walk(base_dir):
                depth = root[len(base_dir):].count(os.sep)
                if depth >= max_depth:
                    dirs[:] = []
                    continue
                for f in files:
                    if os.path.splitext(f)[1].lower() not in _VIDEO_EXTS_PROXY:
                        continue
                    if 'sample' in f.lower():
                        continue
                    rel = os.path.relpath(os.path.join(root, f), base_dir)
                    if ep_re.search(rel):
                        # Controllo blindato: il nome della serie deve essere nel file o nella cartella
                        norm_file = normalize_series_name(f)
                        norm_root = normalize_series_name(root)
                        
                        if _series_name_matches(norm_series, norm_file) or \
                           norm_series in norm_file or \
                           norm_series in norm_root:
                            return os.path.join(root, f)
        except OSError:
            pass
        return ''

    # 1. NAS
    if archive_path:
        season_dir = os.path.join(archive_path, f'Stagione {s_num}')
        for search_root in ([season_dir] if os.path.isdir(season_dir) else []) + [archive_path]:
            fpath = _scan_dir(search_root, max_depth=2)
            if fpath:
                return True, 'nas', fpath

    # 2. Cartella definitiva
    if final_dir and final_dir != archive_path:
        fpath = _scan_dir(final_dir, max_depth=3)
        if fpath:
            return True, 'final', fpath

    # 3. Cartella temporanea
    if temp_dir and temp_dir not in (final_dir, archive_path):
        fpath = _scan_dir(temp_dir, max_depth=3)
        if fpath:
            return True, 'temp', fpath

    return False, '', ''


@app.route('/api/debug/torrent_match', methods=['GET'])
def debug_torrent_match():
    """Debug endpoint: verifica perché un torrent non viene riconosciuto.
    Uso: /api/debug/torrent_match?name=Star.Trek.Starfleet.Academy.S01E10...mkv
    """
    from flask import request, jsonify
    import os, re
    from urllib.parse import unquote_plus
    from core.models import normalize_series_name, _series_name_matches

    t_name = request.args.get('name', '')
    cfg_data = parse_series_config()
    configured_series = cfg_data.get('series', [])
    settings = cfg_data.get('settings', {})
    final_dir = settings.get('libtorrent_dir', '').strip()
    temp_dir  = settings.get('libtorrent_temp_dir', '').strip()

    result = {'t_name': t_name, 'steps': []}

    m_ep = re.search(r'(?i)(?<![\w])S(\d{1,2})[.\s_-]*E(\d{1,3})(?![\d])', t_name)
    if not m_ep:
        result['steps'].append('NO SxxExx found in name')
        return jsonify(result)

    s_num, e_num = int(m_ep.group(1)), int(m_ep.group(2))
    prefix_raw   = t_name[:m_ep.start()]
    prefix_clean = re.sub(r'[._]+', ' ', prefix_raw).strip()
    norm_t_name  = normalize_series_name(prefix_clean)

    result['s_num'] = s_num
    result['e_num'] = e_num
    result['prefix_raw'] = prefix_raw
    result['prefix_clean'] = prefix_clean
    result['norm_t_name'] = norm_t_name
    result['final_dir'] = final_dir
    result['temp_dir'] = temp_dir

    series_matches = []
    for s in configured_series:
        nc = normalize_series_name(s.get('name', ''))
        m = _series_name_matches(nc, norm_t_name)
        series_matches.append({
            'name': s.get('name'),
            'norm': nc,
            'archive_path': s.get('archive_path', ''),
            'match': m
        })
    result['series_matches'] = series_matches

    matched = next((s for s in series_matches if s['match']), None)
    archive_path = matched['archive_path'] if matched else ''
    result['archive_path'] = archive_path
    result['archive_path_exists'] = os.path.isdir(archive_path) if archive_path else False
    result['final_dir_exists'] = os.path.isdir(final_dir) if final_dir else False

    found, where, found_fpath = _find_episode_on_disk(
        norm_t_name, s_num, e_num,
        archive_path, final_dir, temp_dir, 'base', ''
    )
    result['found'] = found
    result['where'] = where

    return jsonify(result)


@app.route('/api/libtorrent/update', methods=['POST'])
def api_libtorrent_update():
    """Aggiorna libtorrent nel venv corrente a una versione specifica via uv/pip.
    Body JSON: {'version': '2.0.13'}  — versione obbligatoria.
    L'aggiornamento ha effetto al prossimo riavvio del servizio.
    """
    from flask import jsonify, request as _req
    import sys, subprocess, shutil
    data = _req.get_json(silent=True) or {}
    version = str(data.get('version', '')).strip()
    if not version or not version.replace('.', '').isdigit():
        return jsonify({'ok': False, 'error': 'Versione non valida'}), 400

    pkg = f'libtorrent=={version}'
    python_bin = sys.executable

    # Prova uv (più veloce, usato da setup.sh); fallback a pip
    uv = shutil.which('uv')
    if not uv:
        for _p in (os.path.expanduser('~/.local/bin/uv'), os.path.expanduser('~/.cargo/bin/uv')):
            if os.path.isfile(_p):
                uv = _p
                break

    if uv:
        cmd = [uv, 'pip', 'install', '--python', python_bin, pkg]
    else:
        cmd = [python_bin, '-m', 'pip', 'install', pkg, '--quiet']

    try:
        result = subprocess.run(cmd, capture_output=True, text=True, timeout=180)
        ok = result.returncode == 0
        output = (result.stdout + result.stderr).strip()
        if ok:
            logger.info(f"✅ libtorrent aggiornato a {version} (riavvio necessario)")
        else:
            logger.warning(f"⚠️ libtorrent update fallito: {output[:200]}")
        return jsonify({'ok': ok, 'version': version, 'output': output})
    except subprocess.TimeoutExpired:
        return jsonify({'ok': False, 'error': 'Timeout (180s) durante aggiornamento'}), 500
    except Exception as e:
        logger.error(f"api_libtorrent_update: {e}")
        return jsonify({'ok': False, 'error': str(e)}), 500


@app.route('/api/torrents', methods=['GET'])
def proxy_torrents_base():
    """Proxy Torrents: Logica Diretta su Cartella (Bypassa il limite del DB per i Manuali)."""
    from flask import jsonify
    try:
        import requests
        resp = requests.get(f'http://127.0.0.1:{get_engine_port()}/api/torrents', timeout=3)
        if resp.status_code != 200: return resp.content, resp.status_code

        data = resp.json()
        torrents = data.get('torrents', []) if isinstance(data, dict) else data
        if isinstance(torrents, dict): torrents = list(torrents.values())

        # ---> INIZIO INIEZIONE DOWNLOAD HTTP NELLA TABELLA TORRENT <---
        try:
            from core.comics import ACTIVE_HTTP_DOWNLOADS
            if ACTIVE_HTTP_DOWNLOADS:
                torrents.extend(list(ACTIVE_HTTP_DOWNLOADS.values()))
        except Exception as e:
            logger.debug(f"list_torrents HTTP: {e}")
            pass
        # ---> FINE INIEZIONE <---

        # Carica dl_source da torrent_meta per mostrare la sorgente nel torrent manager
        try:
            with _torrent_meta_db() as _src_conn:
                _src_rows = _src_conn.execute(
                    "SELECT hash, dl_source FROM torrent_meta WHERE dl_source != ''"
                ).fetchall()
            _src_map = {r[0].lower(): r[1] for r in _src_rows}
        except Exception:
            _src_map = {}

        import re, os
        from urllib.parse import unquote_plus
        from core.models import normalize_series_name, _series_name_matches

        cfg_data = parse_series_config()
        configured_series = cfg_data.get('series', [])

        # Leggi le dir di download dalla config — usate per la ricerca a 3 livelli
        settings = cfg_data.get('settings', {})
        final_dir = settings.get('libtorrent_dir', '').strip()
        temp_dir  = settings.get('libtorrent_temp_dir', '').strip()
        rename_fmt      = settings.get('rename_format', 'base').strip().lower()
        rename_template = settings.get('rename_template',
                          '{Serie} - {Stagione}{Episodio} - {Titolo} [{Risoluzione}]').strip()

        import time as _time_mod
        now_ts = _time_mod.time()

        for t in torrents:
            t_name = unquote_plus(t.get('name', ''))
            if 'dl_source' not in t:
                t['dl_source'] = _src_map.get(t.get('hash', '').lower(), '')

            # ---> INIZIO FIX CONSUMI: Cattura il peso in tempo reale <---
            t_hash = t.get('hash', '')
            t_size = t.get('total_size', 0)
            if t_hash and t_size > 0:
                try:
                    c = db.conn.cursor()
                    c.execute("UPDATE episodes SET size_bytes=? WHERE magnet_hash=? AND size_bytes=0", (t_size, t_hash))
                    ep_rows = c.rowcount
                    c.execute("UPDATE movies SET size_bytes=? WHERE magnet_hash=? AND size_bytes=0", (t_size, t_hash))
                    mov_rows = c.rowcount
                    if ep_rows > 0 or mov_rows > 0:
                        db.conn.commit()
                except: pass
            # ---> FINE FIX CONSUMI <---

            # Cerca SxxExx nel nome del torrent.
            m_ep = re.search(r'(?i)(?<![\w])S(\d{1,2})[.\s_-]*E(\d{1,3})(?![\d])', t_name)
            if not m_ep:
                # SOLUZIONE STRUTTURALE FUMETTI/FILM:
                # Anche se non è una serie TV, controlliamo se il file esiste già fisicamente nella cartella
                if t_name and t_name != 'Tutto' and final_dir and os.path.exists(final_dir):
                    # Puliamo il nome del torrent da punti e underscore per un confronto sicuro
                    clean_tname = re.sub(r'[._]+', ' ', t_name).strip().lower()
                    if clean_tname:
                        for f_name in os.listdir(final_dir):
                            clean_fname = re.sub(r'[._]+', ' ', f_name).strip().lower()
                            # Se troviamo un file o cartella che combacia con il nome del torrent
                            if clean_tname in clean_fname or clean_fname in clean_tname:
                                t_prog = float(t.get('progress', 0))
                                is_finto_completato = t_prog >= 1.0 or (t_prog == 0.0 and t.get('completed_time', 0) > 0) or t.get('state') == 'error'
                                if is_finto_completato:
                                    t['physical_file_found'] = True
                                    t['progress'] = 1.0
                                    if 'seeding' not in str(t.get('state', '')).lower():
                                        t['state'] = 'Terminato'
                                    if t.get('total_size', 0) == 0: t['total_size'] = 104857600
                                    t['completed'] = t['total_size']
                                    t['downloaded'] = t['total_size']
                                    t['eta'] = -2
                                break
            else:
                # Estrai nome serie: tutto prima di SxxExx, converti dots in spazi
                prefix_raw = t_name[:m_ep.start()]
                # "Star.Trek.Starfleet.Academy." → "Star Trek Starfleet Academy"
                prefix_clean = re.sub(r'[._]+', ' ', prefix_raw).strip()
                norm_t_name = normalize_series_name(prefix_clean)
                s_num, e_num = int(m_ep.group(1)), int(m_ep.group(2))

                # Trova la serie corrispondente in configurazione per avere archive_path.
                # Prova prima match esatto, poi match per sottostringa (fallback).
                series_cfg = next(
                    (s for s in configured_series
                     if _series_name_matches(normalize_series_name(s.get('name', '')), norm_t_name)),
                    None
                )
                # Fallback: match per sottostringa (es. "star trek starfleet academy"
                # contiene "starfleet academy" o viceversa)
                if series_cfg is None:
                    for s in configured_series:
                        nc = normalize_series_name(s.get('name', ''))
                        if nc and norm_t_name and (nc in norm_t_name or norm_t_name in nc):
                            series_cfg = s
                            break

                archive_path = series_cfg.get('archive_path', '').strip() if series_cfg else ''

                cache_key = f"{norm_t_name}|{s_num}|{e_num}"
                cached = PHYSICAL_FILE_CACHE.get(cache_key)
                if cached and (now_ts - cached[0]) < CACHE_TTL:
                    found, where = cached[1], cached[2]
                    found_fpath = cached[3] if len(cached) > 3 else ''
                else:
                    # Chiamata pulita e singola senza loop infiniti sui dischi
                    found, where, found_fpath = _find_episode_on_disk(
                        norm_t_name, s_num, e_num,
                        archive_path, final_dir, temp_dir,
                        rename_fmt, rename_template
                    )
                    PHYSICAL_FILE_CACHE[cache_key] = (now_ts, found, where, found_fpath)

                if found:
                    t_prog = float(t.get('progress', 0))
                    is_finto_completato = t_prog >= 1.0 or (t_prog == 0.0 and t.get('completed_time', 0) > 0) or t.get('state') == 'error'
                    if is_finto_completato:
                        t['physical_file_found'] = True
                        t['progress'] = 1.0
                        if 'seeding' not in str(t.get('state', '')).lower():
                            t['state'] = 'Terminato'
                        if t.get('total_size', 0) == 0:
                            try:
                                t['total_size'] = os.path.getsize(found_fpath) if found_fpath else 104857600
                            except OSError:
                                t['total_size'] = 104857600
                        t['completed'] = t['total_size']
                        t['downloaded'] = t['total_size']
                        if where == 'nas':
                            t['eta'] = -2
                    # where == 'final' o 'temp': pct=100, eta rimane quello reale → mostra ✓

        return jsonify(torrents)
    except Exception as e:
        return jsonify({'error': str(e)}), 500



@app.route('/api/torrents/set_limits', methods=['POST'])
def torrent_set_limits():
    """Inoltra i limiti DL/UL/Seeding al motore (extto3.py) che gestisce la vera sessione."""
    try:
        data = request.get_json(silent=True) or {}
        if not data.get('hash'):
            return jsonify({'ok': False, 'error': 'hash mancante'}), 400
        
        import requests
        r = requests.post(
            f'http://127.0.0.1:{get_engine_port()}/api/torrents/set_limits',
            json=data,
            timeout=10
        )
        return jsonify(r.json()), r.status_code
    except Exception as e:
        logger.warning(f"torrent_set_limits proxy error: {e}")
        return jsonify({'ok': False, 'error': 'Motore non raggiungibile'}), 500


@app.route('/api/torrents/<path:subpath>', methods=['GET', 'POST', 'OPTIONS'])
def proxy_torrents(subpath):
    target_url = f'http://127.0.0.1:{get_engine_port()}/api/torrents/{subpath}'
    try:
        if request.method == 'GET':
            resp = requests.get(target_url, timeout=5)
        elif request.method == 'POST':
            resp = requests.post(
                target_url, 
                json=request.get_json(),
                headers={'Content-Type': 'application/json'},
                timeout=5
            )
        else:
            return {'error': 'Method not allowed'}, 405
        
        return resp.content, resp.status_code, {
            'Content-Type': resp.headers.get('Content-Type', 'application/json'),
            'Access-Control-Allow-Origin': '*'
        }
    except requests.exceptions.RequestException as e:
        print(f'❌ Proxy torrent error: {e}')
        return {'error': 'Backend unavailable', 'detail': str(e)}, 503

@app.route('/api/tmdb/search', methods=['GET'])
def tmdb_search():
    """Cerca un titolo su TMDB per l'autocompletamento nella Web UI"""
    query = request.args.get('q', '').strip()
    media_type = request.args.get('type', 'tv') # 'tv' per serie, 'movie' per film

    if not query:
        return jsonify({'success': False, 'error': 'Inserisci un titolo da cercare'})

    try:
        from core.config import Config
        cfg = Config()
        api_key = getattr(cfg, 'tmdb_api_key', '').strip()
        tmdb_lang = getattr(cfg, 'tmdb_language', 'it-IT').strip()
        
        if not api_key:
            return jsonify({'success': False, 'error': 'Chiave API TMDB mancante. Inseriscila in Configurazione -> Avanzate.'})

        url = f"https://api.themoviedb.org/3/search/{media_type}"
        params = {'api_key': api_key, 'query': query, 'language': tmdb_lang}
        
        res = requests.get(url, params=params, timeout=10)
        if res.status_code == 200:
            data = res.json()
            results = []
            for item in data.get('results', [])[:5]: # Prendi i primi 5 risultati
                title = item.get('name') if media_type == 'tv' else item.get('title')
                date_str = item.get('first_air_date') if media_type == 'tv' else item.get('release_date')
                year = date_str[:4] if date_str else ''
                orig_title = item.get('original_name') or item.get('original_title')
                results.append({'id': item.get('id'), 'title': title, 'year': year, 'original_title': orig_title})
            return jsonify({'success': True, 'results': results})
        else:
            return jsonify({'success': False, 'error': f"Errore server TMDB: {res.status_code}"})
    except Exception as e:
        return jsonify({'success': False, 'error': f"Errore di rete: {str(e)}"}) 

@app.route('/api/tmdb/discover', methods=['GET'])
def tmdb_discover():
    """Scarica i film e le serie in tendenza da TMDB per la sezione Esplora"""
    media_type = request.args.get('type', 'movie') 
    category = request.args.get('category', 'trending') # <--- ORA LEGGE IL TAB CLICCATO
    
    try:
        from core.config import Config
        cfg = Config()
        api_key = getattr(cfg, 'tmdb_api_key', '').strip()
        tmdb_lang = getattr(cfg, 'tmdb_language', 'it-IT').strip()

        if not api_key:
            return jsonify({'success': False, 'error': 'API Key TMDB mancante.'})

        # --- ROUTING INTELLIGENTE BASATO SULLA CATEGORIA ---
        search_query = ''
        if category == 'search':
            search_query = request.args.get('q', '').strip()
            if not search_query:
                return jsonify({'success': True, 'results': []})
            url = f"https://api.themoviedb.org/3/search/{media_type}"
        elif category == 'top_rated':
            url = f"https://api.themoviedb.org/3/{media_type}/top_rated"
        elif category in ('now_playing', 'on_the_air'):
            url = f"https://api.themoviedb.org/3/movie/now_playing" if media_type == 'movie' else f"https://api.themoviedb.org/3/tv/on_the_air"
        elif category == 'upcoming':
            url = f"https://api.themoviedb.org/3/movie/upcoming" if media_type == 'movie' else f"https://api.themoviedb.org/3/tv/airing_today"
        elif category == 'popular':
            url = f"https://api.themoviedb.org/3/{media_type}/popular"
        else:
            # Default: Tendenze
            url = f"https://api.themoviedb.org/3/trending/{media_type}/week"
        results = []
        seen_ids = set()

        # Facciamo 3 "chiamate" per prendere le pagine 1, 2 e 3 (Totale: 60 risultati)
        for page in range(1, 4):
            params = {'api_key': api_key, 'language': tmdb_lang, 'page': page}
            if search_query:
                params['query'] = search_query
            res = requests.get(url, params=params, timeout=10)

            if res.status_code == 200:
                data = res.json()
                for item in data.get('results', []):
                    item_id = item.get('id', '')
                    if item_id and item_id in seen_ids:
                        continue
                    seen_ids.add(item_id)
                    title = item.get('name') if media_type == 'tv' else item.get('title')
                    date_str = item.get('first_air_date') if media_type == 'tv' else item.get('release_date')
                    year = date_str[:4] if date_str else ''
                    results.append({
                        'id': item_id,
                        'title': title,
                        'year': year,
                        'overview': item.get('overview', 'Nessuna trama disponibile.'),
                        'poster': item.get('poster_path', ''),
                        'vote': item.get('vote_average', 0)
                    })
            else:
                break # Se una pagina fallisce, interrompe il ciclo e restituisce quello che ha trovato

        return jsonify({'success': True, 'results': results})
    except Exception as e:
        return jsonify({'success': False, 'error': str(e)})

@app.route('/api/series/<int:series_id>/rename-preview', methods=['GET'])
def rename_preview(series_id):
    """Genera l'anteprima dei file che verrebbero rinominati (video + file ausiliari .srt, .jpg, ecc.)."""
    try:
        from core.config import Config
        from core.tmdb import TMDBClient
        from core.renamer import _build_filename, _VIDEO_EXTS
        import os
        import re

        cfg = Config()
        api_key = getattr(cfg, 'tmdb_api_key', '').strip()
        if not api_key:
            return jsonify({'success': False, 'error': 'Chiave API TMDB mancante nelle impostazioni.'})

        c = db.conn.cursor()
        c.execute("SELECT name FROM series WHERE id=?", (series_id,))
        row = c.fetchone()
        if not row:
            return jsonify({'success': False, 'error': 'Serie non trovata'})
        series_name = row['name']

        config_data = parse_series_config()
        apath = ""
        for s in config_data['series']:
            if s['name'].lower() == series_name.lower():
                apath = s.get('archive_path', '')
                break

        if not apath or not os.path.exists(apath):
            return jsonify({'success': False, 'error': 'Percorso archivio della serie non trovato sul disco.'})

        force_reprocess = request.args.get('force', '0') == '1'

        tmdb = TMDBClient(api_key, cache_days=int(getattr(cfg, 'tmdb_cache_days', 7)))
        tmdb_id = tmdb.get_tmdb_id_for_series(db, series_name)
        if not tmdb_id:
            tmdb_id = tmdb.resolve_series_id(series_name)
        if not tmdb_id:
            return jsonify({'success': False, 'error': 'Serie non identificata su TMDB.'})

        cfg_data        = Config()
        rename_fmt      = str(getattr(cfg_data, 'rename_format', 'base')).strip().lower()
        rename_template = str(getattr(cfg_data, 'rename_template', '{Serie} - {Stagione}{Episodio} - {Titolo} [{Risoluzione}][{Lingue}]')).strip()
        if rename_fmt not in ('base', 'standard', 'completo', 'custom'):
            rename_fmt = 'base'

        series_year = None
        if rename_fmt != 'base':
            try:
                td = tmdb._get(f'/tv/{tmdb_id}', {'language': tmdb.language})
                d  = (td or {}).get('first_air_date', '')
                series_year = d[:4] if d and len(d) >= 4 else None
            except Exception as e:
                logger.debug(f"series_year TMDB: {e}")
                pass

        _gmt = None
        _mediainfo_ok = False
        _mediainfo_warning = None
        if rename_fmt != 'base':
            try:
                from core.mediainfo_helper import mediainfo_available, get_media_tags as _gmt_import
                if mediainfo_available():
                    _gmt = _gmt_import
                    _mediainfo_ok = True
                else:
                    _mediainfo_warning = "mediainfo non disponibile — installa: apt install mediainfo && pip install pymediainfo"
            except ImportError as _ie:
                _mediainfo_warning = f"pymediainfo ImportError: {_ie}"
            except Exception as _me:
                _mediainfo_warning = f"mediainfo errore: {_me}"

        # Regex riutilizzata
        _re_se  = re.compile(r'(?i)[Ss]0*(\d{1,2})[._\-\s]*[Ee]0*(\d{1,3})|0*(\d{1,2})x0*(\d{1,3})')
        _re_ep  = re.compile(r'(?i)(?:ep|episodio|episode|e)[._\-\s]*0*(\d{1,3})|^0*(\d{1,3})(?:[\s\.\-]|$)')
        _re_fld = re.compile(r'(?i)(?:stagione|season|serie|s)\s*[._\-]*0*(\d+)')

        def _parse_se(fname, folder_season):
            """Restituisce (season, episode) oppure (0, 0)."""
            m = _re_se.search(fname)
            if m:
                return int(m.group(1) or m.group(3)), int(m.group(2) or m.group(4))
            if folder_season is not None:
                m2 = _re_ep.search(fname)
                if m2:
                    return folder_season, int(m2.group(1) or m2.group(2))
            return 0, 0

        # --- INIZIO CONTEGGIO TOTALE ---
        total_files_to_scan = 0
        for r, d, f in os.walk(apath):
            for name in f:
                ext = os.path.splitext(name)[1].lower()
                if ext in _VIDEO_EXTS and 'sample' not in name.lower():
                    total_files_to_scan += 1
        # --- FINE CONTEGGIO TOTALE ---

        global RENAME_PROGRESS, _rename_progress_lock
        with _rename_progress_lock:
            RENAME_PROGRESS = {
                "status": "working", 
                "current": 0, 
                "total": total_files_to_scan, 
                "msg": "Inizializzazione..."
            }

        preview_list  = []
        already_ok_list = []
        current_video = 0

        for root_dir, _, files in os.walk(apath):
            folder_season = None
            fm = _re_fld.search(os.path.basename(root_dir))
            if fm:
                folder_season = int(fm.group(1))

            # --- Passo 1: Costruisci mappe separate per video singoli e per i best ---
            best_score_map = {} # (sea, epi) -> max_score
            best_base_map = {}  # (sea, epi) -> new_base del file video MIGLIORE
            old_best_video_map = {} # (sea, epi) -> old_base del file video MIGLIORE
            
            video_renames = {} # fname -> new_fname (Mappa specifica per ogni singolo file video)

            from core.renamer import _sanitize as _rn_sanitize
            from core.models import Parser
            _expected_prefix = f"{_rn_sanitize(series_name)} - S"

            for fname in files:
                ext = os.path.splitext(fname)[1].lower()
                if ext not in _VIDEO_EXTS or 'sample' in fname.lower():
                    continue

                sea, epi = _parse_se(fname, folder_season)
                if sea <= 0 or epi <= 0:
                    continue

                current_video += 1
                with _rename_progress_lock:
                    RENAME_PROGRESS["current"] = current_video
                    RENAME_PROGRESS["msg"]     = f"Analisi: {fname[:40]}..."

                base_name = os.path.splitext(fname)[0]

                q = Parser.parse_quality(fname)
                current_score = q.score() if hasattr(q, 'score') else 0

                ep_title = tmdb.fetch_episode_title(tmdb_id, sea, epi) if tmdb_id else None
                tags = {}
                if _mediainfo_ok and _gmt:
                    try:
                        tags = _gmt(os.path.join(root_dir, fname))
                    except Exception:
                        pass

                new_video_name = _build_filename(series_name, sea, epi, ep_title, ext,
                                                 fmt=rename_fmt, year=series_year, tags=tags,
                                                 template_str=rename_template)

                # Il file è già corretto solo se il nome generato è identico a quello attuale
                if not force_reprocess and fname == new_video_name:
                    video_renames[fname] = fname
                    if (sea, epi) not in best_score_map or current_score > best_score_map.get((sea, epi), -1):
                        best_base_map[(sea, epi)] = base_name
                        old_best_video_map[(sea, epi)] = base_name
                        best_score_map[(sea, epi)] = current_score
                    already_ok_list.append(fname)
                    continue

                video_renames[fname] = new_video_name
                new_base = os.path.splitext(new_video_name)[0]

                # In caso di duplicati video per lo stesso episodio, il MIGLIORE vince (non l'ultimo!)
                if (sea, epi) not in best_score_map or current_score > best_score_map.get((sea, epi), -1):
                    best_base_map[(sea, epi)] = new_base
                    old_best_video_map[(sea, epi)] = base_name
                    best_score_map[(sea, epi)] = current_score

            # --- Passo 2: applica rename_map a TUTTI i file della cartella ---
            apath_abs = os.path.abspath(apath)
            for fname in files:
                sea, epi = _parse_se(fname, folder_season)
                if sea <= 0 or epi <= 0:
                    continue
                if (sea, epi) not in best_base_map:
                    continue

                base_name = os.path.splitext(fname)[0]
                ext       = os.path.splitext(fname)[1].lower()

                if ext in _VIDEO_EXTS and 'sample' not in fname.lower():
                    # Ogni file video ottiene la SUA rinomina corretta
                    new_fname = video_renames.get(fname, fname)
                else:
                    # I file ausiliari seguono il video MIGLIORE
                    best_new_base = best_base_map[(sea, epi)]
                    best_old_base = old_best_video_map[(sea, epi)]
                    
                    suffix = ""
                    if best_old_base and base_name.startswith(best_old_base):
                        suffix = base_name[len(best_old_base):]
                    else:
                        m_suffix = re.search(r'([.\-](?:thumb|poster|fanart|nfo|forced|[a-zA-Z]{2,3}))+$', base_name, flags=re.IGNORECASE)
                        if m_suffix:
                            suffix = m_suffix.group(0)
                            
                    new_fname = best_new_base + suffix + ext

                if fname == new_fname and not force_reprocess:
                    if fname not in already_ok_list:
                        already_ok_list.append(fname)
                    continue

                src_abs = os.path.abspath(os.path.join(root_dir, fname))
                dst_abs = os.path.abspath(os.path.join(root_dir, new_fname))

                if not src_abs.startswith(apath_abs + os.sep) or \
                   not dst_abs.startswith(apath_abs + os.sep):
                    continue

                rel_old = os.path.relpath(src_abs, apath_abs)
                rel_new = os.path.relpath(dst_abs, apath_abs)
                preview_list.append({'old': rel_old, 'new': rel_new})

        with _rename_progress_lock:
            RENAME_PROGRESS["status"] = "idle"

        return jsonify({'success': True, 'preview': preview_list, 'already_ok': already_ok_list, 'mediainfo_warning': _mediainfo_warning})
    except Exception as e:
        with _rename_progress_lock:
            RENAME_PROGRESS["status"] = "idle"
        return jsonify({'success': False, 'error': str(e)}), 500


@app.route('/api/series/<int:series_id>/rename-execute', methods=['POST'])
def rename_execute(series_id):
    """Esegue fisicamente la rinomina sul disco (Supporta Sottocartelle e file Ausiliari)."""
    try:
        from core.config import Config
        from core.renamer import _VIDEO_EXTS
        import os
        import re

        cfg = Config()
        api_key = getattr(cfg, 'tmdb_api_key', '').strip()
        if not api_key:
            return jsonify({'success': False, 'error': 'API Key mancante'})

        c = db.conn.cursor()
        c.execute("SELECT name FROM series WHERE id=?", (series_id,))
        row = c.fetchone()
        if not row:
            return jsonify({'success': False, 'error': 'Serie non trovata'})
        series_name = row['name']

        config_data = parse_series_config()
        apath = next((s.get('archive_path', '') for s in config_data['series']
                      if s['name'].lower() == series_name.lower()), "")
        if not apath or not os.path.exists(apath):
            return jsonify({'success': False, 'error': 'Percorso invalido'})

        apath_abs = os.path.abspath(apath)

        payload      = request.get_json(silent=True) or {}
        preview_data = payload.get('preview', [])
        if not preview_data:
            return jsonify({'success': False, 'error': 'Dati di anteprima mancanti. Ricarica la pagina e riprova.'})

        global RENAME_PROGRESS, _rename_progress_lock
        with _rename_progress_lock:
            RENAME_PROGRESS = {"status": "working", "current": 0, "total": len(preview_data), "msg": "Rinomina in corso..."}

        count  = 0
        _re_se = re.compile(r'(?i)[Ss]0*(\d{1,2})[._\-\s]*[Ee]0*(\d{1,3})|0*(\d{1,2})x0*(\d{1,3})')

        for idx, item in enumerate(preview_data):
            old_rel = item.get('old')
            new_rel = item.get('new')
            if not old_rel or not new_rel:
                continue

            src = os.path.abspath(os.path.join(apath_abs, old_rel))
            dst = os.path.abspath(os.path.join(apath_abs, new_rel))

            # Protezione path traversal: entrambi i path devono stare dentro apath
            if not src.startswith(apath_abs + os.sep) or \
               not dst.startswith(apath_abs + os.sep):
                continue

            with _rename_progress_lock:
                RENAME_PROGRESS["current"] = idx + 1
                RENAME_PROGRESS["msg"]     = f"Rinomina: {os.path.basename(src)[:40]}..."

            if os.path.exists(src):
                if src == dst:
                    continue
                    
                if os.path.exists(dst):
                    # --- GESTIONE CONFLITTO RINOMINA ---
                    try:
                        from core.cleaner import _handle_duplicate
                        from core.models import Parser
                        trash_path = str(getattr(cfg, 'trash_path', '')).strip()
                        c_action = str(getattr(cfg, 'cleanup_action', 'move')).lower()
                        
                        ext = os.path.splitext(src)[1].lower()
                        if ext in _VIDEO_EXTS:
                            q_src = Parser.parse_quality(os.path.basename(src))
                            q_dst = Parser.parse_quality(os.path.basename(dst))
                            
                            if q_src.score() > q_dst.score():
                                log_maintenance(f"🗑️ [CONFLITTO RINOMINA] Il nuovo file è migliore. Sposto l'esistente in trash: '{os.path.basename(dst)}'")
                                _handle_duplicate(dst, trash_path, action=c_action, reason="rename conflict (inferior)")
                            else:
                                log_maintenance(f"⏭️ [CONFLITTO RINOMINA] L'esistente è migliore o uguale. Scarto il nuovo: '{os.path.basename(src)}'")
                                _handle_duplicate(src, trash_path, action=c_action, reason="rename conflict (new is inferior)")
                                continue
                        else:
                            # File ausiliari (.jpg, .srt, ecc): sovrascriviamo cestinando il vecchio
                            log_maintenance(f"🗑️ [CONFLITTO RINOMINA] Sostituisco file ausiliario esistente: '{os.path.basename(dst)}'")
                            _handle_duplicate(dst, trash_path, action=c_action, reason="rename conflict (auxiliary override)")
                    except Exception as e:
                        log_maintenance(f"⚠️ Errore gestione conflitto su '{os.path.basename(src)}': {e}")
                        continue

                # A questo punto la via è libera (o dst scartato, o non c'era)
                if not os.path.exists(dst) and os.path.exists(src):
                    os.rename(src, dst)
                    log_maintenance(f"✏️ Rinomina: {os.path.basename(src)} ➔ {os.path.basename(dst)}")
                    count += 1

                    # Aggiornamento DB: se è un file video, aggiorna episodes.title
                    ext = os.path.splitext(dst)[1].lower()
                    if ext in _VIDEO_EXTS:
                        m = _re_se.search(os.path.basename(dst))
                        if m:
                            sea = int(m.group(1) or m.group(3))
                            epi = int(m.group(2) or m.group(4))
                            new_title = os.path.splitext(os.path.basename(dst))[0]
                            try:
                                c.execute(
                                    "UPDATE episodes SET title=? WHERE series_id=? AND season=? AND episode=?",
                                    (new_title, series_id, sea, epi)
                                )
                                db.conn.commit()
                            except Exception as e:
                                logger.warning(f"rename-execute db commit: {e}")

        with _rename_progress_lock:
            RENAME_PROGRESS["status"] = "idle"

        # --- PULIZIA DOPPIONI E CADAVERI (invariata) ---
        cfg_data    = Config()
        _cleanup    = str(getattr(cfg_data, 'cleanup_upgrades', 'no')).lower() in ('yes', 'true', '1')
        _trash      = str(getattr(cfg_data, 'trash_path', '')).strip()
        trash_count = 0

        if _cleanup and _trash and os.path.exists(apath):
            from core.cleaner import _handle_duplicate
            from core.models import Parser, normalize_series_name, _series_name_matches
            from collections import defaultdict
            _re_se2  = re.compile(r'(?i)[Ss]0*(\d{1,2})[._\-\s]*[Ee]0*(\d{1,3})|0*(\d{1,2})x0*(\d{1,3})')
            _re_ep2  = re.compile(r'(?i)(?:ep|episodio|episode|e)[._\-\s]*0*(\d{1,3})|^0*(\d{1,3})(?:[\s\.\-]|$)')
            _re_fld2 = re.compile(r'(?i)(?:stagione|season|serie|s)\s*[._\-]*0*(\d+)')

            for root_dir, _, files_in_dir in os.walk(apath):
                folder_season = None
                fm = _re_fld2.search(os.path.basename(root_dir))
                if fm:
                    folder_season = int(fm.group(1))

                ep_videos = defaultdict(list)
                ep_aux    = defaultdict(list)

                for fname in files_in_dir:
                    sea = epi = 0
                    m_std = _re_se2.search(fname)
                    if m_std:
                        sea = int(m_std.group(1) or m_std.group(3))
                        epi = int(m_std.group(2) or m_std.group(4))
                    elif folder_season is not None:
                        m_ep = _re_ep2.search(fname)
                        if m_ep:
                            sea = folder_season
                            epi = int(m_ep.group(1) or m_ep.group(2))
                    if sea > 0 and epi > 0:
                        ext = os.path.splitext(fname)[1].lower()
                        if ext in _VIDEO_EXTS and 'sample' not in fname.lower():
                            ep_videos[(sea, epi)].append(fname)
                        else:
                            ep_aux[(sea, epi)].append(fname)

                for (sea, epi), video_list in ep_videos.items():
                    best_f = video_list[0]
                    if len(video_list) > 1:
                        scored_files = []
                        for f in video_list:
                            try:
                                fpath = os.path.join(root_dir, f)
                                q = Parser.parse_quality(f)
                                name_bonus = 10 if _series_name_matches(normalize_series_name(series_name), normalize_series_name(f)) else 0
                                score = (q.score() if hasattr(q, 'score') else 0) + name_bonus
                                size  = os.path.getsize(fpath) if os.path.exists(fpath) else 0
                                scored_files.append((score, size, f))
                            except Exception as e:
                                logger.debug(f"scored_files getsize: {e}")
                                scored_files.append((0, 0, f))
                        scored_files.sort(key=lambda x: (x[0], x[1]), reverse=True)
                        best_score, best_size, best_f = scored_files[0]
                        for score, size, f in scored_files[1:]:
                            src_dup = os.path.join(root_dir, f)
                            if not os.path.exists(src_dup):
                                continue
                            reason = f"doppione di S{sea:02d}E{epi:02d} (vince '{best_f}')"
                            if _handle_duplicate(src_dup, _trash, action=str(getattr(cfg_data, 'cleanup_action', 'move')).lower(), reason=reason):
                                trash_count += 1

                    best_base = os.path.splitext(best_f)[0]
                    for aux_f in ep_aux[(sea, epi)]:
                        if not aux_f.startswith(best_base):
                            # Protezione falsi cadaveri: se il file ausiliario contiene
                            # la stessa coppia S/E del video ma ha un base diverso,
                            # potrebbe essere un .srt legittimo non rinominato (nome
                            # vecchio rimasto sul disco). Lo eliminiamo SOLO se il suo
                            # base è davvero diverso da best_base ignorando qualità/tag,
                            # cioè se non condivide neanche il prefisso S/E.
                            aux_base = os.path.splitext(aux_f)[0]
                            aux_has_se = bool(_re_se2.search(aux_base))
                            if aux_has_se:
                                # Il file ausiliario ha un suo pattern S/E esplicito:
                                # è quasi certamente un residuo di un download precedente
                                # (nome diverso dal video attuale) → cadavere legittimo
                                pass
                            else:
                                # Senza pattern S/E nel nome (es. "01 ITA.srt" in cartella
                                # stagione) non possiamo distinguere con certezza → skip
                                continue
                            aux_src = os.path.join(root_dir, aux_f)
                            if not os.path.exists(aux_src):
                                continue
                            reason = f"file orfano (non appartiene al video '{best_f}')"
                            if _handle_duplicate(aux_src, _trash, action=str(getattr(cfg_data, 'cleanup_action', 'move')).lower(), reason=reason):
                                trash_count += 1

        # Notifica Jellyfin/Plex se configurati (no-op se URL/credenziali mancanti)
        if count > 0:
            jellyfin_notify_refresh()
            plex_notify_refresh()

        return jsonify({'success': True, 'renamed': count, 'removed': trash_count})
    except Exception as e:
        with _rename_progress_lock:
            RENAME_PROGRESS["status"] = "idle"
        return jsonify({'success': False, 'error': str(e)}), 500


@app.route('/api/series/<int:series_id>/search-missing', methods=['POST'])
def search_missing_series_api(series_id):
    """Avvia la ricerca mirata degli episodi mancanti in background."""
    def _bg_search_missing():
        try:
            from core.config import Config
            from core.engine import Engine
            from core.models import Parser
            import requests

            cfg = Config()
            eng = Engine()
            _web_port = int(getattr(cfg, 'web_port', None) or 5000)
            
            # Usiamo il database globale dell'interfaccia Web (che ha get_series_episodes)
            global db

            c = db.conn.cursor()
            c.execute('SELECT name FROM series WHERE id=?', (series_id,))
            row = c.fetchone()
            if not row: return
            series_name = row['name']

            from core.models import normalize_series_name as _nsn_cfg
            serie_cfg = next((s for s in cfg.series if _nsn_cfg(s['name']) == _nsn_cfg(series_name)), None)
            if not serie_cfg: return

            log_maintenance(f"🕵️ Avviata ricerca mirata mancanti per: {series_name}")

            api_key = getattr(cfg, 'tmdb_api_key', '').strip()
            tmdb_lang = getattr(cfg, 'tmdb_language', 'it-IT').strip()

            tmdb_seasons = {}
            if api_key:
                search_url = f"https://api.themoviedb.org/3/search/tv?api_key={api_key}&query={series_name}&language={tmdb_lang}"
                search_res = requests.get(search_url, timeout=5).json()
                if search_res.get('results'):
                    tmdb_id = search_res['results'][0]['id']
                    details = requests.get(f"https://api.themoviedb.org/3/tv/{tmdb_id}?api_key={api_key}&language={tmdb_lang}", timeout=5).json()
                    for s in details.get('seasons', []):
                        if s['season_number'] > 0:
                            tmdb_seasons[s['season_number']] = s['episode_count']

            episodes_db = db.get_series_episodes(series_id)
            downloaded = set()
            for ep in episodes_db:
                if ep['downloaded_at']:
                    downloaded.add((ep['season'], ep['episode']))

            ignored_seasons = serie_cfg.get('ignored_seasons', []) # <-- Aggiunto
            
            missing_list = []
            for s_num, ep_count in tmdb_seasons.items():
                if s_num in ignored_seasons:
                    continue # <--- SALTA COMPLETAMENTE LE STAGIONI SPENTE!
                for e_num in range(1, ep_count + 1):
                    if (s_num, e_num) not in downloaded:
                        missing_list.append((s_num, e_num))

            if not missing_list:
                log_maintenance(f"✅ Nessun episodio mancante trovato per {series_name}.")
                return

            log_maintenance(f"🔍 Trovati {len(missing_list)} episodi mancanti per {series_name}. Interrogo Jackett...")

            lang_req = serie_cfg.get('language', serie_cfg.get('lang', 'ita'))
            qual_req = serie_cfg.get('quality', serie_cfg.get('qual', ''))
            aliases  = serie_cfg.get('aliases', [])
            found_count = 0

            names_to_search = [series_name]
            for _a in (aliases or []):
                _a = str(_a).strip()
                if _a and _a.lower() != series_name.lower():
                    names_to_search.append(_a)

            for s_num, e_num in missing_list[:15]:
                ep_str = f"S{s_num:02d}E{e_num:02d}"
                log_maintenance(f"   📡 Cerco: {series_name} {ep_str}...")

                j_res = []
                for search_name in names_to_search:
                    base_q = search_name
                    if lang_req and lang_req not in ('custom', 'none', 'any', '*'):
                        base_q += f" {lang_req}"
                    j_res.extend(eng._jackett_search(base_q, {}, season=s_num, ep=e_num))
                    if len(names_to_search) > 1:
                        time.sleep(2)

                if not j_res:
                    _ed2k_en = str(_cdb.get_setting('gap_fill_ed2k', 'no')).lower() in ('yes','true','1')
                    if _ed2k_en:
                        try:
                            from core.clients.amule import AmuleClient
                            _amule_cfg = Config()
                            _am_en = str(getattr(_amule_cfg, 'qbt', {}).get('amule_enabled', 'no')).lower() in ('yes','true','1')
                            if _am_en:
                                _q = f"{series_name} {ep_str}"
                                log_maintenance(f"   🔵 Jackett: nessun risultato. Provo eD2k: '{_q}'...")
                                with AmuleClient(_amule_cfg) as _am:
                                    _am_res = _am.search(_q, network='global')
                                if _am_res:
                                    _best = max(_am_res, key=lambda r: r.get('sources', 0))
                                    log_maintenance(f"   🔵 eD2k: trovato '{_best['name']}' ({_best.get('sources',0)} sorgenti)")
                                    with AmuleClient(_amule_cfg) as _am:
                                        _ok = _am.download_result(_best['idx'])
                                    if _ok:
                                        log_maintenance(f"   ✅ eD2k: {ep_str} inviato ad aMule")
                                        found_count += 1
                                else:
                                    log_maintenance(f"   ⚠️  eD2k: nessun risultato per '{_q}'")
                        except Exception as _e:
                            log_maintenance(f"   ⚠️  eD2k fallback errore: {_e}")
                    time.sleep(2)
                    continue

                best_ep_cand = None
                best_ep_score = -1

                for item in j_res:
                    if not cfg._lang_ok(item['title'], lang_req): continue
                    ep_p = Parser.parse_series_episode(item['title'])
                    
                    if ep_p and ep_p['season'] == s_num and ep_p['episode'] == e_num:
                        match = cfg.find_series_match(ep_p['name'], ep_p['season'])
                        if not match or match['name'] != series_name: continue

                        # Controllo manuale della qualità per non dipendere dal DB del motore
                        min_rank = cfg._min_res_from_qual_req(qual_req)
                        max_rank = cfg._max_res_from_qual_req(qual_req)
                        this_rank = cfg._res_rank_from_title(item['title'])
                        _score = ep_p['quality'].score() if hasattr(ep_p['quality'], 'score') else 0
                        bonus = cfg.get_custom_score(item['title']) if hasattr(cfg, 'get_custom_score') else 0
                        _score += bonus

                        if min_rank <= this_rank <= max_rank:
                            if _score > best_ep_score:
                                best_ep_score = _score
                                best_ep_cand = item['magnet']
                            # Registra come match valido (lingua+qualità ok)
                            try:
                                db.record_feed_match(series_id, s_num, e_num,
                                                     item['title'], int(_score),
                                                     None, item['magnet'])
                            except Exception as e:
                                logger.debug(f"record_feed_match manual: {e}")
                                pass
                        else:
                            # Lingua ok ma qualità fuori range: match parziale
                            _fail = 'below_quality' if this_rank < min_rank else 'above_quality'
                            try:
                                db.record_feed_match(series_id, s_num, e_num,
                                                     item['title'], int(_score),
                                                     _fail, item['magnet'])
                            except Exception as e:
                                logger.debug(f"record_feed_match manual fail: {e}")
                                pass

                if best_ep_cand:
                    import urllib.request, json, base64, ssl
                    try:
                        # Usa jackett_timeout dalla config (default 30s)
                        _http_timeout = int((parse_series_config().get('settings') or {}).get('jackett_timeout', 30))
                        # 1. PREPARAZIONE INVIO (MAGNET vs HTTP)
                        if best_ep_cand.startswith('http'):
                            log_maintenance(f"   📥 Analisi link tracker...")
                            import requests
                            
                            res = requests.get(best_ep_cand, timeout=_http_timeout, verify=False, allow_redirects=False, headers={'User-Agent': 'Mozilla/5.0'})
                            
                            current_link = best_ep_cand
                            if res.status_code in (301, 302, 307, 308):
                                loc = res.headers.get('Location', '')
                                if loc.startswith('magnet:'):
                                    log_maintenance(f"   🧲 Redirect rilevato: è un link Magnet.")
                                    current_link = loc
                                    best_ep_cand = loc 
                                else:
                                    res = requests.get(loc, timeout=_http_timeout, verify=False, headers={'User-Agent': 'Mozilla/5.0'})

                            if not current_link.startswith('magnet:') and res.status_code == 200:
                                b64_data = base64.b64encode(res.content).decode('utf-8')
                                payload = {
                                    'filename': f"{series_name}_S{s_num:02d}E{e_num:02d}.torrent",
                                    'data': b64_data,
                                    'download_now': True
                                }
                                req_api = urllib.request.Request(
                                    f'http://127.0.0.1:{_web_port}/api/upload-torrent',
                                    data=json.dumps(payload).encode(),
                                    headers={'Content-Type': 'application/json'}
                                )
                            elif current_link.startswith('magnet:'):
                                pass
                            else:
                                raise Exception(f"Errore download file (Status: {res.status_code})")

                        if best_ep_cand.startswith('magnet:'):
                            log_maintenance(f"   🧲 Invio link Magnet al client...")
                            req_api = urllib.request.Request(
                                f'http://127.0.0.1:{_web_port}/api/send-magnet',
                                data=json.dumps({'magnet': best_ep_cand}).encode(),
                                headers={'Content-Type': 'application/json'}
                            )

                        urllib.request.urlopen(req_api, timeout=10)
                        log_maintenance(f"   ✅ Successo: {ep_str} inviato (Score: {best_ep_score})")
                        _save_tag_for_magnet(best_ep_cand, 'Serie TV')
                        found_count += 1
                        
                        now_iso = datetime.now().isoformat()
                        c = db.conn.cursor()
                        c.execute('INSERT INTO episodes (series_id, season, episode, title, quality_score, is_repack, downloaded_at) VALUES (?, ?, ?, ?, ?, 0, ?)',
                            (series_id, s_num, e_num, f"{series_name} {ep_str}", int(best_ep_score), now_iso))
                        db.conn.commit()
                        # Registra come 'downloaded' nel feed_matches
                        try:
                            db.record_feed_match(series_id, s_num, e_num,
                                                 f"{series_name} {ep_str}", int(best_ep_score),
                                                 'downloaded', best_ep_cand)
                        except Exception as e:
                            logger.debug(f"record_feed_match rescore: {e}")
                            pass
                        
                    except Exception as e:
                        log_maintenance(f"   ❌ Errore invio per {ep_str}: {str(e)}")
                else:
                    log_maintenance(f"   ❌ Nessun risultato valido per {ep_str} (qualità/lingua).")
                    _ed2k_en2 = str(_cdb.get_setting('gap_fill_ed2k', 'no')).lower() in ('yes','true','1')
                    if _ed2k_en2:
                        try:
                            from core.clients.amule import AmuleClient
                            _amule_cfg2 = Config()
                            _am_en2 = str(getattr(_amule_cfg2, 'qbt', {}).get('amule_enabled', 'no')).lower() in ('yes','true','1')
                            if _am_en2:
                                _q2 = f"{series_name} {ep_str}"
                                log_maintenance(f"   🔵 Provo fallback eD2k: '{_q2}'...")
                                with AmuleClient(_amule_cfg2) as _am2:
                                    _am_res2 = _am2.search(_q2, network='global')
                                if _am_res2:
                                    _best2 = max(_am_res2, key=lambda r: r.get('sources', 0))
                                    log_maintenance(f"   🔵 eD2k: '{_best2['name']}' ({_best2.get('sources',0)} sorgenti)")
                                    with AmuleClient(_amule_cfg2) as _am2:
                                        _ok2 = _am2.download_result(_best2['idx'])
                                    if _ok2:
                                        log_maintenance(f"   ✅ eD2k: {ep_str} inviato ad aMule")
                                        found_count += 1
                        except Exception as _e2:
                            log_maintenance(f"   ⚠️  eD2k fallback errore: {_e2}")

                time.sleep(2)

            log_maintenance(f"🏁 Ricerca mirata terminata per {series_name}. Inviati al client: {found_count}.")
        except Exception as e:
            import traceback
            err_details = traceback.format_exc()
            log_maintenance(f"❌ Errore critico in background search:\n{err_details}")

    import threading
    threading.Thread(target=_bg_search_missing, daemon=True).start()
    return jsonify({'success': True, 'message': 'Ricerca mirata avviata in background! Apri il tab Log per seguirla.'})
 
@app.route('/api/series/<int:series_id>/toggle-season', methods=['POST'])
def toggle_season(series_id):
    """Accende/spegne il monitoraggio di una specifica stagione."""
    try:
        data = request.json or {}
        season = int(data.get('season', 0))
        
        c = db.conn.cursor()
        c.execute('SELECT name FROM series WHERE id=?', (series_id,))
        series_name = c.fetchone()['name']
        
        cfg = parse_series_config()
        updated = False
        for s in cfg.get('series', []):
            if s.get('name', '').strip().lower() == series_name.strip().lower():
                ignored = s.get('ignored_seasons', [])
                if season in ignored:
                    ignored.remove(season) # La riaccende
                else:
                    ignored.append(season) # La spegne
                s['ignored_seasons'] = ignored
                updated = True
                break
        
        if updated:
            save_series_config(cfg)
            return jsonify({'success': True})
        return jsonify({'success': False, 'error': 'Serie non trovata'})
    except Exception as e:
        return jsonify({'success': False, 'error': str(e)})    


@app.route('/api/rename-format-preview', methods=['GET'])
def rename_format_preview():
    from core.renamer import _build_filename, RENAME_FORMAT_LABELS
    try:
        from core.mediainfo_helper import mediainfo_available
        mi_ok = mediainfo_available()
    except ImportError:
        mi_ok = False

    template_str = request.args.get('tmpl', '{Serie} - {Stagione}{Episodio} - {Titolo} [{Risoluzione}][{HDR}][{Lingue}]')

    example_tags = {
        'resolution':  '1080p',
        'video_codec': 'h264',
        'audio_codec': 'EAC3 Atmos',
        'channels':    '5.1',
        'hdr':         'HDR10',
        'languages':   ['IT', 'EN'],
    }
    examples = {}
    for fmt in ('base', 'standard', 'completo', 'custom'):
        examples[fmt] = _build_filename(
            'Nome Serie Generica', 1, 1, 'Titolo Episodio', '.mkv',
            fmt=fmt, year='2024', tags=example_tags, template_str=template_str
        )
    return jsonify({
        'success': True,
        'mediainfo_available': mi_ok,
        'examples': examples,
        'labels': RENAME_FORMAT_LABELS,
    })


@app.route('/api/sources/health', methods=['GET'])
def sources_health():
    """Effettua un Ping/Test in tempo reale su tutte le fonti configurate (Jackett + URL).

    NOTA: verify=False è intenzionale — Jackett gira tipicamente su localhost con
    certificato self-signed; i tracker pubblici hanno spesso SSL non valido.
    Il warning viene soppresso solo localmente, non a livello di processo.
    """
    from core.config import Config
    import requests
    import time
    import urllib3

    cfg = Config()
    results = []

    # 1. Test Jackett + Prowlarr (tutti gli indexer configurati)
    from core.engine import Engine as _PingEng
    for _ix in _PingEng._get_indexers(cfg):
        _ix_url  = _ix['url'].rstrip('/')
        _ix_api  = _ix['api']
        _ix_name = _ix['label']
        # Usa l'endpoint /api corretto per tipo (Jackett vs Prowlarr)
        _test_url = _PingEng._torznab_url(_ix_url)
        start = time.time()
        try:
            with warnings.catch_warnings():
                warnings.simplefilter("ignore", urllib3.exceptions.InsecureRequestWarning)
                r = requests.get(_test_url, params={'apikey': _ix_api, 't': 'caps'}, timeout=10, verify=False)
            ms = int((time.time() - start) * 1000)
            if r.status_code == 200:
                results.append({'name': f'{_ix_name} (Aggregatore)', 'url': _ix_url, 'status': 'online', 'ping': ms, 'error': ''})
            else:
                results.append({'name': f'{_ix_name} (Aggregatore)', 'url': _ix_url, 'status': 'error', 'ping': ms, 'error': f'HTTP {r.status_code}'})
        except requests.exceptions.Timeout:
            results.append({'name': f'{_ix_name} (Aggregatore)', 'url': _ix_url, 'status': 'timeout', 'ping': '>10000', 'error': 'Timeout 10s'})
        except Exception as e:
            logger.debug(f"indexer check: {e}")
            results.append({'name': f'{_ix_name} (Aggregatore)', 'url': _ix_url, 'status': 'error', 'ping': '-', 'error': 'Non Raggiungibile'})

    # 2. Test URLs di Scraping
    for u in getattr(cfg, 'urls', []):
        name = "Il Corsaro Nero" if "corsaro" in u.lower() else ("ExtTo" if "extto" in u.lower() else "Sito Torrent")
        start = time.time()
        try:
            # Fake browser header per aggirare blocchi base
            # verify=False: i tracker pubblici spesso hanno SSL non valido o scaduto
            with warnings.catch_warnings():
                warnings.simplefilter("ignore", urllib3.exceptions.InsecureRequestWarning)
                r = requests.get(u, timeout=10, verify=False, headers={'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64)'})
            ms = int((time.time() - start) * 1000)
            # Accettiamo 403 e 302 come "Online" perché molti tracker mettono Cloudflare o redirect
            if r.status_code in [200, 301, 302, 403]: 
                warn = f'(Risposta: HTTP {r.status_code})' if r.status_code != 200 else ''
                results.append({'name': name, 'url': u, 'status': 'online', 'ping': ms, 'error': warn})
            else:
                results.append({'name': name, 'url': u, 'status': 'error', 'ping': ms, 'error': f'HTTP {r.status_code}'})
        except requests.exceptions.Timeout:
            results.append({'name': name, 'url': u, 'status': 'timeout', 'ping': '>10000', 'error': 'Timeout 10s'})
        except Exception as e:
            results.append({'name': name, 'url': u, 'status': 'error', 'ping': '-', 'error': 'Sito Offline o Irraggiungibile'})

    return jsonify({'success': True, 'sources': results})

@app.route('/api/log', methods=['POST'])
def write_client_log():
    """Permette alla WebUI di scrivere notifiche ed eventi nel file log principale"""
    try:
        data = request.json or {}
        msg = data.get('message', '')
        if msg:
            log_maintenance(f"🖥️ [WebUI] {msg}")
        return jsonify({'success': True})
    except Exception as e:
        logger.debug(f"log_maintenance endpoint: {e}")
        return jsonify({'success': False})
    

# ============================================================================
# FUMETTI — GETCOMICS
# ============================================================================

def _comics_db():
    """Restituisce istanza ComicsDB (lazy import per non pesare all'avvio)."""
    from core.comics import ComicsDB
    return ComicsDB(os.path.join(BASE_DIR, 'comics.db'))

def _get_notifier():
    """Istanzia il Notifier con la config corrente. Ritorna None se non configurato."""
    try:
        from core.notifier import Notifier
        cfg = parse_series_config().get('settings', {})
        return Notifier(cfg)
    except Exception as e:
        logger.debug(f"get_notifier: {e}")
        return None


def _comics_scraper():
    from core.comics import GetComicsScraper
    return GetComicsScraper()

def _comics_send_magnet(magnet: str, save_path: str = '') -> bool:
    """Invia un magnet/torrent al client configurato. Usato dal ciclo fumetti."""
    try:
        config   = parse_series_config()
        settings = config.get('settings', {})
        target_path = save_path if save_path else settings.get('libtorrent_dir', '/downloads').strip()

        if settings.get('qbittorrent_enabled') == 'yes':
            qb_url  = settings.get('qbittorrent_url', '')
            qb_user = settings.get('qbittorrent_username', '')
            qb_pass = settings.get('qbittorrent_password', '')
            sess = requests.Session()
            r = sess.post(f"{qb_url}/api/v2/auth/login", data={'username': qb_user, 'password': qb_pass}, timeout=5)
            if _qbt_ok(r):
                data = {'urls': magnet, 'paused': 'true'}
                if target_path: data['savepath'] = target_path
                r = sess.post(f"{qb_url}/api/v2/torrents/add", data=data, timeout=5)
                if _qbt_ok(r):
                    _save_tag_for_magnet(magnet, 'Fumetti')
                    return True

        if settings.get('transmission_enabled') == 'yes':
            tr_url  = settings.get('transmission_url', '')
            tr_user = settings.get('transmission_username', '')
            tr_pass = settings.get('transmission_password', '')
            auth = (tr_user, tr_pass) if tr_user else None
            r = requests.post(tr_url, auth=auth, timeout=5)
            sid = r.headers.get('X-Transmission-Session-Id', '')
            payload = {'method': 'torrent-add', 'arguments': {'filename': magnet, 'paused': True}}
            if target_path: payload['arguments']['download-dir'] = target_path
            r = requests.post(tr_url, json=payload, headers={'X-Transmission-Session-Id': sid}, auth=auth, timeout=5)
            if r.status_code == 409:
                sid = r.headers.get('X-Transmission-Session-Id', sid)
                r = requests.post(tr_url, json=payload, headers={'X-Transmission-Session-Id': sid}, auth=auth, timeout=5)
            if r.status_code == 200:
                _save_tag_for_magnet(magnet, 'Fumetti')
                return True

        if settings.get('libtorrent_enabled') == 'yes':
            # Se è un file .torrent (es. GetComics), lo scarica prima di passarlo a Libtorrent per avere indietro l'Hash corretto da Taggare!
            if magnet.startswith('http://') or magnet.startswith('https://'):
                import base64
                try:
                    r_file = requests.get(magnet, timeout=15, verify=False, headers={'User-Agent': 'Mozilla/5.0'})
                    if r_file.status_code == 200:
                        b64_data = base64.b64encode(r_file.content).decode('utf-8')
                        payload = {'data': b64_data, 'filename': 'comic.torrent'}
                        if target_path: payload['save_path'] = target_path
                        r = requests.post(f'http://127.0.0.1:{get_engine_port()}/api/torrents/add_torrent_file', json=payload, timeout=10)
                        if r.status_code == 200 and r.json().get('ok'):
                            _lt_h = r.json().get('hash', '')
                            if _lt_h: _save_tag_for_hash(_lt_h, 'Fumetti')
                            return True
                except Exception as e:
                    logger.error(f"Error downloading comics torrent file: {e}")
            
            # Se è un classico Magnet Link
            payload = {'magnet': magnet}
            if target_path: payload['save_path'] = target_path
            r = requests.post(f'http://127.0.0.1:{get_engine_port()}/api/torrents/add', json=payload, timeout=10)
            if r.status_code == 200 and r.json().get('ok'):
                _save_tag_for_magnet(magnet, 'Fumetti')
                _lt_h = r.json().get('hash', '')
                if _lt_h: _save_tag_for_hash(_lt_h, 'Fumetti')
                return True

    except Exception as e:
        logger.error(f"comics send_magnet error: {e}")
    return False


@app.route('/api/comics/search', methods=['GET'])
def comics_search():
    """Cerca fumetti su getcomics.org (scraping live)."""
    query = request.args.get('q', '').strip()
    page  = int(request.args.get('page', 1))
    if not query:
        return jsonify({'success': False, 'error': 'Parametro q mancante'})
    try:
        scraper = _comics_scraper()
        results = scraper.search(query, page=page)
        return jsonify({'success': True, 'results': results, 'query': query})
    except Exception as e:
        return jsonify({'success': False, 'error': str(e)})


@app.route('/api/comics/weekly', methods=['GET'])
def comics_weekly():
    """
    Restituisce i link del weekly pack per una data specifica.
    Parametri: date=YYYY-MM-DD (default: data odierna)
    """
    date_str = request.args.get('date', '')
    if not date_str:
        from datetime import date as _date
        date_str = _date.today().isoformat()
    try:
        scraper = _comics_scraper()
        result  = scraper.get_weekly_links(date_str)
        return jsonify({'success': True, **result})
    except Exception as e:
        return jsonify({'success': False, 'error': str(e)})


@app.route('/api/comics/weekly/settings', methods=['GET'])
def comics_weekly_settings_get():
    """Legge le impostazioni del download automatico weekly."""
    try:
        comics_db = _comics_db()
        cfg = comics_db.get_weekly_settings()
        return jsonify({'success': True, **cfg})
    except Exception as e:
        return jsonify({'success': False, 'error': str(e)})

@app.route('/api/comics/weekly/settings', methods=['POST'])
def comics_weekly_settings_set():
    """Salva le impostazioni del download automatico weekly."""
    try:
        data      = request.get_json() or {}
        enabled   = bool(data.get('weekly_enabled', False))
        from_date = str(data.get('weekly_from_date', '') or '')
        comics_db = _comics_db()
        comics_db.set_weekly_settings(enabled, from_date)
        return jsonify({'success': True})
    except Exception as e:
        return jsonify({'success': False, 'error': str(e)})

@app.route('/api/comics/weekly/list', methods=['GET'])
def comics_weekly_list():
    """Lista dei weekly pack trovati/inviati (dallo storico DB), con paginazione."""
    try:
        comics_db = _comics_db()
        limit  = int(request.args.get('limit', 20))
        page   = max(1, int(request.args.get('page', 1)))
        offset = (page - 1) * limit
        rows   = comics_db.get_weekly_packs(limit=limit, offset=offset)
        total  = comics_db.count_weekly_packs()
        return jsonify({
            'success': True,
            'packs':   rows,
            'total':   total,
            'page':    page,
            'limit':   limit,
            'pages':   max(1, (total + limit - 1) // limit),
        })
    except Exception as e:
        return jsonify({'success': False, 'error': str(e)})


@app.route('/api/comics/weekly/send', methods=['POST'])
def comics_weekly_send():
    """Invia manualmente un weekly pack al client torrent cercando fino a 7 giorni prima."""
    try:
        data     = request.get_json(silent=True) or {}
        date_str = data.get('date', '').strip()
        if not date_str:
            return jsonify({'success': False, 'error': 'data mancante'})

        scraper = _comics_scraper()
        # Abilita la ricerca flessibile!
        result  = scraper.get_weekly_links(date_str, flexible=True)
        
        if not result['found']:
            return jsonify({'success': False, 'error': f'Nessun pack trovato attorno al {date_str}'})

        magnet = result['magnets'][0] if result['magnets'] else ''
        torrent = result['torrents'][0] if result['torrents'] else ''
        link   = magnet or torrent
        actual_date = result['pack_date']

        ok = _comics_send_magnet(link)
        if ok:
            comics_db = _comics_db()
            comics_db.add_weekly(actual_date, magnet, torrent)
            comics_db.mark_weekly_sent(actual_date)
            push_notification('download', '📚 Weekly Pack Fumetti',
                              f'Pack {actual_date} inviato al client', {})
            return jsonify({'success': True, 'message': f'Weekly pack {actual_date} trovato e inviato!'})
            
        return jsonify({'success': False, 'error': 'Invio al client torrent fallito'})
    except Exception as e:
        return jsonify({'success': False, 'error': str(e)})
        
@app.route('/api/comics/check-links', methods=['GET'])
def comics_check_links():
    """Controlla e restituisce tutti i link scaricabili di una pagina GetComics."""
    try:
        post_url = request.args.get('url', '').strip()
        if not post_url:
            return jsonify({'success': False, 'error': 'URL mancante'})
        scraper = _comics_scraper()
        links = scraper.get_links(post_url)
        magnets    = links.get('magnets',  []) or []
        torrents   = links.get('torrents', []) or []
        ddls       = links.get('ddls',     []) or []
        mega_links = links.get('mega',     []) or []
        torrent_link = (magnets + torrents + [None])[0]
        mega_link    = (mega_links + [None])[0]
        ddl_link     = (ddls + [None])[0]
        import shutil as _shutil
        return jsonify({
            'success':        True,
            'torrent_link':   torrent_link,
            'mega_link':      mega_link,
            'ddl_link':       ddl_link,
            'has_torrent':    bool(torrent_link),
            'has_mega':       bool(mega_link),
            'has_ddl':        bool(ddl_link),
            'available':      bool(torrent_link or mega_link or ddl_link),
            'megatools_ok':   bool(_shutil.which('megadl')),
        })
    except Exception as e:
        return jsonify({'success': False, 'error': str(e)})


@app.route('/api/comics/download-mega', methods=['POST'])
def comics_download_mega():
    """Avvia il download di un fumetto da Mega usando megatools (megadl)."""
    try:
        import shutil as _shutil
        if not _shutil.which('megadl'):
            return jsonify({'success': False,
                            'error': 'megatools non installato — esegui: apt install megatools'}), 503
        data     = request.get_json(silent=True) or {}
        mega_url = data.get('mega_url', '').strip()
        title    = data.get('title', 'fumetto').strip()
        logger.info(f"[MEGA] endpoint called: title={title!r} mega_url={mega_url!r}")
        if not mega_url:
            logger.warning("[MEGA] Mega URL missing in request")
            return jsonify({'success': False, 'error': 'URL Mega mancante'})
        config   = parse_series_config()
        settings = config.get('settings', {})
        target   = settings.get('libtorrent_dir', '/downloads').strip()
        logger.info(f"[MEGA] target_dir={target!r}")
        from core.comics import download_comic_mega_bg, ACTIVE_HTTP_DOWNLOADS
        logger.info(f"[MEGA] ACTIVE_HTTP_DOWNLOADS has {len(ACTIVE_HTTP_DOWNLOADS)} entries before start")
        _notifier = _get_notifier()
        ok = download_comic_mega_bg(mega_url, target, title, notifier=_notifier)
        logger.info(f"[MEGA] download_comic_mega_bg returned {ok}, ACTIVE_HTTP_DOWNLOADS now has {len(ACTIVE_HTTP_DOWNLOADS)} entries")
        if ok:
            if _notifier:
                try: _notifier.notify_comic(title, is_weekly=False, method='mega')
                except Exception: pass
            return jsonify({'success': True, 'method': 'megatools',
                            'message': f'Download Mega avviato — visibile nel Torrent Manager'})
        return jsonify({'success': False, 'error': 'Avvio download Mega fallito'})
    except Exception as e:
        logger.error(f"[MEGA] endpoint exception: {e}", exc_info=True)
        return jsonify({'success': False, 'error': str(e)})


@app.route('/api/comics/download-direct', methods=['POST'])
def comics_download_direct():
    """Scarica un fumetto via HTTP diretto o torrent/magnet.

    Accetta:
      { "url": "<pagina getcomics>" }              → scraping automatico
      { "url": "<ddl redirect>", "title": "..." }  → DDL già noto, salta scraping
    """
    try:
        import urllib.parse as _urlparse
        data  = request.get_json(silent=True) or {}
        url   = data.get('url', '').strip()
        title = data.get('title', '').strip()
        if not url:
            return jsonify({'success': False, 'error': 'URL mancante'})

        logger.info(f"[DDL] endpoint: url={url!r} title={title!r}")

        # Se l'URL è già un redirect GetComics (/dlds/...) usalo come DDL diretto
        # senza fare scraping della pagina
        is_ddl_direct = (
            '/dlds/' in url or
            url.endswith('.cbz') or url.endswith('.cbr') or url.endswith('.zip')
        )

        magnet = torrent = ddl = ''
        if is_ddl_direct:
            ddl = url
            logger.info(f"[DDL] Direct URL, skipping scraping")
        else:
            scraper = _comics_scraper()
            links   = scraper.get_links(url)
            magnet  = links.get('magnets', [''])[0] if links.get('magnets') else ''
            torrent = links.get('torrents', [''])[0] if links.get('torrents') else ''
            ddl     = links.get('ddls',    [''])[0] if links.get('ddls')    else ''
            logger.info(f"[DDL] scraping: magnet={bool(magnet)} torrent={bool(torrent)} ddl={bool(ddl)}")

        link = magnet or torrent
        if link:
            if _comics_send_magnet(link):
                return jsonify({'success': True, 'message': 'Download torrent avviato!'})
            return jsonify({'success': False, 'error': 'Invio al client torrent fallito.'})

        elif ddl:
            config     = parse_series_config()
            settings   = config.get('settings', {})
            target_dir = settings.get('libtorrent_dir', '/downloads').strip()
            if not title:
                title = _urlparse.unquote(
                    ddl.split('/')[-1]
                    .replace('.cbz','').replace('.cbr','').replace('-',' ')
                ).title().strip() or 'fumetto'

            from core.comics import download_comic_file_bg as download_comic_http_bg
            _notifier_ddl = _get_notifier()
            ok = download_comic_http_bg(ddl, target_dir, title, notifier=_notifier_ddl)
            logger.info(f"[DDL] http_bg started={ok} title={title!r}")
            if ok:
                if _notifier_ddl:
                    try: _notifier_ddl.notify_comic(title, is_weekly=False, method='http')
                    except Exception: pass
                return jsonify({'success': True,
                                'message': 'Download avviato — visibile nel Torrent Manager'})
            return jsonify({'success': False, 'error': 'Avvio download fallito.'})

        else:
            return jsonify({'success': False, 'error': 'Nessun file scaricabile trovato.'})

    except Exception as e:
        logger.error(f"[DDL] exception: {e}", exc_info=True)
        return jsonify({'success': False, 'error': str(e)})

@app.route('/api/comics', methods=['GET'])
def comics_list():
    """Lista fumetti monitorati."""
    try:
        comics_db = _comics_db()
        comics    = comics_db.get_comics()
        # Aggiunge conteggio storia per ogni fumetto
        for c in comics:
            history = comics_db.get_history(comic_id=c['id'], limit=1000)
            c['downloads_count'] = len(history)
        return jsonify({'success': True, 'comics': comics})
    except Exception as e:
        return jsonify({'success': False, 'error': str(e)})


@app.route('/api/comics', methods=['POST'])
def comics_add():
    """Aggiunge un fumetto al monitoraggio."""
    try:
        data = request.get_json(silent=True) or {}
        required = ['title', 'tag_url', 'from_date']
        for f in required:
            if not data.get(f, '').strip():
                return jsonify({'success': False,
                                'error': f'Campo obbligatorio mancante: {f}'})
        comics_db = _comics_db()
        result = comics_db.add_comic(
            title       = data['title'].strip(),
            tag_url     = data['tag_url'].strip(),
            cover_url   = data.get('cover_url', '').strip(),
            publisher   = data.get('publisher', '').strip(),
            description = data.get('description', '').strip(),
            from_date   = data['from_date'].strip(),
            save_path   = data.get('save_path', '').strip(),
        )
        if result.get('success'):
            try:
                _n = _get_notifier()
                if _n: _n.notify_comic_monitored(data['title'].strip())
            except Exception: pass
        return jsonify(result)
    except Exception as e:
        return jsonify({'success': False, 'error': str(e)})


@app.route('/api/comics/<int:comic_id>', methods=['GET'])
def comics_get(comic_id):
    """Dettaglio fumetto + storico download."""
    try:
        comics_db = _comics_db()
        comic     = comics_db.get_comic(comic_id)
        if not comic:
            return jsonify({'success': False, 'error': 'Non trovato'}), 404
        history = comics_db.get_history(comic_id=comic_id, limit=50)
        return jsonify({'success': True, 'comic': comic, 'history': history})
    except Exception as e:
        return jsonify({'success': False, 'error': str(e)})


@app.route('/api/comics/<int:comic_id>', methods=['PATCH'])
def comics_update(comic_id):
    """Aggiorna un fumetto (from_date, save_path, enabled, ecc.)."""
    try:
        data = request.get_json(silent=True) or {}
        comics_db = _comics_db()
        ok        = comics_db.update_comic(comic_id, **data)
        return jsonify({'success': ok})
    except Exception as e:
        return jsonify({'success': False, 'error': str(e)})


@app.route('/api/comics/<int:comic_id>', methods=['DELETE'])
def comics_delete(comic_id):
    """Rimuove un fumetto dal monitoraggio."""
    try:
        comics_db = _comics_db()
        ok        = comics_db.delete_comic(comic_id)
        _delete_poster('comic', comic_id)
        return jsonify({'success': ok})
    except Exception as e:
        return jsonify({'success': False, 'error': str(e)})


@app.route('/api/comics/<int:comic_id>/history', methods=['GET'])
def comics_history(comic_id):
    """Storico download di un fumetto."""
    try:
        comics_db = _comics_db()
        history   = comics_db.get_history(comic_id=comic_id, limit=100)
        return jsonify({'success': True, 'history': history})
    except Exception as e:
        return jsonify({'success': False, 'error': str(e)})


@app.route('/api/comics/cycle', methods=['POST'])
def comics_run_cycle():
    """Forza un ciclo manuale del modulo fumetti (eseguito in background)."""
    import threading as _threading
    from core.comics import run_comics_cycle

    def _bg():
        try:
            notifier = _get_notifier()
            run_comics_cycle(
                send_magnet_fn = _comics_send_magnet,
                logger_fn      = log_maintenance,
                notify_fn      = notifier.notify_comic if notifier and hasattr(notifier, 'notify_comic') else None,
            )
        except Exception as e:
            log_maintenance(f"❌ Errore ciclo fumetti: {e}")

    _threading.Thread(target=_bg, daemon=True).start()
    return jsonify({'success': True, 'message': 'Ciclo fumetti avviato in background'})


@app.route('/api/comics/history', methods=['GET'])
def comics_history_all():
    """Storico globale degli ultimi download fumetti."""
    try:
        comics_db = _comics_db()
        history   = comics_db.get_history(limit=100)
        return jsonify({'success': True, 'history': history})
    except Exception as e:
        return jsonify({'success': False, 'error': str(e)})
        
@app.route('/api/comics/history/<int:history_id>', methods=['DELETE'])
def comics_history_delete_single(history_id):
    """Rimuove un singolo record dallo storico per permetterne il ri-scaricamento."""
    try:
        comics_db = _comics_db()
        ok = comics_db.delete_history(history_id)
        return jsonify({'success': ok})
    except Exception as e:
        return jsonify({'success': False, 'error': str(e)})        


@app.route('/api/comics/history/<int:history_id>/resend', methods=['POST'])
def comics_history_resend(history_id):
    """Ri-invia al client torrent il magnet di un fumetto già scaricato in passato."""
    try:
        comics_db = _comics_db()
        # Imposta row_factory per accesso per nome colonna
        import sqlite3 as _sq3
        comics_db.conn.row_factory = _sq3.Row
        # Verifica colonne disponibili nella tabella
        cols = [r[1] for r in comics_db.conn.execute("PRAGMA table_info(comics_history)").fetchall()]
        logger.info(f"comics_history columns: {cols}")
        # Costruisce query in base alle colonne esistenti
        select_cols = "id, title"
        has_magnet      = 'magnet'      in cols
        has_torrent_url = 'torrent_url' in cols
        if has_magnet:      select_cols += ", magnet"
        if has_torrent_url: select_cols += ", torrent_url"
        row = comics_db.conn.execute(
            f"SELECT {select_cols} FROM comics_history WHERE id=?", (history_id,)
        ).fetchone()
        if not row:
            return jsonify({'success': False, 'error': f'Record {history_id} non trovato'})
        title       = row['title']
        link        = ''
        if has_magnet      and row['magnet']:      link = row['magnet']
        if not link and has_torrent_url and row['torrent_url']: link = row['torrent_url']
        logger.info(f"comics resend id={history_id} title={title!r} link={link[:60] if link else 'EMPTY'!r}")
        if not link:
            return jsonify({'success': False, 'error': f'Nessun magnet/torrent salvato per "{title}". Fumetto scaricato prima che il campo venisse registrato.'})
        ok = _comics_send_magnet(link)
        logger.info(f"comics resend _comics_send_magnet result: {ok}")
        if ok:
            return jsonify({'success': True,  'message': f'"{title}" inviato al client!'})
        else:
            return jsonify({'success': False, 'error': 'Invio fallito — controlla log e configurazione client torrent'})
    except Exception as e:
        logger.error(f"comics_history_resend error: {e}", exc_info=True)
        return jsonify({'success': False, 'error': str(e)})


# ===========================================================================
# I18N — Lingue & Traduzioni
# ===========================================================================

@app.route('/api/i18n/languages', methods=['GET'])
def i18n_languages():
    """Lista lingue disponibili nel DB + file YAML disponibili in languages/."""
    try:
        langs = _cdb.get_languages()
        yaml_files = _cdb.get_available_yaml_files()
        active = _cdb.get_ui_language()
        return jsonify({
            'languages': langs,
            'yaml_files': yaml_files,
            'active': active,
        })
    except Exception as e:
        logger.warning(f"i18n_languages: {e}")
        return jsonify({'error': str(e)}), 500


@app.route('/api/i18n/active', methods=['GET'])
def i18n_get_active():
    """Restituisce la lingua UI attiva."""
    try:
        return jsonify({'lang': _cdb.get_ui_language()})
    except Exception as e:
        return jsonify({'error': str(e)}), 500


@app.route('/api/i18n/active', methods=['POST'])
def i18n_set_active():
    """Cambia la lingua UI attiva."""
    try:
        data = request.get_json(force=True) or {}
        lang = data.get('lang', '').strip().lower()
        if not lang:
            return jsonify({'success': False, 'error': 'Campo lang mancante'}), 400
        _cdb.set_ui_language(lang)
        return jsonify({'success': True, 'lang': lang})
    except Exception as e:
        logger.warning(f"i18n_set_active: {e}")
        return jsonify({'success': False, 'error': str(e)}), 500


@app.route('/api/i18n/<lang>', methods=['GET'])
def i18n_get_lang(lang):
    """Restituisce tutte le stringhe tradotte per una lingua."""
    try:
        lang = _cdb._normalize_lang_code(lang.lower())
        strings = _cdb.get_translation(lang)
        return jsonify({'lang': lang, 'strings': strings, 'count': len(strings)})
    except Exception as e:
        logger.warning(f"i18n_get_lang {lang}: {e}")
        return jsonify({'error': str(e)}), 500


@app.route('/api/i18n/<lang>', methods=['POST'])
def i18n_save_lang(lang):
    """Salva/aggiorna le stringhe tradotte per una lingua."""
    try:
        lang = _cdb._normalize_lang_code(lang.lower())
        data = request.get_json(force=True) or {}
        strings = data.get('strings', {})
        if not isinstance(strings, dict):
            return jsonify({'success': False, 'error': 'Il campo strings deve essere un oggetto'}), 400
        count = _cdb.set_translation_bulk(lang, strings)
        return jsonify({'success': True, 'saved': count, 'lang': lang})
    except Exception as e:
        logger.warning(f"i18n_save_lang {lang}: {e}")
        return jsonify({'success': False, 'error': str(e)}), 500


@app.route('/api/i18n/<lang>', methods=['DELETE'])
def i18n_delete_lang(lang):
    """Elimina tutte le stringhe di una lingua dal DB."""
    try:
        lang = _cdb._normalize_lang_code(lang.lower())
        count = _cdb.delete_translation_lang(lang)
        return jsonify({'success': True, 'deleted': count, 'lang': lang})
    except ValueError as e:
        return jsonify({'success': False, 'error': str(e)}), 400
    except Exception as e:
        logger.warning(f"i18n_delete_lang {lang}: {e}")
        return jsonify({'success': False, 'error': str(e)}), 500


@app.route('/api/i18n/export/<lang>', methods=['POST'])
def i18n_export_yaml(lang):
    """Esporta le stringhe di una lingua in languages/<lang>.yaml."""
    try:
        result = _cdb.export_yaml_file(lang.lower())
        if result['error']:
            return jsonify({'success': False, 'error': result['error']}), 400
        return jsonify({'success': True, 'exported': result['exported'], 'path': result['path']})
    except Exception as e:
        logger.warning(f"i18n_export_yaml {lang}: {e}")
        return jsonify({'success': False, 'error': str(e)}), 500


@app.route('/api/i18n/import/<lang>', methods=['POST'])
def i18n_import_yaml(lang):
    """Importa languages/<lang>.yaml nel DB (normalizza codice a 3 lettere)."""
    try:
        result = _cdb.import_yaml_file(lang.lower())  # cerca il file col nome originale
        if result['error']:
            return jsonify({'success': False, 'error': result['error']}), 400
        return jsonify({'success': True, 'imported': result['imported'], 'lang': result['lang']})
    except Exception as e:
        logger.warning(f"i18n_import_yaml {lang}: {e}")
        return jsonify({'success': False, 'error': str(e)}), 500


@app.route('/api/system/lt_mem_suggest', methods=['GET'])
def lt_mem_suggest():
    """Legge la RAM totale del sistema e restituisce valori libtorrent consigliati."""
    try:
        total_kb = 0
        with open('/proc/meminfo') as _f:
            for line in _f:
                if line.startswith('MemTotal:'):
                    total_kb = int(line.split()[1])
                    break
        total_mb = total_kb // 1024
    except Exception:
        total_mb = 0

    # Valori ottimizzati per target NFS/NAS: cache_size accumula i pezzi in RAM
    # prima di inviarli in batch al NAS, riducendo drasticamente le scritture di rete.
    # cache_size in blocchi da 16 KiB; queue_mb = max_queued_disk_bytes in MB.
    if 0 < total_mb < 2048:
        cache_size, queue_mb, send_kb, peer_list =     0,   8,  256, 100
    elif total_mb < 4096:
        cache_size, queue_mb, send_kb, peer_list =  1024,  32,  512, 200
    elif total_mb < 8192:
        cache_size, queue_mb, send_kb, peer_list =  8192,  64, 1024, 300
    elif total_mb < 16384:
        cache_size, queue_mb, send_kb, peer_list = 16384,  64, 1024, 500
    else:
        cache_size, queue_mb, send_kb, peer_list = 32768, 128, 2048, 500

    return jsonify({
        'total_mb':   total_mb,
        'cache_size': cache_size,
        'cache_mb':   cache_size * 16 // 1024,
        'queue_mb':   queue_mb,
        'send_kb':    send_kb,
        'peer_list':  peer_list,
    })


@app.route('/api/ramdisk_check', methods=['GET'])
def ramdisk_check():
    """
    Verifica che il path indicato sia usabile da EXTTO come RAM disk.
    Controlla: esistenza, tipo di mount (tmpfs/ramfs), permessi di scrittura, spazio.
    Risposta JSON:
      ok          bool   — tutto ok, EXTTO può scrivere
      writable    bool   — EXTTO ha i permessi di scrittura
      mount_type  str    — 'tmpfs' | 'ramfs' | 'other' | 'unknown'
      is_ramdisk  bool   — True se mount_type in (tmpfs, ramfs)
      total_gb    float
      used_gb     float
      free_gb     float
      warning     str    — eventuale avviso non bloccante
      error       str    — errore bloccante (path inesistente, non scrivibile, ecc.)
    """
    import shutil, tempfile
    path = request.args.get('path', '').strip()

    if not path:
        return jsonify({'ok': False, 'error': 'Percorso non specificato'})
    if not os.path.isdir(path):
        return jsonify({'ok': False, 'error': f'Directory non trovata: {path}'})

    # --- Tipo di mount ---
    mount_type = 'unknown'
    try:
        with open('/proc/mounts', 'r') as fh:
            for line in fh:
                parts = line.split()
                if len(parts) >= 3:
                    mpoint = parts[1]
                    fstype = parts[2]
                    # Cerca il mountpoint più specifico che prefissa il path
                    norm_path   = os.path.normpath(path)
                    norm_mpoint = os.path.normpath(mpoint)
                    if norm_path == norm_mpoint or norm_path.startswith(norm_mpoint + os.sep):
                        mount_type = fstype
    except Exception:
        pass

    is_ramdisk = mount_type in ('tmpfs', 'ramfs')

    # --- Permessi di scrittura: tenta un file temporaneo reale ---
    writable = False
    try:
        fd, tmp_path = tempfile.mkstemp(dir=path, prefix='.extto_writetest_')
        os.close(fd)
        os.unlink(tmp_path)
        writable = True
    except Exception:
        pass

    if not writable:
        return jsonify({
            'ok': False, 'writable': False, 'is_ramdisk': is_ramdisk,
            'mount_type': mount_type,
            'error': f'EXTTO non ha i permessi di scrittura su {path}'
        })

    # --- Spazio ---
    try:
        usage   = shutil.disk_usage(path)
        total_gb = round(usage.total / 1024**3, 2)
        used_gb  = round(usage.used  / 1024**3, 2)
        free_gb  = round(usage.free  / 1024**3, 2)
    except Exception as e:
        return jsonify({'ok': False, 'writable': True, 'error': f'Errore lettura spazio: {e}'})

    # --- Avviso non bloccante se non è un fs in RAM ---
    warning = ''
    if not is_ramdisk:
        warning = (
            f"Il filesystem rilevato è '{mount_type}', non tmpfs/ramfs. "
            f"EXTTO funzionerà, ma non si tratta di un vero RAM disk."
        )

    return jsonify({
        'ok':         True,
        'writable':   True,
        'mount_type': mount_type,
        'is_ramdisk': is_ramdisk,
        'total_gb':   total_gb,
        'used_gb':    used_gb,
        'free_gb':    free_gb,
        'warning':    warning,
        'error':      '',
    })


@app.route('/api/mkdir', methods=['POST'])
def mkdir_route():
    """Crea una nuova cartella (usata dal file browser della UI)."""
    data   = request.json or {}
    parent = os.path.normpath((data.get('parent') or '').strip())
    name   = (data.get('name') or '').strip()
    if not parent or not name:
        return jsonify({'success': False, 'error': 'Parametri mancanti'})
    if any(c in name for c in ('/', '\\', chr(0))):
        return jsonify({'success': False, 'error': 'Nome cartella non valido'})
    if not os.path.isdir(parent):
        return jsonify({'success': False, 'error': 'Cartella padre non esistente'})
    new_dir = os.path.join(parent, name)
    if os.path.exists(new_dir):
        return jsonify({'success': True, 'path': new_dir, 'already_existed': True})
    try:
        os.makedirs(new_dir, exist_ok=True)
        logger.info(f"📁 mkdir: '{new_dir}'")
        return jsonify({'success': True, 'path': new_dir})
    except PermissionError:
        return jsonify({'success': False, 'error': 'Permesso negato'})
    except Exception as e:
        return jsonify({'success': False, 'error': str(e)})


@app.route('/api/browse_dir', methods=['GET'])
def browse_dir():
    """Elenca le sottodirectory di un percorso (per il file browser della UI)."""
    path = request.args.get('path', '/')
    path = os.path.normpath(path)
    if not os.path.isdir(path):
        return jsonify({'success': False, 'error': 'Percorso non valido', 'dirs': []})
    try:
        entries = []
        for name in sorted(os.listdir(path)):
            full = os.path.join(path, name)
            if os.path.isdir(full) and not name.startswith('.'):
                entries.append(name)
        parent = os.path.dirname(path) if path != '/' else None
        return jsonify({'success': True, 'path': path, 'parent': parent, 'dirs': entries})
    except PermissionError:
        return jsonify({'success': False, 'error': 'Permesso negato', 'dirs': []})
    except Exception as e:
        return jsonify({'success': False, 'error': str(e), 'dirs': []})

# ============================================================================
# ANTI-CACHE GLOBALE PER LE API
# ============================================================================
@app.after_request
def prevent_api_caching(response):
    """Impedisce al browser di memorizzare in cache le risposte delle API."""
    if request.path.startswith('/api/'):
        response.headers['Cache-Control'] = 'no-cache, no-store, must-revalidate, max-age=0'
        response.headers['Pragma'] = 'no-cache'
        response.headers['Expires'] = '0'
    return response



def _sync_language_files():
    """
    Auto-sync YAML -> DB all'avvio.
    Per ogni <lang>.yaml nella cartella languages/, importa nel DB tutte le chiavi
    mancanti rispetto a cio' che e' gia' in DB.
    Basta aggiornare/sostituire il file YAML e riavviare il servizio,
    senza dover fare import manuale dalla UI.
    """
    if not os.path.isdir(LANGUAGES_DIR):
        return
    try:
        yaml_files = [f for f in os.listdir(LANGUAGES_DIR) if f.endswith('.yaml')]
        if not yaml_files:
            return
        synced = []
        for fname in yaml_files:
            lang_code = fname[:-5].lower()  # es. "eng.yaml" -> "eng"
            try:
                result = _cdb.import_yaml_file(lang_code)
                if result.get('imported', 0) > 0:
                    synced.append(f"{lang_code}(+{result['imported']})")
            except Exception as e:
                logger.warning(f"[i18n-sync] {fname}: {e}")
        if synced:
            print(f"Language files synced: {', '.join(synced)}")
        else:
            print(f"Language files up to date ({len(yaml_files)} languages)")
    except Exception as e:
        logger.warning(f"[i18n-sync] startup sync failed: {e}")


# ============================================================================
# JELLYFIN / MEDIA SERVER INTEGRATION
# ============================================================================

def jellyfin_notify_refresh(settings: dict = None):
    """Chiama /Library/Refresh su Jellyfin dopo rename/move. No-op se non configurato."""
    try:
        s       = settings or _cdb.get_all_settings()
        url     = str(s.get('jellyfin_url',     '') or '').strip().rstrip('/')
        api_key = str(s.get('jellyfin_api_key', '') or '').strip()
        if not url or not api_key:
            return
        import requests as _req
        resp = _req.post(
            f"{url}/Library/Refresh",
            headers={"X-Emby-Token": api_key},
            timeout=10,
        )
        if resp.status_code in (200, 204):
            logger.info("[Jellyfin] ✅ Library Refresh inviato.")
        else:
            logger.warning(f"[Jellyfin] Refresh HTTP {resp.status_code}")
    except Exception as e:
        logger.warning(f"[Jellyfin] jellyfin_notify_refresh: {e}")


@app.route('/api/jellyfin/config', methods=['GET'])
def jellyfin_get_config():
    return jsonify({
        'jellyfin_url':     str(_cdb.get_setting('jellyfin_url',     '') or ''),
        'jellyfin_api_key': str(_cdb.get_setting('jellyfin_api_key', '') or ''),
    })


@app.route('/api/jellyfin/config', methods=['POST'])
def jellyfin_save_config():
    data    = request.get_json(force=True) or {}
    url     = str(data.get('jellyfin_url',     '') or '').strip().rstrip('/')
    api_key = str(data.get('jellyfin_api_key', '') or '').strip()
    try:
        _cdb.set_settings_bulk({'jellyfin_url': url, 'jellyfin_api_key': api_key})
        return jsonify({'success': True})
    except Exception as e:
        return jsonify({'success': False, 'error': str(e)}), 500


@app.route('/api/jellyfin/test-refresh', methods=['POST'])
def jellyfin_test_refresh():
    url     = str(_cdb.get_setting('jellyfin_url',     '') or '').strip().rstrip('/')
    api_key = str(_cdb.get_setting('jellyfin_api_key', '') or '').strip()
    if not url or not api_key:
        return jsonify({'success': False, 'error': 'URL o API Key non configurati'}), 400
    try:
        import requests as _req
        resp = _req.post(f"{url}/Library/Refresh",
                         headers={"X-Emby-Token": api_key}, timeout=10)
        if resp.status_code in (200, 204):
            return jsonify({'success': True})
        return jsonify({'success': False, 'error': f'HTTP {resp.status_code}'}), 502
    except Exception as e:
        return jsonify({'success': False, 'error': str(e)}), 500


# --- PLEX ---

def plex_notify_refresh(settings: dict = None):
    """Chiama /library/sections/all/refresh su Plex dopo rename/move. No-op se non configurato."""
    try:
        s     = settings or _cdb.get_all_settings()
        url   = str(s.get('plex_url',   '') or '').strip().rstrip('/')
        token = str(s.get('plex_token', '') or '').strip()
        if not url or not token:
            return
        import requests as _req
        resp = _req.get(
            f"{url}/library/sections/all/refresh",
            params={"X-Plex-Token": token},
            timeout=10,
        )
        if resp.status_code in (200, 204):
            logger.info("[Plex] ✅ Library Refresh inviato.")
        else:
            logger.warning(f"[Plex] Refresh HTTP {resp.status_code}")
    except Exception as e:
        logger.warning(f"[Plex] plex_notify_refresh: {e}")


@app.route('/api/plex/config', methods=['GET'])
def plex_get_config():
    return jsonify({
        'plex_url':   str(_cdb.get_setting('plex_url',   '') or ''),
        'plex_token': str(_cdb.get_setting('plex_token', '') or ''),
    })


@app.route('/api/plex/config', methods=['POST'])
def plex_save_config():
    data  = request.get_json(force=True) or {}
    url   = str(data.get('plex_url',   '') or '').strip().rstrip('/')
    token = str(data.get('plex_token', '') or '').strip()
    try:
        _cdb.set_settings_bulk({'plex_url': url, 'plex_token': token})
        return jsonify({'success': True})
    except Exception as e:
        return jsonify({'success': False, 'error': str(e)}), 500


@app.route('/api/plex/test-refresh', methods=['POST'])
def plex_test_refresh():
    url   = str(_cdb.get_setting('plex_url',   '') or '').strip().rstrip('/')
    token = str(_cdb.get_setting('plex_token', '') or '').strip()
    if not url or not token:
        return jsonify({'success': False, 'error': 'URL o Token non configurati'}), 400
    try:
        import requests as _req
        resp = _req.get(f"{url}/library/sections/all/refresh",
                        params={"X-Plex-Token": token}, timeout=10)
        if resp.status_code in (200, 204):
            return jsonify({'success': True})
        return jsonify({'success': False, 'error': f'HTTP {resp.status_code}'}), 502
    except Exception as e:
        return jsonify({'success': False, 'error': str(e)}), 500


# ============================================================================
# FLARESOLVERR TEST
# ============================================================================

@app.route('/api/flaresolverr/test', methods=['POST'])
def flaresolverr_test():
    fs_url = str(_cdb.get_setting('flaresolverr_url', '') or '').strip().rstrip('/')
    if not fs_url:
        return jsonify({'success': False, 'error': 'FlareSolverr URL non configurato'}), 400
    try:
        import requests as _req
        resp = _req.post(f"{fs_url}/v1",
            json={"cmd": "request.get", "url": "https://www.google.com", "maxTimeout": 15000},
            timeout=25)
        if resp.status_code != 200:
            return jsonify({'success': False, 'error': f'FlareSolverr HTTP {resp.status_code}'}), 502
        data = resp.json()
        if data.get('status') != 'ok':
            msg = data.get('message', '')
            return jsonify({'success': False, 'error': f'status: {data.get("status","?")} — {msg}'}), 502
        sol_status = data.get('solution', {}).get('status', 0)
        version    = data.get('version', '?')
        return jsonify({'success': True, 'version': version, 'page_status': sol_status})
    except Exception as e:
        return jsonify({'success': False, 'error': str(e)}), 500


# ============================================================================
# TRAKT.TV INTEGRATION
# ============================================================================

import threading as _trakt_threading

_TRAKT_FLOW: dict = {}
_TRAKT_FLOW_LOCK  = _trakt_threading.Lock()


def _trakt_settings() -> dict:
    return {
        "client_id":        str(_cdb.get_setting("trakt_client_id",        "") or ""),
        "client_secret":    str(_cdb.get_setting("trakt_client_secret",     "") or ""),
        "access_token":     str(_cdb.get_setting("trakt_access_token",      "") or ""),
        "refresh_token":    str(_cdb.get_setting("trakt_refresh_token",     "") or ""),
        "token_expires":    int(_cdb.get_setting("trakt_token_expires",     0)  or 0),
        "watchlist_sync":   bool(_cdb.get_setting("trakt_watchlist_sync",   False)),
        "scrobble_enabled": bool(_cdb.get_setting("trakt_scrobble_enabled", False)),
        "calendar_days":    int(_cdb.get_setting("trakt_calendar_days",     7)  or 7),
        "import_quality":   str(_cdb.get_setting("trakt_import_quality",    "720p+") or "720p+"),
        "import_language":  str(_cdb.get_setting("trakt_import_language",   "ita")   or "ita"),
    }


def _trakt_load():
    from core.trakt import load_trakt_client
    return load_trakt_client()


@app.route('/api/trakt/status', methods=['GET'])
def trakt_status():
    try:
        s = _trakt_settings()
        expires_in_days = None
        if s["token_expires"]:
            delta = s["token_expires"] - time.time()
            expires_in_days = max(0, int(delta // 86400))
        return jsonify({
            "configured":       bool(s["client_id"]),
            "authenticated":    bool(s["access_token"]),
            "expires_in_days":  expires_in_days,
            "watchlist_sync":   s["watchlist_sync"],
            "scrobble_enabled": s["scrobble_enabled"],
            "calendar_days":    s["calendar_days"],
            "import_quality":   s["import_quality"],
            "import_language":  s["import_language"],
        })
    except Exception as e:
        logger.error(f"trakt_status: {e}")
        return jsonify({"error": str(e)}), 500


@app.route('/api/trakt/settings', methods=['POST'])
def trakt_save_settings():
    try:
        data = request.get_json(force=True) or {}
        bulk = {}
        for key in ("client_id", "client_secret"):
            if key in data:
                bulk[f"trakt_{key}"] = str(data[key]).strip()
        for key in ("watchlist_sync", "scrobble_enabled"):
            if key in data:
                bulk[f"trakt_{key}"] = bool(data[key])
        if "calendar_days" in data:
            bulk["trakt_calendar_days"] = int(data["calendar_days"])
        for key in ("import_quality", "import_language"):
            if key in data:
                bulk[f"trakt_{key}"] = str(data[key]).strip()
        if bulk:
            _cdb.set_settings_bulk(bulk)
        try:
            from core.config import Config as _Cfg; _Cfg.invalidate()
        except Exception:
            pass
        return jsonify({"ok": True})
    except Exception as e:
        logger.error(f"trakt_save_settings: {e}")
        return jsonify({"error": str(e)}), 500


@app.route('/api/trakt/auth/start', methods=['POST'])
def trakt_auth_start():
    try:
        client = _trakt_load()
        if not client:
            return jsonify({"error": "client_id non configurato. Salva prima le credenziali."}), 400
        flow = client.start_device_auth()
        if not flow:
            return jsonify({"error": "Impossibile avviare il Device Flow Trakt"}), 502
        with _TRAKT_FLOW_LOCK:
            _TRAKT_FLOW.update({
                "device_code": flow["device_code"],
                "interval":    flow.get("interval", 5),
                "expires_in":  flow.get("expires_in", 600),
                "started_at":  time.time(),
            })
        return jsonify({
            "user_code":        flow["user_code"],
            "verification_url": flow["verification_url"],
            "expires_in":       flow.get("expires_in", 600),
            "interval":         flow.get("interval", 5),
        })
    except Exception as e:
        logger.error(f"trakt_auth_start: {e}")
        return jsonify({"error": str(e)}), 500


@app.route('/api/trakt/auth/poll', methods=['POST'])
def trakt_auth_poll():
    try:
        from core.trakt import save_trakt_tokens
        with _TRAKT_FLOW_LOCK:
            state = dict(_TRAKT_FLOW)

        if not state.get("device_code"):
            return jsonify({"status": "error", "message": "Nessun Device Flow attivo. Clicca su 'Collega Trakt'."})

        elapsed = time.time() - state.get("started_at", 0)
        if elapsed >= state.get("expires_in", 600):
            return jsonify({"status": "expired", "message": "Codice scaduto. Riprova."})

        client = _trakt_load()
        if not client:
            return jsonify({"status": "error", "message": "client_id non configurato"})

        resp = requests.post(
            "https://api.trakt.tv/oauth/device/token",
            json={
                "code":          state["device_code"],
                "client_id":     client.client_id,
                "client_secret": client.client_secret,
            },
            headers={"Content-Type": "application/json"},
            timeout=15,
        )

        if resp.status_code == 200:
            data = resp.json()
            client.access_token  = data["access_token"]
            client.refresh_token = data.get("refresh_token", "")
            client.token_expires = int(time.time()) + int(data.get("expires_in", 7776000))
            save_trakt_tokens(client)
            with _TRAKT_FLOW_LOCK:
                _TRAKT_FLOW.clear()
            logger.info("[Trakt] Autenticazione completata.")
            return jsonify({"status": "authorized", "message": "✅ Connesso a Trakt!"})
        elif resp.status_code == 400:
            return jsonify({"status": "pending",  "message": "In attesa di autorizzazione..."})
        elif resp.status_code == 410:
            return jsonify({"status": "expired",  "message": "Codice scaduto."})
        elif resp.status_code == 418:
            return jsonify({"status": "denied",   "message": "Autorizzazione negata."})
        else:
            return jsonify({"status": "error",    "message": f"Errore Trakt: {resp.status_code}"})

    except Exception as e:
        logger.error(f"trakt_auth_poll: {e}")
        return jsonify({"status": "error", "message": str(e)})


@app.route('/api/trakt/auth/revoke', methods=['POST'])
def trakt_auth_revoke():
    try:
        from core.trakt import save_trakt_tokens
        client = _trakt_load()
        if client and client.is_authenticated():
            client.revoke_token()
            save_trakt_tokens(client)
        _cdb.set_settings_bulk({
            "trakt_access_token":  "",
            "trakt_refresh_token": "",
            "trakt_token_expires": 0,
        })
        return jsonify({"ok": True})
    except Exception as e:
        logger.error(f"trakt_auth_revoke: {e}")
        return jsonify({"error": str(e)}), 500


@app.route('/api/trakt/watchlist', methods=['GET'])
def trakt_get_watchlist():
    try:
        client = _trakt_load()
        if not client or not client.is_authenticated():
            return jsonify({"error": "Non autenticato su Trakt"}), 401
        shows = client.get_watchlist_shows()
        c = db.conn.cursor()
        c.execute("SELECT name FROM series WHERE enabled=1")
        existing = {r[0].lower() for r in c.fetchall()}
        return jsonify([{
            "title":     show["title"],
            "year":      show["year"],
            "ids":       show["ids"],
            "listed_at": show["listed_at"],
            "in_extto":  show["title"].lower() in existing,
        } for show in shows])
    except Exception as e:
        logger.error(f"trakt_get_watchlist: {e}")
        return jsonify({"error": str(e)}), 500


@app.route('/api/trakt/watchlist/import', methods=['POST'])
def trakt_import_watchlist():
    try:
        data          = request.get_json(force=True) or {}
        s             = _trakt_settings()
        quality       = data.get("quality",       s["import_quality"])
        language      = data.get("language",      s["import_language"])
        skip_existing = data.get("skip_existing", True)
        filter_titles = [t.lower() for t in data.get("titles", [])]

        client = _trakt_load()
        if not client or not client.is_authenticated():
            return jsonify({"error": "Non autenticato su Trakt"}), 401

        shows = client.get_watchlist_shows()
        if not shows:
            return jsonify({"imported": 0, "skipped": 0, "message": "Watchlist vuota o errore API"})

        c = db.conn.cursor()
        c.execute("SELECT name FROM series")
        existing = {r[0].lower() for r in c.fetchall()}

        imported, skipped, errors = 0, 0, []

        for show in shows:
            title = show["title"]
            tl    = title.lower()
            if filter_titles and tl not in filter_titles:
                continue
            if skip_existing and tl in existing:
                skipped += 1
                continue
            tmdb_id = str(show["ids"].get("tmdb", "") or "")
            try:
                c.execute(
                    """INSERT INTO series
                       (name, quality_requirement, seasons, language, enabled,
                        archive_path, timeframe, aliases, ignored_seasons, tmdb_id)
                       VALUES (?, ?, '1+', ?, 1, '', 0, '[]', '[]', ?)
                       ON CONFLICT(name) DO NOTHING""",
                    (title, quality, language, tmdb_id)
                )
                if c.rowcount > 0:
                    imported += 1
                    logger.info(f"[Trakt] ✅ Importata: {title} (tmdb={tmdb_id})")
                else:
                    skipped += 1
            except Exception as ie:
                errors.append(f"{title}: {ie}")
                logger.warning(f"[Trakt] import '{title}': {ie}")

        db.conn.commit()
        return jsonify({
            "imported": imported,
            "skipped":  skipped,
            "errors":   errors,
            "message":  f"{imported} serie importate, {skipped} già presenti.",
        })
    except Exception as e:
        logger.error(f"trakt_import_watchlist: {e}")
        return jsonify({"error": str(e)}), 500


@app.route('/api/trakt/calendar', methods=['GET'])
def trakt_get_calendar():
    try:
        from datetime import date as _date
        client = _trakt_load()
        if not client or not client.is_authenticated():
            return jsonify({"error": "Non autenticato su Trakt"}), 401

        s          = _trakt_settings()
        days       = max(1, min(int(request.args.get("days", s["calendar_days"]) or 7), 31))
        start_date = request.args.get("start", _date.today().isoformat())

        episodes = client.get_my_calendar(start_date=start_date, days=days)

        c = db.conn.cursor()
        c.execute("SELECT name FROM series WHERE enabled=1")
        existing = {r[0].lower() for r in c.fetchall()}
        for ep in episodes:
            ep["in_extto"] = ep["series_title"].lower() in existing

        return jsonify({"start_date": start_date, "days": days, "episodes": episodes})
    except Exception as e:
        logger.error(f"trakt_get_calendar: {e}")
        return jsonify({"error": str(e)}), 500


@app.route('/api/trakt/scrobble', methods=['POST'])
def trakt_scrobble():
    try:
        s = _trakt_settings()
        if not s["scrobble_enabled"]:
            return jsonify({"error": "Scrobble non abilitato nelle impostazioni Trakt"}), 403
        client = _trakt_load()
        if not client or not client.is_authenticated():
            return jsonify({"error": "Non autenticato su Trakt"}), 401

        data    = request.get_json(force=True) or {}
        name    = data.get("series_name", "")
        season  = int(data.get("season", 0))
        ep      = int(data.get("episode", 0))
        tmdb_id = int(data["tmdb_id"]) if data.get("tmdb_id") else None

        if not name or not season or not ep:
            return jsonify({"error": "series_name, season ed episode sono obbligatori"}), 400

        ok = client.scrobble_episode(name, tmdb_id, season, ep)
        if ok:
            from core.trakt import save_trakt_tokens
            save_trakt_tokens(client)
            return jsonify({"ok": True, "message": f"Segnato: {name} S{season:02d}E{ep:02d}"})
        return jsonify({"error": "Scrobble fallito (vedi log)"}), 502
    except Exception as e:
        logger.error(f"trakt_scrobble: {e}")
        return jsonify({"error": str(e)}), 500


# ============================================================================
# END TRAKT INTEGRATION
# ============================================================================

@app.route('/api/aria2/status-service', methods=['GET'])
def aria2_status_service():
    import subprocess
    try:
        # Controlla se il processo aria2c è in esecuzione
        subprocess.check_output(['pgrep', '-x', 'aria2c'])
        return jsonify({'active': True})
    except:
        return jsonify({'active': False})

@app.route('/api/aria2/start', methods=['POST'])
def aria2_start():
    import subprocess
    try:
        import core.config_db as _cdb
        path   = _cdb.get_setting('aria2c_path', 'aria2c')
        secret = _cdb.get_setting('aria2_rpc_secret', '')
        port   = int(_cdb.get_setting('aria2_rpc_port', '6800') or '6800')
        cmd = [path, '--daemon', '--enable-rpc', '--rpc-listen-all',
               f'--rpc-listen-port={port}']
        if secret:
            cmd.append(f'--rpc-secret={secret}')
        subprocess.Popen(cmd)
        # Se aria2_rpc_url non è ancora configurato, lo impostiamo automaticamente
        # in modo che EXTTO (Watchdog, add()) sappia dove connettersi.
        current_url = (_cdb.get_setting('aria2_rpc_url', '') or '').strip()
        if not current_url:
            auto_url = f'http://localhost:{port}/jsonrpc'
            try:
                _cdb.set_settings_bulk({'aria2_rpc_url': auto_url})
            except Exception:
                pass  # Non blocchiamo l'avvio se il salvataggio fallisce
        return jsonify({'success': True})
    except Exception as e:
        return jsonify({'success': False, 'error': str(e)})

@app.route('/api/aria2/stop', methods=['POST'])
def aria2_stop():
    import subprocess
    try:
        subprocess.call(['pkill', '-x', 'aria2c'])
        return jsonify({'success': True})
    except Exception as e:
        return jsonify({'success': False, 'error': str(e)})


def _rqbit_pidfile() -> str:
    from core.constants import STATE_DIR as _SD
    return os.path.join(_SD, 'rqbit.pid')


def _rqbit_build_cmd(overrides: dict = None) -> list:
    """overrides (opzionale): {'rqbit_bin_path','rqbit_http_addr','rqbit_dir','rqbit_socks_url'}
    — permette di avviare rqbit con valori non ancora salvati (usato da 'Verifica
    configurazione' → 'Avvia ora'). Le chiavi assenti/vuote ricadono sul valore salvato."""
    overrides = overrides or {}

    def _val(key, default=''):
        v = overrides.get(key)
        return str(v).strip() if v not in (None, '') else str(_cdb.get_setting(key, default)).strip()

    bin_path  = _val('rqbit_bin_path', './rqbit-linux-amd64')
    addr      = _val('rqbit_http_addr', '127.0.0.1:3030')
    out_dir   = _val('rqbit_dir', '/downloads')
    socks_url = _val('rqbit_socks_url', '')
    dl_limit  = int(_cdb.get_setting('rqbit_dl_limit', '0') or 0)
    ul_limit  = int(_cdb.get_setting('rqbit_ul_limit', '0') or 0)

    os.makedirs(out_dir, exist_ok=True)
    cmd = [bin_path, '--http-api-listen-addr', addr]
    if dl_limit > 0:
        cmd += ['--ratelimit-download', str(dl_limit * 1024)]
    if ul_limit > 0:
        cmd += ['--ratelimit-upload', str(ul_limit * 1024)]
    if socks_url:
        cmd += ['--socks-url', socks_url]
    cmd += ['server', 'start', out_dir]
    return cmd


def _rqbit_is_running() -> bool:
    try:
        addr = _cdb.get_setting('rqbit_http_addr', '127.0.0.1:3030')
        r = requests.get(f"http://{addr}/", timeout=2)
        return r.status_code == 200
    except Exception:
        return False


def _rqbit_do_start(overrides: dict = None) -> dict:
    try:
        # Evita di lanciare un secondo processo se uno risponde già sullo
        # stesso indirizzo (es. doppio click su "Avvia"): il nuovo processo
        # fallirebbe il bind della porta e lascerebbe un pidfile "orfano"
        # puntato su un PID morto, perdendo il tracking di quello reale.
        addr = (overrides or {}).get('rqbit_http_addr') or _cdb.get_setting('rqbit_http_addr', '127.0.0.1:3030')
        try:
            if requests.get(f"http://{addr}/", timeout=1.5).status_code == 200:
                return {'success': True, 'already_running': True}
        except Exception:
            pass

        proc = subprocess.Popen(_rqbit_build_cmd(overrides), stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL)
        with open(_rqbit_pidfile(), 'w') as f:
            f.write(str(proc.pid))
        return {'success': True}
    except Exception as e:
        return {'success': False, 'error': str(e)}


def _rqbit_do_stop() -> dict:
    try:
        pidfile = _rqbit_pidfile()
        if not os.path.exists(pidfile):
            return {'success': False, 'error': 'rqbit non risulta avviato da EXTTO'}
        with open(pidfile) as f:
            pid = int(f.read().strip())
        os.kill(pid, 15)  # SIGTERM
        os.remove(pidfile)
        return {'success': True}
    except ProcessLookupError:
        try:
            os.remove(_rqbit_pidfile())
        except Exception:
            pass
        return {'success': True}
    except Exception as e:
        return {'success': False, 'error': str(e)}


@app.route('/api/rqbit/test-config', methods=['POST'])
def rqbit_test_config():
    """Verifica la configurazione rqbit (usa i valori del form, anche non
    ancora salvati) senza modificare nulla: binario, cartella download,
    indirizzo HTTP API (e se già in ascolto, un vero round-trip sull'API)."""
    data = request.get_json(silent=True) or {}
    bin_path = (data.get('bin_path') or _cdb.get_setting('rqbit_bin_path', './rqbit-linux-amd64')).strip()
    out_dir  = (data.get('dir') or _cdb.get_setting('rqbit_dir', '/downloads')).strip()
    addr     = (data.get('http_addr') or _cdb.get_setting('rqbit_http_addr', '127.0.0.1:3030')).strip()
    socks_url = (data.get('socks_url') or '').strip()

    checks = []
    overall_ok = True
    rqbit_running = False

    def _add(label, ok, message):
        nonlocal overall_ok
        checks.append({'label': label, 'ok': ok, 'message': message})
        if not ok:
            overall_ok = False

    # 1. Binario
    try:
        resolved = bin_path if (os.sep in bin_path or bin_path.startswith('.')) else (shutil.which(bin_path) or bin_path)
        if not os.path.isfile(resolved):
            _add('Binario', False, f"'{bin_path}' non trovato")
        elif not os.access(resolved, os.X_OK):
            _add('Binario', False, f"'{bin_path}' trovato ma non eseguibile (permessi?)")
        else:
            out = subprocess.run([resolved, '--version'], capture_output=True, text=True, timeout=5).stdout
            m = re.search(r'(\d+\.\d+\.\d+(?:-\w+(?:\.\d+)?)?)', out)
            ver = m.group(1) if m else out.strip() or '?'
            _add('Binario', True, f"OK — versione {ver}")
    except Exception as e:
        _add('Binario', False, f"Errore eseguendo il binario: {e}")

    # 2. Cartella download
    try:
        os.makedirs(out_dir, exist_ok=True)
        test_file = os.path.join(out_dir, '.extto_rqbit_write_test')
        with open(test_file, 'w') as f:
            f.write('ok')
        os.remove(test_file)
        _add('Cartella download', True, f"'{out_dir}' scrivibile")
    except Exception as e:
        _add('Cartella download', False, f"'{out_dir}' non scrivibile: {e}")

    # 3. Indirizzo HTTP API
    try:
        if ':' not in addr:
            _add('Indirizzo HTTP API', False, f"'{addr}' non è nel formato host:porta")
        else:
            try:
                r = requests.get(f"http://{addr}/", timeout=2)
                info = r.json() if r.status_code == 200 else {}
                if info.get('server') == 'rqbit':
                    rqbit_running = True
                    _add('Indirizzo HTTP API', True,
                         f"rqbit già in ascolto su {addr} (v{info.get('version', '?')})")
                    # 4. Round-trip reale sull'API, dato che è già raggiungibile
                    try:
                        requests.get(f"http://{addr}/stats", timeout=3).raise_for_status()
                        _add('Round-trip API', True, 'GET /stats risposto correttamente')
                    except Exception as e:
                        _add('Round-trip API', False, f"/stats non risponde: {e}")
                else:
                    _add('Indirizzo HTTP API', False,
                         f"qualcos'altro risponde già su {addr} (non è rqbit) — cambia porta")
            except requests.exceptions.ConnectionError:
                _add('Indirizzo HTTP API', True, f"{addr} libero, pronto per l'avvio")
    except Exception as e:
        _add('Indirizzo HTTP API', False, f"Errore verifica indirizzo: {e}")

    # 5. SOCKS proxy (solo verifica formato, non testiamo la connessione reale)
    if socks_url:
        if socks_url.startswith('socks5://'):
            _add('Proxy SOCKS5', True, 'formato valido (connessione non testata)')
        else:
            _add('Proxy SOCKS5', False, "deve iniziare con 'socks5://'")

    return jsonify({'success': overall_ok, 'checks': checks, 'rqbit_running': rqbit_running})


def _rqbit_notify(subject: str, message: str) -> None:
    try:
        from core.notifier import Notifier
        notifier = Notifier(_cdb.get_all_settings())
        notifier._send_telegram(message)
        notifier._send_email(subject, message)
    except Exception as e:
        logger.debug(f"_rqbit_notify: {e}")


_RQ_SUPERVISOR_STATE = {'consecutive_failures': 0, 'given_up': False}
_RQ_SUPERVISOR_MAX_FAILURES = 5


def _rqbit_supervisor_loop():
    """Sorveglia il processo rqbit avviato da EXTTO (analogo al supervisore
    implicito che libtorrent ha gratis essendo in-process): se risulta 'atteso
    attivo' (pidfile presente, rqbit_enabled=yes) ma l'API HTTP non risponde,
    lo considera crashato, notifica e prova a riavviarlo automaticamente.
    Dopo troppi fallimenti consecutivi smette di ritentare (niente restart-loop)
    e manda una notifica che richiede intervento manuale."""
    import time as _t
    _t.sleep(30)  # attesa iniziale: lascia partire il resto del processo Flask
    while True:
        try:
            enabled = str(_cdb.get_setting('rqbit_enabled', 'no')).lower() in ('yes', 'true', '1')
            expected_running = enabled and os.path.exists(_rqbit_pidfile())

            if not expected_running:
                _RQ_SUPERVISOR_STATE['given_up'] = False
            elif _rqbit_is_running():
                _RQ_SUPERVISOR_STATE['consecutive_failures'] = 0
                _RQ_SUPERVISOR_STATE['given_up'] = False
            elif not _RQ_SUPERVISOR_STATE['given_up']:
                logger.warning("🔴 rqbit non risponde: tentativo di riavvio automatico...")
                _rqbit_notify(
                    "⚠️ EXTTO: rqbit non risponde",
                    "🔴 <b>rqbit</b> non risponde più (crash o processo terminato).\n"
                    "Tentativo di riavvio automatico in corso..."
                )
                result = _rqbit_do_start()
                _t.sleep(3)
                if result.get('success') and _rqbit_is_running():
                    logger.info("🟢 rqbit riavviato con successo dal supervisore.")
                    _rqbit_notify(
                        "✅ EXTTO: rqbit riavviato",
                        "✅ <b>rqbit</b> è stato riavviato automaticamente con successo."
                    )
                    _RQ_SUPERVISOR_STATE['consecutive_failures'] = 0
                else:
                    _RQ_SUPERVISOR_STATE['consecutive_failures'] += 1
                    n = _RQ_SUPERVISOR_STATE['consecutive_failures']
                    logger.error(f"❌ rqbit: riavvio automatico fallito ({n}/{_RQ_SUPERVISOR_MAX_FAILURES}).")
                    if n >= _RQ_SUPERVISOR_MAX_FAILURES:
                        _RQ_SUPERVISOR_STATE['given_up'] = True
                        _rqbit_notify(
                            "🆘 EXTTO: rqbit non riparte",
                            f"🆘 <b>rqbit</b> non riparte dopo {n} tentativi automatici.\n"
                            "Serve un intervento manuale (verifica binario/percorso configurati in "
                            "Configurazione → Client, poi riavvia dal pannello Manutenzione)."
                        )
        except Exception as e:
            logger.debug(f"_rqbit_supervisor_loop: {e}")

        _t.sleep(20)


@app.route('/api/rqbit/status-service', methods=['GET'])
def rqbit_status_service():
    return jsonify({
        'active': _rqbit_is_running(),
        'supervisor_given_up': _RQ_SUPERVISOR_STATE['given_up'],
        'consecutive_failures': _RQ_SUPERVISOR_STATE['consecutive_failures'],
    })

@app.route('/api/rqbit/start', methods=['POST'])
def rqbit_start():
    # Accetta opzionalmente valori non ancora salvati (usato da "Verifica
    # configurazione" → "Avvia ora"), sia in forma corta (bin_path/http_addr/
    # dir/socks_url) sia con le chiavi rqbit_* complete.
    body = request.get_json(silent=True) or {}
    overrides = {
        'rqbit_bin_path':  body.get('bin_path')  or body.get('rqbit_bin_path'),
        'rqbit_http_addr': body.get('http_addr') or body.get('rqbit_http_addr'),
        'rqbit_dir':       body.get('dir')       or body.get('rqbit_dir'),
        'rqbit_socks_url': body.get('socks_url') or body.get('rqbit_socks_url'),
    }
    # Persiste subito i valori usati per l'avvio: altrimenti il badge di stato,
    # il supervisore e i prossimi avvii leggerebbero l'indirizzo/percorso salvato
    # in precedenza (diverso da quello realmente in ascolto), rischiando di far
    # partire un secondo processo rqbit "orfano" su un indirizzo differente.
    to_save = {k: v for k, v in overrides.items() if v not in (None, '')}
    if to_save:
        try:
            _cdb.set_settings_bulk(to_save)
        except Exception as e:
            logger.debug(f"rqbit_start: salvataggio override fallito: {e}")
    return jsonify(_rqbit_do_start(overrides))

@app.route('/api/rqbit/stop', methods=['POST'])
def rqbit_stop():
    return jsonify(_rqbit_do_stop())


# --- Controllo/aggiornamento versione rqbit (release GitHub del CLI/server, non la desktop app) ---
_RQ_UPDATE_CACHE: dict = {'latest': '', 'current': '', 'update_available': False, 'checked_at': 0.0}
_RQ_GITHUB_RELEASE_API = 'https://api.github.com/repos/ikatson/rqbit/releases/latest'
_RQ_ASSET_NAME = 'rqbit-linux-amd64'


def _rqbit_current_version(bin_path: str) -> str:
    try:
        out = subprocess.run([bin_path, '--version'], capture_output=True, text=True, timeout=5).stdout
        m = re.search(r'(\d+\.\d+\.\d+(?:-\w+(?:\.\d+)?)?)', out)
        return m.group(1) if m else ''
    except Exception:
        return ''


def _get_rqbit_update_info(force: bool = False) -> dict:
    """Controlla la release GitHub più recente di rqbit (CLI/server). Risultato cached 24h."""
    global _RQ_UPDATE_CACHE
    now = time.time()
    if not force and now - _RQ_UPDATE_CACHE['checked_at'] < 86400:
        return _RQ_UPDATE_CACHE
    _RQ_UPDATE_CACHE['checked_at'] = now
    try:
        bin_path = _cdb.get_setting('rqbit_bin_path', './rqbit-linux-amd64')
        current = _rqbit_current_version(bin_path)
        r = requests.get(_RQ_GITHUB_RELEASE_API, timeout=8,
                          headers={'Accept': 'application/vnd.github+json'})
        r.raise_for_status()
        tag = (r.json().get('tag_name') or '').lstrip('v')
        _RQ_UPDATE_CACHE = {
            'latest': tag,
            'current': current,
            'update_available': bool(tag and current and tag != current),
            'checked_at': now,
        }
        if _RQ_UPDATE_CACHE['update_available']:
            logger.info(f"🔔 rqbit: versione {tag} disponibile su GitHub (installata: {current})")
    except Exception as _e:
        logger.debug(f"_get_rqbit_update_info: {_e}")
    return _RQ_UPDATE_CACHE


@app.route('/api/rqbit/update-check', methods=['GET'])
def rqbit_update_check():
    force = request.args.get('force', '').lower() in ('1', 'true', 'yes')
    return jsonify(_get_rqbit_update_info(force=force))


@app.route('/api/rqbit/update', methods=['POST'])
def rqbit_update():
    """Scarica l'ultima release rqbit-linux-amd64 da GitHub, sostituisce il binario
    configurato e riavvia il servizio se era in esecuzione."""
    try:
        bin_path = _cdb.get_setting('rqbit_bin_path', './rqbit-linux-amd64')
        info = _get_rqbit_update_info(force=True)
        latest = info.get('latest', '')
        if not latest:
            return jsonify({'success': False, 'error': 'Impossibile determinare la versione più recente'})

        was_running = _rqbit_is_running()
        if was_running:
            _rqbit_do_stop()
            time.sleep(1)
            # Verifica che si sia davvero fermato (es. se non era tracciato dal
            # pidfile di EXTTO, _rqbit_do_stop() fallisce silenziosamente):
            # altrimenti sostituiremmo il binario sotto un processo ancora vivo
            # e poi lo "start" finale troverebbe l'indirizzo già occupato,
            # segnalando falsamente 'restarted' con la versione vecchia ancora
            # in esecuzione.
            if _rqbit_is_running():
                return jsonify({'success': False,
                                 'error': 'rqbit risulta ancora in esecuzione (non tracciato da EXTTO?) — fermalo manualmente prima di aggiornare.'})

        download_url = f"https://github.com/ikatson/rqbit/releases/download/v{latest}/{_RQ_ASSET_NAME}"
        tmp_path = bin_path + '.update_tmp'
        with requests.get(download_url, stream=True, timeout=60) as r:
            r.raise_for_status()
            with open(tmp_path, 'wb') as f:
                for chunk in r.iter_content(chunk_size=1024 * 256):
                    f.write(chunk)
        os.chmod(tmp_path, 0o755)
        os.replace(tmp_path, bin_path)

        _RQ_UPDATE_CACHE['current'] = latest
        _RQ_UPDATE_CACHE['update_available'] = False

        restarted = False
        if was_running:
            restarted = _rqbit_do_start().get('success', False)

        return jsonify({'success': True, 'version': latest, 'restarted': restarted})
    except Exception as e:
        return jsonify({'success': False, 'error': str(e)})


def _mfs_enrich_worker():
    """Thread background: arricchisce movie_feed_seen con dati TMDB a bassa priorità.
    Cadenza: ~1 query ogni 4s → max 15 req/min, molto sotto il limite TMDB (40/10s).
    Processa 10 gruppi per ciclo, poi dorme 5 minuti prima del prossimo batch.
    tmdb_id=0 significa 'cercato, non trovato' → non viene riprovato.
    """
    import time as _t
    _t.sleep(45)  # warm-up: lascia avviare il server
    while True:
        try:
            from core.config import Config as _Cfg
            from core.database import Database as _DB
            cfg = _Cfg()
            api_key = getattr(cfg, 'tmdb_api_key', '').strip()
            if not api_key:
                _t.sleep(300)
                continue
            tmdb_lang = getattr(cfg, 'tmdb_language', 'it-IT').strip() or 'it-IT'
            db = _DB()
            groups = db.get_mfs_unenriched_groups(limit=10)
            db.close()
            if not groups:
                _t.sleep(300)
                continue
            for g in groups:
                ck        = g['ck']
                raw_name  = g['best_name'] or ''
                year      = g['year'] or 0
                # Pulisci eventuali tag sorgente residui nel nome
                clean_name = re.sub(r'\[.*?\].*$', '', raw_name).strip(' -_.,')
                if not clean_name or len(clean_name) < 2:
                    db2 = _DB(); db2.apply_mfs_tmdb(ck, 0, ''); db2.close()
                    _t.sleep(4)
                    continue
                try:
                    url = (f"https://api.themoviedb.org/3/search/movie"
                           f"?api_key={api_key}"
                           f"&query={requests.utils.quote(clean_name)}"
                           f"&language={tmdb_lang}")
                    if year:
                        url += f"&year={year}"
                    res = requests.get(url, timeout=8).json()
                    results = res.get('results', [])
                    db2 = _DB()
                    if results:
                        # Escludi voci a bassissima popolarità (spot TV, trailer, ecc.)
                        good = [r for r in results if r.get('popularity', 0) >= 1.0]
                        first = good[0] if good else None
                        if first:
                            n = db2.apply_mfs_tmdb(ck, first['id'], first.get('title', clean_name))
                            logger.debug(f"🎬 mfs_enrich: '{clean_name}' → TMDB {first['id']} '{first.get('title')}' (pop={first.get('popularity',0):.1f}, {n} record aggiornati)")
                        else:
                            db2.apply_mfs_tmdb(ck, 0, '')
                            logger.debug(f"mfs_enrich: '{clean_name}' → solo risultati a bassa popolarità (scartati)")
                    else:
                        db2.apply_mfs_tmdb(ck, 0, '')
                        logger.debug(f"mfs_enrich: '{clean_name}' → nessun risultato TMDB")
                    db2.close()
                except Exception as ex:
                    logger.warning(f"mfs_enrich TMDB error for '{clean_name}': {ex}")
                _t.sleep(4)   # rate limit conservativo
        except Exception as ex:
            logger.warning(f"_mfs_enrich_worker: {ex}")
        _t.sleep(300)   # 5 minuti tra un batch e il prossimo


def _sfs_enrich_worker():
    """Thread background: arricchisce series_feed_seen con dati TMDB a bassa priorità.
    Stessa cadenza e semantica di _mfs_enrich_worker, ma verso /search/tv.
    tmdb_id=0 significa 'cercato, non trovato' → non viene riprovato.
    """
    import time as _t
    _t.sleep(60)  # warm-up: lascia avviare il server (sfalsato rispetto a mfs-enrich)
    while True:
        try:
            from core.config import Config as _Cfg
            from core.database import Database as _DB
            cfg = _Cfg()
            api_key = getattr(cfg, 'tmdb_api_key', '').strip()
            if not api_key:
                _t.sleep(300)
                continue
            tmdb_lang = getattr(cfg, 'tmdb_language', 'it-IT').strip() or 'it-IT'
            db = _DB()
            groups = db.get_sfs_unenriched_groups(limit=10)
            db.close()
            if not groups:
                _t.sleep(300)
                continue
            for g in groups:
                ck        = g['ck']
                raw_name  = g['best_name'] or ''
                # Pulisci eventuali tag sorgente residui nel nome
                clean_name = re.sub(r'\[.*?\].*$', '', raw_name).strip(' -_.,')
                if not clean_name or len(clean_name) < 2:
                    db2 = _DB(); db2.apply_sfs_tmdb(ck, 0, ''); db2.close()
                    _t.sleep(4)
                    continue
                try:
                    url = (f"https://api.themoviedb.org/3/search/tv"
                           f"?api_key={api_key}"
                           f"&query={requests.utils.quote(clean_name)}"
                           f"&language={tmdb_lang}")
                    res = requests.get(url, timeout=8).json()
                    results = res.get('results', [])
                    db2 = _DB()
                    if results:
                        # Escludi voci a bassissima popolarità (spot TV, trailer, ecc.)
                        good = [r for r in results if r.get('popularity', 0) >= 1.0]
                        first = good[0] if good else None
                        if first:
                            n = db2.apply_sfs_tmdb(ck, first['id'], first.get('name', clean_name))
                            logger.debug(f"📺 sfs_enrich: '{clean_name}' → TMDB {first['id']} '{first.get('name')}' (pop={first.get('popularity',0):.1f}, {n} record aggiornati)")
                        else:
                            db2.apply_sfs_tmdb(ck, 0, '')
                            logger.debug(f"sfs_enrich: '{clean_name}' → solo risultati a bassa popolarità (scartati)")
                    else:
                        db2.apply_sfs_tmdb(ck, 0, '')
                        logger.debug(f"sfs_enrich: '{clean_name}' → nessun risultato TMDB")
                    db2.close()
                except Exception as ex:
                    logger.warning(f"sfs_enrich TMDB error for '{clean_name}': {ex}")
                _t.sleep(4)   # rate limit conservativo
        except Exception as ex:
            logger.warning(f"_sfs_enrich_worker: {ex}")
        _t.sleep(300)   # 5 minuti tra un batch e il prossimo


if __name__ == '__main__':
    from waitress import serve
    import logging
    from core.config import Config

    logging.getLogger('waitress').setLevel(logging.ERROR)

    _cfg_port = Config()
    WEB_PORT = int(getattr(_cfg_port, 'web_port', None) or 5000)

    # Auto-sync dei file YAML delle traduzioni -> DB
    _sync_language_files()

    # Thread enrichment TMDB per Film dal Feed (low-priority, rate-limited)
    threading.Thread(target=_mfs_enrich_worker, daemon=True, name='mfs-enrich').start()
    threading.Thread(target=_sfs_enrich_worker, daemon=True, name='sfs-enrich').start()

    # Supervisore rqbit: rileva crash del processo esterno e lo riavvia automaticamente
    threading.Thread(target=_rqbit_supervisor_loop, daemon=True, name='rqbit-supervisor').start()

    print(f"EXTTO Web Interface starting on http://localhost:{WEB_PORT}")
    serve(app, host='0.0.0.0', port=WEB_PORT, threads=4)