#!/bin/sh
# tmww lib: player.lib.sh

# this file is part of tmww - the mana world watcher
# willee, 2012-2014
# GPL v3

# check if not run from tmww
if [ "$TMWW_PLUGINS" != "yes" ] ; then
   echo >&2 "This script is tmww lib and not intended for manual run."
   exit 1
fi

#
# common
#
#

# chars allowed in player alias name (as shell pattern inside [])
playerchars="a-zA-Z0-9_\-"

[ "${TMWW_LIMITED}" = "yes" ] && playerdb="${limiteddb}"

JQ=$(command -v jq 2>&-)

# eval TMWW_ALTSPATH="${TMWW_ALTSPATH:-${DIRCONFIG}/alts}"
TMWW_ALTSPATH="${TMWW_ALTSPATH:-${DIRCONFIG}/alts}"
TMWW_ALTSPATH=${TMWW_ALTSPATH}/${servername}
TMWW_UPDATELIMITED="${TMWW_UPDATELIMITED:-no}"
TMWW_LIMITED="${TMWW_LIMITED:-no}"
playerdb="${TMWW_ALTSPATH}/dbplayers.jsonl"
limiteddb="${TMWW_ALTSPATH}/limited.jsonl"
# separate temp files in case of lockfile timeout
# using PRIVTMP here to avoid endless chmod to ensure multiuser support
playerdbtmp=${TMWW_PRIVTMP}/playerdb.temp
playerdbtmp2=${TMWW_PRIVTMP}/playerdb.temp2

check_jq() {
   if [ -z "${JQ}" ]; then
       error "jq not found. Aborting."
       return 1
   fi
}

check_player() {
   check_string_chars "$1" "*[!${playerchars}]*" "Disallowed characters at player name" || return 1
   if ! grep -m 1 "\"player\":\"$1\"" "${playerdb}" >/dev/null 2>&1 ; then
       error "No such player: $1"; return 1
   fi
}

check_id() {
   check_string_chars "$1" "*[!0-9]*" "Disallowed characters in ID" || return 1
}

TMWW_DBLOCK="${TMWW_LOCK}/tmww-db-${servername}"
set_db_lock() {
   check_lock "altdb" "${TMWW_DBLOCK}" 35
}

unset_db_lock() {
   rmdir ${TMWW_DBLOCK} 2>/dev/null
}

# format: single line, space separated
player_fields_string="name wiki trello server port tmwc active cc"
player_fields_array="aka roles alts accounts links xmpp mail skype repo forum"
player_fields_roles="content sound music gm code map pixel admin host wiki advisor translator packager web concept dude"

#
# player show/get
#
#

aux_player_show_chars_by_char() {
   result=$(aux_player_get_by_char "$1")
   [ -z "$result" ] || aux_player_show_chars_by_player "${result}"
}

aux_player_show_ids_by_char() {
   result=$(aux_player_get_by_char "$1")
   [ -z "$result" ] || aux_player_show_ids_by_player "${result}"
}

aux_player_show_parties_by_char() {
   result=$(aux_player_get_by_char "$1")
   [ -z "$result" ] || aux_player_show_parties_by_player "${result}"
}

aux_player_show_chars_by_id() {
   result=$(aux_player_get_by_id "$1")
   [ -z "$result" ] || aux_player_show_chars_by_player "${result}"
}

aux_player_show_ids_by_id() {
   result=$(aux_player_get_by_id "$1")
   [ -z "$result" ] || aux_player_show_ids_by_player "${result}"
}

aux_player_show_parties_by_id() {
   local party
   result=$(aux_player_get_by_id "$1")
   [ -z "$result" ] || aux_player_show_parties_by_player "${result}"
}

aux_player_show_chars_by_player() {
   aux_player_query_chardb "$1" | sed 's/.\{8\}//'
   aux_player_query_alts "$1"
}

aux_player_show_ids_by_player() {
   aux_player_query_chardb "$1"
   aux_player_query_alts "$1"
}

