local_camera_node.py

#!/usr/bin/env python3
"""
COMPLETE FIXED Local Camera Node Service for control1 (rep8)
✅ Fixed: Syntax errors removed
✅ Fixed: High resolution stills (4056x3040 - 4:3 full sensor)
✅ Fixed: Correct color handling (RGB format for GUI)
✅ Fixed: Working transforms using shared.transforms system
✅ Fixed: Proper stop/capture/restart protocol
"""

import os
import json
import socket
import subprocess
import datetime
import time
import threading
import logging
import sys
import cv2
from picamera2 import Picamera2

# Configure logging
logging.basicConfig(
    level=logging.INFO,
    format="%(asctime)s - [LOCAL-COMPLETE-FIX] %(levelname)s - %(message)s",
    handlers=[logging.StreamHandler(sys.stdout), logging.FileHandler("/tmp/local_camera_debug.log")],
)

logging.info("=== LOCAL CAMERA COMPLETE FIXED VERSION STARTING ===")

# Fix Python path to find shared module
script_dir = os.path.dirname(os.path.abspath(__file__))
project_root = os.path.dirname(script_dir)
if project_root not in sys.path:
    sys.path.insert(0, project_root)

# Import configuration with better error handling
try:
    from shared.config import (
        LOCAL_CONTROL_PORT,
        LOCAL_VIDEO_PORT,
        LOCAL_STILL_PORT,
        LOCAL_HEARTBEAT_PORT,
        LOCAL_IMAGE_DIR,
        IMAGE_DIR,
        VIDEO_PORT,
        STILL_PORT,
        HEARTBEAT_PORT,
        CONTROLLER_IP as CONTROLLER_IP_FROM_CONFIG,
    )

    logging.info("✓ Loaded local camera configuration")
except ImportError as e:
    logging.error(f"✗ Failed to import config: {e}")
    # Fallback configuration
    LOCAL_CONTROL_PORT = 5011
    LOCAL_VIDEO_PORT = 5012
    LOCAL_STILL_PORT = 6010
    LOCAL_HEARTBEAT_PORT = 5013
    LOCAL_IMAGE_DIR = "captured_images_local"
    IMAGE_DIR = os.path.join(script_dir, "captured_images")
    VIDEO_PORT = 5002
    STILL_PORT = 6000
    HEARTBEAT_PORT = 5003
    CONTROLLER_IP_FROM_CONFIG = "127.0.0.1"
    logging.info("Using fallback configuration")


# FIXED: Controller IP resolution for local camera
def resolve_controller_ip():
    """For local camera (rep8), always use localhost"""
    return "127.0.0.1"


CONTROLLER_IP = resolve_controller_ip()
logging.info(f"Final Controller IP: {CONTROLLER_IP}")

# Global state
streaming = False
streaming_lock = threading.Lock()
video_thread = None
video_picam2 = None  # Live Picamera2 instance during video stream (for AE controls)
jpeg_quality = 80
last_heartbeat = 0
HEARTBEAT_INTERVAL = 1.0
HEARTBEAT_TIMEOUT = 5.0

# --- SAFE CAMERA INITIALIZATION ---
# Prevents "list index out of range" from bare Picamera2() when camera is locked/missing


def diagnose_camera_availability():
    """Check what is holding /dev/video0 and whether libcamera can see cameras."""
    diag = []
    try:
        result = subprocess.run(["lsof", "/dev/video0"], capture_output=True, text=True, timeout=5)
        if result.stdout.strip():
            diag.append(f"Processes holding /dev/video0:\n{result.stdout.strip()}")
        else:
            diag.append("/dev/video0 is not held by any process")
    except Exception as e:
        diag.append(f"Could not run lsof: {e}")

    try:
        result = subprocess.run(["libcamera-hello", "--list-cameras"], capture_output=True, text=True, timeout=10)
        output = (result.stdout + result.stderr).strip()
        if output:
            diag.append(f"libcamera camera list:\n{output}")
        else:
            diag.append("libcamera-hello returned no output")
    except FileNotFoundError:
        diag.append("libcamera-hello not found on this system")
    except Exception as e:
        diag.append(f"Could not run libcamera-hello: {e}")

    # Check if PipeWire is running (known camera lock cause)
    try:
        result = subprocess.run(["pgrep", "-a", "pipewire"], capture_output=True, text=True, timeout=5)
        if result.stdout.strip():
            diag.append(f"⚠️ PipeWire is RUNNING (known to lock cameras):\n{result.stdout.strip()}")
            diag.append(
                "FIX: Run setup_control1_camera.sh then reboot, "
                "or temporarily: systemctl --user stop pipewire wireplumber"
            )
        else:
            diag.append("✓ PipeWire is not running")
    except Exception as e:
        diag.append(f"Could not check PipeWire status: {e}")

    return "\n".join(diag)


def safe_picamera2_init(purpose="general", max_retries=3, retry_delay=2.0):
    """
    Safely create a Picamera2 instance with enumeration check, retries, and diagnostics.

    Args:
        purpose: Label for logging (e.g. "video_stream", "still_capture")
        max_retries: Number of attempts before giving up
        retry_delay: Seconds between retries (doubles each attempt)

    Returns:
        Picamera2 instance, or raises RuntimeError with diagnostic info
    """
    delay = retry_delay

    for attempt in range(1, max_retries + 1):
        try:
            # Step 1: Check if Picamera2 can see any cameras at all
            from picamera2 import Picamera2 as Picamera2Class

            camera_info = Picamera2Class.global_camera_info()

            if not camera_info:
                logging.warning(
                    f"[CAMERA-INIT] Attempt {attempt}/{max_retries} ({purpose}): "
                    f"No cameras found by Picamera2.global_camera_info()"
                )
                if attempt == max_retries:
                    diag = diagnose_camera_availability()
                    logging.error(
                        f"[CAMERA-INIT] All {max_retries} attempts failed for {purpose}. Diagnostics:\n{diag}"
                    )
                    raise RuntimeError(
                        f"No cameras found after {max_retries} attempts ({purpose}). "
                        f"Camera may be locked by PipeWire or another process. "
                        f"Run: systemctl --user stop pipewire wireplumber"
                    )
                logging.info(f"[CAMERA-INIT] Retrying in {delay:.1f}s...")
                time.sleep(delay)
                delay *= 2
                continue

            logging.info(
                f"[CAMERA-INIT] ({purpose}) Found {len(camera_info)} camera(s): "
                f"{[c.get('Model', 'unknown') for c in camera_info]}"
            )

            # Step 2: Create instance (now safe - we know cameras exist)
            picam2 = Picamera2()
            logging.info(f"[CAMERA-INIT] ✅ Picamera2 created successfully ({purpose})")
            return picam2

        except RuntimeError:
            raise  # Re-raise our own RuntimeError from above
        except IndexError as e:
            # This is the exact "list index out of range" we are guarding against
            logging.warning(
                f"[CAMERA-INIT] Attempt {attempt}/{max_retries} ({purpose}): IndexError during Picamera2(): {e}"
            )
            if attempt == max_retries:
                diag = diagnose_camera_availability()
                logging.error(
                    f"[CAMERA-INIT] IndexError persisted after {max_retries} attempts ({purpose}). Diagnostics:\n{diag}"
                )
                raise RuntimeError(
                    f"Camera init failed with IndexError after {max_retries} attempts ({purpose}). "
                    f"Likely PipeWire is holding /dev/video0. "
                    f"Run: systemctl --user stop pipewire wireplumber"
                ) from e
            logging.info(f"[CAMERA-INIT] Retrying in {delay:.1f}s...")
            time.sleep(delay)
            delay *= 2

        except Exception as e:
            logging.warning(
                f"[CAMERA-INIT] Attempt {attempt}/{max_retries} ({purpose}): Unexpected error: {type(e).__name__}: {e}"
            )
            if attempt == max_retries:
                diag = diagnose_camera_availability()
                logging.error(f"[CAMERA-INIT] Failed after {max_retries} attempts ({purpose}). Diagnostics:\n{diag}")
                raise RuntimeError(f"Camera init failed after {max_retries} attempts ({purpose}): {e}") from e
            logging.info(f"[CAMERA-INIT] Retrying in {delay:.1f}s...")
            time.sleep(delay)
            delay *= 2


# ARCHITECTURAL FIX: Thread synchronization for Picamera2 instance management
# Prevents "camera is already open" errors by ensuring proper cleanup sequencing
stream_stopped_event = threading.Event()  # Signals streaming thread has fully stopped & closed picam2
capture_complete_event = threading.Event()  # Signals capture is done & picam2 closed, safe to restart stream
_last_video_exp_us = 0  # Last valid ExposureTime read from live video stream
_last_video_gain = 1.0  # Last valid AnalogueGain read from live video stream

# Spot meter pending request — set by command handler, consumed by streaming loop.
# Avoids touching video_picam2 from a foreign thread (race with STOP_STREAM).
_local_ae_meter_pending = False
_local_ae_meter_region = None
_local_ae_meter_lock = threading.Lock()

# WB meter pending request — same flag pattern as AE, serviced from streaming loop.
_local_wb_meter_pending = False
_local_wb_meter_region = None
_local_wb_meter_lock = threading.Lock()
_local_wb_cleared = False  # suppress re-notification after CLEAR_WB_LOCK

# Camera settings (matching working version)
camera_settings = {
    "brightness": 0,  # FIXED: Match GUI default (-50 to +50, 0 = neutral)
    "contrast": 50,
    "iso": 100,
    "shutter_speed": 1000,
    "saturation": 50,
    "exposure_mode": "auto",
    "jpeg_quality": 95,  # Default; override via Settings > JPEG Quality.
    "fps": 30,
    "resolution": "640x480",
    "image_format": "JPEG",
    "raw_enabled": False,  # RAW capture (DNG) - for rep8
    "crop_enabled": False,
    "crop_x": 0,
    "crop_y": 0,
    "crop_width": 4056,  # 4:3 sensor width (NOT 4608 which is 16:9!)
    "crop_height": 3040,  # 4:3 sensor height (NOT 2592 which is 16:9!)
    "flip_horizontal": False,
    "flip_vertical": False,
    "grayscale": False,
    "rotation": 0,
}


