#!/usr/bin/env bash
# Back the Claude memory store up to chezmoi, then commit and push it.
# Runs from the Stop hook.

set -uo pipefail

SRC="$HOME/.local/share/chezmoi"
STORE="$HOME/.claude/memories"
PATHSPEC="private_dot_claude/memories"
SENTINEL="$HOME/.claude/.chezmoi-memories-unpushed"

# Discard the hook's stdin JSON.
[ -t 0 ] || cat >/dev/null 2>&1

git_c() { git -C "$SRC" "$@"; }

report_unpushed() {
  local n="$1"
  printf '%s\n' "$(date -u +%Y-%m-%dT%H:%M:%SZ) — $n commit(s) unpushed" > "$SENTINEL"
  printf '{"systemMessage":"chezmoi memories: %s commit(s) committed locally but NOT pushed. Resolve with: git -C ~/.local/share/chezmoi pull --rebase \\u0026\\u0026 git -C ~/.local/share/chezmoi push"}\n' "$n"
}

unpushed_count() {
  git_c rev-list --count '@{u}..HEAD' 2>/dev/null || echo "?"
}

store_healthy() {
  [ -d "$STORE" ] && [ -n "$(find "$STORE" -type f -name '*.md' -print -quit 2>/dev/null)" ]
}

# --- Step 1: Pull upstream memory changes into the local store ---------------
# Three-way comparison against the commit of the last completed sync.
BASEFILE="$HOME/.claude/.chezmoi-memories-base"
CONFLICTS="$HOME/.claude/.chezmoi-memories-conflicts"

blob_at() { git_c rev-parse -q --verify "$1:$2" 2>/dev/null || true; }

# Tree hash the store would have if committed.
store_tree() {
  local idx
  idx="$(mktemp)" || return 1
  rm -f "$idx"
  GIT_INDEX_FILE="$idx" git_c --work-tree="$STORE" add -- '*.md' 2>/dev/null &&
    GIT_INDEX_FILE="$idx" git_c write-tree
  rm -f "$idx"
}

# First run: use the newest commit whose memories tree matches the store.
bootstrap_base() {
  local tree c
  tree="$(store_tree)" || return 0
  git_c log --format=%H -n 200 -- "$PATHSPEC" | while IFS= read -r c; do
    if [ "$(git_c rev-parse -q --verify "$c:$PATHSPEC")" = "$tree" ]; then
      printf '%s\n' "$c"
      break
    fi
  done
}

reconcile_upstream() {
  local base head src rel tgt b h t
  base="$(cat "$BASEFILE" 2>/dev/null || bootstrap_base)"
  head="$(git_c rev-parse -q --verify HEAD)" || return 0
  [ -n "$base" ] && [ "$base" != "$head" ] || return 0
  git_c cat-file -e "$base^{commit}" 2>/dev/null || return 0

  git_c diff --name-only --no-renames "$base" "$head" -- "$PATHSPEC" |
  while IFS= read -r src; do
    rel="${src#"$PATHSPEC"/}"
    tgt="$STORE/$rel"
    b="$(blob_at "$base" "$src")"
    h="$(blob_at "$head" "$src")"
    t=""
    [ -f "$tgt" ] && t="$(git hash-object --stdin < "$tgt")"

    # Already up to date.
    [ "$t" = "$h" ] && continue
    if [ "$t" = "$b" ]; then
      # Untouched locally: take the upstream version (or deletion).
      if [ -z "$h" ]; then
        rm -f "$tgt"
        rmdir "$(dirname "$tgt")" 2>/dev/null || true
      else
        mkdir -p "$(dirname "$tgt")"
        git_c cat-file blob "$h" > "$tgt"
      fi
    else
      # Changed on both sides: keep the local copy and record the conflict.
      printf '%s\n' "$rel" >> "$CONFLICTS"
    fi
  done
}

if store_healthy; then
  reconcile_upstream
fi

# --- Step 2: Repair each store's MEMORY.md index ----------------------------
# Drop lines for deleted files; add lines for memories the index misses.
# Recently modified files are skipped so their writer can index them.
INDEX_GRACE_MIN=10

index_line_target() {
  printf '%s' "$1" | sed -n 's/^- \[[^]]*\](\([^)]*\.md\)).*/\1/p'
}

