#!/usr/bin/env just --justfile
# makes variables accesible as $1 $2 $@, useful for escaping variadics

set positional-arguments := true

export invokedir := invocation_directory()
export epoch := `date +%s`
export GUM_FILTER_HEIGHT := "15"
export GIT := `command -v git-wait >/dev/null && echo "git-wait" || echo "git"`
# will trigger a direnv reload when we enter $SHELL
export DIRENV_WATCHES := ""
# please no surprises for now
export NIXPKGS_CONFIG := ""
export NIX_PATH := `echo "${NIX_PATH_ORIG:-"${NIX_PATH:-}"}"`

# required programs: git nix nom gum fzf tee nix-update

@_default:
    cd "$invokedir"; just "$(gum filter $(just --summary --unsorted | tr ' ' '\n' | grep -vxE 'commit|fixup|list|build'))"
@commit *args:
    cd "$invokedir"; just "$(gum filter $(just --summary --unsorted | tr ' ' '\n' | grep '^commit-'))" "$@"
@fixup *args:
    cd "$invokedir"; just "$(gum filter $(just --summary --unsorted | tr ' ' '\n' | grep '^fixup-'))" "$@"
@list *args:
    cd "$invokedir"; just "$(gum filter $(just --summary --unsorted | tr ' ' '\n' | grep '^list-'))" "$@"
@instantiate *args:
    cd "$invokedir"; just "$(gum filter $(just --summary --unsorted | tr ' ' '\n' | grep '^instantiate-'))" "$@"
@build *args:
    cd "$invokedir"; just "$(gum filter $(just --summary --unsorted | tr ' ' '\n' | grep '^build-'))" "$@"
@bump *args:
    cd "$invokedir"; just "$(gum filter $(just --summary --unsorted | tr ' ' '\n' | grep '^bump-'))" "$@"

# === info helpers ===

list-packages +$cut_args="-c1-": _packages_json
    #!/usr/bin/env -S bash -euo pipefail
    cachefile=/tmp/nixpkgs-packages.json.tsv
    if [[ -s "$cachefile" && "$cachefile" -nt packages.json ]]; then
        cut <"$cachefile" "$@"
    else
        jq <packages.json 'to_entries[] | select(.value.meta.position==null|not) | [.key, .value.meta.position] | @tsv' -r \
            | tr '0123456789' '9876543210' | sort | tr '0123456789' '9876543210' \
            | sed -e "s#\t$(realpath master)/#\t#" \
            | sed -e 's#:\([0-9]*\)$#\t\1#' \
            | grep . >"$cachefile"
    fi

@_list_packages_fname_filtered:
    xargs -d $'\n' -n 2000 just __list_packages_fname_filtered
@__list_packages_fname_filtered +fnames:
    just list-packages | grep --fixed-strings "$(printf "\t%s\t\n" "$@")" \
        | grep -v $'\t'pkgs/top-level/ \
        | grep -v $'\t'pkgs/applications/editors/vim/plugins/ \
        | grep -v $'\t'pkgs/applications/editors/vim/plugins/ \
        | grep -v $'\t'pkgs/applications/editors/vscode/extensions/default.nix \
        | grep -v $'\t'pkgs/build-support/cc-wrapper/default.nix \
        | grep -v $'\t'pkgs/build-support/trivial-builders/default.nix \
        | grep -v $'\t'pkgs/desktops/gnome/extensions/buildGnomeExtension.nix \
        | grep -v $'\t'pkgs/development/compilers/chicken/5/default.nix \
        | grep -v $'\t'pkgs/development/haskell-modules/hackage-packages.nix \
        | grep -v $'\t'pkgs/development/lisp-modules/imported.nix \
        | grep -v $'\t'pkgs/development/lua-modules/generated-packages.nix \
        | grep -v $'\t'pkgs/development/python-modules/mypy-boto3/default.nix \
        | grep -v $'\t'pkgs/development/python-modules/types-aiobotocore-packages/default.nix \
        | grep -v $'\t'pkgs/os-specific/linux/nvidia-x11/generic.nix \
        | grep -v $'\t'pkgs/servers/home-assistant/default.nix \
        | grep -v $'\t'pkgs/tools/package-management/akku/default.nix \
        | grep -v $'\t'pkgs/tools/typesetting/tex/texlive/build-texlive-package.nix

@_list_packages_attrpath_filtered:
    xargs -d $'\n' -n 2000 just __list_packages_attrpath_filtered
__list_packages_attrpath_filtered +attrpaths:
    #!/usr/bin/env -S bash -euo pipefail
    declare -a attrpaths=("$@")
    attrpaths=("${attrpaths[@]/"."/"\."}")
    attrpaths=("${attrpaths[@]/"*"/"\*"}")
    attrpaths=("${attrpaths[@]/"+"/"\+"}")
    attrpaths=("${attrpaths[@]/"$"/"\$"}")
    attrpaths=("${attrpaths[@]/"("/"\("}")
    attrpaths=("${attrpaths[@]/")"/"\)"}")
    attrpaths=("${attrpaths[@]/#/"^"}")
    attrpaths=("${attrpaths[@]/%/$'\t'}")
    # printf >&1 "'%s'\n" "${attrpaths[@]}"
    just list-packages | grep "$(printf "%s\n" "${attrpaths[@]}")"