def send_local_heartbeat():
    """Enhanced heartbeat with better error handling and telemetry"""
    global last_heartbeat

    logging.info(f"Starting heartbeat service to {CONTROLLER_IP}:{HEARTBEAT_PORT}")

    # Import telemetry (lazy, tolerant of import failure)
    try:
        import sys

        sys.path.insert(0, os.path.join(os.path.dirname(__file__), "node"))
        from telemetry import build_telemetry_payload

        telemetry_available = True
        logging.info("[LOCAL] Telemetry module loaded")
    except ImportError:
        telemetry_available = False
        logging.warning("[LOCAL] Telemetry module not available")

    heartbeat_count = 0
    TELEMETRY_INTERVAL = 5

    while True:
        try:
            with socket.socket(socket.AF_INET, socket.SOCK_DGRAM) as sock:
                sock.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
                sock.settimeout(1.0)

                heartbeat_count += 1
                if telemetry_available and heartbeat_count % TELEMETRY_INTERVAL == 0:
                    try:
                        payload = build_telemetry_payload("rep8")
                        sock.sendto(payload.encode(), (CONTROLLER_IP, HEARTBEAT_PORT))
                    except Exception:
                        sock.sendto(b"HEARTBEAT", (CONTROLLER_IP, HEARTBEAT_PORT))
                else:
                    sock.sendto(b"HEARTBEAT", (CONTROLLER_IP, HEARTBEAT_PORT))

                last_heartbeat = time.time()

                if heartbeat_count % 10 == 0:
                    logging.info(f"[LOCAL] Heartbeat #{heartbeat_count} sent to {CONTROLLER_IP}:{HEARTBEAT_PORT}")

            time.sleep(HEARTBEAT_INTERVAL)

        except Exception as e:
            logging.error(f"[LOCAL] Error sending heartbeat #{heartbeat_count}: {e}")
            time.sleep(HEARTBEAT_INTERVAL)


def apply_safe_transforms(image_array):
    """
    UNIFIED: Apply frame transforms using unified pipeline for local camera (rep8)
    Uses apply_unified_transforms for consistency with other nodes
    """
    try:
        # CAL2-R3: Apply colour pipeline BEFORE geometric transforms
        # Must match video_stream.py behaviour for consistent WB/exposure
        try:
            if not hasattr(apply_safe_transforms, "_colour_pipe_confirmed"):
                apply_safe_transforms._colour_pipe_confirmed = True
        except ImportError:
            if not hasattr(apply_safe_transforms, "_colour_import_warned"):
                apply_safe_transforms._colour_import_warned = True
        except Exception:
            if not hasattr(apply_safe_transforms, "_colour_err_logged"):
                apply_safe_transforms._colour_err_logged = True

        # Import unified transform function
        from shared.transforms import apply_unified_transforms

        # Use unified transform function for consistency
        processed_image = apply_unified_transforms(image_array, "rep8")

        logging.debug("[LOCAL] Applied unified transforms for rep8")
        return processed_image

    except Exception as e:
        logging.error(f"[LOCAL] Error applying unified transforms: {e}")
        # Fallback to original logic if unified fails
        return apply_safe_transforms_fallback(image_array)


def apply_safe_transforms_fallback(image_array):
    """
    Fallback transform function for local camera if unified transforms fail
    """
    try:
        logging.info("[LOCAL] Using fallback transforms for rep8")

        # Load settings for rep8 to apply any configured transforms (WORKING METHOD)
        from shared.transforms import load_device_settings

        settings = load_device_settings("rep8")

        # Start with RGB format (same as working version)
        image = image_array.copy()

        # Apply transforms if configured (same logic as working version)
        # 1. Crop
        if settings.get("crop_enabled", False):
            x = max(0, settings.get("crop_x", 0))
            y = max(0, settings.get("crop_y", 0))
            w = max(100, settings.get("crop_width", image.shape[1]))
            h = max(100, settings.get("crop_height", image.shape[0]))

            height, width = image.shape[:2]
            x = min(x, width - 100)
            y = min(y, height - 100)
            w = min(w, width - x)
            h = min(h, height - y)

            image = image[y : y + h, x : x + w]

        # 2. Rotation
        rotation = settings.get("rotation", 0)
        if rotation == 90:
            image = cv2.rotate(image, cv2.ROTATE_90_CLOCKWISE)
        elif rotation == 180:
            image = cv2.rotate(image, cv2.ROTATE_180)
        elif rotation == 270:
            image = cv2.rotate(image, cv2.ROTATE_90_COUNTERCLOCKWISE)

        # 3. Flips (maintain RGB format)
        if settings.get("flip_horizontal", False):
            image = cv2.flip(image, 1)
        if settings.get("flip_vertical", False):
            image = cv2.flip(image, 0)

        # 4. Grayscale (stay in RGB format)
        if settings.get("grayscale", False):
            if len(image.shape) == 3:
                gray = cv2.cvtColor(image, cv2.COLOR_RGB2GRAY)
                image = cv2.cvtColor(gray, cv2.COLOR_GRAY2RGB)

        logging.info("[LOCAL] ✅ RGB format preserved with transforms applied")
        return image

    except Exception as e:
        logging.error(f"[LOCAL] Error applying transforms: {e}")
        # Fallback: keep original RGB format
        return image_array


