#!/usr/bin/env bash
set -u

MINIMUM_SAMPLES="50"
EXPECTED_BASELINE_PARSER_SHA256="91c4d66770197e1986ed91eb6a4870e7da7df5a522ffdf4329b6d9250f238307"
EXPECTED_TEST_CONFIG_SHA256="d037561b32760fbd0e2aec9f1eefc5efda27b1918eca4742c89092a8a2f7e92e"
EXPECTED_DIAGNOSTIC_CONFIG_SHA256="cd999ff249452298d650a22c8fe5b0b03bf48c0735f4630befdec8209cbb13a3"

SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
PACKAGE_ROOT="$(cd "$SCRIPT_DIR/../.." && pwd)"
PARSER="${S03_BASELINE_PARSER:-$PACKAGE_ROOT/baseline/parse_s03_binary.py}"
CONFIG_VERIFIER="$SCRIPT_DIR/verify_s03h1_config.py"

MODE="NOT_PROVIDED"
MODE_STATUS="NOT_DEMONSTRATED"
PROFILE_CONFIG_STATUS="NOT_DEMONSTRATED"
OBSERVABILITY_STATUS="NOT_DEMONSTRATED"
FUNCTIONAL_STATUS="NOT_DEMONSTRATED"
SEMANTIC_STATUS="NOT_DEMONSTRATED"
TIMING_STATUS="NOT_EVALUATED"
MEASUREMENT_ELIGIBILITY="NO"

emit_contract() {
    printf "MODE=%s\n" "$MODE"
    printf "MODE_STATUS=%s\n" "$MODE_STATUS"
    printf "PROFILE_CONFIG_STATUS=%s\n" "$PROFILE_CONFIG_STATUS"
    printf "OBSERVABILITY_STATUS=%s\n" "$OBSERVABILITY_STATUS"
    printf "FUNCTIONAL_STATUS=%s\n" "$FUNCTIONAL_STATUS"
    printf "SEMANTIC_STATUS=%s\n" "$SEMANTIC_STATUS"
    printf "TIMING_STATUS=%s\n" "$TIMING_STATUS"
    printf "MEASUREMENT_ELIGIBILITY=%s\n" "$MEASUREMENT_ELIGIBILITY"
}

fail_early() {
    code="$1"
    shift
    printf "[NON DIMOSTRATO] %s\n" "$*" >&2
    emit_contract
    printf "VALIDATION_RESULT=FAIL_REQUIRED_INPUT\n"
    exit "$code"
}

if [ "$#" -ne 2 ]; then
    printf "Uso: %s TEST|DIAGNOSTIC <directory-run|run.log>\n" "$0" >&2
    emit_contract
    exit 2
fi

MODE="$1"
case "$MODE" in
    TEST)
        EXPECTED_PROFILE_CONFIG_SHA256="$EXPECTED_TEST_CONFIG_SHA256"
        ;;
    DIAGNOSTIC)
        EXPECTED_PROFILE_CONFIG_SHA256="$EXPECTED_DIAGNOSTIC_CONFIG_SHA256"
        ;;
    *)
        MODE_STATUS="FAIL"
        PROFILE_CONFIG_STATUS="FAIL"
        OBSERVABILITY_STATUS="FAIL"
        printf "UNKNOWN_MODE=%s\n" "$MODE" >&2
        emit_contract
        printf "VALIDATION_RESULT=FAIL_UNKNOWN_MODE\n"
        exit 2
        ;;
esac

INPUT_PATH="$2"
if [ -d "$INPUT_PATH" ]; then
    RUN_DIR="$(cd "$INPUT_PATH" && pwd)"
    RUN_LOG="$RUN_DIR/run.log"
elif [ -f "$INPUT_PATH" ]; then
    RUN_LOG="$(cd "$(dirname "$INPUT_PATH")" && pwd)/$(basename "$INPUT_PATH")"
    RUN_DIR="$(dirname "$RUN_LOG")"
else
    fail_early 21 "Percorso di validazione non trovato: $INPUT_PATH"
