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

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

INPUT_PATH="$1"

if [ -d "$INPUT_PATH" ]; then
    RUN_DIR="$(cd "$INPUT_PATH" >/dev/null 2>&1 && pwd)"
    RUN_LOG="$RUN_DIR/run.log"
elif [ -f "$INPUT_PATH" ]; then
    RUN_LOG="$(cd "$(dirname "$INPUT_PATH")" >/dev/null 2>&1 && pwd)/$(basename "$INPUT_PATH")"
    RUN_DIR="$(dirname "$RUN_LOG")"
else
    printf "[NON DIMOSTRATO] Percorso di validazione non trovato: %s\n" "$INPUT_PATH" >&2
    exit 21
fi

RUN_CONFIG="$RUN_DIR/configuration.marte"
OUTPUT_FILE="$RUN_DIR/s02_output.bin"
RUNNER_SUMMARY="$RUN_DIR/runner_summary.txt"

for required_file in "$RUN_LOG" "$RUN_CONFIG" "$OUTPUT_FILE"; do
    if [ ! -f "$required_file" ]; then
        printf "[NON DIMOSTRATO] File richiesto assente: %s\n" "$required_file" >&2
        exit 21
    fi
done

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

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")"
NO_ERROR_LINES="$(count_lines '^\[NoError ' "$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")"
UNCLASSIFIED_WARNING_LINES=$((WARNING_LINES - PRIORITY_CLIP_LINES - PRIORITY_FAIL_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

PLACEHOLDER_COUNT="$(grep -o '__MARTE_RUN_DIR__' "$RUN_CONFIG" 2>/dev/null | wc -l)"
NAMESPACED_CLASS_COUNT="$(count_lines '^[[:space:]]*Class = FileDataSource::FileWriter[[:space:]]*$' "$RUN_CONFIG")"
PLAIN_CLASS_COUNT="$(count_lines '^[[:space:]]*Class = FileWriter[[:space:]]*$' "$RUN_CONFIG")"
EXPECTED_FILENAME="$RUN_DIR/s02_output.bin"
FILENAME_MATCH_LINES="$(
    python3 - "$RUN_CONFIG" "$EXPECTED_FILENAME" <<'PYCONFIG'
import sys
from pathlib import Path

config_path = Path(sys.argv[1])
expected = f'Filename = "{sys.argv[2]}"'
count = sum(
    1
    for line in config_path.read_text(encoding="utf-8").splitlines()
    if line.strip() == expected
)
print(count)
PYCONFIG
)"

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

case "$MARTE_EXIT_CODE" in
    124)
        MARTE_EXIT_CLASS="TIMEOUT_EXIT_124"
        ;;
    137)
        MARTE_EXIT_CLASS="EXIT_137_SIGKILL"
        ;;
    0)
        MARTE_EXIT_CLASS="EXIT_0"
        ;;
    NOT_AVAILABLE)
        MARTE_EXIT_CLASS="NOT_AVAILABLE"
        ;;
    *)
        MARTE_EXIT_CLASS="OTHER_EXIT_CODE"
        ;;
esac

CONFIG_REPORT="$(mktemp "${TMPDIR:-/tmp}/s02_validator_config_XXXXXX.log")"
BINARY_REPORT="$(mktemp "${TMPDIR:-/tmp}/s02_validator_binary_XXXXXX.log")"
trap 'rm -f -- "$CONFIG_REPORT" "$BINARY_REPORT"' EXIT

python3 - "$RUN_CONFIG" >"$CONFIG_REPORT" 2>&1 <<'PYCONFIGOBS'
import re
import sys
from decimal import Decimal, InvalidOperation
from pathlib import Path


class Node:
    def __init__(self, name):
        self.name = name.lstrip("+$")
        self.properties = {}