aux_player_show_parties_by_player() {
   local party
   aux_player_query_chardb "$1" | while read -r line; do
       party=$( func_party_get "${line#????????}" )
       if [ -z "${party}" ]; then
           printf "%s\n" "${line}"
       else
           printf "%-32s -- %s\n" "${line}" "${party}"
       fi
   done
   # player not recorded in dbchars most probably has no party known
   aux_player_query_alts "$1"
}

aux_player_query_chardb() {
   aux_player_ids "$1" | while read line; do
       aux_char_show_ids_by_id "${line}"
   done
}

aux_player_query_alts() {
   ${JQ} -r "if (.[\"player\"]==\"$1\") then \
       (if (.alts|length)>0 then .alts[] else empty end) \
       else empty end" "${playerdb}" 2>&-
}

func_player_show() {
   local output_format critetion
   output_format="chars"; critetion=""
   [ -z "$2" -a ! -z "$1" ] && {
       check_player "$1" || return 1
       aux_player_show_ids_by_player "$1"
       return
   }
   if [ "$1" != "by" ]; then
       case "$1" in
           chars|ids|parties) : ;;
           *) error_incorrect; return 1 ;;
       esac
       output_format="$1"
       shift
   fi
   [ "$1" != "by" ] && { error_incorrect; return 1; }
   shift
   [ -z "$1" ] && { error_missing; return 1; }
   check_jq || return 2
   criterion="$1"; shift
   [ -n "$2" ] && { error_toomuch; return 1; }
   [ -z "$1" ] && { error_missing; return 1; }
   case "${criterion}" in
       player) check_player "$1" || return 1 ;;
       id)     check_id "$1" || return 1 ;;
       char)   : ;;
       *)      error_incorrect; return 1 ;;
   esac
   eval aux_player_show_${output_format}_by_${criterion} \"\$@\"
   return $?
}

# if char in chardb, get accid and lookup playerdb with accid
# otherwise try unresolved "alts" fields
aux_player_get_by_char() {
   result=$(func_char_get "$1")
   if [ -z "$result" ]; then
       # triple escaping: awk param, regex pattern, json value
       # like sed-chars but without "/" (skipping gawk warning)
       chname=$( printf "%s" "$1" |
           sed ${ESED} 's/\\/\\\\\\\\\\\\\\\\/g;s/([.*"+!@#$%^?[{|()])/\\\1/g'; )
       ${AWK} ${AWKPARAMS} -v chname="${chname}" -- '
       $0 ~ "\"alts\":\\[[^]]*\"" chname "\"" {
           sub("^.*\"player\":\"",""); sub("\".*$","")
           print; exit
           }
       ' ${playerdb}
   else
       aux_player_get_by_id "$result"
   fi
}

# only 1st match
aux_player_get_by_id() {
   check_string_chars "$1" "*[!0-9]*" "Invalid account ID" || return 1
   ${AWK} ${AWKPARAMS} -v accid="$1" -- '
   $0 ~ "\"accounts\":\\[[^]]*\"" accid "\"" {
       sub("^.*\"player\":\"",""); sub("\".*$","")
       print; exit
       }
   ' ${playerdb}
}

func_player_get() {
   local criterion
   [ -z "$2" -a ! -z "$1" ] && {
       aux_player_get_by_char "$1"
       return
   }
   [ "$1" != "by" ] && { error_incorrect; return 1; }
   shift
   [ -z "$2" ] && { error_missing; return 1; }
   criterion="$1"; shift
   [ -n "$2" ] && { error_toomuch; return 1; }
   case "${criterion}" in
       char)   : ;;
       id)     check_id "$1" || return 1 ;;
       *)      error_incorrect; return 1 ;;
   esac
   eval aux_player_get_by_${criterion} \"\$1\"
   return $?
}

#
# player misc
#
#

