#!/bin/sh
# vim: set filetype=sh :
#        file: /usr/share/shellia/ia.check
#   copyright: Bernd Schumacher <bernd.schumacher@hpe.com> (2007-2020)
#     license: GNU General Public License, version 3
# description: ia.check - functions to check stderr, stdout and exit-value of
#   steps. For each list of steps, handled by one ia call, the check-option -c
#   or -C can be choosen.

# ia_find_lib <lib>
# example:
#   program "/nfs/host1/usr/local/bin/program" with line "ia_source_lib /usr/share/shellia/ia" called
#   from directory "/tmp" will try "/tmp/ia", ... "/nfs/host1/usr/share/shellia/ia", ... and
#   "/usr/share/shellia/ia" in the listed order.
ia_find_lib()
{
  local i
  local p

  for i in "$@"; do
    [ -f "./$(basename "$i")" ] && /bin/echo "./$(basename "$i")" && return 0
    p="$0"
    while :; do
      [ "$p" != "$(dirname p)" ] || break
      p="$(dirname "$p")"
      [ -f "$p/$i" ] && /bin/echo "$p/$i" && return 0
    done
    [ -f "$i" ] && /bin/echo "$i" && return 0
    return 1
  done
}

if [ "${ia_prefix:=ia}" != "ia" ] || [ "${dbg_prefix:=dbg}" != "dbg" ]; then
  [ -n "$(eval "/bin/echo \${${ia_prefix}_check_already_sourced:=}")" ] && return
  eval "$(sed -e "s/ia_/${ia_prefix}_/g" -e "s/ia()/${ia_prefix}()/g" \
    -e "s/dbg/${dbg_prefix}/g" "$(ia_find_lib /usr/share/shellia/ia.check)")"
  return
fi

[ "${ia_check_already_sourced:=}" ] && return || ia_check_already_sourced=1

. "$(ia_find_lib /usr/share/shellia/ia.basic)"


ia_check_exitcode()
{
  local ia_ign_awk
  local ia_std_awk
  ia_ign_awk="$(/bin/echo "$ia_ign" | sed -e 's#/#\\/#g')" # escape / in gawk /$ia_ignore/{...}
  ia_std_awk="$(/bin/echo "$ia_std" | sed -e 's#/#\\/#g')" # escape / in gawk /$ia_stdout/{...}
  ia_awk=""
  [ -n "$ia_std_awk" ] && ia_awk="$ia_awk/$ia_std_awk/{getline;printf(\"s:%s\n\",\$0);next}" # stdout is more important that ignore
  [ -n "$ia_ign_awk" ] && ia_awk="$ia_awk/$ia_ign_awk/{getline;printf(\"i:%s\n\",\$0);next}"
  ia_awk="$ia_awk{getline;printf(\"e:%s\n\",\$0);next}"
  # to grep without color-codes, we add a line without color-codes before each line
  ia_out="$(cat "$ia_out_file" | gawk "$ia_awk")"
  #ia_dev_dbg "ia_check_exitcode: ia_out_file=<$(cat $ia_out_file)> ignore=<$ia_ign> stdout=<$ia_std> ia_awk=<$ia_awk> ia_out=<$ia_out> ia_return=<$ia_return>"
}

ia_check_c()
{
  local ia_ign_awk
  local ia_std_awk
  ia_ign_awk="$(/bin/echo "$ia_ign" | sed -e 's#/#\\/#g')" # escape / in gawk /$ia_ignore/{...}
  ia_std_awk="$(/bin/echo "$ia_std" | sed -e 's#/#\\/#g')" # escape / in gawk /$ia_stdout/{...}
  ia_awk=""
  ia_awk="$ia_awk/^\+ eval.*ia_init_details\"$/{getline;next}" # delete set +x line from $ia_init
  ia_awk="$ia_awk/^\++ /{getline;print;next}"
  [ -n "$ia_std_awk" ] && ia_awk="$ia_awk/$ia_std_awk/{getline;printf(\"s:%s\n\",\$0);next}" # stdout is more important that ignore
  [ -n "$ia_ign_awk" ] && ia_awk="$ia_awk/$ia_ign_awk/{getline;printf(\"i:%s\n\",\$0);next}"
  ia_awk="$ia_awk{getline;printf(\"e:%s\n\",\$0);next}"
  # to grep without color-codes, we add a line without color-codes before each line
  ia_out="$(cat "$ia_out_file" |
    gawk '{l=$0;gsub(/'$ia_col_regex'/,"");print;print l}' | gawk "$ia_awk")"
  #ia_dev_dbg "ia_check_c: ia_out_file=<$(cat $ia_out_file)> ignore=<$ia_ign> stdout=<$ia_std> ia_awk=<$ia_awk> ia_out=<$ia_out> ia_return=<$ia_return>"
}

