"""Tests for the feed extension system.

Tests cover the ABC base class, plugin discovery, per-feed storage, the
``run_extensions`` integration function, and the built-in example plugin.
"""

from __future__ import annotations

import json
import os
import tempfile
from contextlib import contextmanager
from http.server import BaseHTTPRequestHandler
from http.server import ThreadingHTTPServer
from pathlib import Path
from threading import Thread
from types import SimpleNamespace
from typing import TYPE_CHECKING
from unittest.mock import MagicMock

import pytest
from reader import Reader as ReaderType
from reader import make_reader

from discord_rss_bot.custom_message import CustomEmbed
from discord_rss_bot.custom_message import get_embed
from discord_rss_bot.custom_message import replace_tags_in_embed
from discord_rss_bot.custom_message import replace_tags_in_text_message
from discord_rss_bot.custom_message import save_embed
from discord_rss_bot.extensions import FeedExtension
from discord_rss_bot.extensions import auto_enable_extensions_for_feed
from discord_rss_bot.extensions import discover_plugins
from discord_rss_bot.extensions import registry_clear
from discord_rss_bot.extensions import run_extensions
from discord_rss_bot.extensions.base import FeedExtension as FeedExtensionABC
from discord_rss_bot.extensions.hoyolab import HoyolabExtension
from discord_rss_bot.extensions.jwplayer_thumbnail import _SLUG_CACHE
from discord_rss_bot.extensions.jwplayer_thumbnail import JWPlayerThumbnailExtension
from discord_rss_bot.extensions.steam import SteamExtension
from discord_rss_bot.extensions.storage import get_enabled_extensions_for_feed
from discord_rss_bot.extensions.storage import set_enabled_extensions_for_feed
from discord_rss_bot.extensions.wordpress import WordPressExtension
from discord_rss_bot.extensions.youtube import YouTubeExtension

if TYPE_CHECKING:
    from collections.abc import Iterator

    from reader import Entry
    from reader import Reader

    from discord_rss_bot.feeds import JsonValue


# ---------------------------------------------------------------------------
# Fixtures
# ---------------------------------------------------------------------------


@pytest.fixture(autouse=True)
def _clear_registry() -> Iterator[None]:
    """Clear the extension registry before and after each test.

    Yields:
        Control back to the test body, then cleans up.
    """
    registry_clear()
    yield
    registry_clear()


@pytest.fixture
def temp_extensions_dir() -> Iterator[str]:
    """Create a temporary directory to act as the extensions directory.

    Yields:
        The path to the temporary extensions directory.
    """
    tmpdir: str = tempfile.mkdtemp(prefix="ext-test-")
    old_env: str | None = os.environ.pop("EXTENSIONS_DIR", None)
    os.environ["EXTENSIONS_DIR"] = tmpdir
    yield tmpdir
    if old_env is not None:
        os.environ["EXTENSIONS_DIR"] = old_env
    else:
        os.environ.pop("EXTENSIONS_DIR", None)


@pytest.fixture
def mock_reader() -> MagicMock:
    """A mock Reader with tag storage support.

    Returns:
        A MagicMock configured with set_tag/get_tag side effects.
    """
    reader: MagicMock = MagicMock()
    reader.tags = {}  # type: ignore[valid-type]

    def _resolve_feed_key(feed_or_url: str | SimpleNamespace) -> str:
        """Extract the feed URL string from either a string or SimpleNamespace.

        Returns:
            The URL as a string.
        """
        if isinstance(feed_or_url, str):
            return feed_or_url
        url = getattr(feed_or_url, "url", None)
        if url is not None:
            return str(url)
        return str(feed_or_url)

    def set_tag(feed_or_url: str | SimpleNamespace, key: str, value: JsonValue) -> None:
        feed_key: str = _resolve_feed_key(feed_or_url)
        if feed_key not in reader.tags:
            reader.tags[feed_key] = {}
        reader.tags[feed_key][key] = value

    def get_tag(feed_or_url: str | SimpleNamespace, key: str, default: JsonValue = None) -> JsonValue:
        feed_key: str = _resolve_feed_key(feed_or_url)
        feed_tags = reader.tags.get(feed_key, {})
        return feed_tags.get(key, default)

    reader.set_tag.side_effect = set_tag
    reader.get_tag.side_effect = get_tag
    return reader


@pytest.fixture
def mock_feed() -> SimpleNamespace:
    """A feed object with all attributes required by tag replacement.

    Returns:
        A SimpleNamespace with feed-like attributes.
    """
    return SimpleNamespace(
        added=None,
        author="Feed Author",
        authors_str="Feed Author",
        last_exception=None,
        last_updated=None,
        link="https://example.com/feed",
        subtitle="",
        title="Example Feed",
        updated=None,
        updates_enabled=True,
        url="https://example.com/feed.xml",
        user_title="",
        version="atom10",
    )


@pytest.fixture
def mock_entry(mock_feed: SimpleNamespace) -> SimpleNamespace:
    """An entry object with all attributes required by tag replacement.

    Returns:
        A SimpleNamespace with entry-like attributes.
    """
    return SimpleNamespace(
        added=None,
        author="Entry Author",
        authors_str="Entry Author",
        content=[SimpleNamespace(value="<p>Hello world</p>")],
        feed=mock_feed,
        feed_url=mock_feed.url,
        id="entry-1",
        important=False,
        link="https://example.com/entry-1",
        published=None,
        read=False,
        read_modified=None,
        summary="",
        title="Test Entry",
        updated=None,
    )