[no-cd]
@list-ripgrepped-packages +$ripgrep_args:
    [[ -e .git && -e flake.nix ]] || { echo >&2 "ERROR: Not in repo root"; false; }
    [[ -n "$ripgrep_args" ]] || { echo >&2 "ERROR: No ripgrep args"; false; }
    rg "$@" pkgs/ -tnix -l | just _list_packages_fname_filtered

[no-cd]
@list-nix-located-packages +$nix_locate_args:
    [[ -e .git && -e flake.nix ]] || { echo >&2 "ERROR: Not in repo root"; false; }
    [[ -n "$nix_locate_args" ]] || { echo >&2 "ERROR: No nix-locate args"; false; }
    nix-locate --top-level --regex "$@" | cut -d' ' -f1 | sd '\.out$' ''  | sort -u | just _list_packages_attrpath_filtered

[no-cd]
@list-dirty-packages:
    test -n "$($GIT diff HEAD --name-only)" || { echo >&2 "No unstaged dirty files found!"; false; }
    $GIT diff HEAD --name-only | just _list_packages_fname_filtered

[no-cd]
@list-touched-packages-since $rev=`cd "$invokedir"; just _a_commit`:
    test -n "$rev" || { echo >&2 "you must pick a revision to compare against!"; false; }
    $GIT diff "$rev" --name-only | just _list_packages_fname_filtered

[no-cd]
@list-unmerged-packages:
    $GIT fetch upstream ||:
    $GIT log HEAD --not --remotes --oneline | cut -d' ' -f2- | cut -d: -f1 |  grep -vE '(^treewide|[, ])' | sort -u

# === build helpers ===

@build-ripgrepped-packages $ripgrep_arg $attr_prefix="" $attr_suffix="" +$extra_args="":
   [[ -n "$extra_args" ]] && export _JUST_NIX_INSTANTIATE_ARGS="$(shift; shift; printf " %q" "$@")"; \
   cd "$invokedir"; just list-ripgrepped-packages "$ripgrep_arg" | cut -f1 | xargs printf "${attr_prefix//%/%%}"'%s'"${attr_suffix//%/%%} " | xargs just build-packages

@build-nix-located-packages $nix_locate_arg $attr_prefix="" $attr_suffix="" +$extra_args="":
   [[ -n "$extra_args" ]] && export _JUST_NIX_INSTANTIATE_ARGS="$(shift; shift; printf " %q" "$@")"; \
   cd "$invokedir"; just list-nix-located-packages "$nix_locate_arg" | cut -f1 | xargs printf "${attr_prefix//%/%%}"'%s'"${attr_suffix//%/%%} " | xargs just build-packages

@build-dirty-packages $attr_prefix="" $attr_suffix="" +$extra_args="":
    [[ -n "$extra_args" ]] && export _JUST_NIX_INSTANTIATE_ARGS="$(shift; shift; printf " %q" "$@")"; \
    cd "$invokedir"; just list-dirty-packages | cut -f1 | xargs printf "${attr_prefix//%/%%}"'%s'"${attr_suffix//%/%%} " | xargs just build-packages

@instantiate-dirty-packages $attr_prefix="" $attr_suffix="" +$extra_args="":
    [[ -n "$extra_args" ]] && export _JUST_NIX_INSTANTIATE_ARGS="$(shift; shift; printf " %q" "$@")"; \
    cd "$invokedir"; just list-dirty-packages | cut -f1 | xargs printf "${attr_prefix//%/%%}"'%s'"${attr_suffix//%/%%} " | xargs just instantiate-packages

@build-touched-packages-since $attr_prefix="" $attr_suffix="" +$extra_args="":
    [[ -n "$extra_args" ]] && export _JUST_NIX_INSTANTIATE_ARGS="$(shift; shift; printf " %q" "$@")"; \
    cd "$invokedir"; just list-touched-packages-since | cut -f1 | xargs printf "${attr_prefix//%/%%}"'%s'"${attr_suffix//%/%%} " | xargs just build-packages

@instantiate-touched-packages-since $attr_prefix="" $attr_suffix="" +$extra_args="":
    [[ -n "$extra_args" ]] && export _JUST_NIX_INSTANTIATE_ARGS="$(shift; shift; printf " %q" "$@")"; \
    cd "$invokedir"; just list-touched-packages-since | cut -f1 | xargs printf "${attr_prefix//%/%%}"'%s'"${attr_suffix//%/%%} " | xargs just instantiate-packages

@build-unmerged-packages $attr_prefix="" $attr_suffix="" +$extra_args="":
    [[ -n "$extra_args" ]] && export _JUST_NIX_INSTANTIATE_ARGS="$(shift; shift; printf " %q" "$@")"; \
    cd "$invokedir"; just list-unmerged-packages | xargs printf "${attr_prefix//%/%%}"'%s'"${attr_suffix//%/%%} " | xargs just build-packages

@instantiate-unmerged-packages $attr_prefix="" $attr_suffix="" +$extra_args="":
    [[ -n "$extra_args" ]] && export _JUST_NIX_INSTANTIATE_ARGS="$(shift; shift; printf " %q" "$@")"; \
    cd "$invokedir"; just list-unmerged-packages | xargs printf "${attr_prefix//%/%%}"'%s'"${attr_suffix//%/%%} " | xargs just instantiate-packages