# with FIELD as/in VALUE and/or FIELD as/in VALUE
# and so on
aux_player_list() {
   local pattern
   pattern=''
   [ "$1" = "with" ] || { error_incorrect; return 1; }
   shift
   check_jq || return 2
   # show with field
   [ -z "$2" -a ! -z "$1" ] && {
       ${JQ} -r --arg field "$1" "if has(\$field) then .player \
           else empty end" "${playerdb}" 2>&1
       return
   }
   # combine pattern
   while true; do
       if [ ! -z "$3" ]; then
           if [ "$2" = "as" ]; then
               escapedvalue=$( sed_chars "$3" )
               pattern="${pattern} contains({\"$1\":\"${escapedvalue}\"})"
               shift 3
           elif [ "$2" = "in" ]; then
               escapedvalue=$( sed_chars "$1" )
               pattern="${pattern} contains({\"$3\":[\"${escapedvalue}\"]})"
               shift 3
           elif [ "$2" = "not" -a "$3" = "as" -a ! -z "$4" ]; then
               escapedvalue=$( sed_chars "$4" )
               pattern="${pattern} (contains({\"$1\":\"${escapedvalue}\"})|not)"
               shift 4
           elif [ "$2" = "not" -a "$3" = "in" -a ! -z "$4" ]; then
               escapedvalue=$( sed_chars "$1" )
               pattern="${pattern} (contains({\"$4\":[\"${escapedvalue}\"]})|not)"
               shift 4
           else error_incorrect; return 1; fi
       else error_incorrect; return 1; fi
       if [ -z "$1" ]; then
           break
       elif [ "$1" = "and" -o "$1" = "or" ]; then
           pattern="${pattern} $1"
           shift
       else error_incorrect; return 1; fi
   done
   ${JQ} -r "if ${pattern} then .player \
       else empty end" "${playerdb}" 2>&-
}

# comma separated list
func_player_list() {
   result=$(aux_player_list "$@" | make_csv )
   [ -z "$result" ] || printf "%s\n" "$result"
}

# player per line
func_player_nlist() {
   aux_player_list "$@"
}

# args:
# 1 -- player
# 2.. -- fields to query
func_player_field() {
   local name
   [ -z "$1" -o -z "$2" ] && { error_missing; return 1; }
   name=$1; shift
   pat=$(
       for i in "$@"; do
       check_string_chars "$i" "*[!a-z]*" "Disallowed characters at field name" || return 1
       printf "\"%s\"\n" "$i"; done | make_csv) || return 1
   check_jq || return 2
   ${JQ} -c -M --arg name "${name}" "if (.[\"player\"]==\$name) then \
       {$pat} else empty end|with_entries(if (.value|length)>0 then \
       . else empty end) // empty" "${playerdb}" 2>&-
}

# args:
# 1 -- player
func_player_keys() {
   [ -n "$2" ] && { error_toomuch; return 1; }
   [ -z "$1" ] && { error_missing; return 1; }
   check_jq || return 2
   ${JQ} -c -M --arg player "$1" "if (.[\"player\"]==\$player) then keys \
       else empty end" "${playerdb}" 2>&-
}

aux_player_ids() {
   ${JQ} -r --arg player "$1" 'if (.["player"]==$player) then
       .accounts // empty | .[] else empty end' "${playerdb}" 2>&-
}

# args:
# 1 -- player
func_player_ids() {
   [ -n "$2" ] && { error_toomuch; return 1; }
   [ -z "$1" ] && { error_missing; return 1; }
   check_jq || return 2
   aux_player_ids "$1"
}

# args:
# 1 -- player
func_player_dump() {
   [ -n "$2" ] && { error_toomuch; return 1; }
   [ -z "$1" ] && { error_missing; return 1; }
   grep -m 1 "\"player\":\"$1\"" "${playerdb}"
}

# args:
# 1 -- number
func_player_record() {
   [ -n "$2" ] && { error_toomuch; return 1; }
   [ -z "$1" ] && { error_missing; return 1; }
   check_string_chars "$1" "*[!0-9]*" "Disallowed characters at player name" || return 1
   [ "$1" -eq 0 ] && return 1
   sed -n "$1{p;q}" "${playerdb}"
}