# ---------------------------------------------------------------------------
# Tests: base.py
# ---------------------------------------------------------------------------


def test_feed_extension_abc_cannot_be_instantiated() -> None:
    """FeedExtension should be abstract and not instantiable directly."""
    with pytest.raises(TypeError):
        FeedExtensionABC()  # type: ignore[abstract]


def test_feed_extension_subclass_can_be_instantiated() -> None:
    """A concrete subclass with ``process_entry`` should work."""

    class ConcreteExtension(FeedExtensionABC):
        name = "test_concrete"

        def process_entry(self, entry: Entry, reader: Reader) -> dict[str, str]:  # ruff:ignore[unused-method-argument]
            return {"hello": "world"}

    instance = ConcreteExtension()
    assert instance.name == "test_concrete"


def test_feed_extension_name_defaults_to_empty_string() -> None:
    """The ``name`` class variable defaults to ``""``."""

    class UnnamedExtension(FeedExtensionABC):
        def process_entry(self, entry: Entry, reader: Reader) -> dict[str, str]:  # ruff:ignore[unused-method-argument]
            return {}

    assert not UnnamedExtension.name, "Expected name to be empty"


# ---------------------------------------------------------------------------
# Tests: discovery.py
# ---------------------------------------------------------------------------


BUILT_IN_EXTENSIONS: frozenset[str] = frozenset({"steam", "youtube", "hoyolab", "jwplayer_thumbnail", "wordpress"})


def _assert_only_built_in_extensions(registry: dict[str, type[FeedExtension]]) -> None:
    """Assert that *registry* contains exactly the built-in extensions."""
    registered: set[str] = set(registry.keys())
    unexpected: set[str] = registered - BUILT_IN_EXTENSIONS
    missing: frozenset[str] = BUILT_IN_EXTENSIONS - registered
    assert not unexpected, f"Registry contains unexpected extensions: {unexpected}"
    assert not missing, f"Registry missing built-in extensions: {missing}"


def test_discover_plugins_empty_directory(temp_extensions_dir: str) -> None:
    """An empty external directory still has built-in extensions."""
    registry: dict[str, type[FeedExtension]] = discover_plugins(force=True)
    _assert_only_built_in_extensions(registry)


def test_discover_plugins_missing_directory() -> None:
    """If the external extensions directory doesn't exist, built-ins still load."""
    old_env: str | None = os.environ.pop("EXTENSIONS_DIR", None)
    try:
        os.environ["EXTENSIONS_DIR"] = str(Path(tempfile.gettempdir()) / "nonexistent-extensions-dir-12345")
        registry: dict[str, type[FeedExtension]] = discover_plugins(force=True)
        _assert_only_built_in_extensions(registry)
    finally:
        if old_env is not None:
            os.environ["EXTENSIONS_DIR"] = old_env
        else:
            os.environ.pop("EXTENSIONS_DIR", None)


def test_discover_plugins_imports_plugin(temp_extensions_dir: str) -> None:
    """A valid plugin file should be discovered and registered alongside built-ins."""
    plugin_code: str = """
from discord_rss_bot.extensions.base import FeedExtension

class TestPlugin(FeedExtension):
    name = "test_plugin"
    description = "A test plugin."

    def process_entry(self, entry, reader):
        return {"test_var": "hello"}
"""
    plugin_path: Path = Path(temp_extensions_dir) / "test_plugin.py"
    plugin_path.write_text(plugin_code, encoding="utf-8")

    registry: dict[str, type[FeedExtension]] = discover_plugins(force=True)
    assert "test_plugin" in registry
    assert registry["test_plugin"].name == "test_plugin"
    assert registry["test_plugin"].description == "A test plugin."
    # Built-in extensions should also be present.
    for name in BUILT_IN_EXTENSIONS:
        assert name in registry, f"Missing built-in extension {name}"


def test_discover_plugins_skips_broken_plugin(temp_extensions_dir: str) -> None:
    """A plugin that raises during import should be skipped, not crash."""
    plugin_path: Path = Path(temp_extensions_dir) / "broken.py"
    plugin_path.write_text("raise SyntaxError('bad syntax'", encoding="utf-8")

    # Should not raise.
    registry: dict[str, type[FeedExtension]] = discover_plugins(force=True)
    assert "broken" not in registry
    # Built-in extensions should still load.
    _assert_only_built_in_extensions(registry)


def test_discover_plugins_skips_init_py(temp_extensions_dir: str) -> None:
    """__init__.py files in the extensions directory should be ignored."""
    init_path: Path = Path(temp_extensions_dir) / "__init__.py"
    init_path.write_text("# package init", encoding="utf-8")

    registry: dict[str, type[FeedExtension]] = discover_plugins(force=True)
    _assert_only_built_in_extensions(registry)


def test_discover_plugins_deduplicates_by_name(temp_extensions_dir: str) -> None:
    """If two plugins define the same name, the last one wins."""
    plugin_a: str = """
from discord_rss_bot.extensions.base import FeedExtension

class PluginA(FeedExtension):
    name = "dup_name"
    def process_entry(self, entry, reader):
        return {"from": "a"}
"""
    plugin_b: str = """
from discord_rss_bot.extensions.base import FeedExtension

class PluginB(FeedExtension):
    name = "dup_name"
    def process_entry(self, entry, reader):
        return {"from": "b"}
"""
    (Path(temp_extensions_dir) / "a.py").write_text(plugin_a)
    (Path(temp_extensions_dir) / "b.py").write_text(plugin_b)

    registry: dict[str, type[FeedExtension]] = discover_plugins(force=True)
    assert "dup_name" in registry
    # The last one alphabetically (b.py) should win.
    assert registry["dup_name"].__name__ == "PluginB"