#

[no-cd]
instantiate-packages +$attrpaths="":
    #!/usr/bin/env -S bash -euo pipefail
    # slower, but resitant to bad attrpaths
    test -n "${attrpaths:-}" || set -- $(just _some_packages)
    if [[ -d "${_INSTANTIATE_CACHE:-}" ]]; then
        mkdir -p "$_INSTANTIATE_CACHE"/{roots,paths}
        worker() {
            local attrpath="$1"
            if [[ -s "$_INSTANTIATE_CACHE/paths/$attrpath" ]]; then
                cat "$_INSTANTIATE_CACHE/paths/$attrpath"
            else
                NIXPKGS_ALLOW_UNFREE=1 nix-instantiate . -A "$attrpath" \
                        ${_JUST_NIX_INSTANTIATE_ARGS:-} \
                        --add-root "$_INSTANTIATE_CACHE/roots/$attrpath" \
                    | tee "$_INSTANTIATE_CACHE/paths/$attrpath"
            fi
        }
        printf "%s\n" "$@" | grep . | \
            xe -j0 -s "$(declare -f worker); worker \"\$@\""
    else
        printf "%s\n" "$@" | grep . | \
            xe -j0 -s 'NIXPKGS_ALLOW_UNFREE=1 nix-instantiate . -A "$1" '"${_JUST_NIX_INSTANTIATE_ARGS:-}"''
    fi


# _JUST_NIX_BUILD_ARGS='--check'
# _JUST_NIX_BUILD_ARGS='-j0 --builders "@/etc/nix/machines; ssh://pederbs@heid.idi.ntnu.no x86_64-linux - 24 5 big-parallel"'
# _JUST_NIX_INSTANTIATE_ARGS='--system darwin'
@build-packages +$attrpaths="":
    test -n "${attrpaths:-}" || set -- $(just _some_packages); \
    cd "$invokedir"; just _build_packages results "$@"

[no-cd]
_build_packages $outdir +$attrpaths:
    #!/usr/bin/env -S bash -euo pipefail -x
    # hint: supports _JUST_NIX_BUILD_ARGS
    # hint: supports _JUST_NIX_INSTANTIATE_ARGS
    test -z "${_JUST_NIX_BUILD_ARGS:-}"       || echo >&2 "_JUST_NIX_BUILD_ARGS       = $_JUST_NIX_BUILD_ARGS"
    test -z "${_JUST_NIX_INSTANTIATE_ARGS:-}" || echo >&2 "_JUST_NIX_INSTANTIATE_ARGS = $_JUST_NIX_INSTANTIATE_ARGS"
    test -d "$outdir" && {
    	fd . "$outdir" --type l -X rm -v
    	fd \\\.log$ "$outdir" --type f -X rm -v
    }
    mkdir -p "$outdir"
    export _INSTANTIATE_CACHE=$(mktemp -d)
    export NOTFOUNDDIR="$(mktemp -d)"; touch "$NOTFOUNDDIR"/no-eval
    shift
    just instantiate-packages "$@" | tee >(command cat >&2) \
        | eval xargs nom-build --keep-going --no-out-link ${_JUST_NIX_BUILD_ARGS:-} ||:
    worker() {
        set -x
        local attrpath="$1"
        local dst="$outdir/$attrpath"
        local drvpath=$( just instantiate-packages "$attrpath" )
        # NIXPKGS_ALLOW_UNFREE=1 nix-build . -A "$attrpath" ${_JUST_NIX_INSTANTIATE_ARGS:-} -j0 --option builders "" --option substitute false -o "$dst" >&/dev/null
        if [[ -n "$drvpath" ]]; then
            NIXPKGS_ALLOW_UNFREE=1 nix-build "$drvpath" -j0 --option builders "" --option substitute false -o "$dst" >&/dev/null
        fi
        # local outpaths=$( nix-store -q --outputs "$drvpath" ) # doesn't gcroot, some outputs may not be pulled from builders
        if [[ -L "$dst" ]]; then
            nix log $(readlink "$dst") > "$dst".log 2>/dev/null ||:
        else
            if [[ -z "$drvpath" ]]; then
                ln -s "$NOTFOUNDDIR"/no-eval "$dst"
            else
                ln -s /build-failure-"$attrpath" "$dst"
                nix log ".#$attrpath" ${_JUST_NIX_INSTANTIATE_ARGS:-} > "$dst".log 2>/dev/null ||:
            fi
        fi
    }
    printf "%s\n" "$@" | xe -j0 -s "$(declare -f worker); worker \"\$@\""
    # echo -e "#!/usr/bin/env bash\ntest -f flake.nix || cd ..; env _JUST_NIX_INSTANTIATE_ARGS=\"\$*\" just _build_packages \"$outdir\"" $attrpaths > "$outdir"/_rerun.sh
    cat <<-EOF >"$outdir"/_rerun.sh
        #!/usr/bin/env bash
        while [[ ! -f flake.nix ]]; do
            cd ..
        done
        _JUST_NIX_INSTANTIATE_ARGS="\$*" just _build_packages "$outdir" $attrpaths
    EOF
    chmod +x "$outdir"/_rerun.sh
    fd . "$outdir" -l

