from __future__ import annotations

import base64
import os
import platform
import sys
import time
import re
from datetime import datetime, timezone
import urllib.request
import urllib.parse
import socket
import json
import psutil
import xml.etree.ElementTree as ET
from flask import Blueprint, jsonify, request
from ..config import DB_PATH, JOBS_RETENTION_DAYS, SMART_QUEUE_HISTORY_RETENTION_DAYS, WORKERS
from ..db import default_user_id, connect, utcnow
from ..services import preferences, rtorrent
from ..services.torrent_cache import torrent_cache
from ..services.torrent_summary import cached_summary
from ..services.workers import enqueue, list_jobs, cancel_job, retry_job, clear_jobs
from ..services.geoip import lookup_ip

bp = Blueprint("api", __name__, url_prefix="/api")


def ok(payload=None):
    data = {"ok": True}
    if payload:
        data.update(payload)
    return jsonify(data)



PORT_CHECK_CACHE_SECONDS = 6 * 60 * 60


def _app_setting_get(key: str):
    with connect() as conn:
        row = conn.execute("SELECT value FROM app_settings WHERE key=?", (key,)).fetchone()
        return row.get("value") if row else None


def _app_setting_set(key: str, value: str):
    with connect() as conn:
        conn.execute("INSERT OR REPLACE INTO app_settings(key,value) VALUES(?,?)", (key, value))


def _iso_from_epoch(value) -> str | None:
    try:
        return datetime.fromtimestamp(float(value), timezone.utc).isoformat(timespec="seconds")
    except Exception:
        return None


def _public_ip(profile: dict | None = None, force: bool = False) -> str:
    if profile and bool(profile.get("is_remote")):
        return rtorrent.remote_public_ip(profile, force=force)
    req = urllib.request.Request("https://api.ipify.org", headers={"User-Agent": "pyTorrent/port-check"})
    with urllib.request.urlopen(req, timeout=8) as res:
        return res.read(64).decode("utf-8", "replace").strip()


def _incoming_port(profile: dict) -> int | None:
    try:
        value = str(rtorrent.client_for(profile).call("network.port_range") or "")
    except Exception:
        value = ""
    match = re.search(r"(\d{2,5})", value)
    if not match:
        return None
    port = int(match.group(1))
    return port if 1 <= port <= 65535 else None


def _yougetsignal_check(public_ip: str, port: int) -> dict:
    body = urllib.parse.urlencode({"remoteAddress": public_ip, "portNumber": str(port)}).encode("utf-8")
    req = urllib.request.Request(
        "https://ports.yougetsignal.com/check-port.php",
        data=body,
        headers={
            "Content-Type": "application/x-www-form-urlencoded; charset=UTF-8",
            "User-Agent": "pyTorrent/port-check",
            "Accept": "text/html,application/json,*/*",
        },
        method="POST",
    )
    with urllib.request.urlopen(req, timeout=12) as res:
        text = res.read(8192).decode("utf-8", "replace")
    low = text.lower()
    if "is open" in low:
        return {"status": "open", "source": "yougetsignal", "raw": text[:500]}
    if "is closed" in low:
        return {"status": "closed", "source": "yougetsignal", "raw": text[:500]}
    return {"status": "unknown", "source": "yougetsignal", "raw": text[:500]}


def _local_port_fallback(public_ip: str, port: int) -> dict:
    try:
        with socket.create_connection((public_ip, port), timeout=3):
            return {"status": "open", "source": "local-fallback"}
    except Exception as exc:
        return {"status": "unknown", "source": "local-fallback", "error": f"Local fallback inconclusive: {exc}"}