# ---------------------------------------------------------------------------
# Tests: storage.py
# ---------------------------------------------------------------------------


def test_get_enabled_extensions_empty_when_no_tag(mock_reader: MagicMock, mock_feed: SimpleNamespace) -> None:
    """If no extensions tag is set, an empty list is returned."""
    enabled: list[str] = get_enabled_extensions_for_feed(mock_reader, mock_feed.url)
    assert enabled == []


def test_set_and_get_enabled_extensions(mock_reader: MagicMock, mock_feed: SimpleNamespace) -> None:
    """Setting enabled extensions and retrieving them should round-trip."""
    names: list[str] = ["jwplayer_thumbnail", "encode_links"]
    set_enabled_extensions_for_feed(mock_reader, mock_feed.url, names)
    enabled: list[str] = get_enabled_extensions_for_feed(mock_reader, mock_feed.url)
    assert enabled == names


def test_set_enabled_extensions_clears_list(mock_reader: MagicMock, mock_feed: SimpleNamespace) -> None:
    """Setting an empty list should clear the enabled extensions."""
    set_enabled_extensions_for_feed(mock_reader, mock_feed.url, ["some_plugin"])
    set_enabled_extensions_for_feed(mock_reader, mock_feed.url, [])
    enabled: list[str] = get_enabled_extensions_for_feed(mock_reader, mock_feed.url)
    assert enabled == []


def test_get_enabled_extensions_handles_string_tag(mock_reader: MagicMock, mock_feed: SimpleNamespace) -> None:
    """If the tag is stored as a JSON string, it should still be parsed."""

    def json_string_tag(feed_url: str, key: str, default: JsonValue = None) -> str:
        return json.dumps(["plugin_a", "plugin_b"])

    mock_reader.get_tag.side_effect = json_string_tag
    enabled: list[str] = get_enabled_extensions_for_feed(mock_reader, mock_feed.url)
    assert enabled == ["plugin_a", "plugin_b"]


def test_get_enabled_extensions_handles_empty_string_tag(mock_reader: MagicMock, mock_feed: SimpleNamespace) -> None:
    """An empty string tag should return an empty list."""

    def empty_string_tag(feed_url: str, key: str, default: JsonValue = None) -> str:
        return ""

    mock_reader.get_tag.side_effect = empty_string_tag
    enabled: list[str] = get_enabled_extensions_for_feed(mock_reader, mock_feed.url)
    assert enabled == []


# ---------------------------------------------------------------------------
# Tests: run_extensions (integration)
# ---------------------------------------------------------------------------


def test_run_extensions_empty_when_none_enabled(
    mock_reader: MagicMock,
    mock_entry: SimpleNamespace,
    mock_feed: SimpleNamespace,
) -> None:
    """If no extensions are enabled for the feed, the result is empty."""
    set_enabled_extensions_for_feed(mock_reader, mock_feed.url, [])
    result: dict[str, str] = run_extensions(mock_entry, mock_reader)  # type: ignore[arg-type]
    assert result == {}


def test_run_extensions_with_missing_plugin(
    mock_reader: MagicMock,
    mock_entry: SimpleNamespace,
    mock_feed: SimpleNamespace,
) -> None:
    """Enabled extension that doesn't exist in the registry is skipped."""
    set_enabled_extensions_for_feed(mock_reader, mock_feed.url, ["nonexistent_plugin"])
    result: dict[str, str] = run_extensions(mock_entry, mock_reader)  # type: ignore[arg-type]
    assert result == {}


def test_run_extensions_with_registered_plugin(
    mock_reader: MagicMock,
    mock_entry: SimpleNamespace,
    mock_feed: SimpleNamespace,
    temp_extensions_dir: str,
) -> None:
    """A registered and enabled extension should produce variables."""
    # Register a plugin via discovery.
    plugin_code: str = """
from discord_rss_bot.extensions.base import FeedExtension

class TestPlugin(FeedExtension):
    name = "test_plugin"

    def process_entry(self, entry, reader):
        return {"custom_var": "hello_from_plugin"}
"""
    (Path(temp_extensions_dir) / "my_plugin.py").write_text(plugin_code)
    discover_plugins(force=True)

    set_enabled_extensions_for_feed(mock_reader, mock_feed.url, ["test_plugin"])
    result: dict[str, str] = run_extensions(mock_entry, mock_reader)  # type: ignore[arg-type]
    assert result == {"custom_var": "hello_from_plugin"}


def test_run_extensions_continues_after_plugin_error(
    mock_reader: MagicMock,
    mock_entry: SimpleNamespace,
    mock_feed: SimpleNamespace,
    temp_extensions_dir: str,
) -> None:
    """If one plugin raises, others should still run and produce results."""
    # Register two plugins: one that raises and one that works.
    good_code: str = """
from discord_rss_bot.extensions.base import FeedExtension

class GoodPlugin(FeedExtension):
    name = "good_plugin"
    def process_entry(self, entry, reader):
        return {"good_var": "ok"}
"""
    bad_code: str = """
from discord_rss_bot.extensions.base import FeedExtension

class BadPlugin(FeedExtension):
    name = "bad_plugin"
    def process_entry(self, entry, reader):
        raise RuntimeError("This plugin failed!")
"""
    (Path(temp_extensions_dir) / "good.py").write_text(good_code)
    (Path(temp_extensions_dir) / "bad.py").write_text(bad_code)
    discover_plugins(force=True)

    set_enabled_extensions_for_feed(mock_reader, mock_feed.url, ["bad_plugin", "good_plugin"])
    result: dict[str, str] = run_extensions(mock_entry, mock_reader)  # type: ignore[arg-type]
    assert result == {"good_var": "ok"}


