Weibo Cli

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

jobs:
  test:
    runs-on: ubuntu-latest
    strategy:
      matrix:
        python-version: ["3.10", "3.12"]
    steps:
      - uses: actions/checkout@v4
      - name: Install uv
        uses: astral-sh/setup-uv@v5
      - name: Set up Python ${{ matrix.python-version }}
        run: uv python install ${{ matrix.python-version }}
      - name: Install dependencies
        run: uv sync --extra dev --extra yaml
      - name: Lint
        run: uv run ruff check .
      - name: Test
        run: uv run pytest tests/ -v --tb=short

name: Publish to PyPI

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

jobs:
  verify:
    uses: ./.github/workflows/ci.yml

  publish:
    needs: verify
    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

.venv/
*.egg-info/
__pycache__/
dist/
uv.lock

[project]
name = "kabi-weibo-cli"
version = "0.2.1"
description = "A CLI for Weibo (微博) — search, browse hot topics, read timelines, explore user profiles from the terminal"
readme = "README.md"
license = "Apache-2.0"
requires-python = ">=3.10"
authors = [{ name = "jackwener", email = "jakevingoo@gmail.com" }]
keywords = ["weibo", "sina", "cli", "terminal", "social-media", "microblog"]
classifiers = [
    "Development Status :: 3 - Alpha",
    "Environment :: Console",
    "License :: OSI Approved :: Apache Software License",
    "Programming Language :: Python :: 3",
    "Topic :: Communications",
]
dependencies = [
    "click>=8.0",
    "rich>=13.0",
    "httpx>=0.27",
    "browser-cookie3>=0.19",
    "qrcode>=7.0",
]

[project.optional-dependencies]
dev = [
    "pytest>=8.0",
    "ruff>=0.11.0",
]
yaml = [
    "pyyaml>=6.0",
]

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

[project.scripts]
weibo = "weibo_cli.cli:cli"

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

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

[tool.pytest.ini_options]
testpaths = ["tests"]
addopts = "-m 'not smoke'"
markers = [
    "smoke: end-to-end tests requiring live cookies (run with: pytest -m smoke)",
]

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

"""Shared test fixtures for Weibo CLI tests."""

from __future__ import annotations

from unittest.mock import MagicMock

import pytest

from weibo_cli.auth import Credential


@pytest.fixture
def mock_credential():
    """A valid fake credential for testing."""
    return Credential(cookies={"SUB": "test_sub", "SUBP": "test_subp", "X-CSRF-TOKEN": "test_csrf"})


@pytest.fixture
def empty_credential():
    """An empty credential for testing."""
    return Credential(cookies={})


@pytest.fixture
def mock_client(mock_credential):
    """A WeiboClient with a mocked httpx.Client — no real network calls."""
    from weibo_cli.client import WeiboClient

    client = WeiboClient.__new__(WeiboClient)
    client.credential = mock_credential
    client._timeout = 30.0
    client._request_delay = 0  # No delay in tests
    client._base_request_delay = 0
    client._max_retries = 1
    client._last_request_time = 0.0
    client._request_count = 0
    client._rate_limit_count = 0
    client._http = MagicMock()
    return client


@pytest.fixture
def hot_search_response():
    """Minimal hot search API response."""
    return {
        "ok": 1,
        "data": {
            "realtime": [
                {
                    "word": "省考",
                    "num": 1160335,
                    "icon_desc": "沸",
                    "rank": 0,
                    "topic_flag": 0,
                },
                {
                    "word": "申论",
                    "num": 814728,
                    "icon_desc": "",
                    "rank": 1,
                    "topic_flag": 0,
                },
            ],
            "hotgov": {
                "word": "#共赴新程之约#",
                "icon_desc": "热",
            },
        },
    }


@pytest.fixture
def profile_response():
    """Minimal profile API response."""
    return {
        "ok": 1,
        "data": {
            "user": {
                "id": 1699432410,
                "idstr": "1699432410",
                "screen_name": "新华社",
                "verified": True,
                "verified_reason": "新华社官方微博",
                "followers_count": 113614253,
                "friends_count": 3089,
                "statuses_count": 195607,
                "description": "新华社官方微博，重大新闻权威首发平台。",
            },
            "tabList": [{"name": "微博", "tabName": "weibo"}],
        },
    }


@pytest.fixture
def weibo_detail_response():
    """Minimal weibo detail API response."""
    return {
        "ok": 1,
        "visible": {"type": 0, "list_id": 0},
        "created_at": "Sat Mar 14 07:20:55 +0800 2026",
        "id": 5276269143133381,
        "idstr": "5276269143133381",
        "mid": "5276269143133381",
        "mblogid": "Qw06Kd98p",
        "user": {
            "id": 1699432410,
            "screen_name": "新华社",
            "verified": True,
        },
        "text_raw": "测试微博正文",
        "source": "微博视频号",
        "reposts_count": 57,
        "comments_count": 114,
        "attitudes_count": 500,
        "reads_count": 1595668,
        "pic_ids": [],
    }

"""Unit tests for auth module — credential persistence, browser extraction, QR flow."""

from __future__ import annotations

import json
import time
from unittest.mock import MagicMock


from weibo_cli.auth import (
    Credential,
    _render_qr_half_blocks,
    clear_credential,
    extract_browser_credential,
    get_credential,
    load_credential,
    save_credential,
)


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


class TestCredential:
    def test_valid_credential(self):
        cred = Credential(cookies={"SUB": "abc", "SUBP": "xyz"})
        assert cred.is_valid

    def test_empty_credential_invalid(self):
        cred = Credential(cookies={})
        assert not cred.is_valid

    def test_to_dict_includes_saved_at(self):
        cred = Credential(cookies={"SUB": "abc"})
        d = cred.to_dict()
        assert "cookies" in d
        assert "saved_at" in d
        assert isinstance(d["saved_at"], float)

    def test_from_dict(self):
        cred = Credential.from_dict({"cookies": {"SUB": "abc"}, "saved_at": 0})
        assert cred.cookies == {"SUB": "abc"}

    def test_from_dict_missing_cookies(self):
        cred = Credential.from_dict({})
        assert cred.cookies == {}
        assert not cred.is_valid

    def test_cookie_header_format(self):
        cred = Credential(cookies={"A": "1", "B": "2"})
        header = cred.as_cookie_header()
        assert "A=1" in header
        assert "B=2" in header
        assert "; " in header

    def test_roundtrip(self):
        original = Credential(cookies={"SUB": "abc", "SUBP": "xyz", "X-CSRF-TOKEN": "csrf"})
        d = original.to_dict()
        restored = Credential.from_dict(d)
        assert restored.cookies == original.cookies


# ── Credential persistence ──────────────────────────────────────────


