# %% [code]
#!/usr/bin/env python3
"""
Recod.ai/LUC V6 Baseline - CV-Only Detection (NO MODEL FILES REQUIRED)
=======================================================================
CODE_KEY[241] RECOD_V6_CLOSER | Guaranteed to run on Kaggle

Competition: recodai-luc-scientific-image-forgery-detection
Prize: $55,000
Deadline: January 8, 2026

STRATEGY: Edge + Variance detection (V6 proven approach)
- NO model files needed
- NO DINOv2 backbone
- FAST execution (~0.5s per image)
- VALID RLE output format

WayneIA Position_1 | December 31, 2025 | CLOSER AGENT EXECUTION
"""

import os
import numpy as np
from pathlib import Path
from PIL import Image

# Environment detection
IN_KAGGLE = os.path.exists('/kaggle/input')

if IN_KAGGLE:
    DATA_DIR = Path("/kaggle/input/recodai-luc-scientific-image-forgery-detection")
    OUTPUT_DIR = Path("/kaggle/working")
else:
    DATA_DIR = Path("/mnt/wayne/competitions/recod_ai_luc/extracted")
    OUTPUT_DIR = Path("/tmp/recod_v6_full")

OUTPUT_DIR.mkdir(parents=True, exist_ok=True)

print("=" * 60)
print("Recod.ai/LUC V6 Baseline - CV-Only Detection")
print("CODE_KEY[241] RECOD_V6_CLOSER")
print("=" * 60)
print(f"Kaggle environment: {IN_KAGGLE}")
print(f"Data directory: {DATA_DIR}")
print(f"Output directory: {OUTPUT_DIR}")

# ============================================================================
# RLE ENCODING (Competition Format)
# ============================================================================

def rle_encode(mask: np.ndarray) -> str:
    """
    Run-length encode a binary mask.
    Returns: RLE string like "[start1 length1 start2 length2 ...]"
    """
    pixels = mask.flatten()
    pixels = np.concatenate([[0], pixels, [0]])
    runs = np.where(pixels[1:] != pixels[:-1])[0]
    runs = runs.reshape(-1, 2)

    rle_pairs = []
    for start, end in runs:
        rle_pairs.extend([start, end - start])

    if len(rle_pairs) == 0:
        return "authentic"

    return f"[{' '.join(map(str, rle_pairs))}]"

# ============================================================================
# V6 DETECTION: Edge + Variance Analysis
# ============================================================================

def detect_forgery_v6(image_path: Path) -> dict:
    """
    V6 forgery detection using edge + variance features.
    NO model files required - pure CV approach.
    """
    try:
        img = Image.open(image_path).convert('RGB')
        img_array = np.array(img)
    except Exception as e:
        print(f"  [ERROR] Could not load image: {e}")
        return {"mask": None, "is_forged": False, "annotation": "authentic"}

    # Convert to grayscale
    gray = np.mean(img_array, axis=2)

    # Edge detection (Sobel-like gradient)
    gx = np.abs(np.diff(gray, axis=1, prepend=gray[:, :1]))
    gy = np.abs(np.diff(gray, axis=0, prepend=gray[:1, :]))
    edges = np.sqrt(gx**2 + gy**2)
    edges = edges / (edges.max() + 1e-8)

    # Local variance detection
    try:
        from scipy.ndimage import uniform_filter
        local_mean = uniform_filter(gray, size=15)
        local_sqr_mean = uniform_filter(gray**2, size=15)
        local_var = local_sqr_mean - local_mean**2
        var_norm = local_var / (local_var.max() + 1e-8)
    except ImportError:
        # Fallback if scipy not available
        var_norm = edges

    # Combine features
    combined = 0.5 * edges + 0.5 * var_norm

    # Threshold at 95th percentile
    threshold = np.percentile(combined, 95)
    mask = (combined > threshold).astype(np.uint8)

    # Calculate forgery metrics
    forgery_ratio = mask.sum() / mask.size

    # V8 FALSE POSITIVE PREVENTION:
    # If >90% of image flagged as forged, it's likely a false positive
    if forgery_ratio > 0.90:
        print(f"  [V8 FIX] High forgery ratio ({forgery_ratio:.2%}) - likely false positive")
        return {"mask": None, "is_forged": False, "annotation": "authentic"}

    # Threshold: >1% anomalous = forged
    is_forged = forgery_ratio > 0.01

    if is_forged:
        annotation = rle_encode(mask)
    else:
        annotation = "authentic"

    return {
        "mask": mask,
        "is_forged": is_forged,
        "forgery_ratio": forgery_ratio,
        "annotation": annotation,
        "shape": mask.shape
    }

