#!/usr/bin/env bash

# note (clean + dedupe + git sync)
# needs: fzf, rg

# written mostly by chatgpt (ai) in april 2026
# brex production

set -euo pipefail
# set -x

NOTES_DIR="${NOTES_DIR:-$HOME/notes}"
#EDITOR="${EDITOR:-vim}" # disabled
# try multiple
for ed in "${EDITOR:-}" hx vim nano; do
    if command -v "$ed" >/dev/null 2>&1; then
        EDITOR="$ed"
        break
    fi
done

# this should now also work with older versions of fzf, if not comment out next line:
export FZF_DEFAULT_OPTS="--pointer='>' --color=fg:-1,bg:-1,hl:-1,fg+:-1,bg+:-1,hl+:-1,info:-1,prompt:-1,spinner:-1,pointer:-1,marker:-1,border:-1"

# deps
for cmd in fzf rg; do
  if ! command -v "$cmd" &>/dev/null; then
    echo "Error: $cmd is required" >&2
    exit 1
  fi
done

mkdir -p "$NOTES_DIR"

today() {
  date +"%Y-%m-%d"
}

slugify() {
  local input="${1:-}"

  input="$(echo "$input" \
    | tr '[:upper:]' '[:lower:]' \
    | tr -cd 'a-z0-9 -' \
    | tr ' ' '-' \
    | sed 's/-\+/-/g' \
    | sed 's/^-//' \
    | sed 's/-$//')"

  echo "$input"
}

open_note_fzf() {
  local file

  file=$(
    find "$NOTES_DIR" -maxdepth 1 -type f -name '*.md' \
      -printf '%T@ %f\n' \
    | sort -nr \
    | cut -d' ' -f2- \
    | fzf --prompt="open> " \
          --preview='cat "'"$NOTES_DIR"'"/{}' \
          --height=80% \
          --reverse
  )

  [[ -z "$file" ]] && return
  "$EDITOR" "$NOTES_DIR/$file"
}

# unlike open_note_fzf, search_notes is curently not limited to *.md files

search_notes() {
  local query="${1:-}"
  local selection file line

  selection=$(
    rg -i -m1 --no-heading --line-number --color=never "$query" "$NOTES_DIR" \
      | fzf \
          --delimiter : \
          --prompt="search> " \
          --preview='cat {1}' \
          --bind "change:reload:rg -i -m1 --no-heading --line-number --color=never {q} '$NOTES_DIR' || true" \
          --phony \
          --query "$query" \
          --height=80% \
          --reverse
  )

  [[ -z "$selection" ]] && return

  file="${selection%%:*}"
  line="${selection#*:}"
  line="${line%%:*}"

  "$EDITOR" "$file" "+$line"
}

create_note() {
  local text="$*"
  local title slug file

  [[ -z "$text" ]] && return

  title="$text"

  slug="$(slugify "$text" | cut -d- -f1-5)"
  [[ -z "$slug" ]] && slug="note"

  file="$NOTES_DIR/$(today)-$slug.md"

  if [[ -f "$file" ]]; then
    "$EDITOR" "$file"
    return
  fi

  cat > "$file" <<EOF
---
title: $title
date: $(today)
---
$title
EOF

  "$EDITOR" "$file"
}

new_note() {
  local title slug file

  title="${*:-note}"

  slug="$(slugify "$title" | cut -d- -f1-5)"
  [[ -z "$slug" ]] && slug="note"

  file="$NOTES_DIR/$(today)-$slug.md"

  if [[ -f "$file" ]]; then
    "$EDITOR" "$file"
    return
  fi

  cat > "$file" <<EOF
---
title: $title
date: $(today)
---
EOF

  "$EDITOR" "$file"
}

list_notes() {
  find "$NOTES_DIR" -maxdepth 1 -type f -name '*.md' \
    -printf '%T@ %f\n' \
  | sort -nr \
  | cut -d' ' -f2-
}

latest_note() {
  find "$NOTES_DIR" -maxdepth 1 -type f -name '*.md' \
    -printf '%T@ %p\n' \
  | sort -nr \
  | head -n1 \
  | cut -d' ' -f2-
}

cat_note() {
  local query="${1:-}"
  local file=""

  if [[ -z "$query" ]]; then
    file="$(latest_note)"
  else
    while IFS= read -r f; do
      if [[ "${f,,}" == *"${query,,}"* ]]; then
        file="$f"
        break
      fi
    done < <(find "$NOTES_DIR" -maxdepth 1 -type f -name '*.md')
  fi

  [[ -z "$file" ]] && { echo "No match found"; exit 1; }

  cat "$file"
}