# TODO: use in 'bump'
[no-cd]
build-package-sources +packages:
    #!/usr/bin/env -S bash -euo pipefail -x
    [[ -e .git && -f flake.nix ]] || { printf >&2 "%s\n" "ERROR: not in repo root!"; false; }
    declare packages=("$@")
    # TODO: allow selecting different names than result-src and results-src-writeable
    just _build_packages results-src "${packages[@]/%/.src}"
    [[ -d results-src-writeable ]] && rm -rf results-src-writeable ||:
    mkdir -p results-src-writeable
    for result in results-src/* ; do
        [[ -L "$result" ]] || continue
        result_writeable=results-src-writeable/"$(basename "$result")"
        mkdir -p "$result_writeable"
        if [[ -d "$(readlink "$result")" ]]; then
            rsync -rxL "$result/" "$result_writeable/" &&
            chmod -R +w "$result_writeable/" ||:
        elif [[ -f "$(readlink "$result")" ]]; then
            atool "$(readlink "$result")" --extract-to="$result_writeable/" ||:
            if [[ $(ls --almost-all "$result_writeable" | wc -l ) -eq 1 ]] && test -d "$result_writeable"/*; then
                mv "$result_writeable"{,-old}
                mv "$result_writeable"-old/* "$result_writeable"
                rmdir "$result_writeable"-old
            fi
        fi
        (
            # todo: should i eval nix and query for upstream remote and ref?
            cd "$result_writeable"
            $GIT init
            $GIT add .
            $GIT commit -m "Base" >/dev/null
        ) ||:
    done
    {
        # printf "#!/usr/bin/env -S nom-build\n"
        printf "#!/usr/bin/env -S nom build -f\n"
        printf "let pkgs = import ./. { }; in {\n"
        for package in "${packages[@]}"; do
            # printf "  # ./build.nix -A %q" "$package"
            printf "  # ./build.nix %q\n" "$package"
            printf "  %s = pkgs.%s.overrideAttrs { src = ./results-src-writeable/%s.src; };\n" "$package" "$package" "$package"
        done
        printf "}\n"
        # printf "# ./build.nix$(printf " -A %q" "${packages[@]}")\n"
        printf "# ./build.nix$(printf " %q" "${packages[@]}")\n"
        printf "# ./build.nix\n"
    } >build.nix
    chmod +x build.nix

@build-pr-packages $pr=`just _a_pr` $merge=`gum choose --header="which refs/pull/<id>/xxx ?" merge head` $attrpaths=`just _some_packages` $args=`gum choose --no-limit -- -j0 "--system "{aarch64,x86_64}-{darwin,linux} --rebuild`:
    -printf "github:nixos/nixpkgs/refs/pull/"$(just _sanitize_pr_url "$pr")"/$merge#%s" $attrpaths | xargs echo + nom build $args
    -(printf "github:nixos/nixpkgs/refs/pull/"$(just _sanitize_pr_url "$pr")"/$merge#%s" $attrpaths | xargs nom build $args) || true
    -printf "github:nixos/nixpkgs/refs/pull/"$(just _sanitize_pr_url "$pr")"/$merge#%s" $attrpaths | xargs echo + nom build $args

# === commit helpers ===

[no-cd]
@commit-staged *$message:
   test -n "$(git diff HEAD --name-only --staged)" || ! echo >&2 "No files are staged!"
   $GIT -c commit.template=<(git diff HEAD --name-only --staged | just _list_packages_fname_filtered | cut -f1 | xargs -d'\n' printf "%s: ${*//%/%%}\n") commit && git show

[no-cd]
commit-dirty-packages +$message=`gum input --placeholder="commit message, (attrpath: this message)"`:
    #!/usr/bin/env -S bash -euo pipefail
    [[ -n "$message" ]]
    just list-dirty-packages |
    while read attrpath position row; do
        [[ -f "$position" ]] || continue
        $GIT diff -s --exit-code "$position" || (
            set -x
            $GIT add "$position"
            $GIT commit -m "$attrpath: $*"
        )
    done

[no-cd]
fixup-commit:
    #!/usr/bin/env -S bash -euo pipefail
    # TODO: list commits first
    test -n "$($GIT diff --name-only --staged)" || {
    	$GIT ls-files --modified --others --exclude-standard |
            grep -v ^results- |
            fzf --layout=reverse --multi --height 15 |
            xe $GIT add --patch
    }
    test -n "$($GIT diff --name-only --staged)" || {
        echo >&2 Nothing is staged!
        false
    }
    just fixup-commit-staged

[no-cd]
fixup-commit-staged commit=`cd "$invokedir"; just _a_commit`:
    #!/usr/bin/env -S bash -euo pipefail
    test -n "{{ commit }}" # just exit if no selection was made
    test -n "$($GIT diff --name-only --staged)" || { echo >&2 Nothing is staged!; false; }
    $GIT diff --staged
    echo; gum format "# ========= into ========="; echo
    $GIT log {{ commit }} -n1
    gum confirm
    $GIT commit --fixup={{ commit }}
    GIT_SEQUENCE_EDITOR=true $GIT rebase -i --autostash --autosquash "$($GIT log -n1 --pretty=%P {{ commit }})"