def port_check_status(force: bool = False) -> dict:
    profile = preferences.active_profile()
    prefs = preferences.get_preferences()
    enabled = bool((prefs or {}).get("port_check_enabled"))
    if not profile:
        return {"status": "unknown", "enabled": enabled, "error": "No profile"}
    port = _incoming_port(profile)
    if not port:
        return {"status": "unknown", "enabled": enabled, "error": "Cannot read rTorrent network.port_range"}
    cache_key = f"port_check:{profile['id']}:{port}"
    if not force:
        cached = _app_setting_get(cache_key)
        if cached:
            try:
                data = json.loads(cached)
                if time.time() - float(data.get("checked_at_epoch") or 0) < PORT_CHECK_CACHE_SECONDS:
                    data["cached"] = True
                    data["enabled"] = enabled
                    if not data.get("checked_at"):
                        data["checked_at"] = _iso_from_epoch(data.get("checked_at_epoch"))
                    return data
            except Exception:
                pass
    checked_at_epoch = time.time()
    result = {"status": "unknown", "enabled": enabled, "port": port, "checked_at_epoch": checked_at_epoch, "checked_at": _iso_from_epoch(checked_at_epoch), "cached": False}
    try:
        public_ip = _public_ip(profile, force=force)
        result["public_ip"] = public_ip
        result["remote"] = bool(profile.get("is_remote"))
        result.update(_yougetsignal_check(public_ip, port))
    except Exception as exc:
        result["error"] = f"YouGetSignal failed: {exc}"
        try:
            public_ip = result.get("public_ip") or _public_ip(profile, force=force)
            result["public_ip"] = public_ip
            result["remote"] = bool(profile.get("is_remote"))
            result.update(_local_port_fallback(public_ip, port))
        except Exception as fallback_exc:
            result["fallback_error"] = str(fallback_exc)
            result["source"] = "none"
    _app_setting_set(cache_key, json.dumps(result))
    return result






def _safe_len(callable_obj) -> int | None:
    try:
        return len(callable_obj())
    except Exception:
        return None

def _table_count(table: str, where: str = "", params: tuple = ()) -> int:
    with connect() as conn:
        exists = conn.execute("SELECT name FROM sqlite_master WHERE type='table' AND name=?", (table,)).fetchone()
        if not exists:
            return 0
        row = conn.execute(f"SELECT COUNT(*) AS n FROM {table} {where}", params).fetchone()
    return int((row or {}).get("n") or 0)


def _db_size() -> dict:
    try:
        size = DB_PATH.stat().st_size if DB_PATH.exists() else 0
        return {"path": str(DB_PATH), "size": size, "size_h": rtorrent.human_size(size)}
    except Exception as exc:
        return {"path": str(DB_PATH), "size": 0, "size_h": "0 B", "error": str(exc)}


def cleanup_summary() -> dict:
    return {
        "jobs_total": _table_count("jobs"),
        "jobs_clearable": _table_count("jobs", "WHERE status NOT IN ('pending', 'running')"),
        "smart_queue_history_total": _table_count("smart_queue_history"),
        "retention_days": {
            "jobs": JOBS_RETENTION_DAYS,
            "smart_queue_history": SMART_QUEUE_HISTORY_RETENTION_DAYS,
        },
        "database": _db_size(),
    }

def active_default_download_path(profile: dict | None) -> str:
    if not profile:
        return ""
    try:
        return rtorrent.default_download_path(profile)
    except Exception:
        return ""


def enrich_bulk_payload(profile: dict, action_name: str, data: dict) -> dict:
    payload = dict(data or {})
    hashes = payload.get("hashes") or []
    if isinstance(hashes, str):
        hashes = [hashes]
    hashes = [str(h) for h in hashes if h]
    payload["hashes"] = hashes
    payload["job_context"] = {
        "source": "api",
        "action": action_name,
        "bulk": len(hashes) > 1,
        "hash_count": len(hashes),
        "requested_at": utcnow(),
    }
    if hashes:
        try:
            by_hash = {str(t.get("hash")): t for t in torrent_cache.snapshot(profile["id"])}
            payload["job_context"]["items"] = [
                {
                    "hash": h,
                    "name": str((by_hash.get(h) or {}).get("name") or ""),
                    "path": str((by_hash.get(h) or {}).get("path") or ""),
                }
                for h in hashes
            ]
        except Exception as exc:
            payload["job_context"]["items_error"] = str(exc)
    if action_name == "move":
        payload["job_context"]["target_path"] = str(payload.get("path") or "")
        payload["job_context"]["move_data"] = bool(payload.get("move_data"))
    if action_name == "remove":
        payload["job_context"]["remove_data"] = bool(payload.get("remove_data"))
    return payload


@bp.get("/profiles")
def profiles_list():
    return ok({"profiles": preferences.list_profiles(), "active": preferences.active_profile()})