def sanitise(text):
    """Remove comments while preserving strings, braces and line boundaries."""
    output = []
    index = 0
    quote = None
    block_comment = False
    while index < len(text):
        char = text[index]
        next_char = text[index + 1] if index + 1 < len(text) else ""
        if block_comment:
            if char == "*" and next_char == "/":
                block_comment = False
                output.extend("  ")
                index += 2
            else:
                output.append("\n" if char == "\n" else " ")
                index += 1
            continue
        if quote:
            output.append(char)
            if char == "\\" and index + 1 < len(text):
                output.append(text[index + 1])
                index += 2
                continue
            if char == quote:
                quote = None
            index += 1
            continue
        if char in {'"', "'"}:
            quote = char
            output.append(char)
            index += 1
            continue
        if char == "/" and next_char == "*":
            block_comment = True
            output.extend("  ")
            index += 2
            continue
        if char == "/" and next_char == "/":
            while index < len(text) and text[index] != "\n":
                output.append(" ")
                index += 1
            continue
        if char == "#":
            while index < len(text) and text[index] != "\n":
                output.append(" ")
                index += 1
            continue
        output.append(char)
        index += 1
    return "".join(output)


def braces_outside_strings(line):
    result = []
    quote = None
    index = 0
    while index < len(line):
        char = line[index]
        if quote:
            if char == "\\" and index + 1 < len(line):
                index += 2
                continue
            if char == quote:
                quote = None
        elif char in {'"', "'"}:
            quote = char
        elif char in "{}":
            result.append(char)
        index += 1
    return result


text = Path(sys.argv[1]).read_text(encoding="utf-8")
clean = sanitise(text)
nodes = []
stack = []
object_open = re.compile(r"^\s*([+$]?[A-Za-z_][A-Za-z0-9_.:-]*)\s*=\s*\{")
assignment = re.compile(r"^\s*([A-Za-z_][A-Za-z0-9_]*)\s*=\s*(.*?)\s*$")

for line in clean.splitlines():
    match = object_open.match(line)
    if match:
        node = Node(match.group(1))
        nodes.append(node)
        stack.append(node)
    elif stack:
        match = assignment.match(line)
        if match and not match.group(2).startswith("{"):
            stack[-1].properties[match.group(1)] = match.group(2).strip()

    opens_and_closes = braces_outside_strings(line)
    opening_already_consumed = bool(match and object_open.match(line))
    if opening_already_consumed:
        removed = False
        adjusted = []
        for brace in opens_and_closes:
            if brace == "{" and not removed:
                removed = True
                continue
            adjusted.append(brace)
        opens_and_closes = adjusted
    for brace in opens_and_closes:
        if brace == "{":
            stack.append(Node("<anonymous>"))
        elif stack:
            stack.pop()


def report_objects(prefix, classes, property_name):
    matches = [node for node in nodes if node.properties.get("Class") in classes]
    names = ",".join(node.name for node in matches) or "NOT_AVAILABLE_OBJECT_NOT_FOUND"
    affinities = []
    for node in matches:
        value = node.properties.get(property_name, "NOT_EXPLICITLY_CONFIGURED")
        affinities.append(f"{node.name}={value}")
    affinity = ",".join(affinities) or "NOT_AVAILABLE_OBJECT_NOT_FOUND"
    print(f"{prefix}_OBJECT_COUNT={len(matches)}")
    print(f"{prefix}_OBJECT_NAMES={names}")
    print(f"{prefix}_AFFINITY={affinity}")


report_objects("REALTIME_THREAD", {"RealTimeThread"}, "CPUs")
report_objects("FILE_WRITER", {"FileDataSource::FileWriter", "FileWriter"}, "CPUMask")
report_objects("LINUX_TIMER", {"LinuxTimer"}, "CPUMask")

frequency_values = []
for node in nodes:
    raw = node.properties.get("Frequency")
    if raw is None:
        continue
    raw = raw.strip().strip('"').strip("'")
    try:
        value = Decimal(raw)
    except InvalidOperation:
        continue
    if value > 0:
        frequency_values.append(value)

unique_frequencies = sorted(set(frequency_values))
if len(unique_frequencies) == 1:
    frequency = unique_frequencies[0]
    period = Decimal(1_000_000) / frequency
    period_text = str(int(period)) if period == period.to_integral_value() else format(period, ".6f").rstrip("0").rstrip(".")
    frequency_text = format(frequency, "f").rstrip("0").rstrip(".") if "." in format(frequency, "f") else format(frequency, "f")
    print(f"DT_NOMINAL_PERIOD_US={period_text}")
    print(f"DT_NOMINAL_SOURCE=CONFIG_FREQUENCY_{frequency_text}_HZ")