open_note() {
  local query="${1:-}"
  local file=""

  if [[ -z "$query" ]]; then
    open_note_fzf
    return
  fi

  while IFS= read -r f; do
    if [[ "${f,,}" == *"${query,,}"* ]]; then
      file="$f"
      break
    fi
  done < <(find "$NOTES_DIR" -maxdepth 1 -type f -name '*.md')

  [[ -z "$file" ]] && { echo "No match found"; exit 1; }

  "$EDITOR" "$file"
}

remove_note() {
  local file trash_dir target

  trash_dir="$NOTES_DIR/.trash"
  mkdir -p "$trash_dir"

  file=$(
    find "$NOTES_DIR" -maxdepth 1 -type f -name '*.md' \
      -printf '%T@ %f\n' \
    | sort -nr \
    | cut -d' ' -f2- \
    | fzf --prompt="trash> " \
          --pointer=">" \
          --color="pointer:red" \
          --preview='cat "'"$NOTES_DIR"'"/{}' \
          --height=80% \
          --reverse
  )

  [[ -z "$file" ]] && return

  printf "Move '%s' to trash? [y/N] " "$file"
  read -r confirm

  if [[ ! "$confirm" =~ ^[yY]$ ]]; then
    echo "Aborted"
    return
  fi

  target="$trash_dir/$file"

  # handle name collisions in trash
  if [[ -e "$target" ]]; then
    target="$trash_dir/$(date +%s)-$file"
  fi

  mv -- "$NOTES_DIR/$file" "$target"
  echo "Moved to trash: $file"
}

usage() {
  cat <<'EOF'
Usage:

  note n "title"          → new note with explicit title
  note "text"             → create/reopen note
  note l                  → list
  note o                  → open (fzf)
  note s                  → search (rg|fzf)
  note c                  → cat latest
  note rm                 → move to .trash
  note pull               → git pull
  note push               → git push
  note --longhelp | less  → full help
  note h                  → this help

EOF
  echo "Storage: $NOTES_DIR"
}

longhelp() {
  cat <<'EOF'
NAME
    note - simple note manager

SYNOPSIS
    note [command] [arguments]

DESCRIPTION
    note is a fast, minimal note-taking tool that stores notes as plain
    text/markdown files in $NOTES_DIR (default: ~/notes).

    It provides:
      - fast fuzzy navigation (fzf)
      - full-text search (ripgrep)
      - quick note creation
      - optional git sync

    Notes are stored as:
        YYYY-MM-DD-slug.md

COMMANDS

    (default)
        note [text]
        Create or reopen a note using the given text.

    new, n, +
        Create a new note with explicit title.

    open, o
        Open a note:
          no args → fzf picker
          query   → first filename match

    list, l
        List notes (sorted by modification time).

    search, s, g, grep
        Full-text search (rg + fzf).
        Opens file at matching line.

    cat, c
        Print note contents:
          no args → latest note
          query   → first match

    remove, rm
        Move a note to .trash (interactive).

    pull
        git pull (inside NOTES_DIR)

    push
        git add + commit + push

    help, h
        Short help

    --longhelp
        This page


FILES

    $NOTES_DIR/*.md
        Notes

    $NOTES_DIR/.trash/
        Deleted notes


ENVIRONMENT

    NOTES_DIR
        Notes location (default: ~/notes)

    EDITOR
        Editor to use (fallback: hx → vim → nano)


EXAMPLES

    note "fix audio bug"
        Create a quick note

    note n "Project ideas"
        Create structured note

    note o
        Open via fzf

    note o mpv
        Open matching note

    note s audio
        Search inside notes

    note c
        Print latest note

    note rm
        Delete note (to trash)

    note push
    note pull
        Sync with git


BEHAVIOR

    • Titles are slugified:
        "My Idea!!!" → my-idea

    • Slugs are truncated (~5 words)

    • Duplicate note (same day/title):
        → reopened instead of recreated


DEPENDENCIES

    Required:
        fzf
        rg

    Optional:
        git


EXIT STATUS

    0  success
    1  failure


AUTHOR

    chatgpt (2026)

EOF
}

cmd="${1:-}"

case "$cmd" in
  new|+|n)
    shift
    new_note "$@"
    ;;
  list|l)
    list_notes
    ;;
  ""|open|o)
    shift || true
    open_note "$@"
    ;;
  remove|rm) 
    shift || true
    remove_note "$@"
    ;;
  cat|c)
    shift || true
    cat_note "$@"
    ;;
  grep|search|g|s)
    shift || true
    search_notes "$@"
    ;;
  h|-h|--help)
    usage
    ;;
  --longhelp)
    longhelp
    ;;
  pull)
  git -C "$NOTES_DIR" pull
    ;;
  push)
  git -C "$NOTES_DIR" add . && git -C "$NOTES_DIR" commit -m "note commit" &&  git -C "$NOTES_DIR" push
    ;;
  *)
  create_note "$@"
    ;;
esac