@bp.post("/profiles")
def profiles_create():
    try:
        return ok({"profile": preferences.save_profile(request.json or {})})
    except Exception as exc:
        return jsonify({"ok": False, "error": str(exc)}), 400


@bp.put("/profiles/<int:profile_id>")
def profiles_update(profile_id: int):
    try:
        return ok({"profile": preferences.update_profile(profile_id, request.json or {})})
    except Exception as exc:
        return jsonify({"ok": False, "error": str(exc)}), 400


@bp.delete("/profiles/<int:profile_id>")
def profiles_delete(profile_id: int):
    preferences.delete_profile(profile_id)
    return ok({"profiles": preferences.list_profiles(), "active": preferences.active_profile()})


@bp.post("/profiles/<int:profile_id>/activate")
def profiles_activate(profile_id: int):
    try:
        return ok({"profile": preferences.activate_profile(profile_id)})
    except Exception as exc:
        return jsonify({"ok": False, "error": str(exc)}), 404


@bp.get("/preferences")
def prefs_get():
    return ok({"preferences": preferences.get_preferences()})


@bp.post("/preferences")
def prefs_save():
    return ok({"preferences": preferences.save_preferences(request.json or {})})


@bp.get("/torrents")
def torrents():
    profile = preferences.active_profile()
    if not profile:
        return ok({"torrents": [], "summary": cached_summary(0, []), "error": "No rTorrent profile"})
    rows = torrent_cache.snapshot(profile["id"])
    return ok({
        "profile_id": profile["id"],
        "torrents": rows,
        "summary": cached_summary(profile["id"], rows),
        "error": torrent_cache.error(profile["id"]),
    })


@bp.get("/torrents/<torrent_hash>/files")
def torrent_files(torrent_hash: str):
    profile = preferences.active_profile()
    if not profile:
        return jsonify({"ok": False, "error": "No profile"}), 400
    return ok({"files": rtorrent.torrent_files(profile, torrent_hash)})


@bp.post("/torrents/<torrent_hash>/files/priority")
def torrent_file_priority(torrent_hash: str):
    profile = preferences.active_profile()
    if not profile:
        return jsonify({"ok": False, "error": "No profile"}), 400
    data = request.get_json(silent=True) or {}
    files = data.get("files") or []
    if not isinstance(files, list) or not files:
        return jsonify({"ok": False, "error": "No files selected"}), 400
    result = rtorrent.set_file_priorities(profile, torrent_hash, files)
    status = 207 if result.get("errors") else 200
    return ok(result), status


@bp.get("/torrents/<torrent_hash>/peers")
def torrent_peers(torrent_hash: str):
    profile = preferences.active_profile()
    if not profile:
        return jsonify({"ok": False, "error": "No profile"}), 400
    peers = rtorrent.torrent_peers(profile, torrent_hash)
    for peer in peers:
        peer.update(lookup_ip(peer.get("ip", "")))
    return ok({"peers": peers})


@bp.post("/torrents/<torrent_hash>/peers/action")
def torrent_peer_action(torrent_hash: str):
    profile = preferences.active_profile()
    if not profile:
        return jsonify({"ok": False, "error": "No profile"}), 400
    data = request.get_json(silent=True) or {}
    try:
        result = rtorrent.peer_action(profile, torrent_hash, int(data.get("peer_index")), str(data.get("action") or ""))
        return ok({"result": result, "message": f"Peer {result['action']} via {result['method']}"})
    except Exception as exc:
        return jsonify({"ok": False, "error": str(exc)}), 400


@bp.get("/torrents/<torrent_hash>/trackers")
def torrent_trackers(torrent_hash: str):
    profile = preferences.active_profile()
    if not profile:
        return jsonify({"ok": False, "error": "No profile"}), 400
    return ok({"trackers": rtorrent.torrent_trackers(profile, torrent_hash)})


@bp.post("/torrents/<torrent_hash>/trackers/<action_name>")
def torrent_tracker_action(torrent_hash: str, action_name: str):
    profile = preferences.active_profile()
    if not profile:
        return jsonify({"ok": False, "error": "No profile"}), 400
    try:
        result = rtorrent.tracker_action(profile, torrent_hash, action_name, request.get_json(silent=True) or {})
        return ok({"result": result, "message": f"Tracker {action_name} via {result.get('method', 'XMLRPC')}"})
    except Exception as exc:
        return jsonify({"ok": False, "error": str(exc)}), 400


