#!/usr/bin/env fades
"""Search Prowlarr, pick 1080p results and send them to Deluge.

Commands:

    single  Search one phrase, pick from the results, send magnets.
    season  Search a whole season episode by episode: given a phrase
        and a season ``N``, searches ``<phrase> s0Ne01``, ``s0Ne02``,
        ... until a search comes back empty, then presents everything
        with an extra column showing the episode each result came
        from, episodes first and peers within each episode.

Both commands show a table, ask for a selection like ``1,3,5-7`` and
load the chosen magnets and torrent files in Deluge (daemon RPC over
the SSH tunnel).

Examples:
    ./torrusq.py single "debian netinst"
    ./torrusq.py single "una peli" --limit 100
    ./torrusq.py season "los simuladores" 2

"""

import argparse
import base64
import html
import json
import os
import sys
import urllib.error
import urllib.parse
import urllib.request

import infoauth  # fades
from deluge_client import DelugeRPCClient  # fades
from prettyTables import Table  # fades

PROWLARR_URL = "http://blackfx:9696"
HD_MARKER = "1080"
# safety cap for `season`: stop searching after this many episodes
MAX_EPISODES = 100

TOP_CATEGORY_NAMES = {
    1000: "Console",
    2000: "Movies",
    3000: "Audio",
    4000: "PC",
    5000: "TV",
    6000: "XXX",
    7000: "Other",
}


# prowlarr api key: from kubernetes config
# deluge: config/deluge/hostlist.conf
credentials = infoauth.load(os.path.expanduser("~/.torrusq.auth"))


class _NoRedirect(urllib.request.HTTPRedirectHandler):
    """Redirect handler that never follows redirects."""

    def redirect_request(self, req, fp, code, msg, headers, newurl):
        """Block the redirect by returning no new request."""
        return None


class ProwlarrError(Exception):
    """Error while talking to the Prowlarr API."""


class ProwlarrClient:
    """Minimal client for the Prowlarr v1 API."""

    def __init__(self, api_key, timeout=30):
        self.base_url = PROWLARR_URL.rstrip("/")
        self.api_key = api_key
        self.timeout = timeout

    def _request(self, path, params=None):
        """Perform an authenticated GET and return the parsed JSON.

        :param path: path relative to ``/api/v1``.
        :param params: query args (or ``None``).
        :raises ProwlarrError: on network, HTTP or JSON errors.
        """
        url = self.base_url + "/api/v1" + path
        if params:
            url += "?" + urllib.parse.urlencode(params)
        request = urllib.request.Request(
            url, headers={"X-Api-Key": self.api_key})
        try:
            with urllib.request.urlopen(
                    request, timeout=self.timeout) as resp:
                raw = resp.read()
        except urllib.error.HTTPError as err:
            detail = err.read().decode("utf-8", "replace")[:200]
            raise ProwlarrError(
                f"GET {path}: HTTP {err.code}: {detail}") from err
        except urllib.error.URLError as err:
            raise ProwlarrError(
                f"no pude conectar a {url}: {err.reason}") from err
        try:
            return json.loads(raw)
        except ValueError as err:
            raise ProwlarrError(f"respuesta no-JSON de {path}") from err

    def search(self, query, limit=None):
        """Search for releases on the enabled indexers.

        :param query: text to search for.
        :param limit: maximum number of results; ``None`` uses the
            server default.
        :return: list of found releases.
        """
        params = {"query": query}
        if limit is not None:
            params["limit"] = limit
        return self._request("/search", params)

    def resolve_magnet(self, url):
        """Return the real magnet URI behind a Prowlarr URL.

        Some indexers expose the magnet only through Prowlarr, which
        answers with a redirect to the actual ``magnet:`` URI. The
        redirect is intercepted instead of followed, because urllib
        cannot handle ``magnet:`` URLs.

        :param url: the release ``magnetUrl``.
        :return: the real ``magnet:`` URI.
        :raises ProwlarrError: on network errors, or if the response
            is not a redirect to a magnet.
        """
        url_opener = urllib.request.build_opener(_NoRedirect())
        request = urllib.request.Request(url, headers={"X-Api-Key": self.api_key})
        try:
            with url_opener.open(request, timeout=self.timeout) as resp:
                resp.read()
        except urllib.error.HTTPError as err:
            location = err.headers.get("Location", "")
            if location.startswith("magnet:"):
                return html.unescape(location)
            raise ProwlarrError(f"no devolvió un magnet: HTTP {err.code}") from err
        except urllib.error.URLError as err:
            raise ProwlarrError(f"no pude conectar a {url}: {err.reason}") from err
        raise ProwlarrError("no devolvió un magnet: sin redirect")

    def download_torrent(self, url):
        """Download the torrent file behind a Prowlarr URL.

        Unlike :meth:`resolve_magnet`, redirects are followed here:
        the endpoint answers with the bencoded torrent content, not
        with a ``magnet:`` redirect.

        :param url: the release ``downloadUrl``.
        :return: the raw torrent bytes.
        :raises ProwlarrError: on network errors, or if the response
            does not look like a torrent file.
        """
        request = urllib.request.Request(url, headers={"X-Api-Key": self.api_key})
        try:
            with urllib.request.urlopen(request, timeout=self.timeout) as resp:
                content = resp.read()
        except urllib.error.HTTPError as err:
            detail = err.read().decode("utf-8", "replace")[:200]
            raise ProwlarrError(f"GET {url}: HTTP {err.code}: {detail}") from err
        except urllib.error.URLError as err:
            raise ProwlarrError(f"no pude conectar a {url}: {err.reason}") from err
        if not content or content.lstrip()[:1] == b"<":
            raise ProwlarrError("la respuesta no es un torrent (¿HTML de error?)")
        return content