# args:
# 1 -- substring
func_player_search() {
   [ -n "$2" ] && { error_toomuch; return 1; }
   [ -z "$1" ] && { error_missing; return 1; }
   result=$(grep -i "$1" "${playerdb}" 2>&1 | \
       sed ${ESED} -n 's/.*"player":"([^"]+)".*/\1/p' | make_csv )
       [ -z "$result" ] || printf "%s\n" "$result"
}

func_player_create() {
   [ -n "$2" ] && { error_toomuch; return 1; }
   [ -z "$1" ] && { error_missing; return 1; }
   if grep -m 1 "\"player\":\"$1\"" "${playerdb}" >/dev/null 2>&1 ; then
       error "Player $1 exists."
   else
       check_string_chars "$1" "*[!${playerchars}]*" "Disallowed characters in player name" || return 1
       set_db_lock
       cp -f "${playerdb}" "${playerdbtmp}" >/dev/null 2>&1
       printf "{\"player\":\"%s\"}\n" "$1" >> "${playerdbtmp}"
       store_shared "${playerdbtmp}" "${playerdb}"
       unset_db_lock
       func_player_lregen
   fi
}

aux_player_sanitize() {
   # resolve alts
   ${JQ} -r "if (.[\"player\"]==\"$1\") then \
       (if (.alts|length)>0 then .alts[] else empty end) \
       else empty end" ${playerdbtmp} 2>&- | \
       while read -r charname; do
       # skip empty field. sanitize operation cleans them
       [ -z "$charname" ] && continue
       # chname=$(printf "%s" "$charname" | sed ${ESED} 's/\\/\\\\/g;s/([.*+!@#$%^/?[{|()])/\\\1/g')
       result=$(func_char_get "$charname")
       # error isn't expected
       if [ ! -z "$result" ]; then
           ${JQ} -c -M --arg alt "$charname" --arg accid "$result" \
               "if ((has(\"alts\") and (.alts|map(.==\$alt)|contains([true])))) \
               then ((.accounts|=.+[\$accid])|(.alts|=.-[\$alt])) else . end" \
               "${playerdbtmp}" > "${playerdbtmp2}" 2>&-
               # "if contains({\"alts\":[\$alt]}) then \
           # this sucks
           mv "${playerdbtmp2}" "${playerdbtmp}"
       fi
       done
   # remove duplicates, leave unique array elements; sort entries
   ${JQ} -S -c -M --arg player "$1" "if (.[\"player\"]==\$player) then \
       (with_entries(if (.value|length)>0 then (if (.value|type)==\"array\" \
       then .value|=(.|unique) else . end) else empty end)) else . end" \
       "${playerdbtmp}" > "${playerdbtmp2}" 2>&-
   store_shared "${playerdbtmp2}" "${playerdbtmp}"
}

# resolve all alts in player record
# args: PLAYER
func_player_resolve() {
   [ -n "$2" ] && { error_toomuch; return 1; }
   [ -z "$1" ] && { error_missing; return 1; }
   check_string_chars "$1" "*[!${playerchars}]*" "Disallowed characters in player name" || return 1
   [ ! -s "${playerdb}" ] && return 3
   check_jq || return 2
   set_db_lock
   cp -f "${playerdb}" "${playerdbtmp}" >/dev/null 2>&1
   aux_player_sanitize "$@"
   store_shared "${playerdbtmp}" "${playerdb}"
   unset_db_lock
   func_player_lregen
}