@bp.post("/torrents/<action_name>")
def torrent_action(action_name: str):
    profile = preferences.active_profile()
    if not profile:
        return jsonify({"ok": False, "error": "No profile"}), 400
    data = request.get_json(silent=True) or {}
    allowed = {"start", "pause", "stop", "resume", "recheck", "reannounce", "remove", "move", "set_label", "set_ratio_group"}
    if action_name not in allowed:
        return jsonify({"ok": False, "error": "Unknown action"}), 400
    payload = enrich_bulk_payload(profile, action_name, data)
    job_id = enqueue(action_name, profile["id"], payload)
    return ok({"job_id": job_id, "hash_count": len(payload.get("hashes") or []), "bulk": len(payload.get("hashes") or []) > 1})


@bp.post("/torrents/add")
def torrent_add():
    profile = preferences.active_profile()
    if not profile:
        return jsonify({"ok": False, "error": "No profile"}), 400
    job_ids = []
    if request.content_type and request.content_type.startswith("multipart/form-data"):
        start = request.form.get("start", "1") in {"1", "true", "on", "yes"}
        directory = request.form.get("directory", "") or active_default_download_path(profile)
        label = request.form.get("label", "")
        uris = [x.strip() for x in request.form.get("uris", "").splitlines() if x.strip()]
        for uri in uris:
            job_ids.append(enqueue("add_magnet", profile["id"], {"uri": uri, "start": start, "directory": directory, "label": label}))
        for uploaded in request.files.getlist("files"):
            data_b64 = base64.b64encode(uploaded.read()).decode("ascii")
            job_ids.append(enqueue("add_torrent_raw", profile["id"], {"filename": uploaded.filename, "data_b64": data_b64, "start": start, "directory": directory, "label": label}))
        return ok({"job_ids": job_ids})
    data = request.get_json(silent=True) or {}
    uris = data.get("uris") or []
    if isinstance(uris, str):
        uris = [x.strip() for x in uris.splitlines() if x.strip()]
    for uri in uris:
        job_ids.append(enqueue("add_magnet", profile["id"], {"uri": uri, "start": data.get("start", True), "directory": data.get("directory", "") or active_default_download_path(profile), "label": data.get("label", "")}))
    return ok({"job_ids": job_ids})


@bp.post("/speed/limits")
def speed_limits():
    profile = preferences.active_profile()
    if not profile:
        return jsonify({"ok": False, "error": "No profile"}), 400
    data = request.get_json(silent=True) or {}
    job_id = enqueue("set_limits", profile["id"], {"down": data.get("down"), "up": data.get("up")})
    return ok({"job_id": job_id})


@bp.get("/system/status")
def system_status():
    profile = preferences.active_profile()
    if not profile:
        return jsonify({"ok": False, "error": "No profile"})
    try:
        status = rtorrent.system_status(profile)
        if bool(profile.get("is_remote")):
            status["usage_source"] = "remote-hidden"
            status["usage_available"] = False
        else:
            status["cpu"] = psutil.cpu_percent(interval=None)
            status["ram"] = psutil.virtual_memory().percent
            status["usage_source"] = "local"
            status["usage_available"] = True
        return ok({"status": status})
    except Exception as exc:
        return jsonify({"ok": False, "error": str(exc)})


