#!/bin/sh

# Requires: xclip

# Clipboard history daemon. cliphist is Wayland-only, so this is the X11

# stand-in: it polls the CLIPBOARD selection and keeps a copy of everything

# that passes through it. Copying is what makes it useful — an X selection

# lives in the process that owns it, so closing the app that copied a string

# takes the string with it. rofi-clip reads what this writes.

#

# Usage: rofi-clipd            run in the foreground (autostart target)

#        rofi-clipd --once     record the clipboard right now and exit

#        rofi-clipd --clear    forget the whole history

set -u

DIR="${XDG_CACHE_HOME:-$HOME/.cache}/rofi-clipboard"

STORE="$DIR/store"

INDEX="$DIR/index"

PIDFILE="$DIR/pid"

# How many entries to keep, and how often to look. A second is under the

# threshold where a copy-then-immediately-quit would be missed in practice.

LIMIT=${ROFI_CLIP_LIMIT:-200}

INTERVAL=${ROFI_CLIP_INTERVAL:-1}

# How long to give an unresponsive selection owner before giving up on a read.

READ_TIMEOUT=${ROFI_CLIP_READ_TIMEOUT:-2}

mkdir -p "$STORE"

# md5sum is the entry's identity: same text, same file, so re-copying an old

# entry moves it to the top instead of duplicating it.

hash_of() { printf '%s' "$1" | md5sum | cut -d' ' -f1; }

# One index line per entry, newest first: "<hash>\t<single-line preview>".

# rofi rows cannot span lines, so newlines become a visible glyph and the

# text is cut to something that fits a menu width.

preview_of() {

    printf '%s' "$1" | awk '

        BEGIN { ORS = "" }

        NR > 1 { print " ⏎ " }

        { gsub(/\t/, " "); print }

    ' | cut -c1-160

}

record() {

    entry=$1

    # Whitespace-only copies are almost always an accident of a drag select.

    case $entry in

        *[![:space:]]*) ;;

        *) return 0 ;;

    esac

    hash=$(hash_of "$entry")

    printf '%s' "$entry" > "$STORE/$hash"

    tmp="$INDEX.$$"

    printf '%s\t%s\n' "$hash" "$(preview_of "$entry")" > "$tmp"

    if [ -f "$INDEX" ]; then

        grep -v "^$hash	" "$INDEX" >> "$tmp"

    fi

    head -n "$LIMIT" "$tmp" > "$INDEX"

    rm -f "$tmp"

    # Everything past the limit fell off the index above; drop its payload

    # too, or the store grows without bound.

    for f in "$STORE"/*; do

        [ -e "$f" ] || continue

        grep -q "^${f##*/}	" "$INDEX" || rm -f "$f"

    done

}

# UTF8_STRING keeps this to text: asking for whatever target an image or a

# file-manager copy offers would store a blob nothing can paste back.

#

# The timeout is not optional. An X selection is served by the process that

# owns it, so reading one is a round trip to another program — and if that

# program stops answering (it died mid-transfer, or it is wedged), xclip waits

# on the reply forever. With no timeout that hangs this loop too, and history

# quietly stops recording until the daemon is restarted by hand.

current() { timeout "$READ_TIMEOUT" xclip -o -selection clipboard -t UTF8_STRING 2>/dev/null; }

case "${1:-}" in

    --once)

        clip=$(current) || exit 0

        [ -n "$clip" ] && record "$clip"

        exit 0

        ;;

    --clear)

        rm -rf "$STORE" "$INDEX"

        mkdir -p "$STORE"

        exit 0

        ;;

    "") ;;

    *) echo "usage: rofi-clipd [--once|--clear]" >&2; exit 2 ;;

esac

# A second daemon would double every entry, so check for a live one first.

# The trap below clears the pidfile on a clean exit, but a kill -9 or a reboot

# leaves it behind — and that stale pid is eventually handed to some unrelated

# process, which would make this refuse to start at every login from then on.

# So the pid has to still be this script, not merely alive.

running() {

    [ -f "$PIDFILE" ] || return 1

    pid=$(cat "$PIDFILE" 2>/dev/null) || return 1

    [ -n "$pid" ] && kill -0 "$pid" 2>/dev/null || return 1

    tr '\0' ' ' < "/proc/$pid/cmdline" 2>/dev/null | grep -q "${0##*/}"

}

if running; then

    echo "rofi-clipd: already running (pid $(cat "$PIDFILE"))" >&2

    exit 1

fi

echo $$ > "$PIDFILE"

# EXIT clears the pidfile on every way out. INT and TERM need handlers that

# actually exit: a handler that just cleans up returns into the loop, leaving a

# daemon that ignores kill *and* has already deleted the pidfile guarding

# against a second one — so the next login starts a duplicate that records

# every copy twice.

trap 'rm -f "$PIDFILE"' EXIT

trap 'exit 130' INT

trap 'exit 143' TERM

last=""

while :; do

    clip=$(current) || clip=""

    if [ -n "$clip" ] && [ "$clip" != "$last" ]; then

        last=$clip

        record "$clip"

    fi

    sleep "$INTERVAL"

done