# ---------------------------------------------------------------------------
# Tests: tag replacement integration (custom_message.py)
# ---------------------------------------------------------------------------


def test_replace_tags_in_embed_uses_extension_variables(
    mock_reader: MagicMock,
    mock_feed: SimpleNamespace,
    mock_entry: SimpleNamespace,
    temp_extensions_dir: str,
) -> None:
    """Extension variables should be available in embed tag replacement."""
    # Register a test plugin.
    plugin_code: str = """
from discord_rss_bot.extensions.base import FeedExtension

class EmbedVarPlugin(FeedExtension):
    name = "embed_var"
    def process_entry(self, entry, reader):
        return {"custom_thumbnail": "https://example.com/thumb.jpg"}
"""
    (Path(temp_extensions_dir) / "embed_var.py").write_text(plugin_code)
    discover_plugins(force=True)

    # Enable the plugin for this feed.
    set_enabled_extensions_for_feed(mock_reader, mock_feed.url, ["embed_var"])

    # Create an embed that uses the extension variable.
    embed: CustomEmbed = get_embed(mock_reader, mock_feed)  # type: ignore[arg-type]
    embed.image_url = "{{custom_thumbnail}}"
    save_embed(mock_reader, mock_feed, embed)  # type: ignore[arg-type]

    # Run replacement.
    result: CustomEmbed = replace_tags_in_embed(mock_feed, mock_entry, mock_reader)  # type: ignore[arg-type]
    assert "https://example.com/thumb.jpg" in result.image_url


def test_replace_tags_in_text_message_uses_extension_variables(
    mock_reader: MagicMock,
    mock_feed: SimpleNamespace,
    mock_entry: SimpleNamespace,
    temp_extensions_dir: str,
) -> None:
    """Extension variables should be available in text message tag replacement."""
    # Register a test plugin.
    plugin_code: str = """
from discord_rss_bot.extensions.base import FeedExtension

class TextVarPlugin(FeedExtension):
    name = "text_var"
    def process_entry(self, entry, reader):
        return {"custom_text": "hello_from_extension"}
"""
    (Path(temp_extensions_dir) / "text_var.py").write_text(plugin_code)
    discover_plugins(force=True)

    # Enable the plugin for this feed.
    set_enabled_extensions_for_feed(mock_reader, mock_feed.url, ["text_var"])

    # Set a custom message that uses the extension variable.
    mock_reader.set_tag(mock_feed.url, "custom_message", "{{custom_text}}")

    # Run replacement.
    result: str = replace_tags_in_text_message(mock_entry, mock_reader)  # type: ignore[arg-type]
    assert "hello_from_extension" in result


# ---------------------------------------------------------------------------
# Tests: JWPlayer example plugin
# ---------------------------------------------------------------------------


def test_jwplayer_thumbnail_extension_extracts_image() -> None:
    """The JWPlayer thumbnail extension should extract the image URL."""
    ext = JWPlayerThumbnailExtension()
    raw_html: str = """
    <div id="player_01"></div>
    <script type="text/javascript">
    jwplayer("player_01").setup({
        file: "https://example.com/video.mp4",
        image: "https://example.com/thumbnail.jpg",
    });
    </script>
    """
    entry: SimpleNamespace = SimpleNamespace(
        id="test",
        content=[SimpleNamespace(value=raw_html)],
        summary="",
        feed=SimpleNamespace(url="https://example.com/feed.xml"),
    )
    result: dict[str, str] = ext.process_entry(entry, MagicMock())  # type: ignore[arg-type]
    assert result.get("jwplayer_thumbnail") == "https://example.com/thumbnail.jpg"
    assert result.get("jwplayer_file") == "https://example.com/video.mp4"


def test_jwplayer_thumbnail_extension_returns_empty_without_content() -> None:
    """If the entry has no content, the extension should return an empty dict."""
    ext = JWPlayerThumbnailExtension()
    entry: SimpleNamespace = SimpleNamespace(
        id="test",
        content=[],
        summary="",
        link="https://example.com/video",
        feed=SimpleNamespace(url="https://example.com/feed.xml"),
    )
    result: dict[str, str] = ext.process_entry(entry, MagicMock())  # type: ignore[arg-type]
    assert result == {}


def test_jwplayer_thumbnail_extension_returns_empty_without_match() -> None:
    """If the HTML has no JWPlayer pattern, the extension should return empty."""
    ext = JWPlayerThumbnailExtension()
    raw_html: str = "<p>No player here.</p>"
    entry: SimpleNamespace = SimpleNamespace(
        id="test",
        content=[SimpleNamespace(value=raw_html)],
        summary="",
        link="https://example.com/video",
        feed=SimpleNamespace(url="https://example.com/feed.xml"),
    )
    result: dict[str, str] = ext.process_entry(entry, MagicMock())  # type: ignore[arg-type]
    assert result == {}


