#!/usr/bin/env bash
#
# gKeyMapper - everything that touches po/*.po, po/gkeymapper.pot and the compiled
# catalogs, in one place, so a translation change is a command instead of a list of
# steps to remember. The rules behind it are written down in po/README.md.
#
# Usage: scripts/i18n.sh <command> [arguments]
#   extract              regenerate po/gkeymapper.pot from the sources
#   update [lang...]     merge the pot into the catalogs: new strings come in
#                        untranslated, existing translations are kept
#   check                validate the pot, the catalogs and the language list
#   status               per-language overview (counts + compiled catalog)
#   todo <lang>          what is still untranslated or fuzzy, with the source
#                        locations from the pot
#   new <lang> [name]    create po/<lang>.po from the pot (name = Language-Team,
#                        e.g. "Italiano"); "new en" writes the identity catalog
#   help                 this text
#
# Only gettext tools and coreutils are used. The tools can be overridden from the
# environment, like the Makefile's variables: XGETTEXT=... scripts/i18n.sh extract

set -euo pipefail

ROOT=$(cd -- "$(dirname -- "${BASH_SOURCE[0]}")/.." && pwd)
# Everything is addressed relative to the repository root and run from there: the
# source locations xgettext writes into the pot ("src/main.cpp:582") and the file
# names the gettext tools print are relative to the current directory, and absolute
# paths would end up in the pot and in every message this script shows.
cd -- "$ROOT" || exit 1
PO_DIR="po"
POT="$PO_DIR/gkeymapper.pot"
LOCALE_DIR="locale"
PACKAGE="gkeymapper"
# What the catalogs carry in Project-Id-Version (see po/*.po).
PO_VERSION="0.1"

XGETTEXT=${XGETTEXT:-xgettext}
MSGFMT=${MSGFMT:-msgfmt}
MSGMERGE=${MSGMERGE:-msgmerge}
MSGATTRIB=${MSGATTRIB:-msgattrib}
MSGCAT=${MSGCAT:-msgcat}

# The counts and message lists below are parsed, so the tools have to answer in
# English, whatever the session's language is.
export LC_ALL=C

# A temp file for a pot, removed on every exit - also on the error paths, where it
# is the half-written file that must not stay behind.
POT_TMP=""
trap 'rm -f "${POT_TMP:-}"' EXIT

# ---------------------------------------------------------------------------
# helpers
# ---------------------------------------------------------------------------

die() {
    printf 'i18n: %s\n' "$*" >&2
    exit 1
}

note() {
    printf '%s\n' "$*"
}

require_tools() {
    local tool
    for tool in "$@"; do
        command -v "$tool" >/dev/null 2>&1 ||
            die "$tool not found - install gettext (see README, Requirements)"
    done
}

# Every source that may hold translatable strings: the GUI, which is the only
# program with gettext set up (src/main.cpp) - the same two directories the Makefile
# compiles into it. The daemon is English on purpose (see `check`), so its sources
# are not scanned. The pot is generated from this list, in this order, so `extract`
# is reproducible: a hand-ordered file list once made the pot's message order depend
# on the machine it ran on.
sources() {
    local file
    for file in "$ROOT"/src/*.cpp "$ROOT"/shared/*.cpp; do
        if [ -e "$file" ]; then printf '%s\n' "${file#"$ROOT"/}"; fi
    done
}

# The languages that have a catalog, i.e. po/*.po - the same list the Makefile
# compiles and installs.
languages() {
    local file
    for file in "$PO_DIR"/*.po; do
        if [ -e "$file" ]; then basename "$file" .po; fi
    done | sort
}

# The messages of a po/pot, one per line and multi-line strings joined: msgcat does
# the joining, so `_("a" "b")` in the sources and the pot entry are the same string.
# The header (empty msgid) is left out.
msgids() {
    "$MSGCAT" --stringtable-output "$1" 2>/dev/null |
        sed -n 's/^"\(.*\)" = .*$/\1/p' | sed '/^$/d'
}

# translated/fuzzy/untranslated of one catalog, into three globals. msgfmt prints
# them as a comma separated list ("81 translated messages, 1 untranslated
# message.") and leaves the parts out that are zero, so the list is split first -
# a pattern like ".*\([0-9]\+\) untranslated" would stop at the last digit of a
# count and read 82 as 2.
stats() {
    local out parts
    out=$("$MSGFMT" --statistics -o /dev/null "$1" 2>&1) || die "$MSGFMT rejected $1"
    parts=$(printf '%s\n' "$out" | tr ',' '\n')
    translated=$(printf '%s\n' "$parts" | sed -n 's/^ *\([0-9]\+\) translated.*/\1/p'); : "${translated:=0}"
    fuzzy=$(printf '%s\n' "$parts" | sed -n 's/^ *\([0-9]\+\) fuzzy.*/\1/p'); : "${fuzzy:=0}"
    untranslated=$(printf '%s\n' "$parts" | sed -n 's/^ *\([0-9]\+\) untranslated.*/\1/p'); : "${untranslated:=0}"
}