# sanitize:
#   resolve all alts
# does not check default field types - string/array; use validation util
func_player_sanitize() {
   [ -z "$1" ] || { error_toomuch; return 1; }
   [ ! -s "${playerdb}" ] && return 3
   check_jq || return 2
   set_db_lock
   cp -f "${playerdb}" "${playerdbtmp}" >/dev/null 2>&1
   echo "Checking duplicate records..."
   # check repeated records
   sed ${ESED} -n 's/.*"player":"([^"]+)".*/\1/p' ${playerdb} | sort | \
       uniq -d | while read duplicate; do
       echo "Duplicated record: $duplicate"
   done
   echo "Clearing duplicate field elements and empty fields..."
   # make sure work only with valid records with "player" field
   sed ${ESED} -n 's/.*"player":"([^"]+)".*/\1/p' ${playerdbtmp} | \
       while read playername; do \
           aux_player_sanitize "$playername"
       done
   store_shared "${playerdbtmp}" "${playerdb}"
   unset_db_lock
   echo "Checking duplicate alts/accounts..."
   # report duplicates
   ( ${JQ} -c -M "if (.alts|length)>0 then \
       \"player \\(.player), alt \\(.alts[])\" else empty end" \
       "${playerdb}" 2>&-
       ${JQ} -c -M "if (.accounts|length)>0 then \
       \"player \\(.player), account \\(.accounts[])\" else empty end" \
       "${playerdb}" 2>&-
   ) | sort -t ',' -k 2 | ${AWK} ${AWKPARAMS} -- '
       BEGIN { FS=","; prev = ""; prevfield=""; dup = 0 }
       /^$/ { next }
       {
           if ( $2 == prevfield ) {
               print prev; dup++
           } else {
               if ( dup != 0) print prev
               dup = 0
           }
           prev = $0; prevfield = $2
       }
       END { if ( dup != 0) print prev }
   '
   [ -x ${TMWW_UTILPATH}/validjsonl.py ] && {
       echo "Validating known playerdb fields..."
       ${TMWW_UTILPATH}/validjsonl.py ${playerdb}
       [ $? -ne 0 ] && echo "Validation failed!"
   }
   echo "Sanitation finished."
   func_player_lregen
}

func_player_ref() {
   [ -z "$1" ] || { error_toomuch; return 1; }
   printf "string: %s\n" "${player_fields_string}"
   printf "array:  %s\n" "${player_fields_array}"
   printf "roles:  %s\n" "${player_fields_roles}"
}

# single backslash sequence will be added as is
# duplicate backslashes if you want to insert two or more backslashes in row
# duplicates in field elements will be skipped
# adding alt will attempt to resolve it
# adding account will not check for duplicates in other records
# PLAYER FIELD value VALUE
# PLAYER FIELD element VALUE
func_player_add() {
   [ -z "$5" -a ! -z "$4" ] || { error_incorrect; return 1; }
   # exit if field was player. use create/rename/remove to change player
   [ "$2" = "player" ] && return 1
   # enforce types for standart fields
   if printf "%s\n" "${player_fields_string}" | grep -wq -- "$2" ; then
       [ "$3" != "value" ] && { error_params "Field must be of string type"; return 1; }
   elif printf "%s\n" "${player_fields_array}" | grep -wq -- "$2" ; then
       [ "$3" != "element" ] && { error_params "Field must be array"; return 1; }
   fi
   # check lowercase field name
   check_string_chars "$2" "*[!a-z]*" "Field name must be lowercase" || return 1
   check_jq || return 2
   set_db_lock
   cp -f "${playerdb}" "${playerdbtmp}" >/dev/null 2>&1
   # result is undefined with non-default field of incompatible type
   if [ "$3" = "value" ]; then
       ${JQ} -S -c -M --arg name "$1" --arg element "$4" \
           "if (.[\"player\"]==\$name) \
           then .[\"$2\"] = \$element else . end" \
           "${playerdbtmp}" > "${playerdbtmp2}" 2>&-
   elif [ "$3" = "element" ]; then
       # check for duplicates in array
       if [ "$2" = "alts" ]; then
           result=$(func_char_get "$4")
           if [ -z "$result" ]; then
               field="$2"; element="$4"
           else
               field="accounts"; element="$result"
           fi
       else
           field="$2"; element="$4"
       fi
       # silly comparison bcause jq can't strict "contains"
       ${JQ} -S -c -M --arg name "$1" --arg element "$element" \
           "if ((.[\"player\"]==\$name) and \
           ((has(\"${field}\") and (.[\"${field}\"]|map(.==\$element)|contains([true])))|not)) \
           then .[\"${field}\"] += [\$element] else . end" \
           "${playerdbtmp}" > "${playerdbtmp2}" 2>&-
   else error_incorrect; unset_db_lock; return 1; fi
   if [ "$?" -eq 0 ]; then
       store_shared "${playerdbtmp2}" "${playerdb}"
   else
       error "Error occured. Contact db owner to check consistency."
   fi
   unset_db_lock
   func_player_lregen
}