def test_jwplayer_thumbnail_extension_matches_hentaigasm_format() -> None:
    """The extension should extract URLs from the actual hentaigasm.com feed format."""
    ext = JWPlayerThumbnailExtension()
    # This is the actual HTML structure from the main hentaigasm feed.
    raw_html: str = """
<p style="text-align: center;"><strong>HENTAIGASM EXCLUSIVE!</strong></p>

<div style="width:620px; height:349px">
<script src="https://content.jwplatform.com/libraries/SAHhwvZq.js"></script>
<script>jwplayer.key="zTEbSn/eAplL0RLXT030FzOcek6qXmtrxju6Jg=="</script>

<div id="player_01"></div>
<script type="text/javascript">
.jwplayer("player_01").setup({
    file: "https://hgasm2.com/Test Video 1 Subbed.mp4",
    width: "620",
    height: "349",
    skin: "seven",
    preload: "none",
    autostart: "false",
    image: "https://hgasm1.com/thumbnail/Test Video 1 Subbed.jpg",
    advertising: {}
});
</script>
</div>

<a class="btn btn-pink" href="https://hgasm3.com/Test Video 1 Subbed.mp4" download>DOWNLOAD</a>
"""
    entry: SimpleNamespace = SimpleNamespace(
        id="test-hentai",
        content=[SimpleNamespace(value=raw_html)],
        summary="",
        feed=SimpleNamespace(url="https://hentaigasm.com/feed/"),
    )
    result: dict[str, str] = ext.process_entry(entry, MagicMock())  # type: ignore[arg-type]
    assert result.get("jwplayer_thumbnail") == "https://hgasm1.com/thumbnail/Test%20Video%201%20Subbed.jpg"
    assert result.get("jwplayer_file") == "https://hgasm2.com/Test%20Video%201%20Subbed.mp4"


# ---------------------------------------------------------------------------
# Tests: auto_enable_url_patterns
# ---------------------------------------------------------------------------


def test_auto_enable_by_url_pattern_matches(
    mock_reader: MagicMock,
    temp_extensions_dir: str,
) -> None:
    """An extension with matching auto_enable_url_patterns should be auto-enabled.

    Check that ``auto_enable_extensions_for_feed`` activates the plugin.
    """
    # Register a test plugin with a URL pattern.
    plugin_code: str = """
from discord_rss_bot.extensions.base import FeedExtension

class AutoPlugin(FeedExtension):
    name = "auto_test"
    auto_enable_url_patterns = [r"example\\.com/feeds"]

    def process_entry(self, entry, reader):
        return {"auto_var": "enabled"}
"""
    plugin_path: Path = Path(temp_extensions_dir) / "auto_plugin.py"
    plugin_path.write_text(plugin_code, encoding="utf-8")
    discover_plugins(force=True)

    mock_feed_url: str = "https://example.com/feeds/test.xml"
    result: list[str] = auto_enable_extensions_for_feed(mock_reader, mock_feed_url)

    assert "auto_test" in result


def test_auto_enable_by_url_pattern_does_not_match(
    mock_reader: MagicMock,
    temp_extensions_dir: str,
) -> None:
    """An extension whose pattern does not match should NOT be auto-enabled."""
    # Register the same plugin as the matching test, so this test actually
    # validates that a non-matching URL does not trigger auto-enable.
    plugin_code: str = """
from discord_rss_bot.extensions.base import FeedExtension

class AutoPlugin(FeedExtension):
    name = "auto_test"
    auto_enable_url_patterns = [r"example\\.com/feeds"]

    def process_entry(self, entry, reader):
        return {"auto_var": "enabled"}
"""
    plugin_path: Path = Path(temp_extensions_dir) / "auto_plugin.py"
    plugin_path.write_text(plugin_code, encoding="utf-8")
    discover_plugins(force=True)

    mock_feed_url: str = "https://other-site.com/feed.xml"
    result: list[str] = auto_enable_extensions_for_feed(mock_reader, mock_feed_url)

    assert "auto_test" not in result


def test_auto_enable_does_not_duplicate_explicitly_enabled(
    mock_reader: MagicMock,
) -> None:
    """If an extension is already explicitly enabled, auto-enable should not add it again."""
    mock_feed_url: str = "https://example.com/feeds/test.xml"
    # Explicitly enable the extension first.
    set_enabled_extensions_for_feed(mock_reader, mock_feed_url, ["auto_test"])

    result: list[str] = auto_enable_extensions_for_feed(mock_reader, mock_feed_url)
    # Should contain auto_test only once.
    assert result == ["auto_test"]


def test_matches_feed_url_classmethod() -> None:
    """The ``matches_feed_url`` classmethod should work correctly."""
    assert FeedExtension.matches_feed_url("http://example.com") is False, "Base class has no patterns"


def test_steam_extension_has_auto_enable_patterns() -> None:
    """The built-in Steam extension should declare URL patterns."""
    assert len(SteamExtension.auto_enable_url_patterns) > 0
    assert SteamExtension.matches_feed_url("https://store.steampowered.com/feeds/news/app/570/")
    assert SteamExtension.matches_feed_url("https://steamcommunity.com/games/570/")
    assert not SteamExtension.matches_feed_url("https://example.com/feed.xml")


def test_youtube_extension_has_auto_enable_patterns() -> None:
    """The built-in YouTube extension should declare URL patterns."""
    assert len(YouTubeExtension.auto_enable_url_patterns) > 0
    assert YouTubeExtension.matches_feed_url("https://www.youtube.com/feeds/videos.xml?channel_id=123")
    assert not YouTubeExtension.matches_feed_url("https://example.com/feed.xml")