rebase-commits commit=`cd "$invokedir"; just _a_commit`:
    cd "$invokedir"; $GIT rebase -i --autostash --autosquash "$($GIT log -n1 --pretty=%P {{ commit }})"

# === pr helper ===

[no-cd]
push-new-pr:
    #!/usr/bin/env -S bash -euo pipefail -x
    # TODO: verify "origin" is a nixpkgs fork and not NixOS/nixpkgs
    title=$(just _a_commit_title ||:)
    $GIT -c push.autoSetupRemote=true push origin
    if [[ -n "$title" ]]; then
        gh pr create --title="$title"
    else
        gh pr create
    fi


# === speed worktrees ===

bump-new-worktree *packages:
    #!/usr/bin/env -S bash -euo pipefail -x
    declare -a packages=("$@")
    [[ -n "${packages[*]}" ]] || packages=($(just _some_packages))
    worktree=$(just _new_worktree bump "$(printf "%s\n" "${packages[0]}" | rev | cut -d. -f1 | rev)")
    [[ -n "worktree" ]]
    cd "$worktree"
    just bump-here "${packages[@]}"
    NIXPKGS_ALLOW_UNFREE=1 "$SHELL"

[no-cd]
bump-here *packages:
    #!/usr/bin/env -S bash -euo pipefail -x
    [[ -e .git && flake.nix ]]
    declare -a packages=("$@")
    [[ -n "${packages[*]}" ]] || packages=($(just _some_packages))
    printf "%s.src\n" "${packages[@]}" | xargs just _build_packages results-src-old ||: # TODO: unpack?
    config=(env
        NIXPKGS_ALLOW_UNFREE=1
        NIXPKGS_ALLOW_BROKEN=1
        NIXPKGS_ALLOW_INSECURE=1
    )
    for package in "${packages[@]}"; do
      if nix eval -f . "$package".passthru.updateScript >&/dev/null; then
        HEAD=$($GIT rev-parse HEAD)
        "${config[@]}" nix-update "$package" --use-update-script --update-script-args "--argstr skip-prompt true" --commit
        if [[ $($GIT rev-parse HEAD) = "$HEAD" ]]; then
          echo "no commit found, trying without the updateScript..."
          $GIT restore .
          "${config[@]}" nix-update "$package" --commit || true
        fi
      else
        "${config[@]}" nix-update "$package" --commit || true
      fi
    done
    set +e
    printf "%s.src\n" "${packages[@]}" | xargs just _build_packages results-src-new # TODO: unpack?
    just _build_packages results "${packages[@]}"
    # TODO: filter non-existing tests:
    printf "%s.tests\n" "${packages[@]}" |  env _JUST_NIX_BUILD_ARGS="-j1" xargs just _build_packages results-tests
    printf "HEAD^%s " $(seq 0 $(($#-1))) | xe $GIT show
    fd . -l results results-tests --max-depth 1
    # test -L result && fd . result --type x --color=always | tee update-executables.txt
    # $GIT show --name-only --pretty="" | xe statix fix
    $GIT diff
    printf "delta results-src-{old,new}/%s.src/.\n" "${packages[@]}"

fix *packages:
    #!/usr/bin/env -S bash -euo pipefail
    declare packages=("$@")
    [[ "${#packages[@]}" -gt 0 ]] || packages=($(just _some_packages))
    [[ "${#packages[@]}" -gt 0 ]] || { printf >&2 "%s\n" "ERROR: no packages chosen..."; false; }
    cd "$(just _new_worktree fix "$(echo "${packages[0]}" | rev | cut -d. -f1 | rev)")"
    just _fix "${packages[@]}" ||:
    $SHELL

[no-cd]
_fix +packages:
    #!/usr/bin/env -S bash -euo pipefail
    [[ -e .git && -f flake.nix ]] || { printf >&2 "%s\n" "ERROR: not in repo root!"; false; }
    declare packages=("$@")
    just build-package-sources "${packages[@]}"
    NIXPKGS_ALLOW_UNFREE=1 just build-packages "${packages[@]}" ||:
    if command -v bat >/dev/null;
    then bat build.nix --style header-filename
    else cat build.nix
    fi
    echo "./results/_rerun.sh --system $(nix config show system)"

pr $number=`just _a_pr`:
    #!/usr/bin/env -S bash -euo pipefail
    number=$(just _sanitize_pr_url "$number")
    if [[ -d prs/pr-"$number" ]]; then
        cd prs/pr-"$number"
    elif test -d prs/pr-"$number"-*; then
        cd prs/pr-"$number"-*
    else
        (cd master;
            $GIT worktree prune
            $GIT worktree add ../prs/pr-"$number"
        )
        cd prs/pr-"$number"
        gh pr checkout "$number"
    fi
    $SHELL

@pr-comment-diff:
    cd "$invokedir"; just _pr_post_diff comment

@pr-review-diff:
    cd "$invokedir"; just _pr_post_diff "review $(gum choose --ordered -- --comment --request-changes --approve)"

@_pr_post_diff mode:
    test "prs" = "$(cd "$invokedir" ; $GIT rev-parse --show-toplevel | rev | cut -d/ -f2 | rev)"
    test -n "$(cd "$invokedir"; $GIT diff --staged)" || { echo no changes staged; cd "$invokedir"; $GIT add --patch; true; }
    test -n "$(cd "$invokedir"; $GIT diff --staged)" || { echo no changes staged; false; }
    cd "$invokedir"; \
    NUMBER="$($GIT rev-parse --show-toplevel | rev | cut -d/ -f1 | rev | cut -d- -f2)"; \
    FNAME="$(mktemp --suffix=.md)"; \
    echo "NUMBER=$NUMBER" "FNAME=$FNAME"; \
    >>"$FNAME" echo; \
    >>"$FNAME" echo '<details>'; \
    >>"$FNAME" echo '<summary>:clipboard: proposed patch</summary>'; \
    >>"$FNAME" echo; \
    >>"$FNAME" echo '```patch'; \
    >>"$FNAME" $GIT diff --staged; \
    >>"$FNAME" echo '```'; \
    >>"$FNAME" echo; \
    >>"$FNAME" echo '</details>'; \
    >>"$FNAME" echo; \
    >>"$FNAME" echo '_How to apply (pick one):_'; \
    >>"$FNAME" echo; \
    >>"$FNAME" echo 'a. `curl -L "'"$($GIT diff --staged | gh gist create -f pr-$NUMBER.patch -)"'/raw" | $GIT apply`'; \
    >>"$FNAME" echo 'b. copy the patch above, run `$GIT apply`, paste (typically `ctrl-shift-v`), press enter, then end the input with `ctrl-d`'; \
    "$EDITOR" "$FNAME"; \
    test -s "$FNAME" && bat --language markdown --style plain --pager never "$FNAME" && gum confirm && gh pr {{ mode }} "$NUMBER" --body-file "$FNAME"; \
    rm -v "$FNAME"

remote-branch $remote_ref=`just _a_remote_branch origin | cut -d/ -f2-`:
    #!/usr/bin/env -S bash -euo pipefail
    branch_dir=$(cut <<<"$remote_ref" -d- -f1)
    branch_base=$(cut <<<"$remote_ref" -d- -f2-)
    cd master
    $GIT worktree add --track ../"$branch_dir/$branch_base" -b "$remote_ref" origin/"$remote_ref"
    cd ../"$branch_dir/$branch_base"
    $SHELL

# === worktrees ===
# TODO: onto release-xx.yy doesn't work

# TODO: python-updates
@new-worktree *args:
    cd "$(just _new_worktree "$@")"; $SHELL

@_a_wt_type:
    gum choose feat fix init bump doc migrate
@_a_wt_name:
    gum input --placeholder="Branch name?"
_new_worktree $type=`just _a_wt_type` $name=`just _a_wt_name` $base=`just _a_upstream_release_branch "Base?"` $onto=`just _a_upstream_release_branch "Onto?" ""`:
    #!/usr/bin/env -S bash -euo pipefail
    [[ -n "$type" ]]
    [[ -n "$name" ]]
    name="$(printf "%s" "$name" | tr '[:space:]/' -- | tr -s -)"
    just _mk_worktree 1>&2 \
        "$type-$name-{{ epoch }}" \
        "$type/$name-{{ epoch }}" \
        "$base" \
        "$onto"
    echo "$type/$name-{{ epoch }}"

_mk_worktree $name $dir $base="upstream/master" $onto="":
    #!/usr/bin/env -S bash -euo pipefail -x
    [[ -n "$name" ]]
    [[ -n "$dir" ]]
    remote="$(cut -d/ -f1  <<<"$base")"
    branch="$(cut -d/ -f2- <<<"$base")"
    cd master
    $GIT worktree prune
    $GIT fetch "$remote" "$branch"
    $GIT branch "$name" "$branch" --no-track
    $GIT worktree add ../"$dir" "$name"
    cd ../"$dir"
    $GIT pull --rebase "$remote" "$branch"
    [[ -z "$onto" ]] || just rebase-onto HEAD "$onto"

pop-commits-to-new-worktree $commits=`cd "$invokedir"; just _some_commits`:
    #!/usr/bin/env -S bash -euo pipefail
    test -n "$commits" || { echo >&2 "no commits were selected!"; false;}
    # we make a nasty assumption here: the last commit passed in is also the topologically oldest one in the git history
    # we also assume the revs in the interactive rebase are just as short or longer as those returned by 'just _some_commits'
    type="$(just _a_wt_type)"
    name="$(
        cd "$invokedir";
        git show --oneline --no-patch "$(head -n1 <<<"$commits")" |
            cut -d' ' -f2- | cut -d: -f1 | rev | cut -d. -f1 | rev
    )"
    cd "$(
        just _new_worktree "$type" "$(gum input --placeholder="Branch name?" --value="$name")"
    )"
    if (tac <<<"$commits" | xargs git cherry-pick); then
        (
            cd "$invokedir"
            EDITOR="sed -i $(xargs <<<"$commits" printf " -e 's/^pick %s/#/g'")" \
                git rebase "$(tail -n1 <<<"$commits")"^^ -i
        )
        git log -n "$(wc -l <<<"$commits" )"
        $SHELL
    else
        echo >&2 "The commits have not been popped."
        git status
        echo >&2 "The commits have not been popped."
        $SHELL
    fi

[no-cd]
@_rebase_onto $onto:
    [[ -n "$onto" ]]
    $GIT fetch upstream "$onto"
    $GIT rebase --onto upstream/"$onto"...HEAD upstream/master --autostash

[no-cd]
rebase-onto $base=`just _a_upstream_release_branch "Base?" HEAD` $onto=`just _a_upstream_release_branch "Onto?"`:
    #!/usr/bin/env -S bash -euo pipefail
    [[ -n "$onto" ]]
    if [[ "$base" != HEAD ]] ; then
        remote="$(cut -d/ -f1  <<<"$base")"
        branch="$(cut -d/ -f2- <<<"$base")"
        (set -x; $GIT fetch "${remote:-upstream}" "$branch")
    fi
    if [[ "$onto" != HEAD ]] ; then
        remote="$(cut -d/ -f1  <<<"$onto")"
        branch="$(cut -d/ -f2- <<<"$onto")"
        (set -x; $GIT fetch "${remote:-upstream}" "$branch")
    fi
    # $GIT rebase --onto upstream/"$onto"...HEAD upstream/master --autostash
    $GIT rebase --onto "$onto"..."$base" $base --autostash

# fix periodic merge conflicts

fix-periodic-merge-conflict $from=`just _a_upstream_release_branch "From?"` $to=`just _a_upstream_release_branch "To?"`:
    cd "$invokedir"; $GIT fetch upstream "$from"
    cd "$invokedir"; $GIT fetch upstream "$to"
    cd "$invokedir"; $GIT worktree add -b fix-merge-conflict-"$from"-to-"$to"-{{ epoch }} ../fix/merge-conflict-"$from"-to-"$to"-{{ epoch }} upstream/"$to"
    cd fix/merge-conflict-"$from"-to-"$to"-{{ epoch }}; $GIT merge upstream/"$from" || true
    cd fix/merge-conflict-"$from"-to-"$to"-{{ epoch }}; $GIT status
    @echo "Cheatsheet:"
    @echo "  $GIT ls-files --modified | sort -u | xe -N0 $GIT reset"
    @echo "  $GIT commit"
    @echo "  $GIT push upstream HEAD:$to"
    cd fix/merge-conflict-"$from"-to-"$to"-{{ epoch }}; $SHELL

# === setup ===

setup:
    #!/usr/bin/env -S bash -euo pipefail
    if [[ ! -e master/.git ]]; then
        gh_user=$(gum input \
            --header "git clone git@github.com:< username >/nixpkgs.git" \
            --value="$(
                if command -v gh >/dev/null && gh auth status >&/dev/null; then
                    gh api user --jq .login
                else
                    whoami
                fi
            )"
        )
        $GIT clone "git@github.com:${gh_user}/nixpkgs.git" master
        [[ -e master/.git ]]
    fi
    cd master
    if ! $GIT remote get-url upstream >&/dev/null; then
        $GIT remote add upstream "https://github.com/NixOS/nixpkgs.git"
    fi
    add_upstream() {
        local branch="$1"
        if [[ ! -d ../upstream/"$branch" ]]; then
            $GIT fetch upstream "$branch"
            $GIT worktree add ../upstream/"$branch" -B "$branch" upstream/"$branch"
        fi
    }
    add_upstream staging
    add_upstream staging-next
    add_upstream staging-24.11
    add_upstream staging-next-24.11

