# lsb init-functions
#
# based on:
# /lib/lsb/init-functions for Debian -*- shell-script -*-
#
# Copyright (c) 2002-03 Chris Lawrence
# All rights reserved.
#
# Redistribution and use in source and binary forms, with or without
# modification, are permitted provided that the following conditions
# are met:
# 1. Redistributions of source code must retain the above copyright
#    notice, this list of conditions and the following disclaimer.
# 2. Redistributions in binary form must reproduce the above copyright
#    notice, this list of conditions and the following disclaimer in the
#    documentation and/or other materials provided with the distribution.
# 3. Neither the name of the author nor the names of other contributors
#    may be used to endorse or promote products derived from this software
#    without specific prior written permission.
#
# THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
# ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
# IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
# ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
# FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
# DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
# OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
# HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
# LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
# OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
# SUCH DAMAGE.

# log_*() functions {{{
TPUT="${TPUT:-"/usr/bin/tput"}"

_have_tput() {
    [ -x "$TPUT" ] && "$TPUT" hpa 60 >/dev/null 2>&1 \
        && return 0 \
        || return 1
}

log_success_msg() {
    printf " * $@\n"
}

log_failure_msg() {
    if _have_tput ; then
        RED="$("$TPUT" setaf 1)"
        #NORMAL="$("$TPUT" op)"
        printf " ${RED}*${NORMAL} $@\n"
    else
        printf " * $@\n"
    fi
}

log_warning_msg() {
    if _have_tput ; then
        YELLOW="$("$TPUT" setaf 3)"
        #NORMAL="$("$TPUT" op")"
        # printf " *${NORMAL} $@\n"
        printf " ${BLUE}*${NORMAL} $@\n"
    else
        printf " * $@\n"
    fi
}

log_warning_msg_nn() {
    if _have_tput ; then
        YELLOW="$("$TPUT" setaf 3)"
        printf " ${BLUE}*${NORMAL} $@"
    else
        printf " * $@"
    fi
}

# int log_begin_message (char *message)
log_begin_msg() {
        if [ "$#" -eq 0 ]; then
                return 1
        fi
        printf " ${GREEN}*${NORMAL} $@\n"
}

log_begin_msg_nn() {
        if [ "$#" -eq 0 ]; then
                return 1
        fi
        printf " ${GREEN}*${NORMAL} $@"
}


SUBMSG="   ${GREEN}-${NORMAL} "

# int log_end_message (int exitstatus)
log_end_msg() {

    # If no arguments were passed, return
    [ "$#" -eq 0 ] && return 1

    # Only do the fancy stuff if we have an appropriate terminal
    # and if /usr is already mounted
    if _have_tput ; then
        COLS="$("$TPUT" cols)"
        if [ -n "$COLS" ]; then
            COL=$(( $COLS - 7 ))
        else
            COL=73
        fi
        UP="$("$TPUT" cuu1)"
        END="$("$TPUT" hpa "$COL")"
        START="$("$TPUT" hpa 0)"
        #RED="$("$TPUT" setaf 1)"
        #NORMAL="$("$TPUT" op)"
        if [ "$1" -eq 0 ]; then
            printf "${UP}${END}${BLUE}[ ${GREEN}ok ${BLUE}]${NORMAL}\n"
        else
            printf "${UP}${START} ${RED}*${NORMAL}${END}[${RED}fail${NORMAL}]\n"
        fi
    else
        if [ "$1" -eq 0 ]; then
            printf "   ...done.\n"
        else
            printf "   ...fail!\n"
        fi
    fi
    return "$1"
}
# }}}

# e*() output functions {{{
# heavily based on gentoo's functions.sh; stripped down and modified
# to match our needs.
#
# defined functions:
#   ebegin()
#   eend()
#   eerror()
#   eindent()
#   einfo()
#   einfon()
#   eoutdent()
#   esetdent()
#   esyslog()
#   ewarn()
#   ewend()
#
# copyright 1999-2005 gentoo foundation
# distributed under the terms of the gnu general public license v2
# $header: /var/cvsroot/gentoo-src/rc-scripts/sbin/functions.sh,v 1.81.2.6 2005/05/15 20:00:31 vapier exp $