ia_check_C()
{
  local ia_ign_awk
  local ia_std_awk
  ia_ign_awk="$(/bin/echo "$ia_ign" | sed -e 's#/#\\/#g')" # escape / in gawk /$ia_ignore/{...}
  ia_std_awk="$(/bin/echo "$ia_std" | sed -e 's#/#\\/#g')" # escape / in gawk /$ia_stdout/{...}
  ia_awk=""
  ia_awk="$ia_awk/^\+ eval.*ia_init_details\"$/{getline;next}" # delete set +x line from $ia_init
  ia_awk="$ia_awk/^\++ /{getline;print;next}"
  [ -n "$ia_ign_awk" ] && ia_awk="$ia_awk/$ia_ign_awk/{getline;printf(\"i:%s\n\",\$0);next}"
  ia_awk="$ia_awk{getline;printf(\"e:%s\n\",\$0);next}"
  # to grep without color-codes, we add a line without color-codes before each line
  ia_out="$(cat "$ia_stderr_file" |
    gawk '{l=$0;gsub(/'$ia_col_regex'/,"");print;print l}' | gawk "$ia_awk"
    sed "s/^/s:/" "$ia_stdout_file")"
  #ia_dev_dbg "ia_check_C: ia_stdout_file=<$(cat $ia_stdout_file)> ia_stderr_file=<$(cat $ia_stderr_file)> ignore=<$ia_ign> ia_awk=<$ia_awk> ia_out=<$ia_out> ia_return=<$ia_return>"
}

ia_dev_expr()
{
  local ia_ignore
  local ia_stdout
  while [ "$ia_input" = "d" ]; do

    if [ "$ia_use_check" = "--exitcode" ]; then
      ia_check_exitcode
    elif [ "$ia_use_check" = "-c" ]; then
      ia_check_c
    else # ia_use_check = "-C"
      ia_check_C
    fi

    cat <<END > /tmp/ia_dev_expr || ia_exiterr $? "shellia: /tmp/ia_dev_expr is not writeable"
# This file is for development of shellia scripts.
END
    cat <<END >>/tmp/ia_dev_expr
# The actual command was:
END
    /bin/echo "$ia_cmd" | sed "s/^/#  /" >> /tmp/ia_dev_expr
    cat <<END >>/tmp/ia_dev_expr
# The actual output of the command was:
END
    /bin/echo "$ia_out" | sed "s/^/#  /" >> /tmp/ia_dev_expr
  cat << END >> /tmp/ia_dev_expr
# Now try to fix lines below.
# Do not forget to fix it in your script.

END
    /bin/echo "ia_ignore \"$(/bin/echo "$ia_ign" | ia_easy_backslash)\"" >> /tmp/ia_dev_expr
    /bin/echo "ia_stdout \"$(/bin/echo "$ia_std" | ia_easy_backslash)\"" >> /tmp/ia_dev_expr
    ia_input="$(ia_ask -f "(d)evelop /tmp/ia_dev_expr (r)etry (q)uit (i)gnore (s)witch interactive" "" "q" "? " "^(q|i|s|r|d)$")"

    ia_ignore=""
    ia_stdout=""
    . /tmp/ia_dev_expr
    ia_ign="$ia_ignore"
    ia_std="$ia_stdout"
  done
}