def test_hoyolab_extension_has_auto_enable_patterns() -> None:
    """The built-in Hoyolab extension should declare URL patterns."""
    assert len(HoyolabExtension.auto_enable_url_patterns) > 0
    assert HoyolabExtension.matches_feed_url("https://feeds.c3kay.de/hoyolab.xml")
    assert not HoyolabExtension.matches_feed_url("https://example.com/feed.xml")


# ---------------------------------------------------------------------------
# Integration test with a real WordPress comment RSS feed (the original issue)
# ---------------------------------------------------------------------------


_COMMENTS_FEED_XML: str = r"""<?xml version="1.0" encoding="UTF-8"?>
<rss version="2.0"
    xmlns:content="http://purl.org/rss/1.0/modules/content/"
    xmlns:dc="http://purl.org/dc/elements/1.1/"
    xmlns:atom="http://www.w3.org/2005/Atom"
    xmlns:sy="http://purl.org/rss/1.0/modules/syndication/">
<channel>
<title>Comments on: Test Article</title>
<link>https://example.com/test-article/</link>
<description></description>
<lastBuildDate>Sat, 18 Jul 2026 05:11:01 +0000</lastBuildDate>
<sy:updatePeriod>hourly</sy:updatePeriod>
<sy:updateFrequency>1</sy:updateFrequency>
<generator>https://wordpress.org/?v=5.8.2</generator>
<item>
    <title>By: Anonymous</title>
    <link>https://example.com/test-article/comment-page-1/#comment-820928</link>
    <dc:creator><![CDATA[Anonymous]]></dc:creator>
    <pubDate>Sat, 18 Jul 2026 05:11:01 +0000</pubDate>
    <guid isPermaLink="false">https://example.com/?p=5633#comment-820928</guid>
    <description><![CDATA[Am I the only one that saw the &quot;Bookmark us&quot; message?]]></description>
    <content:encoded><![CDATA[<p>Am I the only one that saw &#8220;Bookmark us&#8221; message?</p>]]></content:encoded>
</item>
<item>
    <title>By: Unknown</title>
    <link>https://example.com/test-article/comment-page-1/#comment-820900</link>
    <dc:creator><![CDATA[Unknown]]></dc:creator>
    <pubDate>Fri, 17 Jul 2026 14:29:42 +0000</pubDate>
    <guid isPermaLink="false">https://example.com/?p=5633#comment-820900</guid>
    <description><![CDATA[Please uncensor the video]]></description>
    <content:encoded><![CDATA[<p>Please uncensor the video</p>]]></content:encoded>
</item>
<item>
    <title>By: mid</title>
    <link>https://example.com/test-article/comment-page-1/#comment-820887</link>
    <dc:creator><![CDATA[mid]]></dc:creator>
    <pubDate>Fri, 17 Jul 2026 06:20:56 +0000</pubDate>
    <guid isPermaLink="false">https://example.com/?p=5633#comment-820887</guid>
    <description><![CDATA[that&#039;s not uncensored]]></description>
    <content:encoded><![CDATA[<p>that&#8217;s not uncensored</p>]]></content:encoded>
</item>
</channel>
</rss>
"""


class _CommentsFeedHandler(BaseHTTPRequestHandler):
    """Serves the WordPress comment RSS XML on any request."""

    def do_GET(self) -> None:
        self.send_response(200)
        self.send_header("Content-Type", "application/xml")
        self.end_headers()
        self.wfile.write(_COMMENTS_FEED_XML.encode("utf-8"))

    def log_message(self, _format: str, *args: str | int) -> None:
        pass


@contextmanager
def _serve_feed() -> Iterator[str]:
    """Start a local HTTP server serving the comments feed XML.

    Yields:
        The URL of the feed.
    """
    with ThreadingHTTPServer(("127.0.0.1", 0), _CommentsFeedHandler) as server:
        server_thread = Thread(target=server.serve_forever, daemon=True)
        server_thread.start()
        try:
            yield f"http://127.0.0.1:{server.server_port}/feed.xml"
        finally:
            server.shutdown()
            server_thread.join()


@pytest.mark.slow
def test_wordpress_comments_feed_pipeline() -> None:
    """End-to-end test using the WordPress comment RSS feed from the original issue.

    Validates that:
    1. The feed XML parses correctly via the reader library
    2. Entry content and summary are populated as expected
    3. The jwplayer_thumbnail extension gracefully returns empty (no script tags)
    4. Tag replacement does not crash with comment feed data
    """
    with (
        tempfile.TemporaryDirectory() as tmpdir,
        _serve_feed() as feed_url,
    ):
        db_path: Path = Path(tmpdir) / "test.sqlite"
        reader: ReaderType = make_reader(url=str(db_path))

        try:
            # Add and update the feed.
            reader.add_feed(feed_url)
            reader.update_feed(feed_url)

            feed = reader.get_feed(feed_url)
            entries: list[Entry] = list(reader.get_entries(feed=feed_url))

            # The comments feed should have 3 entries.
            assert len(entries) == 3, f"Expected 3 comments, got {len(entries)}"

            for entry in entries:
                # Each entry should have a title (comment author).
                assert entry.title is not None
                assert entry.title.startswith("By:")

                # Each entry should have a link back to the comment.
                assert entry.link is not None
                assert "comment-page" in entry.link

                # Summary should be plain text (from <description>),
                # content should be HTML (from <content:encoded>).
                assert entry.summary is not None
                assert "<p>" not in entry.summary
                if entry.content:
                    assert "<p>" in entry.content[0].value

                # The jwplayer_thumbnail extension should return empty
                # because this feed has no JWPlayer script blocks.
                ext = JWPlayerThumbnailExtension()
                result: dict[str, str] = ext.process_entry(entry, reader)  # type: ignore[arg-type]
                assert result == {}, f"JWPlayer extension should return empty for comment feed, got {result}"

                # Tag replacement should not crash.
                replaced_text: str = replace_tags_in_text_message(entry, reader)
                assert isinstance(replaced_text, str)

                # Embed replacement should not crash.
                replaced_embed = replace_tags_in_embed(feed, entry, reader)
                assert replaced_embed is not None

            # Verify content:encoded was parsed into the content field.
            first_entry = entries[0]
            assert first_entry.content is not None
            raw_content: str = first_entry.content[0].value
            assert "Bookmark us" in raw_content or "bookmark" in raw_content.lower()
            assert "<p>" in raw_content

        finally:
            reader.close()


