ii

#!/bin/bash

# Imaginary interpreter
# Version 2.0, bash

sn="$(basename "$0")"
if test -f $HOME/.emacs.d/host/pen.el/scripts/$sn && ! test "$HOME/.emacs.d/host/pen.el/scripts" = "$(dirname "$0")"; then
    $HOME/.emacs.d/host/pen.el/scripts/$sn "$@"
    exit "$?"
fi

CMD="$(cmd-nice-without-bs "$@")"

sn="$(basename "$0")"

inside-docker-p() {
    test -f /.dockerenv
}

use_comint=y
while [ $# -gt 0 ]; do opt="$1"; case "$opt" in
    "") { shift; }; ;;
    -nd) {
        export NO_DOCKER=y
        shift
    }
    ;;

    -s) {
        export SILENT=y
        shift
    }
    ;;

    -d) {
        export DEBUG=y
        shift
    }
    ;;

    *) break;
esac; done

if { ! test "$NO_DOCKER" = y; } && { ! inside-docker-p; }; then
    # pen sh nvc ii "$@"
    pen sh ii "$@"
    exit "$?"
fi

ii-logo 1>&2

while [ $# -gt 0 ]; do opt="$1"; case "$opt" in
    "") { shift; }; ;;
    -nc|-nocomint) {
        use_comint=n
        shift
    }
    ;;

    *) break;
esac; done

lang="$1"
test -n "$lang" || exit 1
shift

case "$lang" in
    shell) {
        lang=bash
    }
    ;;

    *)
esac

memory="$1"
echo "$memory" | tee -a /tmp/yo.txt &>/dev/null &

kickstarter="$2"
kickstarter="$(p "$kickstarter" | pen-str remove-trailing-whitespace | tee -a /tmp/kickstarter.txt)"

test -d "prompts" && : "${PROMPTS_DIR:="prompts"}"
test -d "$HOME/.emacs.d/host/prompts" && : "${PROMPTS_DIR:="$HOME/.emacs.d/host/prompts"}"
test -d "$HOME/.pen/prompts" && : "${PROMPTS_DIR:="$HOME/.pen/prompts"}"

lang_lc="$(p "$lang" | tr '[:upper:]' '[:lower:]' | slugify)"

set -o pipefail

funs="$(penl)"
if ! test "$?" = 0; then
    echo "pen must be running" 1>&2
    exit 1
fi

fun="$(p "$funs" | awk 1 | grep -P "imagine-a-${lang_lc}-interpreter/2" | sed 's/^pf-//')"

extra_args=()

if test -z "$fun"; then
    test "$SILENT" = y || echo "No $lang_lc interpreter prompt" 1>&2
    extra_args+=("$lang")
    # exit 1
fi

: "${fun:="generic-interpreter/3"}"

if test -n "$fun"; then
    fn="$(p "$fun" | tr -s / -)"
    path="$PROMPTS_DIR/prompts/${fn}.prompt"
fi

if ! { test -n "$path" && test -f "$path"; }; then
    test "$SILENT" = y || echo "No path for $lang_lc interpreter prompt at $path 1>&2" 1>&2
    exit 1
fi

if test -z "$kickstarter"; then
    # Instead of reading the kickstarter directly, generate it frm

    IFS= read -rd '' banner < <(penf -p --pool -op "<banner>" -nogen -u "$fun" "" "" "${extra_args[@]}" | pen-str remove-trailing-whitespace);typeset -p banner &>/dev/null

    if test -n "$banner" && ! test "${banner}" = "<banner>"; then
        prelude="<banner>\\n<kickstarter>"
    else
        prelude="<kickstarter>"
    fi

    IFS= read -rd '' kickstarter < <(penf -p --pool -op "$prelude" -nogen -u "$fun" "" "" "${extra_args[@]}" | pen-str remove-trailing-whitespace);typeset -p kickstarter &>/dev/null

    # IFS= read -rd '' kickstarter < <(cat "$path" | yq -r '.subprompts[0].kickstarter // empty' | sed "s/<language>/$lang/g" | pen-str remove-trailing-whitespace);typeset -p kickstarter &>/dev/null
