chain.py

#!/usr/bin/env python3
"""
chain.py - local tamper-evident log for location points (the "internal blockchain").

Each GPS point becomes one entry in an append-only file (chain.jsonl).
Every entry stores the hash of the previous one, so editing any past entry
breaks the chain from that point forward and `verify` will catch it.

No Bitcoin, no external timestamp authority. Stdlib only.

Usage:
    python3 chain.py ingest <file.gpx | folder | archive.zip> [...]
    python3 chain.py verify
    python3 chain.py status
"""

import sys, os, json, hashlib, zipfile, glob
import xml.etree.ElementTree as ET
from datetime import datetime, timezone

CHAIN_PATH = os.path.join(os.path.dirname(os.path.abspath(__file__)), "chain.jsonl")


# --- chain primitives ------------------------------------------------------
def load_chain():
    rows = []
    if os.path.exists(CHAIN_PATH):
        with open(CHAIN_PATH, encoding="utf-8") as f:
            for line in f:
                if line.strip():
                    rows.append(json.loads(line))
    return rows

def entry_hash(core):
    return hashlib.sha256(
        json.dumps(core, sort_keys=True, ensure_ascii=False).encode("utf-8")
    ).hexdigest()

def append_point(prev_hash, seq, p):
    core = {
        "seq": seq,
        "ingested_utc": datetime.now(timezone.utc).isoformat(),
        "point_time": p["time"],
        "lat": p["lat"], "lon": p["lon"], "ele": p.get("ele"),
        "source_file": p["src_file"],
        "prev_hash": prev_hash,
    }
    entry = dict(core, hash=entry_hash(core))
    with open(CHAIN_PATH, "a", encoding="utf-8") as f:
        f.write(json.dumps(entry, ensure_ascii=False) + "\n")
    return entry


# --- GPX parsing (namespace-agnostic) --------------------------------------
def localname(tag):
    return tag.rsplit("}", 1)[-1]

def parse_gpx(text, src_file):
    pts = []
    root = ET.fromstring(text)
    for el in root.iter():
        if localname(el.tag) != "trkpt":
            continue
        lat, lon = el.get("lat"), el.get("lon")
        if lat is None or lon is None:
            continue
        t, ele = None, None
        for c in el:
            ln = localname(c.tag)
            if ln == "time": t = (c.text or "").strip()
            elif ln == "ele": ele = (c.text or "").strip()
        pts.append({"lat": float(lat), "lon": float(lon),
                    "ele": float(ele) if ele else None,
                    "time": t, "src_file": src_file})
    return pts

def collect_points(paths):
    pts = []
    for path in paths:
        if os.path.isdir(path):
            for f in glob.glob(os.path.join(path, "**", "*.gpx"), recursive=True):
                pts += parse_gpx(open(f, encoding="utf-8").read(), os.path.basename(f))
        elif path.lower().endswith(".zip"):
            with zipfile.ZipFile(path) as z:
                for name in z.namelist():
                    if name.lower().endswith(".gpx"):
                        pts += parse_gpx(z.read(name).decode("utf-8"), os.path.basename(name))
        elif path.lower().endswith(".gpx"):
            pts += parse_gpx(open(path, encoding="utf-8").read(), os.path.basename(path))
        else:
            print(f"  ! skipped (not gpx/zip/dir): {path}")
    return pts


# --- commands --------------------------------------------------------------
def cmd_ingest(paths):
    chain = load_chain()
    seen = {(r["point_time"], round(r["lat"], 6), round(r["lon"], 6)) for r in chain}
    prev = chain[-1]["hash"] if chain else "GENESIS"
    seq = len(chain)

    pts = collect_points(paths)
    pts.sort(key=lambda p: (p["time"] or ""))   # chronological within this run

    added = skipped = 0
    for p in pts:
        key = (p["time"], round(p["lat"], 6), round(p["lon"], 6))
        if key in seen:
            skipped += 1
            continue
        e = append_point(prev, seq, p)
        prev = e["hash"]; seq += 1; added += 1
        seen.add(key)

    print(f"ingested points: {len(pts)} | added: {added} | skipped dupes: {skipped}")
    print(f"chain length: {seq} | head: {prev[:16]}")

def cmd_verify():
    chain = load_chain()
    prev = "GENESIS"
    for i, e in enumerate(chain):
        core = {k: v for k, v in e.items() if k != "hash"}
        if entry_hash(core) != e["hash"]:
            print(f"BROKEN at seq {i}: content was altered.")
            return 1
        if core["prev_hash"] != prev:
            print(f"BROKEN at seq {i}: chain link does not match previous entry.")
            return 1
        prev = e["hash"]
    print(f"chain intact: {len(chain)} entries, head {prev[:16]}")
    return 0

def cmd_status():
    chain = load_chain()
    if not chain:
        print("chain empty.")
        return
    times = [r["point_time"] for r in chain if r["point_time"]]
    print(f"entries: {len(chain)}")
    print(f"point time span: {min(times)}  ->  {max(times)}")
    print(f"head hash: {chain[-1]['hash']}")


if __name__ == "__main__":
    if len(sys.argv) < 2:
        print(__doc__); sys.exit(1)
    cmd = sys.argv[1]
    if cmd == "ingest":
        cmd_ingest(sys.argv[2:])
    elif cmd == "verify":
        sys.exit(cmd_verify())
    elif cmd == "status":
        cmd_status()
    else:
        print(__doc__); sys.exit(1)