def _fmt_size(num_bytes):
    """Format a number of bytes in human readable form (base 1024)."""
    if not num_bytes:
        return "?"

    num_gigas = int(num_bytes) / 1024 ** 3
    return f"{num_gigas:.2f} GiB"


def _fmt_count(value):
    """Format a peers count, or a dash if it is unknown."""
    return "-" if value is None else str(value)


def _category_names(release):
    """Return the release category names, joined with a plus sign.

    Prowlarr sends the categories of a release as dicts with id and
    name, but older versions may send plain ids, which are resolved
    against the well-known top level categories.
    """
    names = set()
    for category in release.get("categories") or []:
        if isinstance(category, dict):
            name = category.get("name")
            if name:
                names.add(name)
        else:
            name = TOP_CATEGORY_NAMES.get(category, str(category))
            names.add(name)
    return " ".join(sorted(names)) or "-"


def _peers_key(release):
    """Return the peers sort key: seeders first, then leechers."""
    return (release.get("seeders", 0), release.get("leechers", 0))


def print_menu(releases, episodes=None):
    """Show the table of candidate releases.

    :param releases: releases already filtered and sorted.
    :param episodes: optional episode labels, parallel to releases.
    """
    headers = ["#", "Tamaño", "S/L", "Categoría", "Título"]
    if episodes is not None:
        headers.insert(4, "Ep.")
    table = Table(headers=headers)
    table.col_alignment = {
        "#": "r",
        "Tamaño": "r",
        "S/L": "r",
        "Categoría": "l",
        "Título": "l",
    }
    if episodes is not None:
        table.col_alignment["Ep."] = "l"
    for number, release in enumerate(releases, start=1):
        print("=========== r", release)
        seeders = release.get("seeders", "-")
        leechers = release.get("leechers", "-")
        row = [
            number,
            _fmt_size(release.get("size")),
            f"{seeders}/{leechers}",
            _category_names(release),
        ]
        if episodes is not None:
            row.append(episodes[number - 1])
        row.append(release.get("title", "?"))
        table.add_row(row)
    print(table.compose())


