#!/bin/bash
# ===================================================================
# Docker Konsistenz-Prüfer
# Validiert Dockerfiles und docker-compose-Dateien gegen docker/versions.toml
# ===================================================================

# Strikte Fehlerbehandlung: Abbruch bei Fehler, bei unset Variablen, und wenn ein Befehl in einer Pipe fehlschlägt.
set -euo pipefail

# Skript-Verzeichnis und Projekt-Wurzel
SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
PROJECT_ROOT="$(cd "$SCRIPT_DIR/.." && pwd)"
DOCKER_DIR="$PROJECT_ROOT/docker"
VERSIONS_TOML="$DOCKER_DIR/versions.toml"
DOCKERFILES_DIR="$PROJECT_ROOT/dockerfiles"

# Farben für die Ausgabe
RED='\033[0;31m'
GREEN='\033[0;32m'
YELLOW='\033[1;33m'
BLUE='\033[0;34m'
NC='\033[0m' # Keine Farbe

# Globale Zähler (werden innerhalb der Funktionen aktualisiert)
_ERRORS=0
_WARNINGS=0
_CHECKS_PASSED=0

# --- Hilfsfunktionen für Ausgabe und Zählung ---

# Funktion zur Ausgabe von farbigem Text und zur Aktualisierung eines globalen Zählers
print_and_count() {
    local color=$1
    local type=$2
    local message=$3
    local counter_name=$4 # Name der globalen Zählervariable

    echo -e "${color}[${type}]${NC} $message"
    if [[ -n "$counter_name" ]]; then
        # Nameref für robuste Zählerinkrementierung verwenden (Globale Variable)
        declare -g -i "$counter_name"
        eval "$counter_name=\$(( $counter_name + 1 ))"
    fi
}

print_info() {
    echo -e "${BLUE}[INFO]${NC} $1"
}

print_success() {
    print_and_count "$GREEN" "ERFOLG" "$1" "_CHECKS_PASSED"
}

print_warning() {
    print_and_count "$YELLOW" "WARNUNG" "$1" "_WARNINGS"
}

print_error() {
    print_and_count "$RED" "FEHLER" "$1" "_ERRORS"
}

# --- TOML Parsing Funktionen ---

