Geeknews Search

#!/usr/bin/env python3

from __future__ import annotations

import argparse
import json
import re
import urllib.request
from dataclasses import asdict, dataclass
from html import unescape
from html.parser import HTMLParser
from pathlib import Path

GEEKNEWS_FEED_URL = "https://feeds.feedburner.com/geeknews-feed"


class _TextExtractor(HTMLParser):
    def __init__(self) -> None:
        super().__init__()
        self.parts: list[str] = []

    def handle_data(self, data: str) -> None:
        self.parts.append(data)

    def text(self) -> str:
        return " ".join(part.strip() for part in self.parts if part.strip())


@dataclass(frozen=True)
class GeekNewsItem:
    id: str
    title: str
    link: str
    published: str | None
    updated: str | None
    author_name: str | None
    author_url: str | None
    summary: str
    content_html: str

    def to_dict(self) -> dict[str, object]:
        return asdict(self)


@dataclass(frozen=True)
class GeekNewsFeed:
    title: str
    source_id: str | None
    updated: str | None
    home_url: str | None
    feed_url: str | None
    category: str | None
    items: list[GeekNewsItem]

    def source_dict(self) -> dict[str, object]:
        return {
            "title": self.title,
            "id": self.source_id,
            "updated": self.updated,
            "home_url": self.home_url,
            "feed_url": self.feed_url,
            "category": self.category,
        }


def _strip_cdata(value: str | None) -> str:
    if not value:
        return ""
    stripped = value.strip()
    if stripped.startswith("<![CDATA[") and stripped.endswith("]]>"):
        return stripped[9:-3]
    return stripped


def _collapse_whitespace(value: str) -> str:
    return re.sub(r"\s+", " ", value).strip()


def _clean_xml_text(value: str | None) -> str:
    return _collapse_whitespace(unescape(_strip_cdata(value)))


def _html_to_text(html: str) -> str:
    parser = _TextExtractor()
    parser.feed(html)
    parser.close()
    return _collapse_whitespace(unescape(parser.text()))


def _first_tag(block: str, tag: str) -> str | None:
    match = re.search(rf"<{tag}\b[^>]*>(.*?)</{tag}>", block, re.DOTALL)
    if not match:
        return None
    return _clean_xml_text(match.group(1))


def _first_raw_tag(block: str, tag: str) -> str | None:
    match = re.search(rf"<{tag}\b[^>]*>(.*?)</{tag}>", block, re.DOTALL)
    if not match:
        return None
    return _strip_cdata(match.group(1)).strip()


def _first_link_href(block: str) -> str | None:
    patterns = (
        r"<link\b[^>]*rel=['\"]alternate['\"][^>]*href=['\"]([^'\"]+)['\"]",
        r"<link\b[^>]*href=['\"]([^'\"]+)['\"]",
    )
    for pattern in patterns:
        match = re.search(pattern, block)
        if match:
            return unescape(match.group(1).strip())
    return None


def _link_href(block: str, *, rel: str | None = None) -> str | None:
    if rel:
        match = re.search(
            rf"<link\b[^>]*(?:rel|ref)=['\"]{re.escape(rel)}['\"][^>]*href=['\"]([^'\"]+)['\"]",
            block,
        )
        if match:
            return unescape(match.group(1).strip())
    return _first_link_href(block)


def _feed_prefix(xml_text: str) -> str:
    if "<entry" not in xml_text:
        return xml_text
    return xml_text.split("<entry", 1)[0]


def _entry_blocks(xml_text: str) -> list[str]:
    return re.findall(r"<entry\b[^>]*>(.*?)</entry>", xml_text, re.DOTALL)


def _validate_limit(limit: int) -> int:
    if limit <= 0:
        raise ValueError("limit must be positive")
    return limit


def load_feed(xml_text: str) -> GeekNewsFeed:
    prefix = _feed_prefix(xml_text)
    items = []
    for entry in _entry_blocks(xml_text):
        author_block_match = re.search(r"<author\b[^>]*>(.*?)</author>", entry, re.DOTALL)
        author_block = author_block_match.group(1) if author_block_match else ""
        content_html = (_first_raw_tag(entry, "content") or "").strip()
        items.append(
            GeekNewsItem(
                id=_first_tag(entry, "id") or "",
                title=_first_tag(entry, "title") or "",
                link=_first_link_href(entry) or (_first_tag(entry, "id") or ""),
                published=_first_tag(entry, "published") or _first_tag(entry, "updated"),
                updated=_first_tag(entry, "updated"),
                author_name=_first_tag(author_block, "name"),
                author_url=_first_tag(author_block, "uri"),
                summary=_html_to_text(content_html),
                content_html=content_html,
            )
        )

    category_match = re.search(r"<category\b[^>]*term=['\"]([^'\"]+)['\"]", prefix)
    return GeekNewsFeed(
        title=_first_tag(prefix, "title") or "GeekNews",
        source_id=_first_tag(prefix, "id"),
        updated=_first_tag(prefix, "updated"),
        home_url=_link_href(prefix, rel="alternate"),
        feed_url=_link_href(prefix, rel="self") or _first_tag(prefix, "id"),
        category=category_match.group(1) if category_match else None,
        items=items,
    )


