#!/usr/bin/env python3
r"""CLI to register a new APKMirror app in the repo.

This script automates the manual edits required when ReVanced adds support for a
new app that's available on APKMirror. It updates:
- src/downloader/sources.py: adds the APKMirror source mapping
- src/patches.py: maps package name -> app key
- README.md: appends the bullet link under the officially supported list

Usage examples:
  python scripts/add_apkmirror_app.py \
    --package com.facebook.katana \
    --name facebook \
    --apkmirror-path facebook-2/facebook

  python scripts/add_apkmirror_app.py \
    --package com.facebook.katana \
    --name facebook \
    --apkmirror-url https://www.apkmirror.com/apk/facebook-2/facebook/

Notes
-----
- APKMirror only. For other sources, extend the script accordingly.
- Idempotent: if entries already exist, it will skip updating that file.
"""

from __future__ import annotations

import argparse
import os
import re
from pathlib import Path

import requests

REPO_ROOT = Path(__file__).resolve().parents[1]
ORG_APP_PARTS = 2
APK_MIRROR_APP_EXISTS_URL = "https://www.apkmirror.com/wp-json/apkm/v1/app_exists/"
DEFAULT_USER_AGENT = os.getenv("APKMIRROR_USER_AGENT", "nikhil")
DEFAULT_BASIC_AUTH = os.getenv(
    "APKMIRROR_AUTH_BASIC",
    # base64("api-apkupdater:rm5rcfruUjKy04sMpyMPJXW8") as provided in the example
    "YXBpLWFwa3VwZGF0ZXI6cm01cmNmcnVVakt5MDRzTXB5TVBKWFc4",
)
DEFAULT_HTTP_TIMEOUT_SECS = 20


def parse_args() -> argparse.Namespace:
    """Parse CLI arguments for registering an APKMirror app."""
    parser = argparse.ArgumentParser(description="Register a new APKMirror app")
    parser.add_argument("--package", required=True, help="Android package name, e.g., com.facebook.katana")
    parser.add_argument("--name", required=True, help="Short app key/name used in configs, e.g., facebook")

    apkmirror = parser.add_mutually_exclusive_group(required=False)
    apkmirror.add_argument(
        "--apkmirror-path",
        help="APKMirror path '<org>/<app>' without leading /apk/, e.g., 'facebook-2/facebook'",
    )
    apkmirror.add_argument(
        "--apkmirror-url",
        help="Full APKMirror app URL, e.g., https://www.apkmirror.com/apk/facebook-2/facebook/",
    )

    parser.add_argument(
        "--apkmirror-auth",
        default=DEFAULT_BASIC_AUTH,
        help="Base64 for Basic Authorization header to APKMirror API (env: APKMIRROR_AUTH_BASIC)",
    )
    parser.add_argument(
        "--user-agent",
        default=DEFAULT_USER_AGENT,
        help="User-Agent value for APKMirror API (env: APKMIRROR_USER_AGENT)",
    )

    parser.add_argument(
        "--dry-run",
        action="store_true",
        help="Show planned changes without writing files",
    )

    return parser.parse_args()


def extract_apkmirror_path(url_or_path: str) -> tuple[str, str]:
    """Return (org, app) from a full URL or 'org/app' path.

    Accepted examples:
      - facebook-2/facebook
      - https://www.apkmirror.com/apk/facebook-2/facebook/
      - https://www.apkmirror.com/apk/facebook-2/facebook
    """
    raw = url_or_path.strip()
    if raw.startswith("http"):
        # Keep only the path after '/apk/'
        m = re.search(r"/apk/([^/?#]+)/([^/?#]+)/?", raw)
        if not m:
            msg = "Unable to parse APKMirror URL. Expected .../apk/<org>/<app>/."
            raise ValueError(
                msg,
            )
        org, app = m.group(1), m.group(2)
    else:
        # org/app
        parts = raw.strip("/").split("/")
        if len(parts) != ORG_APP_PARTS:
            msg = "--apkmirror-path must be '<org>/<app>'"
            raise ValueError(msg)
        org, app = parts
    return org, app