# TODO: test
#upstreams-fetch:
#    cd master; $GIT fetch upstream master
#    cd master; $GIT fetch upstream staging
#    cd master; $GIT fetch upstream staging-next
#    cd master; $GIT fetch upstream release-24.05
#    cd master; $GIT fetch upstream staging-24.05
#    cd master; $GIT fetch upstream release-23.11
#    cd master; $GIT fetch upstream staging-23.11
#    cd master; $GIT fetch upstream python-updates
#  === helpers ===
# TODO stat the file and redo if too old, or tie it to the master checkout commit

clean:
    #!/usr/bin/env -S bash -euo pipefail
    cleanlist="$(just _mk_clean_list)" || exit 1
    #gum choose --no-limit --height="$(($(wc -l <<<"$cleanlist") + 5))" <<<"$cleanlist" | bash -x -
    gum choose --no-limit <<<"$cleanlist" | bash -x -

_mk_clean_list:
    #!/usr/bin/env -S bash -euo pipefail
    # set -x
    (
        cd master
        # TODO: assert "upstream" present?
        just _upstream_release_branches "" | xargs -d'\n' $GIT fetch upstream
    )
    porcelain2jsonl() {
        uniq | (
            printf "["
            while read key data; do
                if test -z "$key"; then
                    printf "]\n["
                else
                    printf '{"%s": "%s"}, ' "$key" "$data"
                fi
            done
            echo "]"
        ) | sed  -e 's/, ]/]/g' | grep -v '^\[\]$' | jq add -c
    }
    worktrees="$( cd master; git worktree list --porcelain | porcelain2jsonl )"
    #cat <<<"$worktrees"
    (
        cd master
        just _upstream_release_branches | xe -j0 $GIT branch --merged ||:
    ) | sort -u |
    while IFS= read line; do
        branch="$(cut <<<"$line" -c3-)"
        if [[ "$branch" = "scratch" ]] \
        || grep <<<"$branch" "$(just _upstream_release_branches '^' '$')" --quiet; then
            continue
        fi
        #jq <<<"$worktrees" '.branch'
        worktree="$( jq <<<"$worktrees" 'select(.branch == "refs/heads/'"$branch"'")' -c | head -n1 )"
        #echo "$line"
        #echo "$branch"
        #echo "$worktree"
        if [[ -n "$worktree" ]]; then
            path="$(jq <<<"$worktree" .worktree -r )"
            if [[ -d "$path" ]]; then
                if (
                  cd "$path"
                  ! $GIT diff HEAD --quiet --exit-code >&/dev/null ||
                  $GIT ls-files --others --exclude-standard |
                     grep -qEv '^(update-executables\.txt|results(-.*)?|build\.nix|(asd|do|foo|test|spismeg|packages)[2-9]?\.(sh|txt|json)|diff\.patch|patch\.diff|(packages(_?[0-9]+))\.json|[^/]*\.log)$'
                ) ; then
                    continue
                fi
                if [[ "$(basename "$path")" != "tmp" ]] \
                && [[ "$(basename "$path")" != "scratch" ]]
                then
                    printf "rm -rf %q\n" "$path"
                fi
            fi
        fi
        printf "%s\n" "( cd master && $GIT worktree prune && git branch -D \"$branch\" )"
    done
    #printf "%s\n" "( cd master && git worktree prune && git prune )" # slow
    printf "%s\n" "( cd master && git worktree prune )"
    printf "%s\n" "rmdir */ --ignore-fail-on-non-empty"