fi

RUN_CONFIG="$RUN_DIR/configuration.marte"
OUTPUT_FILE="$RUN_DIR/s03_output.bin"
RUNNER_SUMMARY="$RUN_DIR/runner_summary.txt"
RUN_HASHES="$RUN_DIR/hashes.sha256"
MODE_FILE="$RUN_DIR/s03h1_mode.txt"

if [ ! -f "$PARSER" ]; then
    fail_early 21 "Parser baseline S03 assente: $PARSER"
fi
PARSER_SHA256="$(sha256sum -- "$PARSER" | awk '{print $1}')"
if [ "$PARSER_SHA256" != "$EXPECTED_BASELINE_PARSER_SHA256" ]; then
    fail_early 21 "Parser baseline S03 con hash inatteso: $PARSER_SHA256"
fi
if [ ! -x "$CONFIG_VERIFIER" ]; then
    fail_early 21 "Verificatore configurazione assente o non eseguibile: $CONFIG_VERIFIER"
fi

for required_file in \
    "$RUN_LOG" \
    "$RUN_CONFIG" \
    "$OUTPUT_FILE" \
    "$RUNNER_SUMMARY" \
    "$RUN_HASHES" \
    "$MODE_FILE"
do
    if [ ! -f "$required_file" ]; then
        fail_early 21 "File richiesto assente: $required_file"
    fi
done

if [ ! -s "$RUN_HASHES" ]; then
    fail_early 21 "Manifest hash assente o vuoto: $RUN_HASHES"
fi

count_lines() {
    pattern="$1"
    file="$2"
    grep -Ec "$pattern" "$file" || true
}

report_value() {
    key="$1"
    file="$2"
    sed -n "s/^${key}=//p" "$file" | tail -n 1
}

MODE_DECLARATION_COUNT="$(count_lines "^MODE=${MODE}$" "$MODE_FILE")"
SCENARIO_DECLARATION_COUNT="$(count_lines '^SCENARIO=S03H1$' "$MODE_FILE")"
CONFIG_HASH_DECLARATION_COUNT="$(
    count_lines "^CANDIDATE_CONFIG_SHA256=${EXPECTED_PROFILE_CONFIG_SHA256}$" "$MODE_FILE"
)"
INSTALLATION_GATE_DECLARATION_COUNT="$(
    count_lines '^S03_H1_INSTALLATION_AUTHORIZED=NO$' "$MODE_FILE"
)"
if [ "$MODE_DECLARATION_COUNT" -eq 1 ] &&
   [ "$SCENARIO_DECLARATION_COUNT" -eq 1 ] &&
   [ "$CONFIG_HASH_DECLARATION_COUNT" -eq 1 ] &&
   [ "$INSTALLATION_GATE_DECLARATION_COUNT" -eq 1 ]; then
    MODE_STATUS="PASS"
else
    MODE_STATUS="FAIL"
fi

START_LINES="$(count_lines '^\[Information - RealTimeLoader\.cpp:[0-9]+\]: Started application in state State1[[:space:]]*$' "$RUN_LOG")"
APPLICATION_START_LINES="$(count_lines '^\[Information - MARTeApp\.cpp:[0-9]+\]: Application starting[[:space:]]*$' "$RUN_LOG")"
FILE_OPEN_LINES="$(count_lines '^\[Information - FileWriter\.cpp:[0-9]+\]: Going to open file with name ' "$RUN_LOG")"
SIGINT_LINES="$(count_lines '^\[Information - Bootstrap\.cpp:[0-9]+\]: Application recieved SIGINT\.[[:space:]]*$' "$RUN_LOG")"
STOP_OK_LINES="$(count_lines '^\[Information - Bootstrap\.cpp:[0-9]+\]: Application successfully stopped\.[[:space:]]*$' "$RUN_LOG")"
TERMINATED_LINES="$(count_lines '^\[NoError - MARTeApp\.cpp:[0-9]+\]: Application terminated[[:space:]]*$' "$RUN_LOG")"

