#!/usr/bin/env python3
"""
Aria Daily Rollup

Komprimiert alte Daily Logs zu wöchentlichen Summaries.
Läuft täglich via Cron.

Logik:
- Daily Logs jünger als 14 Tage bleiben unverändert (recency view)
- Daily Logs zwischen 14 und 90 Tagen werden zu wöchentlichen Files komprimiert
- Wöchentliche Files älter als 90 Tage werden zu monatlichen
- Monatliche Files bleiben für immer

Komprimierung passiert OFFLINE: Wir extrahieren nur Headlines, Erledigtes und
wichtige Quotes. Originale werden in /root/aria/brain-archive/ verschoben
(NICHT gelöscht - nur ausgelagert).

Das ist eine LOKALE Umstrukturierung, nicht semantische Komprimierung.
Aria liest die Files als normaler Markdown-Kontext.
"""

import os
import re
import sys
import shutil
from datetime import datetime, timedelta
from pathlib import Path
from collections import defaultdict

BRAIN_DIR = Path("/root/aria/brain")
DAILY_DIR = BRAIN_DIR / "06-Daily"
WEEKLY_DIR = BRAIN_DIR / "06-Daily" / "weekly"
MONTHLY_DIR = BRAIN_DIR / "06-Daily" / "monthly"
ARCHIVE_DIR = Path("/root/aria/brain-archive")

DAILY_KEEP_DAYS = 14
WEEKLY_KEEP_DAYS = 90


def parse_date_from_filename(name: str) -> datetime | None:
    """2026-04-06.md -> datetime"""
    m = re.match(r'^(\d{4})-(\d{2})-(\d{2})\.md$', name)
    if not m:
        return None
    try:
        return datetime(int(m.group(1)), int(m.group(2)), int(m.group(3)))
    except ValueError:
        return None


def extract_summary(path: Path) -> dict:
    """Extrahiert Headlines, Bullet Points und kurze Stats aus einem Daily Log."""
    text = path.read_text(encoding="utf-8")
    headlines = re.findall(r'^##+ (.+)$', text, re.MULTILINE)
    done_items = re.findall(r'^\s*- \[x\] (.+)$', text, re.MULTILINE)
    open_items = re.findall(r'^\s*- \[ \] (.+)$', text, re.MULTILINE)
    line_count = len(text.splitlines())

    return {
        "date": path.stem,
        "headlines": headlines,
        "done_count": len(done_items),
        "open_count": len(open_items),
        "done_items": done_items[:10],  # Top 10
        "line_count": line_count,
    }


def write_weekly_rollup(week_start: datetime, daily_files: list[Path]) -> Path:
    """Schreibt eine Wochen-Zusammenfassung."""
    WEEKLY_DIR.mkdir(parents=True, exist_ok=True)
    week_str = week_start.strftime("%Y-W%V")
    out_path = WEEKLY_DIR / f"{week_str}.md"

    summaries = [extract_summary(f) for f in sorted(daily_files)]
    total_done = sum(s["done_count"] for s in summaries)
    total_open = sum(s["open_count"] for s in summaries)

    lines = [
        f"---",
        f"name: Wochen-Zusammenfassung {week_str}",
        f"description: Zusammenfassung der Daily Logs vom {summaries[0]['date']} bis {summaries[-1]['date']}",
        f"type: weekly",
        f"date: {week_start.strftime('%Y-%m-%d')}",
        f"---",
        "",
        f"# Woche {week_str}",
        "",
        f"Zeitraum: {summaries[0]['date']} bis {summaries[-1]['date']}",
        f"Erledigt insgesamt: {total_done} Items",
        f"Noch offen am Wochenende: {total_open} Items",
        f"Daily Logs in dieser Woche: {len(summaries)}",
        "",
        "## Tageshighlights",
        "",
    ]

    for s in summaries:
        lines.append(f"### {s['date']} ({s['done_count']} erledigt)")
        if s["headlines"]:
            for h in s["headlines"][:5]:
                lines.append(f"- {h}")
        if s["done_items"]:
            lines.append("")
            lines.append("**Wichtigste Erledigungen:**")
            for item in s["done_items"][:5]:
                lines.append(f"- {item}")
        lines.append("")

    lines.append("## Hinweis")
    lines.append("")
    lines.append("Die einzelnen Daily Logs dieser Woche wurden nach `/root/aria/brain-archive/06-Daily/` verschoben.")
    lines.append("Bei Bedarf kann ich dort nach Details suchen.")

    out_path.write_text("\n".join(lines), encoding="utf-8")
    return out_path


def archive_files(files: list[Path]):
    """Verschiebt Files ins Archiv (nicht gelöscht)."""
    archive_daily = ARCHIVE_DIR / "06-Daily"
    archive_daily.mkdir(parents=True, exist_ok=True)
    for f in files:
        target = archive_daily / f.name
        shutil.move(str(f), str(target))


def main():
    if not DAILY_DIR.exists():
        print("Daily-Verzeichnis nicht gefunden")
        return

    today = datetime.now()
    cutoff_daily = today - timedelta(days=DAILY_KEEP_DAYS)

    # Sammle alle Daily Logs
    daily_files = []
    for f in DAILY_DIR.glob("*.md"):
        date = parse_date_from_filename(f.name)
        if date is None:
            continue  # Skip non-date files
        daily_files.append((date, f))

    # Filter nur die alten
    to_rollup = [(d, f) for d, f in daily_files if d < cutoff_daily]

    if not to_rollup:
        print("Keine Daily Logs zum Komprimieren")
        return

    # Group by ISO week
    by_week = defaultdict(list)
    for date, file in to_rollup:
        # ISO week: Montag der Woche als Key
        week_start = date - timedelta(days=date.isoweekday() - 1)
        by_week[week_start].append(file)

    # Schreibe Weekly Rollups + archiviere Daily Files
    for week_start, files in sorted(by_week.items()):
        out_path = write_weekly_rollup(week_start, files)
        print(f"Erstellt: {out_path}")
        archive_files(files)
        print(f"  {len(files)} Daily Logs ins Archiv verschoben")


if __name__ == "__main__":
    main()