Rdt Cli

name: CI

on:
  push:
    branches: [main]
  pull_request:
    branches: [main]
  workflow_call:

jobs:
  lint-and-test:
    name: Lint and test (Python ${{ matrix.python-version }})
    runs-on: ubuntu-latest
    strategy:
      fail-fast: false
      matrix:
        python-version: ["3.10", "3.12", "3.13"]
    steps:
      - uses: actions/checkout@v4

      - name: Set up Python
        uses: actions/setup-python@v5
        with:
          python-version: ${{ matrix.python-version }}

      - name: Install uv
        uses: astral-sh/setup-uv@v6

      - name: Install dependencies
        run: uv sync --group dev

      - name: Run ruff
        run: uv run ruff check .

      - name: Run tests
        run: uv run python -m pytest -q

  build:
    name: Build package
    runs-on: ubuntu-latest
    needs: lint-and-test
    steps:
      - uses: actions/checkout@v4

      - name: Set up Python
        uses: actions/setup-python@v5
        with:
          python-version: "3.12"

      - name: Install uv
        uses: astral-sh/setup-uv@v6

      - name: Install dependencies
        run: uv sync --group dev

      - name: Build distribution
        run: uv build

name: Publish to PyPI

on:
  push:
    tags:
      - "v*"
  workflow_dispatch:

jobs:
  publish:
    runs-on: ubuntu-latest
    environment: pypi
    permissions:
      id-token: write

    steps:
      - uses: actions/checkout@v4

      - uses: actions/setup-python@v5
        with:
          python-version: "3.12"

      - name: Setup uv
        uses: astral-sh/setup-uv@v6

      - name: Build package
        run: uv build

      - name: Publish to PyPI
        uses: pypa/gh-action-pypi-publish@release/v1

__pycache__/
*.py[cod]
dist/
.venv/
*.egg-info/
.ruff_cache/
.pytest_cache/
.mypy_cache/

[build-system]
requires = ["hatchling"]
build-backend = "hatchling.build"

[project]
name = "rdt-cli"
version = "0.4.2"
description = "A CLI for Reddit — browse feeds, read posts, search, and interact via terminal 📖"
readme = "README.md"
requires-python = ">=3.10"
license = "Apache-2.0"
authors = [{ name = "jackwener", email = "jakevingoo@gmail.com" }]
keywords = ["reddit", "rdt", "cli", "terminal", "api"]
classifiers = [
    "Development Status :: 3 - Alpha",
    "Environment :: Console",
    "License :: OSI Approved :: Apache Software License",
    "Programming Language :: Python :: 3",
    "Topic :: Utilities",
]
dependencies = [
    "click>=8.0",
    "rich>=13.0",
    "httpx>=0.27",
    "browser-cookie3>=0.19",
    "pyyaml>=6.0",
]

[project.urls]
Homepage = "https://github.com/jackwener/rdt-cli"
Repository = "https://github.com/jackwener/rdt-cli"
Issues = "https://github.com/jackwener/rdt-cli/issues"

[project.scripts]
rdt = "rdt_cli.cli:cli"

[tool.hatch.build.targets.wheel]
packages = ["rdt_cli"]

[tool.ruff]
target-version = "py310"
line-length = 120

[tool.ruff.lint]
select = ["E", "F", "I", "B", "UP"]

[tool.mypy]
python_version = "3.10"
ignore_missing_imports = true
check_untyped_defs = true

[tool.pytest.ini_options]
testpaths = ["tests"]
python_files = ["test_*.py"]
addopts = "-m 'not smoke'"
markers = ["smoke: end-to-end tests requiring live cookies"]

[dependency-groups]
dev = ["pytest>=8.0", "ruff>=0.4"]

"""Reddit CLI."""

__version__ = "0.4.2"

"""Allow running as `python -m rdt_cli`."""

from rdt_cli.cli import cli

cli()

"""Authentication for Reddit CLI.

Strategy:
1. Try loading saved credential from ~/.config/rdt-cli/credential.json
2. Try extracting cookies from local browsers via browser-cookie3
3. No QR login — Reddit uses OAuth/cookie-based auth only
"""

from __future__ import annotations

import json
import logging
import shutil
import subprocess
import time
from typing import Any

from .constants import CONFIG_DIR, CREDENTIAL_FILE, REQUIRED_COOKIES

logger = logging.getLogger(__name__)

# Credential TTL: attempt refresh after 7 days
CREDENTIAL_TTL_DAYS = 7
_CREDENTIAL_TTL_SECONDS = CREDENTIAL_TTL_DAYS * 86400


# ── Credential data class ───────────────────────────────────────────


class Credential:
    """Holds Reddit session cookies."""

    def __init__(
        self,
        cookies: dict[str, str],
        *,
        source: str = "unknown",
        username: str | None = None,
        modhash: str | None = None,
        saved_at: float | None = None,
        last_verified_at: float | None = None,
    ):
        self.cookies = cookies
        self.source = source
        self.username = username
        self.modhash = modhash
        self.saved_at = saved_at
        self.last_verified_at = last_verified_at

    @property
    def is_valid(self) -> bool:
        return bool(self.cookies)

    def to_dict(self) -> dict[str, Any]:
        saved_at = self.saved_at or time.time()
        return {
            "cookies": self.cookies,
            "source": self.source,
            "username": self.username,
            "modhash": self.modhash,
            "saved_at": saved_at,
            "last_verified_at": self.last_verified_at,
        }

    @classmethod
    def from_dict(cls, data: dict[str, Any]) -> Credential:
        return cls(
            cookies=data.get("cookies", {}),
            source=data.get("source", "saved"),
            username=data.get("username"),
            modhash=data.get("modhash"),
            saved_at=data.get("saved_at"),
            last_verified_at=data.get("last_verified_at"),
        )

    def as_cookie_header(self) -> str:
        return "; ".join(f"{k}={v}" for k, v in self.cookies.items())


# ── Persistence ─────────────────────────────────────────────────────


def save_credential(credential: Credential) -> None:
    """Save credential to disk with restricted permissions."""
    CONFIG_DIR.mkdir(parents=True, exist_ok=True)
    if credential.saved_at is None:
        credential.saved_at = time.time()
    CREDENTIAL_FILE.write_text(json.dumps(credential.to_dict(), indent=2, ensure_ascii=False))
    CREDENTIAL_FILE.chmod(0o600)


def load_credential() -> Credential | None:
    """Load saved credential with TTL-based auto-refresh."""
    if not CREDENTIAL_FILE.exists():
        return None
    try:
        data = json.loads(CREDENTIAL_FILE.read_text())
        cred = Credential.from_dict(data)
        if not cred.is_valid:
            return None

        # TTL check — auto-refresh if stale
        saved_at = data.get("saved_at", 0)
        if saved_at and (time.time() - saved_at) > _CREDENTIAL_TTL_SECONDS:
            logger.info("Credential older than %d days, attempting browser refresh", CREDENTIAL_TTL_DAYS)
            fresh = extract_browser_credential()
            if fresh:
                logger.info("Auto-refreshed credential from browser")
                return fresh
            logger.warning("Cookie refresh failed; using existing cookies")

        return cred
    except (json.JSONDecodeError, KeyError):
        return None