class TestCredentialPersistence:
    def test_save_and_load(self, tmp_path, monkeypatch):
        monkeypatch.setattr("weibo_cli.auth.CONFIG_DIR", tmp_path)
        monkeypatch.setattr("weibo_cli.auth.CREDENTIAL_FILE", tmp_path / "credential.json")

        cred = Credential(cookies={"SUB": "test_sub"})
        save_credential(cred)

        loaded = load_credential()
        assert loaded is not None
        assert loaded.cookies == {"SUB": "test_sub"}

    def test_load_nonexistent(self, tmp_path, monkeypatch):
        monkeypatch.setattr("weibo_cli.auth.CREDENTIAL_FILE", tmp_path / "nonexistent.json")
        assert load_credential() is None

    def test_load_invalid_json(self, tmp_path, monkeypatch):
        cred_file = tmp_path / "credential.json"
        cred_file.write_text("not valid json!!!")
        monkeypatch.setattr("weibo_cli.auth.CREDENTIAL_FILE", cred_file)
        assert load_credential() is None

    def test_load_empty_cookies(self, tmp_path, monkeypatch):
        cred_file = tmp_path / "credential.json"
        cred_file.write_text(json.dumps({"cookies": {}, "saved_at": time.time()}))
        monkeypatch.setattr("weibo_cli.auth.CREDENTIAL_FILE", cred_file)
        assert load_credential() is None

    def test_clear_credential(self, tmp_path, monkeypatch):
        cred_file = tmp_path / "credential.json"
        cred_file.write_text("{}")
        monkeypatch.setattr("weibo_cli.auth.CREDENTIAL_FILE", cred_file)
        clear_credential()
        assert not cred_file.exists()

    def test_clear_nonexistent(self, tmp_path, monkeypatch):
        monkeypatch.setattr("weibo_cli.auth.CREDENTIAL_FILE", tmp_path / "nonexistent.json")
        # Should not raise
        clear_credential()

    def test_load_triggers_refresh_when_stale(self, tmp_path, monkeypatch):
        cred_file = tmp_path / "credential.json"
        old_time = time.time() - (8 * 86400)  # 8 days ago
        cred_file.write_text(json.dumps({"cookies": {"SUB": "old"}, "saved_at": old_time}))
        monkeypatch.setattr("weibo_cli.auth.CONFIG_DIR", tmp_path)
        monkeypatch.setattr("weibo_cli.auth.CREDENTIAL_FILE", cred_file)

        fresh_cred = Credential(cookies={"SUB": "fresh"})
        monkeypatch.setattr("weibo_cli.auth.extract_browser_credential", lambda: fresh_cred)

        loaded = load_credential()
        assert loaded is not None
        assert loaded.cookies["SUB"] == "fresh"

    def test_load_uses_old_when_refresh_fails(self, tmp_path, monkeypatch):
        cred_file = tmp_path / "credential.json"
        old_time = time.time() - (8 * 86400)
        cred_file.write_text(json.dumps({"cookies": {"SUB": "old"}, "saved_at": old_time}))
        monkeypatch.setattr("weibo_cli.auth.CONFIG_DIR", tmp_path)
        monkeypatch.setattr("weibo_cli.auth.CREDENTIAL_FILE", cred_file)
        monkeypatch.setattr("weibo_cli.auth.extract_browser_credential", lambda: None)

        loaded = load_credential()
        assert loaded is not None
        assert loaded.cookies["SUB"] == "old"

    def test_file_permissions(self, tmp_path, monkeypatch):
        monkeypatch.setattr("weibo_cli.auth.CONFIG_DIR", tmp_path)
        monkeypatch.setattr("weibo_cli.auth.CREDENTIAL_FILE", tmp_path / "credential.json")

        save_credential(Credential(cookies={"SUB": "test"}))
        perms = (tmp_path / "credential.json").stat().st_mode & 0o777
        assert perms == 0o600


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


class TestBrowserExtraction:
    def test_extraction_success(self, monkeypatch, tmp_path):
        monkeypatch.setattr("weibo_cli.auth.CONFIG_DIR", tmp_path)
        monkeypatch.setattr("weibo_cli.auth.CREDENTIAL_FILE", tmp_path / "credential.json")

        mock_result = MagicMock()
        mock_result.returncode = 0
        mock_result.stdout = json.dumps({"browser": "Chrome", "cookies": {"SUB": "extracted"}})

        monkeypatch.setattr("subprocess.run", lambda *a, **kw: mock_result)
        cred = extract_browser_credential()
        assert cred is not None
        assert cred.cookies["SUB"] == "extracted"

    def test_extraction_no_cookies(self, monkeypatch):
        mock_result = MagicMock()
        mock_result.returncode = 0
        mock_result.stdout = json.dumps({"error": "no_cookies"})

        monkeypatch.setattr("subprocess.run", lambda *a, **kw: mock_result)
        assert extract_browser_credential() is None

    def test_extraction_not_installed(self, monkeypatch):
        mock_result = MagicMock()
        mock_result.returncode = 0
        mock_result.stdout = json.dumps({"error": "not_installed"})

        monkeypatch.setattr("subprocess.run", lambda *a, **kw: mock_result)
        assert extract_browser_credential() is None

    def test_extraction_subprocess_failure(self, monkeypatch):
        mock_result = MagicMock()
        mock_result.returncode = 1
        mock_result.stderr = "error"

        monkeypatch.setattr("subprocess.run", lambda *a, **kw: mock_result)
        assert extract_browser_credential() is None

    def test_extraction_timeout(self, monkeypatch):
        import subprocess
        monkeypatch.setattr("subprocess.run", lambda *a, **kw: (_ for _ in ()).throw(subprocess.TimeoutExpired("cmd", 15)))
        assert extract_browser_credential() is None

    def test_extraction_invalid_json(self, monkeypatch):
        mock_result = MagicMock()
        mock_result.returncode = 0
        mock_result.stdout = "not json"

        monkeypatch.setattr("subprocess.run", lambda *a, **kw: mock_result)
        assert extract_browser_credential() is None

    def test_extraction_with_cookie_source(self, monkeypatch, tmp_path):
        monkeypatch.setattr("weibo_cli.auth.CONFIG_DIR", tmp_path)
        monkeypatch.setattr("weibo_cli.auth.CREDENTIAL_FILE", tmp_path / "credential.json")

        captured_cmd = {}

        def fake_run(cmd, **kw):
            captured_cmd["args"] = cmd
            result = MagicMock()
            result.returncode = 0
            result.stdout = json.dumps({"browser": "Firefox", "cookies": {"SUB": "fx"}})
            return result

        monkeypatch.setattr("subprocess.run", fake_run)
        cred = extract_browser_credential(cookie_source="Firefox")
        assert cred is not None
        assert "Firefox" in captured_cmd["args"]


# ── get_credential chain ────────────────────────────────────────────


class TestGetCredential:
    def test_returns_saved_first(self, monkeypatch):
        saved = Credential(cookies={"SUB": "saved"})
        monkeypatch.setattr("weibo_cli.auth.load_credential", lambda: saved)
        monkeypatch.setattr("weibo_cli.auth.extract_browser_credential", lambda: None)

        result = get_credential()
        assert result.cookies["SUB"] == "saved"

    def test_falls_back_to_browser(self, monkeypatch):
        browser_cred = Credential(cookies={"SUB": "browser"})
        monkeypatch.setattr("weibo_cli.auth.load_credential", lambda: None)
        monkeypatch.setattr("weibo_cli.auth.extract_browser_credential", lambda: browser_cred)

        result = get_credential()
        assert result.cookies["SUB"] == "browser"

    def test_returns_none_when_all_fail(self, monkeypatch):
        monkeypatch.setattr("weibo_cli.auth.load_credential", lambda: None)
        monkeypatch.setattr("weibo_cli.auth.extract_browser_credential", lambda: None)

        assert get_credential() is None


# ── QR rendering ────────────────────────────────────────────────────


class TestQRRendering:
    def test_render_empty_matrix(self):
        assert _render_qr_half_blocks([]) == ""

    def test_render_small_matrix(self):
        matrix = [
            [True, False],
            [False, True],
        ]
        result = _render_qr_half_blocks(matrix)
        assert isinstance(result, str)
        assert len(result) > 0

    def test_render_all_true(self):
        # 4x4 matrix ensures full blocks survive the quiet zone padding
        matrix = [[True]*4 for _ in range(4)]
        result = _render_qr_half_blocks(matrix)
        assert "█" in result

    def test_render_all_false(self):
        matrix = [[False, False], [False, False]]
        result = _render_qr_half_blocks(matrix)
        # Should produce spaces (with quiet zone)
        assert isinstance(result, str)

"""Tests for Weibo CLI — importability, command registration, and output format."""

from __future__ import annotations

import pytest
from click.testing import CliRunner

from weibo_cli.cli import cli


# ── Import & registration tests ─────────────────────────────────────


def test_import_cli():
    """CLI module is importable."""
    from weibo_cli import cli as cli_mod
    assert cli_mod is not None


def test_help():
    runner = CliRunner()
    result = runner.invoke(cli, ["--help"])
    assert result.exit_code == 0
    assert "Weibo CLI" in result.output


