"""Generic, config-driven sources: HTML scrape, JSON API, RSS/Atom, manual.

These carry the long tail of the fleet -- Shure, Crown, Novastar, Waves,
Focusrite and friends publish version numbers on ordinary web pages with no
API behind them. Everything is declared in inventory.yaml so a broken
selector is a one-line YAML fix rather than a code change.
"""

from __future__ import annotations

import html as html_mod
import re
import xml.etree.ElementTree as ET
from datetime import datetime, timezone
from email.utils import parsedate_to_datetime

from ..models import Item, VersionCheck
from ..versions import parse
from .base import Context, error, manual

_TAG_RE = re.compile(r"<(script|style)\b.*?</\1>", re.S | re.I)
_ANY_TAG = re.compile(r"<[^>]+>")


def _visible_text(raw: str) -> str:
    text = _TAG_RE.sub(" ", raw)
    text = _ANY_TAG.sub(" ", text)
    text = html_mod.unescape(text)
    return re.sub(r"\s+", " ", text)


class HtmlSource:
    """Pull a version out of a web page with a regex.

    Inventory usage:

        source:
          kind: html
          url: https://www.resolume.com/download/
          pattern: 'Arena\\s+([\\d.]+)'
          strip_tags: true     # search visible text rather than raw markup
          select: max          # max (default) | first
          date_pattern: '([A-Z][a-z]+ \\d{1,2}, \\d{4})'   # optional
    """

    kind = "html"

    def check(self, item: Item, ctx: Context) -> VersionCheck:
        url = item.source.get("url")
        pattern = item.source.get("pattern")
        if not url or not pattern:
            return error(item, "html source requires 'url' and 'pattern'")

        resp = ctx.http.get(url, ttl=item.source.get("ttl", 3600))
        if not resp.ok:
            return error(item, f"HTTP {resp.status} from {url}")

        haystack = (
            _visible_text(resp.text)
            if item.source.get("strip_tags", True)
            else resp.text
        )

        try:
            rx = re.compile(pattern, re.I)
        except re.error as exc:
            return error(item, f"bad 'pattern' regex: {exc}")

        found = [m.group(1) if m.groups() else m.group(0) for m in rx.finditer(haystack)]
        versions = [p for p in (parse(f) for f in found) if p.valid]
        if not versions:
            return error(
                item,
                f"pattern matched nothing on {url} -- the page layout probably changed",
            )

        chosen = (
            max(versions) if item.source.get("select", "max") == "max" else versions[0]
        )

        released = None
        dpat = item.source.get("date_pattern")
        if dpat:
            dm = re.search(dpat, haystack)
            if dm:
                released = _try_dates(dm.group(1))

        return VersionCheck(
            item_id=item.id,
            latest=chosen.raw,
            released=released,
            status="ok",
            release_url=item.check_url or url,
            detail=f"scraped from {url}",
        )


def _dig(obj, path: str):
    """Walk a dotted path with optional [n] indices: 'data.releases[0].version'."""
    cur = obj
    for token in path.split("."):
        if not token:
            continue
        m = re.match(r"^([^\[\]]*)((?:\[\d+\])*)$", token)
        if not m:
            return None
        key, idxs = m.group(1), m.group(2)
        if key:
            if not isinstance(cur, dict) or key not in cur:
                return None
            cur = cur[key]
        for i in re.findall(r"\[(\d+)\]", idxs):
            if not isinstance(cur, list) or int(i) >= len(cur):
                return None
            cur = cur[int(i)]
    return cur


class JsonSource:
    """Read a version from a JSON endpoint.

    Inventory usage:

        source:
          kind: json
          url: https://example.com/api/latest.json
          version_path: data.latest.version
          date_path: data.latest.released      # optional
          notes_path: data.latest.notes        # optional
    """

    kind = "json"

    def check(self, item: Item, ctx: Context) -> VersionCheck:
        url = item.source.get("url")
        vpath = item.source.get("version_path")
        if not url or not vpath:
            return error(item, "json source requires 'url' and 'version_path'")

        resp = ctx.http.get(url, ttl=item.source.get("ttl", 3600))
        if not resp.ok:
            return error(item, f"HTTP {resp.status} from {url}")
        try:
            data = resp.json()
        except ValueError as exc:
            return error(item, f"invalid JSON from {url}: {exc}")

        raw_version = _dig(data, vpath)
        if raw_version is None:
            return error(item, f"version_path {vpath!r} not present in payload")
        ver = parse(str(raw_version))
        if not ver.valid:
            return error(item, f"unparseable version {raw_version!r}")

        released = None
        if dpath := item.source.get("date_path"):
            released = _try_dates(_dig(data, dpath))
        notes = None
        if npath := item.source.get("notes_path"):
            val = _dig(data, npath)
            notes = str(val)[:4000] if val else None

        return VersionCheck(
            item_id=item.id,
            latest=ver.raw,
            released=released,
            status="ok",
            release_notes=notes,
            release_url=item.check_url or url,
            detail=f"json:{vpath}",
        )