def clear_credential() -> None:
    """Remove saved credential file."""
    if CREDENTIAL_FILE.exists():
        CREDENTIAL_FILE.unlink()


# ── Browser cookie extraction ───────────────────────────────────────


def extract_browser_credential() -> Credential | None:
    """Extract Reddit cookies from installed browsers.

    Uses subprocess to avoid SQLite lock when browser is running.
    """
    if shutil.which("uv"):
        cred = _extract_subprocess()
        if cred:
            return cred
    return _extract_direct()


def _extract_subprocess() -> Credential | None:
    """Extract via uv subprocess — avoids SQLite lock."""
    script = '''
import browser_cookie3, json
cookies = {}
for browser_fn in [browser_cookie3.chrome, browser_cookie3.firefox, browser_cookie3.edge, browser_cookie3.brave]:
    try:
        jar = browser_fn(domain_name=".reddit.com")
        for c in jar:
            cookies[c.name] = c.value
        if cookies:
            break
    except Exception:
        continue
if cookies:
    print(json.dumps(cookies))
'''
    try:
        result = subprocess.run(
            ["uv", "run", "--with", "browser-cookie3", "python3", "-c", script],
            capture_output=True,
            text=True,
            timeout=30,
        )
        if result.returncode == 0 and result.stdout.strip():
            cookies = json.loads(result.stdout.strip())
            if any(k in cookies for k in REQUIRED_COOKIES):
                cred = Credential(cookies=cookies, source="browser:subprocess")
                save_credential(cred)
                return cred
    except Exception as e:
        logger.debug("Subprocess extraction failed: %s", e)
    return None


def _extract_direct() -> Credential | None:
    """Fallback direct extraction (may fail if browser is open)."""
    try:
        import browser_cookie3
    except ImportError:
        logger.warning("browser-cookie3 not available for direct extraction")
        return None

    for fn in [browser_cookie3.chrome, browser_cookie3.firefox, browser_cookie3.edge, browser_cookie3.brave]:
        try:
            jar = fn(domain_name=".reddit.com")
            cookies = {c.name: c.value for c in jar}
            if any(k in cookies for k in REQUIRED_COOKIES):
                cred = Credential(cookies=cookies, source=f"browser:{fn.__name__}")
                save_credential(cred)
                return cred
        except Exception:
            continue
    return None


# ── Credential chain ────────────────────────────────────────────────


def get_credential() -> Credential | None:
    """Try saved → browser → return None."""
    cred = load_credential()
    if cred:
        return cred
    cred = extract_browser_credential()
    if cred:
        return cred
    return None

"""CLI entry point for rdt-cli.

Usage:
    rdt login / status / logout
    rdt feed / popular / all / sub <subreddit>
    rdt read <post_id> / show <index> / open <id_or_index>
    rdt search <query> / export <query>
    rdt user <username> / user-posts <username> / user-comments <username>
    rdt saved / upvoted
    rdt upvote / save / subscribe / comment
"""

from __future__ import annotations

import logging

import click

from . import __version__
from .commands import auth, browse, post, search, social


@click.group()
@click.version_option(version=__version__, prog_name="rdt")
@click.option("-v", "--verbose", is_flag=True, help="Enable verbose logging (show request URLs, timing)")
@click.pass_context
def cli(ctx: click.Context, verbose: bool) -> None:
    """rdt — Reddit in your terminal 📖"""
    ctx.ensure_object(dict)
    logging.basicConfig(
        level=logging.INFO if verbose else logging.WARNING,
        format="%(name)s %(message)s",
    )


# ─── Auth commands ───────────────────────────────────────────────────

cli.add_command(auth.login)
cli.add_command(auth.logout)
cli.add_command(auth.status)
cli.add_command(auth.whoami)

# ─── Browse commands ─────────────────────────────────────────────────

cli.add_command(browse.feed)
cli.add_command(browse.popular)
cli.add_command(browse.all_cmd)
cli.add_command(browse.sub)
cli.add_command(browse.sub_info)
cli.add_command(browse.user)
cli.add_command(browse.user_posts)
cli.add_command(browse.user_comments)
cli.add_command(browse.saved)
cli.add_command(browse.upvoted)
cli.add_command(browse.open_post)

# ─── Post commands ───────────────────────────────────────────────────

cli.add_command(post.read)
cli.add_command(post.show)

# ─── Search & Export ─────────────────────────────────────────────────

cli.add_command(search.search)
cli.add_command(search.export)

# ─── Social commands ────────────────────────────────────────────────

cli.add_command(social.upvote)
cli.add_command(social.save)
cli.add_command(social.subscribe)
cli.add_command(social.comment)


if __name__ == "__main__":
    cli()

"""API client for Reddit with rate limiting, retry, and anti-detection."""

from __future__ import annotations

import logging
from typing import Any

from .config import DEFAULT_CONFIG, RuntimeConfig
from .constants import (
    ALL_URL,
    COMMENT_URL,
    DEFAULT_LIMIT,
    HOME_URL,
    MORECHILDREN_URL,
    POPULAR_URL,
    POST_COMMENTS_SHORT_URL,
    POST_COMMENTS_URL,
    SAVE_URL,
    SEARCH_URL,
    SUBREDDIT_ABOUT_URL,
    SUBREDDIT_SEARCH_URL,
    SUBSCRIBE_URL,
    SUBSCRIPTIONS_URL,
    UNSAVE_URL,
    USER_ABOUT_URL,
    USER_COMMENTS_URL,
    USER_POSTS_URL,
    USER_SAVED_URL,
    USER_UPVOTED_URL,
    VOTE_URL,
)
from .exceptions import (
    RedditApiError,
)
from .fingerprint import BrowserFingerprint
from .session import SessionState
from .transports import ReadTransport, WriteTransport

logger = logging.getLogger(__name__)