@bp.get("/app/status")
def app_status():
    started = time.perf_counter()
    profile = preferences.active_profile()
    proc = psutil.Process(os.getpid())
    try:
        jobs = list_jobs(10, 0)
        jobs_total = jobs.get("total", 0)
    except Exception:
        jobs_total = 0
    status = {
        "pytorrent": {
            "ok": True,
            "pid": os.getpid(),
            "uptime_seconds": round(time.time() - proc.create_time(), 1),
            "memory_rss": proc.memory_info().rss,
            "memory_rss_h": rtorrent.human_size(proc.memory_info().rss),
            "threads": proc.num_threads(),
            "cpu_percent": proc.cpu_percent(interval=None),
            "jobs_total": jobs_total,
            "python": platform.python_version(),
            "platform": platform.platform(),
            "executable": sys.executable,
            "worker_threads": WORKERS,
            "open_files": _safe_len(proc.open_files) if hasattr(proc, "open_files") else None,
            "connections": _safe_len(lambda: proc.net_connections(kind="inet")) if hasattr(proc, "net_connections") else None,
        },
        "cleanup": cleanup_summary(),
        "profile": profile,
        "scgi": None,
    }
    if profile:
        try:
            status["scgi"] = rtorrent.scgi_diagnostics(profile)
        except Exception as exc:
            status["scgi"] = {"ok": False, "error": str(exc), "url": profile.get("scgi_url")}
    try:
        prefs = preferences.get_preferences()
        status["port_check"] = {"status": "disabled", "enabled": False} if not bool((prefs or {}).get("port_check_enabled")) else port_check_status(force=False)
    except Exception as exc:
        status["port_check"] = {"status": "error", "error": str(exc)}
    status["api_ms"] = round((time.perf_counter() - started) * 1000, 2)
    return ok({"status": status})


@bp.get("/port-check")
def port_check_get():
    prefs = preferences.get_preferences()
    if not bool((prefs or {}).get("port_check_enabled")):
        return ok({"port_check": {"status": "disabled", "enabled": False}})
    return ok({"port_check": port_check_status(force=False)})


@bp.post("/port-check")
def port_check_post():
    return ok({"port_check": port_check_status(force=True)})


@bp.get("/jobs")
def jobs_list():
    limit = int(request.args.get("limit", 50))
    offset = int(request.args.get("offset", 0))
    data = list_jobs(limit, offset)
    return ok({"jobs": data["rows"], "total": data["total"], "limit": data["limit"], "offset": data["offset"]})


@bp.post("/jobs/clear")
def jobs_clear():
    deleted = clear_jobs()
    return ok({"deleted": deleted})


@bp.get("/cleanup/summary")
def cleanup_status():
    return ok({"cleanup": cleanup_summary()})


@bp.post("/cleanup/jobs")
def cleanup_jobs():
    deleted = clear_jobs()
    return ok({"deleted": deleted, "cleanup": cleanup_summary()})


@bp.post("/cleanup/smart-queue")
def cleanup_smart_queue():
    with connect() as conn:
        exists = conn.execute("SELECT name FROM sqlite_master WHERE type='table' AND name='smart_queue_history'").fetchone()
        if not exists:
            deleted = 0
        else:
            cur = conn.execute("DELETE FROM smart_queue_history")
            deleted = int(cur.rowcount or 0)
    return ok({"deleted": deleted, "cleanup": cleanup_summary()})


@bp.post("/cleanup/all")
def cleanup_all():
    deleted_jobs = clear_jobs()
    with connect() as conn:
        exists = conn.execute("SELECT name FROM sqlite_master WHERE type='table' AND name='smart_queue_history'").fetchone()
        if not exists:
            deleted_smart = 0
        else:
            cur = conn.execute("DELETE FROM smart_queue_history")
            deleted_smart = int(cur.rowcount or 0)
    return ok({"deleted": {"jobs": deleted_jobs, "smart_queue_history": deleted_smart}, "cleanup": cleanup_summary()})


@bp.post("/jobs/<job_id>/cancel")
def jobs_cancel(job_id: str):
    if not cancel_job(job_id):
        return jsonify({"ok": False, "error": "Only pending or failed jobs can be cancelled"}), 400
    return ok()


@bp.post("/jobs/<job_id>/retry")
def jobs_retry(job_id: str):
    if not retry_job(job_id):
        return jsonify({"ok": False, "error": "Only failed or cancelled jobs can be retried"}), 400
    return ok()


@bp.get("/path/default")
def path_default():
    profile = preferences.active_profile()
    if not profile:
        return jsonify({"ok": False, "error": "No profile"}), 400
    try:
        return ok({"path": rtorrent.default_download_path(profile)})
    except Exception as exc:
        return jsonify({"ok": False, "error": str(exc)}), 400


@bp.get("/path/browse")
def path_browse():
    profile = preferences.active_profile()
    if not profile:
        return jsonify({"ok": False, "error": "No profile"}), 400
    base = request.args.get("path") or ""
    try:
        return ok(rtorrent.browse_path(profile, base))
    except Exception as exc:
        return jsonify({"ok": False, "error": str(exc)}), 400