elif not unique_frequencies:
    print("DT_NOMINAL_PERIOD_US=NOT_AVAILABLE")
    print("DT_NOMINAL_SOURCE=NOT_AVAILABLE_NO_POSITIVE_FREQUENCY")
else:
    print("DT_NOMINAL_PERIOD_US=NOT_AVAILABLE")
    print("DT_NOMINAL_SOURCE=NOT_AVAILABLE_MULTIPLE_FREQUENCIES")

print("CONFIG_OBSERVABILITY_STATUS=PASS")
PYCONFIGOBS

CONFIG_RC=$?

config_value() {
    key="$1"
    sed -n "s/^${key}=//p" "$CONFIG_REPORT" | tail -n 1
}

CONFIG_OBSERVABILITY_STATUS="$(config_value CONFIG_OBSERVABILITY_STATUS)"
REALTIME_THREAD_OBJECT_COUNT="$(config_value REALTIME_THREAD_OBJECT_COUNT)"
REALTIME_THREAD_OBJECT_NAMES="$(config_value REALTIME_THREAD_OBJECT_NAMES)"
REALTIME_THREAD_AFFINITY="$(config_value REALTIME_THREAD_AFFINITY)"
FILE_WRITER_OBJECT_COUNT="$(config_value FILE_WRITER_OBJECT_COUNT)"
FILE_WRITER_OBJECT_NAMES="$(config_value FILE_WRITER_OBJECT_NAMES)"
FILE_WRITER_AFFINITY="$(config_value FILE_WRITER_AFFINITY)"
LINUX_TIMER_OBJECT_COUNT="$(config_value LINUX_TIMER_OBJECT_COUNT)"
LINUX_TIMER_OBJECT_NAMES="$(config_value LINUX_TIMER_OBJECT_NAMES)"
LINUX_TIMER_AFFINITY="$(config_value LINUX_TIMER_AFFINITY)"
DT_NOMINAL_PERIOD_US="$(config_value DT_NOMINAL_PERIOD_US)"
DT_NOMINAL_SOURCE="$(config_value DT_NOMINAL_SOURCE)"

python3 - "$OUTPUT_FILE" "${DT_NOMINAL_PERIOD_US:-NOT_AVAILABLE}" >"$BINARY_REPORT" 2>&1 <<'PY'
from collections import Counter
from decimal import Decimal, InvalidOperation
import struct
import sys
from pathlib import Path

path = Path(sys.argv[1])
nominal_period_raw = sys.argv[2]
data = path.read_bytes()

expected_names = [
    "Counter",
    "Time",
    "State1_Thread1_CycleTime",
]
expected_type_hex = "0408"
expected_signals = len(expected_names)
signal_header_bytes = 2 + 32 + 4

print(f"FILE_SIZE_BYTES={len(data)}")

if len(data) < 4:
    print("BINARY_STATUS=FAIL_HEADER_TOO_SMALL")
    sys.exit(31)

number_of_signals = struct.unpack_from("<I", data, 0)[0]
print(f"NUMBER_OF_SIGNALS={number_of_signals}")

if number_of_signals != expected_signals:
    print("BINARY_STATUS=FAIL_SIGNAL_COUNT")
    sys.exit(32)

offset = 4
names = []
type_hex_values = []
elements = []

for index in range(number_of_signals):
    if offset + signal_header_bytes > len(data):
        print(f"TRUNCATED_SIGNAL_HEADER_INDEX={index}")
        print("BINARY_STATUS=FAIL_TRUNCATED_SIGNAL_HEADER")
        sys.exit(33)

    type_bytes = data[offset:offset + 2]
    offset += 2

    raw_name = data[offset:offset + 32]
    offset += 32

    number_of_elements = struct.unpack_from("<I", data, offset)[0]
    offset += 4

    name = raw_name.split(b"\x00", 1)[0].decode("ascii", errors="replace")
    names.append(name)
    type_hex_values.append(type_bytes.hex())
    elements.append(number_of_elements)

    print(f"SIGNAL_{index}_TYPE_HEX={type_bytes.hex()}")
    print(f"SIGNAL_{index}_NAME={name}")
    print(f"SIGNAL_{index}_NUMBER_OF_ELEMENTS={number_of_elements}")