class RedditClient:
    """Reddit API client with Gaussian jitter, exponential backoff, and session-stable identity.

    Anti-detection strategy:
    - Gaussian jitter delay between requests
    - 5% chance of random long pause (2-5s) to mimic reading
    - Exponential backoff on HTTP 429/5xx (up to 3 retries)
    - Response cookies merged back into session jar
    - Per-request logging with counter
    """

    def __init__(
        self,
        credential: object | None = None,
        timeout: float = 30.0,
        request_delay: float = 1.0,
        max_retries: int = 3,
    ):
        self.credential = credential
        self._timeout = timeout
        self._request_delay = request_delay
        self._max_retries = max_retries
        self._config = RuntimeConfig(
            timeout=timeout,
            read_request_delay=request_delay,
            write_request_delay=max(request_delay, DEFAULT_CONFIG.write_request_delay),
            max_retries=max_retries,
            status_check_timeout=min(timeout, DEFAULT_CONFIG.status_check_timeout),
        )
        self._fingerprint = BrowserFingerprint.chrome133_mac()
        self.session = SessionState.from_credential(credential)
        self._read_transport: ReadTransport | None = None
        self._write_transport: WriteTransport | None = None
        self._http = None

    @property
    def client(self):
        if not self._read_transport:
            raise RuntimeError("Client not initialized. Use 'with RedditClient() as client:'")
        return self._read_transport.client

    def __enter__(self) -> RedditClient:
        self._read_transport = ReadTransport(
            self.session,
            config=self._config,
            fingerprint=self._fingerprint,
            request_delay=self._config.read_request_delay,
        )
        self._write_transport = WriteTransport(
            self.session,
            config=self._config,
            fingerprint=self._fingerprint,
            request_delay=self._config.write_request_delay,
        )
        self._http = self._read_transport.client
        return self

    def __exit__(self, *args: Any) -> None:
        if self._read_transport:
            self._read_transport.close()
            self._read_transport = None
        if self._write_transport:
            self._write_transport.close()
            self._write_transport = None
        self._http = None

    @property
    def request_stats(self) -> dict[str, int]:
        read_count = self._read_transport.request_count if self._read_transport else 0
        write_count = self._write_transport.request_count if self._write_transport else 0
        return {"request_count": read_count + write_count}

    # ── Core request ────────────────────────────────────────────────

    def _request(self, method: str, url: str, **kwargs: Any) -> Any:
        """Read request through the low-risk transport."""
        if not self._read_transport:
            raise RuntimeError("Client not initialized. Use 'with RedditClient() as client:'")
        return self._read_transport.request(method, url, **kwargs)

    def _write_request(self, method: str, url: str, **kwargs: Any) -> Any:
        """Write request through the authenticated transport."""
        if not self._write_transport:
            raise RuntimeError("Client not initialized. Use 'with RedditClient() as client:'")
        return self._write_transport.request(method, url, **kwargs)

    def _get(self, url: str, params: dict[str, Any] | None = None) -> Any:
        """GET request."""
        return self._request("GET", url, params=params)

    def _post(self, url: str, data: dict[str, Any] | None = None) -> Any:
        """POST request."""
        return self._write_request("POST", url, data=data)

    # ── Listing helpers ─────────────────────────────────────────────

    @staticmethod
    def _extract_posts(data: dict) -> list[dict]:
        """Extract post list from Reddit Listing response."""
        if isinstance(data, list):
            # Comments endpoint returns [post_listing, comments_listing]
            return data
        children = data.get("data", {}).get("children", [])
        return [child.get("data", child) for child in children]

    @staticmethod
    def _extract_after(data: dict) -> str | None:
        """Extract pagination cursor."""
        if isinstance(data, list):
            return None
        return data.get("data", {}).get("after")

    # ── Feed / Listing endpoints ────────────────────────────────────

    def get_home(self, limit: int = DEFAULT_LIMIT, after: str | None = None) -> dict:
        """Get home feed (requires login)."""
        params: dict[str, Any] = {"limit": limit, "raw_json": 1}
        if after:
            params["after"] = after
        return self._get(HOME_URL, params=params)

    def get_popular(self, limit: int = DEFAULT_LIMIT, after: str | None = None) -> dict:
        """Get /r/popular."""
        params: dict[str, Any] = {"limit": limit, "raw_json": 1}
        if after:
            params["after"] = after
        return self._get(POPULAR_URL, params=params)

    def get_all(self, limit: int = DEFAULT_LIMIT, after: str | None = None) -> dict:
        """Get /r/all."""
        params: dict[str, Any] = {"limit": limit, "raw_json": 1}
        if after:
            params["after"] = after
        return self._get(ALL_URL, params=params)

    def get_subreddit(
        self,
        subreddit: str,
        sort: str = "hot",
        limit: int = DEFAULT_LIMIT,
        after: str | None = None,
        time_filter: str | None = None,
    ) -> dict:
        """Get subreddit listing."""
        url = f"/r/{subreddit}.json" if sort == "hot" else f"/r/{subreddit}/{sort}.json"
        params: dict[str, Any] = {"limit": limit, "raw_json": 1}
        if after:
            params["after"] = after
        if time_filter and sort in ("top", "controversial"):
            params["t"] = time_filter
        return self._get(url, params=params)

    def get_subreddit_about(self, subreddit: str) -> dict:
        """Get subreddit info."""
        data = self._get(SUBREDDIT_ABOUT_URL.format(subreddit=subreddit), params={"raw_json": 1})
        return data.get("data", data)

    # ── Post / Comments ─────────────────────────────────────────────

    def get_post_comments(
        self,
        post_id: str,
        subreddit: str | None = None,
        sort: str = "best",
        limit: int = DEFAULT_LIMIT,
    ) -> list[dict]:
        """Get post and its comments.

        Returns [post_listing, comments_listing].
        """
        if subreddit:
            url = POST_COMMENTS_URL.format(subreddit=subreddit, post_id=post_id)
        else:
            url = POST_COMMENTS_SHORT_URL.format(post_id=post_id)
        params: dict[str, Any] = {"sort": sort, "limit": limit, "raw_json": 1}
        return self._get(url, params=params)

    def get_more_comments(
        self,
        post_id: str,
        children: list[str],
        *,
        sort: str = "best",
    ) -> dict:
        """Expand additional comments for a post."""
        if not children:
            return {"json": {"data": {"things": []}}}
        params: dict[str, Any] = {
            "api_type": "json",
            "link_id": f"t3_{post_id}",
            "children": ",".join(children),
            "sort": sort,
            "limit_children": False,
            "raw_json": 1,
        }
        return self._get(MORECHILDREN_URL, params=params)

    # ── Search ──────────────────────────────────────────────────────

    def search(
        self,
        query: str,
        subreddit: str | None = None,
        sort: str = "relevance",
        time_filter: str = "all",
        limit: int = DEFAULT_LIMIT,
        after: str | None = None,
    ) -> dict:
        """Search posts."""
        if subreddit:
            url = SUBREDDIT_SEARCH_URL.format(subreddit=subreddit)
        else:
            url = SEARCH_URL
        params: dict[str, Any] = {
            "q": query,
            "sort": sort,
            "t": time_filter,
            "limit": limit,
            "restrict_sr": "on" if subreddit else "off",
            "raw_json": 1,
        }
        if after:
            params["after"] = after
        return self._get(url, params=params)

    # ── User ────────────────────────────────────────────────────────

    def get_user_about(self, username: str) -> dict:
        """Get user profile info."""
        data = self._get(USER_ABOUT_URL.format(username=username), params={"raw_json": 1})
        return data.get("data", data)

    def get_user_posts(self, username: str, limit: int = DEFAULT_LIMIT, after: str | None = None) -> dict:
        """Get user's submitted posts."""
        params: dict[str, Any] = {"limit": limit, "raw_json": 1}
        if after:
            params["after"] = after
        return self._get(USER_POSTS_URL.format(username=username), params=params)

    def get_user_comments(self, username: str, limit: int = DEFAULT_LIMIT, after: str | None = None) -> dict:
        """Get user's comments."""
        params: dict[str, Any] = {"limit": limit, "raw_json": 1}
        if after:
            params["after"] = after
        return self._get(USER_COMMENTS_URL.format(username=username), params=params)

    def get_user_saved(self, username: str, limit: int = DEFAULT_LIMIT, after: str | None = None) -> dict:
        """Get user's saved items."""
        params: dict[str, Any] = {"limit": limit, "raw_json": 1}
        if after:
            params["after"] = after
        return self._get(USER_SAVED_URL.format(username=username), params=params)

    def get_user_upvoted(self, username: str, limit: int = DEFAULT_LIMIT, after: str | None = None) -> dict:
        """Get user's upvoted items."""
        params: dict[str, Any] = {"limit": limit, "raw_json": 1}
        if after:
            params["after"] = after
        return self._get(USER_UPVOTED_URL.format(username=username), params=params)

    # ── Identity (requires auth) ────────────────────────────────────

    def get_me(self) -> dict:
        """Get current user info and enrich session capabilities."""
        data = self._get("/api/me.json", params={"raw_json": 1})
        if isinstance(data, dict):
            self.session.apply_identity(data)
        return data

    def validate_session(self) -> dict[str, Any]:
        """Probe a lightweight auth endpoint to classify current credential."""
        try:
            identity = self.get_me()
            return {
                "authenticated": True,
                "username": self.session.username,
                "capabilities": sorted(self.session.capabilities),
                "modhash_present": bool(self.session.modhash),
                "identity": identity,
            }
        except RedditApiError as exc:
            self.session.apply_validation_error(str(exc))
            return {
                "authenticated": False,
                "username": self.session.username,
                "capabilities": sorted(self.session.capabilities),
                "modhash_present": bool(self.session.modhash),
                "error": str(exc),
            }

    # ── Write actions (require authentication) ──────────────────────

    def vote(self, fullname: str, direction: int) -> dict:
        """Vote on a post or comment. direction: 1=upvote, 0=unvote, -1=downvote."""
        return self._post(VOTE_URL, data={"id": fullname, "dir": str(direction)})

    def save_item(self, fullname: str) -> dict:
        """Save a post or comment."""
        return self._post(SAVE_URL, data={"id": fullname})

    def unsave_item(self, fullname: str) -> dict:
        """Unsave a post or comment."""
        return self._post(UNSAVE_URL, data={"id": fullname})

    def subscribe(self, subreddit: str, action: str = "sub") -> dict:
        """Subscribe or unsubscribe. action: 'sub' or 'unsub'."""
        return self._post(SUBSCRIBE_URL, data={"sr_name": subreddit, "action": action})

    def post_comment(self, parent_fullname: str, text: str) -> dict:
        """Post a comment."""
        return self._post(COMMENT_URL, data={"parent": parent_fullname, "text": text})

    # ── Subscription feed ───────────────────────────────────────────

    def get_my_subscriptions(
        self, limit: int = 100, max_subs: int = 20,
    ) -> list[str]:
        """Get names of subscribed subreddits (up to max_subs)."""
        names: list[str] = []
        after: str | None = None
        while len(names) < max_subs:
            params: dict[str, Any] = {"limit": min(limit, 100), "raw_json": 1}
            if after:
                params["after"] = after
            data = self._get(SUBSCRIPTIONS_URL, params=params)
            children = data.get("data", {}).get("children", [])
            if not children:
                break
            for child in children:
                name = child.get("data", {}).get("display_name", "")
                if name:
                    names.append(name)
                if len(names) >= max_subs:
                    break
            after = data.get("data", {}).get("after")
            if not after:
                break
        return names

    def get_subs_only_feed(
        self,
        limit_per_sub: int = DEFAULT_LIMIT,
        max_subs: int = 20,
        on_progress: Any = None,
    ) -> dict:
        """Aggregate newest posts from subscribed subreddits.

        Returns a synthetic listing dict compatible with parse_listing().
        """
        subs = self.get_my_subscriptions(max_subs=max_subs)
        if not subs:
            return {"data": {"children": [], "after": None}}

        all_posts: list[dict] = []
        seen_ids: set[str] = set()

        for i, sub_name in enumerate(subs):
            if on_progress:
                on_progress(i + 1, len(subs), sub_name)
            try:
                data = self.get_subreddit(sub_name, sort="new", limit=limit_per_sub)
                children = data.get("data", {}).get("children", [])
                for child in children:
                    post = child.get("data", child)
                    pid = post.get("id", "")
                    if pid and pid not in seen_ids:
                        seen_ids.add(pid)
                        all_posts.append(child if "data" in child else {"data": child})
            except RedditApiError as exc:
                logger.warning("Skipping r/%s: %s", sub_name, exc)

        # Sort by created_utc descending
        all_posts.sort(
            key=lambda c: c.get("data", {}).get("created_utc", 0),
            reverse=True,
        )

        return {"data": {"children": all_posts, "after": None}}