# ---------------------------------------------------------------------------
# Main feed XML (hentaigasm-style, with JWPlayer video entries)
# ---------------------------------------------------------------------------

_MAIN_FEED_XML: str = """<?xml version="1.0" encoding="UTF-8"?>
<rss version="2.0"
    xmlns:content="http://purl.org/rss/1.0/modules/content/"
    xmlns:dc="http://purl.org/dc/elements/1.1/"
    xmlns:atom="http://www.w3.org/2005/Atom"
    xmlns:sy="http://purl.org/rss/1.0/modules/syndication/">
<channel>
<title>Hentaigasm - Test Feed</title>
<link>https://example.com</link>
<description></description>
<lastBuildDate>Sun, 19 Jul 2026 04:20:40 +0000</lastBuildDate>
<item>
    <title>Test Video 1 Subbed</title>
    <link>https://example.com/test-video-1/</link>
    <dc:creator><![CDATA[admin]]></dc:creator>
    <pubDate>Sun, 19 Jul 2026 04:00:49 +0000</pubDate>
    <guid isPermaLink="false">https://example.com/?p=5501</guid>
    <description><![CDATA[]]></description>
    <content:encoded><![CDATA[

<p style="text-align: center;"><strong>HENTAIGASM EXCLUSIVE!</strong></p>

<div style="width:620px; height:349px">
<script src="https://content.jwplatform.com/libraries/SAHhwvZq.js"></script>
<script>jwplayer.key="zTEbSn/eAplL0RLXT030FzOcek6qXmtrxju6Jg=="</script>

<div id="player_01"></div>
<script type="text/javascript">
jwplayer("player_01").setup({
    file: "https://cdn.example.com/Test Video 1 Subbed.mp4",
    width: "620",
    height: "349",
    skin: "seven",
    preload: "none",
    autostart: "false",
    image: "https://cdn.example.com/thumbnail/Test Video 1 Subbed.jpg",
    advertising: {}
});
</script>
</div>

]]></content:encoded>
</item>
</channel>
</rss>
"""


class _MainFeedHandler(BaseHTTPRequestHandler):
    """Serves the main feed XML with JWPlayer video entries."""

    def do_GET(self) -> None:
        self.send_response(200)
        self.send_header("Content-Type", "application/xml")
        self.end_headers()
        self.wfile.write(_MAIN_FEED_XML.encode("utf-8"))

    def log_message(self, _format: str, *args: str | int) -> None:
        pass


@contextmanager
def _serve_main_feed() -> Iterator[str]:
    """Start a local HTTP server serving the main feed XML with JWPlayer content.

    Yields:
        The URL of the feed.
    """
    with ThreadingHTTPServer(("127.0.0.1", 0), _MainFeedHandler) as server:
        server_thread = Thread(target=server.serve_forever, daemon=True)
        server_thread.start()
        try:
            yield f"http://127.0.0.1:{server.server_port}/feed.xml"
        finally:
            server.shutdown()
            server_thread.join()


@pytest.mark.slow
def test_hentaigasm_main_feed_jwplayer_extraction() -> None:
    """End-to-end test using a hentaigasm-style main feed with JWPlayer content.

    This test confirms that feedparser strips ``<script>`` tags from
    ``<content:encoded>``, so the JWPlayer ``image:`` and ``file:``
    properties are NOT available in ``entry.content``.

    The extension falls back to fetching the HTML page at ``entry.link``,
    but in the test environment no real server is available, so the
    extension returns empty.  A separate test validates the HTTP fetch
    fallback with a local server.
    """
    with (
        tempfile.TemporaryDirectory() as tmpdir,
        _serve_main_feed() as feed_url,
    ):
        db_path: Path = Path(tmpdir) / "test.sqlite"
        reader: ReaderType = make_reader(url=str(db_path))

        try:
            reader.add_feed(feed_url)
            reader.update_feed(feed_url)

            entries = list(reader.get_entries(feed=feed_url))

            # Should have 1 video entry.
            assert len(entries) == 1, f"Expected 1 entry, got {len(entries)}"

            entry = entries[0]
            assert entry.title is not None

            # CONFIRMATION: feedparser strips <script> tags entirely.
            # The content <p> and <div> survive, but all <script> blocks
            # (including the jwplayer setup with image:/file:) are gone.
            assert entry.content is not None
            assert len(entry.content) > 0
            raw_content: str = entry.content[0].value
            assert "jwplayer" not in raw_content, (
                f"BUG: script content survived parsing! Content: {raw_content[:300]!r}"
            )
            assert "image:" not in raw_content
            assert "file:" not in raw_content
            assert "player_01" in raw_content  # non-script div survives

            # Auto-enable is URL-based — the test feed URL (127.0.0.1) doesn't
            # match "hentaigasm\.com", so we manually enable for this test.
            set_enabled_extensions_for_feed(reader, entry.feed.url, ["jwplayer_thumbnail"])
            enabled: list[str] = get_enabled_extensions_for_feed(reader, entry.feed.url)
            assert "jwplayer_thumbnail" in enabled

        finally:
            reader.close()


