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

LAUNCHER_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
CANDIDATE_ROOT="$(cd "$LAUNCHER_DIR/.." && pwd)"

if [ -n "${MARTE_BENCHMARK_SUITE_ROOT:-}" ]; then
    SUITE="$(cd "$MARTE_BENCHMARK_SUITE_ROOT" && pwd)"
else
    SUITE="/home/dariodf/Scrivania/MARTE/marte-benchmark-suite"
fi

PATCHER="$CANDIDATE_ROOT/patchers/configuration/build_s03h1_from_s02.sh"
VALIDATOR="$CANDIDATE_ROOT/scenarios/S03H1_execution_profiles/validate.sh"
CONFIG_VERIFIER="$CANDIDATE_ROOT/scenarios/S03H1_execution_profiles/verify_s03h1_config.py"
CSV_EXPORTER="$CANDIDATE_ROOT/scenarios/S03H1_execution_profiles/export_s03_csv.py"
TEST_CONFIG="$CANDIDATE_ROOT/configurations/generated/S03H1/from_patcher/smoke_s03h1_execution_profiles_test_from_s02.marte"
DIAGNOSTIC_CONFIG="$CANDIDATE_ROOT/configurations/generated/S03H1/from_patcher/smoke_s03h1_execution_profiles_diagnostic_from_s02.marte"

RUNNER="$SUITE/common/marte_runner.sh"
LIVE_PATHS="$SUITE/common/paths.sh"
LIVE_ENVIRONMENT="$SUITE/common/environment.sh"
LIVE_OPERATIONAL_LAUNCHER="$SUITE/launcher/marte_benchmark_launcher.sh"
LIVE_PATCHER_S01="$SUITE/patchers/configuration/build_s01_from_s00.sh"
LIVE_PATCHER_S02="$SUITE/patchers/configuration/build_s02_from_s01.sh"
LIVE_PATCHER_S03="$SUITE/patchers/configuration/build_s03_from_s02.sh"
LIVE_VALIDATOR_S02="$SUITE/scenarios/S02_binary_recording/validate.sh"
LIVE_VALIDATOR_S03="$SUITE/scenarios/S03_semantic_sentinels/validate.sh"
LIVE_PARSER_S03="$SUITE/scenarios/S03_semantic_sentinels/parse_s03_binary.py"
LIVE_S00_CONFIG="$SUITE/configurations/generated/S00/smoke_s0_core.marte"
LIVE_S01_CONFIG="$SUITE/configurations/generated/S01/from_patcher/smoke_s1_timing_from_s00.marte"
LIVE_S02_CONFIG="$SUITE/configurations/generated/S02/from_patcher/smoke_s2_binary_recording_from_s01.marte"
LIVE_S03_CONFIG="$SUITE/configurations/generated/S03/from_patcher/smoke_s3_semantic_sentinels_from_s02.marte"

EXPECTED_TEST_CONFIG_SHA256="d037561b32760fbd0e2aec9f1eefc5efda27b1918eca4742c89092a8a2f7e92e"
EXPECTED_DIAGNOSTIC_CONFIG_SHA256="cd999ff249452298d650a22c8fe5b0b03bf48c0735f4630befdec8209cbb13a3"
EXPECTED_PATCHER_SHA256="5db5f71db4ab8f007b2e78230c2506bed4c62a8e502fb1c08ca04eb14b645b82"
EXPECTED_VALIDATOR_SHA256="748f403a045f9dbed64910de67e75ba5529c02ab5894417a866225518c10b5e5"
EXPECTED_CONFIG_VERIFIER_SHA256="2f1c41b186bd2e79a9fb51fab0461a7a0dce104bf0852c0ec1ade2c55a017443"
EXPECTED_CSV_EXPORTER_SHA256="b413ad113e188141891b61b930a607890b8468051e8a61cb0f0454c519a51fb7"

print_usage() {
    printf "Uso:\n"
    printf "  %s S03H1 <durata-secondi> TEST\n" "$0"
    printf "  %s S03H1 <durata-secondi> DIAGNOSTIC\n" "$0"
    printf "\n"
    printf "La candidata non installa e non modifica la baseline S03 R3.\n"
}