aux_player_del_field() {
   check_jq || return 2
   set_db_lock
   cp -f "${playerdb}" "${playerdbtmp}" >/dev/null 2>&1
   ${JQ} -S -c -M --arg name "$1" --arg field "$2" \
       "if (.[\"player\"]==\$name) then \
       (with_entries(select(.key!=\$field))) else . end" \
       "${playerdbtmp}" > "${playerdbtmp2}" 2>&-
   if [ "$?" -eq 0 ]; then
       store_shared "${playerdbtmp2}" "${playerdb}"
   else
       error "Error occured. Contact db owner to check consistency."
   fi
   unset_db_lock
}

aux_player_del_element() {
   check_jq || return 2
   set_db_lock
   cp -f "${playerdb}" "${playerdbtmp}" >/dev/null 2>&1
   # remove element and field if no elements inside
   ${JQ} -S -c -M --arg name "$1" --arg element "$4" \
       "if ((.[\"player\"]==\$name) and \
       (has(\"$2\") and (.[\"$2\"]|map(.==\$element)|contains([true])))) \
       then .[\"$2\"] -= [\$element] else . end | \
       with_entries(if (.value|length)>0 then . else empty end)" \
       "${playerdbtmp}" > "${playerdbtmp2}" 2>&-
   if [ "$?" -eq 0 ]; then
       store_shared "${playerdbtmp2}" "${playerdb}"
   else
       error "Error occured. Contact db owner to check consistency."
   fi
   unset_db_lock
}

func_player_del() {
   # check lowercase field name
   check_string_chars "$2" "*[!a-z]*" "Field name must be lowercase." || return 1
   if [ -z "$3" -a -n "$2" ]; then
       aux_player_del_field "$@"
   elif [ -z "$5" -a -n "$4" -a "$3" = "element" ]; then
       aux_player_del_element "$@"
   else error_incorrect; fi
   func_player_lregen
}

func_player_remove() {
   [ -n "$2" ] && { error_toomuch; return 1; }
   [ -z "$1" ] && { error_missing; return 1; }
   set_db_lock
   cp -f "${playerdb}" "${playerdbtmp}" >/dev/null 2>&1
   grep -v "\"player\":\"$1\"" "${playerdbtmp}" > "${playerdbtmp2}"
   store_shared "${playerdbtmp2}" "${playerdb}"
   unset_db_lock
   func_player_lregen
}

func_player_append() {
   [ -n "$2" ] && { error_toomuch; return 1; }
   [ -z "$1" ] && { error_missing; return 1; }
   set_db_lock
   cp -f "${playerdb}" "${playerdbtmp}" >/dev/null 2>&1
   printf "%s\n" "$1" >> "${playerdbtmp}"
   store_shared "${playerdbtmp}" "${playerdb}"
   unset_db_lock
   func_player_lregen
}

# PLAYER to NEWNAME
func_player_rename() {
   [ -n "$4" ] && { error_toomuch; return 1; }
   [ -z "$3" ] && { error_missing; return 1; }
   [ "$2" != "to" ] && { error_incorrect; return 1; }
   check_string_chars "$3" "*[!${playerchars}]*" "Disallowed characters in player name" || return 1
   check_jq || return 2
   set_db_lock
   cp -f "${playerdb}" "${playerdbtmp}" >/dev/null 2>&1
   ${JQ} -S -c -M --arg name "$1" --arg newname "$3" \
       "if (.[\"player\"]==\$name) \
       then .player = \$newname else . end" \
       "${playerdbtmp}" > "${playerdbtmp2}" 2>&-
   if [ "$?" -eq 0 ]; then
       store_shared "${playerdbtmp2}" "${playerdb}"
   else
       error "Error occured. Contact db owner to check consistency."
   fi
   unset_db_lock
   func_player_lregen
}