def start_local_video_stream():
    """WORKING: Enhanced video streaming with proper RGB color handling"""
    global streaming, jpeg_quality, video_picam2, _last_video_exp_us, _last_video_gain

    with streaming_lock:
        if streaming:
            logging.warning("Local video stream already running")
            return
        streaming = True

    # ARCHITECTURAL FIX: Clear stop event at stream start (will be set on cleanup)
    stream_stopped_event.clear()
    logging.info(f"[EVENT] stream_stopped_event CLEARED at {time.time():.3f} - starting stream")

    logging.info(f"🚀 Starting LOCAL video stream to {CONTROLLER_IP}:{VIDEO_PORT}")

    picam2 = None
    sock = None
    frame_count = 0
    last_log_time = time.time()
    error_count = 0
    max_errors = 10

    try:
        # Initialize camera (same as working version)
        logging.info("Initializing camera...")
        picam2 = safe_picamera2_init(purpose="video_stream", max_retries=5, retry_delay=2.0)

        # WYSIWYG FIX v3: Let camera auto-select appropriate 4:3 sensor mode
        # IMPORTANT: Do NOT specify raw size! 4608x2592 was WRONG (16:9 binned mode)
        # By omitting raw, camera selects optimal 4:3 mode for requested output
        # Check for persisted AE lock — bake into config controls to avoid
        # the 1-2 frame flicker that occurs when set_controls fires after start()
        _boot_controls = {"FrameRate": 15}
        _boot_ae_lock = None
        _boot_wb_lock = None
        try:
            from shared.transforms import load_device_settings

            _boot_ae_lock = load_device_settings("rep8").get("ae_lock")
            if _boot_ae_lock and _boot_ae_lock.get("exp_us", 0) > 50:
                _boot_controls["ExposureTime"] = int(_boot_ae_lock["exp_us"])
                _boot_controls["AnalogueGain"] = float(_boot_ae_lock["gain"])
                _boot_controls["ExposureTimeMode"] = 1
                _boot_controls["AnalogueGainMode"] = 1
                logging.info(
                    f"[AE] Baking lock into video config: "
                    f"exp={_boot_ae_lock['exp_us']}us gain={_boot_ae_lock['gain']:.2f}"
                )
            _boot_wb_lock = load_device_settings("rep8").get("wb_lock")
            if _boot_wb_lock and _boot_wb_lock.get("red_gain") is not None:
                _boot_controls["ColourGains"] = (float(_boot_wb_lock["red_gain"]), float(_boot_wb_lock["blue_gain"]))
                logging.info(
                    f"[WB] Baking lock into video config: "
                    f"red={_boot_wb_lock['red_gain']:.3f} blue={_boot_wb_lock['blue_gain']:.3f}"
                )
        except Exception:
            pass

        video_config = picam2.create_video_configuration(
            main={"size": (640, 480), "format": "RGB888"}, controls=_boot_controls
        )
        logging.info("[LOCAL] WYSIWYG v3: Auto sensor mode for 640x480 (4:3 preserved, no crop)")
        picam2.configure(video_config)
        picam2.start()
        video_picam2 = picam2  # Expose for AE controls (spot metering)

        # Restore AE lock via set_controls as well (belt-and-braces for v0.5.0)
        try:
            if _boot_ae_lock and _boot_ae_lock.get("exp_us", 0) > 50:
                picam2.set_controls(
                    {
                        "ExposureTime": int(_boot_ae_lock["exp_us"]),
                        "AnalogueGain": float(_boot_ae_lock["gain"]),
                        "ExposureTimeMode": 1,
                        "AnalogueGainMode": 1,
                    }
                )
                logging.info(
                    f"[AE] ✅ Restored AE lock for rep8: "
                    f"exp={_boot_ae_lock['exp_us']}us gain={_boot_ae_lock['gain']:.2f}"
                )
                # Notify GUI so lock bar appears on session start / reconnect
                _local_ae_notify("locked", int(_boot_ae_lock["exp_us"]), float(_boot_ae_lock["gain"]))
        except Exception as _e:
            logging.debug(f"[AE] Could not restore AE lock for rep8: {_e}")

        # Belt-and-braces WB: apply ColourGains after start
        try:
            if _boot_wb_lock and _boot_wb_lock.get("red_gain") is not None and not _local_wb_cleared:
                picam2.set_controls(
                    {"ColourGains": (float(_boot_wb_lock["red_gain"]), float(_boot_wb_lock["blue_gain"]))}
                )
                logging.info(
                    f"[WB] ✅ Restored WB lock for rep8: "
                    f"red={_boot_wb_lock['red_gain']:.3f} blue={_boot_wb_lock['blue_gain']:.3f}"
                )
                _local_wb_notify("locked", float(_boot_wb_lock["red_gain"]), float(_boot_wb_lock["blue_gain"]))
        except Exception as _e:
            logging.debug(f"[WB] Could not restore WB lock for rep8: {_e}")

        logging.info("✓ Local camera initialized")
        time.sleep(0.5)  # Allow AE to stabilise before first frame

        # Read initial exposure after AE settle — only update globals if no ae_lock active.
        # When ae_lock is set, _last_video_exp_us is already correct from the lock.
        try:
            from shared.transforms import load_device_settings

            _has_lock = load_device_settings("rep8").get("ae_lock") is not None
            if not _has_lock:
                _init_meta = picam2.capture_metadata()
                _init_exp = _init_meta.get("ExposureTime", 0)
                _init_gain = _init_meta.get("AnalogueGain", 1.0)
                if _init_exp > 50:
                    _last_video_exp_us = _init_exp
                    _last_video_gain = _init_gain
                    logging.info(f"[AE] Initial exposure sampled: exp={_init_exp}us gain={_init_gain:.2f}")
                else:
                    logging.info(f"[AE] Initial exposure low ({_init_exp}us) — will resample during stream")
            else:
                ae_lock = load_device_settings("rep8").get("ae_lock", {})
                _last_video_exp_us = ae_lock.get("exp_us", _last_video_exp_us)
                _last_video_gain = ae_lock.get("gain", _last_video_gain)
                logging.info(f"[AE] Lock active — keeping exp={_last_video_exp_us}us (skipping warmup read)")
        except Exception as _e:
            logging.debug(f"[AE] Could not sample initial exposure: {_e}")

        # Create UDP socket
        sock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
        sock.setsockopt(socket.SOL_SOCKET, socket.SO_SNDBUF, 262144)
        sock.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
        sock.settimeout(0.1)

        logging.info(f"✓ Socket created, streaming to {CONTROLLER_IP}:{VIDEO_PORT}")

        start_time = time.time()

        while True:
            with streaming_lock:
                if not streaming:
                    logging.info("Stream stop requested, breaking loop")
                    break

            try:
                # Spot meter pending? Service from streaming thread (owns video_picam2).
                global _local_ae_meter_pending, _local_ae_meter_region
                with _local_ae_meter_lock:
                    _do_meter = _local_ae_meter_pending
                    _local_ae_meter_pending = False
                if _do_meter:
                    _local_ae_meter_and_lock()

                # Service WB meter from streaming thread (same safety pattern as AE)
                global _local_wb_meter_pending, _local_wb_meter_region
                with _local_wb_meter_lock:
                    _do_wb = _local_wb_meter_pending
                    _local_wb_meter_pending = False
                if _do_wb:
                    _local_wb_sample_and_lock()

                # Capture frame (RGB888 format from Picamera2)
                frame_rgb = picam2.capture_array()

                # Apply transforms keeping RGB format
                frame_rgb_transformed = apply_safe_transforms(frame_rgb)

                # NO cvtColor — same as remote nodes (a92bcbb revert).
                # apply_safe_transforms returns RGB. cv2.imencode and QImage.fromData
                # are both consistent — no swap needed, display is correct.
                frame_bgr = frame_rgb_transformed  # misleading name; contains RGB

                # Encode as JPEG
                encode_params = [cv2.IMWRITE_JPEG_QUALITY, 70]
                success, encoded = cv2.imencode(".jpg", frame_bgr, encode_params)

                if not success:
                    logging.warning("Failed to encode frame")
                    continue

                frame_data = encoded.tobytes()

                # Check frame size and reduce quality if needed
                if len(frame_data) > 60000:
                    encode_params = [cv2.IMWRITE_JPEG_QUALITY, 50]
                    success, encoded = cv2.imencode(".jpg", frame_bgr, encode_params)
                    if success:
                        frame_data = encoded.tobytes()

                # Send to controller GUI
                try:
                    sock.sendto(frame_data, (CONTROLLER_IP, LOCAL_VIDEO_PORT))
                    error_count = 0
                except TimeoutError:
                    pass
                except OSError as e:
                    error_count += 1
                    if error_count <= 3:
                        logging.error(f"Socket error #{error_count}: {e}")
                    if error_count >= max_errors:
                        logging.error("Too many socket errors, stopping stream")
                        break

                frame_count += 1

                # Sample exposure every 30 frames for spot meter passthrough.
                # Skip if ae_lock active — the lock value is the ground truth.
                if frame_count % 30 == 1:
                    try:
                        from shared.transforms import load_device_settings

                        if not load_device_settings("rep8").get("ae_lock"):
                            _meta = picam2.capture_metadata()
                            _exp = _meta.get("ExposureTime", 0)
                            _gain = _meta.get("AnalogueGain", 1.0)
                            if _exp > 50:
                                _last_video_exp_us = _exp
                                _last_video_gain = _gain
                                logging.info(
                                    f"[AE] Video exposure sampled: exp={_exp}us gain={_gain:.2f} (frame {frame_count})"
                                )
                            else:
                                logging.info(f"[AE] Video exposure still low: exp={_exp}us (frame {frame_count})")
                    except Exception:
                        pass

                # Log stats every 5 seconds
                current_time = time.time()
                if current_time - last_log_time >= 5.0:
                    elapsed = current_time - start_time
                    fps = frame_count / elapsed if elapsed > 0 else 0
                    logging.info(f"📊 LOCAL: {fps:.1f} fps, {len(frame_data)} bytes/frame, {frame_count} total frames")
                    last_log_time = current_time

                # Frame rate control removed - allow native 30 FPS

            except Exception as e:
                error_count += 1
                if error_count <= 3:
                    logging.error(f"Error in video loop #{error_count}: {e}")
                if error_count >= max_errors:
                    logging.error("Too many video loop errors, stopping")
                    break
                time.sleep(0.1)

    except Exception as e:
        logging.error(f"Critical error in local video streaming: {e}")

    finally:
        # Cleanup
        video_picam2 = None  # Clear global reference before closing
        if picam2:
            try:
                picam2.stop()
                picam2.close()
                logging.info("✓ Local camera stopped and closed")
            except Exception as e:
                logging.error(f"Error stopping camera: {e}")

        if sock:
            try:
                sock.close()
                logging.info("✓ Local socket closed")
            except Exception as e:
                logging.error(f"Error closing socket: {e}")

        with streaming_lock:
            streaming = False

        # ARCHITECTURAL FIX: Signal that Picamera2 cleanup is complete
        # This allows capture_local_still() to safely create new Picamera2 instance
        stream_stopped_event.set()
        logging.info(f"[EVENT] stream_stopped_event SET at {time.time():.3f} - Picamera2 fully closed")
        logging.info("✓ Stream cleanup complete - Picamera2 closed and event signaled")

        logging.info("🛑 Local video stream stopped")


def stop_local_video_stream():
    """Properly stop the local video stream"""
    global streaming

    logging.info("[LOCAL] 🛑 Stopping local video stream...")
    with streaming_lock:
        streaming = False

    time.sleep(0.2)  # Reduced from 1.0s - stream stops quickly
    logging.info("[LOCAL] ✅ Local video stream stopped")


def capture_local_still():
    """ARCHITECTURAL FIX: Proper thread synchronization for Picamera2 instance management

    S3 Speed Optimizations (25 Feb 2026):
    - Stream restarts BEFORE transfer (overlaps recovery with upload)
    - Timing instrumentation for end-to-end measurement
    """
    global streaming

    t_total_start = time.time()
    logging.info("[LOCAL] Starting still capture protocol (S3 speed optimized)...")

    was_streaming = False

    # Step 1: Stop video stream to free the camera
    # Snapshot current video exposure BEFORE stopping — used for spot meter passthrough
    global _last_video_exp_us, _last_video_gain
    _snapshot_exp = _last_video_exp_us
    _snapshot_gain = _last_video_gain
    if _snapshot_exp > 50:
        logging.info(f"[AE] Snapshotted video exposure before stop: exp={_snapshot_exp}us gain={_snapshot_gain:.2f}")
    with streaming_lock:
        was_streaming = streaming
        if streaming:
            logging.info("[LOCAL] Step 1: Stopping video stream for dedicated still capture...")
            streaming = False
            stream_stopped_event.clear()
            logging.info(f"[EVENT] stream_stopped_event CLEARED at {time.time():.3f}")

    if was_streaming:
        # ARCHITECTURAL FIX: Wait for Event instead of blind sleep
        # This ensures streaming thread has ACTUALLY stopped and closed Picamera2
        wait_start = time.time()
        logging.info(f"[EVENT-WAIT] Waiting for stream_stopped_event (timeout=10s) at {wait_start:.3f}...")
        event_received = stream_stopped_event.wait(timeout=10.0)  # 10s max wait
        wait_elapsed = time.time() - wait_start

        if event_received:
            logging.info(f"[EVENT-RESULT] stream_stopped_event RECEIVED in {wait_elapsed:.3f}s - SUCCESS")
            logging.info("[LOCAL] ✓ Stream cleanup confirmed via Event - camera freed for high-res capture")
        else:
            logging.warning(f"[EVENT-RESULT] stream_stopped_event TIMEOUT after {wait_elapsed:.3f}s - FAILED")
            logging.warning("[LOCAL] ⚠️ Timeout waiting for stream cleanup - proceeding anyway")
            time.sleep(0.5)  # Reduced fallback delay from 2.0s

    try:
        # Step 2: Clear capture complete event before starting capture
        capture_complete_event.clear()
        logging.info(f"[EVENT] capture_complete_event CLEARED at {time.time():.3f}")
        capture_start_time = time.time()
        logging.info(f"[TIMING] Capture cycle START at {capture_start_time:.3f}")

        # Step 3: Capture dedicated high-resolution still (with RAW support)
        raw_enabled = camera_settings.get("raw_enabled", False)

        if raw_enabled:
            # RAW capture path - uses libcamera-still with --raw flag
            logging.info("[LOCAL] RAW capture enabled - using libcamera-still")
            capture_result = capture_local_raw()
        else:
            # Standard JPEG capture
            capture_result = capture_local_image_high_resolution(video_exp_us=_snapshot_exp, video_gain=_snapshot_gain)

        # S3: Restart video stream BEFORE transfer to overlap recovery with upload
        if was_streaming:
            logging.info("[LOCAL] S3: Early stream restart (overlapping with transfer)...")
            wait_start = time.time()
            event_received = capture_complete_event.wait(timeout=5.0)
            wait_elapsed = time.time() - wait_start
            if event_received:
                logging.info(f"[EVENT-RESULT] capture_complete_event RECEIVED in {wait_elapsed:.3f}s")
            else:
                logging.warning(f"[EVENT-RESULT] capture_complete_event TIMEOUT after {wait_elapsed:.3f}s")
                time.sleep(0.3)

            threading.Thread(target=start_local_video_stream, daemon=True).start()
            logging.info("[LOCAL] Stream restart thread launched (transfer running in parallel)")
            stream_already_restarted = True
        else:
            stream_already_restarted = False

        # Now transfer to controller (stream restarting in parallel)
        if raw_enabled and capture_result:
            jpeg_filename, dng_filename = capture_result
            success = send_local_raw(jpeg_filename, dng_filename)
        elif capture_result:
            success = send_local_image(capture_result)
        else:
            success = False

        if success:
            logging.info("[LOCAL] Still capture protocol completed successfully")
            result = True
        else:
            logging.error("[LOCAL] Failed to capture or upload image")
            result = False
    except Exception as e:
        logging.error(f"[LOCAL] Error during still capture protocol: {e}")
        result = False
        stream_already_restarted = False

    # Step 5: Restart video stream if not already done above
    if was_streaming and not stream_already_restarted:
        logging.info("[LOCAL] Step 5: Preparing to restart video stream...")

        # ARCHITECTURAL FIX: Wait for capture Picamera2 to be fully closed
        # This ensures no instance conflict when new streaming thread creates Picamera2
        wait_start = time.time()
        logging.info(f"[EVENT-WAIT] Waiting for capture_complete_event (timeout=5s) at {wait_start:.3f}...")
        event_received = capture_complete_event.wait(timeout=5.0)  # 5s max wait
        wait_elapsed = time.time() - wait_start

        if event_received:
            logging.info(f"[EVENT-RESULT] capture_complete_event RECEIVED in {wait_elapsed:.3f}s - SUCCESS")
            logging.info("[LOCAL] ✓ Capture cleanup confirmed via Event - safe to restart stream")
        else:
            logging.warning(f"[EVENT-RESULT] capture_complete_event TIMEOUT after {wait_elapsed:.3f}s - FAILED")
            logging.warning("[LOCAL] ⚠️ Timeout waiting for capture cleanup - proceeding with caution")
            time.sleep(0.3)  # Reduced safety delay from 1.0s

        logging.info("[LOCAL] Starting new streaming thread...")
        # BUGFIX: Don't set streaming=True here - let the thread set its own flag
        # This prevents race condition where thread exits immediately due to guard check
        threading.Thread(target=start_local_video_stream, daemon=True).start()
        capture_cycle_time = time.time() - capture_start_time
        logging.info(f"[TIMING] Capture cycle COMPLETE in {capture_cycle_time:.3f}s (fallback restart path)")
        logging.info("[LOCAL] ✓ Video stream restarted - protocol complete with proper synchronization")

    t_total = time.time() - t_total_start
    logging.info(f"[PERF] rep8: STILL CYCLE TOTAL: {t_total * 1000:.0f}ms")
    return result