def test_version():
    runner = CliRunner()
    result = runner.invoke(cli, ["--version"])
    assert result.exit_code == 0
    assert "0.2.1" in result.output


EXPECTED_COMMANDS = [
    "login", "logout", "status", "me",
    "hot", "feed", "detail", "comments", "trending", "search",
    "profile", "weibos", "following", "followers", "reposts", "home",
]


@pytest.mark.parametrize("cmd", EXPECTED_COMMANDS)
def test_command_registered(cmd):
    """All expected commands are registered."""
    runner = CliRunner()
    result = runner.invoke(cli, [cmd, "--help"])
    assert result.exit_code == 0, f"{cmd} --help failed: {result.output}"


def test_command_count():
    """Ensure we have exactly the expected number of commands."""
    assert len(cli.commands) == len(EXPECTED_COMMANDS)


# ── Constants tests ─────────────────────────────────────────────────


def test_constants_urls():
    from weibo_cli.constants import BASE_URL, PASSPORT_URL, HOT_SEARCH_URL
    assert BASE_URL == "https://weibo.com"
    assert PASSPORT_URL == "https://passport.weibo.com"
    assert HOT_SEARCH_URL.startswith("/ajax/")


def test_constants_headers():
    from weibo_cli.constants import HEADERS
    assert "User-Agent" in HEADERS
    assert "Chrome" in HEADERS["User-Agent"]


# ── Exception tests ─────────────────────────────────────────────────


def test_exception_hierarchy():
    from weibo_cli.exceptions import WeiboApiError, SessionExpiredError, QRExpiredError, error_code_for_exception
    assert issubclass(SessionExpiredError, WeiboApiError)
    assert issubclass(QRExpiredError, WeiboApiError)
    assert error_code_for_exception(SessionExpiredError()) == "not_authenticated"
    assert error_code_for_exception(QRExpiredError()) == "qr_expired"


def test_all_error_codes():
    from weibo_cli.exceptions import (
        AuthRequiredError, ParamError, RateLimitError, error_code_for_exception
    )
    assert error_code_for_exception(AuthRequiredError()) == "not_authenticated"
    assert error_code_for_exception(RateLimitError()) == "rate_limited"
    assert error_code_for_exception(ParamError("test")) == "invalid_params"
    assert error_code_for_exception(ValueError("test")) == "unknown_error"


# ── Command help text ───────────────────────────────────────────────


@pytest.mark.parametrize("cmd,expected_text", [
    ("hot", "热搜"),
    ("feed", "Feed"),
    ("detail", "详情"),
    ("comments", "评论"),
    ("trending", "趋势"),
    ("search", "搜索"),
    ("profile", "用户资料"),
    ("weibos", "微博列表"),
    ("following", "关注列表"),
    ("followers", "粉丝列表"),
    ("reposts", "转发"),
    ("home", "关注者"),
])
def test_command_help_text(cmd, expected_text):
    """Each command has appropriate help description."""
    runner = CliRunner()
    result = runner.invoke(cli, [cmd, "--help"])
    assert expected_text in result.output


@pytest.mark.parametrize("cmd", ["hot", "feed", "detail", "comments", "trending", "search", "profile", "weibos", "following", "followers", "reposts", "home"])
def test_json_option_available(cmd):
    """All data commands support --json flag."""
    runner = CliRunner()
    result = runner.invoke(cli, [cmd, "--help"])
    assert "--json" in result.output

"""Unit tests for WeiboClient — mock all API methods, verify URL/params/response handling."""

from __future__ import annotations

import json
from unittest.mock import MagicMock

import httpx
import pytest

from weibo_cli.client import WeiboClient
from weibo_cli.exceptions import SessionExpiredError, WeiboApiError


# ── Response handling ────────────────────────────────────────────────


class TestHandleResponse:
    def test_ok_1_with_data_key(self, mock_client):
        raw = {"ok": 1, "data": {"realtime": [{"word": "test"}]}}
        result = mock_client._handle_response(raw, "test")
        assert result == {"realtime": [{"word": "test"}]}

    def test_ok_1_without_data_key(self, mock_client):
        raw = {"ok": 1, "statuses": []}
        result = mock_client._handle_response(raw, "test")
        assert result == raw

    def test_ok_minus_100_raises_session_expired(self, mock_client):
        raw = {"ok": -100, "url": "https://weibo.com/login.php"}
        with pytest.raises(SessionExpiredError):
            mock_client._handle_response(raw, "test")

    def test_ok_0_login_message_raises_session_expired(self, mock_client):
        raw = {"ok": 0, "message": "请先登录"}
        with pytest.raises(SessionExpiredError):
            mock_client._handle_response(raw, "test")

    def test_ok_0_login_后使用_raises_session_expired(self, mock_client):
        raw = {"ok": 0, "message": "请登录后使用"}
        with pytest.raises(SessionExpiredError):
            mock_client._handle_response(raw, "test")

    def test_ok_0_generic_error(self, mock_client):
        raw = {"ok": 0, "message": "参数错误"}
        with pytest.raises(WeiboApiError, match="参数错误"):
            mock_client._handle_response(raw, "test")


# ── Context manager ─────────────────────────────────────────────────


class TestContextManager:
    def test_enter_creates_client(self, mock_credential):
        client = WeiboClient(mock_credential, request_delay=0)
        with client as c:
            assert c.client is not None
            assert c._http is not None

    def test_exit_closes_client(self, mock_credential):
        client = WeiboClient(mock_credential, request_delay=0)
        with client:
            pass
        assert client._http is None

    def test_client_without_context_raises(self, mock_credential):
        client = WeiboClient(mock_credential, request_delay=0)
        with pytest.raises(RuntimeError, match="not initialized"):
            _ = client.client


# ── Rate limiting ────────────────────────────────────────────────────


class TestRateLimiting:
    def test_mark_request_increments_counter(self, mock_client):
        assert mock_client._request_count == 0
        mock_client._mark_request()
        assert mock_client._request_count == 1
        mock_client._mark_request()
        assert mock_client._request_count == 2


# ── API method tests (mocked HTTP) ──────────────────────────────────


class TestHotSearchAPI:
    def test_get_hot_search_calls_correct_url(self, mock_client, hot_search_response):
        mock_resp = MagicMock()
        mock_resp.status_code = 200
        mock_resp.text = json.dumps(hot_search_response)
        mock_resp.json.return_value = hot_search_response
        mock_resp.cookies = httpx.Cookies()
        mock_client._http.request.return_value = mock_resp

        result = mock_client.get_hot_search()
        assert "realtime" in result
        assert len(result["realtime"]) == 2
        assert result["realtime"][0]["word"] == "省考"

        # Verify correct URL was called
        call_args = mock_client._http.request.call_args
        assert call_args[0][0] == "GET"
        assert "/ajax/side/hotSearch" in call_args[0][1]


class TestProfileAPI:
    def test_get_profile_passes_uid(self, mock_client, profile_response):
        mock_resp = MagicMock()
        mock_resp.status_code = 200
        mock_resp.text = json.dumps(profile_response)
        mock_resp.json.return_value = profile_response
        mock_resp.cookies = httpx.Cookies()
        mock_client._http.request.return_value = mock_resp

        result = mock_client.get_profile("1699432410")
        assert result["user"]["screen_name"] == "新华社"

        call_args = mock_client._http.request.call_args
        assert "/ajax/profile/info" in call_args[0][1]
        params = call_args[1].get("params", {})
        assert params["uid"] == "1699432410"


class TestWeiboDetailAPI:
    def test_get_weibo_detail(self, mock_client, weibo_detail_response):
        mock_resp = MagicMock()
        mock_resp.status_code = 200
        mock_resp.text = json.dumps(weibo_detail_response)
        mock_resp.json.return_value = weibo_detail_response
        mock_resp.cookies = httpx.Cookies()
        mock_client._http.request.return_value = mock_resp

        result = mock_client.get_weibo_detail("Qw06Kd98p")
        assert result["mblogid"] == "Qw06Kd98p"
        assert result["user"]["screen_name"] == "新华社"

        call_args = mock_client._http.request.call_args
        assert "/ajax/statuses/show" in call_args[0][1]
        params = call_args[1].get("params", {})
        assert params["id"] == "Qw06Kd98p"