"""Common helpers for Reddit CLI commands."""

from __future__ import annotations

import json
import os
import platform
import subprocess
import sys
from collections.abc import Callable
from datetime import datetime, timezone
from typing import Any, TypeVar

import click
from rich.console import Console

from ..auth import Credential, get_credential
from ..client import RedditClient
from ..exceptions import RedditApiError, SessionExpiredError, error_code_for_exception

T = TypeVar("T")

console = Console(stderr=True)
error_console = Console(stderr=True)
_stdout = Console()

_SCHEMA_VERSION = "1"
_OUTPUT_ENV = "OUTPUT"


# ── Shared formatters (DRY — used by browse, search, post) ──────────


def format_score(score: int) -> str:
    """Format score as human-readable string (e.g., 1.2k)."""
    if score >= 1000:
        return f"{score / 1000:.1f}k"
    return str(score)


def format_time(ts: float) -> str:
    """Format Unix timestamp to relative time string."""
    if not ts:
        return "-"
    now = datetime.now(timezone.utc).timestamp()
    diff = now - ts
    if diff < 0:
        return "just now"
    if diff < 60:
        return f"{int(diff)}s ago"
    if diff < 3600:
        return f"{int(diff / 60)}m ago"
    if diff < 86400:
        return f"{int(diff / 3600)}h ago"
    if diff < 604800:
        return f"{int(diff / 86400)}d ago"
    return datetime.fromtimestamp(ts, tz=timezone.utc).strftime("%Y-%m-%d")


# ── Output format resolution ────────────────────────────────────────


def resolve_output_format(*, as_json: bool, as_yaml: bool) -> str | None:
    """Resolve explicit flags first, then env override, then TTY default.

    Returns "json", "yaml", or None (for rich rendering).
    """
    if as_json and as_yaml:
        raise click.UsageError("Use only one of --json or --yaml.")
    if as_json:
        return "json"
    if as_yaml:
        return "yaml"

    output_mode = os.getenv(_OUTPUT_ENV, "auto").strip().lower()
    if output_mode == "yaml":
        return "yaml"
    if output_mode == "json":
        return "json"
    if output_mode == "rich":
        return None

    if not sys.stdout.isatty():
        return "yaml"
    return None


# ── Structured output (stable agent envelope) ──────────────────────


def success_payload(data: Any) -> dict[str, Any]:
    """Wrap structured success data in the shared agent schema."""
    return {
        "ok": True,
        "schema_version": _SCHEMA_VERSION,
        "data": data,
    }