def discover_apkmirror_path_via_api(package_name: str, auth_b64: str, user_agent: str) -> tuple[str, str]:
    """Query APKMirror app_exists API to discover the org/app path for a package.

    Tries `app.link` first, then falls back to `release.link`.
    Returns (org, app).
    """
    headers = {
        "Authorization": f"Basic {auth_b64}",
        "User-Agent": user_agent,
        "Content-Type": "application/json",
    }
    payload = {"pnames": [package_name]}
    resp = requests.post(
        APK_MIRROR_APP_EXISTS_URL,
        headers=headers,
        json=payload,
        timeout=DEFAULT_HTTP_TIMEOUT_SECS,
    )
    if resp.status_code != 200:  # noqa: PLR2004
        msg = f"APKMirror app_exists API error: HTTP {resp.status_code}"
        raise RuntimeError(msg)
    data = resp.json()
    items = data.get("data") or []
    if not items:
        msg = f"No data returned from APKMirror for {package_name}"
        raise RuntimeError(msg)

    item = items[0]
    app_link = ((item.get("app") or {}).get("link")) or ((item.get("release") or {}).get("link"))
    if not app_link:
        msg = "APKMirror response missing app/release link"
        raise RuntimeError(msg)

    # Expect a path like: /apk/<org>/<app>/...
    m = re.search(r"/apk/([^/]+)/([^/]+)/", app_link)
    if not m:
        msg = "Unable to parse org/app from APKMirror response link"
        raise RuntimeError(msg)
    return m.group(1), m.group(2)


def read_text(path: Path) -> str:
    """Read text from a file using UTF-8 encoding."""
    return path.read_text(encoding="utf-8")


def write_text(path: Path, content: str) -> None:
    """Write text to a file using UTF-8 encoding."""
    path.write_text(content, encoding="utf-8")


def insert_kv_into_dict(  # noqa: C901, PLR0912,PLR0915
    content: str,
    dict_var_pattern: str,
    key: str,
    value_code: str,
) -> tuple[str, bool]:
    r"""Insert a key/value into a Python dict literal for a variable.

    - dict_var_pattern: regex to match the variable assignment line that opens the dict
      e.g., r"revanced_package_names[\s\S]*?=\s*\{"
    - key: dictionary key to insert (without quotes)
    - value_code: full code for the value expression (already quoted/f-string as needed)

    Returns: (new_content, changed)
    """
    # Find dict opening
    open_match = re.search(dict_var_pattern, content)
    if not open_match:
        msg = "Could not locate dictionary with given pattern"
        raise RuntimeError(msg)

    # Find the '{' start index and walk to matching '}'
    brace_start = content.find("{", open_match.start())
    if brace_start == -1:
        msg = "Malformed dictionary start: missing '{'"
        raise RuntimeError(msg)

    i = brace_start
    depth = 0
    in_str: str | None = None
    esc = False
    while i < len(content):
        ch = content[i]
        if in_str:
            if esc:
                esc = False
            elif ch == "\\":
                esc = True
            elif ch == in_str:
                in_str = None
        elif ch in ('"', "'"):
            in_str = ch
        elif ch == "{":
            depth += 1
        elif ch == "}":
            depth -= 1
            if depth == 0:
                brace_end = i
                break
        i += 1
    else:
        msg = "Malformed dictionary: missing closing '}'"
        raise RuntimeError(msg)

    # The dictionary body
    body = content[brace_start + 1 : brace_end]

    # Check if key already exists
    key_re = re.compile(rf"^[ \t]*\"{re.escape(key)}\"\s*:\s*", re.MULTILINE)
    if key_re.search(body):
        return content, False

    # Determine indentation: look for first item, else fallback to 4 spaces more than dict line indent
    # Get indentation of first item (if any)
    item_match = re.search(r"^(?P<indent>[ \t]+)\"[^\n]+\"\s*:\s*", body, re.MULTILINE)
    if item_match:
        indent = item_match.group("indent")
    else:
        # Compute dictionary base indent from line start to '{'
        line_start = content.rfind("\n", 0, brace_start) + 1
        base_indent = content[line_start:brace_start].split("\n")[-1]
        # Count leading spaces/tabs of the line
        m_leading = re.match(r"^[ \t]*", base_indent)
        if not m_leading:
            msg = "Could not determine indentation for dictionary body"
            raise RuntimeError(msg)
        leading = m_leading.group(0)
        indent = leading + " " * 4

    new_entry = f'\n{indent}"{key}": {value_code},'

    # Insert before closing brace
    new_body = body + new_entry + "\n"
    new_content = content[: brace_start + 1] + new_body + content[brace_end:]
    return new_content, True