@pytest.mark.slow
def test_jwplayer_thumbnail_wordpress_batch_fallback() -> None:
    """Verify the batch WordPress API fallback works.

    Serves a fake WordPress REST API response (a list of posts) so the
    extension extracts JWPlayer URLs from the cached batch data.
    """
    _SLUG_CACHE.clear()

    wp_json: str = json.dumps([
        {
            "slug": "test-slug",
            "content": {
                "rendered": (
                    '<p>Test</p><div id="player_01"></div>'
                    '<script>jwplayer("player_01").setup({'
                    'file: "https://cdn.example.com/video.mp4", '
                    'image: "https://cdn.example.com/thumb.jpg"'
                    "});</script>"
                ),
            },
        },
        {
            "slug": "other-post",
            "content": {"rendered": "<p>No player here.</p>"},
        },
    ])

    class _APIHandler(BaseHTTPRequestHandler):
        def do_GET(self) -> None:
            self.send_response(200)
            self.send_header("Content-Type", "application/json")
            self.end_headers()
            self.wfile.write(wp_json.encode("utf-8"))

        def log_message(self, _format: str, *args: str | int) -> None:
            pass

    with ThreadingHTTPServer(("127.0.0.1", 0), _APIHandler) as server:
        server_thread = Thread(target=server.serve_forever, daemon=True)
        server_thread.start()
        port: int = server.server_port

        try:
            entry = SimpleNamespace(
                id="test-wp-batch",
                content=[],
                summary="",
                link=f"http://127.0.0.1:{port}/test-slug/",
                feed=SimpleNamespace(url=f"http://127.0.0.1:{port}/feed/"),
            )

            ext = JWPlayerThumbnailExtension()
            result: dict[str, str] = ext.process_entry(entry, MagicMock())  # type: ignore[arg-type]

            assert result.get("jwplayer_thumbnail") == "https://cdn.example.com/thumb.jpg", (
                f"Batch WP fallback should extract thumbnail, got {result}"
            )
            assert result.get("jwplayer_file") == "https://cdn.example.com/video.mp4", (
                f"Batch WP fallback should extract file, got {result}"
            )

            # Second entry from the same site uses cache — no API call.
            entry2 = SimpleNamespace(
                id="other-post",
                content=[],
                summary="",
                link=f"http://127.0.0.1:{port}/other-post/",
                feed=SimpleNamespace(url=f"http://127.0.0.1:{port}/feed/"),
            )
            result2: dict[str, str] = ext.process_entry(entry2, MagicMock())  # type: ignore[arg-type]
            assert result2 == {}, "Entry without player should return empty"

        finally:
            server.shutdown()
            server_thread.join()
            _SLUG_CACHE.clear()


# ---------------------------------------------------------------------------
# Tests: WordPress extension
# ---------------------------------------------------------------------------


def test_wordpress_extension_uses_shared_batch_cache() -> None:
    """The WordPress extension should use the shared batch cache."""
    _SLUG_CACHE.clear()
    content_html: str = (
        "<p>Test</p>"
        "<script>jwplayer().setup({file: 'https://cdn.example.com/v.mp4', image: 'https://cdn.example.com/thumb.jpg'});</script>"
    )
    # Pre-populate the shared cache with the new richer format.
    _SLUG_CACHE["https://example.com"] = {
        "test-slug": {
            "content": content_html,
            "excerpt": "<p>Test excerpt</p>",
            "title": "Test Post",
        },
    }

    ext = WordPressExtension()
    entry = SimpleNamespace(
        id="test",
        link="https://example.com/test-slug/",
        feed=SimpleNamespace(url="https://example.com/feed/"),
    )
    result = ext.process_entry(entry, MagicMock())  # type: ignore[arg-type]
    assert result.get("wp_jwplayer_thumbnail") == "https://cdn.example.com/thumb.jpg"
    assert result.get("wp_jwplayer_file") == "https://cdn.example.com/v.mp4"
    assert result.get("wp_content_raw") == content_html
    assert result.get("wp_content") is not None
    assert "Test" in result.get("wp_content", "")
    assert result.get("wp_excerpt_raw") == "<p>Test excerpt</p>"
    assert result.get("wp_excerpt") is not None
    assert "Test excerpt" in result.get("wp_excerpt", "")
    # No spaces in URL values.
    for key, val in result.items():
        if key.startswith("wp_jwplayer"):
            assert " " not in val, f"URL should be encoded, got spaces: {val}"
    _SLUG_CACHE.clear()


def test_wordpress_extension_provides_correct_variables() -> None:
    """The WordPress extension should declare the correct variables."""
    expected: set[str] = {
        "wp_content",
        "wp_content_raw",
        "wp_excerpt",
        "wp_excerpt_raw",
        "wp_jwplayer_file",
        "wp_jwplayer_thumbnail",
    }
    assert set(WordPressExtension.provides_variables) == expected