def error_payload(code: str, message: str, *, details: Any | None = None) -> dict[str, Any]:
    """Wrap structured error data in the shared agent schema."""
    error: dict[str, Any] = {
        "code": code,
        "message": message,
    }
    if details is not None:
        error["details"] = details
    return {
        "ok": False,
        "schema_version": _SCHEMA_VERSION,
        "error": error,
    }


def print_json(data: Any) -> None:
    """Print raw JSON output to stdout."""
    click.echo(json.dumps(data, indent=2, ensure_ascii=False))


def print_yaml(data: Any) -> None:
    """Print raw YAML output to stdout."""
    try:
        import yaml

        click.echo(yaml.dump(
            data, allow_unicode=True, default_flow_style=False,
            sort_keys=False, default_style='"', width=1000,
        ))
    except ImportError:
        click.echo(json.dumps(data, indent=2, ensure_ascii=False))


def maybe_print_structured(data: Any, *, as_json: bool, as_yaml: bool) -> bool:
    """Print structured output (with envelope) when requested or when stdout is non-TTY.

    Returns True if output was printed, False if rich rendering should be used.
    """
    fmt = resolve_output_format(as_json=as_json, as_yaml=as_yaml)
    if not fmt:
        return False
    payload = success_payload(data)
    if fmt == "json":
        print_json(payload)
    else:
        print_yaml(payload)
    return True


def emit_error(
    code: str,
    message: str,
    *,
    as_json: bool | None = None,
    as_yaml: bool | None = None,
    details: Any | None = None,
) -> bool:
    """Emit a structured error when the active output mode is machine-readable.

    Returns True if the error was emitted as structured output.
    """
    if as_json is None or as_yaml is None:
        ctx = click.get_current_context(silent=True)
        params = ctx.params if ctx is not None else {}
        as_json = bool(params.get("as_json", False)) if as_json is None else as_json
        as_yaml = bool(params.get("as_yaml", False)) if as_yaml is None else as_yaml

    fmt = resolve_output_format(as_json=bool(as_json), as_yaml=bool(as_yaml))
    if fmt is None:
        return False

    payload = error_payload(code, message, details=details)
    if fmt == "json":
        print_json(payload)
    else:
        print_yaml(payload)
    return True


# ── Auth / Client helpers ───────────────────────────────────────────


def require_auth() -> Credential:
    """Get credential or exit with error."""
    cred = get_credential()
    if not cred:
        console.print("[yellow]⚠️  Not logged in[/yellow]. Use [bold]rdt login[/bold] to authenticate")
        sys.exit(1)
    return cred


def optional_auth() -> Credential | None:
    """Get credential if available, or None (for public endpoints)."""
    return get_credential()


def get_client(credential: Credential | None = None) -> RedditClient:
    """Create a RedditClient with optional credential."""
    return RedditClient(credential)


def run_client_action(credential: Credential | None, action: Callable[[RedditClient], T]) -> T:
    """Run a client action with auto-retry on session expiry."""
    try:
        with get_client(credential) as client:
            return action(client)
    except SessionExpiredError:
        from ..auth import extract_browser_credential

        fresh = extract_browser_credential()
        if fresh:
            with get_client(fresh) as client:
                return action(client)
        raise


def handle_command(
    credential: Credential | None,
    *,
    action: Callable[[RedditClient], T],
    render: Callable[[T], None] | None = None,
    as_json: bool = False,
    as_yaml: bool = False,
) -> T | None:
    """Run a client action with structured output support.

    - --json → JSON stdout (with envelope)
    - --yaml or non-TTY → YAML (with envelope)
    - Otherwise → rich render

    On error: emits structured error + exit(1).
    """
    try:
        data = run_client_action(credential, action)

        if maybe_print_structured(data, as_json=as_json, as_yaml=as_yaml):
            return data

        if render:
            render(data)
        return data

    except RedditApiError as exc:
        exit_for_error(exc, as_json=as_json, as_yaml=as_yaml)
        return None  # unreachable, but for type checker


def handle_errors(fn: Callable[[], T], *, as_json: bool = False, as_yaml: bool = False) -> T | None:
    """Run arbitrary command logic and catch RedditApiError."""
    try:
        return fn()
    except RedditApiError as exc:
        exit_for_error(exc, as_json=as_json, as_yaml=as_yaml)
        return None


def exit_for_error(
    exc: Exception,
    *,
    as_json: bool = False,
    as_yaml: bool = False,
    prefix: str | None = None,
) -> None:
    """Emit a structured/non-structured error and terminate the command."""
    message = str(exc)
    if prefix:
        message = f"{prefix}: {message}"

    code = error_code_for_exception(exc)

    if emit_error(code, message, as_json=as_json, as_yaml=as_yaml):
        raise SystemExit(1) from None

    error_console.print(f"[red]❌ [{code}] {message}[/red]")
    raise SystemExit(1) from None


def structured_output_options(command: Callable) -> Callable:
    """Add --json/--yaml options to a Click command."""
    command = click.option("--yaml", "as_yaml", is_flag=True, help="Output as YAML")(command)
    command = click.option("--json", "as_json", is_flag=True, help="Output as JSON")(command)
    return command


def listing_options(command: Callable) -> Callable:
    """Add --json/--yaml/--output/--full-text/--compact options to listing commands."""
    command = click.option(
        "-c", "--compact", is_flag=True,
        help="Compact output (fewer fields, agent-friendly)",
    )(command)
    command = click.option(
        "--full-text", "full_text", is_flag=True,
        help="Show full title/text without truncation",
    )(command)
    command = click.option(
        "-o", "--output", "output_file", default=None,
        help="Save structured output to file (JSON/YAML)",
    )(command)
    command = click.option("--yaml", "as_yaml", is_flag=True, help="Output as YAML")(command)
    command = click.option("--json", "as_json", is_flag=True, help="Output as JSON")(command)
    return command


def output_or_render(data: Any, *, as_json: bool, as_yaml: bool, render: Callable) -> None:
    """DRY output routing: JSON / YAML (with envelope) / Rich."""
    if maybe_print_structured(data, as_json=as_json, as_yaml=as_yaml):
        return
    render(data)


def save_output_to_file(data: Any, output_file: str) -> None:
    """Save structured output to a file (auto-detect JSON/YAML by extension)."""
    payload = success_payload(data)
    ext = output_file.rsplit(".", 1)[-1].lower() if "." in output_file else "json"
    if ext in ("yml", "yaml"):
        try:
            import yaml
            text = yaml.dump(
                payload, allow_unicode=True, default_flow_style=False,
                sort_keys=False, default_style='"', width=1000,
            )
        except ImportError:
            text = json.dumps(payload, indent=2, ensure_ascii=False)
    else:
        text = json.dumps(payload, indent=2, ensure_ascii=False)
    with open(output_file, "w", encoding="utf-8") as f:
        f.write(text)
    console.print(f"[green]✅ Saved to {output_file}[/green]")


def compact_posts(posts: list[dict]) -> list[dict]:
    """Strip non-essential fields for agent-friendly compact output."""
    keep = {"id", "name", "title", "subreddit", "author", "score", "num_comments", "permalink", "url", "created_utc"}
    return [{k: v for k, v in p.items() if k in keep} for p in posts]