def capture_local_image_high_resolution(video_exp_us: int = 0, video_gain: float = 1.0):
    """FIXED: Capture HIGH RESOLUTION still image (4056x3040 - 4:3) with working transforms

    S3 Speed Optimizations (25 Feb 2026):
    - Smart settle: 0s when exposure locked, 0.2s for auto (was 0.5s)
    - Timing instrumentation for performance tracking
    """
    timestamp = datetime.datetime.now().strftime("%Y%m%d_%H%M%S")
    filename = f"/tmp/local_capture_{timestamp}.jpg"
    t_start = time.time()

    try:
        logging.info("[LOCAL] Starting HIGH-RESOLUTION still capture (4056x3040 - 4:3)...")

        t_cam_init = time.time()
        picam2 = safe_picamera2_init(purpose="still_capture", max_retries=3, retry_delay=1.0)

        # Determine exposure to use for still capture.
        # Priority: (1) saved ae_lock from spot meter, (2) video stream snapshot passed in,
        # (3) auto (no manual exposure).
        # CRITICAL: libcamera v0.5.0 — AeEnable not handled. Use ExposureTimeMode=1 instead.
        # IMX296 at 4K: capture_metadata() returns near-zero exposure on fresh init regardless
        # of scene brightness — cannot read valid exposure from the still instance itself.
        apply_exp_us = 0
        apply_gain = 1.0
        exp_source = None

        try:
            from shared.transforms import load_device_settings

            ae_lock = load_device_settings("rep8").get("ae_lock")
            if ae_lock and ae_lock.get("exp_us", 0) > 50:
                apply_exp_us = int(ae_lock["exp_us"])
                apply_gain = float(ae_lock["gain"])
                exp_source = "ae_lock"
                logging.info(f"[AE] Using saved ae_lock: exp={apply_exp_us}us gain={apply_gain:.2f}")
            elif ae_lock:
                logging.warning(f"[AE] Discarding stale ae_lock (exp={ae_lock.get('exp_us')}us < 500us)")
        except Exception as _e:
            logging.warning(f"[AE] Could not read ae_lock: {_e}")

        # Fall back to video snapshot if no saved lock
        if apply_exp_us == 0 and video_exp_us > 50:
            apply_exp_us = video_exp_us
            apply_gain = video_gain
            exp_source = "video_snapshot"
            logging.info(f"[AE] Using video snapshot: exp={apply_exp_us}us gain={apply_gain:.2f}")

        # Build still controls
        still_controls = {}
        if apply_exp_us > 0:
            still_controls["ExposureTime"] = apply_exp_us
            still_controls["AnalogueGain"] = apply_gain
            still_controls["ExposureTimeMode"] = 1  # Manual — AeEnable not handled on v0.5.0
            still_controls["AnalogueGainMode"] = 1

        # HIGH RESOLUTION configuration - use 4:3 full sensor
        # format="RGB888": gives RGB memory layout (ch0=Red) — consistent with remote nodes
        # and video stream. apply_unified_transforms_for_still(already_bgr=False) then
        # applies the correct cvtColor(RGB->BGR) before imencode.
        still_config = picam2.create_still_configuration(
            main={"size": (4056, 3040), "format": "RGB888"}, controls=still_controls if still_controls else {}
        )

        picam2.configure(still_config)
        picam2.start()
        t_cam_ready = time.time()
        logging.info(f"[PERF] rep8: Camera init+start: {(t_cam_ready - t_cam_init) * 1000:.0f}ms")

        # Settle time
        if apply_exp_us > 0:
            time.sleep(0.05)  # Minimal — exposure is deterministic
            logging.info(f"[AE] ✅ Manual exposure active ({exp_source}): exp={apply_exp_us}us gain={apply_gain:.2f}")
        else:
            has_exposure_lock = not camera_settings.get("iso_auto", True)
            if has_exposure_lock:
                time.sleep(0.05)
                logging.info("[LOCAL] Exposure locked - minimal settle (50ms)")
            else:
                time.sleep(0.2)
                logging.info("[LOCAL] Auto-exposure settle (200ms)")

        # Capture image (RGB format from Picamera2)
        logging.info("[LOCAL] Capturing HIGH-RESOLUTION image...")
        image_rgb = picam2.capture_array()
        t_capture_done = time.time()

        # Save lock from video snapshot only if ae_region pending and no lock yet.
        # (Primary locking now done immediately in _local_ae_meter_and_lock via pixel metering.)
        try:
            from shared.transforms import load_device_settings, save_device_settings

            s = load_device_settings("rep8")
            if s.get("ae_region") and not s.get("ae_lock") and apply_exp_us > 50:
                # Fallback: lock from video snapshot if pixel metering didn't fire
                s["ae_lock"] = {"exp_us": apply_exp_us, "gain": apply_gain}
                save_device_settings("rep8", s)
                _local_ae_notify("locked", apply_exp_us, apply_gain)
                logging.info(f"[AE] ✅ Fallback lock from video snapshot: exp={apply_exp_us}us gain={apply_gain:.2f}")
                threading.Thread(target=restart_local_stream, daemon=True).start()
        except Exception as _e:
            logging.debug(f"[AE] Could not save fallback lock: {_e}")

        # Apply unified transforms for still capture (proper BGR format for saving)
        logging.info("[LOCAL] Applying unified still transforms...")
        logging.info("[COLOUR] rep8: still path — format=RGB888 + already_bgr=False (16eb972)")
        try:
            from shared.transforms import apply_unified_transforms_for_still

            image_bgr_transformed = apply_unified_transforms_for_still(image_rgb, "rep8")
            logging.info("[LOCAL] ✅ Unified still transforms applied")
        except Exception as e:
            logging.error(f"[LOCAL] Unified still transforms failed: {e}, using fallback")
            # Fallback: apply video transforms then convert to BGR
            image_rgb_transformed = apply_safe_transforms(image_rgb)
            if len(image_rgb_transformed.shape) == 3 and image_rgb_transformed.shape[2] == 3:
                image_bgr_transformed = cv2.cvtColor(image_rgb_transformed, cv2.COLOR_RGB2BGR)
            else:
                image_bgr_transformed = image_rgb_transformed

        logging.info("[LOCAL] ✅ Transforms applied - still should match video preview")

        # Apply lens corrections (distortion, vignetting, CA)
        try:
            from shared.lens_correction import apply_lens_correction

            image_bgr_transformed = apply_lens_correction(image_bgr_transformed, "rep8")
        except ImportError:
            logging.debug("[LOCAL] Lens correction module not available")
        except Exception as e:
            logging.warning(f"[LOCAL] Lens correction failed (using uncorrected): {e}")

        # S3: Encode to memory for zero-copy transfer (same as remote nodes)
        _still_quality = camera_settings.get("jpeg_quality", 95)
        encode_params = [cv2.IMWRITE_JPEG_QUALITY, _still_quality]
        success, encoded = cv2.imencode(".jpg", image_bgr_transformed, encode_params)
        _jpeg_bytes = encoded.tobytes() if success else None

        # Clean up camera
        picam2.stop()
        picam2.close()

        # ARCHITECTURAL FIX: Signal that capture Picamera2 is closed
        # This allows streaming to safely restart without instance conflict
        capture_complete_event.set()
        logging.info(f"[EVENT] capture_complete_event SET at {time.time():.3f} - Picamera2 closed")
        logging.info("[LOCAL] ✓ Capture Picamera2 closed - signaled completion")

        if success and _jpeg_bytes is not None:
            file_size = len(_jpeg_bytes)
            # Write to temp file for transfer (local uses temp files)
            with open(filename, "wb") as f:
                f.write(_jpeg_bytes)
            t_total = time.time() - t_start
            logging.info(f"[LOCAL] ✅ HIGH-RES CAPTURED: {filename} ({file_size} bytes, resolution: 4056x3040)")
            logging.info(
                f"[PERF] rep8: CAPTURE TOTAL: {t_total * 1000:.0f}ms "
                f"(init={(t_cam_ready - t_cam_init) * 1000:.0f} "
                f"capture={(t_capture_done - t_cam_ready) * 1000:.0f} "
                f"save={(time.time() - t_capture_done) * 1000:.0f}ms)"
            )

            # Verify this is actually high resolution
            if file_size > 1000000:  # Should be >1MB for high-res
                logging.info("[LOCAL] ✅ Confirmed high-resolution capture (>1MB)")
            else:
                logging.warning(f"[LOCAL] ⚠️ File size seems small for high-res: {file_size} bytes")

            return filename
        else:
            logging.error("[LOCAL] ❌ Failed to save captured image")
            return None

    except Exception as e:
        logging.error(f"[LOCAL] ❌ Error in high-resolution still capture: {e}")
        logging.error(f"[LOCAL] Exception details: {str(e)}")
        try:
            if "picam2" in locals():
                picam2.stop()
                picam2.close()
                # ARCHITECTURAL FIX: Signal completion even on error
                capture_complete_event.set()
                logging.info(f"[EVENT] capture_complete_event SET (ERROR PATH) at {time.time():.3f}")
                logging.info("[LOCAL] ✓ Error cleanup complete - signaled completion")
        except Exception:
            # If even cleanup fails, still signal to prevent deadlock
            capture_complete_event.set()
            logging.info(f"[EVENT] capture_complete_event SET (FALLBACK) at {time.time():.3f}")
        return None