# Drop auto-generated index lines when a hand-written line exists for the same file.
drop_superseded_generated_lines() {
  local buf
  buf="$(mktemp)" || { cat; return 0; }
  cat > "$buf"
  awk '
    function target(l,   s) {
      if (!match(l, /^- \[[^]]*\]\([^)]*\.md\)/)) return ""
      s = substr(l, RSTART, RLENGTH)
      sub(/^- \[[^]]*\]\(/, "", s); sub(/\)$/, "", s)
      return s
    }
    function generated(l, t,   title) {
      title = t; sub(/\.md$/, "", title); gsub(/-/, " ", title)
      return index(l, "- [" title "](" t ")") == 1
    }
    NR == FNR {
      t = target($0)
      if (t != "" && !generated($0, t)) handwritten[t] = 1
      next
    }
    {
      t = target($0)
      if (t != "" && handwritten[t] && generated($0, t)) next
      print
    }' "$buf" "$buf"
  rm -f "$buf"
}

sync_memory_index() {
  local dir="$1"
  local index="$dir/MEMORY.md"
  local tmp
  tmp="$(mktemp)" || return 0

  [ -f "$index" ] || printf '# Memory Index\n\n' > "$index"

  # Drop lines whose file no longer exists.
  while IFS= read -r line || [ -n "$line" ]; do
    local target
    target="$(index_line_target "$line")"
    if [ -n "$target" ] && [ ! -f "$dir/$target" ]; then
      continue
    fi
    printf '%s\n' "$line"
  done < "$index" | drop_superseded_generated_lines > "$tmp"

  # Add a line for every unindexed memory, using its `description:` frontmatter.
  local f base desc title
  for f in "$dir"/*.md; do
    [ -e "$f" ] || continue
    base="$(basename "$f")"
    [ "$base" = "MEMORY.md" ] && continue
    grep -qF "($base)" "$tmp" && continue
    [ -n "$(find "$f" -mmin -"$INDEX_GRACE_MIN" 2>/dev/null)" ] && continue

    desc="$(sed -n 's/^description:[[:space:]]*//p' "$f" | head -1 \
            | sed 's/^"//; s/"$//; s/\\"/"/g')"
    title="$(printf '%s' "${base%.md}" | tr '-' ' ')"
    [ -n "$desc" ] || desc="$title"
    printf -- '- [%s](%s) — %s\n' "$title" "$base" "$desc" >> "$tmp"
  done

  if ! cmp -s "$tmp" "$index"; then
    cat "$tmp" > "$index"
  fi
  rm -f "$tmp"
}

if store_healthy; then
  for memdir in "$STORE"/*/; do
    [ -d "$memdir" ] || continue
    sync_memory_index "${memdir%/}"
  done
fi

# --- Step 3: Mirror the store into chezmoi's source tree --------------------
chezmoi add "$STORE" 2>/dev/null || true

# --- Step 4: Propagate deletions and renames --------------------------------
# `chezmoi add` never removes files, so forget entries whose target is gone.
# Skipped if the store looks empty, so a broken store can't wipe the backup.
if store_healthy; then
  chezmoi managed "$STORE" 2>/dev/null | sort -r | while IFS= read -r rel; do
    [ -n "$rel" ] || continue
    [ -e "$HOME/$rel" ] || chezmoi forget --force "$HOME/$rel" >/dev/null 2>&1 || true
  done
fi

# --- Step 5: Guards ---------------------------------------------------------
[ -d "$SRC/.git" ] || exit 0

# Don't commit in the middle of a rebase, merge, etc.
for state in rebase-merge rebase-apply MERGE_HEAD CHERRY_PICK_HEAD REVERT_HEAD; do
  if [ -e "$SRC/.git/$state" ]; then
    exit 0
  fi
done

# --- Step 6: Commit (memories path only) ------------------------------------
git_c add -- "$PATHSPEC" 2>/dev/null || exit 0

if ! git_c diff --cached --quiet -- "$PATHSPEC" 2>/dev/null; then
  git_c commit -q -m "memories: auto-sync $(date +%Y-%m-%dT%H:%M)" -- "$PATHSPEC" 2>/dev/null || exit 0
fi

# Record this commit as the base for the next sync.
git_c rev-parse HEAD > "$BASEFILE" 2>/dev/null || true

# --- Step 7: Push -----------------------------------------------------------
if git_c push -q origin HEAD 2>/dev/null; then
  rm -f "$SENTINEL"
  if [ -s "$CONFLICTS" ]; then
    printf '{"systemMessage":"chezmoi memories: %s memory file(s) changed on another machine AND locally; kept the local copy. Review the list in ~/.claude/.chezmoi-memories-conflicts (git log shows the upstream version), then delete that file."}\n' \
      "$(sort -u "$CONFLICTS" | wc -l | tr -d ' ')"
  fi
  exit 0
fi

# Push failed: the commit is safe locally; report the backlog.
n="$(unpushed_count)"
[ "$n" = "0" ] && exit 0
report_unpushed "$n"
exit 0