# Funktion zum Extrahieren einer Version aus der [versions] Sektion der TOML-Datei
get_version() {
    local key=$1
    # grep zur schnellen Lokalisierung des Abschnitts, dann awk zum Finden des Schlüssels
    grep -A 20 -E '^\[versions\]' "$VERSIONS_TOML" | \
        awk -v k="$key" '
            /\[/ { exit } # Beim nächsten Abschnitt stoppen
            $1 == k && $2 == "=" { v=$3; gsub(/"/,"",v); print v; exit }
        ' || true
}

# Funktion zum Abrufen aller gültigen ARG-Namen aus der TOML-Datei
get_valid_args() {
    # 1. Versions-Schlüssel aus [versions] extrahieren
    awk '/^\[versions\]/,/^\[/ {if (/^[a-zA-Z].*= /) print $1}' "$VERSIONS_TOML" | grep -v "^\[" || true
    # 2. Build-Argumente aus [build-args] extrahieren (Tokens innerhalb von Anführungszeichen)
    awk '/^\[build-args\]/,/^\[/ {
        if ($0 ~ /^[[:space:]]*args[[:space:]]*=/) {
            line = $0
            # Array-Begrenzer entfernen: [ und ]
            gsub(/[\[\]]/, "", line)
            # Durch die zitierten Tokens iterieren
            while (match(line, /"[A-Za-z0-9_]+"/)) {
                token = substr(line, RSTART+1, RLENGTH-2)
                print token
                line = substr(line, RSTART+RLENGTH)
            }
        }
    }' "$VERSIONS_TOML" || true
    # 3. Service-Ports extrahieren
    awk '/^\[service-ports\]/,/^\[/ {if (/^[a-zA-Z].*= /) print $1}' "$VERSIONS_TOML" | grep -v "^\[" || true
}

# Funktion zum Abrufen der Environment-Variablen-Mappings aus der TOML-Datei
get_env_mappings() {
    awk '/^\[environment-mapping\]/,/^\[/ {
        if (/^[a-zA-Z].*= /) {
            key = $1
            value = $3
            gsub(/"/, "", value)
            print key ":" value
        }
    }' "$VERSIONS_TOML" || true
}

# Port-Wert aus [service-ports] in versions.toml abrufen
get_toml_port() {
    local service_key=$1
    grep -A 20 -E '^\[service-ports\]' "$VERSIONS_TOML" | \
        awk -v key="$service_key" '
            /\[/ { exit }
            $1 == key { print $3; exit }
        ' || true
}

# --- Validierungsfunktionen ---

# Funktion zur Validierung der Dockerfile ARGs
validate_dockerfile_args() {
    local dockerfile=$1
    local relative_path=${dockerfile#"$PROJECT_ROOT"/}

    print_info "Validiere Dockerfile: $relative_path"

    if [[ ! -f "$dockerfile" ]]; then
        print_error "Dockerfile nicht gefunden: $relative_path"
        return
    fi

    local dockerfile_args
    # Alle ARG-Deklarationen erfassen (nur Name)
    dockerfile_args=$(grep "^ARG " "$dockerfile" 2>/dev/null | sed 's/^ARG //' | sed 's/=.*//' | sort -u || true)

    local valid_args
    valid_args=$(get_valid_args | sort -u)

    local has_centralized_args=false

    # Jedes ARG im Dockerfile prüfen
    while IFS= read -r arg; do
        [[ -z "$arg" ]] && continue

        # Prüfen, ob ARG in versions.toml definiert oder ein Standard Docker ARG ist
        case "$arg" in
            # Standard Docker Build-Argumente
            BUILDPLATFORM|TARGETPLATFORM|BUILDOS|TARGETOS|BUILDARCH|TARGETARCH)
                print_success "  ✓ Standard Docker ARG: $arg"
                has_centralized_args=true
                ;;
            # Anwendungs-spezifische Argumente, die zentralisiert sein sollten
            GRADLE_VERSION|JAVA_VERSION|NODE_VERSION|NGINX_VERSION|VERSION|SPRING_PROFILES_ACTIVE|SERVICE_PATH|SERVICE_NAME|SERVICE_PORT|CLIENT_PATH|CLIENT_MODULE|CLIENT_NAME)
                if echo "$valid_args" | grep -q "^$arg$"; then
                    print_success "  ✓ Zentralisiertes ARG: $arg"
                    has_centralized_args=true
                else
                    print_warning "  ⚠ ARG $arg sollte in versions.toml definiert werden"
                fi
                ;;
            # Laufzeit-Konfigurationsargumente (lokal akzeptabel)
            APP_USER|APP_GROUP|APP_UID|APP_GID)
                print_success "  ✓ Laufzeit-Konfigurations ARG: $arg"
                ;;
            *)
                # Prüfen, ob es ein Versions-bezogenes ARG ist, das zentralisiert werden sollte
                if [[ "$arg" =~ _(VERSION|PORT)$ ]] || [[ "$arg" =~ ^(DOCKER_|SERVICE_|CLIENT_) ]]; then
                    print_warning "  ⚠ ARG $arg sollte möglicherweise in versions.toml zentralisiert werden"
                else
                    print_success "  ✓ Benutzerdefiniertes ARG: $arg"
                fi
                ;;
        esac
    done <<< "$dockerfile_args"

    if [[ "$has_centralized_args" == true ]]; then
        print_success "  ✓ Dockerfile verwendet zentralisiertes Versionsmanagement"
    else
        print_warning "  ⚠ Dockerfile sollte zentralisierte ARGs aus versions.toml verwenden"
    fi

    # Prüfen auf Standardzuweisungen bei zentralisierten ARGs (verboten)
    local centralized_args_regex='^(GRADLE_VERSION|JAVA_VERSION|NODE_VERSION|NGINX_VERSION|VERSION|SPRING_PROFILES_ACTIVE)='
    local defaulted_args
    defaulted_args=$(grep -nE "^ARG ${centralized_args_regex}" "$dockerfile" || true)

    if [[ -n "$defaulted_args" ]]; then
        print_error "  ❌ Zentralisierte ARGs dürfen keine Standardwerte in Dockerfiles haben:"
        # Prozess-Substitution verwenden, um den Verlust von $ERRORS-Updates zu vermeiden
        while IFS= read -r line; do
            print_error "    $relative_path:$line"
        done < <(echo "$defaulted_args")
    else
        print_success "  ✓ Keine Standardwerte für zentralisierte ARGs gesetzt"
    fi

    # Prüfen auf festcodierte Versionen in ARG-Standardwerten
    local hardcoded_versions
    hardcoded_versions=$(grep -nE "^ARG [A-Z0-9_]+=.*(alpine|[0-9]+\.[0-9]+)" "$dockerfile" | grep -v "APP_" || true)

    if [[ -n "$hardcoded_versions" ]]; then
        print_error "  ❌ Festcodierte Versionen in ARG-Standardwerten gefunden (sollten versions.toml verwenden):"
        # Prozess-Substitution verwenden, um den Verlust von $ERRORS-Updates zu vermeiden
        while IFS= read -r line; do
            print_error "    $relative_path:$line"
        done < <(echo "$hardcoded_versions")
    else
        print_success "  ✓ Keine festcodierten Versionsliterale in ARG-Standardwerten"
    fi
}

