"""Groepeer posts tot reeksen (novels) op auteur, titel en next-links."""

from __future__ import annotations

from collections import defaultdict
from dataclasses import dataclass, field
from typing import Iterable

from .links import Link, extract_links, links_from_ids
from .normalize import display_series_title, is_oneshot, is_story_post, normalize_title, slug


@dataclass
class Post:
    id: str
    title: str
    author: str
    created_utc: int
    permalink: str
    flair: str | None
    over_18: bool = False
    score: int = 0
    is_self: bool = True
    next_ids: tuple[str, ...] = ()
    prev_ids: tuple[str, ...] = ()
    first_ids: tuple[str, ...] = ()
    all_linked_ids: tuple[str, ...] = ()
    links: tuple[Link, ...] = ()
    wiki_path: str | None = None

    @property
    def norm_title(self) -> str:
        return normalize_title(self.title)

    @classmethod
    def from_reddit(cls, raw: dict) -> Post | None:
        pid = (raw.get("id") or "").strip().lower()
        if not pid:
            return None
        author = raw.get("author") or "[deleted]"
        title = raw.get("title") or ""
        url = raw.get("url") or ""
        permalink = raw.get("permalink") or ""
        if not permalink and "/comments/" in url:
            permalink = "/r/" + url.split("/r/", 1)[-1] if "/r/" in url else f"/r/HFY/comments/{pid}/"
        if not permalink:
            permalink = f"/r/HFY/comments/{pid}/"
        if permalink.startswith("http"):
            permalink = "/r/" + permalink.split("/r/", 1)[-1] if "/r/" in permalink else f"/r/HFY/comments/{pid}/"
        if not permalink.startswith("/"):
            permalink = f"/r/HFY/comments/{pid}/"
        if "is_self" in raw:
            is_self = bool(raw["is_self"])
        else:
            # Arctic Shift accepteert is_self niet als fields=; een externe url is een link-post.
            is_self = (not url) or ("reddit.com/" in url) or url.startswith("/r/")
        flair = raw.get("link_flair_text")
        created = int(raw.get("created_utc") or raw.get("created") or 0)
        links = extract_links(raw.get("selftext") or raw.get("selftext_html") or "")
        return cls(
            id=pid,
            title=title,
            author=author,
            created_utc=created,
            permalink=permalink,
            flair=flair,
            over_18=bool(raw.get("over_18")),
            score=int(raw.get("score") or 0),
            is_self=is_self,
            next_ids=links.next_ids,
            prev_ids=links.prev_ids,
            first_ids=links.first_ids,
            all_linked_ids=links.all_ids,
            links=links.links or links_from_ids(links.next_ids, links.prev_ids, links.first_ids, links.all_ids),
        )


@dataclass
class Novel:
    id: str
    name: str
    author: str
    chapters: list[Post] = field(default_factory=list)
    flair: str | None = None
    over_18: bool = False
    oneshot: bool = False
    wiki_path: str | None = None

    @property
    def updated_utc(self) -> int:
        return max((c.created_utc for c in self.chapters), default=0)

    @property
    def created_utc(self) -> int:
        return min((c.created_utc for c in self.chapters), default=0)

    @property
    def path(self) -> str:
        return f"series/{self.id}"


class _UnionFind:
    def __init__(self, items: Iterable[str]) -> None:
        self.parent = {i: i for i in items}

    def find(self, x: str) -> str:
        p = self.parent.setdefault(x, x)
        if p != x:
            self.parent[x] = self.find(p)
        return self.parent[x]

    def union(self, a: str, b: str) -> None:
        ra, rb = self.find(a), self.find(b)
        if ra != rb:
            self.parent[rb] = ra


def filter_story_posts(posts: Iterable[Post]) -> list[Post]:
    return [p for p in posts if is_story_post(p.flair, p.is_self, p.title) and p.author not in {"[deleted]", "[removed]"}]


def cluster_posts(posts: Iterable[Post]) -> list[Novel]:
    """Groepeer op (auteur, genormaliseerde titel) en merge via next/prev van dezelfde auteur."""
    items = filter_story_posts(posts)
    if not items:
        return []
    by_id = {p.id: p for p in items}
    uf = _UnionFind(by_id)

    # 1. Zelfde auteur + dezelfde genormaliseerde titel.
    groups: dict[tuple[str, str], list[str]] = defaultdict(list)
    for p in items:
        key = p.norm_title or f"__id_{p.id}"
        groups[(p.author.lower(), key)].append(p.id)
    for ids in groups.values():
        head = ids[0]
        for other in ids[1:]:
            uf.union(head, other)

    # 2. Expliciete next/prev/first-links tussen posts van dezelfde auteur.
    def maybe_merge(src: Post, target_id: str) -> None:
        dst = by_id.get(target_id)
        if not dst:
            return
        if src.author.lower() != dst.author.lower():
            return
        uf.union(src.id, dst.id)

    for p in items:
        for tid in p.next_ids + p.prev_ids + p.first_ids:
            maybe_merge(p, tid)

    clustered: dict[str, list[Post]] = defaultdict(list)
    for p in items:
        clustered[uf.find(p.id)].append(p)

    novels: list[Novel] = []
    for members in clustered.values():
        members.sort(key=lambda p: (p.created_utc, p.id))
        first = members[0]
        name = display_series_title([m.title for m in members])
        # Stabiel id: de oudste post. Zo blijft een reeks herkenbaar als er hoofdstukken bijkomen.
        nid = first.id
        flair = next((m.flair for m in members if m.flair), first.flair)
        novel = Novel(
            id=nid,
            name=name,
            author=first.author,
            chapters=members,
            flair=flair,
            over_18=any(m.over_18 for m in members),
            oneshot=is_oneshot(flair, len(members)),
        )
        novels.append(novel)

    novels.sort(key=lambda n: n.updated_utc, reverse=True)
    return novels


def merge_novels(existing: list[Novel], incoming: list[Novel]) -> list[Novel]:
    """Voeg een incrementele update samen: posts met hetzelfde id winnen van de nieuwe batch."""
    posts: dict[str, Post] = {}
    for novel in existing + incoming:
        for ch in novel.chapters:
            posts[ch.id] = ch
    return cluster_posts(posts.values())