fail() {
    code="$1"
    shift
    printf "S03_H1_LAUNCHER_STATUS=FAIL\n" >&2
    printf "S03_H1_LAUNCHER_ERROR=%s\n" "$*" >&2
    exit "$code"
}

validate_duration() {
    candidate_duration="$1"
    case "$candidate_duration" in
        *[!0-9]*|"")
            return 1
            ;;
    esac
    [ "$candidate_duration" -gt 0 ]
}

verify_hash() {
    candidate_file="$1"
    candidate_expected="$2"
    candidate_label="$3"
    if [ ! -f "$candidate_file" ]; then
        printf "HASH_CHECK=%s STATUS=MISSING FILE=%s\n" \
            "$candidate_label" "$candidate_file" >&2
        return 1
    fi
    candidate_actual="$(sha256sum -- "$candidate_file" | awk '{print $1}')"
    printf "HASH_CHECK=%s EXPECTED=%s ACTUAL=%s FILE=%s\n" \
        "$candidate_label" "$candidate_expected" "$candidate_actual" "$candidate_file"
    [ "$candidate_actual" = "$candidate_expected" ]
}

verify_candidate_components() {
    verify_hash "$PATCHER" "$EXPECTED_PATCHER_SHA256" "S03H1_PATCHER" || return 1
    verify_hash "$VALIDATOR" "$EXPECTED_VALIDATOR_SHA256" "S03H1_VALIDATOR" || return 1
    verify_hash "$CONFIG_VERIFIER" "$EXPECTED_CONFIG_VERIFIER_SHA256" "S03H1_CONFIG_VERIFIER" || return 1
    verify_hash "$CSV_EXPORTER" "$EXPECTED_CSV_EXPORTER_SHA256" "S03H1_CSV_EXPORTER" || return 1
    verify_hash "$CANDIDATE_CONFIG" "$EXPECTED_CANDIDATE_CONFIG_SHA256" "S03H1_${MODE}_CONFIG" || return 1
    return 0
}

PROTECTED_PATHS=(
    "$LIVE_OPERATIONAL_LAUNCHER"
    "$LIVE_S00_CONFIG"
    "$LIVE_S01_CONFIG"
    "$LIVE_S02_CONFIG"
    "$LIVE_S03_CONFIG"
    "$LIVE_PATCHER_S01"
    "$LIVE_PATCHER_S02"
    "$LIVE_PATCHER_S03"
    "$LIVE_VALIDATOR_S02"
    "$LIVE_VALIDATOR_S03"
    "$LIVE_PARSER_S03"
    "$RUNNER"
    "$LIVE_PATHS"
    "$LIVE_ENVIRONMENT"
)
PROTECTED_EXPECTED_HASHES=(
    "7ef0419826c85c0364aad2403db4b8340cd815e9d9ce17edfbe5da8e6fbf2683"
    "49a9b48595aab88cd8fd11d1e58ace4ab11d7d0a649e9b143bdc25c8866253d5"
    "1513e1ca72eba56d53079ac7328908f12ddc72772456e2d75bcbacb6465d2427"
    "8ecc8ba55e46e9f6fb8f304404d4070ff4c2ea5b9c783a69113bc08b457859d1"
    "0f8916735ff67a9be2b167b52f147687fe131a063f410a81bfbf3bf9ff65f1e4"
    "a8cced1ea1711806863606e27c3ba52a3e72794dbe8c36c253570709ce3f7ccb"
    "8ac51d09f6f7984af3522e373bab59e2553775c418f69a53ccb93d8d1b893391"
    "96c778ba6a15353fd969b19960706d7c0ca810c0c6fd61a14b5f88960e4e2b7a"
    "7cd29b216b5edc3c72750a3326aebe5a9fdfb3b7522f1d7a6e8b0a1a97b3d60a"
    "95caf207c4d29037c4973d756ff5a7004a3360aad9656d068948e222a4ba0c98"
    "91c4d66770197e1986ed91eb6a4870e7da7df5a522ffdf4329b6d9250f238307"
    "9e4f1a6b0dabc244fd0726fd18bf07e86b29a9fc6a76d54fcaf61c79f13c9633"
    "468d92c3eb048b7137ea52a768f459d2d1f26f83f5a5c174d3333d032c9583c6"
    "b1faa567e480c326c72107b886f387f108907900804621337524f1f856f056ac"
)

