lfrc

# https://github.com/LukeSmithxyz/voidrice/blob/master/.config/lf/lfrc
# https://github.com/gokcehan/lf/blob/master/etc/lfrc.example
# https://github.com/gokcehan/lf/wiki/Integrations
# https://github.com/gokcehan/lf/wiki/Tips
# https://pkg.go.dev/github.com/gokcehan/lf#hdr-Configuration

# https://pkg.go.dev/github.com/gokcehan/lf#hdr-Options

# tabs are NOT supported (use kitty instead)

# interpreter for shell commands
set shell bash

# set '-eu' options for shell commands
# These options are used to have safer shell commands. Option '-e' is used to
# exit on error and option '-u' is used to give error for unset variables.
# Option '-f' disables pathname expansion which can be useful when $f, $fs, and
# $fx variables contain names with '*' or '?' characters. However, this option
# is used selectively within individual commands as it can be limiting at
# times.
set shellopts '-eu'

# set internal field separator (IFS) to "\n" for shell commands
# This is useful to automatically split file names in $fs and $fx properly
# since default file separator used in these variables (i.e. 'filesep' option)
# is newline. You need to consider the values of these options and create your
# commands accordingly.
set ifs "\n"

# leave some space at the top and the bottom of the screen
# set scrolloff 10
set scrolloff 9999

# set info           []string  (default '')
set anchorfind false
set drawbox
set incfilter true
set incsearch true
set mouse true
set number true
set promptfmt "\033[34;1m%d\033[0m\033[1m%f\033[0m"
set ratios 1:2
set relativenumber true

###

# # Use the `dim` attribute instead of underline for the cursor in the preview pane
# set cursorpreviewfmt "\033[7;2m"

map F filter

# use enter for shell commands
# map E shell
map E :push $bash<enter>

# map <m-1> select
map <m-down> down
map <m-up> up
map J page-down
map K page-up

# # show the result of execution of previous commands
# map ` !true

# https://github.com/gokcehan/lf/blob/a3127a2dc340ec9f9135f596f987e5c0184f3deb/doc.go#L182
# f  Current file selection as a full path.
# fs Selected file(s) separated with the value of 'filesep' option as full path(s).
# fx Selected file(s) (i.e. 'fs') if there are any selected files, otherwise current file selection (i.e. 'f').

# # execute current file (must be executable)
# map x $$f
# map X !$f

# dedicated keys for file opener actions
map o &mimeopen $f
map O $mimeopen --ask $f

# define a custom 'open' command
# This command is called when current file is not a directory. You may want to
# use either file extensions and/or mime types here. Below uses an editor for
# text files and a file opener for the rest.
# this is clearly quite limited compared to rifle. detecting mimetype over file
# extension also leads to some undesirable behaviour (opening js/json with
# firefox by default)
cmd open &{{
    case $(file --mime-type -Lb $f) in
        text/* | */javascript | */json) lf -remote "send $id \$$EDITOR \$fx";;
        *) for f in $fx; do $OPENER $f > /dev/null 2> /dev/null & done;;
    esac
}}

# # mkdir command. See wiki if you want it to select created dir
# map N :push %mkdir<space>

# rename {{{
map r
# Rename the file with a completely different name
map rc push :rename<space>
# Edit the current filename
map ra ${{
	# get 'basename' of the selection
	filename="${f##*/}"
	# quote it so we won't deal with quotes in the lf -remote command
	filename="$(printf '%q' "$filename")"
	filename="${filename// /<space>}"
	lf -remote "send $id push :rename<space>$filename"
}}

# Edit filename before the extension
map a
map a ${{
        # won't work if no .ext
	# get 'basename' of the selection
	filename="${f##*/}"
	# quote it so we won't deal with quotes in the lf -remote command
	filename="$(printf '%q' "$filename")"
	filename="${filename// /<space>}"
	lf -remote "send $id push :rename<space>$filename<a-b><c-b>"
}}

# simplest solution
# goes to start if no ext, only a minor annoyance
map a :rename; cmd-word-back; cmd-left

# <a-f> invalid
# map a push A<a-b><a-b><a-f> # before extension

# map a ${{
# # cmd rename-before-ext &{{
# 	if [ "$(echo "$fx" | wc -l)" -gt 1 ]; then
# 		lf -remote "send $id echo You can't change more than one file name"
# 		lf -remote "send $id unselect"
# 	else
# 		if [ -d "$f" ]; then
# 			lf -remote "send $id rename"
# 		else
# 			ext_len="$(echo ${f##*.} | wc -m)" # extention length
# 			for i in $(seq "$ext_len"); do
# 				pos="${pos}<left>"
# 			done
# 			lf -remote "send $id rename"
# 			lf -remote "send $id push "$pos""
# 		fi
# 	fi
# }}

