"""Journal Day, Draft, Entry and Space product store. Source messages stay in dialogue_store."""
from __future__ import annotations

import json
import re
import uuid
from datetime import datetime, timezone

from dialogue_store import (
    StoreError,
    create_conversation,
    create_space,
    get_space,
    list_conversations_for_day,
    list_spaces,
    rename_space,
    start_usage_session,
)
from db import _insert_source_refs, get_db, row_to_dict
from journal_policy import consolidation_offer, require_origin
from journal_body import clean_title, to_markdown

DATE_RE = re.compile(r"^\d{4}-\d{2}-\d{2}$")
SCRATCH_MAX_ITEMS = 40
SCRATCH_MAX_TEXT = 400


def _now() -> str:
    return datetime.now(timezone.utc).replace(microsecond=0).isoformat()


def _parse_ids(raw: str | None) -> list[str]:
    if not raw:
        return []
    try:
        data = json.loads(raw)
    except json.JSONDecodeError:
        return []
    if not isinstance(data, list):
        return []
    return [str(item) for item in data]


def _load_source_ids(conn, table: str, owner_col: str, owner_id: str, row: dict | None) -> tuple[list[str], list[str]]:
    refs = conn.execute(
        f"""
        SELECT source_kind, source_id, sort_order
        FROM {table}
        WHERE {owner_col} = ?
        ORDER BY source_kind, sort_order
        """,
        (owner_id,),
    ).fetchall()
    conversations: list[str] = []
    messages: list[str] = []
    for item in refs:
        kind = item["source_kind"]
        source_id = item["source_id"]
        if kind == "conversation":
            conversations.append(source_id)
        elif kind == "message":
            messages.append(source_id)
    if conversations or messages:
        return conversations, messages
    row = row or {}
    return _parse_ids(row.get("source_conversation_ids")), _parse_ids(row.get("source_message_ids"))


def _attach_sources(conn, table: str, owner_col: str, owner_id: str, row: dict | None) -> dict | None:
    if not row:
        return None
    conversations, messages = _load_source_ids(conn, table, owner_col, owner_id, row)
    row["source_conversation_ids"] = conversations
    row["source_message_ids"] = messages
    row["title"] = clean_title(row.get("title") or "")
    return row


def _owned(conn, table: str, record_id: str, profile_id: str) -> dict | None:
    return row_to_dict(
        conn.execute(
            f"SELECT * FROM {table} WHERE id = ? AND profile_id = ?",
            (record_id, profile_id),
        ).fetchone()
    )


def _decode_draft(conn, row: dict | None) -> dict | None:
    if not row:
        return None
    return _attach_sources(conn, "journal_draft_source_refs", "draft_id", row["id"], row)


def _decode_version(conn, row: dict | None) -> dict | None:
    if not row:
        return None
    owner_id = row.get("current_version_id") or row.get("id")
    return _attach_sources(conn, "journal_entry_version_source_refs", "version_id", owner_id, row)


def create_user_space(profile_id: str, title: str) -> dict:
    if not (title or "").strip():
        raise StoreError("empty_title", "Space-Name darf nicht leer sein")
    return create_space(profile_id, title.strip(), visibility="user")


def list_user_spaces(profile_id: str) -> list[dict]:
    return list_spaces(profile_id, visibility="user")


def get_user_space(profile_id: str, space_id: str) -> dict:
    space = get_space(profile_id, space_id)
    if space.get("visibility") != "user":
        raise StoreError("not_found", "Reflection Space nicht gefunden", 404)
    return space


def rename_user_space(profile_id: str, space_id: str, title: str) -> dict:
    get_user_space(profile_id, space_id)
    return rename_space(profile_id, space_id, title)


def get_or_create_day(profile_id: str, space_id: str, calendar_date: str) -> dict:
    get_user_space(profile_id, space_id)
    if not DATE_RE.match(calendar_date or ""):
        raise StoreError("invalid_date", "calendar_date muss YYYY-MM-DD sein")
    with get_db() as conn:
        existing = row_to_dict(
            conn.execute(
                """
                SELECT * FROM journal_days
                WHERE profile_id = ? AND space_id = ? AND calendar_date = ?
                """,
                (profile_id, space_id, calendar_date),
            ).fetchone()
        )
        if existing:
            return existing
        day_id = str(uuid.uuid4())
        conn.execute(
            """
            INSERT INTO journal_days (id, profile_id, space_id, calendar_date)
            VALUES (?, ?, ?, ?)
            """,
            (day_id, profile_id, space_id, calendar_date),
        )
        return row_to_dict(conn.execute("SELECT * FROM journal_days WHERE id = ?", (day_id,)).fetchone())


def get_day(profile_id: str, journal_day_id: str) -> dict:
    with get_db() as conn:
        day = _owned(conn, "journal_days", journal_day_id, profile_id)
    if not day:
        raise StoreError("not_found", "Journal Day nicht gefunden", 404)
    return day