print("SIGNAL_NAMES=" + ",".join(names))

if names != expected_names:
    print("BINARY_STATUS=FAIL_SIGNAL_NAMES")
    sys.exit(34)

if any(value != expected_type_hex for value in type_hex_values):
    print("BINARY_STATUS=FAIL_SIGNAL_TYPES")
    sys.exit(35)

if any(value != 1 for value in elements):
    print("BINARY_STATUS=FAIL_NUMBER_OF_ELEMENTS")
    sys.exit(36)

header_bytes = offset
sample_bytes = expected_signals * 4
payload_bytes = len(data) - header_bytes
remainder_bytes = payload_bytes % sample_bytes
sample_count = payload_bytes // sample_bytes

print(f"HEADER_BYTES={header_bytes}")
print(f"SAMPLE_BYTES={sample_bytes}")
print(f"PAYLOAD_BYTES={payload_bytes}")
print(f"PAYLOAD_REMAINDER_BYTES={remainder_bytes}")
print(f"COMPLETE_SAMPLE_COUNT={sample_count}")

if remainder_bytes != 0:
    print("BINARY_STATUS=FAIL_PAYLOAD_REMAINDER")
    sys.exit(37)

records = [
    struct.unpack_from("<III", data, header_bytes + index * sample_bytes)
    for index in range(sample_count)
]

counters = [record[0] for record in records]
times = [record[1] for record in records]
cycle_times = [record[2] for record in records]

dt_values = [current - previous for previous, current in zip(times, times[1:])]
dt_histogram = Counter(dt_values)
distinct_dt_values = sorted(dt_histogram)
leading_zero_cycle_time_samples = 0
for value in cycle_times:
    if value != 0:
        break
    leading_zero_cycle_time_samples += 1

print(f"DT_INTERVAL_COUNT={len(dt_values)}")
print("DT_DISTINCT_VALUES=" + (",".join(str(value) for value in distinct_dt_values) or "NOT_AVAILABLE"))
print(
    "DT_HISTOGRAM="
    + (",".join(f"{value}:{dt_histogram[value]}" for value in distinct_dt_values) or "NOT_AVAILABLE")
)
print(f"DT_MIN={min(dt_values) if dt_values else 'NOT_AVAILABLE'}")
print(f"DT_MAX={max(dt_values) if dt_values else 'NOT_AVAILABLE'}")
print(f"LEADING_ZERO_CYCLE_TIME_SAMPLES={leading_zero_cycle_time_samples}")

try:
    nominal_period = Decimal(nominal_period_raw)
except InvalidOperation:
    nominal_period = None

if nominal_period is not None and dt_values:
    anomaly_indices = [
        index for index, value in enumerate(dt_values)
        if Decimal(value) != nominal_period
    ]
    print(f"DT_ANOMALY_COUNT={len(anomaly_indices)}")
    print("DT_ANOMALY_INDICES=" + (",".join(str(index) for index in anomaly_indices) or "NONE"))
    if anomaly_indices:
        first_index = anomaly_indices[0]
        print(f"DT_FIRST_ANOMALY_BETWEEN_RECORDS={first_index}_AND_{first_index + 1}")
        print(f"DT_FIRST_ANOMALY_COUNTER_PAIR={counters[first_index]}_AND_{counters[first_index + 1]}")
        print(f"DT_FIRST_ANOMALY_VALUE={dt_values[first_index]}")
    else:
        print("DT_FIRST_ANOMALY_BETWEEN_RECORDS=NONE")
        print("DT_FIRST_ANOMALY_COUNTER_PAIR=NONE")
        print("DT_FIRST_ANOMALY_VALUE=NONE")
else:
    print("DT_ANOMALY_COUNT=NOT_AVAILABLE")
    print("DT_ANOMALY_INDICES=NOT_AVAILABLE")
    print("DT_FIRST_ANOMALY_BETWEEN_RECORDS=NOT_AVAILABLE")
    print("DT_FIRST_ANOMALY_COUNTER_PAIR=NOT_AVAILABLE")
    print("DT_FIRST_ANOMALY_VALUE=NOT_AVAILABLE")