cmd bulk-rename ${{
    old="$(mktemp)"
    new="$(mktemp)"
    if [ -n "$fs" ]; then
        fs="$(basename -a $fs)"
    else
        fs="$(ls)"
    fi
    printf '%s\n' "$fs" >"$old"
    printf '%s\n' "$fs" >"$new"
    $EDITOR "$new"
    [ "$(wc -l < "$new")" -ne "$(wc -l < "$old")" ] && exit
    paste "$old" "$new" | while IFS= read -r names; do
        src="$(printf '%s' "$names" | cut -f1)"
        dst="$(printf '%s' "$names" | cut -f2)"
        if [ "$src" = "$dst" ] || [ -e "$dst" ]; then
            continue
        fi
        mv -- "$src" "$dst"
    done
    rm -- "$old" "$new"
    lf -remote "send $id unselect"
}}
# }}}

# define a custom 'rename' command without prompt for overwrite
# cmd rename %[ -e $1 ] && printf "file exists" || mv $f $1
# map r push :rename<space>

# symlinks {{{
cmd follow_link %{{
  lf -remote "send ${id} select '$(readlink $f)'"
}}
map gL follow_link

# y (select for copy) and P to paste soft-link
# d (select for cut) and P to paste hard-link
cmd link %{{
    set -- $(cat ~/.local/share/lf/files)
    mode="$1"
    shift
    if [ "$#" -lt 1 ]; then
        lf -remote "send $id echo no files to link"
        exit 0
    fi
    case "$mode" in
        # symbolically copy mode is indicating a soft link
        copy) ln -sr -t . -- "$@";;
        # while a move mode is indicating a hard link
        move) ln -t . -- "$@";;
    esac
    rm ~/.local/share/lf/files
    lf -remote "send clear"
}}
map P :link
# }}}

# copy/paste {{{
cmd paste_async &{{
    set -- $(cat ~/.local/share/lf/files)
    mode="$1"
    shift
    case "$mode" in
        copy) cp -rn -- "$@" .;;
        move) mv -n -- "$@" .;;
    esac
    rm ~/.local/share/lf/files
    lf -remote "send clear"
}}

cmd paste_progress &{{
    set -- $(cat ~/.local/share/lf/files)
    mode="$1"
    shift
    case "$mode" in
        copy)
            rsync -av --ignore-existing --progress -- "$@" . |
            stdbuf -i0 -o0 -e0 tr '\r' '\n' |
            while IFS= read -r line; do
                lf -remote "send $id echo $line"
            done
            ;;
        move) mv -n -- "$@" .;;
    esac
    rm ~/.local/share/lf/files
    lf -remote "send clear"
}}

cmd paste_try_cow &{{
    # # This was very helpful for debugging:
    # log_file="$HOME/lf-reflink-log-$(date +'%Y-%m-%d_%H-%M-%S')"
    # [ -f "$log_file" ] || touch "$log_file"
    # exec 1>> $log_file 2>&1
    # set -x

    # In theory, this may fail,
    # but I tested it on selection with 10k files - everything worked (bash)
    set -- $(cat ~/.local/share/lf/files)
    mode="$1"
    shift

    if [ $mode = 'copy' ]; then
        # Reflink if all items of selection and the destination are on the
        # same mount point and it is CoW fs.
        # (to make sure reflink never fails in first place, so we don't have to
        # clean up)

        src_targets="$(df --output=target -- "$@" | sed '1d' | sort -u)"

        if [ "$(df --output=target -- "$PWD" | tail -n 1)" = \
             "$(echo "$src_targets" | tail -n 1)" ] && \
             (( "$(echo "$src_targets" | wc -l)" == 1 )) && \
             [[ "$(df --output=fstype -- "$PWD" | tail -n 1)" =~ ^(btrfs|xfs|zfs)$ ]]; then

            echo 'selected copy and cp reflink paste'

            start=$(date '+%s')

            # Handle same names in dst
            # TODO parallelism, idk - but exit/return/break won't stop the loop from subshell...
            for i in "$@"; do
                name="${i##*/}"
                original="$name"

                count=0
                while [ -w "$PWD/$name" ]; do
                    count=$((count+1))
                    name="$original.~$count~"
                done

                set +e
                cp_out="$(cp -rn --reflink=always -- "$i" "$PWD/$name" 2>&1)"
                set -e

                if [ ! -z "$cp_out" ]; then
                    lf -remote "send $id echoerr $cp_out"
                    exit 0
                fi
            done

            finish=$(( $(date '+%s') - $start ))
            t=''
            if (( $finish > 2 )); then
                t="${finish}s"
            fi

            # Or just skip a file when names are the same.
            # (A LOT faster if you e.g. pasting selection of 10k files)
            # cp -rn --reflink=always -- "$@" .

            lf -remote "send clear"

            green=$'\u001b[32m'
            reset=$'\u001b[0m'
            lf -remote "send $id echo ${green}reflinked!${reset} $t"
        else
            echo 'selected copy and lf native paste'
            lf -remote "send $id paste"
            lf -remote "send clear"
        fi

    elif [ $mode = 'move' ]; then
        echo 'selected move and lf native paste'
        lf -remote "send $id paste"
        lf -remote "send clear"
    fi

    # # for debug
    # set +x

    lf -remote "send load"
}}

