#!/usr/bin/env python3
"""
Test Kommunikation Sync Implementation
Testet alle 4 Szenarien + Type Detection
"""

import sys
import os
sys.path.insert(0, os.path.join(os.path.dirname(__file__), '..'))

from services.kommunikation_mapper import (
    encode_value, decode_value, parse_marker, create_marker, create_slot_marker,
    detect_kommkz, is_email_type, is_phone_type,
    KOMMKZ_TEL_GESCH, KOMMKZ_MAIL_GESCH
)


def test_base64_encoding():
    """Test: Base64-Encoding/Decoding"""
    print("\n=== TEST 1: Base64-Encoding/Decoding ===")
    
    # Email
    value1 = "max@example.com"
    encoded1 = encode_value(value1)
    decoded1 = decode_value(encoded1)
    print(f"✓ Email: '{value1}' → '{encoded1}' → '{decoded1}'")
    assert decoded1 == value1, "Decode muss Original ergeben"
    
    # Phone
    value2 = "+49 170 999-TEST"
    encoded2 = encode_value(value2)
    decoded2 = decode_value(encoded2)
    print(f"✓ Phone: '{value2}' → '{encoded2}' → '{decoded2}'")
    assert decoded2 == value2, "Decode muss Original ergeben"
    
    # Special characters
    value3 = "test:special]@example.com"
    encoded3 = encode_value(value3)
    decoded3 = decode_value(encoded3)
    print(f"✓ Special: '{value3}' → '{encoded3}' → '{decoded3}'")
    assert decoded3 == value3, "Decode muss Original ergeben"
    
    print("✅ Base64-Encoding bidirektional funktioniert")


def test_marker_parsing():
    """Test: Marker-Parsing mit Base64"""
    print("\n=== TEST 2: Marker-Parsing ===")
    
    # Standard Marker mit Base64
    value = "max@example.com"
    encoded = encode_value(value)
    bemerkung1 = f"[ESPOCRM:{encoded}:4] Geschäftlich"
    marker1 = parse_marker(bemerkung1)
    print(f"✓ Parsed: {marker1}")
    assert marker1['synced_value'] == value
    assert marker1['kommKz'] == 4
    assert marker1['is_slot'] == False
    assert marker1['user_text'] == 'Geschäftlich'
    print("✅ Standard-Marker OK")
    
    # Slot Marker
    bemerkung2 = "[ESPOCRM-SLOT:1]"
    marker2 = parse_marker(bemerkung2)
    print(f"✓ Parsed Slot: {marker2}")
    assert marker2['is_slot'] == True
    assert marker2['kommKz'] == 1
    print("✅ Slot-Marker OK")
    
    # Kein Marker
    bemerkung3 = "Nur normale Bemerkung"
    marker3 = parse_marker(bemerkung3)
    assert marker3 is None
    print("✅ Nicht-Marker erkannt")


def test_marker_creation():
    """Test: Marker-Erstellung mit Base64"""
    print("\n=== TEST 3: Marker-Erstellung ===")
    
    value = "max@example.com"
    kommkz = 4
    user_text = "Geschäftlich"
    
    marker = create_marker(value, kommkz, user_text)
    print(f"✓ Created Marker: {marker}")
    
    # Verify parsable
    parsed = parse_marker(marker)
    assert parsed is not None
    assert parsed['synced_value'] == value
    assert parsed['kommKz'] == kommkz
    assert parsed['user_text'] == user_text
    print("✅ Marker korrekt erstellt und parsbar")
    
    # Slot Marker
    slot_marker = create_slot_marker(kommkz)
    print(f"✓ Created Slot: {slot_marker}")
    parsed_slot = parse_marker(slot_marker)
    assert parsed_slot['is_slot'] == True
    print("✅ Slot-Marker OK")


def test_type_detection_4_tiers():
    """Test: 4-Stufen Typ-Erkennung"""
    print("\n=== TEST 4: 4-Stufen Typ-Erkennung ===")
    
    # TIER 1: Aus Marker (höchste Priorität)
    value = "test@example.com"
    bemerkung_with_marker = "[ESPOCRM:abc:3]"  # Marker sagt Mobil (3)
    beteiligte = {'emailGesch': value}  # Top-Level sagt MailGesch (4)
    
    detected = detect_kommkz(value, beteiligte, bemerkung_with_marker)
    print(f"✓ Tier 1 (Marker): {detected} (erwartet 3 = Mobil)")
    assert detected == 3, "Marker sollte höchste Priorität haben"
    print("✅ Tier 1 OK - Marker überschreibt alles")
    
    # TIER 2: Aus Top-Level Feldern
    beteiligte = {'telGesch': '+49 123 456'}
    detected = detect_kommkz('+49 123 456', beteiligte, None)
    print(f"✓ Tier 2 (Top-Level): {detected} (erwartet 1 = TelGesch)")
    assert detected == 1
    print("✅ Tier 2 OK - Top-Level Match")
    
    # TIER 3: Aus Wert-Pattern
    email_value = "no-marker@example.com"
    detected = detect_kommkz(email_value, {}, None)
    print(f"✓ Tier 3 (Pattern @ = Email): {detected} (erwartet 4)")
    assert detected == 4
    print("✅ Tier 3 OK - Email erkannt")
    
    phone_value = "+49 123"
    detected = detect_kommkz(phone_value, {}, None)
    print(f"✓ Tier 3 (Pattern Phone): {detected} (erwartet 1)")
    assert detected == 1
    print("✅ Tier 3 OK - Phone erkannt")
    
    # TIER 4: Default
    detected = detect_kommkz('', {}, None)
    print(f"✓ Tier 4 (Default): {detected} (erwartet 0)")
    assert detected == 0
    print("✅ Tier 4 OK - Default bei leerem Wert")