verify_protected_baseline() {
    candidate_index=0
    while [ "$candidate_index" -lt "${#PROTECTED_PATHS[@]}" ]; do
        verify_hash \
            "${PROTECTED_PATHS[$candidate_index]}" \
            "${PROTECTED_EXPECTED_HASHES[$candidate_index]}" \
            "PROTECTED_${candidate_index}" || return 1
        candidate_index=$((candidate_index + 1))
    done
    return 0
}

write_protected_hashes() {
    candidate_destination="$1"
    sha256sum -- "${PROTECTED_PATHS[@]}" >"$candidate_destination"
}

parse_contract_field() {
    candidate_field="$1"
    candidate_file="$2"
    PARSED_FIELD_VALUE=""
    PARSED_FIELD_ERROR=""
    if [ ! -f "$candidate_file" ]; then
        PARSED_FIELD_ERROR="NO_FILE"
        return 1
    fi
    candidate_count="$(grep -Ec "^${candidate_field}=[A-Z][A-Z0-9_]*$" "$candidate_file" || true)"
    candidate_any_count="$(grep -Ec "^${candidate_field}=" "$candidate_file" || true)"
    if [ "$candidate_any_count" -eq 0 ]; then
        PARSED_FIELD_ERROR="MISSING"
        return 1
    fi
    if [ "$candidate_any_count" -ne 1 ]; then
        PARSED_FIELD_ERROR="DUPLICATED"
        return 1
    fi
    if [ "$candidate_count" -ne 1 ]; then
        PARSED_FIELD_ERROR="MALFORMED"
        return 1
    fi
    PARSED_FIELD_VALUE="$(sed -n "s/^${candidate_field}=//p" "$candidate_file")"
    return 0
}