# name is different to avoid recursive calls
map p paste_try_cow
# }}}

# # make sure trash folder exists
# %mkdir -p ~/.trash
# # move current file or selected files to trash folder
# # (also see 'man mv' for backup/overwrite options)
# cmd trash %set -f; mv $fx ~/.trash
# map <delete> trash

# define a custom 'delete' command
cmd delete ${{
    set -f
    printf "$fx\n"
    # printf "delete?[y/n]"
    read -p 'delete? [y/n]' ans
    [ "$ans" = "y" ] && rm -rfv $fx
}}
map D delete

# cmd dup ${{
#     cp -v $fx $fx_
# }}
# map yp dup

# extract the current file with the right command
# (xkcd link: https://xkcd.com/1168/)
cmd extract ${{
    set -f
    case $f in
        *.tar.bz|*.tar.bz2|*.tbz|*.tbz2) tar xjvf $f;;
        *.tar.gz|*.tgz) tar xzvf $f;;
        *.tar.xz|*.txz) tar xJvf $f;;
        *.zip) unzip $f;;
        *.rar) unrar x $f;;
        *.7z) 7z x $f;;
    esac
}}

# compress current file or selected files with tar and gunzip
cmd tar ${{
    set -f
    mkdir $1
    cp -r $fx $1
    tar czf $1.tar.gz $1
    rm -rf $1
}}

# compress current file or selected files with zip
cmd zip ${{
    set -f
    mkdir $1
    cp -r $fx $1
    zip -r $1.zip $1
    rm -rf $1
}}

cmd edit-config ${{
    $EDITOR ~/.config/lf/lfrc
    lf -remote "send $id source ~/.config/lf/lfrc"
}}

map C edit-config

# # Dynamically set number of columns
# ${{
#     w=$(tput cols)
#     if [ $w -le 80 ]; then
#         lf -remote "send $id set ratios 1:2"
#     elif [ $w -le 160 ]; then
#         lf -remote "send $id set ratios 1:2:3"
#     else
#         lf -remote "send $id set ratios 1:2:3:5"
#     fi
# }}

cmd toggle_preview %{{
    if [ "$lf_preview" = "true" ]; then
        lf -remote "send $id :set preview false; set ratios 1:5"
    else
        lf -remote "send $id :set preview true; set ratios 1:2:3"
    fi
}}

map zp toggle_preview

# map J :updir; down; open
# map J :updir; set dironly true; down; set dironly false; open
# map K :updir; set dironly true; up; set dironly false; open
# map K :updir; up; open

# cmd on-cd &{{
#     case "$PWD" in
#         /mnt/movies*)
#             lf -remote "send $id set user_prev_sortby $lf_sortby"
#             lf -remote "send $id set sortby natural"
#             lf -remote "send $id set noreverse"
#             lf -remote "send $id echomsg changed sort to natural"
#             ;;
#         *)
#             # restore sorting on directory exit
#             if [[ "$lf_user_prev_sortby" != "" ]]; then
#                 lf -remote "send $id set sortby $lf_user_prev_sortby"
#                 lf -remote "send $id set reverse"
#                 lf -remote "send $id echomsg restored sort to $lf_user_prev_sortby"
#                 lf -remote "send $id set user_prev_sortby ''"
#             fi
#             ;;
#     esac
# }}

cmd on-cd &{{
    # '&' commands run silently in background (which is what we want here),
    # but are not connected to stdout.
    # To make sure our escape sequence still reaches stdout we pipe it to /dev/tty
# printf "\033]0; $PWD\007" > /dev/tty
printf "\033]0; $(pwd | sed "s|$HOME|~|")\007" > /dev/tty
}}

# also run at startup
on-cd

# i don't like the default y mapping
# note: no 'unmap'
map y

cmd yank-dirname $dirname -- "$f" | head -c-1 | xclip -i -selection clipboard
cmd yank-path $printf '%s' "$fx" | xclip -i -selection clipboard
cmd yank-basename $basename -a -- $fx | head -c-1 | xclip -i -selection clipboard

map yp :yank-path
map yn :yank-basename