def parse_selection(spec, max_index):
    """Parse a menu selection like ``1,3,5-7``.

    Accepts numbers and inclusive ranges separated by commas, with
    optional whitespace.

    :param spec: the string typed by the user.
    :param max_index: highest valid menu number.
    :return: 1-based indices, sorted and de-duplicated.
    :raises ValueError: on invalid or out-of-range tokens.
    """
    chosen = set()
    for token in spec.split(","):
        token = token.strip()
        if not token:
            continue
        if "-" in token:
            start_s, _, end_s = token.partition("-")
            try:
                start, end = int(start_s), int(end_s)
            except ValueError:
                raise ValueError(f"rango inválido: {token!r}") from None
            numbers = range(start, end + 1)
        else:
            try:
                numbers = [int(token)]
            except ValueError:
                raise ValueError(f"número inválido: {token!r}") from None
        for number in numbers:
            if not 1 <= number <= max_index:
                raise ValueError(
                    f"{number} fuera de rango (1-{max_index})")
            chosen.add(number)
    if not chosen:
        raise ValueError("selección vacía")
    return sorted(chosen)


def episode_label(season, episode):
    """Build the ``s0NeMM`` label for a season and episode."""
    return f"s{season:02d}e{episode:02d}"


def episode_query(query, season, episode):
    """Build the search phrase for one episode of a season."""
    return f"{query} {episode_label(season, episode)}"


def choose_and_send(prowlarr, releases, episodes=None):
    """Show the menu, ask a selection and load the magnets in Deluge.

    :param prowlarr: the :class:`ProwlarrClient` to resolve magnets.
    :param releases: candidate releases, already filtered and sorted.
    :param episodes: optional episode labels, parallel to releases.
    :return: exit code for :func:`sys.exit`.
    """
    print_menu(releases, episodes)
    spec = input(
        "números a descargar (ej. 1,3,5-7, 'q' para salir): ").strip()
    if not spec or spec.lower() in ("q", "quit", "salir"):
        print("no mando nada")
        return 0
    try:
        indices = parse_selection(spec, len(releases))
    except ValueError as err:
        print(f"error: {err}", file=sys.stderr)
        return 2

    items = []
    for index in indices:
        release = releases[index - 1]
        title = release.get("title", "?")
        raw_url = release.get("magnetUrl") or ""

        # if the raw url is a magnet one, it's simeple
        if raw_url.startswith("magnet:"):
            items.append(("magnet", html.unescape(raw_url)))
            continue

        # if not, it should resolve to a magnet one (fail if not)
        if raw_url:
            try:
                items.append(("magnet", prowlarr.resolve_magnet(raw_url)))
            except ProwlarrError as err:
                print(f"error con el magnet de '{title}': {err}", file=sys.stderr)
            continue

        # if no magnet, let's try with the download url
        download_url = release.get("downloadUrl")
        if not download_url:
            print(f"Sin magnet ni torrent, lo salteo: {title}", file=sys.stderr)
            continue
        file_name = release.get("fileName") or f"{title}.torrent"

        # it may still resolve to a magnet one, use it if it does!
        try:
            magnet_url = prowlarr.resolve_magnet(download_url)
        except ProwlarrError:
            pass
        else:
            items.append(("magnet", magnet_url))
            continue

        # else try to get the torrent from there
        try:
            content = prowlarr.download_torrent(download_url)
        except ProwlarrError as err:
            print(f"error con el torrent de '{title}': {err}", file=sys.stderr)
            continue
        items.append(("torrent", (file_name, content)))

    print("===== M", [
        (kind, payload if kind == "magnet"
         else (payload[0], len(payload[1])))
        for kind, payload in items
    ])
    if not items:
        print("No hay nada para mandar a Deluge")
        return 1

    deluge = DelugeRPCClient(
        "127.0.0.1",
        58846,
        credentials["deluge_user"],
        credentials["deluge_password"],
    )
    deluge.connect()   # levanta excepción si la auth falla
    print(f"Mandando {len(items)} torrent(s) a Deluge...")
    for kind, payload in items:
        try:
            if kind == "magnet":
                result = deluge.call(
                    "core.add_torrent_magnet", payload,
                    {"add_paused": False})
            else:
                file_name, content = payload
                result = deluge.call(
                    "core.add_torrent_file",
                    [file_name],
                    [base64.b64encode(content).decode("ascii")],
                    [{"add_paused": False}],
                )
        except Exception as exc:
            print("======== error", exc)
            print("Deluge ERROR:", exc.args[0].split("\n")[0])
        else:
            print("===== result", result)
    return 0


