"""Meta AI — blog listing (ai.meta.com/blog) → ANNOUNCEMENT events, release posts queued for LLM extraction.

The listing has no RSS (404). It is server-rendered twice: React cards (title link + "Mon D, YYYY" date + category) and a `<noscript>`
list view (h4 title, "Month DD, YYYY" date, "Learn More" link). Both are parsed; items are deduplicated by URL.

llama.com (redirects to developer.meta.com/ai) is a client-rendered Comet app: the HTML contains no model list at all (SSR disabled,
`fail_bad_preloaders`), so no Llama model target is emitted — Llama model facts come from the release posts (LLM) and other connectors.
"""
from __future__ import annotations

import re

from selectolax.parser import HTMLParser, Node

from aiatlas.registry import org_ref
from aiatlas.sdk.connector import BaseConnector, Parsed, RunContext
from aiatlas.sdk.extract.dates import parse_datetime
from aiatlas.sdk.extract.feeds import FeedItem
from aiatlas.sdk.extract.html import node_text
from aiatlas.sdk.facts import Facts, Target
from aiatlas.sdk.fetch import FetchResult

from ._common import announcement_events

BLOG = "https://ai.meta.com/blog/"
POST_URL = re.compile(r"^https://ai\.meta\.com/blog/[^/?#]+/?$")
DATE = re.compile(r"\b(January|February|March|April|May|June|July|August|September|October|November|December|Jan|Feb|Mar|Apr|Jun|Jul|Aug|Sep|Sept|Oct|Nov|Dec)\.? \d{1,2}, \d{4}\b")
CATEGORIES = ("Research", "Open Source", "Computer Vision", "Product", "Responsible AI", "Developer", "Blog", "FEATURED", "Speech & Audio", "Large Language Models",
              "Generative AI", "Hardware", "Robotics", "Infrastructure")
NOISE = {"", "learn more", "featured", "read more"}


class MetaAIConnector(BaseConnector):
    name = "meta_ai"
    label = "Meta AI — blog"
    description = "AI at Meta blog listing: announcements and research posts (no feed available; HTML listing parsed)."
    source_key = "ai.meta.com"
    version = "1"
    parser_version = "1"
    interval_seconds = 3600
    min_interval_seconds = 1800
    rate_per_min = 10
    tier = 1
    priority = 1
    expected_min_records = 1
    concurrency = 1

    async def discover(self, ctx: RunContext) -> list[Target]:
        return [Target(url=BLOG, doc_type="listing", key="blog", min_bytes=5000)]

    async def extract(self, ctx: RunContext, target: Target, res: FetchResult, parsed: Parsed) -> Facts:
        facts = Facts()
        org = org_ref("meta-ai")
        facts.entities.append(org)
        if (target.key or "") == "blog" and parsed.html:
            # fresh parse: the SDK's parse_html decomposes <noscript> (where the server-rendered list view lives) from the tree it keeps
            items = listing_items(HTMLParser(res.content).body)
            announcement_events(facts, org, items, source_name="ai.meta.com/blog", max_follow=15)
            facts.document_title, facts.document_entity = "AI at Meta blog", org
        return facts


def listing_items(root: Node | None) -> list[FeedItem]:
    if root is None:
        return []
    by_url: dict[str, FeedItem] = {}
    for a in root.css("a[href]"):
        href = (a.attributes.get("href") or "").strip()
        if not POST_URL.match(href):
            continue
        url = href if href.endswith("/") else href + "/"
        title = node_text(a)
        aria = a.attributes.get("aria-label") or ""
        if title.lower() in NOISE or len(title) < 8:
            title = re.sub(r"^Read\s+", "", aria).strip() if aria else ""
        date = None
        category = None
        node: Node | None = a
        # climb to the smallest container that still describes this single post (stop before a node holding other posts)
        for _ in range(8):
            node = node.parent if node else None
            if node is None or node.tag in ("body", "html"):
                break
            others = {(x.attributes.get("href") or "").rstrip("/") for x in node.css("a[href]") if POST_URL.match(x.attributes.get("href") or "")}
            if len(others) > 1:
                break
            text = node_text(node)
            if date is None:
                m = DATE.search(text)
                if m:
                    date = parse_datetime(m.group(0))
            if not title:
                h = node.css_first("h4, h3, h2")
                title = node_text(h) if h else ""
            if category is None:
                for c in CATEGORIES:
                    if c not in ("FEATURED", "Blog") and re.search(rf"(^|\n| ){re.escape(c)}(\n| |$)", text):
                        category = c
                        break
            if date is not None and title:
                break
        if not title:
            continue
        item = by_url.get(url)
        if item is None:
            by_url[url] = FeedItem(id=url, url=url, title=title[:300], summary=None, published_at=date, updated_at=None, categories=[category] if category else [])
        else:
            if item.published_at is None and date:
                item.published_at = date
            if not item.categories and category:
                item.categories = [category]
    return sorted(by_url.values(), key=lambda it: it.published_at.timestamp() if it.published_at else 0, reverse=True)


CONNECTORS = [MetaAIConnector]