"""Vollständige Tests für ErrorCollector - Alle Datentypen"""

import sys
sys.stdout.reconfigure(encoding='utf-8')

from error_collector import ErrorCollector

print("="*70)
print("Test Suite: ErrorCollector - Alle Datentypen und Kombinationen")
print("="*70)

# Test 1: Mehrere einzelne String-Fehler (create_numbers.py Szenario)
print("\nTest 1: Mehrere einzelne String-Fehler")
ec1 = ErrorCollector()
ec1.add_errors({"symbol_error": "Fehler 1"})
ec1.add_errors({"symbol_error": "Fehler 2"})
ec1.add_errors({"symbol_error": "Fehler 3"})
assert ec1.errors["symbol_error"] == ["Fehler 1", "Fehler 2", "Fehler 3"]
assert isinstance(ec1.errors["symbol_error"], list)
print("✓ Strings werden zu flacher Liste zusammengefasst")

# Test 2: Dictionary bleibt Dictionary (getpositions.py Szenario)
print("\nTest 2: Dictionary bleibt Dictionary (double_ids)")
ec2 = ErrorCollector()
double_ids = {"ID1": [[100, 200], [300, 400]], "ID2": [[500, 600]]}
ec2.add_errors({"double_ids": double_ids})
assert isinstance(ec2.errors["double_ids"], dict)
assert ec2.errors["double_ids"]["ID1"] == [[100, 200], [300, 400]]
assert ec2.errors["double_ids"]["ID2"] == [[500, 600]]
print("✓ Dictionary bleibt Dictionary (nicht zu Liste verpackt)")

# Test 3: Dictionary Update/Merge bei mehrmaligem Hinzufügen
print("\nTest 3: Dictionary Merge bei zweimaligem Hinzufügen")
ec3 = ErrorCollector()
ec3.add_errors({"duplicate_ids": {"ID1": [[10, 20]], "ID2": [[30, 40]]}})
ec3.add_errors({"duplicate_ids": {"ID3": [[50, 60]]}})
assert isinstance(ec3.errors["duplicate_ids"], dict)
assert ec3.errors["duplicate_ids"]["ID1"] == [[10, 20]]
assert ec3.errors["duplicate_ids"]["ID2"] == [[30, 40]]
assert ec3.errors["duplicate_ids"]["ID3"] == [[50, 60]]
print("✓ Dictionaries werden gemerged (nicht verschachtelt)")

# Test 4: Liste bleibt Liste
print("\nTest 4: Liste bleibt Liste (overdefined_tunnel)")
ec4 = ErrorCollector()
ec4.add_errors({"overdefined_tunnel": ["TUNNEL1", "TUNNEL2"]})
assert isinstance(ec4.errors["overdefined_tunnel"], list)
assert ec4.errors["overdefined_tunnel"] == ["TUNNEL1", "TUNNEL2"]
print("✓ Liste bleibt Liste")

# Test 5: Liste Extend bei mehrmaligem Hinzufügen
print("\nTest 5: Liste Extend bei zweimaligem Hinzufügen")
ec5 = ErrorCollector()
ec5.add_errors({"tunnel_errors": ["T1", "T2"]})
ec5.add_errors({"tunnel_errors": ["T3", "T4"]})
assert isinstance(ec5.errors["tunnel_errors"], list)
assert ec5.errors["tunnel_errors"] == ["T1", "T2", "T3", "T4"]
print("✓ Listen werden extended (nicht verschachtelt)")

# Test 6: Warnungen mit Dictionary (missing_attributes)
print("\nTest 6: Warnungen mit Dictionary (missing_attributes)")
ec6 = ErrorCollector()
missing_attrs = {"BX0101": "Fehlendes Attribut A", "BX0102": "Fehlendes Attribut B"}
ec6.add_warnings({"missing_attributes": missing_attrs})
assert isinstance(ec6.warnings["missing_attributes"], dict)
assert ec6.warnings["missing_attributes"]["BX0101"] == "Fehlendes Attribut A"
print("✓ Warnung Dictionary bleibt Dictionary")

# Test 7: Warnungen Dictionary Merge
print("\nTest 7: Warnungen Dictionary Merge")
ec7 = ErrorCollector()
ec7.add_warnings({"missing_attributes": {"ID1": "Error 1"}})
ec7.add_warnings({"missing_attributes": {"ID2": "Error 2"}})
assert isinstance(ec7.warnings["missing_attributes"], dict)
assert ec7.warnings["missing_attributes"]["ID1"] == "Error 1"
assert ec7.warnings["missing_attributes"]["ID2"] == "Error 2"
print("✓ Warnungs-Dictionaries werden gemerged")