if sample_count < 50:
    print("BINARY_STATUS=FAIL_INSUFFICIENT_SAMPLES")
    sys.exit(38)

counter_gap_count = sum(
    1 for previous, current in zip(counters, counters[1:])
    if current != previous + 1
)
time_decrease_count = sum(
    1 for previous, current in zip(times, times[1:])
    if current < previous
)
nonzero_cycle_times = [value for value in cycle_times if value > 0]

print(f"COUNTER_FIRST={counters[0]}")
print(f"COUNTER_LAST={counters[-1]}")
print(f"COUNTER_GAP_COUNT={counter_gap_count}")
print(f"TIME_FIRST={times[0]}")
print(f"TIME_LAST={times[-1]}")
print(f"TIME_DECREASE_COUNT={time_decrease_count}")
print(f"NONZERO_CYCLE_TIME_SAMPLES={len(nonzero_cycle_times)}")

if nonzero_cycle_times:
    print(f"CYCLE_TIME_MIN={min(nonzero_cycle_times)}")
    print(f"CYCLE_TIME_MAX={max(nonzero_cycle_times)}")
    print(f"CYCLE_TIME_MEAN={sum(nonzero_cycle_times) / len(nonzero_cycle_times):.3f}")
else:
    print("CYCLE_TIME_MIN=NOT_AVAILABLE")
    print("CYCLE_TIME_MAX=NOT_AVAILABLE")
    print("CYCLE_TIME_MEAN=NOT_AVAILABLE")

if counters[0] != 1 or counter_gap_count != 0:
    print("BINARY_STATUS=FAIL_COUNTER_SEQUENCE")
    sys.exit(39)

if time_decrease_count != 0:
    print("BINARY_STATUS=FAIL_TIME_MONOTONICITY")
    sys.exit(40)

if len(nonzero_cycle_times) == 0:
    print("BINARY_STATUS=FAIL_NO_CYCLE_TIME")
    sys.exit(41)

print("BINARY_STATUS=PASS")
PY

BINARY_RC=$?

binary_value() {
    key="$1"
    sed -n "s/^${key}=//p" "$BINARY_REPORT" | tail -n 1
}

BINARY_STATUS="$(binary_value BINARY_STATUS)"
FILE_SIZE_BYTES="$(binary_value FILE_SIZE_BYTES)"
NUMBER_OF_SIGNALS="$(binary_value NUMBER_OF_SIGNALS)"
SIGNAL_NAMES="$(binary_value SIGNAL_NAMES)"
HEADER_BYTES="$(binary_value HEADER_BYTES)"
SAMPLE_BYTES="$(binary_value SAMPLE_BYTES)"
PAYLOAD_BYTES="$(binary_value PAYLOAD_BYTES)"
PAYLOAD_REMAINDER_BYTES="$(binary_value PAYLOAD_REMAINDER_BYTES)"
COMPLETE_SAMPLE_COUNT="$(binary_value COMPLETE_SAMPLE_COUNT)"
COUNTER_FIRST="$(binary_value COUNTER_FIRST)"
COUNTER_LAST="$(binary_value COUNTER_LAST)"
COUNTER_GAP_COUNT="$(binary_value COUNTER_GAP_COUNT)"
TIME_FIRST="$(binary_value TIME_FIRST)"
TIME_LAST="$(binary_value TIME_LAST)"
TIME_DECREASE_COUNT="$(binary_value TIME_DECREASE_COUNT)"
NONZERO_CYCLE_TIME_SAMPLES="$(binary_value NONZERO_CYCLE_TIME_SAMPLES)"
CYCLE_TIME_MIN="$(binary_value CYCLE_TIME_MIN)"
CYCLE_TIME_MAX="$(binary_value CYCLE_TIME_MAX)"
CYCLE_TIME_MEAN="$(binary_value CYCLE_TIME_MEAN)"
DT_INTERVAL_COUNT="$(binary_value DT_INTERVAL_COUNT)"
DT_DISTINCT_VALUES="$(binary_value DT_DISTINCT_VALUES)"
DT_HISTOGRAM="$(binary_value DT_HISTOGRAM)"
DT_MIN="$(binary_value DT_MIN)"
DT_MAX="$(binary_value DT_MAX)"
DT_ANOMALY_COUNT="$(binary_value DT_ANOMALY_COUNT)"
DT_ANOMALY_INDICES="$(binary_value DT_ANOMALY_INDICES)"
DT_FIRST_ANOMALY_BETWEEN_RECORDS="$(binary_value DT_FIRST_ANOMALY_BETWEEN_RECORDS)"
DT_FIRST_ANOMALY_COUNTER_PAIR="$(binary_value DT_FIRST_ANOMALY_COUNTER_PAIR)"
DT_FIRST_ANOMALY_VALUE="$(binary_value DT_FIRST_ANOMALY_VALUE)"
LEADING_ZERO_CYCLE_TIME_SAMPLES="$(binary_value LEADING_ZERO_CYCLE_TIME_SAMPLES)"