class RssSource:
    """Version from the newest entry title in an RSS or Atom feed.

    Inventory usage:

        source:
          kind: rss
          url: https://example.com/releases.atom
          pattern: '([\\d.]+)'
    """

    kind = "rss"

    def check(self, item: Item, ctx: Context) -> VersionCheck:
        url = item.source.get("url")
        if not url:
            return error(item, "rss source requires 'url'")

        resp = ctx.http.get(url, ttl=item.source.get("ttl", 1800))
        if not resp.ok:
            return error(item, f"HTTP {resp.status} from {url}")

        try:
            root = ET.fromstring(resp.text.encode("utf-8", "replace"))
        except ET.ParseError as exc:
            return error(item, f"malformed feed: {exc}")

        entries = _feed_entries(root)
        if not entries:
            return error(item, "feed contained no items")

        rx = re.compile(item.source.get("pattern", r"([0-9]+(?:\.[0-9]+)+)"))
        for title, link, published in entries:
            m = rx.search(title or "")
            if not m:
                continue
            ver = parse(m.group(1) if m.groups() else m.group(0))
            if not ver.valid:
                continue
            return VersionCheck(
                item_id=item.id,
                latest=ver.raw,
                released=published,
                status="ok",
                release_url=link or item.check_url or url,
                detail=title,
            )

        return error(item, "no feed entry title matched the version pattern")


def _feed_entries(root) -> list[tuple[str | None, str | None, datetime | None]]:
    ns = {"atom": "http://www.w3.org/2005/Atom"}
    out: list[tuple[str | None, str | None, datetime | None]] = []

    for it in root.iter():
        tag = it.tag.split("}")[-1]
        if tag not in ("item", "entry"):
            continue
        title = _child_text(it, ("title",))
        link = _child_text(it, ("link", "guid")) or _atom_link(it, ns)
        date_text = _child_text(it, ("pubDate", "updated", "published", "date"))
        out.append((title, link, _try_dates(date_text)))
    return out


def _child_text(el, names: tuple[str, ...]) -> str | None:
    for child in el:
        if child.tag.split("}")[-1] in names and (child.text or "").strip():
            return child.text.strip()
    return None


def _atom_link(el, ns) -> str | None:
    for child in el:
        if child.tag.split("}")[-1] == "link":
            href = child.attrib.get("href")
            if href:
                return href
    return None


_DATE_FORMATS = (
    "%Y-%m-%d", "%d %b %Y", "%d %B %Y", "%b %d, %Y", "%B %d, %Y",
    "%m/%d/%Y", "%Y/%m/%d", "%Y-%m-%dT%H:%M:%S",
)


def _try_dates(text) -> datetime | None:
    if text is None:
        return None
    if isinstance(text, (int, float)):
        # Heuristic: values that large are milliseconds.
        secs = text / 1000.0 if text > 1e11 else float(text)
        try:
            return datetime.fromtimestamp(secs, tz=timezone.utc)
        except (OverflowError, OSError, ValueError):
            return None
    text = str(text).strip()
    if not text:
        return None
    try:
        dt = datetime.fromisoformat(text.replace("Z", "+00:00"))
        return dt if dt.tzinfo else dt.replace(tzinfo=timezone.utc)
    except ValueError:
        pass
    try:
        dt = parsedate_to_datetime(text)
        if dt:
            return dt if dt.tzinfo else dt.replace(tzinfo=timezone.utc)
    except (TypeError, ValueError):
        pass
    for fmt in _DATE_FORMATS:
        try:
            return datetime.strptime(text, fmt).replace(tzinfo=timezone.utc)
        except ValueError:
            continue
    return None


class ManualSource:
    """No machine-readable feed exists (or the vendor blocks scraping).

    avwatch still tracks these: it runs the community risk scan, records what
    you tell it via ``avwatch set-installed``, and puts the item in a
    "verify by hand" section of the report with a deep link. That is a
    deliberate design choice -- a wrong scraped version is worse than an
    honest "go look".
    """

    kind = "manual"

    def check(self, item: Item, ctx: Context) -> VersionCheck:
        note = item.source.get("note") or (
            "Vendor publishes no machine-readable version feed. Check the link."
        )
        return manual(item, note)