def cmd_single(prowlarr, args):
    """Search one phrase, present the candidates and send the chosen.

    :param prowlarr: the :class:`ProwlarrClient` to search with.
    :param args: parsed CLI arguments.
    :return: exit code for :func:`sys.exit`.
    """
    try:
        releases = prowlarr.search(args.query, limit=args.limit)
    except ProwlarrError as err:
        print(f"error: {err}", file=sys.stderr)
        return 1

    matching = [
        release for release in releases
        if HD_MARKER in release.get("title", "")
    ]
    matching.sort(key=_peers_key, reverse=True)
    print(
        f"{len(releases)} resultado(s), "
        f"{len(matching)} con '{HD_MARKER}' en el título"
    )
    if not matching:
        return 0
    return choose_and_send(prowlarr, matching)


def cmd_season(prowlarr, args):
    """Search a whole season, episode by episode, and send the chosen.

    Searches ``<query> s0Ne01``, ``<query> s0Ne02``, ... until a
    search comes back empty, then presents everything found.

    :param prowlarr: the :class:`ProwlarrClient` to search with.
    :param args: parsed CLI arguments.
    :return: exit code for :func:`sys.exit`.
    """
    found = []
    for episode in range(1, MAX_EPISODES + 1):
        query = episode_query(args.query, args.season, episode)
        try:
            releases = prowlarr.search(query, limit=args.limit)
        except ProwlarrError as err:
            print(f"error: {err}", file=sys.stderr)
            return 1
        if not releases:
            break
        print(f"{query}: {len(releases)} resultado(s)")
        found.extend((release, episode) for release in releases)

    matching = [
        (release, episode)
        for release, episode in found
        if HD_MARKER in release.get("title", "")
    ]
    # episodes go up, peers go down within each episode; the stable
    # sort keeps the peers order when the episodes are sorted.
    matching.sort(key=lambda pair: _peers_key(pair[0]), reverse=True)
    matching.sort(key=lambda pair: pair[1])
    print(
        f"{len(found)} resultado(s) en total, "
        f"{len(matching)} con '{HD_MARKER}' en el título"
    )
    if not matching:
        return 0
    labels = [
        episode_label(args.season, episode) for _, episode in matching
    ]
    return choose_and_send(
        prowlarr, [release for release, _ in matching], labels)


def build_parser():
    """Build the CLI argparse parser."""
    common = argparse.ArgumentParser(add_help=False)
    common.add_argument(
        "--limit", type=int, default=None,
        help="máximo de resultados que le pide a Prowlarr")
    parser = argparse.ArgumentParser(
        description="Busca en Prowlarr, muestra un menú y manda los "
        "magnets elegidos a Deluge; ejemplos en el docstring.")
    sub = parser.add_subparsers(dest="command", required=True)

    single = sub.add_parser(
        "single", parents=[common], help="una búsqueda, elijo y mando")
    single.add_argument("query", help="frase a buscar en Prowlarr")

    season = sub.add_parser(
        "season", parents=[common],
        help="busca episodio por episodio una temporada entera")
    season.add_argument("query", help="frase base, p.ej. la serie")
    season.add_argument(
        "season", type=int, metavar="N", help="número de temporada")

    return parser


def main(argv=None):
    """Run the flow of the chosen command.

    :param argv: arguments; ``None`` uses ``sys.argv[1:]``.
    :return: exit code for :func:`sys.exit`.
    """
    args = build_parser().parse_args(argv)
    prowlarr = ProwlarrClient(credentials["prowlarr_api_key"])
    if args.command == "season":
        return cmd_season(prowlarr, args)
    return cmd_single(prowlarr, args)


if __name__ == "__main__":
    sys.exit(main())