STARTUP_ERROR_LINES="$(count_lines 'Failed dlopen|Failed CreateByName|Failed to Initialise object|Failed to initialise the ObjectRegistryDatabase|Could not Initialise the loader' "$RUN_LOG")"
FATAL_ERROR_LINES="$(count_lines '^\[FatalError ' "$RUN_LOG")"
OS_ERROR_LINES="$(count_lines '^\[OSError ' "$RUN_LOG")"
ERROR_LINES="$(count_lines '^\[Error ' "$RUN_LOG")"
INITIALISATION_ERROR_LINES="$(count_lines '^\[InitialisationEr ' "$RUN_LOG")"
WARNING_LINES="$(count_lines '^\[Warning ' "$RUN_LOG")"

PRIORITY_CLIP_LINES="$(count_lines '^\[Warning - Threads\.cpp:[0-9]+\]: Requested a thread priority that is higher than ' "$RUN_LOG")"
PRIORITY_FAIL_LINES="$(count_lines '^\[Warning - Threads\.cpp:[0-9]+\]: Failed to change the thread priority' "$RUN_LOG")"
LINUX_TIMER_DEFAULT_WARNING_LINES="$(count_lines '^\[Warning - LinuxTimer\.cpp:[0-9]+\]: (ExecutionMode|CPUMask|StackSize) not specified using: ' "$RUN_LOG")"
CONFIG_DB_NODE_WARNING_LINES="$(count_lines '^\[Warning - MARTeApp\.cpp:[0-9]+\]: \[ConfigurationDatabaseNode\] - instances: [0-9]+[[:space:]]*$' "$RUN_LOG")"

UNCLASSIFIED_WARNING_LINES=$((
    WARNING_LINES -
    PRIORITY_CLIP_LINES -
    PRIORITY_FAIL_LINES -
    LINUX_TIMER_DEFAULT_WARNING_LINES -
    CONFIG_DB_NODE_WARNING_LINES
))
if [ "$UNCLASSIFIED_WARNING_LINES" -lt 0 ]; then
    UNCLASSIFIED_WARNING_LINES=0
fi

DOUBLE_STOP_LINES="$(count_lines '^\[FatalError - RealTimeApplication\.cpp:[0-9]+\]: Could not stop the RealTimeApplication\. Was it ever started\?[[:space:]]*$' "$RUN_LOG")"
ASYNC_EVENTSEM_CLOSE_LINES="$(count_lines '^\[FatalError - MemoryMapAsyncOutputBroker\.cpp:[0-9]+\]: Could not Close the EventSem\.[[:space:]]*$' "$RUN_LOG")"
PTHREAD_MUTEX_DESTROY_LINES="$(count_lines '^\[OSError - EventSem\.cpp:[0-9]+\]: Error: pthread_mutex_destroy\(\)[[:space:]]*$' "$RUN_LOG")"

UNCLASSIFIED_FATAL_LINES=$((FATAL_ERROR_LINES - DOUBLE_STOP_LINES - ASYNC_EVENTSEM_CLOSE_LINES))
UNCLASSIFIED_OS_ERROR_LINES=$((OS_ERROR_LINES - PTHREAD_MUTEX_DESTROY_LINES))
if [ "$UNCLASSIFIED_FATAL_LINES" -lt 0 ]; then
    UNCLASSIFIED_FATAL_LINES=0
fi
if [ "$UNCLASSIFIED_OS_ERROR_LINES" -lt 0 ]; then
    UNCLASSIFIED_OS_ERROR_LINES=0
fi