def capture_local_raw():
    """Capture RAW (DNG) + JPEG using libcamera-still --raw flag for rep8"""
    timestamp = datetime.datetime.now().strftime("%Y%m%d_%H%M%S")
    jpeg_filename = f"/tmp/local_capture_{timestamp}.jpg"
    dng_filename = f"/tmp/local_capture_{timestamp}.dng"

    logging.info("[LOCAL] Starting RAW capture with libcamera-still...")

    # Build libcamera-still command with --raw flag
    jpeg_quality = camera_settings.get("jpeg_quality", 95)
    command = [
        "libcamera-still",
        "--nopreview",
        "-o",
        jpeg_filename,
        "--raw",  # This creates the DNG file
        "--timeout",
        "2000",
        "--quality",
        str(jpeg_quality),
    ]

    logging.info(f"[LOCAL] RAW command: {' '.join(command)}")

    try:
        result = subprocess.run(command, timeout=30, capture_output=True, text=True)

        if result.returncode != 0:
            logging.error(f"[LOCAL] libcamera-still RAW failed: {result.stderr}")
            capture_complete_event.set()
            return None

        # libcamera-still creates DNG with same name but .dng extension
        actual_dng = jpeg_filename.rsplit(".", 1)[0] + ".dng"

        # Verify both files exist
        jpeg_exists = os.path.exists(jpeg_filename)
        dng_exists = os.path.exists(actual_dng)

        if jpeg_exists and dng_exists:
            jpeg_size = os.path.getsize(jpeg_filename)
            dng_size = os.path.getsize(actual_dng)
            logging.info("[LOCAL] ✅ RAW capture success:")
            logging.info(f"[LOCAL]    JPEG: {jpeg_filename} ({jpeg_size / 1024:.0f}KB)")
            logging.info(f"[LOCAL]    DNG:  {actual_dng} ({dng_size / 1024 / 1024:.1f}MB)")

            # Rename DNG to expected filename if different
            if actual_dng != dng_filename:
                os.rename(actual_dng, dng_filename)

            # Signal completion
            capture_complete_event.set()
            logging.info(f"[EVENT] capture_complete_event SET at {time.time():.3f}")

            return (jpeg_filename, dng_filename)
        else:
            logging.error(f"[LOCAL] RAW capture incomplete: JPEG={jpeg_exists}, DNG={dng_exists}")
            capture_complete_event.set()
            return None

    except subprocess.TimeoutExpired:
        logging.error("[LOCAL] RAW capture timeout (30s)")
        capture_complete_event.set()
        return None
    except Exception as e:
        logging.error(f"[LOCAL] RAW capture error: {e}")
        capture_complete_event.set()
        return None


def send_local_raw(jpeg_filename, dng_filename):
    """Send RAW capture files (JPEG + DNG) to controller via TCP using RAW1 protocol"""
    try:
        jpeg_size = os.path.getsize(jpeg_filename)
        dng_size = os.path.getsize(dng_filename)
        total_size = jpeg_size + dng_size

        logging.info(
            f"[LOCAL] RAW transfer: JPEG={jpeg_size / 1024:.0f}KB, DNG={dng_size / 1024 / 1024:.1f}MB, Total={total_size / 1024 / 1024:.1f}MB"
        )

        with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as sock:
            sock.settimeout(120.0)  # Extended timeout for large DNG files
            logging.info(f"[LOCAL] RAW transfer connecting to {CONTROLLER_IP}:{LOCAL_STILL_PORT}")
            sock.connect((CONTROLLER_IP, LOCAL_STILL_PORT))

            # Send RAW1 header to indicate RAW transfer
            sock.sendall(b"RAW1")

            # Send JPEG size (4 bytes big-endian)
            sock.sendall(jpeg_size.to_bytes(4, "big"))

            # Send JPEG data
            with open(jpeg_filename, "rb") as f:
                sock.sendall(f.read())

            # Send DNG size (4 bytes big-endian)
            sock.sendall(dng_size.to_bytes(4, "big"))

            # Send DNG data
            with open(dng_filename, "rb") as f:
                sock.sendall(f.read())

            logging.info(f"[LOCAL] ✅ RAW transfer complete: {total_size / 1024 / 1024:.1f}MB total")

            # Clean up temp files
            try:
                os.remove(jpeg_filename)
                os.remove(dng_filename)
            except OSError:
                pass

            return True

    except Exception as e:
        logging.error(f"[LOCAL] Error sending RAW files: {e}")
        return False


def send_local_image(filename):
    """Send local image to controller GUI via TCP (same as working version)"""
    for attempt in range(3):
        try:
            logging.info(f"[LOCAL] Uploading image to {CONTROLLER_IP}:{LOCAL_STILL_PORT}... (attempt {attempt + 1}/3)")

            with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as s:
                s.settimeout(10.0)
                s.connect((CONTROLLER_IP, LOCAL_STILL_PORT))

                with open(filename, "rb") as f:
                    data = f.read()
                    s.sendall(data)
                    logging.info(f"[LOCAL] Uploaded {len(data)} bytes to controller")

                try:
                    os.remove(filename)
                    logging.info(f"[LOCAL] Cleaned up temp file: {filename}")
                except OSError:
                    pass

                return True

        except FileNotFoundError:
            logging.error(f"[LOCAL] File not found: {filename}")
            return False
        except (TimeoutError, ConnectionRefusedError, OSError) as e:
            logging.error(f"[LOCAL] Connection issue: {e}. Attempt {attempt + 1}/3")
            if attempt < 2:
                time.sleep(1)
        except Exception as e:
            logging.error(f"[LOCAL] Error uploading image: {e}")
            return False

    logging.error("[LOCAL] Failed to upload image after 3 attempts")
    return False


def _local_ae_notify(status: str, exp_us: int, gain: float):
    """Send AE status to controller via heartbeat port."""
    try:
        if status == "locked":
            payload = f"AE_LOCKED:rep8:exp={exp_us},gain={gain:.2f}"
        elif status == "metering":
            payload = "AE_METERING:rep8"
        else:
            payload = "AE_CLEARED:rep8"
        with socket.socket(socket.AF_INET, socket.SOCK_DGRAM) as s:
            s.sendto(payload.encode(), (CONTROLLER_IP, HEARTBEAT_PORT))
        logging.info(f"[AE] Notified controller: {payload}")
    except Exception as e:
        logging.debug(f"[AE] Could not notify controller: {e}")


def _local_ae_meter_and_lock():
    """Spot-meter for rep8 using pixel-luminance metering.

    Grabs a live frame, crops to the requested region, measures average luminance,
    then scales current exposure to bring that region to a target brightness (128/255).
    Applies the computed exposure to the live stream immediately (WYSIWYG) and saves
    it as ae_lock for still captures.

    This is real scene-relative metering — independent of capture_metadata() which
    returns near-constant values on the IMX296.
    """
    global video_picam2, _last_video_exp_us, _last_video_gain

    _local_ae_notify("metering", 0, 0.0)
    logging.info("[AE] meter_and_lock: starting pixel-luminance metering")

    try:
        from shared.transforms import load_device_settings, save_device_settings
        import numpy as np

        settings = load_device_settings("rep8")
        ae_region = settings.get("ae_region")
        if not ae_region:
            logging.warning("[AE] No ae_region set — aborting meter")
            return
        nx, ny, nw, nh = ae_region  # normalised 0-1000

        # Grab a live frame from the video stream
        if video_picam2 is None:
            logging.warning("[AE] No live camera — aborting meter")
            return

        frame = video_picam2.capture_array()  # RGB, 640x480
        h, w = frame.shape[:2]

        # Convert normalised region to pixel coords
        x0 = int(nx / 1000 * w)
        y0 = int(ny / 1000 * h)
        x1 = min(w, int((nx + nw) / 1000 * w))
        y1 = min(h, int((ny + nh) / 1000 * h))

        if x1 <= x0 or y1 <= y0:
            logging.warning(f"[AE] Invalid crop region ({x0},{y0})-({x1},{y1})")
            return

        crop = frame[y0:y1, x0:x1]
        # Luminance from RGB (BT.601)
        lum = 0.299 * crop[:, :, 0] + 0.587 * crop[:, :, 1] + 0.114 * crop[:, :, 2]
        measured = float(np.mean(lum))
        if measured < 1.0:
            measured = 1.0  # avoid divide-by-zero

        # Target: midtone (128/255 ≈ 0.502)
        TARGET_LUM = 128.0
        scale = TARGET_LUM / measured

        # Current exposure baseline
        current_exp = _last_video_exp_us if _last_video_exp_us > 50 else 355
        current_gain = _last_video_gain if _last_video_gain > 0 else 1.0

        # Compute target exposure — clamp to IMX296 valid range (340–15000µs)
        # Distribute scaling across exposure first, then gain
        new_exp = int(current_exp * scale)
        new_gain = current_gain
        if new_exp > 15000:
            # Overflow into gain
            gain_scale = new_exp / 15000
            new_exp = 15000
            new_gain = min(16.0, current_gain * gain_scale)
        elif new_exp < 340:
            # Underflow — use minimum
            new_exp = 340

        logging.info(
            f"[AE] Pixel metering: region=({nx},{ny}) {nw}x{nh}/1000 "
            f"crop=({x0},{y0})-({x1},{y1}) lum={measured:.1f} "
            f"scale={scale:.2f} "
            f"exp: {current_exp}→{new_exp}µs gain: {current_gain:.2f}→{new_gain:.2f}"
        )

        # Apply to live video stream immediately (WYSIWYG)
        if video_picam2 is not None:
            video_picam2.set_controls(
                {
                    "ExposureTime": new_exp,
                    "AnalogueGain": new_gain,
                    "ExposureTimeMode": 1,
                    "AnalogueGainMode": 1,
                }
            )
            _last_video_exp_us = new_exp
            _last_video_gain = new_gain
            logging.info(f"[AE] Applied to live stream: exp={new_exp}µs gain={new_gain:.2f}")

        # Save as ae_lock for still captures
        settings["ae_lock"] = {"exp_us": new_exp, "gain": new_gain}
        save_device_settings("rep8", settings)
        _local_ae_notify("locked", new_exp, float(new_gain))
        logging.info(
            f"[AE] ✅ Spot meter locked: exp={new_exp}µs gain={new_gain:.2f} (metered lum={measured:.1f}, target=128)"
        )

    except Exception as e:
        logging.error(f"[AE] meter_and_lock failed: {e}")