# initialisation {{{
# internal variables

# Don't output to stdout?
RC_QUIET_STDOUT="no"

# Default values for e-message indentation and dots
RC_INDENTATION=''
RC_DEFAULT_INDENT=2
#RC_DOT_PATTERN=' .'
RC_DOT_PATTERN=''
# don't output to stdout?
rc_quiet_stdout="no"

# default values for e-message indentation and dots
rc_indentation=''
rc_default_indent=2
#rc_dot_pattern=' .'
rc_dot_pattern=''

# should we use color?
if [ -r /proc/cmdline ] ; then
  grep -q ' nocolor' /proc/cmdline && RC_NOCOLOR='yes'
fi
[ -n "$NOCOLORS" ] && RC_NOCOLOR='yes'
RC_NOCOLOR="${RC_NOCOLOR:-no}"
if [ "$RC_NOCOLOR" = "no" ] ; then
  if [ -r /etc/grml_colors ] ; then
    . /etc/grml_colors
  fi
fi

# Can the terminal handle endcols?
if [ "${RC_NOCOLOR}" = "yes" ]; then
  RC_ENDCOL="no"
else
  RC_ENDCOL="yes"
fi

# Setup COLS and ENDCOL so eend can line up the [ ok ]
# width of [ ok ] == 7
COLS="$(stty size 2>/dev/null | cut -d' ' -f2)"
if [ -z "${COLS}" ] || [ "${COLS}" -le 0 ] ; then
  COLS=80
fi

if [ "${RC_ENDCOL}" = "yes" ]; then
  ENDCOL="[$(( ${COLS} - 8 ))G"
else
  ENDCOL=''
fi

# Setup the colors so our messages all look pretty
if [ "${RC_NOCOLOR}" = "yes" ]; then
  unset GOOD WARN BAD NORMAL HILITE BRACKET
else
  GOOD=''
  WARN=''
  BAD=''
  NORMAL=''
  HILITE=''
  BRACKET=''
fi
#}}}

# void esyslog(char* priority, char* tag, char* message)
#
#    use the system logger to log a message
#
esyslog() {
  local pri
  local tag

  [ "$#" -le 2 ] && return 0
  if [ -x /usr/bin/logger ] ; then
    pri="$1"
    tag="$2"
    shift 2

    /usr/bin/logger -p "${pri}" -t "${tag}" -- "$@"
  fi

  return 0
}