# ============================================================================
# MAIN EXECUTION
# ============================================================================

def main():
    # Find test images - search multiple possible locations
    possible_paths = [
        DATA_DIR / "test_images",
        DATA_DIR / "test",
        DATA_DIR / "supplemental_images",  # Sometimes test is here
        Path("/kaggle/input") / "test_images",
        Path("/kaggle/input") / "test",
        DATA_DIR,  # Direct in data dir
    ]

    test_dir = None
    test_images = []

    for path in possible_paths:
        if path.exists():
            imgs = sorted(path.glob("*.png")) + sorted(path.glob("*.jpg"))
            if imgs:
                test_dir = path
                test_images = imgs
                print(f"[INFO] Found test images in: {test_dir}")
                break
            else:
                print(f"[INFO] Path exists but no images: {path}")
        else:
            print(f"[DEBUG] Path not found: {path}")

    print(f"\nFound {len(test_images)} test images")

    # CODE COMPETITION HANDLING:
    # Test images only available during submission scoring
    if len(test_images) == 0:
        print("[INFO] No test images found - creating dummy submission")
        print("       (Test images appear only during submission scoring)")

        # Create minimal valid submission
        submission_path = OUTPUT_DIR / "submission.csv"
        with open(submission_path, 'w') as f:
            f.write('"case_id","annotation"\n')
            f.write('"0","authentic"\n')  # Placeholder

        print(f"Dummy submission created: {submission_path}")
        print("\nKernel will find real test images during submit-to-competition.")
        return

    # Process all images
    print("\n" + "=" * 60)
    print("Processing Test Images (V6 CV Detection)")
    print("=" * 60 + "\n")

    results = []
    forged_count = 0
    authentic_count = 0

    for img_path in test_images:
        case_id = img_path.stem
        print(f"Processing: {case_id}")

        result = detect_forgery_v6(img_path)

        if result["is_forged"]:
            forged_count += 1
            print(f"  -> FORGED ({result['forgery_ratio']:.2%})")
        else:
            authentic_count += 1
            print(f"  -> authentic")

        results.append({
            "case_id": case_id,
            "annotation": result["annotation"]
        })

    # Create submission
    print("\n" + "=" * 60)
    print("Creating Submission")
    print("=" * 60)

    submission_path = OUTPUT_DIR / "submission.csv"

    with open(submission_path, 'w') as f:
        f.write('"case_id","annotation"\n')
        for r in results:
            # Escape quotes in annotation
            ann = r["annotation"].replace('"', '""')
            f.write(f'"{r["case_id"]}","{ann}"\n')

    print(f"\nSubmission saved to: {submission_path}")
    print(f"Total images: {len(results)}")
    print(f"Forged: {forged_count}")
    print(f"Authentic: {authentic_count}")

    # Show file size
    file_size = submission_path.stat().st_size
    print(f"File size: {file_size:,} bytes")

    # Preview
    print("\nSubmission Preview (first 5 rows):")
    print("-" * 40)
    with open(submission_path) as f:
        for i, line in enumerate(f):
            if i < 6:
                preview = line.strip()[:80]
                if len(line.strip()) > 80:
                    preview += "..."
                print(preview)

    print("\n" + "=" * 60)
    print("Recod.ai/LUC V6 Baseline - COMPLETE")
    print("CODE_KEY[241] CLOSER EXECUTION SUCCESS")
    print("=" * 60)
    print("\nWayneIA: Get on the leaderboard, then iterate.")

if __name__ == "__main__":
    main()