@bp.get("/labels")
def labels_list():
    profile = preferences.active_profile()
    pid = profile["id"] if profile else None
    with connect() as conn:
        rows = conn.execute("SELECT * FROM labels WHERE user_id=? AND (profile_id=? OR profile_id IS NULL) ORDER BY name COLLATE NOCASE", (default_user_id(), pid)).fetchall()
    return ok({"labels": rows})


@bp.post("/labels")
def labels_save():
    profile = preferences.active_profile()
    if not profile:
        return jsonify({"ok": False, "error": "No profile"}), 400
    data = request.get_json(silent=True) or {}
    name = str(data.get("name") or "").strip()
    if not name:
        return jsonify({"ok": False, "error": "Missing label name"}), 400
    now = utcnow()
    with connect() as conn:
        conn.execute("INSERT OR IGNORE INTO labels(user_id,profile_id,name,color,created_at,updated_at) VALUES(?,?,?,?,?,?)", (default_user_id(), profile["id"], name, data.get("color") or "#64748b", now, now))
    return labels_list()


@bp.delete("/labels/<int:label_id>")
def labels_delete(label_id: int):
    profile = preferences.active_profile()
    pid = profile["id"] if profile else None
    with connect() as conn:
        conn.execute("DELETE FROM labels WHERE id=? AND user_id=? AND (profile_id=? OR profile_id IS NULL)", (label_id, default_user_id(), pid))
    return labels_list()


@bp.get("/ratio-groups")
def ratio_groups_list():
    profile = preferences.active_profile()
    pid = profile["id"] if profile else None
    with connect() as conn:
        rows = conn.execute("SELECT * FROM ratio_groups WHERE user_id=? AND (profile_id=? OR profile_id IS NULL) ORDER BY name COLLATE NOCASE", (default_user_id(), pid)).fetchall()
    return ok({"groups": rows})


@bp.post("/ratio-groups")
def ratio_groups_save():
    profile = preferences.active_profile()
    if not profile:
        return jsonify({"ok": False, "error": "No profile"}), 400
    data = request.get_json(silent=True) or {}
    name = str(data.get("name") or "").strip()
    if not name:
        return jsonify({"ok": False, "error": "Missing group name"}), 400
    now = utcnow()
    with connect() as conn:
        conn.execute("INSERT OR REPLACE INTO ratio_groups(user_id,profile_id,name,min_ratio,max_ratio,seed_time_minutes,action,enabled,created_at,updated_at) VALUES(?,?,?,?,?,?,?,?,?,?)", (default_user_id(), profile["id"], name, float(data.get("min_ratio") or 1), float(data.get("max_ratio") or 2), int(data.get("seed_time_minutes") or 0), data.get("action") or "stop", 1 if data.get("enabled", True) else 0, now, now))
    return ratio_groups_list()


@bp.get("/rss")
def rss_list():
    profile = preferences.active_profile()
    pid = profile["id"] if profile else None
    with connect() as conn:
        feeds = conn.execute("SELECT * FROM rss_feeds WHERE user_id=? AND (profile_id=? OR profile_id IS NULL) ORDER BY name", (default_user_id(), pid)).fetchall()
        rules = conn.execute("SELECT * FROM rss_rules WHERE user_id=? AND (profile_id=? OR profile_id IS NULL) ORDER BY name", (default_user_id(), pid)).fetchall()
    return ok({"feeds": feeds, "rules": rules})


@bp.post("/rss/feeds")
def rss_feed_save():
    profile = preferences.active_profile()
    data = request.get_json(silent=True) or {}
    now = utcnow()
    with connect() as conn:
        conn.execute("INSERT INTO rss_feeds(user_id,profile_id,name,url,enabled,created_at,updated_at) VALUES(?,?,?,?,?,?,?)", (default_user_id(), profile["id"] if profile else None, data.get("name") or "RSS", data.get("url") or "", 1, now, now))
    return rss_list()