def list_days(profile_id: str, space_id: str) -> list[dict]:
    get_user_space(profile_id, space_id)
    with get_db() as conn:
        rows = conn.execute(
            """
            SELECT d.*,
                   (SELECT COUNT(*) FROM conversations c
                     WHERE c.journal_day_id = d.id AND c.profile_id = d.profile_id) AS conversation_count,
                   (SELECT COUNT(*) FROM journal_entries e
                     WHERE e.journal_day_id = d.id AND e.profile_id = d.profile_id AND e.deleted_at IS NULL
                   ) AS entry_count
            FROM journal_days d
            WHERE d.profile_id = ? AND d.space_id = ?
            ORDER BY d.calendar_date DESC
            """,
            (profile_id, space_id),
        ).fetchall()
    result = []
    for row in rows:
        item = row_to_dict(row)
        entry = current_entries(profile_id, item["id"])
        item["entry_title"] = (entry[-1].get("title") if entry else "") or ""
        item["entry_id"] = entry[-1]["id"] if entry else None
        result.append(item)
    return result


def create_day_conversation(profile_id: str, journal_day_id: str, title: str = "") -> dict:
    day = get_day(profile_id, journal_day_id)
    usage = start_usage_session(profile_id, intent="journal")
    return create_conversation(
        profile_id,
        usage_session_id=usage["id"],
        title=title or "Gespräch",
        space_id=day["space_id"],
        journal_day_id=day["id"],
    )


def current_draft(profile_id: str, journal_day_id: str) -> dict | None:
    get_day(profile_id, journal_day_id)
    with get_db() as conn:
        row = row_to_dict(
            conn.execute(
                """
                SELECT * FROM journal_drafts
                WHERE profile_id = ? AND journal_day_id = ? AND superseded_at IS NULL
                ORDER BY created DESC
                LIMIT 1
                """,
                (profile_id, journal_day_id),
            ).fetchone()
        )
        return _decode_draft(conn, row)


def insert_draft(
    profile_id: str,
    journal_day_id: str,
    title: str,
    body: str,
    source_conversation_ids: list[str],
    source_message_ids: list[str],
) -> dict:
    get_day(profile_id, journal_day_id)
    draft_id = str(uuid.uuid4())
    as_of = _now()
    with get_db() as conn:
        conn.execute(
            """
            UPDATE journal_drafts
            SET superseded_at = ?
            WHERE profile_id = ? AND journal_day_id = ? AND superseded_at IS NULL
            """,
            (as_of, profile_id, journal_day_id),
        )
        conn.execute(
            """
            INSERT INTO journal_drafts
              (id, profile_id, journal_day_id, title, body,
               source_conversation_ids, source_message_ids, as_of)
            VALUES (?, ?, ?, ?, ?, ?, ?, ?)
            """,
            (
                draft_id,
                profile_id,
                journal_day_id,
                clean_title(title),
                body or "",
                "[]",
                "[]",
                as_of,
            ),
        )
        _insert_source_refs(
            conn,
            "journal_draft_source_refs",
            "draft_id",
            draft_id,
            profile_id,
            source_conversation_ids or [],
            source_message_ids or [],
        )
        row = row_to_dict(conn.execute("SELECT * FROM journal_drafts WHERE id = ?", (draft_id,)).fetchone())
        return _decode_draft(conn, row)


def current_entries(profile_id: str, journal_day_id: str) -> list[dict]:
    with get_db() as conn:
        rows = conn.execute(
            """
            SELECT e.*, v.title, v.body, v.origin, v.source_conversation_ids, v.source_message_ids, v.created AS version_created
            FROM journal_entries e
            LEFT JOIN journal_entry_versions v ON v.id = e.current_version_id
            WHERE e.profile_id = ? AND e.journal_day_id = ? AND e.deleted_at IS NULL
            ORDER BY e.created
            """,
            (profile_id, journal_day_id),
        ).fetchall()
        return [_decode_version(conn, row_to_dict(row)) for row in rows]


def get_entry(profile_id: str, entry_id: str, include_deleted: bool = False) -> dict:
    with get_db() as conn:
        entry = _owned(conn, "journal_entries", entry_id, profile_id)
        if not entry:
            raise StoreError("not_found", "Journal Entry nicht gefunden", 404)
        if entry.get("deleted_at") and not include_deleted:
            raise StoreError("not_found", "Journal Entry nicht gefunden", 404)
        version = None
        if entry.get("current_version_id"):
            version = _decode_version(
                conn,
                row_to_dict(
                    conn.execute(
                        "SELECT * FROM journal_entry_versions WHERE id = ? AND profile_id = ?",
                        (entry["current_version_id"], profile_id),
                    ).fetchone()
                ),
            )
    entry["version"] = version
    if version:
        entry["title"] = version.get("title") or ""
        entry["body"] = version.get("body") or ""
        entry["origin"] = version.get("origin")
        entry["source_conversation_ids"] = version.get("source_conversation_ids") or []
        entry["source_message_ids"] = version.get("source_message_ids") or []
    return entry


def list_versions(profile_id: str, entry_id: str) -> list[dict]:
    get_entry(profile_id, entry_id, include_deleted=True)
    with get_db() as conn:
        rows = conn.execute(
            """
            SELECT * FROM journal_entry_versions
            WHERE profile_id = ? AND entry_id = ?
            ORDER BY created
            """,
            (profile_id, entry_id),
        ).fetchall()
        return [_decode_version(conn, row_to_dict(row)) for row in rows]