fi

IFS= read -rd '' ii_input_echo_pp < <(cat "$path" | yq -r '.["ii-input-echo-pp"] // empty' 2>/dev/null);typeset -p ii_input_echo_pp &>/dev/null
IFS= read -rd '' user_prompt_re < <(cat "$path" | yq -r '.["user-prompt"] // empty' 2>/dev/null | chomp | pen-str onelineify-safe);typeset -p user_prompt_re &>/dev/null
IFS= read -rd '' comint_user_prompt_re < <(cat "$path" | yq -r '.["comint-user-prompt-regex"] // empty' 2>/dev/null | chomp);typeset -p comint_user_prompt_re &>/dev/null
IFS= read -rd '' repl_preprocessor < <(cat "$path" | yq -r '.pipelines[]."repl-pp" // empty' 2>/dev/null | chomp);typeset -p repl_preprocessor &>/dev/null

if test -n "$repl_preprocessor"; then
    kickstarter="$(printf -- "%s" "$kickstarter" | eval "$repl_preprocessor")"
fi

: "${user_prompt_re:="$comint_user_prompt_re"}"

if test "$use_comint" = y && ! printf -- "%s\n" "$INSIDE_EMACS" | grep -q -P 'comint$'; then
    comint -p "$user_prompt_re" -E "ii -s $CMD"
    exit $?
fi

prompt_the_lm() {
    user_input="$1"

    # TODO Use pena because I want better results
    # Rather, make a penc (pen collect) and use that

    # cmd penf -u "$fun" "$memory" "$user_input" | pen-tv &>/dev/null

    pena -fz -u --pool "$fun" "$memory" "$user_input"  "${extra_args[@]}"
}

p "${kickstarter} "
memory="${kickstarter} "

# Sometimes I want to read multiple lines. How?
while read -e -r user_input; do
    test "$DEBUG" = y &&  echo -en "\033[1A\033[2K"
    test "$DEBUG" = y &&  echo "$user_input"

    if test -n "$ii_input_echo_pp"; then
        IFS= read -rd '' ii_input_echo < <(printf -- "%s" "$user_input" | eval "$ii_input_echo_pp");typeset -p ii_input_echo &>/dev/null
        if test -n "$ii_input_echo"; then
            printf -- "%s\n" "$ii_input_echo"
            user_input="$user_input\n$ii_input_echo"
        fi
    fi

    test "$DEBUG" = y && printf -- "%s" "$user_input"

    # These commands are for re-prompting
    case "$user_input" in
        "!!"|""|"!1"|"~1") {
            memory="$last_memory"
            user_input="$last_user_input"
        }
        ;;

        "!!"*) {
            memory="$last_memory"
            user_input="${user_input:2}"
        }
        ;;

        "!2"|"~2") {
            memory="$last_last_memory"
            user_input="$last_last_user_input"
        }
        ;;
    esac

    # The prompt functions are not perfect and we want to coerce the output to the form we want
    gen="$(prompt_the_lm "$user_input" | chomp | sed -z 's/^\n\+//')"
    last_last_memory="$last_memory"; last_memory="$memory"
    memory+="$user_input\n"
    p "$gen"
    memory+="$gen"
    p "$memory" > "/tmp/memory.txt"
    last_last_user_input="$last_user_input"; last_user_input="$user_input"
done

p () {
    {
        i=1
        while [ "$i" -lt "$#" ]; do
            eval ARG=\${$i}
            printf -- "%s " "$ARG"
            i=$((i + 1))
        done
        eval ARG=\${$i}
        printf -- "%s" "$ARG"
    } | sed 's/\\n/\n/g'
}