def compact_post_detail(detail: Any) -> dict[str, Any]:
    """Flatten a PostDetail into a compact, agent-friendly structure."""
    from ..models import PostDetail
    from ..parser import parse_post_detail

    if not isinstance(detail, PostDetail):
        detail = parse_post_detail(detail)

    post = detail.post
    compact_post = {
        "id": post.id,
        "title": post.title,
        "subreddit": post.subreddit,
        "author": post.author,
        "score": post.score,
        "num_comments": post.num_comments,
        "selftext": post.selftext,
        "url": post.url,
        "permalink": post.permalink,
    }

    def _flatten_comments(comments: list, depth: int = 0) -> list[dict]:
        flat: list[dict] = []
        for c in comments:
            if c.author == "[more]":
                continue
            flat.append({
                "author": c.author,
                "score": c.score,
                "body": c.body,
                "depth": depth,
            })
            flat.extend(_flatten_comments(c.replies, depth + 1))
        return flat

    return {
        "post": compact_post,
        "comments": _flatten_comments(detail.comments),
    }


def write_delay() -> None:
    """Random delay for write operations (1.5-4s) to mitigate rate limits."""
    import random
    import time

    delay = random.uniform(1.5, 4.0)
    time.sleep(delay)


def open_url(url: str) -> None:
    """Open a URL in the default browser."""
    system = platform.system()
    try:
        if system == "Darwin":
            subprocess.run(["open", url], check=True)
        elif system == "Linux":
            subprocess.run(["xdg-open", url], check=True)
        elif system == "Windows":
            subprocess.run(["start", url], check=True, shell=True)
        else:
            click.echo(url)
    except (FileNotFoundError, subprocess.CalledProcessError):
        click.echo(url)

"""Auth commands: login, logout, status, whoami."""

from __future__ import annotations

import click

from ._common import (
    console,
    handle_command,
    maybe_print_structured,
    require_auth,
    structured_output_options,
)


@click.command()
def login() -> None:
    """Extract browser cookies for Reddit authentication"""
    from ..auth import extract_browser_credential, get_credential

    # Check if already logged in
    cred = get_credential()
    if cred:
        console.print("[green]✅ Already authenticated[/green]")
        return

    console.print("[dim]🔍 Searching for Reddit cookies in browsers...[/dim]")
    cred = extract_browser_credential()
    if cred:
        console.print(f"[green]✅ Login successful![/green] ({len(cred.cookies)} cookies extracted)")
    else:
        console.print("[red]❌ No Reddit cookies found.[/red]")
        console.print("  [dim]Please login to reddit.com in your browser first, then retry.[/dim]")


@click.command()
def logout() -> None:
    """Clear saved Reddit cookies"""
    from ..auth import clear_credential

    clear_credential()
    console.print("[green]✅ Credentials cleared[/green]")


@click.command()
@structured_output_options
def status(as_json: bool, as_yaml: bool) -> None:
    """Check authentication status"""
    from ..auth import CREDENTIAL_FILE, get_credential
    from ..client import RedditClient
    from ..session import summarize_session

    cred = get_credential()
    state = summarize_session(RedditClient(cred).session)
    info = {
        "authenticated": state.authenticated,
        "cookie_count": state.cookie_count,
        "credential_file": str(CREDENTIAL_FILE),
        "source": state.source,
        "username": state.username,
        "capabilities": list(state.capabilities),
        "modhash_present": state.modhash_present,
        "last_verified_at": state.last_verified_at,
        "error": state.error,
    }

    if cred:
        with RedditClient(cred) as client:
            result = client.validate_session()
        state = summarize_session(client.session)
        info.update(
            {
                "authenticated": result["authenticated"],
                "username": result.get("username") or state.username,
                "capabilities": result.get("capabilities", list(state.capabilities)),
                "modhash_present": result.get("modhash_present", state.modhash_present),
                "last_verified_at": state.last_verified_at,
                "error": result.get("error"),
            }
        )

    if maybe_print_structured(info, as_json=as_json, as_yaml=as_yaml):
        return

    if info["authenticated"]:
        console.print(f"[green]✅ Authenticated[/green] ({info['cookie_count']} cookies)")
        if info["username"]:
            console.print(f"  [dim]user: {info['username']}[/dim]")
        console.print(f"  [dim]capabilities: {', '.join(info['capabilities']) or '-'}[/dim]")
        console.print(f"  [dim]source: {info['source']}[/dim]")
    else:
        console.print("[yellow]⚠️  Not authenticated[/yellow]")
        if info["error"]:
            console.print(f"  [dim]{info['error']}[/dim]")
        console.print("  [dim]Use 'rdt login' to extract cookies from your browser[/dim]")


@click.command()
@structured_output_options
def whoami(as_json: bool, as_yaml: bool) -> None:
    """Show current user profile (karma, account age)"""
    from rich.panel import Panel

    from ._common import format_time

    cred = require_auth()

    def _render(data: dict) -> None:
        name = data.get("name", "?")
        karma_post = data.get("link_karma", 0)
        karma_comment = data.get("comment_karma", 0)
        total_karma = data.get("total_karma", karma_post + karma_comment)
        created = data.get("created_utc", 0)
        is_gold = "⭐ " if data.get("is_gold") else ""
        is_mod = "🛡️ " if data.get("is_mod") else ""

        text = (
            f"[bold cyan]u/{name}[/bold cyan] {is_gold}{is_mod}\n"
            f"📊 Total karma: {total_karma:,}\n"
            f"   Post: {karma_post:,} · Comment: {karma_comment:,}\n"
            f"📅 Joined: {format_time(created)}\n"
        )

        panel = Panel(text, title="👤 Me", border_style="green")
        console.print(panel)

    def _action(client):
        me = client.get_me()
        name = me.get("name") or client.session.username
        if not name:
            return me
        profile = client.get_user_about(name)
        profile.setdefault("name", name)
        profile["_session"] = {
            "capabilities": sorted(client.session.capabilities),
            "modhash_present": bool(client.session.modhash),
        }
        return profile

    handle_command(cred, action=_action, render=_render, as_json=as_json, as_yaml=as_yaml)

"""Browse commands: feed, subreddit, popular, all, user, open."""

from __future__ import annotations

import logging

import click
from rich.panel import Panel
from rich.table import Table

from ..client import RedditClient
from ..constants import SORT_OPTIONS, TIME_FILTERS
from ..exceptions import RedditApiError
from ..index_cache import save_index
from ..parser import parse_listing, parse_subreddit_info, parse_user_profile
from ._common import (
    console,
    format_score,
    format_time,
    handle_command,
    listing_options,
    maybe_print_structured,
    open_url,
    optional_auth,
    require_auth,
    save_output_to_file,
    structured_output_options,
)

logger = logging.getLogger(__name__)

# Default title truncation length
_TITLE_MAX = 50
_FULL_TITLE_MAX = 200


# ── Helpers ─────────────────────────────────────────────────────────


