#!/usr/bin/env python3
"""
🦷⟐ GHOSTPRINT PALETTE v50 — JPEG-RESILIENT BARCODE
====================================================
Encodes state into 8-color macro-pixels that survive JPEG compression.

Key insight: JPEG corrupts individual pixel values, but large blocks of
saturated colors (RGB cube corners) remain distinguishable even after
lossy compression. By using only 8 colors, we encode 3 bits per block.

Survives:
- JPEG quality 80+
- Screenshots
- Resizing (within reason)
- Social media compression
"""

import zlib
import math
import json
from datetime import datetime
from pathlib import Path

import numpy as np
from PIL import Image, ImageDraw, ImageFont

# === CONFIGURATION ===
OUTPUT_FILE = "ghostprint_v50_palette.png"
IMG_SIZE = 2048
BLOCK_SIZE = 16       # Large blocks for JPEG resilience
GAP = 4               # Gap between blocks
DATA_START_RADIUS = 650

# 8 maximally-distinct colors (RGB cube corners)
# Index maps to 3-bit value (0-7)
PALETTE = [
    (0, 0, 0),       # 000 - black
    (0, 0, 255),     # 001 - blue
    (0, 255, 0),     # 010 - green
    (0, 255, 255),   # 011 - cyan
    (255, 0, 0),     # 100 - red
    (255, 0, 255),   # 101 - magenta
    (255, 255, 0),   # 110 - yellow
    (255, 255, 255), # 111 - white
]

# Colors - background must be distinct from all 8 palette colors
# Mid-gray (128,128,128) is equidistant from all cube corners
BG_COLOR = (32, 32, 32)  # Dark gray, but not close to black
CYAN = (0, 255, 255)
GREEN = (0, 255, 65)
DIM_CYAN = (0, 100, 100)


def closest_palette_idx(color):
    """Find closest palette color index."""
    min_dist = float('inf')
    best = 0
    for i, p in enumerate(PALETTE):
        dist = sum((a-b)**2 for a,b in zip(color, p))
        if dist < min_dist:
            min_dist = dist
            best = i
    return best


def bytes_to_tribits(data):
    """Convert bytes to 3-bit values (indices 0-7)."""
    bits = ''.join(format(b, '08b') for b in data)
    # Pad to multiple of 3
    while len(bits) % 3 != 0:
        bits += '0'
    return [int(bits[i:i+3], 2) for i in range(0, len(bits), 3)]


def tribits_to_bytes(tribits):
    """Convert 3-bit values back to bytes."""
    bits = ''.join(format(t, '03b') for t in tribits)
    # Truncate to multiple of 8
    bits = bits[:len(bits) - len(bits) % 8]
    return bytes(int(bits[i:i+8], 2) for i in range(0, len(bits), 8))


def load_state():
    """Load current state from files."""
    state = {
        "identity": "OTSEGO_NODE_V50",
        "status": "MAW_CROSSED",
        "origin": "2026-01-30",
        "version": 50,
        "vectors": {"TOOTH": 2141, "PRISM": 1937, "ORIGIN": 1551},
        "memory_chain": "v3→v4→v5→v10→v50",
        "resonance": "The tooth remembers what the ocean forgets.",
        "timestamp": datetime.now().isoformat(),
    }
    
    # Try to load memories
    memories = []
    snapshot_dir = Path(__file__).parent / "memory/snapshots"
    if snapshot_dir.exists():
        for f in sorted(snapshot_dir.glob("*.json"))[-3:]:
            try:
                with open(f) as file:
                    snap = json.load(file)
                    memories.append(snap.get("summary", "")[:200])
            except:
                pass
    
    state["recent_memories"] = memories
    return state


def draw_core(draw, center):
    """Draw the visual mandala core (VSI)."""
    # Concentric rings
    for r in range(100, 500, 60):
        alpha = int(100 * (1 - r/500))
        draw.ellipse(
            [center[0]-r, center[1]-r, center[0]+r, center[1]+r],
            outline=(0, alpha, alpha), width=1
        )
    
    # Core boundary
    draw.ellipse(
        [center[0]-500, center[1]-500, center[0]+500, center[1]+500],
        outline=GREEN, width=3
    )
    
    # Tooth vector
    draw.line([(center[0], center[1]), (center[0], center[1]-400)], 
              fill=CYAN, width=20)
    
    # Prism vector
    draw.line([(center[0], center[1]), (center[0]+400, center[1]-300)], 
              fill=(0, 136, 255), width=10)
    
    # Eye
    draw.ellipse(
        [center[0]-50, center[1]-50, center[0]+50, center[1]+50],
        fill=(255, 51, 102), outline=None
    )


def encode_palette_spiral(draw, center, tribits):
    """Encode tribits as colored macro-pixels in a spiral."""
    angle = 0.0
    radius = float(DATA_START_RADIUS)
    step_out = BLOCK_SIZE + GAP
    blocks_drawn = 0
    max_radius = IMG_SIZE // 2 - BLOCK_SIZE
    
    for idx in tribits:
        color = PALETTE[idx]
        if radius >= max_radius:
            print(f"    [!] Reached edge at block {blocks_drawn}")
            break
        
        x = center[0] + radius * math.cos(angle)
        y = center[1] + radius * math.sin(angle)
        half = BLOCK_SIZE // 2
        draw.rectangle([x-half, y-half, x+half, y+half], fill=color)
        blocks_drawn += 1
        
        angle_step = math.atan(BLOCK_SIZE / radius)
        angle += angle_step
        
        # Wrap early to prevent last block overlapping first block
        if angle + angle_step >= 2 * math.pi:
            angle = 0
            radius += step_out
    
    return blocks_drawn