LOGGER_SIGNAL_LINES="$(count_lines '^\[Information - LoggerBroker\.cpp:[0-9]+\]: (Counter|Time|State1_Thread1_CycleTime|SentinelScalarA|SentinelScalarB|SentinelVector) \[[0-9]+:[0-9]+\]:' "$RUN_LOG")"
LOGGER_COUNTER_LINES="$(count_lines '^\[Information - LoggerBroker\.cpp:[0-9]+\]: Counter \[0:0\]:' "$RUN_LOG")"
LOGGER_TIME_LINES="$(count_lines '^\[Information - LoggerBroker\.cpp:[0-9]+\]: Time \[0:0\]:' "$RUN_LOG")"
LOGGER_CYCLE_TIME_LINES="$(count_lines '^\[Information - LoggerBroker\.cpp:[0-9]+\]: State1_Thread1_CycleTime \[0:0\]:' "$RUN_LOG")"
LOGGER_SCALAR_A_LINES="$(count_lines '^\[Information - LoggerBroker\.cpp:[0-9]+\]: SentinelScalarA \[0:0\]:' "$RUN_LOG")"
LOGGER_SCALAR_B_LINES="$(count_lines '^\[Information - LoggerBroker\.cpp:[0-9]+\]: SentinelScalarB \[0:0\]:' "$RUN_LOG")"
LOGGER_VECTOR_LINES="$(count_lines '^\[Information - LoggerBroker\.cpp:[0-9]+\]: SentinelVector \[0:2\]:' "$RUN_LOG")"

case "$MODE" in
    TEST)
        if [ "$LOGGER_SIGNAL_LINES" -eq 0 ] &&
           [ "$LOGGER_COUNTER_LINES" -eq 0 ] &&
           [ "$LOGGER_TIME_LINES" -eq 0 ] &&
           [ "$LOGGER_CYCLE_TIME_LINES" -eq 0 ] &&
           [ "$LOGGER_SCALAR_A_LINES" -eq 0 ] &&
           [ "$LOGGER_SCALAR_B_LINES" -eq 0 ] &&
           [ "$LOGGER_VECTOR_LINES" -eq 0 ]; then
            OBSERVABILITY_STATUS="PASS"
        else
            OBSERVABILITY_STATUS="FAIL"
        fi
        ;;
    DIAGNOSTIC)
        if [ "$LOGGER_COUNTER_LINES" -ge 1 ] &&
           [ "$LOGGER_TIME_LINES" -ge 1 ] &&
           [ "$LOGGER_CYCLE_TIME_LINES" -ge 1 ] &&
           [ "$LOGGER_SCALAR_A_LINES" -ge 1 ] &&
           [ "$LOGGER_SCALAR_B_LINES" -ge 1 ] &&
           [ "$LOGGER_VECTOR_LINES" -ge 1 ]; then
            OBSERVABILITY_STATUS="PASS"
        else
            OBSERVABILITY_STATUS="FAIL"
        fi
        ;;
esac

CONFIG_REPORT="$(mktemp "${TMPDIR:-/tmp}/s03h1_validator_config_XXXXXX.log")" || exit 22
BINARY_REPORT="$(mktemp "${TMPDIR:-/tmp}/s03h1_validator_binary_XXXXXX.log")" || exit 22
HASH_REPORT="$(mktemp "${TMPDIR:-/tmp}/s03h1_validator_hashes_XXXXXX.log")" || exit 22
trap 'rm -f -- "$CONFIG_REPORT" "$BINARY_REPORT" "$HASH_REPORT"' EXIT HUP INT TERM

EXPECTED_FILENAME="$RUN_DIR/s03_output.bin"
PYTHONHASHSEED=0 "$CONFIG_VERIFIER" \
    "$MODE" \
    "$RUN_CONFIG" \
    "$EXPECTED_FILENAME" \
    >"$CONFIG_REPORT" 2>&1
CONFIG_RC=$?
PROFILE_CONFIG_STATUS="$(
    report_value CONFIG_PROFILE_VERIFICATION_STATUS "$CONFIG_REPORT"
)"
if [ -z "$PROFILE_CONFIG_STATUS" ]; then
    PROFILE_CONFIG_STATUS="FAIL"
fi

PYTHONHASHSEED=0 python3 "$PARSER" "$OUTPUT_FILE" --min-samples "$MINIMUM_SAMPLES" \
    >"$BINARY_REPORT" 2>&1
PARSER_RC=$?