@bp.post("/rss/rules")
def rss_rule_save():
    profile = preferences.active_profile()
    data = request.get_json(silent=True) or {}
    now = utcnow()
    with connect() as conn:
        conn.execute("INSERT INTO rss_rules(user_id,profile_id,name,pattern,save_path,label,start,enabled,created_at,updated_at) VALUES(?,?,?,?,?,?,?,?,?,?)", (default_user_id(), profile["id"] if profile else None, data.get("name") or "Rule", data.get("pattern") or ".*", data.get("save_path") or active_default_download_path(profile), data.get("label") or "", 1 if data.get("start", True) else 0, 1, now, now))
    return rss_list()


@bp.post("/rss/check")
def rss_check():
    profile = preferences.active_profile()
    if not profile:
        return jsonify({"ok": False, "error": "No profile"}), 400
    queued = 0
    with connect() as conn:
        feeds = conn.execute("SELECT * FROM rss_feeds WHERE user_id=? AND profile_id=? AND enabled=1", (default_user_id(), profile["id"])).fetchall()
        rules = conn.execute("SELECT * FROM rss_rules WHERE user_id=? AND profile_id=? AND enabled=1", (default_user_id(), profile["id"])).fetchall()
    for feed in feeds:
        try:
            raw = urllib.request.urlopen(feed["url"], timeout=10).read(2_000_000)
            root = ET.fromstring(raw)
            for item in root.findall('.//item')[:100]:
                title = item.findtext('title') or ''
                link = item.findtext('link') or ''
                enc = item.find('enclosure')
                if enc is not None and enc.get('url'):
                    link = enc.get('url') or link
                for rule in rules:
                    if re.search(rule["pattern"], title, re.I) and link:
                        enqueue("add_magnet", profile["id"], {"uri": link, "start": bool(rule["start"]), "directory": rule.get("save_path") or active_default_download_path(profile), "label": rule.get("label") or ""})
                        queued += 1
        except Exception as exc:
            with connect() as conn:
                conn.execute("UPDATE rss_feeds SET last_error=?, last_checked_at=?, updated_at=? WHERE id=?", (str(exc), utcnow(), utcnow(), feed["id"]))
    return ok({"queued": queued})


@bp.get('/rtorrent-config')
def rtorrent_config_get():
    profile = preferences.active_profile()
    if not profile:
        return jsonify({'ok': False, 'error': 'No profile'}), 400
    try:
        return ok({'config': rtorrent.get_config(profile)})
    except Exception as exc:
        return jsonify({'ok': False, 'error': str(exc)}), 500

@bp.post('/rtorrent-config')
def rtorrent_config_save():
    profile = preferences.active_profile()
    if not profile:
        return jsonify({'ok': False, 'error': 'No profile'}), 400
    try:
        data = request.get_json(silent=True) or {}
        result = rtorrent.set_config(profile, data.get('values') or {}, bool(data.get('apply_now', True)), bool(data.get('apply_on_start')), data.get('clear_keys') or [])
        if not result.get('ok'):
            return jsonify({'ok': False, 'error': 'Some settings were not saved', 'result': result}), 400
        return ok({'result': result})
    except Exception as exc:
        return jsonify({'ok': False, 'error': str(exc)}), 500


@bp.post('/rtorrent-config/generate')
def rtorrent_config_generate():
    profile = preferences.active_profile()
    if not profile:
        return jsonify({'ok': False, 'error': 'No profile'}), 400
    try:
        data = request.get_json(silent=True) or {}
        return ok({'config_text': rtorrent.generate_config_text(data.get('values') or {})})
    except Exception as exc:
        return jsonify({'ok': False, 'error': str(exc)}), 500

@bp.get('/smart-queue')
def smart_queue_get():
    from ..services import smart_queue
    profile = preferences.active_profile()
    if not profile:
        return ok({'settings': {}, 'exclusions': [], 'error': 'No profile'})
    try:
        history_limit = max(1, min(int(request.args.get('history_limit', 10) or 10), 100))
        settings = smart_queue.get_settings(profile['id'])
        exclusions = smart_queue.list_exclusions(profile['id'])
        history = smart_queue.list_history(profile['id'], limit=history_limit)
        history_total = smart_queue.count_history(profile['id'])
        return ok({'settings': settings, 'exclusions': exclusions, 'history': history, 'history_total': history_total})
    except Exception as exc:
        return jsonify({'ok': False, 'error': str(exc), 'settings': {}, 'exclusions': []})