def list_items(feed: GeekNewsFeed, limit: int = 10) -> list[GeekNewsItem]:
    return feed.items[:_validate_limit(limit)]


def search_items(feed: GeekNewsFeed, query: str, limit: int = 10) -> list[GeekNewsItem]:
    if not query.strip():
        raise ValueError("query is required")
    limit = _validate_limit(limit)
    needle = query.casefold()
    matches = []
    for item in feed.items:
        haystack = "\n".join(
            part
            for part in (
                item.title,
                item.summary,
                item.author_name or "",
                item.author_url or "",
                item.id,
                item.link,
            )
            if part
        ).casefold()
        if needle in haystack:
            matches.append(item)
        if len(matches) >= limit:
            break
    return matches


def get_item_detail(feed: GeekNewsFeed, lookup: str) -> GeekNewsItem:
    normalized_lookup = lookup.strip().casefold()
    if not normalized_lookup:
        raise ValueError("lookup is required")
    for item in feed.items:
        candidates = [item.id, item.link, item.title]
        lowered = [candidate.casefold() for candidate in candidates if candidate]
        if normalized_lookup in lowered or any(normalized_lookup in candidate for candidate in lowered):
            return item
    raise LookupError(f"No GeekNews entry matched: {lookup}")


def _serialize_items(items: list[GeekNewsItem]) -> list[dict[str, object]]:
    return [item.to_dict() for item in items]


def build_list_payload(feed: GeekNewsFeed, limit: int = 10) -> dict[str, object]:
    items = list_items(feed, limit=limit)
    return {"source": feed.source_dict(), "count": len(items), "items": _serialize_items(items)}


def build_search_payload(feed: GeekNewsFeed, query: str, limit: int = 10) -> dict[str, object]:
    items = search_items(feed, query=query, limit=limit)
    return {
        "source": feed.source_dict(),
        "query": query,
        "count": len(items),
        "items": _serialize_items(items),
    }


def build_detail_payload(feed: GeekNewsFeed, lookup: str) -> dict[str, object]:
    item = get_item_detail(feed, lookup)
    return {"source": feed.source_dict(), "item": item.to_dict()}


def fetch_feed(url: str = GEEKNEWS_FEED_URL, timeout: int = 20) -> str:
    request = urllib.request.Request(url, headers={"User-Agent": "k-skill-geeknews/1.0"})
    with urllib.request.urlopen(request, timeout=timeout) as response:
        charset = response.headers.get_content_charset() or "utf-8"
        return response.read().decode(charset, errors="replace")


def _add_feed_source_args(parser: argparse.ArgumentParser) -> None:
    parser.add_argument("--feed-url", default=GEEKNEWS_FEED_URL, help="기본값: GeekNews public feed URL")
    parser.add_argument("--feed-file", help="테스트/오프라인 검증용 로컬 Atom XML 파일")


def parse_args(argv: list[str] | None = None) -> argparse.Namespace:
    parser = argparse.ArgumentParser(description="Read GeekNews entries from the public RSS/Atom feed.")

    subparsers = parser.add_subparsers(dest="command", required=True)

    list_parser = subparsers.add_parser("list", help="최신 GeekNews 항목 목록")
    _add_feed_source_args(list_parser)
    list_parser.add_argument("--limit", type=int, default=10)

    search_parser = subparsers.add_parser("search", help="제목/요약/작성자 기준 검색")
    _add_feed_source_args(search_parser)
    search_parser.add_argument("--query", required=True)
    search_parser.add_argument("--limit", type=int, default=10)

    detail_parser = subparsers.add_parser("detail", help="항목 상세 확인")
    _add_feed_source_args(detail_parser)
    detail_parser.add_argument("--id", required=True, help="entry id/link/topic id 일부")

    return parser.parse_args(argv)


def _load_feed_text(args: argparse.Namespace) -> str:
    if args.feed_file:
        return Path(args.feed_file).read_text(encoding="utf-8")
    return fetch_feed(url=args.feed_url)


def main(argv: list[str] | None = None) -> None:
    args = parse_args(argv)
    feed = load_feed(_load_feed_text(args))

    if args.command == "list":
        payload = build_list_payload(feed, limit=args.limit)
    elif args.command == "search":
        payload = build_search_payload(feed, query=args.query, limit=args.limit)
    else:
        payload = build_detail_payload(feed, lookup=args.id)

    print(json.dumps(payload, ensure_ascii=False, indent=2))


if __name__ == "__main__":
    main()