#!/bin/sh
#
# Compara dois registros de ensaio e diz se o ensaio VALE.
#
#   sh scripts/comparar-ensaios.sh ensaios/primeira.txt ensaios/segunda.txt
#
# TRÊS CLASSES DE LINHA, com regras diferentes — e é a distinção entre elas que
# faz a comparação significar alguma coisa:
#
#   ORIGEM     tem que ser idêntica. Se a base de origem mudou entre as duas
#              execuções, elas não mediram a mesma coisa e comparar os tempos
#              ENGANA. Isto invalida o ensaio; não é uma falha, é um empate
#              anulado.
#
#   RESULTADO  tem que ser idêntico. Contagem, sequência, extremos de data,
#              soma. Duas execuções com tempos parecidos e contagens diferentes
#              é o pior dos casos, e o mais fácil de não perceber.
#
#   TEMPO      pode variar, dentro de uma faixa. Se variar mais que isso, algo
#              não é determinístico — cache, vizinho na máquina, concorrência —
#              e o número não serve para dimensionar janela nenhuma.
#
# Sai com 1 se o ensaio não vale.
set -e

A="$1"
B="$2"

if [ ! -f "$A" ] || [ ! -f "$B" ]; then
    echo "uso: sh scripts/comparar-ensaios.sh <registro-1> <registro-2>" >&2
    exit 1
fi

# Quanto um tempo pode variar entre execuções, em porcento.
TOLERANCIA="${TOLERANCIA:-20}"

# Abaixo disto o ruído domina e a porcentagem não diz nada: 1s contra 2s é 100%
# de diferença e não significa coisa alguma.
PISO=10

PROBLEMAS=0
ANULADO=0

valor() { grep -E "^$2 " "$1" | head -1 | sed "s/^$2 *//" | sed 's/ *$//'; }

comparar_igual() {
    VA=$(valor "$A" "$1")
    VB=$(valor "$B" "$1")

    if [ -z "$VA" ] && [ -z "$VB" ]; then
        return 0
    fi

    if [ "$VA" = "$VB" ]; then
        printf '   %-24s %s\n' "$1" "$VA"
        return 0
    fi

    printf '   %-24s DIFERE   1: %s   2: %s\n' "$1" "$VA" "$VB"

    if [ "$2" = "anula" ]; then
        ANULADO=$((ANULADO + 1))
    else
        PROBLEMAS=$((PROBLEMAS + 1))
    fi
}

comparar_tempo() {
    VA=$(valor "$A" "$1")
    VB=$(valor "$B" "$1")

    case "$VA$VB" in
        *FALHOU*|'') printf '   %-24s SEM MEDIDA (1: %s  2: %s)\n' "$1" "$VA" "$VB"
                     PROBLEMAS=$((PROBLEMAS + 1)); return 0 ;;
    esac

    MAIOR=$VA
    MENOR=$VB
    [ "$VB" -gt "$VA" ] && { MAIOR=$VB; MENOR=$VA; }

    DIF=$((MAIOR - MENOR))

    if [ "$MAIOR" -lt "$PISO" ]; then
        printf '   %-24s %ss / %ss   (curto demais para julgar)\n' "$1" "$VA" "$VB"
        return 0
    fi

    PCT=$((DIF * 100 / MAIOR))

    if [ "$PCT" -le "$TOLERANCIA" ]; then
        printf '   %-24s %ss / %ss   (%s%%)\n' "$1" "$VA" "$VB" "$PCT"
    else
        printf '   %-24s %ss / %ss   (%s%%)  ACIMA DA TOLERANCIA DE %s%%\n' \
            "$1" "$VA" "$VB" "$PCT" "$TOLERANCIA"
        PROBLEMAS=$((PROBLEMAS + 1))
    fi
}

# ---------------------------------------------------------------------------
echo "== A origem era a mesma? =="
echo "   (se não era, as duas execuções não mediram a mesma coisa)"
echo

for t in agendas vendas vendas_produtos clientes usuarios_acessos pontuacoes_historicos; do
    comparar_igual "linhas_$t"   anula
    comparar_igual "maior_id_$t" anula
done

# ---------------------------------------------------------------------------
echo
echo "== O resultado foi o mesmo? =="
echo

for t in agendas vendas vendas_produtos clientes usuarios_acessos pontuacoes_historicos; do
    comparar_igual "destino_$t"
done

comparar_igual "sequencia_vendas"
comparar_igual "data_min_vendas"
comparar_igual "data_max_vendas"
comparar_igual "soma_vendas"

echo
comparar_igual "portao_conferir_migracao"
comparar_igual "portao_conferir_papeis"
comparar_igual "portao_vigencia"
comparar_igual "portao_caracterizacao"
comparar_igual "portao_volta_atras"

# ---------------------------------------------------------------------------
echo
echo "== Os tempos são previsíveis? =="
echo

# `clone_pg` e `clone_mysql` desde 11/10/2026 (D378): as copias de cada banco com
# as fixtures, onde as duas fases da suite rodam.
for f in limpeza schema papeis carga conferencia semente papeis_provas clone_pg apontar vigencia caracterizacao clone_mysql volta_atras TOTAL; do
    comparar_tempo "$f"
done

# ---------------------------------------------------------------------------
echo
echo "== O ensaio mede o hardware certo? =="
echo

LIM_A=$(valor "$A" "postgres_cpus")
LIM_B=$(valor "$B" "postgres_cpus")

printf '   %-24s 1: %s\n' "postgres_cpus" "$LIM_A"
printf '   %-24s 2: %s\n' "" "$LIM_B"

case "$LIM_A$LIM_B" in
    *"SEM LIMITE"*)
        echo
        echo "   AVISO: ao menos uma execução rodou sem limite de contêiner."
        echo "   Os tempos medem a máquina do laboratório, não a de produção."
        echo "   Servem para provar REPETIBILIDADE; não servem para dimensionar"
        echo "   a janela. Ver ambiente-homologacao.md."
        ;;
esac

# ---------------------------------------------------------------------------
echo
echo "=========================================================="

if [ "$ANULADO" -gt 0 ]; then
    echo "ENSAIO ANULADO: a base de origem mudou entre as duas execuções."
    echo "$ANULADO diferença(s) na impressão digital da origem."
    echo
    echo "Não é uma falha do procedimento — é uma comparação sem sentido."
    echo "Congele a origem e repita as duas execuções."
    exit 1
fi

if [ "$PROBLEMAS" -eq 0 ]; then
    echo "ENSAIO VÁLIDO: mesmo resultado, tempos dentro da tolerância."
    exit 0
fi

echo "ENSAIO NÃO CONCLUSIVO: $PROBLEMAS ponto(s) acima."
echo
echo "Resultado diferente entre execuções significa carga não determinística —"
echo "isso precisa ser entendido antes de qualquer corte. Tempo fora da faixa"
echo "significa que o número não serve para dimensionar a janela; repita."
exit 1