class TestHotTimelineAPI:
    def test_get_hot_timeline_default_params(self, mock_client):
        hot_response = {"ok": 1, "statuses": [], "max_id": "0"}
        mock_resp = MagicMock()
        mock_resp.status_code = 200
        mock_resp.text = json.dumps(hot_response)
        mock_resp.json.return_value = hot_response
        mock_resp.cookies = httpx.Cookies()
        mock_client._http.request.return_value = mock_resp

        result = mock_client.get_hot_timeline()
        assert "statuses" in result

        call_args = mock_client._http.request.call_args
        params = call_args[1].get("params", {})
        assert params["group_id"] == "102803"
        assert params["count"] == "10"

    def test_get_hot_timeline_custom_count(self, mock_client):
        hot_response = {"ok": 1, "statuses": [], "max_id": "0"}
        mock_resp = MagicMock()
        mock_resp.status_code = 200
        mock_resp.text = json.dumps(hot_response)
        mock_resp.json.return_value = hot_response
        mock_resp.cookies = httpx.Cookies()
        mock_client._http.request.return_value = mock_resp

        mock_client.get_hot_timeline(count=5)
        params = mock_client._http.request.call_args[1].get("params", {})
        assert params["count"] == "5"


class TestCommentsAPI:
    def test_get_comments_default_params(self, mock_client):
        comments_response = {"ok": 1, "data": [], "max_id": 0}
        mock_resp = MagicMock()
        mock_resp.status_code = 200
        mock_resp.text = json.dumps(comments_response)
        mock_resp.json.return_value = comments_response
        mock_resp.cookies = httpx.Cookies()
        mock_client._http.request.return_value = mock_resp

        mock_client.get_comments("12345")
        params = mock_client._http.request.call_args[1].get("params", {})
        assert params["id"] == "12345"
        assert params["count"] == "20"
        assert "max_id" not in params

    def test_get_comments_with_max_id(self, mock_client):
        comments_response = {"ok": 1, "data": [], "max_id": 0}
        mock_resp = MagicMock()
        mock_resp.status_code = 200
        mock_resp.text = json.dumps(comments_response)
        mock_resp.json.return_value = comments_response
        mock_resp.cookies = httpx.Cookies()
        mock_client._http.request.return_value = mock_resp

        mock_client.get_comments("12345", max_id=999)
        params = mock_client._http.request.call_args[1].get("params", {})
        assert params["max_id"] == "999"


class TestRepostsAPI:
    def test_get_reposts(self, mock_client):
        reposts_response = {"ok": 1, "data": [], "total_number": 0}
        mock_resp = MagicMock()
        mock_resp.status_code = 200
        mock_resp.text = json.dumps(reposts_response)
        mock_resp.json.return_value = reposts_response
        mock_resp.cookies = httpx.Cookies()
        mock_client._http.request.return_value = mock_resp

        mock_client.get_reposts("12345", page=2)
        params = mock_client._http.request.call_args[1].get("params", {})
        assert params["id"] == "12345"
        assert params["page"] == "2"


# ── Retry behavior ──────────────────────────────────────────────────


class TestRetryBehavior:
    def test_retries_on_timeout(self, mock_client):
        mock_client._max_retries = 2
        mock_client._http.request.side_effect = httpx.TimeoutException("timeout")

        with pytest.raises(WeiboApiError, match="failed after"):
            mock_client._request("GET", "/ajax/test")

        assert mock_client._http.request.call_count == 2

    def test_retries_on_server_error(self, mock_client):
        mock_client._max_retries = 2
        error_resp = MagicMock()
        error_resp.status_code = 502
        error_resp.cookies = httpx.Cookies()
        mock_client._http.request.return_value = error_resp

        success_resp = MagicMock()
        success_resp.status_code = 200
        success_resp.text = '{"ok": 1}'
        success_resp.json.return_value = {"ok": 1}
        success_resp.cookies = httpx.Cookies()

        mock_client._http.request.side_effect = [error_resp, success_resp]
        result = mock_client._request("GET", "/ajax/test")
        assert result == {"ok": 1}

    def test_html_response_raises_error(self, mock_client):
        html_resp = MagicMock()
        html_resp.status_code = 200
        html_resp.text = "<html>Login Required</html>"
        html_resp.cookies = httpx.Cookies()
        html_resp.raise_for_status.return_value = None
        mock_client._http.request.return_value = html_resp

        with pytest.raises(WeiboApiError, match="HTML"):
            mock_client._request("GET", "/ajax/test")


# ── Cookie merging ───────────────────────────────────────────────────


class TestCookieMerging:
    def test_merge_response_cookies(self, mock_credential):
        """Verify that response cookies are merged back into the session."""
        client = WeiboClient(mock_credential, request_delay=0)
        with client:
            resp = MagicMock()
            resp.cookies = httpx.Cookies()
            resp.cookies.set("NEW_COOKIE", "new_value")
            client._merge_response_cookies(resp)
            assert client.client.cookies.get("NEW_COOKIE") == "new_value"

"""Tests for _common.py utilities and new API methods."""

from __future__ import annotations

import json
from unittest.mock import MagicMock, patch

import httpx
import pytest

from weibo_cli.commands._common import format_count, strip_html
from weibo_cli.exceptions import SessionExpiredError, WeiboApiError


# ── strip_html tests ─────────────────────────────────────────────────


class TestStripHtml:
    def test_basic_tags(self):
        assert strip_html("<b>hello</b>") == "hello"

    def test_nested_tags(self):
        assert strip_html("<a href='#'><span>link</span></a>") == "link"

    def test_empty_string(self):
        assert strip_html("") == ""

    def test_none_input(self):
        assert strip_html(None) == ""

    def test_no_tags(self):
        assert strip_html("plain text") == "plain text"

    def test_self_closing_tags(self):
        assert strip_html("hello<br/>world") == "helloworld"

    def test_mixed_content(self):
        assert strip_html("Hello <b>world</b>! <i>Good</i>") == "Hello world! Good"


# ── format_count tests ──────────────────────────────────────────────


class TestFormatCount:
    def test_small_number(self):
        assert format_count(1000) == "1000"

    def test_exact_10000(self):
        assert format_count(10000) == "1.0万"

    def test_large_number(self):
        assert format_count(113614253) == "11361.4万"

    def test_string_input(self):
        assert format_count("5000") == "5000"

    def test_string_large(self):
        assert format_count("50000") == "5.0万"

    def test_invalid_string(self):
        assert format_count("abc") == "abc"

    def test_none_input(self):
        assert format_count(None) == "None"

    def test_zero(self):
        assert format_count(0) == "0"


# ── _handle_response unwrap tests ────────────────────────────────────


class TestHandleResponseUnwrap:
    def test_unwrap_true_extracts_data(self, mock_client):
        raw = {"ok": 1, "data": {"items": [1, 2, 3]}}
        result = mock_client._handle_response(raw, "test", unwrap=True)
        assert result == {"items": [1, 2, 3]}

    def test_unwrap_false_returns_full(self, mock_client):
        raw = {"ok": 1, "data": {"items": [1, 2, 3]}}
        result = mock_client._handle_response(raw, "test", unwrap=False)
        assert result == raw

    def test_unwrap_false_with_raw_api(self, mock_client):
        """APIs like statuses/show return data at top level, not wrapped."""
        raw = {"ok": 1, "mblogid": "abc", "text": "hello"}
        result = mock_client._handle_response(raw, "test", unwrap=False)
        assert result == raw
        assert result["mblogid"] == "abc"

    def test_session_expired_precise_match(self, mock_client):
        """Only precise keywords should trigger SessionExpiredError."""
        raw = {"ok": 0, "message": "请先登录"}
        with pytest.raises(SessionExpiredError):
            mock_client._handle_response(raw, "test")

    def test_login_related_not_falsely_matched(self, mock_client):
        """Messages containing '登录' but not matching keywords should raise WeiboApiError."""
        raw = {"ok": 0, "message": "登录设备异常"}
        with pytest.raises(WeiboApiError, match="登录设备异常"):
            mock_client._handle_response(raw, "test")