sha256sum -c --strict "$RUN_HASHES" >"$HASH_REPORT" 2>&1
HASH_RC=$?

FUNCTIONAL_BINARY_STATUS="$(report_value FUNCTIONAL_BINARY_STATUS "$BINARY_REPORT")"
SEMANTIC_BINARY_STATUS="$(report_value SEMANTIC_BINARY_STATUS "$BINARY_REPORT")"
BINARY_STATUS="$(report_value BINARY_STATUS "$BINARY_REPORT")"
FIRST_ERROR_CODE="$(report_value FIRST_ERROR_CODE "$BINARY_REPORT")"
PROFILE_ERROR_CODE="$(report_value PROFILE_ERROR_CODE "$CONFIG_REPORT")"
COMPLETE_SAMPLE_COUNT="$(report_value COMPLETE_SAMPLE_COUNT "$BINARY_REPORT")"
HEADER_BYTES="$(report_value OBSERVED_HEADER_BYTES "$BINARY_REPORT")"
RECORD_BYTES="$(report_value OBSERVED_RECORD_BYTES_FROM_HEADER "$BINARY_REPORT")"
PAYLOAD_BYTES="$(report_value PAYLOAD_BYTES "$BINARY_REPORT")"
PAYLOAD_REMAINDER_BYTES="$(report_value PAYLOAD_REMAINDER_BYTES "$BINARY_REPORT")"

MARTE_EXIT_CODE="$(sed -n 's/^Exit code MARTe:[[:space:]]*//p' "$RUNNER_SUMMARY" | tail -n 1)"
TEE_EXIT_CODE="$(sed -n 's/^Exit code tee:[[:space:]]*//p' "$RUNNER_SUMMARY" | tail -n 1)"
if [ -z "$MARTE_EXIT_CODE" ]; then
    MARTE_EXIT_CODE="NOT_AVAILABLE"
fi
if [ -z "$TEE_EXIT_CODE" ]; then
    TEE_EXIT_CODE="NOT_AVAILABLE"
fi

case "$MARTE_EXIT_CODE" in
    137)
        TIMING_STATUS="NOT_VALID_EXIT_137_SIGKILL"
        ;;
    *)
        if [ "$PRIORITY_FAIL_LINES" -ge 1 ]; then
            TIMING_STATUS="NOT_VALID_PRIORITY_NOT_APPLIED"
        else
            TIMING_STATUS="UNASSESSED_DT_SEMANTICS"
        fi
        ;;
esac

FUNCTIONAL_OK=0
if [ "$START_LINES" -ge 1 ] &&
   [ "$APPLICATION_START_LINES" -ge 1 ] &&
   [ "$FILE_OPEN_LINES" -ge 1 ] &&
   [ "$STARTUP_ERROR_LINES" -eq 0 ] &&
   [ "$MODE_STATUS" = "PASS" ] &&
   [ "$CONFIG_RC" -eq 0 ] &&
   [ "$PROFILE_CONFIG_STATUS" = "PASS" ] &&
   [ "$OBSERVABILITY_STATUS" = "PASS" ] &&
   [ "$FUNCTIONAL_BINARY_STATUS" = "PASS" ] &&
   [ "$HASH_RC" -eq 0 ] &&
   [ "$TEE_EXIT_CODE" = "0" ] &&
   [ "$UNCLASSIFIED_FATAL_LINES" -eq 0 ] &&
   [ "$UNCLASSIFIED_OS_ERROR_LINES" -eq 0 ] &&
   [ "$ERROR_LINES" -eq 0 ] &&
   [ "$INITIALISATION_ERROR_LINES" -eq 0 ]; then
    FUNCTIONAL_OK=1
fi

if [ "$FUNCTIONAL_OK" -eq 1 ]; then
    FUNCTIONAL_STATUS="PASS"
fi

if [ "$MODE_STATUS" = "PASS" ] &&
   [ "$PROFILE_CONFIG_STATUS" = "PASS" ] &&
   [ "$SEMANTIC_BINARY_STATUS" = "PASS" ]; then
    SEMANTIC_STATUS="PASS"
