#!/bin/bash

# script pour renommer des personnages ou lieux dans un document Manuskript

# ./renomme <document manuskript> <ancien nom> <nouveau nom> [ins=poids] [del=poids] [rep=poids]

#

# Le document d'origine est sauvegardé (voir variable $backup)

#

# Si <nouveau nom> est "check", ou "prox" ou "leven", une étude de proximité est alors effectuée

# sur l'algorithme Levenshtein. Les paramètres de poids sont des nombres entiers, et permettent

# de pondérer l'ajout (ins=), la suppression (del=) et le remplacement (rep=) de caractère.

# par défaut chacun des trois paramètres est égal à 1.

# Il n'y a pas d'ordre obligatoire pour le paramétrage, et si un paramétrage est effectué plusieurs fois

# c'est le plus à gauche qui prend la priorité. Il n'y a pas de backup effectué pour l'opération de vérification de la proximité

# crédit algo: https://en.wikibooks.org/wiki/Algorithm_Implementation/Strings/Levenshtein_distance

set -e

manuscrit=${1:?}

ancien=${2:?}

nouveau=${3:?}

if test "${manuscrit:0:1}" != '/'; then

    manuscrit="$PWD/$manuscrit"

fi

test -r "$manuscrit" || exit 1

test $(file --brief --mime-type --dereference "$manuscrit") == 'application/zip' || exit 2

backup="${manuscrit/%.msk} (avant renommage de «${ancien}» en «${nouveau}»).msk"

function trap_exit () {

    rm -fr $temp

    cd - > /dev/null

}

function determinant () {

    eval "local nom=\"\$$1\""

    if [[ ${nom:0:1} == @(A|E|H|I|O|U) \

       || ${nom:0:1} == @(Â|Ê|H|Î|Ô|Û) \

       || ${nom:0:1} == @(Ä|Ë|H|Ï|Ö|Ü) \

       || ${nom:0:1} == @(À|È|H|Ì|Ò|Ù) \

       || ${nom:0:1} == @(Á|É|H|Í|Ó|Ú) \

    ]]; then

        eval "determinant_$1=\"d'\""

        eval "determinant_$1_formatted=\"d-\""

    else

        eval "determinant_$1=\"de \""

        eval "determinant_$1_formatted=\"de-\""

    fi

}

function format () {

    eval "$1_formatted=\$(tr --complement --squeeze-repeats 'A-Za-z-_\n' - <<< \"\${$1// /_}\")"

}

function renomme_fichiers () {

    for char in $(find characters -type f -regex "characters/[0-9]+-$1.txt"); do

        local new_char=$(sed "s/$1/$2/" <<< $char)

        echo "character: $char -> $new_char"

        mv $char $new_char

        break

    done

    for chapter in $(find outline -type d -regex "outline/.*$1.*"); do

        local new_chapter=$(sed "s/$1/$2/g" <<< $chapter)

        echo "chapter: $chapter -> $new_chapter"

        mv $chapter $new_chapter

    done

    for part in $(find outline -type f -regex "outline/[^/]*$1[^/]*.md"); do

        local new_part=$(sed "s/$1/$2/g" <<< $part)

        echo "part: $part -> $new_part"

        mv $part $new_part

    done

}

trap trap_exit EXIT

temp=$(mktemp --directory /dev/shm/XXXXXXXXX)

cd $temp