classify_s03h1_run() {
    classify_validator_rc="$1"
    classify_tee_rc="$2"
    classify_validation_file="$3"
    classify_csv_rc="$4"
    classify_invariance_status="$5"

    FINAL_RC=20
    FINAL_RESULT="INCONCLUSIVE"
    BLOCK_REASON="NONE"
    PARSED_MODE_STATUS="NOT_EVALUATED"
    PARSED_PROFILE_CONFIG_STATUS="NOT_EVALUATED"
    PARSED_OBSERVABILITY_STATUS="NOT_EVALUATED"
    PARSED_FUNCTIONAL_STATUS="NOT_EVALUATED"
    PARSED_SEMANTIC_STATUS="NOT_EVALUATED"
    PARSED_TIMING_STATUS="NOT_EVALUATED"
    PARSED_MEASUREMENT_ELIGIBILITY="NOT_EVALUATED"

    if [ "$classify_tee_rc" -ne 0 ]; then
        FINAL_RC=67
        FINAL_RESULT="FAIL_VALIDATION_LOG"
        BLOCK_REASON="VALIDATION_LOG_NOT_WRITTEN"
        return 0
    fi

    CONTRACT_PARSE_ERROR="NONE"
    for candidate_field in \
        MODE_STATUS \
        PROFILE_CONFIG_STATUS \
        OBSERVABILITY_STATUS \
        FUNCTIONAL_STATUS \
        SEMANTIC_STATUS \
        TIMING_STATUS \
        MEASUREMENT_ELIGIBILITY
    do
        if parse_contract_field "$candidate_field" "$classify_validation_file"; then
            case "$candidate_field" in
                MODE_STATUS) PARSED_MODE_STATUS="$PARSED_FIELD_VALUE" ;;
                PROFILE_CONFIG_STATUS) PARSED_PROFILE_CONFIG_STATUS="$PARSED_FIELD_VALUE" ;;
                OBSERVABILITY_STATUS) PARSED_OBSERVABILITY_STATUS="$PARSED_FIELD_VALUE" ;;
                FUNCTIONAL_STATUS) PARSED_FUNCTIONAL_STATUS="$PARSED_FIELD_VALUE" ;;
                SEMANTIC_STATUS) PARSED_SEMANTIC_STATUS="$PARSED_FIELD_VALUE" ;;
                TIMING_STATUS) PARSED_TIMING_STATUS="$PARSED_FIELD_VALUE" ;;
                MEASUREMENT_ELIGIBILITY) PARSED_MEASUREMENT_ELIGIBILITY="$PARSED_FIELD_VALUE" ;;
            esac
        elif [ "$CONTRACT_PARSE_ERROR" = "NONE" ]; then
            CONTRACT_PARSE_ERROR="${candidate_field}_${PARSED_FIELD_ERROR}"
        fi
    done

    if [ "$CONTRACT_PARSE_ERROR" != "NONE" ]; then
        FINAL_RC=22
        FINAL_RESULT="INCONCLUSIVE_S03H1_CONTRACT"
        BLOCK_REASON="$CONTRACT_PARSE_ERROR"
        return 0
    fi
    if [ "$PARSED_MEASUREMENT_ELIGIBILITY" != "NO" ]; then
        FINAL_RC=22
        FINAL_RESULT="INCONCLUSIVE_S03H1_CONTRACT"
        BLOCK_REASON="ELIGIBILITY_CONTRACT_VIOLATION_${PARSED_MEASUREMENT_ELIGIBILITY}"
        return 0
    fi
    if [ "$classify_invariance_status" != "PASS" ]; then
        FINAL_RC=71
        FINAL_RESULT="FAIL_PROTECTED_BASELINE_CHANGED"
        BLOCK_REASON="PROTECTED_BASELINE_INVARIANCE_${classify_invariance_status}"
        return 0
    fi
    if [ "$classify_csv_rc" -ne 0 ]; then
        FINAL_RC=70
        FINAL_RESULT="FAIL_DERIVED_CSV_EXPORT"
        BLOCK_REASON="CSV_EXPORT_RC_${classify_csv_rc}"
        return 0
    fi

    case "$classify_validator_rc" in
        0|10|11)
            ;;
        20|21)
            FINAL_RC=20
            FINAL_RESULT="S03H1_VALIDATION_INCONCLUSIVE"
            BLOCK_REASON="VALIDATOR_RC_${classify_validator_rc}"
            return 0
            ;;
        *)
            FINAL_RC=68
            FINAL_RESULT="FAIL_VALIDATOR_EXIT"
            BLOCK_REASON="UNRECOGNISED_VALIDATOR_RC_${classify_validator_rc}"
            return 0
            ;;
    esac

    for candidate_status in \
        "$PARSED_MODE_STATUS" \
        "$PARSED_PROFILE_CONFIG_STATUS" \
        "$PARSED_OBSERVABILITY_STATUS" \
        "$PARSED_FUNCTIONAL_STATUS" \
        "$PARSED_SEMANTIC_STATUS"
    do
        if [ "$candidate_status" != "PASS" ]; then
            FINAL_RC=25
            FINAL_RESULT="S03H1_CONTRACT_STATUS_NOT_PASS"
            BLOCK_REASON="REQUIRED_STATUS_${candidate_status}"
            return 0
        fi
    done

    case "$PARSED_TIMING_STATUS" in
        NOT_VALID_*)
            FINAL_RC=14
            FINAL_RESULT="FUNCTIONAL_AND_SEMANTIC_PASS_TIMING_NOT_VALID"
            BLOCK_REASON="$PARSED_TIMING_STATUS"
            ;;
        UNASSESSED_*)
            FINAL_RC=15
            FINAL_RESULT="FUNCTIONAL_AND_SEMANTIC_PASS_TIMING_UNASSESSED"
            BLOCK_REASON="$PARSED_TIMING_STATUS"
            ;;
        *)
            FINAL_RC=22
            FINAL_RESULT="INCONCLUSIVE_TIMING_CONTRACT"
            BLOCK_REASON="TIMING_STATUS_${PARSED_TIMING_STATUS}"
            ;;
    esac
    return 0
}