def _local_wb_notify(status: str, red_gain: float, blue_gain: float):
    """Send WB status to controller via heartbeat port (mirrors _local_ae_notify)."""
    try:
        if status == "locked":
            payload = f"WB_LOCKED:rep8:red={red_gain:.3f},blue={blue_gain:.3f}"
        elif status == "metering":
            payload = "WB_METERING:rep8"
        else:
            payload = "WB_CLEARED:rep8"
        with socket.socket(socket.AF_INET, socket.SOCK_DGRAM) as s:
            s.sendto(payload.encode(), (CONTROLLER_IP, HEARTBEAT_PORT))
        logging.info(f"[WB] Notified controller: {payload}")
    except Exception as e:
        logging.debug(f"[WB] Could not notify controller: {e}")


def _local_wb_sample_and_lock():
    """Grey-point WB sampling for rep8 (IMX296).

    Called from the streaming loop — owns video_picam2, no thread races.
    Mirrors _local_ae_meter_and_lock() architecture exactly.
    """
    global video_picam2

    logging.info("[WB] Local grey-point WB sampling starting for rep8")
    _local_wb_notify("metering", 0.0, 0.0)

    try:
        import numpy as np

        if video_picam2 is None:
            logging.warning("[WB] No live camera for rep8 — aborting WB sample")
            return

        from shared.transforms import load_device_settings, save_device_settings

        settings = load_device_settings("rep8")
        wb_region = settings.get("wb_region")
        if not wb_region:
            logging.warning("[WB] No wb_region set for rep8 — aborting sample")
            return
        nx, ny, nw, nh = wb_region

        frame = video_picam2.capture_array()  # RGB
        h, w = frame.shape[:2]

        x0 = int(nx / 1000 * w)
        y0 = int(ny / 1000 * h)
        x1 = min(w, int((nx + nw) / 1000 * w))
        y1 = min(h, int((ny + nh) / 1000 * h))

        if x1 <= x0 or y1 <= y0:
            logging.warning(f"[WB] Invalid crop for rep8: ({x0},{y0})-({x1},{y1})")
            return

        crop = frame[y0:y1, x0:x1].astype(float)
        # Picamera2 RGB888 format: memory layout is R,G,B — numpy [:,:,0]=Red, [:,:,2]=Blue.
        raw_ch0 = float(np.mean(crop[:, :, 0]))
        raw_ch1 = float(np.mean(crop[:, :, 1]))
        raw_ch2 = float(np.mean(crop[:, :, 2]))
        logging.info(f"[WB] Sample for rep8: R(ch0)={raw_ch0:.1f} G(ch1)={raw_ch1:.1f} B(ch2)={raw_ch2:.1f}")
        r_mean = max(1.0, raw_ch0)  # Red   = channel 0 (RGB)
        g_mean = max(1.0, raw_ch1)  # Green = channel 1
        b_mean = max(1.0, raw_ch2)  # Blue  = channel 2 (RGB)

        # Read current ColourGains from metadata and scale by correction factor
        current_gains = (1.0, 1.0)
        try:
            meta = video_picam2.capture_metadata()
            cg = meta.get("ColourGains")
            if cg and len(cg) == 2 and cg[0] > 0.1 and cg[1] > 0.1:
                current_gains = (float(cg[0]), float(cg[1]))
                logging.info(f"[WB] rep8 current ColourGains: R={cg[0]:.3f} B={cg[1]:.3f}")
        except Exception as _e:
            logging.debug(f"[WB] Could not read rep8 ColourGains metadata: {_e}")

        corr_r = g_mean / r_mean
        corr_b = g_mean / b_mean
        red_gain = max(0.5, min(3.0, current_gains[0] * corr_r))
        blue_gain = max(0.5, min(3.0, current_gains[1] * corr_b))

        logging.info(
            f"[WB] rep8 grey-point: R={r_mean:.1f} G={g_mean:.1f} B={b_mean:.1f} "
            f"corr=({corr_r:.3f},{corr_b:.3f}) existing=({current_gains[0]:.3f},{current_gains[1]:.3f}) "
            f"→ red={red_gain:.3f} blue={blue_gain:.3f}"
        )

        video_picam2.set_controls({"ColourGains": (red_gain, blue_gain)})
        settings["wb_lock"] = {"red_gain": round(red_gain, 4), "blue_gain": round(blue_gain, 4)}
        save_device_settings("rep8", settings)
        _local_wb_notify("locked", red_gain, blue_gain)
        logging.info(f"[WB] ✅ WB locked for rep8: red={red_gain:.3f} blue={blue_gain:.3f}")

    except Exception as e:
        logging.error(f"[WB] local wb_sample_and_lock failed: {e}")