affinity_display() {
    object_count="$1"
    affinity_mapping="$2"
    if [ "$object_count" = "1" ]; then
        printf "%s" "${affinity_mapping#*=}"
    else
        printf "%s" "$affinity_mapping"
    fi
}

REALTIME_THREAD_AFFINITY_DISPLAY="$(affinity_display "${REALTIME_THREAD_OBJECT_COUNT:-0}" "${REALTIME_THREAD_AFFINITY:-NOT_AVAILABLE}")"
FILE_WRITER_AFFINITY_DISPLAY="$(affinity_display "${FILE_WRITER_OBJECT_COUNT:-0}" "${FILE_WRITER_AFFINITY:-NOT_AVAILABLE}")"
LINUX_TIMER_AFFINITY_DISPLAY="$(affinity_display "${LINUX_TIMER_OBJECT_COUNT:-0}" "${LINUX_TIMER_AFFINITY:-NOT_AVAILABLE}")"

printf "============================================================\n"
printf "VALIDAZIONE PRECISA S02\n"
printf "============================================================\n"
printf "Run directory:                 %s\n" "$RUN_DIR"
printf "Log:                           %s\n" "$RUN_LOG"
printf "Configurazione:                %s\n" "$RUN_CONFIG"
printf "File binario:                  %s\n" "$OUTPUT_FILE"
printf "Avvii State1:                  %s\n" "$START_LINES"
printf "Application starting:          %s\n" "$APPLICATION_START_LINES"
printf "Aperture FileWriter:            %s\n" "$FILE_OPEN_LINES"
printf "Placeholder residui:           %s\n" "$PLACEHOLDER_COUNT"
printf "Classe qualificata FileWriter: %s\n" "$NAMESPACED_CLASS_COUNT"
printf "Classe semplice FileWriter:    %s\n" "$PLAIN_CLASS_COUNT"
printf "Filename corretti:             %s\n" "$FILENAME_MATCH_LINES"
printf "Dimensione file:               %s byte\n" "${FILE_SIZE_BYTES:-NOT_AVAILABLE}"
printf "Segnali binari:                %s\n" "${NUMBER_OF_SIGNALS:-NOT_AVAILABLE}"
printf "Nomi segnali:                  %s\n" "${SIGNAL_NAMES:-NOT_AVAILABLE}"
printf "Header:                        %s byte\n" "${HEADER_BYTES:-NOT_AVAILABLE}"
printf "Record:                        %s byte\n" "${SAMPLE_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 "Counter iniziale:              %s\n" "${COUNTER_FIRST:-NOT_AVAILABLE}"
printf "Counter finale:                %s\n" "${COUNTER_LAST:-NOT_AVAILABLE}"
printf "Salti Counter:                 %s\n" "${COUNTER_GAP_COUNT:-NOT_AVAILABLE}"
printf "Time iniziale:                 %s\n" "${TIME_FIRST:-NOT_AVAILABLE}"
printf "Time finale:                   %s\n" "${TIME_LAST:-NOT_AVAILABLE}"
printf "Regressioni Time:              %s\n" "${TIME_DECREASE_COUNT:-NOT_AVAILABLE}"
printf "CycleTime non nulli:           %s\n" "${NONZERO_CYCLE_TIME_SAMPLES:-NOT_AVAILABLE}"
printf "CycleTime minimo:              %s\n" "${CYCLE_TIME_MIN:-NOT_AVAILABLE}"
printf "CycleTime massimo:             %s\n" "${CYCLE_TIME_MAX:-NOT_AVAILABLE}"
printf "CycleTime medio:               %s\n" "${CYCLE_TIME_MEAN:-NOT_AVAILABLE}"
printf "Stato parser binario:          %s\n" "${BINARY_STATUS:-NOT_AVAILABLE}"
printf "Exit code MARTe:               %s\n" "$MARTE_EXIT_CODE"
printf "Exit code tee:                 %s\n" "$TEE_EXIT_CODE"
printf "SIGINT ricevuti:               %s\n" "$SIGINT_LINES"
printf "Stop riusciti:                 %s\n" "$STOP_OK_LINES"
printf "Application terminated:        %s\n" "$TERMINATED_LINES"
printf "Errori startup:                %s\n" "$STARTUP_ERROR_LINES"
printf "FatalError reali:              %s\n" "$FATAL_ERROR_LINES"
printf "OSError reali:                 %s\n" "$OS_ERROR_LINES"
printf "Error reali:                   %s\n" "$ERROR_LINES"
printf "InitialisationError reali:     %s\n" "$INITIALISATION_ERROR_LINES"
printf "NoError:                       %s\n" "$NO_ERROR_LINES"
printf "Doppio arresto:                %s\n" "$DOUBLE_STOP_LINES"
printf "Close EventSem asincrono:      %s\n" "$ASYNC_EVENTSEM_CLOSE_LINES"
printf "pthread_mutex_destroy:         %s\n" "$PTHREAD_MUTEX_DESTROY_LINES"
printf "FatalError non classificati:   %s\n" "$UNCLASSIFIED_FATAL_LINES"
printf "OSError non classificati:      %s\n" "$UNCLASSIFIED_OS_ERROR_LINES"