cmd yank-basename-without-extension ${{
    echo "$fx" |
      xargs -r -d '\n' basename -a |
      awk -e '{
        for (i=length($0); i > 0; i--) {
          if (substr($0, i, 1) == ".") {
            if (i == 1) print $0
            else print substr($0, 0, i-1)

            break
          }
        }

        if (i == 0)
          print $0
      }' |
      if [ -n "$fs" ]; then cat; else tr -d '\n'; fi |
      xclip -i -selection clipboard
}}

cmd run-escaped %{{
  IFS=" "
  cmd="$1"
  shift
  "$cmd" "$*"
}}
map \\ push :run-escaped<space>

cmd select-files &{{
    get_files() {
        if [ "$lf_hidden" = 'false' ]; then
            find "$PWD" -mindepth 1 -maxdepth 1 -type f -not -name '.*' -print0
        else
            find "$PWD" -mindepth 1 -maxdepth 1 -type f -print0
        fi |
        xargs -0 printf ' %q'
    }

    lf -remote "send $id :unselect; toggle $(get_files)"
}}

cmd select-dirs &{{
    get_dirs() {
        if [ "$lf_hidden" = 'false' ]; then
            find "$PWD" -mindepth 1 -maxdepth 1 -type d -not -name '.*' -print0
        else
            find "$PWD" -mindepth 1 -maxdepth 1 -type d -print0
        fi |
        xargs -0 printf ' %q'
    }

    lf -remote "send $id :unselect; toggle $(get_dirs)"
}}

%[ $LF_LEVEL -eq 1 ] || echo "Warning: You're in a nested lf instance!"

cmd bookmark_jump ${{
    res="$(cat $LF_BOOKMARK_PATH/$(ls $LF_BOOKMARK_PATH | fzf))"
    lf -remote "send $id cd \"$res\""
}}

cmd bookmark_create ${{
    read ans
    echo $PWD > $LF_BOOKMARK_PATH/$ans
}}

cmd git_branch ${{
    git branch | fzf | xargs git checkout
    pwd_shell=$(pwd)
    lf -remote "send $id updir"
    lf -remote "send $id cd \"$pwd_shell\""
}}
map gb :git_branch
map gp ${{clear; git pull --rebase || true; echo "press ENTER"; read ENTER}}
map gs ${{clear; git status; echo "press ENTER"; read ENTER}}
map gl ${{clear; git log --graph --pretty=format:'%Cred%h%Creset -%C(yellow)%d%Creset %s %Cgreen(%cr) %C(bold blue)<%an>%Creset' --abbrev-commit}}

# cmd on-cd &{{
#     # display git repository status in your prompt
#     source /usr/share/git/completion/git-prompt.sh
#     GIT_PS1_SHOWDIRTYSTATE=auto
#     GIT_PS1_SHOWSTASHSTATE=auto
#     GIT_PS1_SHOWUNTRACKEDFILES=auto
#     GIT_PS1_SHOWUPSTREAM=auto
#     GIT_PS1_COMPRESSSPARSESTATE=auto
#     git=$(__git_ps1 " [GIT BRANCH:> %s]") || true
#     fmt="\033[32;1m%u@%h\033[0m:\033[34;1m%w\033[0m\033[33;1m$git\033[0m"
#     lf -remote "send $id set promptfmt \"$fmt\""
# }}

map f $vi $(fzf)

# cmd fzf $vi $(find . -name "$1" | fzf)
# map f push :fzf<space>

cmd fzf_jump ${{
    res="$(find . -maxdepth 1 | fzf --reverse --header='Jump to location' | sed 's/\\/\\\\/g;s/"/\\"/g')"
    if [ -d "$res" ] ; then
        cmd="cd"
    elif [ -f "$res" ] ; then
        cmd="select"
    else
        exit 0
    fi
    lf -remote "send $id $cmd \"$res\""
}}
map <c-f> :fzf_jump


cmd trim_video ${{
    ffpb -ss  -i $f -c copy tmp.mkv
        mv tmp.mkv $f
        notify-send "$f trimmed!"
# lf -remote "send $id $cmd \"$res\""
# for file in %%s ; do ffmpeg -ss  -i "$file" -c copy "$file"_1.mkv ; done
}}

map sA :set sortby atime; set noreverse; set info atime
map sC :set sortby ctime; set noreverse; set info ctime
map sE :set sortby ext; set noreverse; set info
map sN :set sortby natural; set noreverse; set info
map sS :set sortby size; set noreverse; set info size
map sT :set sortby time; set noreverse; set info time
map sa :set sortby atime; set reverse; set info atime
map sc :set sortby ctime; set reverse; set info ctime
map se :set sortby ext; set reverse; set info
map sn :set sortby natural; set reverse; set info
map ss :set sortby size; set reverse; set info size
map st :set sortby time; set reverse; set info time