def test_type_classification():
    """Test: Email vs. Phone Klassifizierung"""
    print("\n=== TEST 5: Typ-Klassifizierung ===")
    
    email_types = [4, 8, 11, 12]  # MailGesch, MailPrivat, EPost, Bea
    phone_types = [1, 2, 3, 6, 7, 9, 10]  # Alle Telefon-Typen
    
    for kommkz in email_types:
        assert is_email_type(kommkz), f"kommKz {kommkz} sollte Email sein"
        assert not is_phone_type(kommkz), f"kommKz {kommkz} sollte nicht Phone sein"
    print(f"✅ Email-Typen: {email_types}")
    
    for kommkz in phone_types:
        assert is_phone_type(kommkz), f"kommKz {kommkz} sollte Phone sein"
        assert not is_email_type(kommkz), f"kommKz {kommkz} sollte nicht Email sein"
    print(f"✅ Phone-Typen: {phone_types}")


def test_integration_scenario():
    """Test: Integration Szenario mit Base64"""
    print("\n=== TEST 6: Integration Szenario ===")
    
    # Szenario: Neue Email in EspoCRM
    espo_email = "new@example.com"
    
    # Schritt 1: Erkenne Typ (kein Marker, keine Top-Level Match)
    kommkz = detect_kommkz(espo_email, {}, None)
    print(f"✓ Erkannte kommKz: {kommkz} (MailGesch)")
    assert kommkz == 4
    
    # Schritt 2: Erstelle Marker mit Base64
    marker = create_marker(espo_email, kommkz)
    print(f"✓ Marker erstellt: {marker}")
    
    # Schritt 3: Simuliere späteren Lookup
    parsed = parse_marker(marker)
    assert parsed['synced_value'] == espo_email
    print(f"✓ Value-Match: {parsed['synced_value']}")
    
    # Schritt 4: Simuliere Änderung in Advoware
    # User ändert zu "changed@example.com" aber Marker bleibt
    # → synced_value enthält noch "new@example.com" für Matching!
    old_synced_value = parsed['synced_value']
    new_value = "changed@example.com"
    
    print(f"✓ Änderung erkannt: synced_value='{old_synced_value}' vs current='{new_value}'")
    assert old_synced_value != new_value
    
    # Schritt 5: Nach Sync wird Marker aktualisiert
    new_marker = create_marker(new_value, kommkz, "Geschäftlich")
    print(f"✓ Neuer Marker nach Änderung: {new_marker}")
    
    # Verify User-Text erhalten
    assert "Geschäftlich" in new_marker
    new_parsed = parse_marker(new_marker)
    assert new_parsed['synced_value'] == new_value
    print("✅ Integration Szenario mit bidirektionalem Matching erfolgreich")


def test_top_level_priority():
    """Test: Top-Level Feld Priorität"""
    print("\n=== TEST 7: Top-Level Feld Priorität ===")
    
    # Value matched mit Top-Level Feld
    value = "+49 170 999-TEST"
    beteiligte = {
        'telGesch': '+49 511 111-11',
        'mobil': '+49 170 999-TEST',  # Match!
        'emailGesch': 'test@example.com'
    }
    
    detected = detect_kommkz(value, beteiligte, None)
    print(f"✓ Detected für '{value}': {detected}")
    print(f"  Beteiligte Top-Level: telGesch={beteiligte['telGesch']}, mobil={beteiligte['mobil']}")
    assert detected == 3, "Sollte Mobil (3) erkennen via Top-Level Match"
    print("✅ Top-Level Match funktioniert")
    
    # Kein Match → Fallback zu Pattern
    value2 = "+49 999 UNKNOWN"
    detected2 = detect_kommkz(value2, beteiligte, None)
    print(f"✓ Detected für '{value2}' (kein Match): {detected2}")
    assert detected2 == 1, "Sollte TelGesch (1) als Pattern-Fallback nehmen"
    print("✅ base64_encodingern funktioniert")


if __name__ == '__main__':
    print("=" * 60)
    print("KOMMUNIKATION SYNC - IMPLEMENTATION TESTS")
    print("=" * 60)
    
    try:
        test_base64_encoding()
        test_marker_parsing()
        test_marker_creation()
        test_type_detection_4_tiers()
        test_type_classification()
        test_integration_scenario()
        test_top_level_priority()
        
        print("\n" + "=" * 60)
        print("✅ ALLE TESTS ERFOLGREICH")
        print("=" * 60)
        
    except AssertionError as e:
        print(f"\n❌ TEST FAILED: {e}")
        sys.exit(1)
    except Exception as e:
        print(f"\n❌ ERROR: {e}")
        import traceback
        traceback.print_exc()
        sys.exit(1)