printf "\n--- INTERVALLI TEMPORALI (osservativo) ---\n"
printf "Periodo nominale:              %s us\n" "${DT_NOMINAL_PERIOD_US:-NOT_AVAILABLE}"
printf "Fonte periodo nominale:        %s\n" "${DT_NOMINAL_SOURCE:-NOT_AVAILABLE}"
printf "Intervalli dt:                 %s\n" "${DT_INTERVAL_COUNT:-NOT_AVAILABLE}"
printf "Valori dt distinti:            %s\n" "${DT_DISTINCT_VALUES:-NOT_AVAILABLE}"
printf "Istogramma dt:                 %s\n" "${DT_HISTOGRAM:-NOT_AVAILABLE}"
printf "dt minimo:                     %s\n" "${DT_MIN:-NOT_AVAILABLE}"
printf "dt massimo:                    %s\n" "${DT_MAX:-NOT_AVAILABLE}"
printf "Intervalli dt anomali:         %s\n" "${DT_ANOMALY_COUNT:-NOT_AVAILABLE}"
printf "Indici dt anomali:             %s\n" "${DT_ANOMALY_INDICES:-NOT_AVAILABLE}"
printf "Primo dt anomalo tra record:   %s\n" "${DT_FIRST_ANOMALY_BETWEEN_RECORDS:-NOT_AVAILABLE}"
printf "Primo dt anomalo Counter:      %s\n" "${DT_FIRST_ANOMALY_COUNTER_PAIR:-NOT_AVAILABLE}"
printf "Primo dt anomalo valore:       %s\n" "${DT_FIRST_ANOMALY_VALUE:-NOT_AVAILABLE}"
printf "CycleTime nulli iniziali:      %s\n" "${LEADING_ZERO_CYCLE_TIME_SAMPLES:-NOT_AVAILABLE}"