# ia_result <cmd>
ia_result()
{
  # global ia_use_silent -- non-empty means do not allow any interactive questions in case of an error
  # global ia_use_minctrl -- non-empty means do not allow to switch to interacive mode in case of an error
  local ia_cmd
  local ia_input

  ia_cmd="$1"
  #ia_dev_dbg "ia_result: ia_cmd=<$ia_cmd>"

  if [ -z "$(/bin/echo "$ia_out" | grep -e "^e:")" ]; then
    ia_out="$(/bin/echo "$ia_out" | sed "s/^e:\(.*\)$/e:${ia_red}\1${ia_no_color}/")"
    #ia_dev_dbg "ia_result: ia_out1=<$ia_out>"
    /bin/echo "$ia_out" | grep -e "^+\+ " | ia_err
    [ -n "$ia_out" ] && ia_log "$ia_out"
    /bin/echo "$ia_out" | sed -n "s/^s://p"
    return 1
  elif [ -n "$ia_use_learn" ]; then
    ia_out="$(/bin/echo "$ia_out" | sed "s/^e:\(.*\)$/l:${ia_orange}\1${ia_no_color}/")"
    #ia_dev_dbg "ia_result: ia_out2=<$ia_out>"
    /bin/echo "$ia_out" | grep -e "^+\+ " | ia_err
    /bin/echo "$ia_out" | grep -v -e "^l:" | ia_log
    /bin/echo "--- output to LEARN from <$ia_head> running <$(/bin/echo "$ia_cmd" | head -n 1)> ---" | ia_logerr
    /bin/echo "$ia_out" | grep -e "^l:" | ia_logerr
    /bin/echo "$ia_out" | sed -n -e "s/^s://p"
    return 1
  else
    ia_out="$(/bin/echo "$ia_out" | sed "s/^e:\(.*\)$/e:${ia_red}\1${ia_no_color}/")"
    #ia_dev_dbg "ia_result: ia_out3=<$ia_out>"
    ia_question="--- output with ERROR from <$ia_head> running <$(/bin/echo "$ia_cmd" | head -n 1)> ---"
    ia_question="$ia_question
$ia_out"
    if [ -z "${ia_use_silent:=}" ] && [ -z "${ia_use_minctrl:=}" ] && [ -z "$ia_use_interactive" ]; then
      ia_question="$ia_question
$(printf "%s" "--- (q)uit (r)edo (i)gnore (s)witch interactive ---")"
    elif [ -z "$ia_use_silent" ]; then
      ia_question="$ia_question
$(printf "%s" "--- (q)uit (r)edo (i)gnore ---")"
    else
      [ $ia_return -ne 0 ] || ia_return=2 # assert nonzero exit
      ia_exiterr $ia_return "$ia_question
Exit because of ERROR and no interactive question allowed."
    fi

    # ia_ask <question> <default> <eof> <prompt> <regex>
    ia_input="$(ia_ask "$ia_question" "" "q" "? " \
      "$([ -n "$ia_use_minctrl" ] && /bin/echo "^(q|i|r)$" || /bin/echo "^(q|i|s|r|d)$")")"
    if [ "$ia_input" = "d" ]; then
      ia_dev_expr
    fi
    if [ "$ia_input" = "q" ]; then
      [ $ia_return -ne 0 ] || ia_return=1 # assert nonzero exit
      exit $ia_return
    elif [ "$ia_input" = "i" ]; then
      # we ignore the error, and use what we have as stdout
      ia_return=0
      /bin/echo "$ia_out" | sed -n "s/^s://p"
      return 1
    # switch to interactive mode
    elif [ "$ia_input" = "s" ] && ! [ "$ia_use_minctrl" ]; then
      /bin/echo
      /bin/echo "switching to interactive mode to point ($ia_answer) which failed"
      /bin/echo
      ia_answer=$((ia_answer-1))
      ia_use_interactive="-i"
      return 1
    fi
  fi
  return 0
}

# ia_check_and_results <cmd> <ignore> <stdout>
# ia_check_and_results -c|-C|--exitcode [-l] <cmd> <ignore> <stdout>
ia_check_and_result()
{
  local ia_out
  local ia_question

  local ia_cmd
  local ia_ign
  local ia_std

  local ia_use_check
  local ia_use_learn

  local ia_out_file
  local ia_stdout_file
  local ia_stderr_file

  local ia_early_exit # 1 if ia_cmd exited early, 0 else

  ia_use_check="$1"
  shift

  ia_use_learn=""
  if [ "$1" = "--learn" ]; then
    ia_use_learn="$1"
    shift
  fi

  ia_cmd="$1"
  ia_ign="$2"
  ia_std="$3"


  ia_activate_extrap

  while :
  do
    if [ "$ia_use_check" = "--exitcode" ]; then
      ia_mktemp ia_out_file
      ia_call_run
      ia_early_exit=$?
      if [ -n "BUG#929178" ]; then
        # Workaround to not crash, when running bash with this bug
        [ "$ia_return" -eq 0 ] && touch $ia_out_file || /bin/echo "exit=$ia_return" >>"$ia_out_file"
      else
        [ "$ia_return" -eq 0 ] || /bin/echo "exit=$ia_return" >>"$ia_out_file"
      fi
      ia_check_exitcode
      ia_result "$ia_cmd" || break
      ia_rmtemp "$ia_out_file"
    elif [ "$ia_use_check" = "-c" ]; then
      ia_mktemp ia_out_file
      ia_call_run "$ia_out_file"
      ia_early_exit=$?
      [ "$ia_return" -eq 0 ] || /bin/echo "exit=$ia_return" >>"$ia_out_file"
      ia_check_c
      ia_result "$ia_cmd" || break
      ia_rmtemp "$ia_out_file"
    else # ia_use_check = "-C"
      ia_mktemp ia_stdout_file
      ia_mktemp ia_stderr_file
      ia_call_run "$ia_stdout_file" "$ia_stderr_file"
      ia_early_exit=$?
      [ "$ia_return" -eq 0 ] || /bin/echo "exit=$ia_return" >>"$ia_stderr_file"
      ia_check_C
      ia_result "$ia_cmd" || break
      ia_rmtemp "$ia_stdout_file"
      ia_rmtemp "$ia_stderr_file"
    fi
  done
  return $ia_early_exit
}