@bp.post('/smart-queue')
def smart_queue_save():
    from ..services import smart_queue
    profile = preferences.active_profile()
    if not profile:
        return ok({'settings': {}, 'error': 'No profile'})
    try:
        payload = request.get_json(silent=True) or {}
        return ok({'settings': smart_queue.save_settings(profile['id'], payload)})
    except Exception as exc:
        return jsonify({'ok': False, 'error': str(exc)})


@bp.post('/smart-queue/check')
def smart_queue_check():
    from ..services import smart_queue
    profile = preferences.active_profile()
    if not profile:
        return ok({'result': {'ok': False, 'error': 'No profile'}})
    try:
        return ok({'result': smart_queue.check(profile, force=True)})
    except Exception as exc:
        return jsonify({'ok': False, 'error': str(exc)}), 500


@bp.post('/smart-queue/exclusion')
def smart_queue_exclusion():
    from ..services import smart_queue
    profile = preferences.active_profile()
    if not profile:
        return jsonify({'ok': False, 'error': 'No profile'}), 400
    data = request.get_json(silent=True) or {}
    torrent_hash = str(data.get('hash') or '').strip()
    if not torrent_hash:
        return jsonify({'ok': False, 'error': 'Missing torrent hash'}), 400
    smart_queue.set_exclusion(profile['id'], torrent_hash, bool(data.get('excluded', True)), str(data.get('reason') or 'manual'))
    return ok({'exclusions': smart_queue.list_exclusions(profile['id'])})

@bp.get('/traffic/history')
def traffic_history_get():
    from ..services import traffic_history
    profile = preferences.active_profile()
    if not profile:
        return ok({'history': {'range': request.args.get('range') or '7d', 'bucket': 'day', 'rows': []}})
    range_name = request.args.get('range') or '7d'
    if range_name not in {'15m', '1h', '3h', '6h', '24h', '7d', '30d', '90d'}:
        range_name = '7d'
    try:
        try:
            from ..services import rtorrent
            status = rtorrent.system_status(profile)
            traffic_history.record(profile['id'], status.get('down_rate', 0), status.get('up_rate', 0), status.get('total_down', 0), status.get('total_up', 0), force=True)
        except Exception:
            pass
        return ok({'history': traffic_history.history(profile['id'], range_name)})
    except Exception as exc:
        return jsonify({'ok': False, 'error': str(exc), 'history': {'range': range_name, 'rows': []}})

@bp.get('/automations')
def automations_get():
    from ..services import automation_rules
    profile = preferences.active_profile()
    if not profile:
        return ok({'rules': [], 'history': [], 'error': 'No profile'})
    try:
        return ok({'rules': automation_rules.list_rules(profile['id']), 'history': automation_rules.list_history(profile['id'])})
    except Exception as exc:
        return jsonify({'ok': False, 'error': str(exc), 'rules': [], 'history': []}), 500


@bp.post('/automations')
def automations_save():
    from ..services import automation_rules
    profile = preferences.active_profile()
    if not profile:
        return jsonify({'ok': False, 'error': 'No profile'}), 400
    try:
        rule = automation_rules.save_rule(profile['id'], request.get_json(silent=True) or {})
        return ok({'rule': rule, 'rules': automation_rules.list_rules(profile['id'])})
    except Exception as exc:
        return jsonify({'ok': False, 'error': str(exc)}), 400


@bp.delete('/automations/<int:rule_id>')
def automations_delete(rule_id: int):
    from ..services import automation_rules
    profile = preferences.active_profile()
    if not profile:
        return jsonify({'ok': False, 'error': 'No profile'}), 400
    try:
        automation_rules.delete_rule(rule_id, profile['id'])
        return ok({'rules': automation_rules.list_rules(profile['id'])})
    except Exception as exc:
        return jsonify({'ok': False, 'error': str(exc)}), 400


@bp.post('/automations/check')
def automations_check():
    from ..services import automation_rules
    profile = preferences.active_profile()
    if not profile:
        return jsonify({'ok': False, 'error': 'No profile'}), 400
    try:
        return ok({'result': automation_rules.check(profile, force=True), 'history': automation_rules.list_history(profile['id'])})
    except Exception as exc:
        return jsonify({'ok': False, 'error': str(exc)}), 500