def update_sources_py(app_key: str, org: str, app: str, *, dry_run: bool) -> bool:
    """Update `src/downloader/sources.py` with the APKMirror mapping.

    Returns True if a change was made.
    """
    path = REPO_ROOT / "src" / "downloader" / "sources.py"
    content = read_text(path)
    value_code = f'f"{ '{' }APK_MIRROR_BASE_APK_URL{ '}' }/{org}/{app}/"'
    pattern = r"apk_sources\s*=\s*\{"
    new_content, changed = insert_kv_into_dict(content, pattern, app_key, value_code)
    if changed and not dry_run:
        write_text(path, new_content)
    return changed


def update_patches_py(package_name: str, app_key: str, *, dry_run: bool) -> bool:
    """Update `src/patches.py` with package -> app key mapping.

    Returns True if a change was made.
    """
    path = REPO_ROOT / "src" / "patches.py"
    content = read_text(path)
    value_code = f'"{app_key}"'
    # Match the dict assignment, accommodating type annotations
    pattern = r"revanced_package_names[\s\S]*?=\s*\{"
    new_content, changed = insert_kv_into_dict(content, pattern, package_name, value_code)
    if changed and not dry_run:
        write_text(path, new_content)
    return changed


def update_readme_md(app_key: str, org: str, app: str, *, dry_run: bool) -> bool:
    """Insert the README bullet link for the new app.

    Returns True if a change was made.
    """
    path = REPO_ROOT / "README.md"
    content = read_text(path)
    bullet = f"    - [{app_key}](https://www.apkmirror.com/apk/{org}/{app}/)"

    # Check if already present (exact label match, beginning of bullet)
    exists_pattern = re.compile(r"^\s*-\s*\[" + re.escape(app_key) + r"\]\(", flags=re.MULTILINE)
    if exists_pattern.search(content):
        return False

    # Locate the supported list block
    # Insert before the note that ends the list
    note = re.search(r"^\s*<br>`\*\*` - You can also patch any other app", content, re.MULTILINE)
    if note:
        insert_pos = note.start()
        new_content = content[:insert_pos] + bullet + "\n" + content[insert_pos:]
    else:
        # Fallback: append at end
        new_content = content.rstrip("\n") + "\n" + bullet + "\n"

    if not dry_run:
        write_text(path, new_content)
    return True


def main() -> None:
    """Entry point: parse args, perform updates, and report results."""
    args = parse_args()

    if args.apkmirror_path or args.apkmirror_url:
        org, app = extract_apkmirror_path(args.apkmirror_path or args.apkmirror_url)
    else:
        org, app = discover_apkmirror_path_via_api(args.package, args.apkmirror_auth, args.user_agent)

    changed_any = False
    changed_sources = update_sources_py(args.name, org, app, dry_run=args.dry_run)
    changed_any = changed_any or changed_sources

    changed_patches = update_patches_py(args.package, args.name, dry_run=args.dry_run)
    changed_any = changed_any or changed_patches

    changed_readme = update_readme_md(args.name, org, app, dry_run=args.dry_run)
    changed_any = changed_any or changed_readme

    if not changed_any:
        pass


if __name__ == "__main__":
    main()