# The `Language:` header of a catalog, so a copy-pasted file is noticed.
po_language() {
    sed -n 's/^"Language: \(.*\)\\n"$/\1/p' "$1"
}

# The POT-Creation-Date of a po/pot. It does not decide whether a file is up to
# date (the message set does); it tells whether a merge happened after the last
# extract.
pot_date() {
    sed -n 's/^"POT-Creation-Date: \(.*\)\\n"$/\1/p' "$1"
}

# One line per entry whose msgstr is not the msgid again - the rule for po/en.po,
# which is an identity catalog because English is the source language. Compared as
# raw (still escaped) text: both sides come from the same file, so the escaping
# matches. Plurals need more than this and are not used anywhere (no ngettext).
identity_mismatches() {
    awk '
        function quoted(line) { sub(/^[^"]*"/, "", line); sub(/"$/, "", line); return line }
        function check() { if (id != "" && str != id) { print id; mismatches++ } }
        /^msgid_plural|^msgstr\[/ { print "plural entries are not supported"; exit 2 }
        /^msgid /   { check(); id = quoted($0); str = ""; in_id = 1; next }
        /^msgstr /  { str = quoted($0); in_id = 0; next }
        /^"/        { if (in_id) id = id quoted($0); else str = str quoted($0); next }
        /^#/        { next }
        /^[[:space:]]*$/ { next }
        END { check(); exit (mismatches > 0 ? 1 : 0) }
    ' "$1"
}

# The pot as xgettext writes it right now, into the given file. `_()` marks
# strings that are translated when they are used, `N_()` the ones that are only
# collected (the help text is assembled later on); both are named explicitly,
# because a gettext that does not know `_` by itself is not unheard of.
extract_to() {
    local out="$1" file
    require_tools "$XGETTEXT"
    local -a files=()
    while IFS= read -r file; do files+=("$file"); done < <(sources)
    [ "${#files[@]}" -gt 0 ] || die "no sources found under src/ or shared/"

    "$XGETTEXT" --from-code=UTF-8 --language=C++ --keyword=_ --keyword=N_ \
        --output="$out" "${files[@]}" || die "$XGETTEXT failed"

    # Nothing or header-only means the extraction is broken, never that the program
    # has no strings. Checked before the pot is replaced, so a broken gettext
    # cannot empty a good pot.
    [ -s "$out" ] || die "$XGETTEXT produced no output (is gettext working? $XGETTEXT --version)"
    [ "$(grep -c '^msgid "' "$out")" -gt 1 ] ||
        die "$XGETTEXT extracted no message - are the keywords right?"
}

# The pot without its header entry and without source locations: the entries of a
# fresh catalog. With identity=1 every msgstr repeats its msgid (po/en.po).
pot_body() {
    awk -v identity="$2" '
        NR == 1 { skipping = 1 }
        skipping { if ($0 ~ /^$/) skipping = 0; next }
        /^#:/ { next }
        /^msgid / {
            if (identity) { buffer = $0; sub(/^msgid/, "msgstr", buffer); collecting = 1 }
            print; next
        }
        /^"/ { if (collecting) buffer = buffer "\n" $0; print; next }
        /^msgstr ""$/ {
            if (collecting) { print buffer; collecting = 0; next }
            print; next
        }
        { print }
    ' "$1"
}

# The language codes the GUI offers (src/optionsdialog.cpp, without the leading
# "" for "follow the session"). A catalog that is not in this list cannot be
# picked; a code without a catalog is a window that stays English.
gui_language_codes() {
    sed -n 's/.*kLanguageCodes\[\] *= *{\(.*\)};.*/\1/p' "src/optionsdialog.cpp" |
        tr ',' '\n' | tr -d ' "' | sed '/^$/d'
}

# The labels of that dropdown: one more than the codes, the first being
# "System language".
gui_language_labels() {
    sed -n '/languageOptions\[\] *= *{/,/nullptr/p' "src/optionsdialog.cpp" |
        sed 's/.*{//; s/nullptr.*//' | tr ',' '\n' | grep -c '[^[:space:]]'
}

# ---------------------------------------------------------------------------
# commands
# ---------------------------------------------------------------------------

cmd_extract() {
    POT_TMP=$(mktemp "${TMPDIR:-/tmp}/$PACKAGE-pot.XXXXXX")
    extract_to "$POT_TMP"

    if [ -f "$POT" ]; then
        local added gone
        added=$(comm -13 <(msgids "$POT" | sort) <(msgids "$POT_TMP" | sort))
        gone=$(comm -23 <(msgids "$POT" | sort) <(msgids "$POT_TMP" | sort))
        note "po/gkeymapper.pot: $(msgids "$POT_TMP" | wc -l) messages"
        [ -z "$added" ] || { note "new:"; printf '%s\n' "$added" | sed 's/^/  /'; }
        [ -z "$gone" ] || { note "gone:"; printf '%s\n' "$gone" | sed 's/^/  /'; }
    else
        note "po/gkeymapper.pot: $(msgids "$POT_TMP" | wc -l) messages"
    fi

    mv "$POT_TMP" "$POT"
    POT_TMP="" # moved, nothing to clean up
    note "wrote po/gkeymapper.pot - now: scripts/i18n.sh update"
}

cmd_update() {
    local lang po
    require_tools "$MSGMERGE" "$MSGFMT"
    [ -f "$POT" ] || die "$POT is missing - run: scripts/i18n.sh extract"

    local -a targets
    if [ "$#" -gt 0 ]; then targets=("$@"); else mapfile -t targets < <(languages); fi
    [ "${#targets[@]}" -gt 0 ] || die "no po/*.po to update"

    for lang in "${targets[@]}"; do
        po="$PO_DIR/$lang.po"
        [ -f "$po" ] || die "$po does not exist (a new language: scripts/i18n.sh new $lang)"
        # --no-location: the catalogs carry no "#: file:line" comments on purpose -
        # they are noise for translators and churn whenever a line moves. The
        # locations live in the pot, and `todo` shows them from there.
        "$MSGMERGE" --quiet --update --no-location "$po" "$POT"
        # msgmerge keeps the previous file as <po>~; a backup in git is noise.
        rm -f "$po~"
        stats "$po"
        note "po/$lang.po: $translated translated, $fuzzy fuzzy, $untranslated untranslated"
    done
}

cmd_check() {
    local lang po code out failures=0 stale_dates=""
    require_tools "$MSGFMT" "$MSGATTRIB" "$MSGCAT" "$MSGMERGE" "$XGETTEXT"
    [ -f "$POT" ] || die "$POT is missing"

    local langs
    langs=$(languages)
    [ -n "$langs" ] || die "no po/*.po found"

    # 1. Is the pot what the sources say? A message that was added or changed
    #    without touching the pot is what this catches - the source locations only
    #    drift when a line moves, which is worth a note, not a failure.
    POT_TMP=$(mktemp "${TMPDIR:-/tmp}/$PACKAGE-pot.XXXXXX")
    extract_to "$POT_TMP"
    local added gone
    added=$(comm -13 <(msgids "$POT" | sort) <(msgids "$POT_TMP" | sort))
    gone=$(comm -23 <(msgids "$POT" | sort) <(msgids "$POT_TMP" | sort))
    if [ -n "$added" ] || [ -n "$gone" ]; then
        note "po/gkeymapper.pot is out of date:"
        [ -z "$added" ] || { note "  in the sources, not in the pot:"; printf '%s\n' "$added" | sed 's/^/    /'; }
        [ -z "$gone" ] || { note "  in the pot, not in the sources:"; printf '%s\n' "$gone" | sed 's/^/    /'; }
        note "  fix: scripts/i18n.sh extract && scripts/i18n.sh update"
        failures=$((failures + 1))
    elif ! diff -q <(grep -v '^"POT-Creation-Date:' "$POT_TMP") \
                   <(grep -v '^"POT-Creation-Date:' "$POT") >/dev/null; then
        note "po/gkeymapper.pot has the same messages, but an older extract (line numbers, order)"
        note "  only the locations in 'todo' are affected - scripts/i18n.sh extract refreshes them"
    fi

    # 2. Every catalog: parsable, complete, translated, and named what it says.
    for lang in $langs; do
        po="$PO_DIR/$lang.po"

        # -c checks the format strings (%s, %d, ...) and the entry structure.
        if ! out=$("$MSGFMT" -c -o /dev/null "$po" 2>&1); then
            note "$lang: $MSGFMT -c failed:"
            printf '%s\n' "$out" | sed 's/^/  /'
            failures=$((failures + 1))
        fi

        # Does the catalog define the same messages as the pot? Compared as two
        # lists rather than with msgcmp, which would also report every untranslated
        # entry and drown the real problem (the counts below say what is missing).
        local missing extra
        missing=$(comm -23 <(msgids "$POT" | sort) <(msgids "$po" | sort))
        extra=$(comm -13 <(msgids "$POT" | sort) <(msgids "$po" | sort))
        if [ -n "$missing" ]; then
            note "$lang: $po does not define:"
            printf '%s\n' "$missing" | sed 's/^/  /'
            failures=$((failures + 1))
        fi
        if [ -n "$extra" ]; then
            note "$lang: $po defines messages the pot does not know:"
            printf '%s\n' "$extra" | sed 's/^/  /'
            failures=$((failures + 1))
        fi

        stats "$po"
        if [ "$untranslated" -ne 0 ]; then
            note "$lang: $untranslated untranslated message(s) - scripts/i18n.sh todo $lang"
            failures=$((failures + 1))
        fi
        if [ "$fuzzy" -ne 0 ]; then
            note "$lang: $fuzzy fuzzy message(s) - those are shown in English"
            failures=$((failures + 1))
        fi

        # Strings that vanished from the program: msgmerge keeps them as "#~"
        # entries. Not an error, but stale food for the next translator.
        local obsolete=0
        obsolete=$(grep -c '^#~' "$po" || true)
        [ "$obsolete" -eq 0 ] ||
            note "$lang: $obsolete obsolete entries (gone from the sources; msgattrib --no-obsolete drops them)"

        if [ "$(po_language "$po")" != "$lang" ]; then
            note "$lang: the header says Language: $(po_language "$po")"
            failures=$((failures + 1))
        fi

        # English has a catalog of its own (an explicit language has to work on a
        # German desktop) and it is an identity one.
        if [ "$lang" = "en" ]; then
            if ! out=$(identity_mismatches "$po"); then
                note "en: po/en.po is not an identity catalog:"
                printf '%s\n' "$out" | head -20 | sed 's/^/  /'
                failures=$((failures + 1))
            fi
        fi

        # A note, not a failure: it only means the file was not merged after the
        # last extract, so its header carries an older date than the pot. Collected
        # into one line - it says nothing about a single language.
        if [ "$(pot_date "$po")" != "$(pot_date "$POT")" ]; then
            stale_dates="$stale_dates $lang"
        fi
    done
    [ -z "$stale_dates" ] ||
        note "not merged against the current pot:$stale_dates (scripts/i18n.sh update)"

    # 3. The languages the GUI offers (src/optionsdialog.cpp): a catalog that cannot
    #    be selected is dead weight, a code without a catalog is an English window
    #    with a German label.
    local codes
    codes=$(gui_language_codes)
    [ -n "$codes" ] || die "could not read kLanguageCodes[] from src/optionsdialog.cpp"
    for lang in $langs; do
        if ! grep -qx "$lang" <<<"$codes"; then
            note "po/$lang.po exists, but $lang is not offered in the options window"
            note "  add it to kLanguageCodes[] and languageOptions[] (src/optionsdialog.cpp)"
            failures=$((failures + 1))
        fi
    done
    for code in $codes; do
        if [ ! -f "$PO_DIR/$code.po" ]; then
            note "the options window offers $code, but po/$code.po is missing"
            failures=$((failures + 1))
        fi
    done
    if [ "$(gui_language_labels)" -ne "$(( $(printf '%s\n' "$codes" | wc -l) + 1 ))" ]; then
        note "kLanguageCodes[] and languageOptions[] differ in length (src/optionsdialog.cpp)"
        failures=$((failures + 1))
    fi

    # 4. Strings marked in the daemon. It has no gettext setup (no setlocale, no
    #    bindtextdomain - see daemon/main.cpp), so a `_()` there would end up in the
    #    pot, get translated, and still show English forever. The GUI is the
    #    translated program.
    local daemon_marked
    daemon_marked=$(grep -lE '(^|[^[:alnum:]_])_\("|N_\("' daemon/*.cpp 2>/dev/null || true)
    if [ -n "$daemon_marked" ]; then
        note "the daemon is not translated, but these files mark strings:"
        printf '%s\n' "$daemon_marked" | sed 's/^/  /'
        note "  either drop the marker, or give the daemon its own gettext setup and"
        note "  add daemon/ to sources() in scripts/i18n.sh"
        failures=$((failures + 1))
    fi

    if [ "$failures" -gt 0 ]; then
        note "i18n: $failures problem(s)"
        return 1
    fi
    note "i18n: $(printf '%s\n' "$langs" | wc -l) languages, $(msgids "$POT" | wc -l) messages, everything in sync"
}

cmd_status() {
    local lang po mo mo_state
    require_tools "$MSGFMT" "$MSGCAT"
    [ -f "$POT" ] || die "$POT is missing"
    printf '%-4s %-8s %10s %6s %11s  %-9s %s\n' \
        lang messages translated fuzzy untranslated catalog file
    for lang in $(languages); do
        po="$PO_DIR/$lang.po"
        stats "$po"
        mo="$LOCALE_DIR/$lang/LC_MESSAGES/$PACKAGE.mo"
        mo_state="not built"
        if [ -f "$mo" ]; then
            # `make translations` rebuilds a catalog that is older than its po.
            if [ "$mo" -nt "$po" ]; then mo_state="current"; else mo_state="stale"; fi
        fi
        printf '%-4s %-8s %10s %6s %11s  %-9s %s\n' "$lang" \
            "$((translated + fuzzy + untranslated))" "$translated" "$fuzzy" "$untranslated" \
            "$mo_state" "po/$lang.po"
    done
    printf '\npot: %s messages, %s\n' "$(msgids "$POT" | wc -l)" "$(pot_date "$POT")"
}

cmd_todo() {
    local lang="${1:-}"
    [ -n "$lang" ] || die "usage: scripts/i18n.sh todo <lang>"
    local po="$PO_DIR/$lang.po"
    [ -f "$po" ] || die "$po does not exist"
    require_tools "$MSGMERGE" "$MSGATTRIB"

    # Merging the pot into the catalog is what puts the source locations next to
    # the messages - the catalogs themselves have none (see cmd_update).
    local open
    open=$("$MSGMERGE" --quiet "$po" "$POT" | "$MSGATTRIB" --untranslated --no-obsolete)
    if [ -n "$open" ]; then
        # A valid po comment, so the output can be kept as a file and translated.
        note "# --- untranslated in po/$lang.po ---"
        printf '%s\n' "$open"
    else
        note "po/$lang.po: nothing untranslated"
    fi

    local fuzzy
    fuzzy=$("$MSGMERGE" --quiet "$po" "$POT" | "$MSGATTRIB" --only-fuzzy --no-obsolete)
    if [ -n "$fuzzy" ]; then
        note
        note "# --- fuzzy: shown in English until reviewed, the old text is kept as a comment ---"
        printf '%s\n' "$fuzzy"
    fi
}

cmd_new() {
    local lang="${1:-}" team="${2:-}"
    [ -n "$lang" ] || die "usage: scripts/i18n.sh new <lang> [Language-Team]"
    case "$lang" in
        *[!a-zA-Z_@.-]*) die "unexpected language code: $lang" ;;
    esac
    [ -f "$POT" ] || die "$POT is missing - run: scripts/i18n.sh extract"
    local po="$PO_DIR/$lang.po"
    [ -e "$po" ] && die "$po already exists"
    if [ -z "$team" ]; then
        # The two catalogs for a language that has been here from the start carry
        # the English name of the language; anything else falls back to its code.
        case "$lang" in
            en) team="English" ;;
            *)  team="$lang" ;;
        esac
    fi

    {
        if [ "$lang" = "en" ]; then
            printf '# English translation for %s.\n' "$PACKAGE"
            printf '# English is the source language; this catalog keeps the strings explicit.\n'
        else
            printf '# %s translation for %s.\n' "$team" "$PACKAGE"
            printf '# Copyright (C) %s\n' "$(date '+%Y')"
            printf '# This file is distributed under the same license as the %s package.\n' "$PACKAGE"
        fi
        printf '#\n'
        # The header in the shape the other catalogs use, so a new language does not
        # start out looking different.
        cat <<EOF
msgid ""
msgstr ""
"Project-Id-Version: $PACKAGE $PO_VERSION\n"
"Report-Msgid-Bugs-To: \n"
"POT-Creation-Date: $(pot_date "$POT")\n"
"PO-Revision-Date: $(date '+%Y-%m-%d %H:%M%z')\n"
"Last-Translator: \n"
"Language-Team: $team\n"
"Language: $lang\n"
"MIME-Version: 1.0\n"
"Content-Type: text/plain; charset=UTF-8\n"
"Content-Transfer-Encoding: 8bit\n"
EOF
        printf '\n'
        # The entries come from the pot: it defines what has to be translated, and
        # every msgstr in it is already empty.
        pot_body "$POT" "$([ "$lang" = "en" ] && echo 1 || echo 0)"
    } >"$po"

    note "wrote po/$lang.po"
    if [ "$lang" != "en" ]; then
        note "next:"
        note "  translate it, then: scripts/i18n.sh check && make translations"
        note "  offer it in the options window, or nobody can pick it:"
        note "    src/optionsdialog.cpp: kLanguageCodes[] and languageOptions[]"
    fi
}

usage() {
    cat <<'EOF'
scripts/i18n.sh <command> [arguments]

  extract              regenerate po/gkeymapper.pot from the sources
  update [lang...]     merge the pot into the catalogs: new strings come in
                       untranslated, existing translations are kept
  check                validate the pot, the catalogs and the language list
  status               per-language overview (counts + compiled catalog)
  todo <lang>          what is still untranslated or fuzzy, with the source
                       locations from the pot
  new <lang> [name]    create po/<lang>.po from the pot (name = Language-Team,
                       e.g. "Italiano"); "new en" writes the identity catalog
  help                 this text

The rules behind the commands are in po/README.md. gettext tools are used from
PATH; override them like the Makefile's variables, e.g. XGETTEXT=/usr/bin/xgettext
EOF
}

command="${1:-help}"
shift || true
case "$command" in
    extract|pot) cmd_extract "$@" ;;
    update) cmd_update "$@" ;;
    check) cmd_check "$@" ;;
    status) cmd_status "$@" ;;
    todo) cmd_todo "$@" ;;
    new) cmd_new "$@" ;;
    help|-h|--help) usage ;;
    *) usage; exit 1 ;;
esac