_packages_json:
    #!/usr/bin/env -S bash -euo pipefail
    if [[ ! -s packages.json ||
        $(( "$epoch" - "$(stat -c %Y packages.json )" )) -gt $(( 60*60*24*7 ))
    ]]; then
        set -x
        if ! $GIT -C master/ diff HEAD --exit-code --quiet 1>&2; then
            echo >&2 "ERROR: $(realpath master) is dirty!"
        fi
        git -C master/ pull upstream master 1>&2
        time nix-env > packages.json \
            --extra-experimental-features no-url-literals \
            --option system x86_64-linux \
            -f ./master \
            -qaP \
            --json \
            --meta \
            --show-trace \
            --no-allow-import-from-derivation \
            --arg config '{ allowAliases = false; }'
    fi

@_a_commit *extra_revs:
    # TODO: check if in a nixpkgs git repo
    { \
        [[ $# -eq 0 ]] || printf "%s\n" "$@"; \
        cd "$invokedir"; $GIT log --oneline -n800; \
    } | gum filter --placeholder "Pick commit..." --height 10 | cut -d' ' -f1 | grep .

@_some_commits:
    # TODO: check if in a git repo
    #cd "$invokedir"; $GIT log --oneline -n800 | gum filter --placeholder "Pick commit..." --height 10 --no-limit | cut -d' ' -f1
    cd "$invokedir"; $GIT log --oneline -n800 | fzf --layout=reverse --multi --height 15 | cut -d' ' -f1

@_a_commit_title:
    cd "$invokedir"; rev="$(just _a_commit)" || exit $?; [[ -n "$rev" ]] && git log --format="%s" -n1 "$rev" | grep .

@_a_package: _packages_json
    #gum spin --show-output just list-packages | cut -f1 | fzf --sync --layout=reverse --height 15 | grep .
    just list-packages >/dev/null
    just list-packages | cut -f1 | fzf --sync --layout=reverse --height 15 | grep .

@_some_packages: _packages_json
    #gum spin --show-output just list-packages | cut -f1 | fzf --sync --layout=reverse --height 15 --multi | grep .
    just list-packages >/dev/null
    just list-packages | cut -f1 | fzf --sync --layout=reverse --height 15 --multi | grep .

@_a_pr:
    cd master; gh pr list --limit 1000 --json 'number,title' --state open | jq '.[]|"\(.number) - \(.title)"' -r | gum filter --placeholder "Pick PR..." --height 10 | cut -d' ' -f1

@_upstream_release_branches $prefix="upstream/" $suffix="":
    printf "${prefix//%/%%}%s${suffix//%/%%}\n" \
        master \
        staging \
        staging-next \
        python-updates \
        release-24.11 \
        staging-24.11 \
        staging-next-24.11

@_a_upstream_release_branch $header *extra_branches:
    shift; gum choose --header="$header" "$@" $(just _upstream_release_branches "${prefix:-upstream/}")
    #  --ordered

@_sanitize_pr_url $number:
    echo "$number" | tr '[:upper:]' '[:lower:]' | sed -Ee 's|https?://github.com/nixos/nixpkgs/pull/([0-9]+).*|\1|'

@_a_remote_branch $remote="origin":
    cd master; $GIT fetch "$remote"
    cd master; $GIT for-each-ref --sort=committerdate refs/remotes --format='%(committerdate:short) %(refname:short)' | sort -r | grep " $remote/" | gum filter  --height=15 --no-sort | cut -d' ' -f2-

@_fmt:
    just --unstable --fmt
    #sd "\n+(@_[a-zA-Z_-]+:)" "\n" justfile