ia_ignore()
{
  [ -n "${ia_ignore:=}" ] && ia_ignore="$ia_ignore|"
  ia_ignore="$ia_ignore$1"
  #ia_dev_dbg "ia_ignore: new=<$ia_ignore>"
}

ia_nocheck()
{
  if [ "${1:-}" = "-f" ]; then
    ia_ignore="-f"
    ia_stdout="-f"
  else
    ia_ignore="-1"
    ia_stdout="-1"
  fi
}

ia_is_nocheck()
{
  if [ "$ia_ignore" = "$ia_stdout" -a \( "$ia_ignore" = "-f" -o "$ia_ignore" = "-1" \) ]; then
    /bin/echo "$ia_ignore"
  fi
}

ia_stdout()
{
  #ia_dev_dbg "ia_stdout: old=<$ia_stdout>"
  [ -n "${ia_stdout:=}" ] && ia_stdout="$ia_stdout|"
  ia_stdout="$ia_stdout$1"
  #ia_dev_dbg "ia_stdout: new=<$ia_stdout>"
}

# ia_get_exit_trap <varname>
# do not call as subshell, to not loose trap
ia_get_exit_trap()
{
  local file
  file="$(mktemp)"
  {
    rm -f -- "$file"
    trap
    # get current EXIT trap, probably empty, one line or multiple lines
    eval "$1=\"$(gawk 'BEGIN{l=""}
      /trap.*EXIT$/{print;exit}
      /EXIT$/{if(l);print l;print;exit}
      /^trap/{l=$0;next}{if(l)l=sprintf("%s\n%s",l,$0)}' |
      ia_easy_backslash)\""
  } > "$file" < "$file"
}

ia_extrap()
{
  local cmd
  local out
  local i

  set +e

  if [ -n "${ia_premature_exit:=}" ]; then
    cmd="$(/bin/echo "$ia_premature_exit" | sed "\${/^#$/d;}")"
    ia_err_ignore_silent "ERROR: ia premature exit of <$cmd>"
    if [ -n "${ia_tmp_files:=}" ]; then
      out="$(cat $ia_tmp_files 2>/dev/null)"
      if [ -n "$out" ]; then
        ia_err_ignore_silent "unchecked output: <$out>"
      fi
    fi
  fi

  rm -f $ia_tmp_files
  ia_tmp_files=""

  # enable stdout and stderr for users's own EXIT trap
  if [ -n "${ia_direct_stderr_fd:-}" ]; then
    eval "exec 2>&${ia_direct_stderr_fd}"
    eval "exec 1>&${ia_direct_stderr_fd}"
  fi
}

ia_activate_extrap()
{
  local extrap
  ia_get_exit_trap extrap # fill variable extrap
  #ia_dev_dbg "ia_activate_extrap old extrap=<$extrap>"
  if [ "$extrap" = "" ]; then
    trap -- "ia_extrap;" EXIT # do not delete ;
  elif [ -z "$(/bin/echo "$extrap" | grep "'ia_extrap;")" ]; then
    extrap="$(/bin/echo "$extrap" | sed "s:':'ia_extrap;:")"
    eval "$extrap"
  else
    # next line only sets the existing trap unchanged again, but it is
    # needed by bash, while dash works without it. (testcase: test.ia_mktemp)
    eval "$extrap"
  fi
}

# ia_mktemp <varname> - returns tempfilename in variable <varname>
ia_mktemp()
{
  # global ia_mktemp_global_last
  local myp
  local ia_mktemp_local_file # make sure this name is not used as $1

  ia_shpid myp
  ia_mktemp_local_file=$(mktemp -t shellia.XXXXXXXXXX)
  if [ "${ia_mktemp_global_last:-}" = "$myp" ]; then
    # we are in the same subshell and share the same global exit variable ia_tmp_files
    if [ -n "${ia_tmp_files:-}" ]; then
      ia_tmp_files="$ia_tmp_files $ia_mktemp_local_file"
    else
     ia_tmp_files="$ia_mktemp_local_file"
    fi
  else
    # we just started a new subshell with a new global exit trap variable ia_tmp_files
    ia_tmp_files="$ia_mktemp_local_file"
  fi
  ia_mktemp_global_last=$myp

  eval "$1=$ia_mktemp_local_file"

  ia_activate_extrap
}

# ia_rmtemp <tempfilename>
ia_rmtemp()
{
  local extrap
  rm -f $1
  ia_tmp_files="$(/bin/echo "$ia_tmp_files" | sed "s: $1\>::")"
}

# ia_shpid <varname>
# this function provides something like the value of BASHPID in bash
# this function normally should not be executed in a subshell
ia_shpid()
{
  eval "$1=\"$(exec sh -c "/bin/echo \$PPID")\""
}