if [[ $nouveau = @(check|prox|leven) ]]; then

    unzip -qq "$manuscrit"

    for param in $(seq 4 $#); do

        for dst in ins del rep max; do

            eval "if test -n '\$$param' && [[ \"\$$param\" =~ $dst=[0-9]+ ]]; then cost_$dst=\${$param#*=}; fi"

        done

    done

    for dst in ins del rep; do

        eval "cost_$dst=\${cost_$dst:-1}"

    done

    cost_max=${cost_max:-$(($cost_ins + $cost_del + $cost_rep))}

    if test $cost_max -ge ${#ancien}; then

        cost_max=$(( ${#ancien} - 1 ))

    fi

    echo paramètres d\'approximation

    echo "caractère manquant (del=): $cost_del"

    echo "caractère inséré   (ins=): $cost_ins"

    echo "caractère remplacé (rep=): $cost_rep"

    echo "distance maximale  (max=): ${cost_max:-$(($cost_ins + $cost_del + $cost_rep))}"

    for f in $(find . -type f); do

        let wc+=$(wc -w < $f)

    done

    awk -v ancien=$ancien -v wc=$wc -v cost_ins=$cost_ins -v cost_del=$cost_del -v cost_rep=$cost_rep -v cost_max=$cost_max '

        BEGIN {

            RS="[[:punct:]]"

            progress_mod    = 10

            actual_progress = 0

            pct_progress    = 0

            progress        = 0

            found_words     = 0

            cost_tot = cost_ins + cost_del + cost_rep

            cost_tot = cost_tot > cost_max ? cost_max : cost_tot

            str1_len = length(ancien)

            for (i=1; i<=str1_len; i++)

                str1_substr[i]=substr(ancien, i, 1)

        }

        function levenshtein(str2) {

            str2_len = length(str2)

            if(str2_len == 0) return str1_len * cost_del

            for(j = 1; j <= str2_len; j++)

                str2_substr[j]=substr(str2, j, 1)

            matrix[0, 0] = 0

            for(i = 1; i <= str1_len; i++) {

                matrix[i, 0] = i * cost_del

                for(j = 1; j <= str2_len; j++) {

                    matrix[0, j] = j * cost_ins

                    x = matrix[i - 1, j] + cost_del

                    y = matrix[i, j - 1] + cost_ins

                    z = matrix[i - 1, j - 1] + (str1_substr[i] == str2_substr[j] ? 0 : cost_rep)

                    x = x < y ? x : y

                    matrix[i, j] = x < z ? x : z

                }

            }

            return matrix[str1_len, str2_len]

        }

        {

            for (word=1; word<=NF; word++) {

                progress++

                lvstn = levenshtein(gensub("[[:punct:]]","","g",$word))

                if (lvstn <= cost_tot && lvstn > 0) {

                    key = sprintf("%s (%d)", $word, lvstn)

                    approx_possibles[key]++

                    found_words++

                }

                pct_progress=int(progress / wc * 100)

                if (actual_progress < pct_progress && pct_progress % progress_mod == 0) {

                    actual_progress = pct_progress

                    printf("%i%\n", actual_progress)

                }

            }

        }

        END {

            if (found_words > 0) {

                printf("mot%s proche%s de «%s» (distance) [occurences]\n", found_words > 0 ? "s" : "", found_words > 0 ? "s" : "", ancien)

                for (i in approx_possibles)

                    printf("- %s [%i]\n", i, approx_possibles[i])

            }

            else {

                print "aucun mot proche et différent de «" ancien "» trouvé"

            }

        }

    ' $(find . -type f)

    exit

fi

mv --backup=numbered "$manuscrit" "$backup"

unzip -qq "$backup"

for version in ancien nouveau; do

    format $version

    determinant $version

done

declare -A remplacement

remplacement=(

    [$ancien]="$nouveau"

    [$ancien_formatted]="$nouveau_formatted"

    [$determinant_ancien$ancien]="$determinant_nouveau$nouveau"

    [$determinant_ancien_formatted$ancien_formatted]="$determinant_nouveau_formatted$nouveau_formatted"

)

renomme_fichiers "$ancien_formatted" "$nouveau_formatted"

renomme_fichiers "$determinant_ancien_formatted$ancien_formatted" "$determinant_nouveau_formatted$nouveau_formatted"

egrep --word-regexp --only-matching --recursive --regexp="($determinant_ancien|$determinant_ancien_formatted)\?($ancien|$ancien_formatted)" . \

| awk -v name="$1" -F ':' '

    {

        if ($NF > 0) {

            file[$1]++

            nb++

        }

    }

    END {

        printf("remplacement de %i occurences pour %s dans %i fichiers\n", nb, name, asort(file))

    }'

for regexp in "${!remplacement[@]}"; do

    egrep --word-regexp --files-with-matches --recursive --regexp="$regexp" . \

    | xargs --no-run-if-empty sed --regexp-extended --in-place "s/(\W|^)$regexp(\W|$)/\1${remplacement[$regexp]}\2/g"

done

zip --recurse-paths --no-dir-entries -qq "${manuscrit}" *