def save_entry(
    profile_id: str,
    journal_day_id: str,
    title: str,
    body: str,
    origin: str,
    entry_id: str | None = None,
    source_conversation_ids: list[str] | None = None,
    source_message_ids: list[str] | None = None,
) -> dict:
    require_origin(origin)
    day = get_day(profile_id, journal_day_id)
    version_id = str(uuid.uuid4())
    with get_db() as conn:
        if entry_id:
            entry = _owned(conn, "journal_entries", entry_id, profile_id)
            if not entry or entry.get("deleted_at"):
                raise StoreError("not_found", "Journal Entry nicht gefunden", 404)
            if entry["journal_day_id"] != journal_day_id:
                raise StoreError("assignment_mismatch", "Entry gehört zu einem anderen Journal Day")
        else:
            entry_id = str(uuid.uuid4())
            conn.execute(
                """
                INSERT INTO journal_entries (id, profile_id, journal_day_id, space_id)
                VALUES (?, ?, ?, ?)
                """,
                (entry_id, profile_id, journal_day_id, day["space_id"]),
            )
        conn.execute(
            """
            INSERT INTO journal_entry_versions
              (id, profile_id, entry_id, title, body, source_conversation_ids, source_message_ids, origin, created)
            VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)
            """,
            (
                version_id,
                profile_id,
                entry_id,
                clean_title(title),
                to_markdown(body or ""),
                "[]",
                "[]",
                origin,
                _now(),
            ),
        )
        _insert_source_refs(
            conn,
            "journal_entry_version_source_refs",
            "version_id",
            version_id,
            profile_id,
            source_conversation_ids or [],
            source_message_ids or [],
        )
        conn.execute(
            """
            UPDATE journal_entries
            SET current_version_id = ?, updated = datetime('now'), deleted_at = NULL
            WHERE id = ? AND profile_id = ?
            """,
            (version_id, entry_id, profile_id),
        )
    return get_entry(profile_id, entry_id)


def restore_entry(profile_id: str, entry_id: str, version_id: str) -> dict:
    entry = get_entry(profile_id, entry_id)
    with get_db() as conn:
        version = row_to_dict(
            conn.execute(
                """
                SELECT * FROM journal_entry_versions
                WHERE id = ? AND entry_id = ? AND profile_id = ?
                """,
                (version_id, entry_id, profile_id),
            ).fetchone()
        )
        if not version:
            raise StoreError("not_found", "Version nicht gefunden", 404)
        decoded = _decode_version(conn, version)
    return save_entry(
        profile_id,
        entry["journal_day_id"],
        decoded.get("title") or "",
        decoded.get("body") or "",
        origin="restore",
        entry_id=entry_id,
        source_conversation_ids=decoded.get("source_conversation_ids") or [],
        source_message_ids=decoded.get("source_message_ids") or [],
    )


def soft_delete_entry(profile_id: str, entry_id: str) -> dict:
    get_entry(profile_id, entry_id)
    with get_db() as conn:
        conn.execute(
            "UPDATE journal_entries SET deleted_at = ?, updated = datetime('now') WHERE id = ? AND profile_id = ?",
            (_now(), entry_id, profile_id),
        )
    return {"id": entry_id, "deleted": True}


def _parse_scratch(raw) -> list[dict]:
    if isinstance(raw, list):
        data = raw
    else:
        try:
            data = json.loads(raw or "[]")
        except json.JSONDecodeError:
            data = []
    if not isinstance(data, list):
        return []
    items: list[dict] = []
    for item in data[:SCRATCH_MAX_ITEMS]:
        if not isinstance(item, dict):
            continue
        text = str(item.get("text") or "")[:SCRATCH_MAX_TEXT]
        items.append(
            {
                "id": str(item.get("id") or uuid.uuid4()),
                "text": text,
                "done": bool(item.get("done")),
            }
        )
    return items


def save_day_scratch(profile_id: str, journal_day_id: str, items: list[dict]) -> list[dict]:
    get_day(profile_id, journal_day_id)
    cleaned = _parse_scratch(items)
    with get_db() as conn:
        conn.execute(
            "UPDATE journal_days SET scratch_json = ?, updated = datetime('now') WHERE id = ? AND profile_id = ?",
            (json.dumps(cleaned, ensure_ascii=False), journal_day_id, profile_id),
        )
    return cleaned


def day_payload(profile_id: str, journal_day_id: str) -> dict:
    day = get_day(profile_id, journal_day_id)
    space = get_user_space(profile_id, day["space_id"])
    conversations = list_conversations_for_day(profile_id, journal_day_id)
    return {
        "day": {key: value for key, value in day.items() if key != "scratch_json"},
        "space": space,
        "conversations": conversations,
        "current_draft": current_draft(profile_id, journal_day_id),
        "entries": current_entries(profile_id, journal_day_id),
        "scratch": _parse_scratch(day.get("scratch_json")),
        "consolidation_offer": consolidation_offer(conversations),
    }