# Test 8: Mixed - mehrere Keys mit verschiedenen Typen
print("\nTest 8: Mixed - verschiedene Typen gleichzeitig")
ec8 = ErrorCollector()
ec8.add_errors({
    "string_errors": "Error 1",
    "dict_errors": {"ID1": [[1, 2]]},
    "list_errors": ["Item1", "Item2"]
})
ec8.add_errors({
    "string_errors": "Error 2",
    "dict_errors": {"ID2": [[3, 4]]},
    "list_errors": ["Item3"]
})
assert ec8.errors["string_errors"] == ["Error 1", "Error 2"]
assert ec8.errors["dict_errors"] == {"ID1": [[1, 2]], "ID2": [[3, 4]]}
assert ec8.errors["list_errors"] == ["Item1", "Item2", "Item3"]
print("✓ Verschiedene Typen werden korrekt behandelt")

# Test 9: Reales getpositions.py Szenario
print("\nTest 9: Reales getpositions.py Szenario")
ec9 = ErrorCollector()
# Wie in getpositions.py
double_ids = {}
double_ids["MA-1001"] = [[100, 200], [300, 400]]
double_ids["MA-1002"] = [[500, 600]]
ec9.add_errors({"double_ids": double_ids})

missing_attribs = {}
missing_attribs["BX0101"] = "Nur ein Block und/oder fehlende Attribute: dict_keys(['A', 'B'])"
ec9.add_warnings({"missing_attributes": missing_attribs})

assert isinstance(ec9.errors["double_ids"], dict)
assert isinstance(ec9.warnings["missing_attributes"], dict)
# Verifiziere dass es für .items() funktioniert
for id_name, positions in ec9.errors["double_ids"].items():
    assert isinstance(id_name, str)
    assert isinstance(positions, list)
print("✓ getpositions.py Format funktioniert für ioconverter.py")

# Test 10: Reales create_numbers.py Szenario
print("\nTest 10: Reales create_numbers.py Szenario")
ec10 = ErrorCollector()
# Mehrmals einzelne Strings mit gleichem Key
ec10.add_errors({"symbol_with_at_not_in_boundary": "Symbol at (10, 20) not in boundary"})
ec10.add_errors({"symbol_with_at_not_in_boundary": "Symbol at (30, 40) not in boundary"})
ec10.add_errors({"symbol_with_at_not_in_boundary": "Symbol at (50, 60) not in boundary"})

# Liste mit mehreren Elementen
ec10.add_errors({"no_symbols_found": [
    "Renamer 'BG-1@@@' hat keine Symbole gefunden",
    "Renamer 'BG-2@@@' hat keine Symbole gefunden"
]})

assert isinstance(ec10.errors["symbol_with_at_not_in_boundary"], list)
assert len(ec10.errors["symbol_with_at_not_in_boundary"]) == 3
assert isinstance(ec10.errors["no_symbols_found"], list)
assert len(ec10.errors["no_symbols_found"]) == 2

# Prüfe auf Verschachtelung
for item in ec10.errors["symbol_with_at_not_in_boundary"]:
    assert isinstance(item, str), f"Verschachtelung gefunden: {type(item)}"
print("✓ create_numbers.py Format - keine Verschachtelung")

# Test 11: Realistisches Szenario mit vielen Fehleraufrufen (wie test_real_scenario.py)
print("\nTest 11: Realistisches Szenario mit vielen einzelnen Fehleraufrufen")
ec11 = ErrorCollector()

# Simuliere "no_symbols_found" Fehler als Liste
ec11.add_errors({
    "no_symbols_found": [
        "Renamer-Block-Gruppe 'BG-1@@@' (DIRECTION: LEFT_RIGHT) hat keine passenden Symbole gefunden. Gesucht auf Layer: ILS_Eingang, ILS_Ausgang. Renamer-Blöcke an Positionen: (300.0, 500.0), (3000.0, 2000.0)",
        "Renamer-Block-Gruppe 'BG-2@@@' (DIRECTION: LEFT_RIGHT) hat keine passenden Symbole gefunden. Gesucht auf Layer: ILS_Eingang, ILS_Ausgang. Renamer-Blöcke an Positionen: (3200.0, 500.0)"
    ]
})