printf "\n--- AFFINITA' DICHIARATE IN CONFIGURAZIONE ---\n"
REALTIME_THREAD_LABEL="RealTimeThread (${REALTIME_THREAD_OBJECT_NAMES:-NOT_AVAILABLE}) CPUs:"
FILE_WRITER_LABEL="FileWriter (${FILE_WRITER_OBJECT_NAMES:-NOT_AVAILABLE}) CPUMask:"
LINUX_TIMER_LABEL="LinuxTimer (${LINUX_TIMER_OBJECT_NAMES:-NOT_AVAILABLE}) CPUMask:"
printf "%-40s %s (rc=%s)\n" "Stato parser configurazione:" "${CONFIG_OBSERVABILITY_STATUS:-NOT_AVAILABLE}" "$CONFIG_RC"
printf "%-40s %s\n" "$REALTIME_THREAD_LABEL" "${REALTIME_THREAD_AFFINITY_DISPLAY:-NOT_AVAILABLE}"
printf "%-40s %s\n" "$FILE_WRITER_LABEL" "${FILE_WRITER_AFFINITY_DISPLAY:-NOT_AVAILABLE}"
printf "%-40s %s\n" "$LINUX_TIMER_LABEL" "${LINUX_TIMER_AFFINITY_DISPLAY:-NOT_AVAILABLE}"

printf "\n--- PRIORITA' E TERMINAZIONE ---\n"
printf "Warning totali:                 %s\n" "$WARNING_LINES"
printf "Warning clipping priorita':     %s\n" "$PRIORITY_CLIP_LINES"
printf "Warning priorita' non applic.:  %s\n" "$PRIORITY_FAIL_LINES"
printf "Warning non classificati:       %s\n" "$UNCLASSIFIED_WARNING_LINES"
printf "Classe exit code:               %s\n" "$MARTE_EXIT_CLASS"

FUNCTIONAL_OK=0

if [ "$START_LINES" -ge 1 ] &&
   [ "$APPLICATION_START_LINES" -ge 1 ] &&
   [ "$FILE_OPEN_LINES" -ge 1 ] &&
   [ "$STARTUP_ERROR_LINES" -eq 0 ] &&
   [ "$PLACEHOLDER_COUNT" -eq 0 ] &&
   [ "$NAMESPACED_CLASS_COUNT" -eq 1 ] &&
   [ "$PLAIN_CLASS_COUNT" -eq 0 ] &&
   [ "$FILENAME_MATCH_LINES" -eq 1 ] &&
   [ "$BINARY_RC" -eq 0 ]; then
    FUNCTIONAL_OK=1
fi

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

if [ "$MARTE_EXIT_CLASS" = "EXIT_137_SIGKILL" ]; then
    TIMING_STATUS="NOT_VALID_EXIT_137_SIGKILL"
elif [ "$PRIORITY_FAIL_LINES" -ge 1 ]; then
    TIMING_STATUS="NOT_VALID_PRIORITY_NOT_APPLIED"
else
    TIMING_STATUS="UNASSESSED_DT_SEMANTICS"
fi

printf "\nFUNCTIONAL_STATUS=%s\n" "$FUNCTIONAL_STATUS"
printf "TIMING_STATUS=%s\n" "$TIMING_STATUS"
case "$FUNCTIONAL_STATUS:$TIMING_STATUS" in
    PASS:NOT_VALID_*)
        printf "FUNCTIONAL_PASS_TIMING_NOT_VALID\n"
        ;;
esac

printf "\n============================================================\n"
printf "CLASSIFICAZIONE\n"
printf "============================================================\n"

if [ "$FUNCTIONAL_OK" -ne 1 ]; then
    printf "[NON DIMOSTRATO] Funzionamento S02 e registrazione binaria non sufficientemente provati.\n"
    printf "[DA VERIFICARE] Dettaglio parser binario:\n"
    cat -- "$BINARY_REPORT"
    exit 20
fi

printf "[VERIFICATO] Funzionamento S02 e registrazione binaria dimostrati.\n"

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 "[VERIFICATO] Shutdown privo di Error, OSError e FatalError.\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 "[DA VERIFICARE] Funzionalità riuscita con sole anomalie di shutdown già classificate.\n"
    exit 10
fi

printf "[DA VERIFICARE] Funzionalità riuscita, ma sono presenti anomalie di shutdown non classificate.\n"
exit 11