# -*- coding: utf-8 -*-
"""
BANCO DE PRUEBAS AISLADAS V5 — TEITAN RESCUE ENGINE
Valida focalizadamente las 7 condiciones exigidas por el Creador:
1. TEST_EXCLUSION_EXCLUSIVE_PRESENCE_LOCK: Exclusión ÚNICA de presence/*.lock; otros .lock se conservan.
2. TEST_NO_EXCLUSION_CRITICAL_FILES: Memorias, contratos y Digital Optimus jamás se excluyen.
3. TEST_EXCLUSION_LOGGING: Registro transparente y detallado de exclusiones justificadas.
4. TEST_REUSE_EXISTING_SQLITE_CHECKPOINT: Reutilización de los 147,609 registros del checkpoint SQLite de Kingston.
5. TEST_NO_READ_SOURCE_ALREADY_VERIFIED: CERO lecturas al SSD C: para archivos ya verificados en Kingston.
6. TEST_DYNAMIC_CAPACITY_CHECK: Evaluación dinámica sin bloqueo erróneo de 135 GiB cuando ya hay archivos staged.
7. TEST_BLOCK_ON_NON_AUTHORIZED_ERROR: Bloqueo inmediato ante cualquier error fuera de presence/*.lock.
"""

import os
import sys
import shutil
import zipfile
import hashlib
import tempfile
import json
import uuid
import sqlite3

sys.path.insert(0, r"C:\Users\intel\AR88_Sandbox")
import teitan_backup_engine as engine

def test_1_exclusion_exclusive_presence_lock():
    # Caso 1: presence lock de antigravity -> DEBE EXCLUIRSE
    f_presence = r"C:\Users\intel\.gemini\antigravity\presence\613250f9-a68b-4888-ad13-bea2aa011bad.lock"
    assert engine.is_presence_lock_file(f_presence) is True

    # Caso 2: lock en otra carpeta de antigravity -> NO EXCLUIR
    f_other_gemini = r"C:\Users\intel\.gemini\antigravity\brain\session.lock"
    assert engine.is_presence_lock_file(f_other_gemini) is False

    # Caso 3: lock en Digital Optimus -> NO EXCLUIR
    f_prod_lock = r"C:\xampp\htdocs\Digital Optimus\storage\app.lock"
    assert engine.is_presence_lock_file(f_prod_lock) is False

    # Caso 4: lock en base de datos o MySQL -> NO EXCLUIR
    f_mysql_lock = r"C:\xampp\mysql\data\ibdata1.lock"
    assert engine.is_presence_lock_file(f_mysql_lock) is False
    return "PASS"

def test_2_no_exclusion_critical_files():
    inv = engine.build_prioritized_inventory()
    # Verificar que los contratos y memorias siguen presentes en core
    norte_found = any(r"DIGITAL_OPTIMUS_NORTE_MAESTRO" in f for f in inv["core"])
    driver_found = any(r"Driver GT 710 Original\Digital_Optimus_Complete_Project.zip" in f for f in inv["core"])
    do_count = inv["digital_optimus_count"]
    
    assert norte_found, "NORTE MAESTRO fue omitido indebidamente"
    assert driver_found, "Driver GT 710 ZIP fue omitido indebidamente"
    assert do_count == 102192, f"Digital Optimus incompleto: {do_count}"
    return "PASS"

def test_3_exclusion_logging():
    inv = engine.build_prioritized_inventory()
    exclusions = inv["justified_exclusions"]
    assert len(exclusions) >= 1, "No se registraron las exclusiones de presence"
    for e in exclusions:
        assert e["reason"] == "VOLATILE_ANTIGRAVITY_PRESENCE_LOCK"
        assert e["path"].endswith(".lock")
        assert "presence" in e["path"]
    return "PASS"