def _render_post_table(
    posts, title: str,
    show_subreddit: bool = True, full_text: bool = False,
) -> None:
    """Render a list of posts as a Rich table."""
    if not posts:
        console.print("[yellow]No posts found[/yellow]")
        return

    save_index([post.to_dict() for post in posts], source=title[:40])
    max_title = _FULL_TITLE_MAX if full_text else _TITLE_MAX

    table = Table(title=title, show_lines=True)
    table.add_column("#", style="dim", width=3)
    table.add_column("Score", style="yellow", width=6, justify="right")
    if show_subreddit:
        table.add_column("Subreddit", style="magenta", max_width=15)
    table.add_column(
        "Title", style="bold cyan",
        max_width=max_title if not full_text else None,
    )
    table.add_column("Author", style="green", max_width=14)
    table.add_column("💬", style="dim", width=5, justify="right")
    table.add_column("Time", style="dim", max_width=10)

    for i, post in enumerate(posts, 1):
        title_text = post.title or "-"
        if post.stickied:
            title_text = f"📌 {title_text}"
        if post.over_18:
            title_text = f"🔞 {title_text}"
        if post.is_video:
            title_text = f"🎬 {title_text}"

        if not full_text:
            title_text = title_text[:max_title]

        row = [
            str(i),
            format_score(post.score),
        ]
        if show_subreddit:
            row.append(f"r/{post.subreddit or '?'}")
        row.extend([
            title_text,
            (post.author or "-")[:14],
            str(post.num_comments),
            format_time(post.created_utc),
        ])
        table.add_row(*row)

    console.print(table)
    console.print("\n  [dim]💡 Use [bold]rdt show <#>[/bold] to read a post[/dim]")


def _listing_render(
    data: dict, title: str,
    show_subreddit: bool = True, next_cmd: str = "",
    full_text: bool = False,
) -> None:
    """Common render for listing endpoints."""
    listing = parse_listing(data)
    _render_post_table(listing.items, title, show_subreddit=show_subreddit, full_text=full_text)
    cursor = listing.after
    if cursor and next_cmd:
        console.print(f"  [dim]▸ More: {next_cmd} --after {cursor}[/dim]")


def _handle_listing(
    cred, *, action, data_title: str, next_cmd: str = "",
    show_subreddit: bool = True,
    as_json: bool, as_yaml: bool,
    output_file: str | None = None,
    full_text: bool = False,
    compact: bool = False,
) -> None:
    """Unified listing handler with --output/--full-text/--compact support."""
    from ._common import exit_for_error, run_client_action

    try:
        data = run_client_action(cred, action)

        # --output: save to file
        if output_file:
            out_data = data
            if compact:
                out_data = [post.to_dict() for post in parse_listing(data).items]
            save_output_to_file(out_data, output_file)
            return

        # --compact: strip fields for structured output
        if compact:
            data = [post.to_dict() for post in parse_listing(data).items]
            if not as_json and not as_yaml:
                as_yaml = True

        # --json/--yaml: structured output
        if maybe_print_structured(data, as_json=as_json, as_yaml=as_yaml):
            return

        # Rich render
        _listing_render(
            data, data_title,
            show_subreddit=show_subreddit,
            next_cmd=next_cmd,
            full_text=full_text,
        )
    except RedditApiError as exc:
        exit_for_error(exc, as_json=as_json, as_yaml=as_yaml)


def _resolve_current_username(client: RedditClient) -> str:
    """Resolve the current username from an authenticated session."""
    identity = client.get_me()
    username = identity.get("name") or client.session.username
    if not username:
        raise RedditApiError("Unable to resolve current username from session")
    return username


# ── feed ────────────────────────────────────────────────────────────


@click.command()
@click.option("--subs-only", is_flag=True, help="Show only posts from subscribed subreddits (sorted by time)")
@click.option("--max-subs", default=20, type=int, help="Max subscriptions to fetch (default: 20)")
@click.option("-n", "--limit", default=25, type=int, help="Number of posts (default: 25)")
@click.option("--after", default=None, help="Pagination cursor")
@listing_options
def feed(
    subs_only: bool, max_subs: int,
    limit: int, after: str | None,
    as_json: bool, as_yaml: bool,
    output_file: str | None, full_text: bool, compact: bool,
) -> None:
    """Browse your home feed (requires login)"""
    cred = require_auth()
    if subs_only:
        if after:
            console.print("[yellow]⚠ --after is ignored with --subs-only[/yellow]")

        def _progress(current: int, total: int, name: str) -> None:
            if not (as_json or as_yaml):
                console.print(f"  [dim]📡 [{current}/{total}] r/{name}[/dim]")

        _handle_listing(
            cred,
            action=lambda c: c.get_subs_only_feed(
                limit_per_sub=limit, max_subs=max_subs, on_progress=_progress,
            ),
            data_title="📡 Subscriptions Feed",
            next_cmd="",
            as_json=as_json, as_yaml=as_yaml,
            output_file=output_file, full_text=full_text, compact=compact,
        )
    else:
        _handle_listing(
            cred,
            action=lambda c: c.get_home(limit=limit, after=after),
            data_title="🏠 Home Feed",
            next_cmd="rdt feed",
            as_json=as_json, as_yaml=as_yaml,
            output_file=output_file, full_text=full_text, compact=compact,
        )


# ── popular ─────────────────────────────────────────────────────────


@click.command()
@click.option("-n", "--limit", default=25, type=int, help="Number of posts")
@click.option("--after", default=None, help="Pagination cursor")
@listing_options
def popular(
    limit: int, after: str | None,
    as_json: bool, as_yaml: bool,
    output_file: str | None, full_text: bool, compact: bool,
) -> None:
    """Browse /r/popular"""
    cred = optional_auth()
    _handle_listing(
        cred,
        action=lambda c: c.get_popular(limit=limit, after=after),
        data_title="🔥 Popular",
        next_cmd="rdt popular",
        as_json=as_json, as_yaml=as_yaml,
        output_file=output_file, full_text=full_text, compact=compact,
    )


# ── all ─────────────────────────────────────────────────────────────


@click.command(name="all")
@click.option("-n", "--limit", default=25, type=int, help="Number of posts")
@click.option("--after", default=None, help="Pagination cursor")
@listing_options
def all_cmd(
    limit: int, after: str | None,
    as_json: bool, as_yaml: bool,
    output_file: str | None, full_text: bool, compact: bool,
) -> None:
    """Browse /r/all"""
    cred = optional_auth()
    _handle_listing(
        cred,
        action=lambda c: c.get_all(limit=limit, after=after),
        data_title="🌍 r/all",
        next_cmd="rdt all",
        as_json=as_json, as_yaml=as_yaml,
        output_file=output_file, full_text=full_text, compact=compact,
    )


# ── sub (subreddit) ─────────────────────────────────────────────────