# regenerate shortened playerdb version if limiteddb is in use
func_player_lregen() {
   # quite return if no there's no limited db
   [ "$TMWW_UPDATELIMITED" = "yes" ] || return 0
   # ensure previous command finished successfully
   [ "$err_flag" -ne 1 ] || return 1
   [ -z "$1" ] || { error_toomuch; return 1; }
   [ -f "${playerdb}" ] || return 3
   [ -f "${TMWW_UTILPATH}/lregen.players" ] || {
       error "Protected playerlist is missed!"
       return 3
   }
   set_db_lock
   ${AWK} ${AWKPARAMS} -- '
       FNR == NR && $1 !~ /^#/ { a[ $1 ]++ }
       {
           match($0,/"player":"([^"]+)"/);
           split(substr($0,RSTART,RLENGTH),b,/"/);
           # print "_" b[4] "_" a[b[4]] "_" ; next
           if ( ! ( b[4] in a ) ) print
       }
       ' "${TMWW_UTILPATH}/lregen.players" "${playerdb}" > "${limiteddb}"
   unset_db_lock
}

#
# arseoscope
#
#

func_arseoscope() {
   [ -n "$2" ] && { error_toomuch; return 1; }
   [ -z "$1" ] && { error_missing; return 1; }
   result=$( func_char_get "$1" )
   [ -z "${result}" ] || {
       plresult=$( aux_player_get_by_id "${result}" )
       [ -z "${plresult}" ] || {
           accounts=$( aux_player_ids "${plresult}" | \
               ${AWK} ${AWKPARAMS} 'BEGIN{s=0}{s+=1}END{print s}')
           printf "playerdb alias: %s; %s known accounts; " "${plresult}" "${accounts}"
       }
       printf "%s: " "${result}"
       aux_char_show_chars_by_id "${result}" | make_csv
       echo
   }
}

#
# shared
#
#

# this pattern generator skips spaces for char/party fuzzy search functions
aux_fuzzy_pattern() {
   # constructing horrible case-insensitive pattern
   # with missed, suppressed and few l33t chars
   # this provides 1 possible error
   # for more possible errors just use agrep; seems ok with 1
   printf "%s" "$*" | sed "s/\(.\)/\1 /g" | ${AWK} ${AWKPARAMS} -- '
       BEGIN { chars = "" }
       {
           for ( i=1; i<=NF; i++ ) {
               s=""
               if ( $i ~ "l" ) s = "I"
               if ( $i ~ "I" ) s = "l"
               if ( $i ~ "O" ) s = "0"
               if ( $i ~ "0" ) s = "O"
               # if ( $i ~ "5" ) s = "sS"
               # if ( $i ~ "s|S" ) s = "5"
               chars = sprintf("%s%s", chars, "[" tolower($i) toupper($i) s "] ")
           }
           n = split(chars, fuzzy)
           # printf("(")
           # letter not found
           for ( i=1; i<=n; i++ ) {
               # printf("%s", fuzzy[1])
               for ( j=1; j<=n; j++ ) {
                   if ( j == i )
                       printf("%s?", fuzzy[j])
                   else
                       printf("%s", fuzzy[j])
               }
               printf("|")
           }
           # letter is different
           for ( i=1; i<=n; i++ ) {
               # printf("%s", fuzzy[1])
               for ( j=1; j<=n; j++ ) {
                   if ( j == i )
                       printf(".?")
                   else
                       printf("%s", fuzzy[j])
               }
               printf("|")
           }
           # missing letter between
           for ( i=1; i<n; i++ ) {
               for ( j=1; j<=n; j++ ) {
                   if ( j == i )
                       printf("%s.?", fuzzy[j])
                   else
                       printf("%s", fuzzy[j])
               }
               if ( i != n - 1) printf("|")
           }
           # printf(")")
       }
   '
}

You are viewing proxied material from sdf.org. The copyright of proxied material belongs to its original authors. Any comments or complaints in relation to proxied material should be directed to the original authors of the content concerned. Please see the disclaimer for more details.