# ── New API method tests ─────────────────────────────────────────────


def _mock_response(data):
    """Create a mock httpx response for the given data."""
    resp = MagicMock()
    resp.status_code = 200
    resp.text = json.dumps(data)
    resp.json.return_value = data
    resp.cookies = httpx.Cookies()
    return resp


class TestGetFollowersAPI:
    def test_get_followers_passes_params(self, mock_client):
        response = {"ok": 1, "users": [{"screen_name": "test"}]}
        mock_client._http.request.return_value = _mock_response(response)

        result = mock_client.get_followers("12345", page=2)
        params = mock_client._http.request.call_args[1].get("params", {})
        assert params["uid"] == "12345"
        assert params["page"] == "2"
        assert params["relate"] == "fans"
        assert "users" in result


class TestGetFriendsTimelineAPI:
    def test_get_friends_timeline_default(self, mock_client):
        response = {"ok": 1, "statuses": [], "max_id": "0"}
        mock_client._http.request.return_value = _mock_response(response)

        result = mock_client.get_friends_timeline()
        params = mock_client._http.request.call_args[1].get("params", {})
        assert params["count"] == "20"
        assert params["max_id"] == "0"
        assert "statuses" in result


class TestGetFollowingAPI:
    def test_get_following_passes_uid(self, mock_client):
        response = {"ok": 1, "users": []}
        mock_client._http.request.return_value = _mock_response(response)

        mock_client.get_following("12345")
        params = mock_client._http.request.call_args[1].get("params", {})
        assert params["uid"] == "12345"
        assert params["page"] == "1"


class TestGetConfigAPI:
    def test_get_config_returns_data(self, mock_client):
        response = {"ok": 1, "data": {"uid": "12345", "login": True}}
        mock_client._http.request.return_value = _mock_response(response)

        result = mock_client.get_config()
        assert result["uid"] == "12345"


class TestSearchWeiboAPI:
    def test_search_weibo_uses_mobile_client(self, mock_client):
        """Verify search_weibo creates a separate mobile client."""
        search_response = {"ok": 1, "data": {"cards": []}}
        mock_mobile = MagicMock()
        mock_mobile.__enter__ = MagicMock(return_value=mock_mobile)
        mock_mobile.__exit__ = MagicMock(return_value=False)
        mock_mobile.request.return_value = _mock_response(search_response)

        with patch.object(mock_client, '_build_mobile_client', return_value=mock_mobile):
            result = mock_client.search_weibo("test")

        assert result == search_response
        mock_mobile.request.assert_called_once()
        call_args = mock_mobile.request.call_args
        assert call_args[1]["params"]["containerid"] == "100103type=1&q=test"

"""Smoke tests for Weibo CLI — require live browser cookies.

Run with: uv run pytest tests/test_smoke.py -v -m smoke
"""

from __future__ import annotations

import json

import pytest
from click.testing import CliRunner

from weibo_cli.cli import cli


runner = CliRunner()


@pytest.mark.smoke
def test_hot_search_live():
    """Hot search returns 50+ items."""
    result = runner.invoke(cli, ["hot", "--json"])
    assert result.exit_code == 0, f"stdout: {result.output}"
    data = json.loads(result.output)
    assert "realtime" in data
    assert len(data["realtime"]) > 10


@pytest.mark.smoke
def test_trending_live():
    """Trending sidebar returns items."""
    result = runner.invoke(cli, ["trending", "--json"])
    assert result.exit_code == 0, f"stdout: {result.output}"
    data = json.loads(result.output)
    assert "realtime" in data
    assert len(data["realtime"]) > 0


@pytest.mark.smoke
def test_detail_live():
    """Weibo detail returns full data."""
    result = runner.invoke(cli, ["detail", "Qw06Kd98p", "--json"])
    assert result.exit_code == 0, f"stdout: {result.output}"
    data = json.loads(result.output)
    assert "user" in data
    assert data["user"]["screen_name"] == "新华社"
    assert "text_raw" in data or "text" in data


@pytest.mark.smoke
def test_profile_live():
    """Profile returns user data with stats."""
    result = runner.invoke(cli, ["profile", "1699432410", "--json"])
    assert result.exit_code == 0, f"stdout: {result.output}"
    data = json.loads(result.output)
    assert "user" in data
    user = data["user"]
    assert user["screen_name"] == "新华社"
    assert user["followers_count"] > 0


@pytest.mark.smoke
def test_feed_live():
    """Hot feed returns statuses."""
    result = runner.invoke(cli, ["feed", "--count", "3", "--json"])
    assert result.exit_code == 0, f"stdout: {result.output}"
    data = json.loads(result.output)
    assert "statuses" in data


@pytest.mark.smoke
def test_status_live():
    """Status command reports login state."""
    result = runner.invoke(cli, ["status"])
    assert result.exit_code == 0
    # Should contain either 已登录 or 未登录
    assert "已登录" in result.output or "未登录" in result.output

"""Weibo CLI."""
__version__ = "0.2.1"

"""Allow ``python -m weibo_cli`` to invoke the CLI."""

from weibo_cli.cli import cli

if __name__ == "__main__":
    cli()

"""Authentication for Weibo.

Strategy:
1. Try loading saved credential from ~/.config/weibo-cli/credential.json
2. Try extracting cookies from local browsers via browser-cookie3
3. Fallback: QR code login in terminal

QR Login Flow (reverse-engineered from passport.weibo.com):
1. GET  /sso/signin → obtain X-CSRF-TOKEN cookie
2. GET  /sso/v2/qrcode/image → get qrid + QR image URL
3. Render QR code in terminal (data = scan URL with qrid)
4. Poll GET /sso/v2/qrcode/check every 2s until success
5. On success, follow crossdomain URL to obtain session cookies
"""

from __future__ import annotations

import json
import logging
import shutil
import subprocess
import sys
import time
from typing import Any
from urllib.parse import parse_qs, urlparse

import httpx
import qrcode

from .constants import (
    CONFIG_DIR,
    CREDENTIAL_FILE,
    PASSPORT_HEADERS,
    PASSPORT_URL,
    QR_CHECK_URL,
    QR_ENTRY,
    QR_IMAGE_URL,
    QR_REDIRECT_URL,
    QR_SOURCE,
    QR_VERSION,
    RETCODE_QR_NOT_SCANNED,
    RETCODE_SUCCESS,
    SSO_SIGNIN_URL,
)
from .exceptions import QRExpiredError

logger = logging.getLogger(__name__)

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

# QR poll config
POLL_INTERVAL_S = 2
POLL_TIMEOUT_S = 240  # 4 minutes


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


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

    def __init__(self, cookies: dict[str, str]):
        self.cookies = cookies

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

    def to_dict(self) -> dict[str, Any]:
        return {"cookies": self.cookies, "saved_at": time.time()}

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

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


# ── Credential persistence ──────────────────────────────────────────


def save_credential(credential: Credential) -> None:
    """Save credential to config file."""
    CONFIG_DIR.mkdir(parents=True, exist_ok=True)
    CREDENTIAL_FILE.write_text(json.dumps(credential.to_dict(), indent=2, ensure_ascii=False))
    CREDENTIAL_FILE.chmod(0o600)
    logger.info("Credential saved to %s", CREDENTIAL_FILE)


