"""Schrijf een statische, gesplitste metadata-index (geen verhaaltekst)."""

from __future__ import annotations

import json
from datetime import datetime, timezone
from pathlib import Path
from typing import Iterable

from .cluster import Novel
from .covers import prune_unused_covers, write_cover

PAGE_SIZE = 50
SCHEMA_VERSION = 1


def _iso(ts: int) -> str | None:
    if not ts:
        return None
    return datetime.fromtimestamp(ts, tz=timezone.utc).strftime("%Y-%m-%dT%H:%M:%SZ")


def infer_status(novel: Novel, now: int | None = None) -> str:
    """Grove status: 180 dagen zonder update = On Hiatus, verder Unknown."""
    if not novel.chapters:
        return "Unknown"
    now = now or int(datetime.now(tz=timezone.utc).timestamp())
    age = now - novel.updated_utc
    if novel.oneshot:
        return "Completed"
    if age > 180 * 24 * 3600:
        return "On Hiatus"
    return "Ongoing"


def novel_to_listing(novel: Novel, cover: str | None = None) -> dict:
    return {
        "id": novel.id,
        "name": novel.name,
        "path": novel.path,
        "author": novel.author,
        "cover": cover,
        "updated": _iso(novel.updated_utc),
        "created": _iso(novel.created_utc),
        "chapters": len(novel.chapters),
        "flair": novel.flair,
        "nsfw": novel.over_18,
        "oneshot": novel.oneshot,
    }


def novel_to_detail(novel: Novel, cover: str | None = None) -> dict:
    listing = novel_to_listing(novel, cover=cover)
    listing.update(
        {
            "status": infer_status(novel),
            "genres": ", ".join(
                x for x in ["HFY", novel.flair or ("OneShot" if novel.oneshot else "Series")] if x
            ),
            "wikiPath": novel.wiki_path,
            "summary": (
                f"{len(novel.chapters)} hoofdstuk{'en' if len(novel.chapters) != 1 else ''} "
                f"op r/HFY door u/{novel.author}."
                + (f" Laatste: {novel.chapters[-1].title}." if novel.chapters else "")
            ),
            "chapterList": [
                {
                    "name": ch.title,
                    "path": f"chapter/{ch.id}",
                    "releaseTime": _iso(ch.created_utc),
                    "chapterNumber": i,
                    "redditId": ch.id,
                    "permalink": ch.permalink,
                    "nextIds": list(ch.next_ids),
                    "prevIds": list(ch.prev_ids),
                    "firstIds": list(ch.first_ids),
                }
                for i, ch in enumerate(novel.chapters, start=1)
            ],
        }
    )
    return listing


def series_relpath(novel_id: str) -> str:
    prefix = (novel_id[:1] or "x").lower()
    return f"series/{prefix}/{novel_id}.json"


def write_index(
    novels: Iterable[Novel],
    dest: Path,
    page_size: int = PAGE_SIZE,
    source: str = "r/HFY wiki-serie-index via Arctic Shift (metadata only; no story text)",
) -> dict:
    dest = Path(dest)
    dest.mkdir(parents=True, exist_ok=True)
    items = list(novels)
    items.sort(key=lambda n: n.updated_utc, reverse=True)

    covers: dict[str, str] = {}
    for novel in items:
        covers[novel.id] = write_cover(dest, novel.name)
    prune_unused_covers(dest, set(covers.values()))

    # Oude shards opruimen zodat verwijderde reeksen niet blijven staan.
    series_root = dest / "series"
    if series_root.exists():
        for old in series_root.rglob("*.json"):
            old.unlink()

    catalog_dir = dest / "catalog"
    catalog_dir.mkdir(parents=True, exist_ok=True)
    for old in catalog_dir.glob("page-*.json"):
        old.unlink()

    pages = []
    for i in range(0, max(len(items), 1), page_size):
        chunk = items[i : i + page_size]
        page_no = i // page_size + 1
        payload = {
            "schemaVersion": SCHEMA_VERSION,
            "page": page_no,
            "novels": [novel_to_listing(n, cover=covers.get(n.id)) for n in chunk],
        }
        name = f"page-{page_no:04d}.json"
        (catalog_dir / name).write_text(json.dumps(payload, ensure_ascii=False, indent=2) + "\n", encoding="utf-8")
        pages.append({"page": page_no, "path": f"catalog/{name}", "count": len(chunk)})

        for novel in chunk:
            rel = series_relpath(novel.id)
            path = dest / rel
            path.parent.mkdir(parents=True, exist_ok=True)
            path.write_text(json.dumps(novel_to_detail(novel, cover=covers.get(novel.id)), ensure_ascii=False, indent=2) + "\n", encoding="utf-8")

    search = [
        {
            "id": n.id,
            "name": n.name,
            "author": n.author,
            "path": n.path,
            "oneshot": n.oneshot,
            "nsfw": n.over_18,
        }
        for n in items
    ]
    (dest / "search-index.json").write_text(
        json.dumps({"schemaVersion": SCHEMA_VERSION, "novels": search}, ensure_ascii=False) + "\n",
        encoding="utf-8",
    )

    meta = {
        "schemaVersion": SCHEMA_VERSION,
        "generatedAt": datetime.now(tz=timezone.utc).strftime("%Y-%m-%dT%H:%M:%SZ"),
        "source": source,
        "novelCount": len(items),
        "chapterCount": sum(len(n.chapters) for n in items),
        "pageSize": page_size,
        "pageCount": len(pages),
        "pages": pages,
        "searchIndex": "search-index.json",
        "seriesPath": "series/{firstLetter}/{id}.json",
    }
    (dest / "catalog-meta.json").write_text(json.dumps(meta, ensure_ascii=False, indent=2) + "\n", encoding="utf-8")
    return meta


def read_existing_posts(dest: Path) -> list[dict]:
    """Lees eerder geschreven reeksen terug als platte post-dicts (zonder selftext)."""
    from .cluster import Post
    from .links import links_from_ids

    posts: list[Post] = []
    series_root = Path(dest) / "series"
    if not series_root.exists():
        return []
    for path in series_root.rglob("*.json"):
        data = json.loads(path.read_text(encoding="utf-8"))
        author = data.get("author") or "Anonymous"
        for ch in data.get("chapterList") or []:
            pid = (ch.get("redditId") or "").strip().lower()
            if not pid:
                continue
            rel = ch.get("releaseTime")
            created = 0
            if rel:
                try:
                    created = int(datetime.fromisoformat(rel.replace("Z", "+00:00")).timestamp())
                except ValueError:
                    created = 0
            next_ids = tuple(ch.get("nextIds") or ())
            prev_ids = tuple(ch.get("prevIds") or ())
            first_ids = tuple(ch.get("firstIds") or ())
            posts.append(
                Post(
                    id=pid,
                    title=ch.get("name") or "",
                    author=author,
                    created_utc=created,
                    permalink=ch.get("permalink") or f"/r/HFY/comments/{pid}/",
                    flair=data.get("flair"),
                    over_18=bool(data.get("nsfw")),
                    is_self=True,
                    next_ids=next_ids,
                    prev_ids=prev_ids,
                    first_ids=first_ids,
                    links=links_from_ids(next_ids, prev_ids, first_ids),
                    wiki_path=data.get("wikiPath"),
                )
            )
    return posts