def test_4_and_5_reuse_checkpoint_and_no_source_read():
    # Comprobar directamente contra la base real de Kingston en E:
    real_db_path = r"E:\TEITAN_RESCUE_OUTPUT\stage_checkpoint.sqlite"
    assert os.path.exists(real_db_path), "No existe la base de checkpoint en E:"
    
    ckpt = engine.CheckpointDB(real_db_path)
    total_staged = ckpt.get_total_staged_bytes()
    assert total_staged > 3 * 1024 * 1024 * 1024, f"Bytes en checkpoint insuficientes: {total_staged}"

    # Tomar un archivo verificado del checkpoint y comprobar que atomic_copy_and_verify no lee C:
    conn = sqlite3.connect(real_db_path)
    c = conn.cursor()
    c.execute("SELECT norm_source, original_source, staged_path, bytes, sha256 FROM file_checkpoints WHERE status = 'VERIFIED' LIMIT 1")
    row = c.fetchone()
    conn.close()

    norm_src, orig_src, staged_p, b_count, expected_sha = row
    assert os.path.exists(staged_p), f"Archivo no existe en stage: {staged_p}"

    # Probar que devuelve RESUMED_VERIFIED_NO_READ_SOURCE
    # Pasamos una ruta ficticia inaccesible como 'src' para demostrar matemáticamente que NO toca C:
    fake_unreadable_src = r"C:\DISCO_ROTO_NO_EXISTE_FAKE.dat"
    # Registramos momentáneamente fake en ckpt con datos de staged_p para verificar la guardia
    fake_norm = os.path.normcase(fake_unreadable_src)
    ckpt.record_entry(fake_norm, fake_unreadable_src, staged_p, b_count, expected_sha, "VERIFIED")

    bytes_ret, sha_ret, status = engine.atomic_copy_and_verify(fake_unreadable_src, staged_p, ckpt)
    assert status == "RESUMED_VERIFIED_NO_READ_SOURCE"
    assert sha_ret == expected_sha
    return "PASS"

def test_6_dynamic_capacity_check():
    # En Kingston E: hay ~196 GiB libres. Con 3.5 GB staged, los bytes pendientes son ~58 GB.
    # El espacio requerido dinámico es: ~58 GB + 55 GB (ZIP) + 15 GB (margen) = ~128 GB.
    # 196 GiB > 128 GiB -> Debe permitir la ejecución sin el bloqueo rígido previo de 135 GiB.
    free_bytes = shutil.disk_usage("E:\\").free
    pending_mock = 58 * 1024 * 1024 * 1024
    required = pending_mock + (55 * 1024 * 1024 * 1024) + engine.SAFETY_MARGIN_BYTES
    assert free_bytes > required, f"Fallo en evaluación de capacidad: {free_bytes} < {required}"
    return "PASS"

def test_7_block_on_non_authorized_error():
    with tempfile.TemporaryDirectory() as tmpdir:
        db_path = os.path.join(tmpdir, "test.sqlite")
        ckpt = engine.CheckpointDB(db_path)
        # Archivo que no existe o tiene error y NO es presence lock
        bad_file = os.path.join(tmpdir, "critical_contract.json")
        dst = os.path.join(tmpdir, "dst.json")

        manifest, errors = engine.stage_copy_group([bad_file], tmpdir, ckpt, "TEST_ERR")
        assert len(errors) == 1, "No se detectó el error de archivo crítico faltante"
        assert len(manifest) == 0
    return "PASS"

def run_suite():
    tests = [
        ("1. Exclusion exclusiva de presence/*.lock", test_1_exclusion_exclusive_presence_lock),
        ("2. No exclusion de contratos ni Digital Optimus", test_2_no_exclusion_critical_files),
        ("3. Registro detallado de exclusiones justificadas", test_3_exclusion_logging),
        ("4. Reutilizacion y no relectura desde SQLite Kingston", test_4_and_5_reuse_checkpoint_and_no_source_read),
        ("5. Evaluacion dinamica de capacidad en Kingston", test_6_dynamic_capacity_check),
        ("6. Bloqueo ante error distinto de exclusion autorizada", test_7_block_on_non_authorized_error)
    ]

    print("=" * 68)
    print("  EJECUTANDO BANCO DE PRUEBAS AISLADAS V5 — TEITAN RESCUE ENGINE")
    print("=" * 68)

    all_pass = True
    for desc, func in tests:
        try:
            res = func()
            print(f"  [{res}] {desc}")
        except Exception as e:
            print(f"  [FAIL] {desc} -> {e}")
            all_pass = False

    print("=" * 68)
    print(f"RESULTADO: {'TODAS LAS PRUEBAS SUPERADAS (PASS)' if all_pass else 'FALLAS DETECTADAS'}")
    return all_pass

if __name__ == "__main__":
    ok = run_suite()
    sys.exit(0 if ok else 1)