# Funktion zur Validierung von docker-compose Versionsreferenzen
validate_compose_versions() {
    local compose_file=$1
    local relative_path=${compose_file#"$PROJECT_ROOT"/}

    print_info "Validiere Docker Compose Datei: $relative_path"

    if [[ ! -f "$compose_file" ]]; then
        print_error "Compose-Datei nicht gefunden: $relative_path"
        return
    fi

    local env_mappings
    env_mappings=$(get_env_mappings)

    # 0) Fehler bei leeren ARG-Werten für kritische Build-Argumente
    local blank_args
    blank_args=$(grep -nE '^[[:space:]]*(GRADLE_VERSION|JAVA_VERSION|NODE_VERSION|NGINX_VERSION|VERSION|SPRING_PROFILES_ACTIVE):[[:space:]]*$' "$compose_file" || true)
    if [[ -n "$blank_args" ]]; then
        print_error "  ❌ Leere Build-Argumente erkannt (müssen auf zentralisierte DOCKER_* Variablen verweisen):"
        while IFS= read -r line; do
            print_error "    $relative_path:$line"
        done < <(echo "$blank_args")
    else
        print_success "  ✓ Keine leeren kritischen Build-Argumente in der Compose-Datei"
    fi

    # Sicherstellen, dass kritische Build-Argumente auf zentralisierte DOCKER_* Variablen verweisen
    local critical_vars=(GRADLE_VERSION JAVA_VERSION NODE_VERSION NGINX_VERSION VERSION SPRING_PROFILES_ACTIVE)
    for v in "${critical_vars[@]}"; do
        # Verwenden von awk, um Mapping-Einträge innerhalb von build->args zuverlässig zu finden
        local mapping_lines
        mapping_lines=$(awk -v var="$v" '
            { line[NR] = $0 }
            END {
                for (i = 1; i <= NR; i++) {
                    if (line[i] ~ "^[[:space:]]*" var ":[[:space:]]*.+$") {
                        found = 0
                        # Bis zu 12 Zeilen zurückblicken, um nach "args:" zu suchen
                        for (j = i - 1; j >= 1 && j >= i - 12; j--) {
                            if (line[j] ~ /^[[:space:]]*args:[[:space:]]*$/) { found = 1; break }
                            # Suche stoppen, wenn eine übergeordnete Sektion erreicht wird
                            if (line[j] ~ /^[[:space:]]*(environment|services|volumes|secrets|networks):/ ) { break }
                        }
                        if (found) { printf("%d:%s\n", i, line[i]) }
                    }
                }
            }' "$compose_file" || true)

        if [[ -n "$mapping_lines" ]]; then
            while IFS= read -r line; do
                local ln
                local content
                ln=$(echo "$line" | cut -d: -f1)
                content=$(echo "$line" | cut -d: -f2- | sed 's/^[[:space:]]*//')
                # Prüfen, ob der Wert auf ${DOCKER_*} verweist
                if ! echo "$content" | grep -q "\${DOCKER_"; then
                    print_error "  ❌ $v sollte in Build-Args-Mappings auf zentralisierte DOCKER_* Variable verweisen (gefunden: $content)"
                    print_error "    $relative_path:$ln"
                fi
            done < <(echo "$mapping_lines")
        fi
    done

    # 2a) Validierung von Standard-Fallbacks in ${DOCKER_*:-fallback} gegen SSoT-Werte
    declare -A env_to_version_key
    while IFS=':' read -r toml_key env_var; do
        [[ -z "$toml_key" || -z "$env_var" ]] && continue
        # Mapping der TOML-Schlüsselnamen zu Environment-Variablennamen
        env_to_version_key[$env_var]=$(echo "$toml_key" | tr -d '\r')
    done <<< "$env_mappings"

    # Vorkommen mit expliziten Standard-Fallbacks finden
    local fallback_lines
    fallback_lines=$(grep -nE "\${DOCKER_[A-Z0-9_]+:-[^}]+" "$compose_file" || true)

    if [[ -n "$fallback_lines" ]]; then
        while IFS= read -r ln; do
            [[ -z "$ln" ]] && continue
            local num
            local text
            num=$(echo "$ln" | cut -d: -f1)
            text=$(echo "$ln" | cut -d: -f2-)

            # Variablennamen und Fallback-Wert extrahieren
            local var
            local fallback
            var=$(echo "$text" | sed -nE "s/.*\$([A-Z0-9_]+):-\([^}][^}]*\).*/\1/p")
            fallback=$(echo "$text" | sed -nE "s/.*\$[A-Z0-9_]+:-([^}][^}]*).*/\1/p")

            if [[ -z "$var" || -z "$fallback" ]]; then
                continue
            fi

            local key
            key=${env_to_version_key[$var]}
            if [[ -z "$key" ]]; then
                print_warning "  ⚠ Variable $var wird mit Fallback verwendet, ist aber nicht in [environment-mapping] gemappt. Fallback-Prüfung übersprungen."
                continue
            fi

            local expected
            expected=$(get_version "$key")
            if [[ -z "$expected" ]]; then
                print_warning "  ⚠ Kein SSoT-Wert für $var (Schlüssel: $key) in versions.toml zum Vergleich des Fallbacks gefunden"
                continue
            fi

            if [[ "$fallback" != "$expected" ]]; then
                print_error "  ❌ Veralteter Standard-Fallback für $var in ${relative_path}:${num} — gefunden '$fallback', erwartet '$expected' aus versions.toml ($key)"
            else
                print_success "  ✓ Fallback für $var stimmt mit SSoT überein ($expected)"
            fi
        done < <(echo "$fallback_lines")
    fi

    # Prüfen auf Versionsreferenzen in der Compose-Datei
    local version_refs
    version_refs=$(grep -o "\${DOCKER_[^}]*}" "$compose_file" | sort -u || true)

    if [[ -z "$version_refs" ]]; then
        print_warning "  ⚠ Keine zentralisierten Versionsreferenzen gefunden"
    else
        while IFS= read -r ref; do
            [[ -z "$ref" ]] && continue

            local var_name
            var_name=${ref#\$\{}
            var_name=${var_name%\}}
            var_name=${var_name%%:-*} # Standard-Fallback (:-value) entfernen

            local mapping_found=false
            while IFS=':' read -r toml_key env_var; do
                if [[ "$env_var" == "$var_name" ]]; then
                    mapping_found=true
                    local toml_version
                    toml_version=$(get_version "$toml_key")
                    if [[ -n "$toml_version" ]]; then
                        print_success "  ✓ Versionsreferenz $ref mappt zu $toml_key = $toml_version"
                    else
                        print_error "  ❌ TOML-Schlüssel $toml_key hat keinen Wert"
                    fi
                    break
                fi
            done <<< "$env_mappings"

            if [[ "$mapping_found" == false ]]; then
                print_warning "  ⚠ Versionsreferenz $ref hat kein Mapping in der [environment-mapping] Sektion"
            fi
        done <<< "$version_refs"
    fi

    # Prüfen auf festcodierte Image-Versionen
    local hardcoded_images
    hardcoded_images=$(grep -E "image:.*:[0-9]" "$compose_file" | grep -v "\${" || true)
    if [[ -n "$hardcoded_images" ]]; then
        print_error "  ❌ Festcodierte Image-Versionen gefunden:"
        while IFS= read -r line; do
            print_error "    $line"
        done < <(echo "$hardcoded_images")
    else
        print_success "  ✓ Keine festcodierten Image-Versionen gefunden"
    fi
}

# Funktion zur Validierung der Port-Konsistenz
# Diese Funktion benötigt keine Argumente.
# shellcheck disable=SC2120
validate_port_consistency() {

    local toml_ports
    local overall_success
    local compose_files
    local full_path
    local compose_ports_raw
    local found_port

    print_info "Validiere Port-Konsistenz..."

    # toml_ports werden durch awk und VERSIONS_TOML gefüllt
    toml_ports=$(awk "/^\[service-ports\]/,/^\[/ {
        if (/^[a-zA-Z].*= [0-9]/) {
            service = $1
            port = $3
            print service ":" port
        }
    }" "$VERSIONS_TOML" || true)

    compose_files=("docker-compose.yml" "docker-compose.services.yml" "docker-compose.clients.yml")
    overall_success=true

    for compose_file in "${compose_files[@]}"; do
        full_path="$PROJECT_ROOT/$compose_file"
        if [[ -f "$full_path" ]]; then
            # Port-Mappings aus Compose-Datei extrahieren (z.B. "8080:8080" oder "80:8080")
            compose_ports_raw=$(grep -E 'ports:[[:space:]]*$|\s*-\s*("?[0-9]+:[0-9]+"?)' "$full_path" 2>/dev/null | grep -v "ports:$" | sed -E 's/.*-\s*"?([^"]*)"?/\1/' || true)

            while IFS=':' read -r service expected_port; do
                [[ -z "$service" ]] && continue

                # Prüfen, ob der Dienstname in der Compose-Datei existiert
                if grep -qE "^[[:space:]]*${service}:" "$full_path"; then
                    found_port=false

                    # Prüfen, ob ein Port-Eintrag mit dem erwarteten internen Port übereinstimmt
                    if echo "$compose_ports_raw" | grep -q ":${expected_port}$"; then
                        found_port=true
                    fi

                    if [[ "$found_port" == true ]]; then
                        print_success "  ✓ Port-Konsistenz für $service: $expected_port"
                    else
                        print_warning "  ⚠ Port-Fehlübereinstimmung/Fehlendes Mapping für $service (erwarteter interner Port: $expected_port)"
                        overall_success=false
                    fi
                fi
            done <<< "$toml_ports"
        fi
    done

  if [[ "$overall_success" == true ]]; then
    # Nur eine allgemeine Erfolgsmeldung hinzufügen, wenn keine detaillierten
    # Warnungen aufgetreten sind, die overall_success auf false gesetzt hätten.
    # Beachten Sie, dass print_success/print_warning die globalen Zähler aktualisieren.
    print_success "  ✓ Gesamte Port-Konsistenzprüfung abgeschlossen."
  else
    # Wenn overall_success auf false gesetzt wurde, wurden bereits detaillierte Warnungen ausgegeben.
    # Hier ist keine weitere Fehlermeldung nötig.
    :
  fi
}

# Funktion zur Validierung von Build-Args Environment-Dateien
validate_build_args_files() {

  local build_args_files
  local full_path
  local invalid_lines
  local bare_docker
  local docker_keys_count

  # Überspringen, wenn der Env-less-Modus aktiv ist
  if [[ "${DOCKER_SSOT_MODE:-compat}" == "envless" ]]; then
    print_info "Env-less Modus aktiv → Überspringe build-args/*.env Validierung"
    print_success "  ✓ Übersprungen: build-args Env-Dateien sind im Env-less Modus nicht erforderlich"
    return
  fi

  print_info "Validiere Build-Args Environment-Dateien..."

  build_args_files=("global.env" "services.env" "infrastructure.env" "clients.env")

  for env_file in "${build_args_files[@]}"; do
    full_path="$DOCKER_DIR/build-args/$env_file"

    if [[ ! -f "$full_path" ]]; then
      print_error "  ❌ Build-Args-Datei fehlt: $env_file"
      continue
    fi

    print_success "  ✓ Build-Args-Datei existiert: $env_file"

    if [[ -s "$full_path" ]]; then
      print_success "  ✓ Build-Args-Datei ist nicht leer: $env_file"
    else
      print_warning "  ⚠ Build-Args-Datei ist leer: $env_file"
    fi

    # 1) Sicherstellen, dass nur gültige Zeilen vorhanden sind: Kommentare, Leerzeilen oder key=value
    invalid_lines=$(grep -n -vE "^(#|\s*$|[A-Za-z_][A-Za-z0-9_]*=)" "$full_path" || true)
    if [[ -n "$invalid_lines" ]]; then
      print_error "  ❌ Ungültige Zeilen (muss key=value oder Kommentar sein):"
      while IFS= read -r line; do
        print_error "    $env_file:$line"
      done < <(echo "$invalid_lines")
    else
      print_success "  ✓ Format OK (nur key=value/Kommentare) in $env_file"
    fi

    # 2) Keine bloßen Platzhalter wie `DOCKER_XYZ` ohne Wert
    bare_docker=$(grep -nE "^DOCKER_[A-Z0-9_]+$" "$full_path" || true)
    if [[ -n "$bare_docker" ]]; then
      print_error "  ❌ Bloße DOCKER_* Platzhalter ohne Werte gefunden:"
      while IFS= read -r line; do
        print_error "    $env_file:$line"
      done < <(echo "$bare_docker")
    else
      print_success "  ✓ Keine bloßen DOCKER_* Platzhalter in $env_file"
    fi

    # 3) Richtlinie: Nur global.env darf DOCKER_* Schlüssel enthalten
    docker_keys_count=$(grep -c -E "^DOCKER_[A-Z0-9_]+" "$full_path" || echo "0")
    if [[ "$env_file" == "global.env" ]]; then
      if [[ "$docker_keys_count" -gt 0 ]]; then
        print_success "  ✓ DOCKER_* Variablen sind nur in global.env vorhanden ($docker_keys_count gefunden)"
      else
        print_warning "  ⚠ Einige DOCKER_* Variablen erwartet in global.env (prometheus/grafana/keycloak, etc.)"
      fi
      # Erforderliche Schlüssel in global.env
      for key in GRADLE_VERSION JAVA_VERSION VERSION; do
        if grep -q "^$key=" "$full_path"; then
          print_success "  ✓ $key ist in global.env vorhanden"
        else
          print_error "  ❌ $key fehlt in global.env"
        fi
      done
    else
      if [[ "$docker_keys_count" -gt 0 ]]; then
        print_error "  ❌ DOCKER_* Variablen dürfen nicht in $env_file vorhanden sein (in global.env zentralisieren)"
      else
        print_success "  ✓ Keine zentralisierten DOCKER_* Variablen in $env_file (wie erwartet)"
      fi
    fi

    # 4) DOCKER_APP_VERSION in Build-Args Env-Dateien verbieten
    if grep -q '^DOCKER_APP_VERSION=' "$full_path"; then
        print_error "  ❌ DOCKER_APP_VERSION sollte nicht in Build-Args-Dateien definiert werden (wird zur Laufzeit von VERSION gemappt)"
    fi
  done
}

# Validierung der Wertgleichheit zwischen versions.toml und Build-Args Env-Dateien
validate_env_value_equality() {

  local has_diff

  # Überspringen, wenn der Env-less-Modus aktiv ist
  if [[ "${DOCKER_SSOT_MODE:-compat}" == "envless" ]]; then
    print_info "Env-less Modus aktiv → Überspringe TOML↔Env-Wert-Gleichheitsprüfung"
    print_success "  ✓ Übersprungen: Werte stammen zur Laufzeit direkt aus versions.toml"
    return
  fi

  print_info "Validiere Wertgleichheit zwischen versions.toml und Build-Args Envs..."

  has_diff=false

  # Interne Hilfsfunktion zum Vergleichen eines TOML-Schlüssels mit einem Env-Schlüssel in einer bestimmten Datei
  _check_env_pair() {

    local env_file=$1
    local env_key=$2
    local toml_key=$3
    local path="$DOCKER_DIR/build-args/$env_file"
    local expected actual port_lookup

    if [[ ! -f "$path" ]]; then
      print_error "  ❌ Fehlende Env-Datei: $env_file"
      has_diff=true
      return
    fi

    # Erwarteter Wert aus TOML (zuerst [versions] versuchen)
    expected=$(get_version "$toml_key")
    # Fallback: [service-ports] versuchen, falls nicht in [versions] gefunden
    if [[ -z "$expected" ]]; then
      port_lookup=$(get_toml_port "$toml_key")
      if [[ -n "$port_lookup" ]]; then
          expected="$port_lookup"
      fi
    fi

    # Aktueller Wert aus Env-Datei
    actual=$(grep -E "^${env_key}=" "$path" | head -1 | sed "s/^[^=]*=//")

    if [[ -z "$expected" ]]; then
      print_warning "  ⚠ TOML-Schlüssel '$toml_key' lieferte keinen Wert (versions.toml prüfen)"
      return
    fi
    if [[ -z "$actual" ]]; then
      print_error "  ❌ $env_file fehlt $env_key (erwartet $expected)"
      has_diff=true
      return
    fi

    # Prüfen auf Nichtübereinstimmung
    if [[ "$expected" != "$actual" ]]; then
      # Versuch zur Normalisierung für den Vergleich (Anführungszeichen entfernen, falls vorhanden)
      local clean_expected
      clean_expected=$(echo "$expected" | sed 's/^"//;s/"$//')
      local clean_actual
      clean_actual=$(echo "$actual" | sed 's/^"//;s/"$//')

      if [[ "$clean_expected" != "$clean_actual" ]]; then
       print_error "  ❌ Nichtübereinstimmung in $env_file: $env_key=$actual != $toml_key=$expected"
       has_diff=true
      else
       # Nur ein Anführungszeichen-Unterschied (z.B. actual="1.0" expected=1.0)
       print_warning "  ⚠ Anführungszeichen-Unterschied in $env_file: $env_key=$actual vs $toml_key=$expected (Wert stimmt überein)"
      fi
    else
      print_success "  ✓ $env_file: $env_key stimmt mit $toml_key überein ($expected)"
    fi
  }

  # Global.env Mappings
  _check_env_pair "global.env" "GRADLE_VERSION" "gradle"
  _check_env_pair "global.env" "JAVA_VERSION" "java"
  _check_env_pair "global.env" "VERSION" "app-version"
  _check_env_pair "global.env" "PROMETHEUS_IMAGE_TAG" "prometheus"
  _check_env_pair "global.env" "GRAFANA_IMAGE_TAG" "grafana"
  _check_env_pair "global.env" "KEYCLOAK_IMAGE_TAG" "keycloak"

  # Clients.env Mappings
  _check_env_pair "clients.env" "NODE_VERSION" "node"
  _check_env_pair "clients.env" "NGINX_VERSION" "nginx"

  if [[ "$has_diff" == false ]]; then
    print_success "Umwelt-Dateien sind vollständig mit versions.toml synchronisiert"
  fi
}

# Nach frei schwebenden Versions-Strings außerhalb kontrollierter Dateien scannen
scan_free_floating_versions() {

  local version_values
  local found_any=false
  local search_paths
  local hits=""
  local generic_hits

  print_info "Scanne nach frei schwebenden Versions-Literalen außerhalb von SSoT-verwalteten Dateien..."

  # Versionswerte aus [versions] sammeln (muss einen Punkt oder Bindestrich enthalten, um ein Versions-String zu sein)
  version_values=$(awk '
    /^\[versions\]/ { in_section=1; next }
    /^\[/ { if (in_section) exit; in_section=0 }
    in_section && $2 == "=" { v=$3; gsub(/"/,"",v); if (v ~ /[\.-]/) print v }
  ' "$VERSIONS_TOML" || true)

  # Alle Dateien finden, die NICHT auf der Ausschlussliste stehen (Endet mit Null-Byte)
  search_paths=$(
    find "$PROJECT_ROOT" -type f \
      -not -path "*/.git/*" \
      -not -path "*/build/*" \
      -not -path "*/.gradle/*" \
      -not -path "*/node_modules/*" \
      -not -path "*/dist/*" \
      -not -path "*/out/*" \
      -not -path "*/target/*" \
      -not -path "$PROJECT_ROOT/README.md" \
      -not -path "$PROJECT_ROOT/docker/versions.toml" \
      -not -path "$PROJECT_ROOT/docker/build-args/*" \
      -not -name "docker-compose*.yml" \
      -not -name "docker-compose*.yml.optimized" \
      -not -path "$PROJECT_ROOT/scripts/*" \
      -not -name "*.sh" \
      -print0
  )

  # 1. Nach exakten, kontrollierten Versions-Strings suchen
  while IFS= read -r val; do
    [[ -z "$val" ]] && continue
    # Portable Suche nach exaktem Wert
    while IFS= read -r -d '' f; do
      grep -nF -- "$val" "$f" 2>/dev/null || true
    done < <(echo "$search_paths" | tr '\0' '\n') | tr '\n' '\0' | while IFS= read -r -d '' line; do
      hits+="${line}\n"
    done

    if [[ -n "$hits" ]]; then
      found_any=true
      print_warning "  ⚠ Vorkommen des Versions-Literals '$val' außerhalb kontrollierter Dateien entdeckt:"
      while IFS= read -r line; do
        print_warning "    $line"
      done < <(echo -e "$hits" | sed 's/\n$//')
    fi
  done <<< "$version_values"

  # 2. Generischer Muster-Scan nach verdächtigen Literalen
  # Suche nach gängigen Versions-Mustern (X.Y.Z, X.Y)
  generic_hits=$(\
    echo "$search_paths" | tr '\0' '\n' | xargs -r grep -nE -- "(^|[^0-9])([0-9]+\.[0-9]+\.[0-9]+([a-zA-Z0-9._-]+)?|([0-9]+\.[0-9]+))" 2>/dev/null \
    | head -n 200 || true) # Ausgabe auf 200 Zeilen begrenzen

  if [[ -n "$generic_hits" ]]; then
    found_any=true
    print_warning "  ⚠ Generische Versions-ähnliche Strings gefunden (auf potenziellen Drift überprüfen):"
    while IFS= read -r line; do
        print_warning "    $line"
    done < <(echo "$generic_hits")
  fi

  if [[ "$found_any" == false ]]; then
    print_success "  ✓ Keine frei schwebenden Versions-Literale entdeckt"
  fi
}

# Funktion zur Anzeige der Validierungszusammenfassung
show_summary() {
  echo ""
  echo "==============================================="
  echo "Zusammenfassung der Docker Konsistenz-Validierung"
  echo "==============================================="
  echo -e "${GREEN}Prüfungen bestanden: $_CHECKS_PASSED${NC}"
  echo -e "${YELLOW}Warnungen: $_WARNINGS${NC}"
  echo -e "${RED}Fehler: $_ERRORS${NC}"
  echo "==============================================="

  if [[ $_ERRORS -eq 0 ]]; then
    if [[ $_WARNINGS -eq 0 ]]; then
      print_info "Alle Konsistenzprüfungen bestanden! ✨"
      return 0
    else
      print_warning "Validierung mit Warnungen abgeschlossen. Bitte beheben Sie diese für optimale Konsistenz."
      return 0
    fi
  else
    print_error "Validierung fehlgeschlagen mit $_ERRORS Fehlern. Bitte beheben Sie diese, bevor Sie fortfahren."
    return 1
  fi
}

# Funktion zur Anzeige der Hilfe
show_help() {
  echo "Docker Konsistenz-Prüfer"
  echo ""
  echo "Verwendung: $0 [BEFEHL]"
  echo ""
  echo "Befehle:"
  echo "  all              Führt alle Validierungsprüfungen aus (Standard)"
  echo "  dockerfiles      Validiert Dockerfile ARG-Deklarationen"
  echo "  compose          Validiert docker-compose Versionsreferenzen"
  echo "  ports            Validiert Port-Konsistenz"
  echo "  build-args       Validiert build-args Environment-Dateien und Wertgleichheit"
  echo "  scan-drift       Scannt das Repo nach frei schwebenden Versions-Literalen"
  echo ""
  echo "Beispiele:"
  echo "  $0               # Alle Validierungen ausführen"
  echo "  $0 dockerfiles   # Nur Dockerfiles validieren"
}

# Hauptausführung
main() {
  local command=${1:-all}

  # Prüfen, ob versions.toml existiert
  if [[ ! -f "$VERSIONS_TOML" ]]; then
    print_error "Versions-Datei nicht gefunden: $VERSIONS_TOML"
    show_summary
    exit 1
  fi

  print_info "Docker Konsistenz-Validierung - Startet..."
  print_info "Versions-Datei: $VERSIONS_TOML"
  echo ""

  case $command in
    "all")
      # Dockerfiles validieren
      find "$DOCKERFILES_DIR" -name "Dockerfile" -type f -print0 | while IFS= read -r -d '' dockerfile; do
        validate_dockerfile_args "$dockerfile"
        echo ""
      done

      # docker-compose-Dateien validieren
      find "$PROJECT_ROOT" -maxdepth 1 -name "docker-compose*.yml*" -type f -print0 | while IFS= read -r -d '' compose_file; do
        validate_compose_versions "$compose_file"
        echo ""
      done

        # Port-Konsistenz validieren
        validate_port_consistency
        echo ""

        # Build-Args-Dateien validieren
        validate_build_args_files
        echo ""

        # Wertgleichheit zwischen TOML und Env-Dateien validieren
        validate_env_value_equality
        echo ""

        # Repository nach frei schwebenden Versions-Literalen scannen
        scan_free_floating_versions
        ;;
      "dockerfiles")
        find "$DOCKERFILES_DIR" -name "Dockerfile" -type f -print0 | while IFS= read -r -d '' dockerfile; do
          validate_dockerfile_args "$dockerfile"
          echo ""
        done
        ;;
      "compose")
        find "$PROJECT_ROOT" -maxdepth 1 -name "docker-compose*.yml*" -type f -print0 | while IFS= read -r -d '' compose_file; do
          validate_compose_versions "$compose_file"
          echo ""
        done
        ;;
      "ports")
        validate_port_consistency
        ;;
      "build-args")
        validate_build_args_files
        validate_env_value_equality
        ;;
      "scan-drift")
        scan_free_floating_versions
        ;;
      "-h"|"--help"|"help")
        show_help
        exit 0
        ;;
    *)
      print_error "Unbekannter Befehl: $command"
      show_help
      exit 1
      ;;
  esac

  show_summary
}

# Hauptfunktion mit allen Argumenten ausführen
main "$@"