#!/usr/bin/env python3
"""Append-only Dyade event replication over pinned SSH peers.

No database files are copied or changed directly. All writes use `dyade emit`.
"""
import argparse
import json
import os
from pathlib import Path
import sqlite3
import subprocess
import sys
import tempfile

DB = Path.home() / ".local/share/dyade/memory.sqlite"
STATE = Path.home() / ".local/share/varde/peer-sync-state"
FIELDS = ("source", "session", "event_id", "occurred_at", "kind", "payload")


def connection():
    return sqlite3.connect(f"file:{DB}?mode=ro", uri=True)


def export(after, limit, owner):
    if not 0 <= after or not 1 <= limit <= 200:
        raise ValueError("Invalid export bounds")
    with connection() as db:
        rows = db.execute(
            "SELECT rowid,owner,project,source,session,event_id,occurred_at,kind,payload,digest "
            "FROM events WHERE rowid>? AND owner=? ORDER BY rowid LIMIT ?",
            (after, owner, limit),
        ).fetchall()
    result = []
    for row in rows:
        rid, record_owner, project, source, session, event_id, occurred_at, kind, payload, digest = row
        result.append({"rowid": rid, "owner": record_owner, "project": project,
                       "digest": digest, "event": dict(zip(FIELDS, (source, session, event_id,
                                                                 occurred_at, kind, json.loads(payload))))})
    print(json.dumps({"schema": "varde.peer-events.v1", "rows": result}, ensure_ascii=False))


def local_event(event):
    with connection() as db:
        return db.execute(
            "SELECT digest FROM events WHERE owner=? AND source=? AND session=? AND event_id=?",
            ("njaal", event["source"], event["session"], event["event_id"]),
        ).fetchone()


def pull(host, owner, limit):
    if not host or any(ch not in "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789.-@" for ch in host):
        raise ValueError("Invalid peer host")
    if owner != "njaal":
        raise ValueError("Unexpected owner")
    STATE.mkdir(parents=True, exist_ok=True, mode=0o700)
    key = host.replace("@", "_").replace(".", "_")
    statefile = STATE / (key + ".json")
    cursor = json.loads(statefile.read_text())["cursor"] if statefile.exists() else 0
    remote = "/home/njaal/.local/share/varde/peer-sync/varde-peer-sync.py"
    command = ["ssh", "-T", "-o", "BatchMode=yes", "-o", "StrictHostKeyChecking=yes",
               "-o", "ForwardAgent=no", "-o", "ClearAllForwardings=yes",
               "-o", "ConnectTimeout=5", "--", host,
               f"python3 {remote} export --after {cursor} --limit {limit} --owner {owner}"]
    output = subprocess.run(command, capture_output=True, timeout=60, check=True)
    if len(output.stdout) > 16 * 1024 * 1024:
        raise ValueError("Peer batch exceeds size limit")
    packet = json.loads(output.stdout)
    if packet.get("schema") != "varde.peer-events.v1" or not isinstance(packet.get("rows"), list):
        raise ValueError("Invalid peer response")
    imported = duplicates = 0
    next_cursor = cursor
    for row in packet["rows"]:
        if row["owner"] != owner or not cursor < row["rowid"] or row["rowid"] <= next_cursor:
            raise ValueError("Peer scope or cursor mismatch")
        event = row["event"]
        if not all(key in event for key in FIELDS):
            raise ValueError("Incomplete peer event")
        if not isinstance(row.get("project"), str) or not row["project"]:
            raise ValueError("Missing source project")
        event["project"] = row["project"]
        existing = local_event(event)
        if existing:
            if existing[0] != row["digest"]:
                raise ValueError("Event identity collision: " + event["event_id"])
            duplicates += 1
        else:
            try:
                result = subprocess.run(["dyade", "emit"], input=json.dumps(event).encode(),
                                        capture_output=True, timeout=30, check=True)
            except subprocess.CalledProcessError as error:
                detail = error.stderr.decode("utf8", "replace").strip().splitlines()[-1:]
                raise RuntimeError("Dyade emit failed at peer row " + str(row["rowid"]) +
                                   ": " + (detail[0][:200] if detail else "no diagnostic")) from None
            acknowledgement = json.loads(result.stdout)
            if acknowledgement.get("ingested") is not True:
                raise ValueError("Dyade did not ingest event")
            verified = local_event(event)
            if not verified or verified[0] != row["digest"]:
                raise ValueError("Event digest mismatch after import")
            imported += 1
        next_cursor = row["rowid"]
    if next_cursor != cursor:
        fd, temporary = tempfile.mkstemp(prefix=".peer-", dir=STATE)
        try:
            os.fchmod(fd, 0o600)
            with os.fdopen(fd, "w") as stream:
                json.dump({"cursor": next_cursor}, stream)
                stream.flush()
                os.fsync(stream.fileno())
            os.replace(temporary, statefile)
        finally:
            if os.path.exists(temporary):
                os.unlink(temporary)
    print(json.dumps({"peer": host, "from": cursor, "to": next_cursor,
                      "imported": imported, "duplicates": duplicates,
                      "more_possible": len(packet["rows"]) == limit}))


if __name__ == "__main__":
    parser = argparse.ArgumentParser()
    parser.add_argument("operation", choices=["export", "pull"])
    parser.add_argument("--after", type=int, default=0)
    parser.add_argument("--limit", type=int, default=100)
    parser.add_argument("--owner", default="njaal")
    parser.add_argument("--host")
    args = parser.parse_args()
    try:
        if args.operation == "export":
            export(args.after, args.limit, args.owner)
        else:
            pull(args.host, args.owner, args.limit)
    except Exception as exc:
        print(f"PEER_SYNC_FAILED: {exc}", file=sys.stderr)
        sys.exit(1)
