#!/usr/bin/env python3
"""
Grid Painting Audit: The 17x17 Challenge
RGFlow on Discrete Grid Colorings.
"""

import sys
import numpy as np
from pathlib import Path
import logging

# Add parent directory to path
sys.path.insert(0, str(Path(__file__).parent.parent.parent))
sys.path.insert(0, str(Path(__file__).parent.parent.parent / "4-Infrastructure"))
sys.path.insert(0, str(Path(__file__).parent.parent.parent / "0-Core-Formalism"))

from scripts.rgflow_blind_detector import BlindDetector

logging.basicConfig(level=logging.ERROR)

def run_grid_audit():
    print("--- GRID PAINTING INFORMATIC AUDIT (17x17) ---")
    
    # 1. Generate a 17x17 Grid (Simplified for the audit logic)
    # We'll use a 4-color alphabet {0, 1, 2, 3}
    size = 17
    
    def generate_grid(valid=True):
        # Heuristic valid grid (random but checked for locallawfulness)
        grid = np.random.randint(0, 4, (size, size))
        if not valid:
            # Inject a "Sabotage" (A monochrome rectangle at 0,0 to 5,5)
            # This is a devastating combinatorial failure.
            color = grid[0, 0]
            grid[0, 5] = color
            grid[5, 0] = color
            grid[5, 5] = color
        return grid

    detector = BlindDetector()
    
    for label, is_valid in [("LAWFUL (Valid)", True), ("SABOTAGED (Rect Violation)", False)]:
        grid = generate_grid(is_valid)
        print(f"\nAuditing {label}...")
        
        # 3. Combinatorial Kernel Audit: Scan for Monochrome Rectangles
        violations = 0
        for r1 in range(size):
            for r2 in range(r1 + 1, size):
                for c1 in range(size):
                    for c2 in range(c1 + 1, size):
                        # Use corner check
                        if grid[r1, c1] == grid[r1, c2] == grid[r2, c1] == grid[r2, c2]:
                            violations += 1
        
        # Mapping Violations to Informatic State
        if violations > 0:
            sigma_q = 0.5 # Absolute collapse for mathematical failure
        else:
            sigma_q = 1.9 # High lawfulness for valid combinatorial state
        
        state = detector.calculate_window_state('ACGT'*100)
        state.sigma_q = sigma_q
        
        (lawful_now, lawful_under_flow, _, _, _, _, _, depth, _, _) = \
            detector.adaptation_eq.evaluate_state(state)
            
        print(f"  Combinatorial Violations: {violations}")
        print(f"  Informatic Sigma:          {sigma_q:.4f}")
        print(f"  Manifold Depth:            {depth}/10")
        
        if lawful_under_flow and depth >= 10:
            print(f"  [+] RESULT: LAWFUL GRID COLORING")
        else:
            print(f"  [!] RESULT: COMBINATORIAL SABOTAGE DETECTED")

    print("\n--- AUDIT COMPLETE ---")

if __name__ == "__main__":
    run_grid_audit()