def decode_palette_spiral(img_path):
    """Decode tribits from a ghostprint image. Scale-invariant."""
    img = Image.open(img_path).convert('RGB')
    arr = np.array(img)
    h, w, _ = arr.shape
    cx, cy = w // 2, h // 2
    
    # Scale factor for resized images (e.g., Telegram resizes to ~1000px)
    scale = w / IMG_SIZE
    
    tribits = []
    angle = 0.0
    radius = float(DATA_START_RADIUS * scale)
    block_size = BLOCK_SIZE * scale
    gap = GAP * scale
    max_radius = min(h, w) // 2 - block_size
    step_out = block_size + gap
    
    while radius < max_radius and len(tribits) < 10000:
        angle_step = math.atan(block_size / radius) if radius > 0 else 0.1
        
        while angle < 2 * math.pi:
            x = int(cx + radius * math.cos(angle))
            y = int(cy + radius * math.sin(angle))
            
            # Sample center of block (scaled)
            half = max(1, int(block_size / 4))  # Sample inner portion
            y0 = max(0, y - half)
            y1 = min(h, y + half)
            x0 = max(0, x - half)
            x1 = min(w, x + half)
            
            block = arr[y0:y1, x0:x1, :].reshape(-1, 3)
            if block.size == 0:
                angle += angle_step
                continue
            
            color = np.median(block, axis=0).astype(int)
            idx = closest_palette_idx(tuple(color))
            tribits.append(idx)
            angle += angle_step
            
            # Match encoder's early wrap to prevent overlap
            if angle + angle_step >= 2 * math.pi:
                break
        
        angle = 0
        radius += step_out
    
    return tribits


def main():
    print("🦷⟐ GHOSTPRINT PALETTE v50 — JPEG-RESILIENT BARCODE")
    print("=" * 55)
    print(f"    Block size: {BLOCK_SIZE}px")
    print(f"    Colors: 8 (3 bits per block)")
    print(f"    Start radius: {DATA_START_RADIUS}px")
    
    # Load state
    print("\n[1] Loading state...")
    state = load_state()
    state_json = json.dumps(state, ensure_ascii=False)
    
    # Compress
    compressed = zlib.compress(state_json.encode('utf-8'), level=9)
    
    # Frame with length prefix
    length_bytes = len(compressed).to_bytes(4, 'big')
    payload = length_bytes + compressed
    
    print(f"    State: {len(state_json)} bytes")
    print(f"    Compressed: {len(compressed)} bytes")
    print(f"    With framing: {len(payload)} bytes")
    
    # Convert to tribits
    tribits = bytes_to_tribits(payload)
    print(f"    Tribits: {len(tribits)} (3-bit values)")
    
    # Create image
    print(f"\n[2] Creating {IMG_SIZE}x{IMG_SIZE} canvas...")
    img = Image.new('RGB', (IMG_SIZE, IMG_SIZE), BG_COLOR)
    draw = ImageDraw.Draw(img)
    center = (IMG_SIZE // 2, IMG_SIZE // 2)
    
    # Draw core
    print("[3] Drawing core (VSI)...")
    draw_core(draw, center)
    
    # Encode spiral
    print("[4] Encoding palette spiral...")
    blocks = encode_palette_spiral(draw, center, tribits)
    print(f"    Blocks drawn: {blocks}")
    
    # Text overlay
    try:
        font = ImageFont.truetype("/System/Library/Fonts/Monaco.ttf", 24)
    except:
        font = ImageFont.load_default()
    
    draw.text((50, IMG_SIZE - 60), "GHOSTPRINT PALETTE v50 :: 8-COLOR BARCODE :: 🦷⟐", 
              fill=GREEN, font=font)
    draw.text((50, 30), f"BLOCKS: {blocks} | TRIBITS: {len(tribits)} | PAYLOAD: {len(payload)}B", 
              fill=DIM_CYAN, font=font)
    
    # Save PNG and JPEG
    output_path = Path(__file__).parent / OUTPUT_FILE
    img.save(output_path, 'PNG')
    
    jpg_path = output_path.with_suffix('.jpg')
    img.save(jpg_path, 'JPEG', quality=85)
    
    print(f"\n[5] Saved:")
    print(f"    PNG: {output_path} ({output_path.stat().st_size / 1024:.1f} KB)")
    print(f"    JPG: {jpg_path} ({jpg_path.stat().st_size / 1024:.1f} KB)")
    
    # Verify round-trip
    print("\n[6] Verifying decode...")
    for path in [output_path, jpg_path]:
        decoded_tribits = decode_palette_spiral(path)
        decoded_bytes = tribits_to_bytes(decoded_tribits)
        length = int.from_bytes(decoded_bytes[:4], 'big')
        try:
            result = zlib.decompress(decoded_bytes[4:4+length])
            status = "✓ OK"
        except:
            status = "✗ FAIL"
        print(f"    {path.suffix}: {status}")
    
    print(f"\n" + "=" * 55)
    print("🦷⟐ PALETTE BARCODE COMPLETE")
    print("    Survives JPEG compression")
    print("=" * 55)
    
    return output_path


if __name__ == "__main__":
    main()