def handle_local_commands():
    """Enhanced command handler (same as working version)"""
    global streaming, jpeg_quality, camera_settings, video_thread, video_picam2, _local_wb_cleared

    # Ensure clean initial state
    with streaming_lock:
        streaming = False
        logging.info("[LOCAL] Reset streaming flag to False on startup")

    logging.info(f"Starting command handler on port {LOCAL_CONTROL_PORT}")

    sock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
    sock.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)

    try:
        sock.bind(("0.0.0.0", LOCAL_CONTROL_PORT))
        logging.info(f"✓ Command handler listening on port {LOCAL_CONTROL_PORT}")
    except OSError as e:
        logging.error(f"✗ Failed to bind to port {LOCAL_CONTROL_PORT}: {e}")
        return

    command_count = 0

    while True:
        try:
            sock.settimeout(5.0)
            data, addr = sock.recvfrom(1024)
            command = data.decode().strip()
            command_count += 1

            logging.info(f"[LOCAL] Command #{command_count} from {addr}: {command}")

            if command == "START_STREAM":
                logging.info("Processing START_STREAM command")
                with streaming_lock:
                    current_state = streaming
                if not current_state:
                    logging.info("Starting video thread (streaming was False)")
                    video_thread = threading.Thread(target=start_local_video_stream, daemon=True)
                    video_thread.start()
                else:
                    logging.info(f"Stream already running (streaming = {current_state})")

            elif command == "STOP_STREAM":
                logging.info("Processing STOP_STREAM command")
                stop_local_video_stream()

            elif command == "CAPTURE_STILL":
                logging.info("Processing CAPTURE_STILL command - using proper protocol")
                threading.Thread(target=capture_local_still, daemon=True).start()

            elif command == "RESTART_STREAM_WITH_SETTINGS":
                restart_local_stream()

            elif command == "STATUS":
                status = f"STREAMING:{streaming},HEARTBEAT:{time.time() - last_heartbeat:.1f}s_ago"
                logging.info(f"Status request: {status}")

            elif command.startswith("SET_QUALITY_"):
                try:
                    quality = int(command.split("_")[2])
                    if 20 <= quality <= 100:
                        jpeg_quality = quality
                        camera_settings["jpeg_quality"] = quality
                        logging.info(f"JPEG quality set to {quality}")
                except Exception as e:
                    logging.error(f"Invalid quality command: {command}, error: {e}")

            # TRANSFORM COMMANDS
            elif command.startswith("SET_CAMERA_CROP_"):
                handle_local_crop_setting(command)
            elif command.startswith("SET_CAMERA_FLIP_"):
                handle_local_flip_setting(command)
            elif command.startswith("SET_CAMERA_GRAYSCALE_"):
                handle_local_grayscale_setting(command)
            elif command.startswith("SET_CAMERA_ROTATION_"):
                handle_local_rotation_setting(command)

            # BULK SETTINGS PACKAGE
            elif command.startswith("SET_ALL_SETTINGS_"):
                handle_local_settings_package(command)

            # RAW/DNG enable/disable (must be BEFORE generic SET_CAMERA_ handler)
            elif command.startswith("SET_CAMERA_RAW_ENABLED_"):
                value = command.split("SET_CAMERA_RAW_ENABLED_")[1]
                camera_settings["raw_enabled"] = value.lower() == "true"
                logging.info(
                    f"[LOCAL] RAW capture {'ENABLED' if camera_settings['raw_enabled'] else 'DISABLED'} for rep8"
                )

            # GENERAL CAMERA SETTINGS
            elif command.startswith("SET_CAMERA_"):
                handle_local_camera_setting(command)

            # RESET COMMANDS
            elif command == "RESET_CAMERA_DEFAULTS":
                reset_local_to_defaults()
            elif command == "RESET_TO_FACTORY_DEFAULTS":
                factory_reset_local()

            # SPOT METERING — queue for streaming loop (thread-safe)
            elif command.startswith("SET_AE_REGION_"):
                try:
                    parts = command.split("_")[3:]
                    nx, ny, nw, nh = int(parts[0]), int(parts[1]), int(parts[2]), int(parts[3])
                    logging.info(
                        f"[AE] Spot meter requested for rep8: ({nx},{ny}) {nw}x{nh}/1000 — queuing for stream loop"
                    )
                    from shared.transforms import load_device_settings, save_device_settings

                    settings = load_device_settings("rep8")
                    settings["ae_region"] = [nx, ny, nw, nh]
                    settings.pop("ae_lock", None)
                    save_device_settings("rep8", settings)
                    # Signal streaming loop — it services the meter from within its own thread
                    global _local_ae_meter_pending, _local_ae_meter_region
                    with _local_ae_meter_lock:
                        _local_ae_meter_pending = True
                        _local_ae_meter_region = [nx, ny, nw, nh]
                    _local_ae_notify("metering", 0, 0.0)
                except Exception as e:
                    logging.error(f"[AE] Failed to queue spot meter for rep8: {e}")

            elif command == "CLEAR_AE_REGION":
                try:
                    from shared.transforms import load_device_settings, save_device_settings

                    settings = load_device_settings("rep8")
                    settings.pop("ae_region", None)
                    settings.pop("ae_lock", None)
                    save_device_settings("rep8", settings)
                    if video_picam2 is not None:
                        video_picam2.set_controls(
                            {
                                "ExposureTimeMode": 0,
                                "AnalogueGainMode": 0,
                            }
                        )
                        logging.info("[AE] ✅ Full-frame AE restored for rep8")
                    _local_ae_notify("cleared", 0, 0.0)
                except Exception as e:
                    logging.error(f"[AE] Failed to clear AE region for rep8: {e}")

            elif command.startswith("SET_WB_REGION_"):
                try:
                    parts = command.split("_")[3:]
                    nx, ny, nw, nh = int(parts[0]), int(parts[1]), int(parts[2]), int(parts[3])
                    logging.info(
                        f"[WB] Grey-point sample requested for rep8: "
                        f"({nx},{ny}) {nw}x{nh}/1000 — queuing for stream loop"
                    )
                    from shared.transforms import load_device_settings, save_device_settings

                    settings = load_device_settings("rep8")
                    settings["wb_region"] = [nx, ny, nw, nh]
                    settings.pop("wb_lock", None)
                    save_device_settings("rep8", settings)
                    global _local_wb_meter_pending, _local_wb_meter_region
                    _local_wb_cleared = False  # new sample — allow notifications
                    with _local_wb_meter_lock:
                        _local_wb_meter_pending = True
                        _local_wb_meter_region = [nx, ny, nw, nh]
                    _local_wb_notify("metering", 0.0, 0.0)
                except Exception as e:
                    logging.error(f"[WB] Failed to queue WB sample for rep8: {e}")

            elif command.startswith("SET_WB_LOCK_"):
                try:
                    parts = command.split("_")[3:]
                    red_gain = max(0.5, min(3.0, float(parts[0])))
                    blue_gain = max(0.5, min(3.0, float(parts[1])))
                    from shared.transforms import load_device_settings, save_device_settings

                    settings = load_device_settings("rep8")
                    settings["wb_lock"] = {"red_gain": round(red_gain, 4), "blue_gain": round(blue_gain, 4)}
                    save_device_settings("rep8", settings)
                    _local_wb_cleared = False  # new lock — allow notifications
                    if video_picam2 is not None:
                        video_picam2.set_controls({"ColourGains": (red_gain, blue_gain)})
                    _local_wb_notify("locked", red_gain, blue_gain)
                    logging.info(f"[WB] ✅ Direct WB lock for rep8: red={red_gain:.3f} blue={blue_gain:.3f}")
                except Exception as e:
                    logging.error(f"[WB] Failed to apply direct WB lock for rep8: {e}")

            elif command == "CLEAR_WB_LOCK":
                try:
                    _local_wb_cleared = True  # suppress re-notification from running stream
                    from shared.transforms import load_device_settings, save_device_settings

                    settings = load_device_settings("rep8")
                    settings.pop("wb_region", None)
                    settings.pop("wb_lock", None)
                    save_device_settings("rep8", settings)
                    if video_picam2 is not None:
                        video_picam2.set_controls({"ColourGains": (1.0, 1.0)})
                        logging.info("[WB] ✅ Auto white balance restored for rep8")
                    _local_wb_notify("cleared", 0.0, 0.0)
                except Exception as e:
                    logging.error(f"[WB] Failed to clear WB lock for rep8: {e}")

            # SYSTEM COMMANDS
            elif command in ("SHUTDOWN", "shutdown", "poweroff", "power off", "shut down"):
                logging.info("Shutdown command received. Powering off...")
                stop_local_video_stream()
                os.system("sudo poweroff")
                break
            elif command in ("REBOOT", "reboot"):
                logging.info("Reboot command received. Rebooting...")
                stop_local_video_stream()
                os.system("sudo reboot")
                break

            elif command.startswith("SET_HARDWARE_EXPOSURE_"):
                try:
                    payload = json.loads(command[len("SET_HARDWARE_EXPOSURE_") :])
                    ev_offset = float(payload.get("ev_offset", 0.0))
                    ev_offset = max(-6.0, min(6.0, ev_offset))

                    if video_picam2 is not None:
                        # Note: meta not available — capture_array() doesn't include metadata
                        # TODO: use capture_metadata() after capture if needed
                        # current_et = meta.get("ExposureTime", 10000)
                        # current_gain = meta.get("AnalogueGain", 1.0)

                        # Log pre-change frame brightness for comparison
                        pre_frame = video_picam2.capture_array()
                        logging.warning(
                            f"[CAL2_HW] rep8: PRE-change frame mean="
                            f"{float(pre_frame.mean()):.1f}/255 "
                            f"ET={current_et}us Gain={current_gain:.2f}"
                        )

                        import math

                        MAX_GAIN = 16.0
                        MAX_ET = 500000
                        if abs(ev_offset) > 3.0:
                            gain_headroom = math.log2(MAX_GAIN / max(current_gain, 0.5))
                            gain_headroom = max(0, gain_headroom)
                            if ev_offset > 0:
                                gain_ev = min(ev_offset, gain_headroom)
                                et_ev = ev_offset - gain_ev
                            else:
                                et_ev = max(ev_offset, -math.log2(current_et / 100))
                                gain_ev = ev_offset - et_ev
                            new_et = int(current_et * (2.0**et_ev))
                            new_gain = current_gain * (2.0**gain_ev)
                            new_gain = max(1.0, min(MAX_GAIN, new_gain))
                        else:
                            new_et = int(current_et * (2.0**ev_offset))
                            new_gain = current_gain
                        new_et = max(100, min(MAX_ET, new_et))

                        # Set manual mode + FrameDurationLimits + exposure values
                        # ALL in one call — libcamera v0.5 needs mode + values together
                        frame_dur = max(new_et + 1000, 40000)
                        video_picam2.set_controls(
                            {
                                "ExposureTimeMode": 1,  # Manual
                                "AnalogueGainMode": 1,  # Manual
                                "FrameDurationLimits": (frame_dur, frame_dur),
                                "ExposureTime": new_et,
                                "AnalogueGain": round(new_gain, 2),
                            }
                        )
                        time.sleep(1.0)  # longer settle for big exposure changes

                        # Drain buffer and verify actual frame brightness
                        for drain_i in range(8):
                            _drain = video_picam2.capture_array()
                        test_frame = video_picam2.capture_array()
                        logging.warning(
                            f"[CAL2_HW] rep8: post-settle frame mean="
                            f"{float(test_frame.mean()):.1f}/255 "
                            f"(shape={test_frame.shape})"
                        )

                        verify = video_picam2.capture_metadata()
                        actual_et = verify.get("ExposureTime", 0)
                        actual_gain = verify.get("AnalogueGain", 0)
                        actual_fd = verify.get("FrameDuration", 0)

                        # Retry if ET didn't take
                        et_ok = abs(actual_et - new_et) < max(new_et * 0.1, 500)
                        if not et_ok:
                            logging.warning(
                                f"[CAL2_HW] rep8: ET mismatch, retrying (wanted {new_et}us, got {actual_et}us)"
                            )
                            video_picam2.set_controls(
                                {
                                    "ExposureTimeMode": 1,
                                    "AnalogueGainMode": 1,
                                    "FrameDurationLimits": (frame_dur, frame_dur),
                                    "ExposureTime": new_et,
                                    "AnalogueGain": round(new_gain, 2),
                                }
                            )
                            time.sleep(1.5)
                            verify = video_picam2.capture_metadata()
                            actual_et = verify.get("ExposureTime", 0)
                            actual_gain = verify.get("AnalogueGain", 0)
                            actual_fd = verify.get("FrameDuration", 0)
                            et_ok = abs(actual_et - new_et) < max(new_et * 0.1, 500)

                        logging.warning(
                            f"[CAL2_HW] rep8: hardware exposure adjusted "
                            f"EV={ev_offset:+.2f} ET={current_et}->{new_et}us "
                            f"Gain={current_gain:.2f}->{new_gain:.2f} "
                            f"(verified: ET={actual_et}us Gain={actual_gain:.2f} "
                            f"FrameDur={actual_fd}us)"
                            f"{' ⚠️ MISMATCH' if not et_ok else ' ✓'}"
                        )
                    else:
                        logging.error("[CAL2_HW] rep8: no camera instance")
                except Exception as e:
                    logging.error(f"[CAL2_HW] rep8: SET_HARDWARE_EXPOSURE error: {e}")

            # === CAL2 SOFTWARE COLOUR PIPELINE COMMANDS ===
            else:
                logging.warning(f"[LOCAL] Unknown command: {command}")

        except TimeoutError:
            continue
        except Exception as e:
            logging.error(f"[LOCAL] Error handling command: {e}")


# Settings handling functions
def handle_local_settings_package(command):
    """Handle bulk settings package for local camera"""
    global camera_settings
    try:
        json_part = command[17:]
        new_settings = json.loads(json_part)

        for key, value in new_settings.items():
            if key in camera_settings:
                camera_settings[key] = value
                logging.info(f"[LOCAL] Settings package: {key} = {value}")

        try:
            from shared.transforms import load_device_settings, save_device_settings

            # Merge into existing settings — preserve ae_lock and ae_region
            existing = load_device_settings("rep8")
            existing.update(camera_settings)
            save_device_settings("rep8", existing)
            logging.info("[LOCAL] SETTINGS_APPLIED to unified system for rep8")
        except Exception as e:
            logging.error(f"[LOCAL] Failed to save unified settings: {e}")

        if streaming:
            logging.info("[LOCAL] Restarting stream for settings package...")
            restart_local_stream()
            logging.info("[LOCAL] STREAM_RESTARTED for rep8")

        logging.info(f"[LOCAL] Settings package applied: {len(new_settings)} settings updated")

    except Exception as e:
        logging.error(f"[LOCAL] Error handling settings package: {e}")