elif [ "$SEMANTIC_BINARY_STATUS" = "FAIL" ]; then
    SEMANTIC_STATUS="FAIL"
else
    SEMANTIC_STATUS="NOT_DEMONSTRATED"
fi

printf "============================================================\n"
printf "VALIDAZIONE S03-H1 - EXECUTION PROFILES\n"
printf "============================================================\n"
printf "Mode:                           %s\n" "$MODE"
printf "Run directory:                  %s\n" "$RUN_DIR"
printf "Configurazione:                 %s\n" "$RUN_CONFIG"
printf "File binario:                   %s\n" "$OUTPUT_FILE"
printf "Manifest hash:                  %s\n" "$RUN_HASHES"
printf "Parser baseline SHA-256:        %s\n" "$PARSER_SHA256"
printf "Mode file:                      %s\n" "$MODE_FILE"
printf "Mode declaration count:         %s\n" "$MODE_DECLARATION_COUNT"
printf "Scenario declaration count:     %s\n" "$SCENARIO_DECLARATION_COUNT"
printf "Config hash declaration count:  %s\n" "$CONFIG_HASH_DECLARATION_COUNT"
printf "Installation gate count:        %s\n" "$INSTALLATION_GATE_DECLARATION_COUNT"
printf "Configurazione profilo:         %s (rc=%s)\n" "$PROFILE_CONFIG_STATUS" "$CONFIG_RC"
printf "Errore profilo:                 %s\n" "${PROFILE_ERROR_CODE:-NOT_AVAILABLE}"
printf "Osservabilita' profilo:         %s\n" "$OBSERVABILITY_STATUS"
printf "Logger signal lines:            %s\n" "$LOGGER_SIGNAL_LINES"
printf "Logger Counter lines:           %s\n" "$LOGGER_COUNTER_LINES"
printf "Logger Time lines:              %s\n" "$LOGGER_TIME_LINES"
printf "Logger CycleTime lines:         %s\n" "$LOGGER_CYCLE_TIME_LINES"
printf "Logger ScalarA lines:           %s\n" "$LOGGER_SCALAR_A_LINES"
printf "Logger ScalarB lines:           %s\n" "$LOGGER_SCALAR_B_LINES"
printf "Logger Vector[3] lines:         %s\n" "$LOGGER_VECTOR_LINES"
printf "Verifica manifest hash:         %s (rc=%s)\n" "$( [ "$HASH_RC" -eq 0 ] && printf PASS || printf FAIL )" "$HASH_RC"
printf "Parser binario:                 %s (rc=%s)\n" "${BINARY_STATUS:-NOT_AVAILABLE}" "$PARSER_RC"
printf "Primo errore parser:            %s\n" "${FIRST_ERROR_CODE:-NOT_AVAILABLE}"
printf "Header osservato:               %s byte\n" "${HEADER_BYTES:-NOT_AVAILABLE}"
printf "Record da header:               %s byte\n" "${RECORD_BYTES:-NOT_AVAILABLE}"
printf "Payload:                        %s byte\n" "${PAYLOAD_BYTES:-NOT_AVAILABLE}"
printf "Residuo payload:                %s byte\n" "${PAYLOAD_REMAINDER_BYTES:-NOT_AVAILABLE}"
printf "Campioni completi:              %s\n" "${COMPLETE_SAMPLE_COUNT:-NOT_AVAILABLE}"
printf "Avvii State1:                   %s\n" "$START_LINES"
printf "Application starting:           %s\n" "$APPLICATION_START_LINES"
printf "Aperture FileWriter:             %s\n" "$FILE_OPEN_LINES"
printf "Exit code MARTe:                %s\n" "$MARTE_EXIT_CODE"
printf "Exit code tee:                  %s\n" "$TEE_EXIT_CODE"
printf "Warning priorita' non applic.:  %s\n" "$PRIORITY_FAIL_LINES"
printf "Warning non classificati:       %s\n" "$UNCLASSIFIED_WARNING_LINES"
printf "FatalError non classificati:    %s\n" "$UNCLASSIFIED_FATAL_LINES"
printf "OSError non classificati:       %s\n" "$UNCLASSIFIED_OS_ERROR_LINES"
printf "Error non classificati:         %s\n" "$ERROR_LINES"
printf "InitialisationError:            %s\n" "$INITIALISATION_ERROR_LINES"
printf "UNCLASSIFIED_WARNING_LINES=%s\n" "$UNCLASSIFIED_WARNING_LINES"
printf "LOGGER_SIGNAL_LINES=%s\n" "$LOGGER_SIGNAL_LINES"
printf "LOGGER_COUNTER_LINES=%s\n" "$LOGGER_COUNTER_LINES"
printf "LOGGER_TIME_LINES=%s\n" "$LOGGER_TIME_LINES"
printf "LOGGER_CYCLE_TIME_LINES=%s\n" "$LOGGER_CYCLE_TIME_LINES"
printf "LOGGER_SCALAR_A_LINES=%s\n" "$LOGGER_SCALAR_A_LINES"
printf "LOGGER_SCALAR_B_LINES=%s\n" "$LOGGER_SCALAR_B_LINES"
printf "LOGGER_VECTOR_LINES=%s\n" "$LOGGER_VECTOR_LINES"