@click.command()
@click.argument("subreddit")
@click.option("-s", "--sort", type=click.Choice(SORT_OPTIONS), default="hot", help="Sort order")
@click.option(
    "-t", "--time", "time_filter",
    type=click.Choice(TIME_FILTERS), default=None,
    help="Time filter (for top/controversial)",
)
@click.option("-n", "--limit", default=25, type=int, help="Number of posts")
@click.option("--after", default=None, help="Pagination cursor")
@listing_options
def sub(
    subreddit: str, sort: str, time_filter: str | None, limit: int,
    after: str | None, as_json: bool, as_yaml: bool,
    output_file: str | None, full_text: bool, compact: bool,
) -> None:
    """Browse a subreddit (e.g., rdt sub python)"""
    cred = optional_auth()
    emoji = {"hot": "🔥", "new": "🆕", "top": "🏆", "rising": "📈"}.get(sort, "📋")
    _handle_listing(
        cred,
        action=lambda c: c.get_subreddit(
            subreddit, sort=sort, limit=limit, after=after, time_filter=time_filter,
        ),
        data_title=f"{emoji} r/{subreddit} ({sort})",
        show_subreddit=False,
        next_cmd=f"rdt sub {subreddit} -s {sort}",
        as_json=as_json, as_yaml=as_yaml,
        output_file=output_file, full_text=full_text, compact=compact,
    )


# ── sub-info ────────────────────────────────────────────────────────


@click.command("sub-info")
@click.argument("subreddit")
@structured_output_options
def sub_info(subreddit: str, as_json: bool, as_yaml: bool) -> None:
    """View subreddit info (subscribers, description)"""
    cred = optional_auth()

    def _render(data: dict) -> None:
        info = parse_subreddit_info(data)
        name = info.display_name_prefixed or f"r/{subreddit}"
        desc = info.public_description or info.description
        subs = info.subscribers
        active = info.accounts_active
        created = info.created_utc
        nsfw = "🔞 NSFW" if info.over18 else ""

        text = (
            f"[bold cyan]{name}[/bold cyan] {nsfw}\n"
            f"👥 {subs:,} subscribers · 🟢 {active:,} online\n"
            f"📅 Created: {format_time(created)}\n"
        )
        if desc:
            text += f"\n{desc[:300]}"

        panel = Panel(text, title=f"📋 {name}", border_style="cyan")
        console.print(panel)

    handle_command(
        cred,
        action=lambda c: c.get_subreddit_about(subreddit),
        render=_render, as_json=as_json, as_yaml=as_yaml,
    )


# ── user ────────────────────────────────────────────────────────────


@click.command()
@click.argument("username")
@structured_output_options
def user(username: str, as_json: bool, as_yaml: bool) -> None:
    """View a user's profile"""
    cred = optional_auth()

    def _render(data: dict) -> None:
        profile = parse_user_profile(data)
        name = profile.name or username
        karma_post = profile.link_karma
        karma_comment = profile.comment_karma
        created = profile.created_utc
        is_gold = "⭐ " if profile.is_gold else ""

        text = (
            f"[bold cyan]u/{name}[/bold cyan] {is_gold}\n"
            f"📊 Post karma: {karma_post:,} · Comment karma: {karma_comment:,}\n"
            f"📅 Account age: {format_time(created)}\n"
        )

        panel = Panel(text, title=f"👤 u/{name}", border_style="green")
        console.print(panel)

    handle_command(
        cred, action=lambda c: c.get_user_about(username),
        render=_render, as_json=as_json, as_yaml=as_yaml,
    )


# ── user-posts ──────────────────────────────────────────────────────


@click.command("user-posts")
@click.argument("username")
@click.option("-n", "--limit", default=25, type=int, help="Number of posts")
@click.option("--after", default=None, help="Pagination cursor")
@listing_options
def user_posts(
    username: str, limit: int, after: str | None,
    as_json: bool, as_yaml: bool,
    output_file: str | None, full_text: bool, compact: bool,
) -> None:
    """View a user's submitted posts"""
    cred = optional_auth()
    _handle_listing(
        cred,
        action=lambda c: c.get_user_posts(username, limit=limit, after=after),
        data_title=f"📝 u/{username}'s posts",
        as_json=as_json, as_yaml=as_yaml,
        output_file=output_file, full_text=full_text, compact=compact,
    )


@click.command("user-comments")
@click.argument("username")
@click.option("-n", "--limit", default=25, type=int, help="Number of comments")
@click.option("--after", default=None, help="Pagination cursor")
@listing_options
def user_comments(
    username: str, limit: int, after: str | None,
    as_json: bool, as_yaml: bool,
    output_file: str | None, full_text: bool, compact: bool,
) -> None:
    """View a user's comments"""
    cred = optional_auth()
    _handle_listing(
        cred,
        action=lambda c: c.get_user_comments(username, limit=limit, after=after),
        data_title=f"💬 u/{username}'s comments",
        next_cmd=f"rdt user-comments {username}",
        as_json=as_json, as_yaml=as_yaml,
        output_file=output_file, full_text=full_text, compact=compact,
    )


@click.command()
@click.option("-n", "--limit", default=25, type=int, help="Number of saved items")
@click.option("--after", default=None, help="Pagination cursor")
@listing_options
def saved(
    limit: int, after: str | None,
    as_json: bool, as_yaml: bool,
    output_file: str | None, full_text: bool, compact: bool,
) -> None:
    """Browse your saved posts"""
    cred = require_auth()
    _handle_listing(
        cred,
        action=lambda c: c.get_user_saved(_resolve_current_username(c), limit=limit, after=after),
        data_title="🔖 Saved",
        next_cmd="rdt saved",
        as_json=as_json, as_yaml=as_yaml,
        output_file=output_file, full_text=full_text, compact=compact,
    )


@click.command()
@click.option("-n", "--limit", default=25, type=int, help="Number of upvoted items")
@click.option("--after", default=None, help="Pagination cursor")
@listing_options
def upvoted(
    limit: int, after: str | None,
    as_json: bool, as_yaml: bool,
    output_file: str | None, full_text: bool, compact: bool,
) -> None:
    """Browse your upvoted posts"""
    cred = require_auth()
    _handle_listing(
        cred,
        action=lambda c: c.get_user_upvoted(_resolve_current_username(c), limit=limit, after=after),
        data_title="⬆ Upvoted",
        next_cmd="rdt upvoted",
        as_json=as_json, as_yaml=as_yaml,
        output_file=output_file, full_text=full_text, compact=compact,
    )


# ── open ────────────────────────────────────────────────────────────


@click.command(name="open")
@click.argument("id_or_index")
def open_post(id_or_index: str) -> None:
    """Open a post in the browser (by ID or index number)

    Examples:
      rdt open 3           # open result #3 in browser
      rdt open 1abc123     # open by post ID
    """
    from ..index_cache import get_item_by_index

    # Try as short-index
    try:
        idx = int(id_or_index)
        item = get_item_by_index(idx)
        if item:
            permalink = item.get("permalink", "")
            if permalink:
                url = f"https://reddit.com{permalink}"
                console.print(f"[dim]Opening: {url}[/dim]")
                open_url(url)
                return
        console.print(f"[yellow]Index {idx} not found in cache[/yellow]")
        return
    except ValueError:
        pass

    # Bare ID or URL
    if id_or_index.startswith("http"):
        open_url(id_or_index)
    else:
        url = f"https://reddit.com/comments/{id_or_index}"
        console.print(f"[dim]Opening: {url}[/dim]")
        open_url(url)