def load_credential() -> Credential | None:
    """Load credential from saved file 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

        # Check TTL — 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 (age: %d+ days)", CREDENTIAL_TTL_DAYS)
        return cred
    except (json.JSONDecodeError, KeyError) as e:
        logger.warning("Failed to load saved credential: %s", e)
    return None


def clear_credential() -> None:
    """Remove saved credential file."""
    if CREDENTIAL_FILE.exists():
        CREDENTIAL_FILE.unlink()
        logger.info("Credential removed: %s", CREDENTIAL_FILE)


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


def extract_browser_credential(cookie_source: str | None = None) -> Credential | None:
    """Extract Weibo cookies from local browsers via browser-cookie3."""
    extract_script = '''
import json, sys
try:
    import browser_cookie3 as bc3
except ImportError:
    print(json.dumps({"error": "not_installed"}))
    sys.exit(0)

target = sys.argv[1] if len(sys.argv) > 1 else None

browsers = [
    ("Chrome", bc3.chrome),
    ("Firefox", bc3.firefox),
    ("Edge", bc3.edge),
    ("Brave", bc3.brave),
    ("Chromium", bc3.chromium),
    ("Opera", bc3.opera),
    ("Vivaldi", bc3.vivaldi),
]

for name, attr in [("Arc", "arc"), ("Safari", "safari"), ("LibreWolf", "librewolf")]:
    fn = getattr(bc3, attr, None)
    if fn:
        browsers.append((name, fn))

if target:
    target_lower = target.lower()
    browsers = [(n, fn) for n, fn in browsers if n.lower() == target_lower]
    if not browsers:
        print(json.dumps({"error": f"unsupported_browser: {target}"}))
        sys.exit(0)

for name, loader in browsers:
    try:
        cj = loader(domain_name=".weibo.com")
        cookies = {c.name: c.value for c in cj if "weibo.com" in (c.domain or "") or "sina.com" in (c.domain or "")}
        if cookies:
            print(json.dumps({"browser": name, "cookies": cookies}))
            sys.exit(0)
    except Exception:
        pass

print(json.dumps({"error": "no_cookies"}))
'''

    try:
        cmd = [sys.executable, "-c", extract_script]
        if cookie_source:
            cmd.append(cookie_source)

        result = subprocess.run(cmd, capture_output=True, text=True, timeout=15)

        if result.returncode != 0:
            logger.debug("Cookie extraction subprocess failed: %s", result.stderr)
            return None

        output = result.stdout.strip()
        if not output:
            return None

        data = json.loads(output)
        if "error" in data:
            if data["error"] == "not_installed":
                logger.debug("browser-cookie3 not installed, skipping")
            else:
                logger.debug("No valid Weibo cookies found: %s", data["error"])
            return None

        cookies = data["cookies"]
        browser_name = data["browser"]
        logger.info("Found cookies in %s (%d cookies)", browser_name, len(cookies))
        cred = Credential(cookies=cookies)
        save_credential(cred)
        return cred

    except subprocess.TimeoutExpired:
        logger.warning("Cookie extraction timed out (browser may be running)")
        return None
    except (json.JSONDecodeError, KeyError) as e:
        logger.warning("Cookie extraction parse error: %s", e)
        return None


# ── QR Code terminal rendering ──────────────────────────────────────


def _render_qr_half_blocks(matrix: list[list[bool]]) -> str:
    """Render QR matrix using Unicode half-block characters (▀▄█ and space)."""
    if not matrix:
        return ""

    # Add 1-module quiet zone
    size = len(matrix)
    padded = [[False] * (size + 2)]
    for row in matrix:
        padded.append([False] + list(row) + [False])
    padded.append([False] * (size + 2))
    matrix = padded
    rows = len(matrix)

    # Check terminal width
    term_cols = shutil.get_terminal_size(fallback=(80, 24)).columns
    qr_width = len(matrix[0])
    if qr_width > term_cols:
        logger.warning("Terminal too narrow (%d) for QR (%d)", term_cols, qr_width)
        return ""

    lines: list[str] = []
    for y in range(0, rows, 2):
        line = ""
        top_row = matrix[y]
        bottom_row = matrix[y + 1] if y + 1 < rows else [False] * len(top_row)
        for x in range(len(top_row)):
            top = top_row[x]
            bottom = bottom_row[x]
            if top and bottom:
                line += "█"
            elif top and not bottom:
                line += "▀"
            elif not top and bottom:
                line += "▄"
            else:
                line += " "
        lines.append(line)
    return "\n".join(lines)


def _display_qr_in_terminal(data: str) -> bool:
    """Display *data* as a QR code in the terminal using Unicode half-blocks.

    Returns True on success.
    """
    qr = qrcode.QRCode(error_correction=qrcode.constants.ERROR_CORRECT_L)
    qr.add_data(data)
    qr.make(fit=True)
    modules = qr.get_matrix()

    rendered = _render_qr_half_blocks(modules)
    if rendered:
        print(rendered)
        return True

    # Fallback to basic ASCII
    qr2 = qrcode.QRCode(
        error_correction=qrcode.constants.ERROR_CORRECT_L,
        box_size=1,
        border=1,
    )
    qr2.add_data(data)
    qr2.make(fit=True)
    qr2.print_ascii(invert=True)
    return True


# ── QR Login flow ───────────────────────────────────────────────────


def qr_login() -> Credential:
    """Full QR code login flow for Weibo.

    1. Visit passport.weibo.com/sso/signin to get X-CSRF-TOKEN cookie
    2. GET /sso/v2/qrcode/image → qrid + image URL
    3. Extract scan URL from image URL, render QR in terminal
    4. Poll /sso/v2/qrcode/check every 2s
    5. On success, follow crossdomain URL for session cookies
    """
    with httpx.Client(
        base_url=PASSPORT_URL,
        headers=dict(PASSPORT_HEADERS),
        follow_redirects=True,
        timeout=httpx.Timeout(30),
    ) as client:
        # Step 1: Get CSRF token by visiting login page
        logger.info("Getting CSRF token from login page...")
        resp = client.get(
            SSO_SIGNIN_URL,
            params={
                "entry": QR_ENTRY,
                "source": QR_SOURCE,
                "url": QR_REDIRECT_URL,
            },
        )
        resp.raise_for_status()

        csrf_token = client.cookies.get("X-CSRF-TOKEN")
        if not csrf_token:
            raise RuntimeError("Failed to obtain X-CSRF-TOKEN from passport.weibo.com")

        logger.info("Got CSRF token: %s...", csrf_token[:20])

        # Update headers with CSRF token
        client.headers["x-csrf-token"] = csrf_token

        # Step 2: Get QR code
        logger.info("Requesting QR code...")
        resp = client.get(QR_IMAGE_URL, params={"entry": QR_ENTRY, "size": "180"})
        resp.raise_for_status()
        qr_data = resp.json()

        if qr_data.get("retcode") != RETCODE_SUCCESS:
            raise RuntimeError(f"Failed to get QR code: {qr_data.get('msg', 'Unknown error')}")

        qrid = qr_data["data"]["qrid"]
        image_url = qr_data["data"]["image"]
        logger.info("Got qrid: %s", qrid)

        # Step 3: Extract scan URL from image URL and render QR
        # The QR encodes: https://passport.weibo.cn/signin/qrcode/scan?qr={qrid}&...
        parsed = urlparse(image_url)
        qs = parse_qs(parsed.query)
        scan_url = qs.get("data", [f"https://passport.weibo.cn/signin/qrcode/scan?qr={qrid}"])[0]

        print("\n📱 请使用 微博APP 扫描以下二维码登录:\n")
        print("   打开微博手机APP → 我的页面 → 扫一扫\n")
        _display_qr_in_terminal(scan_url)
        print(f"\n⏳ 等待扫码中... (超时: {POLL_TIMEOUT_S // 60} 分钟)")
        print(f"   (QR ID: {qrid[:20]}...)\n")

        # Step 4: Poll for scan status
        start_time = time.time()
        last_status = None

        while (time.time() - start_time) < POLL_TIMEOUT_S:
            try:
                resp = client.get(
                    QR_CHECK_URL,
                    params={
                        "entry": QR_ENTRY,
                        "source": QR_SOURCE,
                        "url": QR_REDIRECT_URL,
                        "qrid": qrid,
                        "rid": "",
                        "ver": QR_VERSION,
                    },
                )
                resp.raise_for_status()
                check_data = resp.json()
                retcode = check_data.get("retcode")
                msg = check_data.get("msg", "")

                if retcode != last_status:
                    logger.info("QR check: retcode=%s msg=%s", retcode, msg)
                    last_status = retcode

                if retcode == RETCODE_SUCCESS:
                    print("  ✅ 扫码成功！正在完成登录...")

                    # Step 5: Follow crossdomain URL to get session cookies
                    cross_url = check_data.get("data", {}).get("url", "")
                    alt = check_data.get("data", {}).get("alt", "")

                    cookies = {}

                    # Collect cookies from passport domain
                    for name, value in client.cookies.items():
                        cookies[name] = value

                    if cross_url:
                        logger.info("Following crossdomain URL...")
                        try:
                            # Use a separate client for cross-domain requests
                            with httpx.Client(
                                follow_redirects=True,
                                timeout=httpx.Timeout(30),
                                headers={"User-Agent": PASSPORT_HEADERS["User-Agent"]},
                            ) as cross_client:
                                cross_resp = cross_client.get(cross_url)
                                for name, value in cross_resp.cookies.items():
                                    cookies[name] = value
                                for name, value in cross_client.cookies.items():
                                    cookies[name] = value
                        except Exception as e:
                            logger.warning("Cross-domain follow failed: %s", e)

                    if alt:
                        # alt parameter may need to be exchanged for final cookies
                        try:
                            alt_url = f"https://login.sina.com.cn/sso/login.php?entry=miniblog&alt={alt}&returntype=TEXT"
                            with httpx.Client(
                                follow_redirects=True,
                                timeout=httpx.Timeout(30),
                                headers={"User-Agent": PASSPORT_HEADERS["User-Agent"]},
                            ) as alt_client:
                                alt_resp = alt_client.get(alt_url)
                                for name, value in alt_resp.cookies.items():
                                    cookies[name] = value
                                for name, value in alt_client.cookies.items():
                                    cookies[name] = value
                        except Exception as e:
                            logger.warning("Alt token exchange failed: %s", e)

                    if not cookies:
                        raise RuntimeError("Login succeeded but no cookies were obtained")

                    credential = Credential(cookies=cookies)
                    save_credential(credential)
                    print("  ✅ 登录成功！凭证已保存到", CREDENTIAL_FILE)
                    return credential

                elif retcode == RETCODE_QR_NOT_SCANNED:
                    # Still waiting for scan
                    pass

                else:
                    # Could be scanned/confirmed/expired
                    if "已扫" in msg or "扫描" in msg:
                        print("  📲 已扫码，请在手机上确认登录...")
                    elif "过期" in msg or "expired" in msg.lower():
                        raise QRExpiredError()

            except httpx.TimeoutException:
                logger.debug("QR check timeout, retrying...")
            except QRExpiredError:
                raise

            time.sleep(POLL_INTERVAL_S)

        raise QRExpiredError()


# ── Unified get_credential ──────────────────────────────────────────


def get_credential() -> Credential | None:
    """Try all auth methods and return credential.

    1. Saved credential file
    2. Browser cookie extraction
    """
    cred = load_credential()
    if cred:
        logger.info("Loaded credential from %s", CREDENTIAL_FILE)
        return cred

    cred = extract_browser_credential()
    if cred:
        logger.info("Extracted credential from browser")
        return cred

    return None

"""CLI entry point for Weibo CLI.