printf "\n--- DETTAGLIO CONFIGURAZIONE PROFILE-AWARE ---\n"
cat -- "$CONFIG_REPORT"
printf "\n--- DETTAGLIO PARSER BINARIO BASELINE ---\n"
cat -- "$BINARY_REPORT"
printf "\n--- VERIFICA HASH ---\n"
cat -- "$HASH_REPORT"

printf "\n--- CONTRATTO S03-H1 ---\n"
emit_contract

if [ "$FUNCTIONAL_STATUS" != "PASS" ]; then
    printf "VALIDATION_RESULT=FUNCTIONAL_NOT_DEMONSTRATED\n"
    exit 20
fi

if [ "$SEMANTIC_STATUS" != "PASS" ]; then
    printf "VALIDATION_RESULT=SEMANTIC_VALIDATION_FAILED\n"
    exit 20
fi

if [ "$SIGINT_LINES" -ge 1 ] &&
   [ "$STOP_OK_LINES" -ge 1 ] &&
   [ "$TERMINATED_LINES" -ge 1 ] &&
   [ "$FATAL_ERROR_LINES" -eq 0 ] &&
   [ "$OS_ERROR_LINES" -eq 0 ] &&
   [ "$ERROR_LINES" -eq 0 ] &&
   [ "$INITIALISATION_ERROR_LINES" -eq 0 ]; then
    printf "VALIDATION_RESULT=PASS_CLEAN_SHUTDOWN\n"
    exit 0
fi

KNOWN_SHUTDOWN_TOTAL=$((
    DOUBLE_STOP_LINES +
    ASYNC_EVENTSEM_CLOSE_LINES +
    PTHREAD_MUTEX_DESTROY_LINES
))
if [ "$SIGINT_LINES" -ge 1 ] &&
   [ "$STOP_OK_LINES" -ge 1 ] &&
   [ "$TERMINATED_LINES" -ge 1 ] &&
   [ "$KNOWN_SHUTDOWN_TOTAL" -ge 1 ] &&
   [ "$UNCLASSIFIED_FATAL_LINES" -eq 0 ] &&
   [ "$UNCLASSIFIED_OS_ERROR_LINES" -eq 0 ] &&
   [ "$ERROR_LINES" -eq 0 ] &&
   [ "$INITIALISATION_ERROR_LINES" -eq 0 ]; then
    printf "VALIDATION_RESULT=PASS_KNOWN_SHUTDOWN_ANOMALY\n"
    exit 10
fi

printf "VALIDATION_RESULT=PASS_UNCLASSIFIED_SHUTDOWN_ANOMALY\n"
exit 11