# Simuliere viele einzelne "symbol_with_at_not_in_boundary" Fehler
ec11.add_errors({"symbol_with_at_not_in_boundary": "Symbol an Position (95.5, 509.5) mit IO='BG-1@@' auf Layer 'ILS_MOTOR' enthält '@' im IO-Attribut, liegt aber in keinem Renamer-Bereich."})
ec11.add_errors({"symbol_with_at_not_in_boundary": "Symbol an Position (2895.5, 2159.5) mit IO='BG-1@@' auf Layer 'ILS_MOTOR' enthält '@' im IO-Attribut, liegt aber in keinem Renamer-Bereich."})
ec11.add_errors({"symbol_with_at_not_in_boundary": "Symbol an Position (4195.5, 2209.5) mit IO='BG-1@@' auf Layer 'ILS_MOTOR' enthält '@' im IO-Attribut, liegt aber in keinem Renamer-Bereich."})
ec11.add_errors({"symbol_with_at_not_in_boundary": "Symbol an Position (5495.5, 2109.5) mit IO='BG-1@@' auf Layer 'ILS_MOTOR' enthält '@' im IO-Attribut, liegt aber in keinem Renamer-Bereich."})
ec11.add_errors({"symbol_with_at_not_in_boundary": "Symbol an Position (2895.5, 2609.5) mit IO='MB-1@@' auf Layer 'ILS_MOTOR' enthält '@' im IO-Attribut, liegt aber in keinem Renamer-Bereich."})
ec11.add_errors({"symbol_with_at_not_in_boundary": "Symbol an Position (4195.5, 2659.5) mit IO='MB-1@@' auf Layer 'ILS_MOTOR' enthält '@' im IO-Attribut, liegt aber in keinem Renamer-Bereich."})
ec11.add_errors({"symbol_with_at_not_in_boundary": "Symbol an Position (5495.5, 2559.5) mit IO='MB-1@@' auf Layer 'ILS_MOTOR' enthält '@' im IO-Attribut, liegt aber in keinem Renamer-Bereich."})
ec11.add_errors({"symbol_with_at_not_in_boundary": "Symbol an Position (3095.5, 509.5) mit IO='BG-2@@' auf Layer 'ILS_MOTOR' enthält '@' im IO-Attribut, liegt aber in keinem Renamer-Bereich."})
ec11.add_errors({"symbol_with_at_not_in_boundary": "Symbol an Position (4395.5, 509.5) mit IO='BG-2@@' auf Layer 'ILS_MOTOR' enthält '@' im IO-Attribut, liegt aber in keinem Renamer-Bereich."})
ec11.add_errors({"symbol_with_at_not_in_boundary": "Symbol an Position (5695.5, 509.5) mit IO='BG-2@@' auf Layer 'ILS_MOTOR' enthält '@' im IO-Attribut, liegt aber in keinem Renamer-Bereich."})

# Verifiziere Struktur
assert isinstance(ec11.errors["symbol_with_at_not_in_boundary"], list)
assert len(ec11.errors["symbol_with_at_not_in_boundary"]) == 10
assert isinstance(ec11.errors["no_symbols_found"], list)
assert len(ec11.errors["no_symbols_found"]) == 2

# Überprüfe, dass KEINE Verschachtelung vorliegt
symbol_errors = ec11.errors["symbol_with_at_not_in_boundary"]
all_strings = all(isinstance(item, str) for item in symbol_errors)
no_nested_lists = not any(isinstance(item, list) for item in symbol_errors)
assert all_strings, "Nicht alle Einträge sind Strings!"
assert no_nested_lists, "Verschachtelte Listen gefunden!"

print("✓ Realistisches Szenario mit 10 einzelnen Fehleraufrufen - keine Verschachtelung")

print("\n" + "="*70)
print("✓✓✓ ALLE TESTS BESTANDEN ✓✓✓")
print("="*70)
print("\nZusammenfassung:")
print("  - Strings → Listen (flach, keine Verschachtelung)")
print("  - Dictionaries → Dictionaries (gemerged bei mehrmaligem Hinzufügen)")
print("  - Listen → Listen (extended bei mehrmaligem Hinzufügen)")
print("  - Mixed Types werden korrekt behandelt")
print("  - Kompatibel mit getpositions.py und create_numbers.py")
print("  - Kompatibel mit ioconverter.py Erwartungen")
print("  - Realistisches Szenario mit vielen einzelnen Aufrufen funktioniert")