Usage:
    weibo login / status / logout / me
    weibo hot / feed / trending / search <keyword>
    weibo detail <mblogid> / comments <mblogid> / reposts <mblogid>
    weibo profile <uid> / weibos <uid> / following <uid> / followers <uid>
    weibo home
"""

from __future__ import annotations

import logging

import click

from . import __version__
from .commands import auth, personal, search


@click.group()
@click.version_option(version=__version__, prog_name="weibo")
@click.option("-v", "--verbose", is_flag=True, help="Enable verbose logging (show request URLs, timing)")
@click.pass_context
def cli(ctx, verbose: bool) -> None:
    """Weibo CLI — 在终端使用微博 🐦"""
    ctx.ensure_object(dict)
    if verbose:
        logging.basicConfig(level=logging.INFO, format="%(name)s %(message)s")
    else:
        logging.basicConfig(level=logging.WARNING)


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

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

# ─── Search / Feed commands ──────────────────────────────────────────

cli.add_command(search.hot)
cli.add_command(search.feed)
cli.add_command(search.detail)
cli.add_command(search.comments)
cli.add_command(search.trending)
cli.add_command(search.search)

# ─── Personal / Profile commands ─────────────────────────────────────

cli.add_command(personal.profile)
cli.add_command(personal.weibos)
cli.add_command(personal.following)
cli.add_command(personal.followers)
cli.add_command(personal.reposts)
cli.add_command(personal.home)


if __name__ == "__main__":
    cli()

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

from __future__ import annotations

import logging
import random
import time
from typing import Any

import httpx

from .auth import Credential
from .constants import (
    BASE_URL,
    BUILD_COMMENTS_URL,
    FEED_GROUPS_URL,
    FOLLOWERS_URL,
    FRIENDS_TIMELINE_URL,
    FRIENDS_URL,
    GET_CONFIG_URL,
    HEADERS,
    HOT_BAND_URL,
    HOT_SEARCH_URL,
    HOT_TIMELINE_URL,
    MOBILE_BASE_URL,
    MOBILE_HEADERS,
    MOBILE_SEARCH_URL,
    MY_MBLOG_URL,
    PROFILE_INFO_URL,
    REPOST_TIMELINE_URL,
    SEARCH_BAND_URL,
    STATUSES_SHOW_URL,
)
from .exceptions import WeiboApiError, SessionExpiredError

logger = logging.getLogger(__name__)


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

    Anti-detection strategy:
    - Gaussian jitter delay between requests (~1s mean, σ=0.3)
    - 5% chance of a random long pause (2-5s) to mimic reading behavior
    - Exponential backoff on HTTP 429/5xx (up to 3 retries)
    - Response cookies merged back into session jar
    """

    def __init__(
        self,
        credential: Credential | 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._base_request_delay = request_delay
        self._max_retries = max_retries
        self._last_request_time = 0.0
        self._request_count = 0
        self._rate_limit_count = 0
        self._http: httpx.Client | None = None

    def _build_client(self) -> httpx.Client:
        cookies = {}
        if self.credential:
            cookies = self.credential.cookies
        return httpx.Client(
            base_url=BASE_URL,
            headers=dict(HEADERS),
            cookies=cookies,
            follow_redirects=True,
            timeout=httpx.Timeout(self._timeout),
        )

    @property
    def client(self) -> httpx.Client:
        if not self._http:
            raise RuntimeError("Client not initialized. Use 'with WeiboClient() as client:'")
        return self._http

    def __enter__(self) -> WeiboClient:
        self._http = self._build_client()
        return self

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

    # ── Rate limiting ───────────────────────────────────────────────

    def _rate_limit_delay(self) -> None:
        if self._request_delay <= 0:
            return
        elapsed = time.time() - self._last_request_time
        if elapsed < self._request_delay:
            jitter = max(0, random.gauss(0.3, 0.15))
            if random.random() < 0.05:
                jitter += random.uniform(2.0, 5.0)
            sleep_time = self._request_delay - elapsed + jitter
            logger.debug("Rate-limit delay: %.2fs", sleep_time)
            time.sleep(sleep_time)

    def _mark_request(self) -> None:
        self._last_request_time = time.time()
        self._request_count += 1

    # ── Response handling ───────────────────────────────────────────

    def _merge_response_cookies(self, resp: httpx.Response) -> None:
        for name, value in resp.cookies.items():
            if value:
                self.client.cookies.set(name, value)

    def _handle_response(self, data: dict[str, Any], action: str, *, unwrap: bool = True) -> dict[str, Any]:
        """Validate API response.

        Weibo uses {ok: 1, data: {...}} format for most endpoints.
        When unwrap=True (default), extract and return data["data"].
        When unwrap=False, return the full response dict (for APIs that don't wrap data).
        """
        ok = data.get("ok")

        if ok == -100:
            raise SessionExpiredError()

        message = data.get("msg", data.get("message", "Unknown error"))

        _SESSION_EXPIRED_KEYWORDS = ("请先登录", "请登录后使用", "请登录", "用户未登录")
        if ok == 0:
            msg_str = str(message)
            if any(kw in msg_str for kw in _SESSION_EXPIRED_KEYWORDS):
                raise SessionExpiredError()
            raise WeiboApiError(f"{action}: {message} (ok={ok})", code=ok, response=data)

        if ok == 1:
            return data.get("data", data) if unwrap else data

        # ok is some other truthy value (e.g. raw APIs return full dict)
        if ok:
            return data.get("data", data) if unwrap else data

        raise WeiboApiError(f"{action}: {message} (ok={ok})", code=ok, response=data)

    # ── Request with retry ──────────────────────────────────────────

    def _request(self, method: str, url: str, *, client: httpx.Client | None = None, **kwargs) -> dict[str, Any]:
        self._rate_limit_delay()
        last_exc: Exception | None = None
        http = client or self.client

        for attempt in range(self._max_retries):
            t0 = time.time()
            try:
                resp = http.request(method, url, **kwargs)
                elapsed = time.time() - t0
                if not client:  # only merge cookies for the main client
                    self._merge_response_cookies(resp)
                self._mark_request()

                logger.info("[#%d] %s %s → %d (%.2fs)", self._request_count, method, url[:60], resp.status_code, elapsed)

                if resp.status_code in (429, 500, 502, 503, 504):
                    wait = (2 ** attempt) + random.uniform(0, 1)
                    logger.warning("HTTP %d, retrying in %.1fs (%d/%d)", resp.status_code, wait, attempt + 1, self._max_retries)
                    time.sleep(wait)
                    continue

                resp.raise_for_status()
                text = resp.text
                if text.startswith("<"):
                    raise WeiboApiError(f"Received HTML instead of JSON from {url}")
                return resp.json()

            except (httpx.TimeoutException, httpx.NetworkError) as exc:
                last_exc = exc
                wait = (2 ** attempt) + random.uniform(0, 1)
                time.sleep(wait)

        if last_exc:
            raise WeiboApiError(f"Request failed after {self._max_retries} retries: {last_exc}") from last_exc
        raise WeiboApiError(f"Request failed after {self._max_retries} retries")

    def _get(self, url: str, params: dict[str, Any] | None = None, action: str = "", *, unwrap: bool = True) -> dict[str, Any]:
        data = self._request("GET", url, params=params)
        return self._handle_response(data, action, unwrap=unwrap)

    # ── Hot Search / Trending ───────────────────────────────────────

    def get_hot_search(self) -> dict[str, Any]:
        """Get hot search list (微博热搜 sidebar, ~52 items)."""
        return self._get(HOT_SEARCH_URL, action="热搜")

    def get_hot_band(self) -> dict[str, Any]:
        """Get full hot band list (微博热搜榜)."""
        return self._get(HOT_BAND_URL, action="热搜榜")

    def get_search_band(self) -> dict[str, Any]:
        """Get search band (trending sidebar, ~16 items)."""
        return self._get(SEARCH_BAND_URL, action="搜索推荐")

    # ── Feed / Timeline ─────────────────────────────────────────────

    def get_hot_timeline(self, group_id: str = "102803", count: int = 10, max_id: str = "0") -> dict[str, Any]:
        """Get hot timeline (热门微博 feed)."""
        return self._get(HOT_TIMELINE_URL, params={
            "since_id": "0", "refresh": "0",
            "group_id": group_id, "containerid": group_id,
            "extparam": "discover|new_feed",
            "max_id": max_id, "count": str(count),
        }, action="热门Feed", unwrap=False)

    def get_friends_timeline(self, count: int = 20, max_id: str = "0") -> dict[str, Any]:
        """Get friends timeline (关注者 feed, requires auth)."""
        return self._get(FRIENDS_TIMELINE_URL, params={
            "count": str(count), "max_id": max_id,
        }, action="关注Feed", unwrap=False)

    def get_feed_groups(self) -> dict[str, Any]:
        """Get feed group configuration."""
        return self._get(FEED_GROUPS_URL, params={"is_new_segment": "1", "fetch_hot": "1"}, action="Feed分组", unwrap=False)

    # ── User / Profile ──────────────────────────────────────────────

    def get_profile(self, uid: str) -> dict[str, Any]:
        """Get user profile info."""
        return self._get(PROFILE_INFO_URL, params={"uid": uid}, action="用户资料")

    def get_user_weibos(self, uid: str, page: int = 1, count: int = 20, feature: int = 0) -> dict[str, Any]:
        """Get user's weibo list."""
        return self._get(MY_MBLOG_URL, params={
            "uid": uid, "page": str(page), "feature": str(feature),
        }, action="用户微博")

    # ── Weibo Detail ────────────────────────────────────────────────

    def get_weibo_detail(self, mblogid: str) -> dict[str, Any]:
        """Get single weibo detail by mblogid (e.g. 'Qw06Kd98p')."""
        return self._get(STATUSES_SHOW_URL, params={"id": mblogid}, action="微博详情", unwrap=False)

    # ── Comments / Reposts ──────────────────────────────────────────

    def get_comments(self, weibo_id: str, count: int = 20, max_id: int = 0) -> dict[str, Any]:
        """Get comments for a weibo."""
        params: dict[str, Any] = {"id": weibo_id, "is_show_bulletin": "2", "count": str(count), "flow": "0"}
        if max_id:
            params["max_id"] = str(max_id)
        return self._get(BUILD_COMMENTS_URL, params=params, action="评论")

    def get_reposts(self, weibo_id: str, page: int = 1, count: int = 10) -> dict[str, Any]:
        """Get repost/forward list for a weibo."""
        return self._get(REPOST_TIMELINE_URL, params={
            "id": weibo_id, "page": str(page), "count": str(count),
        }, action="转发", unwrap=False)

    # ── Social ──────────────────────────────────────────────────────

    def get_following(self, uid: str, page: int = 1) -> dict[str, Any]:
        """Get user's following list."""
        return self._get(FRIENDS_URL, params={"uid": uid, "page": str(page)}, action="关注列表", unwrap=False)

    def get_followers(self, uid: str, page: int = 1) -> dict[str, Any]:
        """Get user's follower list."""
        return self._get(FOLLOWERS_URL, params={
            "uid": uid, "page": str(page), "relate": "fans",
        }, action="粉丝列表", unwrap=False)

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

    def _build_mobile_client(self) -> httpx.Client:
        """Build a mobile API client for m.weibo.cn endpoints."""
        cookies = self.credential.cookies if self.credential else {}
        return httpx.Client(
            base_url=MOBILE_BASE_URL,
            headers=dict(MOBILE_HEADERS),
            cookies=cookies,
            follow_redirects=True,
            timeout=httpx.Timeout(self._timeout),
        )

    def search_weibo(self, keyword: str, page: int = 1) -> dict[str, Any]:
        """Search weibos by keyword using mobile API."""
        containerid = f"100103type=1&q={keyword}"
        params = {
            "containerid": containerid,
            "page_type": "searchall",
            "page": str(page),
        }
        with self._build_mobile_client() as mobile:
            data = self._request("GET", MOBILE_SEARCH_URL, params=params, client=mobile)
        return data

    # ── Config ──────────────────────────────────────────────────────

    def get_config(self) -> dict[str, Any]:
        """Get app configuration (contains current user info)."""
        return self._get(GET_CONFIG_URL, action="配置")