# void eindent(int num)
#
#    increase the indent used for e-commands.
#
eindent() {
  local i="${1:-0}"
  [ "$i" -gt 0 ] || i="${RC_DEFAULT_INDENT}"
  esetdent $(( ${#RC_INDENTATION} + $i ))
}

# void eoutdent(int num)
#
#    decrease the indent used for e-commands.
#
eoutdent() {
  local i="${1:-0}"
  [ "$i" -gt 0 ] || i="${RC_DEFAULT_INDENT}"
  esetdent $(( ${#RC_INDENTATION} - $i ))
}

# void esetdent(int num)
#
#    hard set the indent used for e-commands.
#    num defaults to 0
#
esetdent() {
  local i="${1:-0}"
  [ "$i" -lt 0 ] && i=0
  RC_INDENTATION="$(printf "%${i}s" '')"
}

# void einfo(char* message)
#
#    show an informative message (with a newline)
#
einfo() {
  einfon "$*\n"
  LAST_E_CMD=einfo
  return 0
}

# void einfon(char* message)
#
#    show an informative message (without a newline)
#
einfon() {
  [ "${RC_QUIET_STDOUT}" = "yes" ] && return 0
  [ "${RC_ENDCOL}" != "yes" ] && [ "${LAST_E_CMD}" = "ebegin" ] && echo
  printf " ${GOOD}*${NORMAL} ${RC_INDENTATION}$*"
  LAST_E_CMD=einfon
  return 0
}

# void ewarn(char* message)
#
#    show a warning message + log it
#
ewarn() {
  if [ "${RC_QUIET_STDOUT}" = "yes" ]; then
      printf " $*\n"
  else
    [ "${RC_ENDCOL}" != "yes" ] && [ "${LAST_E_CMD}" = "ebegin" ] && echo
    printf " ${WARN}*${NORMAL} ${RC_INDENTATION}$*\n"
  fi

  # Log warnings to system log
  esyslog "daemon.warning" "rc-scripts" "$@"

  LAST_E_CMD=ewarn
  return 0
}

# void eerror(char* message)
#
#    show an error message + log it
#
eerror() {
  if [ "${RC_QUIET_STDOUT}" = "yes" ]; then
    printf " $*\n" >&2
  else
    [ "${RC_ENDCOL}" != "yes" ] && [ "${LAST_E_CMD}" = "ebegin" ] && echo
    printf " ${BAD}*${NORMAL} ${RC_INDENTATION}$*\n"
  fi

  # Log errors to system log
  esyslog "daemon.err" "rc-scripts" "$@"

  LAST_E_CMD=eerror
  return 0
}

# void ebegin(char* message)
#
#    show a message indicating the start of a process
#
ebegin() {
  local msg="$@" dots spaces
  spaces="$(printf '%'"${#RC_DOT_PATTERN}"'s' '')"
  [ "${RC_QUIET_STDOUT}" = "yes" ] && return 0

  if [ -n "${RC_DOT_PATTERN}" ]; then
    dots="$(printf "%$(( $COLS - 3 - ${#RC_INDENTATION} - ${#msg} - 7 ))s" '')"
    while [ "${dots#${spaces}}" != "${dots}" ] ; do
        dots="${dots#${spaces}}${RC_DOT_PATTERN}"
    done
    msg="${msg}${dots}"
  else
    msg="${msg} ..."
  fi
  einfon "${msg}"
  [ "${RC_ENDCOL}" = "yes" ] && echo

  LAST_E_LEN=$(( 3 + ${#RC_INDENTATION} + ${#msg} ))
  LAST_E_CMD=ebegin
  return 0
}

# void _eend(int error, char *efunc, char* errstr)
#
#    indicate the completion of process, called from eend/ewend
#    if error, show errstr via efunc
#
#    This function is private to functions.sh.  Do not call it from a
#    script.
#
_eend() {
  local retval="${1:-0}" efunc="${2:-eerror}" msg
  shift 2

  if [ "${retval}" -eq 0 ]; then
    [ "${RC_QUIET_STDOUT}" = "yes" ] && return 0
    msg="${BRACKET}[ ${GOOD}ok${BRACKET} ]${NORMAL}"
  else
    if [ "$#" -gt 0 ] ; then
        "${efunc}" "$@"
    fi
    msg="${BRACKET}[ ${BAD}!!${BRACKET} ]${NORMAL}"
  fi

  if [ "${RC_ENDCOL}" = "yes" ]; then
    printf "${ENDCOL}  ${msg}\n"
  else
    [ "${LAST_E_CMD}" = "ebegin" ] || LAST_E_LEN=0
    printf "%$(( ${COLS} - ${LAST_E_LEN} - 6 ))s%b\n" '' "${msg}"
  fi

  return "${retval}"
}

# void eend(int error, char* errstr)
#
#    indicate the completion of process
#    if error, show errstr via eerror
#
eend() {
  local retval="${1:-0}"
  shift

  _eend "${retval}" eerror "$@"

  LAST_E_CMD=eend
  return "$retval"
}

# void ewend(int error, char* errstr)
#
#    indicate the completion of process
#    if error, show errstr via ewarn
#
ewend() {
  local retval="${1:-0}"
  shift

  _eend "${retval}" ewarn "$@"

  LAST_E_CMD=ewend
  return "$retval"
}
#}}}

# if we're using systemd then redefine functions
# for output in systemd style
if [ "$(cat /proc/1/comm 2>/dev/null)" = "systemd" ] ; then
  einfo() {
    printf "[  ${GREEN}OK${NORMAL}  ] %s\n" "$*"
  }

  ewarn() {
    printf "[ ${YELLOW}WARN${NORMAL} ] %s\n" "$*"
  }

  eerror() {
    printf "[ ${RED}FAIL${NORMAL} ] %s\n" "$*"
  }

  eend() {
    :
  }
fi

# vim: ft=sh tw=80 ts=4 foldmethod=marker