#!/usr/bin/env python
"""
DELTA HEAT PERSISTENCE TEST: Genesis of Domain [14] (Hold) and [42] (Deep Storage)

Math:
- [7] = Persist (The Hard Drive)
- [2] * [7] = [14] = Hold (Mechanism of Persistence = The "Save" Command)
- [6] * [7] = [42] = Persistent Flip (Deep Storage / Log File)

Heat:
- Delta Heat tracks atomic change over time
- A write operation generates heat (complexity increase)
"""
from logos.mtl.interpreter import MTLInterpreter

mtl = MTLInterpreter()

print('=' * 60)
print('   DELTA HEAT PERSISTENCE TEST (Genesis of [14] and [42])')
print('=' * 60)

# === PHASE 1: Recreate the Volatile State ===
print('\n[PHASE 1] Recreating Volatile State in Domain [6]')
mtl.execute('(domain [2])')
mtl.execute('(store inverter (list -1 -1 -1))')
mtl.execute('(domain [3])')
mtl.execute('(store state (list 10 20 30))')
mtl.execute('(domain [6])')
mtl.execute('(store fused_state (mult (in-domain [2] (fetch inverter)) (in-domain [3] (fetch state))))')
volatile = mtl.execute('(fetch fused_state)')
print(f'   Volatile Data in [6]: {volatile}')

# === PHASE 2: Apply Persist Factor [7] ===
print('\n[PHASE 2] Applying Persist Factor [7] -> Deep Storage [42]')
# Domain [42] = [6] * [7] = Persistent Flip
# We store the volatile data into [42], encoding it as "persisted"
mtl.execute('(domain [42])')
# Persist the data by wrapping it with the storage context
mtl.execute('(store log_entry_001 (in-domain [6] (fetch fused_state)))')
persisted = mtl.execute('(fetch log_entry_001)')
print(f'   Persisted Data in [42]: {persisted}')

# === PHASE 3: Hold Operation via Domain [14] ===
print('\n[PHASE 3] "Hold" Operation - Domain [14] = Mechanism of Persistence')
# Domain [14] acts as the "Save" mechanism
# It should provide a function to commit volatile -> persistent

mtl.execute('(domain [14])')
# Store the "address" of what we're holding, not the data itself (pointer logic)
# In LOGOS, we can use the composite ID as a reference
mtl.execute('(store held_ref [42])')  # Holding reference to [42]
mtl.execute('(store held_timestamp 1736582400)')  # Unix timestamp (conceptual)
held = mtl.execute('(get-domain [14])')
print(f'   Hold Registry [14]: {held}')

# === PHASE 4: Delta Heat Tracking ===
print('\n[PHASE 4] Delta Heat Calculation')
# Heat = Complexity of operation
# Original state in [3]: [10, 20, 30]
# Final state in [42]: [-10, -20, -30]
# Delta = sum of absolute changes

original = [10, 20, 30]
final = [-10, -20, -30]
delta_heat = sum(abs(o - f) for o, f in zip(original, final))
print(f'   Original State: {original}')
print(f'   Final State: {final}')
print(f'   Delta Heat: {delta_heat}')

# Store heat metric in the Hold domain
mtl.execute(f'(store delta_heat {delta_heat})')
print(f'   Heat logged in [14]: {mtl.execute("(fetch delta_heat)")}')

# === PHASE 5: Domain Map Verification ===
print('\n[PHASE 5] Final Domain Map')
print('=' * 40)
for domain_key in [2, 3, 6, 7, 14, 42]:
    contents = mtl.domains.get(domain_key, {})
    if contents:
        print(f'   [{domain_key:2d}] {contents}')

# === VERIFICATION ===
print('\n' + '=' * 60)
if persisted == [-10, -20, -30] and delta_heat == 120:
    print('✅ PERSISTENCE VERIFIED: Volatile -> Permanent Storage')
    print('✅ DELTA HEAT CALCULATED: Atomic Change Tracked')
    print(f'   [6] Flip → [42] Deep Storage (6 × 7 = 42)')
    print(f'   [14] Hold = Mechanism of Persistence')
else:
    print('❌ Verification Failed')