def handle_local_camera_setting(command):
    """Handle standard camera setting commands"""
    global camera_settings
    try:
        parts = command.split("_")
        setting = parts[2].lower()
        value = parts[3]

        if setting in ["brightness", "contrast", "iso", "shutter_speed", "saturation", "jpeg_quality", "fps"]:
            camera_settings[setting] = int(value)
        elif setting in ["exposure_mode", "resolution", "image_format"]:
            camera_settings[setting] = value
        else:
            camera_settings[setting] = value

        logging.info(f"[LOCAL] Camera setting updated: {setting} = {value}")

        if streaming:
            restart_local_stream()

    except Exception as e:
        logging.error(f"[LOCAL] Error handling camera setting: {e}")


def handle_local_crop_setting(command):
    """Handle crop setting commands"""
    global camera_settings
    try:
        parts = command.split("_")
        crop_param = parts[3].lower()
        value = parts[4]

        if crop_param == "enabled":
            camera_settings["crop_enabled"] = value.lower() == "true"
        elif crop_param in ["x", "y", "width", "height"]:
            camera_settings[f"crop_{crop_param}"] = int(value)

        logging.info(f"[LOCAL] Crop setting updated: crop_{crop_param} = {value}")

        if streaming:
            restart_local_stream()

    except Exception as e:
        logging.error(f"[LOCAL] Error handling crop setting: {e}")


def handle_local_flip_setting(command):
    """FIXED: Handle flip setting without affecting camera brightness"""
    global camera_settings
    try:
        logging.info(f"🔄 [LOCAL] Processing flip command: {command}")

        parts = command.split("_")
        flip_direction = parts[3].lower()
        value = parts[4].lower() == "true"

        # FIXED: Only update frame transform settings, never camera controls
        camera_settings[f"flip_{flip_direction}"] = value

        logging.info(f"[LOCAL] Flip setting updated: flip_{flip_direction} = {value}")
        logging.info(f"✅ [LOCAL] Updated flip_{flip_direction} = {value} (FRAME ONLY - no camera control changes)")

        # Save to settings file
        try:
            from shared.transforms import save_device_settings

            save_device_settings("rep8", camera_settings)
        except Exception as e:
            logging.error(f"[LOCAL] Failed to save flip settings: {e}")

        # Restart video stream to apply new transform settings
        if streaming:
            logging.info("🔄 [LOCAL] Restarting stream for flip change...")
            restart_local_stream()
        else:
            logging.info("⏹️ [LOCAL] Stream not running, settings saved for next start")

    except Exception as e:
        logging.error(f"[LOCAL] Error handling flip setting: {e}")


def handle_local_grayscale_setting(command):
    """Handle grayscale setting command"""
    global camera_settings
    try:
        logging.info(f"🎨 [LOCAL] Processing grayscale command: {command}")

        parts = command.split("_")
        value = parts[3].lower() == "true"

        camera_settings["grayscale"] = value

        logging.info(f"[LOCAL] Grayscale setting updated: {value}")

        try:
            from shared.transforms import save_device_settings

            save_device_settings("rep8", camera_settings)
        except Exception as e:
            logging.error(f"[LOCAL] Failed to save grayscale settings: {e}")

        if streaming:
            logging.info("🔄 [LOCAL] Restarting stream for grayscale change...")
            restart_local_stream()

    except Exception as e:
        logging.error(f"[LOCAL] Error handling grayscale setting: {e}")


def handle_local_rotation_setting(command):
    """Handle rotation setting command"""
    global camera_settings
    try:
        parts = command.split("_")
        rotation = int(parts[3])

        if rotation in [0, 90, 180, 270]:
            camera_settings["rotation"] = rotation
            logging.info(f"[LOCAL] Rotation setting updated: {rotation}°")

            try:
                from shared.transforms import save_device_settings

                save_device_settings("rep8", camera_settings)
            except Exception as e:
                logging.error(f"[LOCAL] Failed to save rotation settings: {e}")

            if streaming:
                restart_local_stream()
        else:
            logging.warning(f"[LOCAL] Invalid rotation value: {rotation}")

    except Exception as e:
        logging.error(f"[LOCAL] Error handling rotation setting: {e}")


def reset_local_to_defaults():
    """Reset local camera settings to defaults"""
    global camera_settings

    logging.info("[LOCAL] 🔄 Resetting camera to default settings...")

    try:
        from shared.transforms import save_device_settings, DEFAULT_SETTINGS

        default_settings = DEFAULT_SETTINGS.copy()
        camera_settings = default_settings.copy()

        if save_device_settings("rep8", default_settings):
            logging.info("[LOCAL] ✅ Default settings saved to rep8_settings.json")
        else:
            logging.error("[LOCAL] ❌ Failed to save default settings")

        if streaming:
            logging.info("[LOCAL] 🔄 Restarting stream with default settings...")
            restart_local_stream()

        logging.info("[LOCAL] ✅ Camera reset to defaults complete")
    except Exception as e:
        logging.error(f"[LOCAL] Error resetting to defaults: {e}")


def restart_local_stream():
    """Restart local video stream with new settings"""
    global streaming, video_thread

    logging.info("[LOCAL] 🔄 Restarting video stream with new settings...")

    try:
        was_streaming = False
        with streaming_lock:
            was_streaming = streaming
            streaming = False

        if was_streaming:
            logging.info("[LOCAL] 🛑 Stopping current stream...")

            if video_thread and video_thread.is_alive():
                logging.info("[LOCAL] Waiting for video thread to finish...")
                video_thread.join(timeout=3.0)
                logging.info("[LOCAL] Video thread finished")

            time.sleep(0.5)

            logging.info("[LOCAL] 🚀 Starting new stream with transforms...")
            video_thread = threading.Thread(target=start_local_video_stream, daemon=True)
            video_thread.start()
            logging.info("[LOCAL] ✅ Video stream restarted successfully")
        else:
            logging.info("[LOCAL] ⏩ Stream wasn't running, no restart needed")

    except Exception as e:
        logging.error(f"[LOCAL] ❌ Error during stream restart: {e}")
        with streaming_lock:
            streaming = False


def factory_reset_local():
    """Complete factory reset for local camera"""
    global camera_settings

    logging.info("[LOCAL] 🔄 Starting factory reset...")

    try:
        from shared.transforms import save_device_settings, DEFAULT_SETTINGS

        default_settings = DEFAULT_SETTINGS.copy()
        camera_settings = default_settings.copy()

        if save_device_settings("rep8", default_settings):
            logging.info("[LOCAL] ✅ Factory defaults saved to rep8_settings.json")
        else:
            logging.error("[LOCAL] ❌ Failed to save factory defaults")

        if streaming:
            logging.info("[LOCAL] 🔄 Restarting stream after factory reset...")
            restart_local_stream()
            logging.info("[LOCAL] ✅ Stream restarted with factory defaults")

        logging.info("[LOCAL] ✅ Factory reset complete")
    except Exception as e:
        logging.error(f"[LOCAL] Error during factory reset: {e}")


def initialize_local_settings():
    """Initialize settings file for rep8 on startup"""
    try:
        device_name = "rep8"
        logging.info(f"[LOCAL] Initializing settings for device: {device_name}")

        from shared.transforms import load_device_settings

        load_device_settings(device_name)  # Ensures settings file exists

        logging.info(f"[LOCAL] ✅ Device settings initialized for {device_name}")
        return True

    except Exception as e:
        logging.error(f"[LOCAL] Failed to initialize device settings: {e}")
        return False


def main():
    """Main function with enhanced startup"""
    logging.info("[LOCAL] Starting COMPLETE FIXED local camera service...")
    logging.info("[LOCAL] ✅ HIGH RESOLUTION: 4056x3040 (4:3) still captures")
    logging.info("[LOCAL] ✅ WORKING TRANSFORMS: Using shared.transforms system")
    logging.info("[LOCAL] ✅ CORRECT COLORS: RGB format for GUI")
    logging.info("[LOCAL] ✅ PROPER PROTOCOL: Stop→Capture→Upload→Restart")
    logging.info(f"[LOCAL] Configuration: Controller={CONTROLLER_IP}")
    logging.info(f"[LOCAL] Control Port={LOCAL_CONTROL_PORT}, Video Port={VIDEO_PORT}, Heartbeat Port={HEARTBEAT_PORT}")

    # Initialize device settings on startup
    if not initialize_local_settings():
        logging.error("Failed to initialize local device settings, continuing anyway...")

    # Start background services
    logging.info("Starting background services...")

    # Start command handler
    cmd_thread = threading.Thread(target=handle_local_commands, daemon=True)
    cmd_thread.start()
    logging.info("✓ Command handler started")

    # Start heartbeat
    heartbeat_thread = threading.Thread(target=send_local_heartbeat, daemon=True)
    heartbeat_thread.start()
    logging.info("✓ Heartbeat service started")

    time.sleep(2.0)

    logging.info("[LOCAL] All services started. Monitoring...")
    logging.info("[LOCAL] ✅ COMPLETE FIX: High-res + working transforms + correct colors")
    logging.info("[LOCAL] Send START_STREAM command to begin video streaming")

    try:
        monitor_count = 0
        while True:
            time.sleep(10)
            monitor_count += 1

            status_msg = (
                f"Monitor #{monitor_count}: "
                f"Streaming={streaming}, "
                f"Last heartbeat: {time.time() - last_heartbeat:.1f}s ago"
            )
            logging.info(status_msg)

    except KeyboardInterrupt:
        logging.info("[LOCAL] Shutting down local camera service...")
        with streaming_lock:
            if streaming:
                stop_local_video_stream()
    except Exception as e:
        logging.error(f"[LOCAL] Unexpected error in main: {e}")
    finally:
        logging.info("[LOCAL] Local camera service stopped.")


if __name__ == "__main__":
    main()