run_s03h1() {
    duration="$1"
    MODE="$2"

    case "$MODE" in
        TEST)
            CANDIDATE_CONFIG="$TEST_CONFIG"
            EXPECTED_CANDIDATE_CONFIG_SHA256="$EXPECTED_TEST_CONFIG_SHA256"
            ;;
        DIAGNOSTIC)
            CANDIDATE_CONFIG="$DIAGNOSTIC_CONFIG"
            EXPECTED_CANDIDATE_CONFIG_SHA256="$EXPECTED_DIAGNOSTIC_CONFIG_SHA256"
            ;;
        *)
            printf "ERRORE: MODE non riconosciuto: %s\n" "$MODE" >&2
            return 2
            ;;
    esac

    if [ ! -d "$SUITE" ]; then
        printf "ERRORE: suite operativa assente: %s\n" "$SUITE" >&2
        return 50
    fi
    if ! verify_candidate_components; then
        printf "ERRORE: integrita' candidata non dimostrata.\n" >&2
        return 51
    fi
    if ! verify_protected_baseline; then
        printf "ERRORE: baseline protetta assente o con hash inatteso.\n" >&2
        return 52
    fi

    WORK_ROOT="$(mktemp -d "${TMPDIR:-/tmp}/s03h1_launcher.XXXXXX")" || return 53
    trap 'rm -rf -- "$WORK_ROOT"' EXIT HUP INT TERM
    GENERATED_CONFIG="$WORK_ROOT/generated_${MODE}.marte"
    PATCHER_LOG="$WORK_ROOT/patcher.log"
    PROTECTED_BEFORE="$WORK_ROOT/protected_baseline_before.sha256"
    CAPTURE="$WORK_ROOT/runner_capture.log"

    "$PATCHER" "$LIVE_S02_CONFIG" "$GENERATED_CONFIG" "$MODE" >"$PATCHER_LOG" 2>&1
    PATCHER_RC=$?
    if [ "$PATCHER_RC" -ne 0 ]; then
        printf "ERRORE: patcher candidato fallito rc=%s\n" "$PATCHER_RC" >&2
        cat -- "$PATCHER_LOG" >&2
        return 54
    fi
    if ! cmp -s -- "$GENERATED_CONFIG" "$CANDIDATE_CONFIG"; then
        printf "ERRORE: build candidato non coincide con config confezionata.\n" >&2
        return 55
    fi

    write_protected_hashes "$PROTECTED_BEFORE" || return 56

    if [ ! -f "$LIVE_PATHS" ]; then
        printf "ERRORE: paths.sh assente: %s\n" "$LIVE_PATHS" >&2
        return 57
    fi
    # shellcheck source=/dev/null
    source "$LIVE_PATHS"
    CONSTANT_GAM_LIB_DIR="$MARTE2_COMPONENTS_ROOT/Build/$MARTE_TARGET/Components/GAMs/ConstantGAM"
    CONSTANT_GAM_LIB="$CONSTANT_GAM_LIB_DIR/ConstantGAM.so"
    if [ ! -f "$CONSTANT_GAM_LIB" ]; then
        printf "ERRORE: ConstantGAM assente: %s\n" "$CONSTANT_GAM_LIB" >&2
        return 58
    fi
    case ":${LD_LIBRARY_PATH-}:" in
        *":${CONSTANT_GAM_LIB_DIR}:"*) ;;
        *)
            if [ -n "${LD_LIBRARY_PATH-}" ]; then
                LD_LIBRARY_PATH="${CONSTANT_GAM_LIB_DIR}:${LD_LIBRARY_PATH}"
            else
                LD_LIBRARY_PATH="$CONSTANT_GAM_LIB_DIR"
            fi
            ;;
    esac
    export LD_LIBRARY_PATH

    printf "============================================================\n"
    printf "S03-H1 EXECUTION PROFILES - RUN CANDIDATA\n"
    printf "============================================================\n"
    printf "MODE=%s\n" "$MODE"
    printf "DURATION=%s\n" "$duration"
    printf "CURRENT_OPERATIONAL_BASELINE=S03_R3_INSTALLED\n"
    printf "S03_H1_INSTALLATION_AUTHORIZED=NO\n"

    "$RUNNER" \
        "S03H1_${MODE}_launcher" \
        "$CANDIDATE_CONFIG" \
        "State1" \
        "$duration" \
        2>&1 | tee "$CAPTURE"
    RUNNER_CODES=("${PIPESTATUS[@]}")
    RUNNER_RC="${RUNNER_CODES[0]}"
    CAPTURE_TEE_RC="${RUNNER_CODES[1]}"
    if [ "$RUNNER_RC" -ne 0 ]; then
        printf "ERRORE: common runner fallito rc=%s\n" "$RUNNER_RC" >&2
        return 60
    fi
    if [ "$CAPTURE_TEE_RC" -ne 0 ]; then
        printf "ERRORE: capture common runner fallita.\n" >&2
        return 61
    fi

    RUN_DIR="$(sed -n 's/^RUN_DIR=//p' "$CAPTURE" | tail -n 1)"
    if [ -z "$RUN_DIR" ] || [ ! -d "$RUN_DIR" ]; then
        printf "ERRORE: RUN_DIR non individuata o assente: %s\n" "$RUN_DIR" >&2
        return 62
    fi

    RUN_LOG="$RUN_DIR/run.log"
    RUNNER_SUMMARY="$RUN_DIR/runner_summary.txt"
    RUN_HASHES="$RUN_DIR/hashes.sha256"
    OUTPUT_FILE="$RUN_DIR/s03_output.bin"
    CSV_FILE="$RUN_DIR/s03_output.csv"
    MODE_FILE="$RUN_DIR/s03h1_mode.txt"
    VALIDATION_LOG="$RUN_DIR/validation.txt"
    CSV_REPORT="$RUN_DIR/csv_export.txt"
    LAUNCHER_SUMMARY="$RUN_DIR/launcher_summary.txt"
    PROTECTED_BEFORE_RUN="$RUN_DIR/protected_baseline_before.sha256"
    PROTECTED_AFTER_RUN="$RUN_DIR/protected_baseline_after.sha256"
    INVARIANCE_REPORT="$RUN_DIR/protected_baseline_invariance.txt"

    cp -- "$PROTECTED_BEFORE" "$PROTECTED_BEFORE_RUN"
    {
        printf "SCENARIO=S03H1\n"
        printf "MODE=%s\n" "$MODE"
        printf "CANDIDATE_CONFIG_SHA256=%s\n" "$EXPECTED_CANDIDATE_CONFIG_SHA256"
        printf "S03_H1_INSTALLATION_AUTHORIZED=NO\n"
    } >"$MODE_FILE"

    sha256sum -- \
        "$MODE_FILE" \
        "${BASH_SOURCE[0]}" \
        "$PATCHER" \
        "$VALIDATOR" \
        "$CONFIG_VERIFIER" \
        "$CSV_EXPORTER" \
        "$LIVE_PARSER_S03" \
        "$RUN_LOG" \
        "$RUNNER_SUMMARY" \
        "$OUTPUT_FILE" \
        "$PROTECTED_BEFORE_RUN" \
        "${PROTECTED_PATHS[@]}" \
        >>"$RUN_HASHES"

    S03_BASELINE_PARSER="$LIVE_PARSER_S03" \
        timeout 30s "$VALIDATOR" "$MODE" "$RUN_DIR" 2>&1 | tee "$VALIDATION_LOG"
    VALIDATION_CODES=("${PIPESTATUS[@]}")
    VALIDATOR_RC="${VALIDATION_CODES[0]}"
    VALIDATION_TEE_RC="${VALIDATION_CODES[1]}"

    "$CSV_EXPORTER" "$OUTPUT_FILE" "$CSV_FILE" >"$CSV_REPORT" 2>&1
    CSV_RC=$?

    write_protected_hashes "$PROTECTED_AFTER_RUN"
    if cmp -s -- "$PROTECTED_BEFORE_RUN" "$PROTECTED_AFTER_RUN"; then
        PROTECTED_BASELINE_INVARIANCE="PASS"
    else
        PROTECTED_BASELINE_INVARIANCE="FAIL"
    fi
    {
        printf "PROTECTED_BASELINE_INVARIANCE=%s\n" "$PROTECTED_BASELINE_INVARIANCE"
        printf "CURRENT_OPERATIONAL_BASELINE=S03_R3_INSTALLED\n"
        printf "S03_H1_INSTALLATION_AUTHORIZED=NO\n"
    } >"$INVARIANCE_REPORT"

    for evidence_file in \
        "$VALIDATION_LOG" \
        "$CSV_REPORT" \
        "$PROTECTED_AFTER_RUN" \
        "$INVARIANCE_REPORT"
    do
        if [ -f "$evidence_file" ]; then
            sha256sum -- "$evidence_file" >>"$RUN_HASHES"
        fi
    done
    if [ -f "$CSV_FILE" ]; then
        sha256sum -- "$CSV_FILE" >>"$RUN_HASHES"
    fi

    classify_s03h1_run \
        "$VALIDATOR_RC" \
        "$VALIDATION_TEE_RC" \
        "$VALIDATION_LOG" \
        "$CSV_RC" \
        "$PROTECTED_BASELINE_INVARIANCE"

    {
        printf "============================================================\n"
        printf "RIEPILOGO LAUNCHER S03-H1 CANDIDATO\n"
        printf "============================================================\n"
        printf "SCENARIO=S03H1\n"
        printf "MODE=%s\n" "$MODE"
        printf "DURATION=%s\n" "$duration"
        printf "RUN_DIR=%s\n" "$RUN_DIR"
        printf "RUNNER_RC=%s\n" "$RUNNER_RC"
        printf "VALIDATOR_RC=%s\n" "$VALIDATOR_RC"
        printf "CSV_EXPORT_RC=%s\n" "$CSV_RC"
        printf "CSV_STATUS=%s\n" "$( [ "$CSV_RC" -eq 0 ] && printf PASS || printf FAIL )"
        printf "MODE_STATUS=%s\n" "$PARSED_MODE_STATUS"
        printf "PROFILE_CONFIG_STATUS=%s\n" "$PARSED_PROFILE_CONFIG_STATUS"
        printf "OBSERVABILITY_STATUS=%s\n" "$PARSED_OBSERVABILITY_STATUS"
        printf "FUNCTIONAL_STATUS=%s\n" "$PARSED_FUNCTIONAL_STATUS"
        printf "SEMANTIC_STATUS=%s\n" "$PARSED_SEMANTIC_STATUS"
        printf "TIMING_STATUS=%s\n" "$PARSED_TIMING_STATUS"
        printf "MEASUREMENT_ELIGIBILITY=NO\n"
        printf "PROTECTED_BASELINE_INVARIANCE=%s\n" "$PROTECTED_BASELINE_INVARIANCE"
        printf "BLOCK_REASON=%s\n" "$BLOCK_REASON"
        printf "FINAL_RESULT=%s\n" "$FINAL_RESULT"
        printf "FINAL_RC=%s\n" "$FINAL_RC"
        printf "S03_H1_INSTALLATION_AUTHORIZED=NO\n"
        printf "CURRENT_OPERATIONAL_BASELINE=S03_R3_INSTALLED\n"
        printf "PERFORMANCE_MEASUREMENT_AUTHORIZED=NO\n"
        printf "S04_AUTHORIZED=NO\n"
        printf "MD00_AUTHORIZED=NO\n"
    } | tee "$LAUNCHER_SUMMARY"
    SUMMARY_CODES=("${PIPESTATUS[@]}")
    if [ "${SUMMARY_CODES[1]}" -ne 0 ]; then
        FINAL_RC=69
    else
        sha256sum -- "$LAUNCHER_SUMMARY" >>"$RUN_HASHES"
    fi

    printf "RUN_DIR=%s\n" "$RUN_DIR"
    printf "RISULTATO_FINALE=%s\n" "$FINAL_RESULT"
    printf "FINAL_RC=%s\n" "$FINAL_RC"

    rm -rf -- "$WORK_ROOT"
    trap - EXIT HUP INT TERM
    return "$FINAL_RC"
}

if [ "${S03H1_LAUNCHER_LIB_ONLY:-0}" = "1" ]; then
    if [ "${BASH_SOURCE[0]}" != "$0" ]; then
        return 0
    fi
    printf "ERRORE: S03H1_LAUNCHER_LIB_ONLY=1 e' ammesso solo con source.\n" >&2
    exit 3
fi

case "$#" in
    1)
        case "$1" in
            -h|--help)
                print_usage
                exit 0
                ;;
            *)
                print_usage >&2
                exit 2
                ;;
        esac
        ;;
    3)
        if [ "$1" != "S03H1" ] && [ "$1" != "s03h1" ]; then
            print_usage >&2
            exit 2
        fi
        if ! validate_duration "$2"; then
            printf "ERRORE: durata non valida: %s\n" "$2" >&2
            exit 2
        fi
        case "$3" in
            TEST|DIAGNOSTIC) ;;
            *)
                printf "ERRORE: MODE non riconosciuto: %s\n" "$3" >&2
                exit 2
                ;;
        esac
        run_s03h1 "$2" "$3"
        exit $?
        ;;
    *)
        print_usage >&2
        exit 2
        ;;
esac