wasma-sys 1.3.0-beta-stable

// WASMA - Windows Assignment System Monitoring Architecture
// wasma_protocol_unix_posix_opt.rs
// POSIX Optionalty Configuration
// All optional settings for WASMA window drawing, rendering, and backend selection.
// Groups: DrawOpt, PixelOpt, XlinxOpt, BackendOpt
// Design: Grouped structs + Builder pattern (both)
// Source: wasma.in.conf parse + runtime override API
// January 2026

use crate::parser::WasmaConfig;
use crate::wasma_protocol_universal_client_unix_posix_window::{ArchKind, CURRENT_ARCH};
use std::sync::{Arc, RwLock};

// ============================================================================
// DRAW OPT — Drawing size and toolkit theme selection
// ============================================================================

/// UI toolkit selection
#[derive(Debug, Clone, PartialEq)]
pub enum ToolkitTheme {
    /// GTK (GNOME toolkit) — GTK3/GTK4
    Gtk(GtkThemeOpt),
    /// Iced (Rust-native GUI)
    Iced(IcedThemeOpt),
    /// Qt (KDE toolkit) — Qt5/Qt6
    Qt(QtThemeOpt),
    /// No toolkit — raw drawing only
    None,
}

impl ToolkitTheme {
    pub fn name(&self) -> &'static str {
        match self {
            Self::Gtk(_) => "GTK",
            Self::Iced(_) => "Iced",
            Self::Qt(_) => "Qt",
            Self::None => "None (raw)",
        }
    }
}

/// GTK theme options
#[derive(Debug, Clone, PartialEq)]
pub struct GtkThemeOpt {
    /// Theme name (e.g. "Adwaita", "Arc", "Breeze")
    pub theme_name: String,
    /// GTK version (3 or 4)
    pub version: u8,
    /// Dark mode
    pub dark_mode: bool,
    /// Font scaling factor
    pub font_scale: f32,
    /// Icon theme name
    pub icon_theme: Option<String>,
}

impl Default for GtkThemeOpt {
    fn default() -> Self {
        Self {
            theme_name: "Adwaita".to_string(),
            version: 4,
            dark_mode: false,
            font_scale: 1.0,
            icon_theme: None,
        }
    }
}

/// Iced theme options
#[derive(Debug, Clone, PartialEq)]
pub struct IcedThemeOpt {
    /// Built-in theme variant
    pub variant: IcedThemeVariant,
    /// Custom accent color (RGBA)
    pub accent_color: Option<[u8; 4]>,
    /// Font family
    pub font_family: Option<String>,
    /// Default text size in logical pixels
    pub text_size: f32,
}

#[derive(Debug, Clone, PartialEq)]
pub enum IcedThemeVariant {
    Light,
    Dark,
    Dracula,
    Nord,
    SolarizedLight,
    SolarizedDark,
    GruvboxLight,
    GruvboxDark,
    CatppuccinLatte,
    CatppuccinMocha,
    Custom(String),
}

impl Default for IcedThemeOpt {
    fn default() -> Self {
        Self {
            variant: IcedThemeVariant::Dark,
            accent_color: None,
            font_family: None,
            text_size: 16.0,
        }
    }
}

/// Qt theme options
#[derive(Debug, Clone, PartialEq)]
pub struct QtThemeOpt {
    /// Style name (e.g. "Fusion", "Breeze", "Oxygen")
    pub style_name: String,
    /// Qt version (5 or 6)
    pub version: u8,
    /// Dark mode
    pub dark_mode: bool,
    /// Platform theme (e.g. "gtk2", "gnome", "kde")
    pub platform_theme: Option<String>,
    /// Font point size
    pub font_pt: f32,
}

impl Default for QtThemeOpt {
    fn default() -> Self {
        Self {
            style_name: "Fusion".to_string(),
            version: 6,
            dark_mode: false,
            platform_theme: None,
            font_pt: 10.0,
        }
    }
}

/// Drawing size configuration
#[derive(Debug, Clone, PartialEq)]
pub struct DrawSizeOpt {
    /// Minimum window width in logical pixels
    pub min_width: u32,
    /// Minimum window height in logical pixels
    pub min_height: u32,
    /// Maximum window width (None = unlimited)
    pub max_width: Option<u32>,
    /// Maximum window height (None = unlimited)
    pub max_height: Option<u32>,
    /// Default window width
    pub default_width: u32,
    /// Default window height
    pub default_height: u32,
    /// Aspect ratio constraint (width/height, None = free)
    pub aspect_ratio: Option<f32>,
    /// Whether window is resizable
    pub resizable: bool,
}

impl Default for DrawSizeOpt {
    fn default() -> Self {
        Self {
            min_width: 100,
            min_height: 100,
            max_width: None,
            max_height: None,
            default_width: 800,
            default_height: 600,
            aspect_ratio: None,
            resizable: true,
        }
    }
}

/// Drawing options group
#[derive(Debug, Clone)]
pub struct DrawOpt {
    pub size: DrawSizeOpt,
    pub toolkit: ToolkitTheme,
    /// Anti-aliasing enabled
    pub antialiasing: bool,
    /// Subpixel rendering (ClearType-style)
    pub subpixel_rendering: bool,
    /// Vsync
    pub vsync: bool,
    /// Target FPS (None = unlimited)
    pub target_fps: Option<u32>,
}

impl Default for DrawOpt {
    fn default() -> Self {
        Self {
            size: DrawSizeOpt::default(),
            toolkit: ToolkitTheme::Iced(IcedThemeOpt::default()),
            antialiasing: true,
            subpixel_rendering: false,
            vsync: true,
            target_fps: None,
        }
    }
}

// ============================================================================
// PIXEL OPT — Pixel size, color, and grid configuration
// ============================================================================

/// Pixel color format
#[derive(Debug, Clone, Copy, PartialEq)]
pub enum PixelColorFormat {
    Rgb888,
    Rgba8888,
    Bgr888,
    Bgra8888,
    Rgb565,
    /// 10-bit HDR
    Rgb101010,
    Rgba16Float,
    /// Grayscale
    Luma8,
}

impl PixelColorFormat {
    pub fn bytes_per_pixel(&self) -> u8 {
        match self {
            Self::Rgb888 => 3,
            Self::Rgba8888 => 4,
            Self::Bgr888 => 3,
            Self::Bgra8888 => 4,
            Self::Rgb565 => 2,
            Self::Rgb101010 => 4,
            Self::Rgba16Float => 8,
            Self::Luma8 => 1,
        }
    }

    pub fn name(&self) -> &'static str {
        match self {
            Self::Rgb888 => "RGB888",
            Self::Rgba8888 => "RGBA8888",
            Self::Bgr888 => "BGR888",
            Self::Bgra8888 => "BGRA8888",
            Self::Rgb565 => "RGB565",
            Self::Rgb101010 => "RGB101010",
            Self::Rgba16Float => "RGBA16F",
            Self::Luma8 => "Luma8",
        }
    }
}

/// Pixel grid configuration — screen-dependent
/// Adapts grid parameters to actual screen properties
#[derive(Debug, Clone, PartialEq)]
pub struct PixelGridScreenDep {
    /// Grid cell width tied to screen pixel pitch
    pub cell_width_px: u32,
    /// Grid cell height tied to screen pixel pitch
    pub cell_height_px: u32,
    /// Grid line color (RGBA)
    pub line_color: [u8; 4],
    /// Grid line width in physical pixels
    pub line_width_phys: f32,
    /// Show grid (debug/design mode)
    pub visible: bool,
    /// Snap windows to grid
    pub snap_to_grid: bool,
}

impl Default for PixelGridScreenDep {
    fn default() -> Self {
        Self {
            cell_width_px: 8,
            cell_height_px: 8,
            line_color: [200, 200, 200, 64],
            line_width_phys: 0.5,
            visible: false,
            snap_to_grid: false,
        }
    }
}

/// Pixel grid configuration — screen-independent
/// Fixed logical units, DPI-agnostic
#[derive(Debug, Clone, PartialEq)]
pub struct PixelGridScreenIndep {
    /// Grid cell size in logical pixels (DPI-independent)
    pub cell_size_logical: f32,
    /// Sub-grid divisions per cell
    pub subdivisions: u8,
    /// Major grid every N cells
    pub major_every: u32,
    /// Major line color (RGBA)
    pub major_color: [u8; 4],
    /// Minor line color (RGBA)
    pub minor_color: [u8; 4],
    pub visible: bool,
}

impl Default for PixelGridScreenIndep {
    fn default() -> Self {
        Self {
            cell_size_logical: 16.0,
            subdivisions: 4,
            major_every: 8,
            major_color: [150, 150, 150, 128],
            minor_color: [200, 200, 200, 64],
            visible: false,
        }
    }
}

/// Pixel size configuration
#[derive(Debug, Clone, PartialEq)]
pub struct PixelSizeOpt {
    /// Logical pixel size multiplier (1.0 = normal, 2.0 = 2x zoom)
    pub logical_scale: f32,
    /// Physical pixel size in micrometers (0 = auto from DPI)
    pub physical_size_um: f32,
    /// Minimum renderable pixel size in logical units
    pub min_size_logical: f32,
}

impl Default for PixelSizeOpt {
    fn default() -> Self {
        Self {
            logical_scale: 1.0,
            physical_size_um: 0.0,
            min_size_logical: 0.5,
        }
    }
}

/// Pixel options group
#[derive(Debug, Clone)]
pub struct PixelOpt {
    pub size: PixelSizeOpt,
    pub color_format: PixelColorFormat,
    /// Background color (RGBA)
    pub background_color: [u8; 4],
    /// Clear color (RGBA) — used when clearing framebuffer
    pub clear_color: [u8; 4],
    pub grid_screen_dep: PixelGridScreenDep,
    pub grid_screen_indep: PixelGridScreenIndep,
    /// Enable pixel-perfect rendering (snap to integer coordinates)
    pub pixel_perfect: bool,
    /// Gamma correction value (1.0 = linear, 2.2 = sRGB)
    pub gamma: f32,
}

impl Default for PixelOpt {
    fn default() -> Self {
        Self {
            size: PixelSizeOpt::default(),
            color_format: PixelColorFormat::Rgba8888,
            background_color: [30, 30, 30, 255],
            clear_color: [0, 0, 0, 255],
            grid_screen_dep: PixelGridScreenDep::default(),
            grid_screen_indep: PixelGridScreenIndep::default(),
            pixel_perfect: true,
            gamma: 2.2,
        }
    }
}

// ============================================================================
// XLINX OPT — Cache, rasterization, architecture, software fallback
// ============================================================================

/// Xlinx cache mode
#[derive(Debug, Clone, Copy, PartialEq)]
pub enum XlinxCacheMode {
    /// Automatic cache management (default)
    Auto,
    /// No cache — always redraw (debug/profiling)
    NoCache,
    /// Manual cache control via API
    Manual,
    /// Aggressive caching — cache everything possible
    Aggressive,
}

impl XlinxCacheMode {
    pub fn name(&self) -> &'static str {
        match self {
            Self::Auto => "auto",
            Self::NoCache => "no_cache",
            Self::Manual => "manual",
            Self::Aggressive => "aggressive",
        }
    }

    pub fn from_str(s: &str) -> Self {
        match s {
            "no_cache" | "none" => Self::NoCache,
            "manual" => Self::Manual,
            "aggressive" | "full" => Self::Aggressive,
            _ => Self::Auto,
        }
    }
}

/// Rasterization mode
#[derive(Debug, Clone, Copy, PartialEq)]
pub enum RasterMode {
    /// Debug rasterization — slow, annotated output (only in debug builds)
    /// WARNING: not for production use
    Debug,
    /// Hardware-based rasterization (GPU, requires hardware support)
    Hardware,
    /// Software-based rasterization (CPU fallback via Xlinx)
    Software,
    /// Auto: hardware if available, software fallback
    Auto,
}

impl RasterMode {
    pub fn name(&self) -> &'static str {
        match self {
            Self::Debug => "debug (rasterization)",
            Self::Hardware => "hardware",
            Self::Software => "software (xlinx fallback)",
            Self::Auto => "auto",
        }
    }

    pub fn from_str(s: &str) -> Self {
        match s {
            "debug" | "dbg" => Self::Debug,
            "hardware" | "hw" => Self::Hardware,
            "software" | "sw" => Self::Software,
            _ => Self::Auto,
        }
    }

    pub fn is_debug_only(&self) -> bool {
        matches!(self, Self::Debug)
    }
}

/// Xlinx base architecture selection
/// Determines which Xlinx rendering pipeline variant is used
#[derive(Debug, Clone, Copy, PartialEq)]
pub enum XlinxArch {
    /// x86_64 native pipeline
    X86_64,
    /// AArch64 / ARM64 native pipeline
    Aarch64,
    /// RISC-V pipeline
    RiscV,
    /// Generic / portable pipeline (for unsupported archs)
    Generic,
    /// Software-only pipeline (Xlinx-based software rasterization)
    SoftwareOnly,
    /// Auto-detect from compile-time arch
    Auto,
}

impl XlinxArch {
    pub fn auto_detect() -> Self {
        match CURRENT_ARCH {
            ArchKind::Amd64 => Self::X86_64,
            ArchKind::Aarch64 => Self::Aarch64,
            ArchKind::RiscV64 => Self::RiscV,
            ArchKind::Sisd | ArchKind::Unknown => Self::SoftwareOnly,
            _ => Self::Generic,
        }
    }

    pub fn name(&self) -> &'static str {
        match self {
            Self::X86_64 => "x86_64",
            Self::Aarch64 => "aarch64",
            Self::RiscV => "riscv",
            Self::Generic => "generic",
            Self::SoftwareOnly => "software_only",
            Self::Auto => "auto",
        }
    }

    pub fn from_str(s: &str) -> Self {
        match s {
            "x86_64" | "amd64" => Self::X86_64,
            "aarch64" | "arm64" => Self::Aarch64,
            "riscv" | "riscv64" => Self::RiscV,
            "generic" => Self::Generic,
            "software" | "sw" => Self::SoftwareOnly,
            _ => Self::Auto,
        }
    }
}

/// USET (User Environment SET) permission flags
/// Controls which Xlinx features the user environment is allowed to configure
#[derive(Debug, Clone, PartialEq)]
pub struct XlinxUsetPermission {
    /// User can change cache mode
    pub allow_cache_change: bool,
    /// User can switch raster mode (cannot enable Debug in production)
    pub allow_raster_change: bool,
    /// User can change arch selection
    pub allow_arch_change: bool,
    /// User can disable hardware acceleration
    pub allow_sw_fallback: bool,
    /// User can modify auto-log settings
    pub allow_log_config: bool,
}

impl Default for XlinxUsetPermission {
    fn default() -> Self {
        Self {
            allow_cache_change: true,
            allow_raster_change: true,
            allow_arch_change: false, // arch change is system-level
            allow_sw_fallback: true,
            allow_log_config: true,
        }
    }
}

/// Xlinx auto-log configuration
#[derive(Debug, Clone, PartialEq)]
pub struct XlinxAutoLog {
    /// Enable automatic logging of Xlinx events
    pub enabled: bool,
    /// Log level: 0=off, 1=errors, 2=warnings, 3=info, 4=debug, 5=trace
    pub level: u8,
    /// Log output path (None = stderr)
    pub output_path: Option<String>,
    /// Log frame timing
    pub log_frame_timing: bool,
    /// Log cache hit/miss ratio
    pub log_cache_stats: bool,
    /// Log raster operations
    pub log_raster_ops: bool,
}

impl Default for XlinxAutoLog {
    fn default() -> Self {
        Self {
            enabled: false,
            level: 2,
            output_path: None,
            log_frame_timing: false,
            log_cache_stats: false,
            log_raster_ops: false,
        }
    }
}

/// Xlinx software rasterization fallback
/// Used when hardware rasterization is unavailable or for unsupported archs
#[derive(Debug, Clone, PartialEq)]
pub struct XlinxSoftFallback {
    /// Enable software fallback
    pub enabled: bool,
    /// Number of software rasterizer threads
    pub thread_count: u8,
    /// Tile size for parallel software rasterization
    pub tile_width: u32,
    pub tile_height: u32,
    /// Enable MSAA in software mode
    pub software_msaa: bool,
    /// MSAA sample count (1, 2, 4, 8)
    pub msaa_samples: u8,
}

impl Default for XlinxSoftFallback {
    fn default() -> Self {
        Self {
            enabled: true,
            thread_count: 4,
            tile_width: 64,
            tile_height: 64,
            software_msaa: false,
            msaa_samples: 1,
        }
    }
}

/// Xlinx options group
#[derive(Debug, Clone)]
pub struct XlinxOpt {
    pub cache_mode: XlinxCacheMode,
    pub raster_mode: RasterMode,
    pub arch: XlinxArch,
    pub soft_fallback: XlinxSoftFallback,
    pub auto_log: XlinxAutoLog,
    pub uset_permission: XlinxUsetPermission,
    /// Hardware rasterization support flag
    /// Automatically set based on arch + driver availability
    pub hw_raster_supported: bool,
    /// Xlinx pipeline version (internal)
    pub pipeline_version: u8,
}

impl Default for XlinxOpt {
    fn default() -> Self {
        let arch = XlinxArch::auto_detect();
        let hw_supported = !matches!(arch, XlinxArch::SoftwareOnly | XlinxArch::Generic);
        Self {
            cache_mode: XlinxCacheMode::Auto,
            raster_mode: RasterMode::Auto,
            arch,
            soft_fallback: XlinxSoftFallback::default(),
            auto_log: XlinxAutoLog::default(),
            uset_permission: XlinxUsetPermission::default(),
            hw_raster_supported: hw_supported,
            pipeline_version: 1,
        }
    }
}

impl XlinxOpt {
    /// Effective raster mode — resolves Auto to concrete mode
    pub fn effective_raster_mode(&self) -> RasterMode {
        match self.raster_mode {
            RasterMode::Auto => {
                if self.hw_raster_supported {
                    RasterMode::Hardware
                } else {
                    RasterMode::Software
                }
            }
            other => other,
        }
    }

    /// Is debug rasterization active?
    /// NOTE: only meaningful in debug builds
    pub fn is_debug_raster(&self) -> bool {
        cfg!(debug_assertions) && matches!(self.raster_mode, RasterMode::Debug)
    }

    /// Apply USET permission check before a change
    pub fn check_uset(&self, change: &str) -> Result<(), String> {
        match change {
            "cache" if !self.uset_permission.allow_cache_change => {
                Err("USET: cache change not permitted".to_string())
            }
            "raster" if !self.uset_permission.allow_raster_change => {
                Err("USET: raster mode change not permitted".to_string())
            }
            "arch" if !self.uset_permission.allow_arch_change => {
                Err("USET: arch change not permitted".to_string())
            }
            "sw_fallback" if !self.uset_permission.allow_sw_fallback => {
                Err("USET: software fallback change not permitted".to_string())
            }
            "log" if !self.uset_permission.allow_log_config => {
                Err("USET: log config change not permitted".to_string())
            }
            _ => Ok(()),
        }
    }
}

// ============================================================================
// BACKEND OPT — X11 / Wayland / Xwayland selection
// ============================================================================

/// Display backend selection
#[derive(Debug, Clone, PartialEq)]
pub enum DisplayBackend {
    /// X11 / Xorg (XCB-based)
    X11,
    /// Wayland (native surfacing)
    Wayland,
    /// XWayland — X11 over Wayland (debug only)
    /// WARNING: only use when X11 backend or X11 is active
    XWayland,
    /// Auto-detect: prefer Wayland, fallback to X11
    Auto,
    /// Headless (no display, for testing/offscreen)
    Headless,
}

impl DisplayBackend {
    pub fn name(&self) -> &'static str {
        match self {
            Self::X11 => "X11 (Xorg/XCB)",
            Self::Wayland => "Wayland",
            Self::XWayland => "XWayland (X11 over Wayland, debug)",
            Self::Auto => "Auto (Wayland preferred)",
            Self::Headless => "Headless",
        }
    }

    pub fn from_str(s: &str) -> Self {
        match s {
            "x11" | "xorg" | "xcb" => Self::X11,
            "wayland" | "wl" => Self::Wayland,
            "xwayland" => Self::XWayland,
            "headless" => Self::Headless,
            _ => Self::Auto,
        }
    }

    pub fn is_xwayland(&self) -> bool {
        matches!(self, Self::XWayland)
    }
}

/// X11 / Xorg debug and management settings
/// NOTE: These settings are disabled if X11 backend is not active
#[derive(Debug, Clone, PartialEq)]
pub struct X11DebugOpt {
    /// Enable X11 XCB debug output
    pub xcb_debug: bool,
    /// Log X11 protocol events
    pub log_events: bool,
    /// Synchronous mode (slow, for debugging)
    pub sync_mode: bool,
    /// Window border width (debug visual aid)
    pub debug_border_width: u8,
    /// Show window decorations
    pub decorations: bool,
    /// X11 composite manager interaction
    pub use_composite: bool,
    /// Override redirect (bypass WM)
    pub override_redirect: bool,
    /// X11 backing store (NotUseful / WhenMapped / Always)
    pub backing_store: X11BackingStore,
}

#[derive(Debug, Clone, Copy, PartialEq)]
pub enum X11BackingStore {
    NotUseful,
    WhenMapped,
    Always,
}

impl Default for X11DebugOpt {
    fn default() -> Self {
        Self {
            xcb_debug: false,
            log_events: false,
            sync_mode: false,
            debug_border_width: 0,
            decorations: true,
            use_composite: true,
            override_redirect: false,
            backing_store: X11BackingStore::NotUseful,
        }
    }
}

/// Wayland surfacing support options
/// Includes both drawing and window output with all settings
#[derive(Debug, Clone, PartialEq)]
pub struct WaylandSurfaceOpt {
    /// Enable Wayland subsurface support
    pub subsurface_support: bool,
    /// Buffer format preference
    pub preferred_format: PixelColorFormat,
    /// Enable fractional scaling (wl_fractional_scale_v1)
    pub fractional_scale: bool,
    /// Enable xdg-decoration protocol
    pub server_side_decorations: bool,
    /// Enable layer shell (for panels/overlays)
    pub layer_shell: bool,
    /// Enable presentation-time protocol
    pub presentation_time: bool,
    /// Enable explicit synchronization
    pub explicit_sync: bool,
    /// DMA-BUF import support
    pub dmabuf: bool,
    /// Output scale hint (1 = 1x, 2 = HiDPI 2x)
    pub output_scale: u32,
    /// Force use of shared memory (shm) buffers
    pub force_shm: bool,
}

impl Default for WaylandSurfaceOpt {
    fn default() -> Self {
        Self {
            subsurface_support: true,
            preferred_format: PixelColorFormat::Rgba8888,
            fractional_scale: true,
            server_side_decorations: true,
            layer_shell: false,
            presentation_time: true,
            explicit_sync: false,
            dmabuf: true,
            output_scale: 1,
            force_shm: false,
        }
    }
}

/// X11 supported change-to-Wayland (ava x wayland) settings
/// Controls automatic backend switching behavior
#[derive(Debug, Clone, PartialEq)]
pub struct X11ToWaylandOpt {
    /// Enable automatic switch from X11 to Wayland when available
    pub auto_switch: bool,
    /// Minimum Wayland compositor version required to switch
    pub min_compositor_version: u32,
    /// Fallback to X11 if Wayland init fails
    pub fallback_to_x11: bool,
    /// Prefer XWayland for specific app IDs
    pub xwayland_app_ids: Vec<String>,
}

impl Default for X11ToWaylandOpt {
    fn default() -> Self {
        Self {
            auto_switch: true,
            min_compositor_version: 1,
            fallback_to_x11: true,
            xwayland_app_ids: Vec::new(),
        }
    }
}

/// Backend options group
#[derive(Debug, Clone)]
pub struct BackendOpt {
    pub backend: DisplayBackend,
    pub x11: X11DebugOpt,
    pub wayland: WaylandSurfaceOpt,
    pub x11_to_wayland: X11ToWaylandOpt,
    /// Whether X11 is currently active (affects x11/xwayland settings)
    pub x11_active: bool,
    /// Whether Wayland compositor is available
    pub wayland_available: bool,
}

impl Default for BackendOpt {
    fn default() -> Self {
        // Auto-detect: check WAYLAND_DISPLAY env var
        let wayland_available = std::env::var("WAYLAND_DISPLAY").is_ok();
        let x11_active = std::env::var("DISPLAY").is_ok();

        Self {
            backend: DisplayBackend::Auto,
            x11: X11DebugOpt::default(),
            wayland: WaylandSurfaceOpt::default(),
            x11_to_wayland: X11ToWaylandOpt::default(),
            x11_active,
            wayland_available,
        }
    }
}

impl BackendOpt {
    /// Resolve effective backend — Auto → concrete selection
    pub fn effective_backend(&self) -> DisplayBackend {
        match &self.backend {
            DisplayBackend::Auto => {
                if self.wayland_available {
                    DisplayBackend::Wayland
                } else if self.x11_active {
                    DisplayBackend::X11
                } else {
                    DisplayBackend::Headless
                }
            }
            other => other.clone(),
        }
    }

    /// Are X11 settings active?
    /// NOTE: if X11 backend or X11 is not active, X11 settings are disabled
    pub fn x11_settings_active(&self) -> bool {
        self.x11_active
            && matches!(
                self.effective_backend(),
                DisplayBackend::X11 | DisplayBackend::XWayland
            )
    }

    /// Are Wayland settings active?
    pub fn wayland_settings_active(&self) -> bool {
        self.wayland_available
            && matches!(
                self.effective_backend(),
                DisplayBackend::Wayland | DisplayBackend::XWayland
            )
    }

    /// Validate XWayland usage
    /// XWayland is only valid when X11 backend or X11 is active
    pub fn validate_xwayland(&self) -> Result<(), String> {
        if matches!(self.backend, DisplayBackend::XWayland) {
            if !self.x11_active {
                return Err(
                    "XWayland requires X11 backend to be active (DISPLAY not set)".to_string(),
                );
            }
        }
        Ok(())
    }
}

// ============================================================================
// POSIX OPT — Master configuration struct
// ============================================================================

/// PosixOpt — master optionalty configuration
/// Combines all option groups with runtime override support
#[derive(Debug, Clone)]
pub struct PosixOpt {
    pub draw: DrawOpt,
    pub pixel: PixelOpt,
    pub xlinx: XlinxOpt,
    pub backend: BackendOpt,
    /// Config source label (for diagnostics)
    pub source: String,
}

impl Default for PosixOpt {
    fn default() -> Self {
        Self {
            draw: DrawOpt::default(),
            pixel: PixelOpt::default(),
            xlinx: XlinxOpt::default(),
            backend: BackendOpt::default(),
            source: "default".to_string(),
        }
    }
}

impl PosixOpt {
    /// Parse from WasmaConfig (config file values)
    pub fn from_config(config: &WasmaConfig) -> Self {
        let mut opt = Self::default();
        opt.source = "wasma.in.conf".to_string();

        // Derive draw size from config
        opt.draw.size.default_width = 800;
        opt.draw.size.default_height = 600;

        // Scope level → xlinx arch selection
        opt.xlinx.arch = XlinxArch::auto_detect();

        // Renderer → raster mode
        opt.xlinx.raster_mode = match config.resource_limits.renderer.as_str() {
            "glx_renderer" | "opencl" | "renderer_opencl" => RasterMode::Hardware,
            "cpu_renderer" | "cpu" => RasterMode::Software,
            _ => RasterMode::Auto,
        };

        // scope_level == 0 → no cache (NULL_EXCEPTION mode)
        if config.resource_limits.scope_level == 0 {
            opt.xlinx.cache_mode = XlinxCacheMode::NoCache;
        }

        // execution_mode → toolkit hint
        opt.draw.toolkit = ToolkitTheme::Iced(IcedThemeOpt::default());

        // Backend: singularity → headless hint
        if config.uri_handling.singularity_instances {
            opt.draw.vsync = true;
        }

        opt
    }

    /// Validate all option groups
    pub fn validate(&self) -> Result<(), Vec<String>> {
        let mut errors = Vec::new();

        // Validate XWayland
        if let Err(e) = self.backend.validate_xwayland() {
            errors.push(e);
        }

        // Debug raster only in debug builds
        if matches!(self.xlinx.raster_mode, RasterMode::Debug) {
            #[cfg(not(debug_assertions))]
            errors.push("RasterMode::Debug is only allowed in debug builds".to_string());
        }

        // MSAA samples must be power of 2
        let s = self.xlinx.soft_fallback.msaa_samples;
        if s != 1 && s != 2 && s != 4 && s != 8 {
            errors.push(format!(
                "Invalid MSAA samples: {} (must be 1, 2, 4, or 8)",
                s
            ));
        }

        // Draw size sanity
        if self.draw.size.min_width > self.draw.size.default_width {
            errors.push("min_width > default_width".to_string());
        }
        if self.draw.size.min_height > self.draw.size.default_height {
            errors.push("min_height > default_height".to_string());
        }

        // Gamma range
        if self.pixel.gamma < 0.1 || self.pixel.gamma > 10.0 {
            errors.push(format!(
                "Gamma out of range: {} (expected 0.1–10.0)",
                self.pixel.gamma
            ));
        }

        if errors.is_empty() {
            Ok(())
        } else {
            Err(errors)
        }
    }

    /// Print diagnostic summary
    pub fn print_summary(&self) {
        println!("╔═══════════════════════════════════════════════════════════╗");
        println!("║              WASMA PosixOpt Summary                       ║");
        println!("╚═══════════════════════════════════════════════════════════╝");
        println!("Source: {}", self.source);
        println!("\n[DrawOpt]");
        println!("  Toolkit:     {}", self.draw.toolkit.name());
        println!(
            "  Size:        {}x{} (min {}x{})",
            self.draw.size.default_width,
            self.draw.size.default_height,
            self.draw.size.min_width,
            self.draw.size.min_height
        );
        println!(
            "  Antialiasing: {} | VSync: {} | FPS: {:?}",
            self.draw.antialiasing, self.draw.vsync, self.draw.target_fps
        );
        println!("\n[PixelOpt]");
        println!(
            "  Color format: {} ({} bpp)",
            self.pixel.color_format.name(),
            self.pixel.color_format.bytes_per_pixel()
        );
        println!(
            "  Gamma: {} | Pixel-perfect: {}",
            self.pixel.gamma, self.pixel.pixel_perfect
        );
        println!(
            "  Grid (screen-dep): visible={} snap={}",
            self.pixel.grid_screen_dep.visible, self.pixel.grid_screen_dep.snap_to_grid
        );
        println!(
            "  Grid (screen-indep): visible={} cell={}lpx",
            self.pixel.grid_screen_indep.visible, self.pixel.grid_screen_indep.cell_size_logical
        );
        println!("\n[XlinxOpt]");
        println!("  Arch:         {}", self.xlinx.arch.name());
        println!("  Cache:        {}", self.xlinx.cache_mode.name());
        println!(
            "  Raster:       {} (effective: {})",
            self.xlinx.raster_mode.name(),
            self.xlinx.effective_raster_mode().name()
        );
        println!("  HW raster:    {}", self.xlinx.hw_raster_supported);
        println!(
            "  SW fallback:  {} ({} threads, {}x{} tiles)",
            self.xlinx.soft_fallback.enabled,
            self.xlinx.soft_fallback.thread_count,
            self.xlinx.soft_fallback.tile_width,
            self.xlinx.soft_fallback.tile_height
        );
        println!(
            "  Auto-log:     {} (level {})",
            self.xlinx.auto_log.enabled, self.xlinx.auto_log.level
        );
        println!("\n[BackendOpt]");
        println!(
            "  Backend:      {} → effective: {}",
            self.backend.backend.name(),
            self.backend.effective_backend().name()
        );
        println!(
            "  X11 active:      {} | Wayland available: {}",
            self.backend.x11_active, self.backend.wayland_available
        );
        println!("  X11 settings:    {}", self.backend.x11_settings_active());
        println!(
            "  Wayland surface: {}",
            self.backend.wayland_settings_active()
        );
        println!(
            "  DMA-BUF:      {} | Frac.scale: {}",
            self.backend.wayland.dmabuf, self.backend.wayland.fractional_scale
        );
    }
}

// ============================================================================
// RUNTIME OPT STORE — Thread-safe runtime override
// ============================================================================

/// Thread-safe runtime option store
/// Wraps PosixOpt in RwLock for concurrent read / exclusive write
pub struct RuntimeOptStore {
    inner: Arc<RwLock<PosixOpt>>,
}

impl RuntimeOptStore {
    pub fn new(base: PosixOpt) -> Self {
        Self {
            inner: Arc::new(RwLock::new(base)),
        }
    }

    /// Read current options (shared, non-blocking)
    pub fn read(&self) -> std::sync::RwLockReadGuard<'_, PosixOpt> {
        self.inner.read().unwrap()
    }

    /// Apply a runtime override via closure
    pub fn override_with<F>(&self, f: F)
    where
        F: FnOnce(&mut PosixOpt),
    {
        let mut opt = self.inner.write().unwrap();
        f(&mut opt);
        opt.source = format!("{} + runtime", opt.source);
    }

    /// Override toolkit theme at runtime
    pub fn set_toolkit(&self, toolkit: ToolkitTheme) {
        self.override_with(|o| o.draw.toolkit = toolkit);
    }

    /// Override display backend at runtime
    pub fn set_backend(&self, backend: DisplayBackend) {
        self.override_with(|o| o.backend.backend = backend);
    }

    /// Override xlinx cache mode at runtime (USET checked)
    pub fn set_cache_mode(&self, mode: XlinxCacheMode) -> Result<(), String> {
        let check = self.read().xlinx.check_uset("cache")?;
        let _ = check;
        self.override_with(|o| o.xlinx.cache_mode = mode);
        Ok(())
    }

    /// Override raster mode at runtime (USET checked)
    pub fn set_raster_mode(&self, mode: RasterMode) -> Result<(), String> {
        // Block Debug mode in production builds
        #[cfg(not(debug_assertions))]
        if matches!(mode, RasterMode::Debug) {
            return Err("RasterMode::Debug not allowed in release builds".to_string());
        }
        self.read().xlinx.check_uset("raster")?;
        self.override_with(|o| o.xlinx.raster_mode = mode);
        Ok(())
    }

    /// Override color format at runtime
    pub fn set_color_format(&self, fmt: PixelColorFormat) {
        self.override_with(|o| o.pixel.color_format = fmt);
    }

    /// Enable/disable screen-dep grid
    pub fn set_screen_dep_grid(&self, visible: bool) {
        self.override_with(|o| o.pixel.grid_screen_dep.visible = visible);
    }

    /// Enable/disable screen-indep grid
    pub fn set_screen_indep_grid(&self, visible: bool) {
        self.override_with(|o| o.pixel.grid_screen_indep.visible = visible);
    }

    /// Enable/disable auto-log
    pub fn set_auto_log(&self, enabled: bool, level: u8) -> Result<(), String> {
        self.read().xlinx.check_uset("log")?;
        self.override_with(|o| {
            o.xlinx.auto_log.enabled = enabled;
            o.xlinx.auto_log.level = level;
        });
        Ok(())
    }

    pub fn clone_store(&self) -> Self {
        Self {
            inner: self.inner.clone(),
        }
    }
}

// ============================================================================
// POSIX OPT BUILDER — Chainable builder pattern
// ============================================================================

pub struct PosixOptBuilder {
    opt: PosixOpt,
}

impl PosixOptBuilder {
    pub fn new() -> Self {
        Self {
            opt: PosixOpt::default(),
        }
    }

    pub fn from_config(config: &WasmaConfig) -> Self {
        Self {
            opt: PosixOpt::from_config(config),
        }
    }

    // ---- DrawOpt ----

    pub fn toolkit(mut self, toolkit: ToolkitTheme) -> Self {
        self.opt.draw.toolkit = toolkit;
        self
    }

    pub fn default_size(mut self, width: u32, height: u32) -> Self {
        self.opt.draw.size.default_width = width;
        self.opt.draw.size.default_height = height;
        self
    }

    pub fn min_size(mut self, width: u32, height: u32) -> Self {
        self.opt.draw.size.min_width = width;
        self.opt.draw.size.min_height = height;
        self
    }

    pub fn max_size(mut self, width: u32, height: u32) -> Self {
        self.opt.draw.size.max_width = Some(width);
        self.opt.draw.size.max_height = Some(height);
        self
    }

    pub fn aspect_ratio(mut self, ratio: f32) -> Self {
        self.opt.draw.size.aspect_ratio = Some(ratio);
        self
    }

    pub fn antialiasing(mut self, enabled: bool) -> Self {
        self.opt.draw.antialiasing = enabled;
        self
    }

    pub fn vsync(mut self, enabled: bool) -> Self {
        self.opt.draw.vsync = enabled;
        self
    }

    pub fn target_fps(mut self, fps: u32) -> Self {
        self.opt.draw.target_fps = Some(fps);
        self
    }

    // ---- PixelOpt ----

    pub fn color_format(mut self, fmt: PixelColorFormat) -> Self {
        self.opt.pixel.color_format = fmt;
        self
    }

    pub fn background_color(mut self, rgba: [u8; 4]) -> Self {
        self.opt.pixel.background_color = rgba;
        self
    }

    pub fn gamma(mut self, gamma: f32) -> Self {
        self.opt.pixel.gamma = gamma;
        self
    }

    pub fn pixel_perfect(mut self, enabled: bool) -> Self {
        self.opt.pixel.pixel_perfect = enabled;
        self
    }

    pub fn screen_dep_grid(mut self, visible: bool, snap: bool) -> Self {
        self.opt.pixel.grid_screen_dep.visible = visible;
        self.opt.pixel.grid_screen_dep.snap_to_grid = snap;
        self
    }

    pub fn screen_indep_grid(mut self, visible: bool, cell_size: f32) -> Self {
        self.opt.pixel.grid_screen_indep.visible = visible;
        self.opt.pixel.grid_screen_indep.cell_size_logical = cell_size;
        self
    }

    // ---- XlinxOpt ----

    pub fn xlinx_cache(mut self, mode: XlinxCacheMode) -> Self {
        self.opt.xlinx.cache_mode = mode;
        self
    }

    pub fn xlinx_raster(mut self, mode: RasterMode) -> Self {
        self.opt.xlinx.raster_mode = mode;
        self
    }

    pub fn xlinx_arch(mut self, arch: XlinxArch) -> Self {
        self.opt.xlinx.arch = arch;
        self.opt.xlinx.hw_raster_supported =
            !matches!(arch, XlinxArch::SoftwareOnly | XlinxArch::Generic);
        self
    }

    pub fn xlinx_soft_fallback(mut self, enabled: bool, threads: u8) -> Self {
        self.opt.xlinx.soft_fallback.enabled = enabled;
        self.opt.xlinx.soft_fallback.thread_count = threads;
        self
    }

    pub fn xlinx_auto_log(mut self, enabled: bool, level: u8) -> Self {
        self.opt.xlinx.auto_log.enabled = enabled;
        self.opt.xlinx.auto_log.level = level;
        self
    }

    pub fn xlinx_uset(mut self, perm: XlinxUsetPermission) -> Self {
        self.opt.xlinx.uset_permission = perm;
        self
    }

    // ---- BackendOpt ----

    pub fn backend(mut self, backend: DisplayBackend) -> Self {
        self.opt.backend.backend = backend;
        self
    }

    pub fn x11_debug(mut self, xcb_debug: bool, sync_mode: bool) -> Self {
        self.opt.backend.x11.xcb_debug = xcb_debug;
        self.opt.backend.x11.sync_mode = sync_mode;
        self
    }

    pub fn wayland_surface(mut self, dmabuf: bool, frac_scale: bool) -> Self {
        self.opt.backend.wayland.dmabuf = dmabuf;
        self.opt.backend.wayland.fractional_scale = frac_scale;
        self
    }

    pub fn x11_to_wayland(mut self, auto_switch: bool, fallback: bool) -> Self {
        self.opt.backend.x11_to_wayland.auto_switch = auto_switch;
        self.opt.backend.x11_to_wayland.fallback_to_x11 = fallback;
        self
    }

    /// Build and validate
    pub fn build(self) -> Result<PosixOpt, Vec<String>> {
        self.opt.validate()?;
        Ok(self.opt)
    }

    /// Build without validation
    pub fn build_unchecked(self) -> PosixOpt {
        self.opt
    }
}

impl Default for PosixOptBuilder {
    fn default() -> Self {
        Self::new()
    }
}

// ============================================================================
// TESTS
// ============================================================================

#[cfg(test)]
mod tests {
    use super::*;
    use crate::parser::ConfigParser;

    fn make_config() -> WasmaConfig {
        let parser = ConfigParser::new(None);
        let content = parser.generate_default_config();
        parser.parse(&content).unwrap()
    }

    #[test]
    fn test_default_posix_opt() {
        let opt = PosixOpt::default();
        assert!(opt.validate().is_ok());
        println!("✅ Default PosixOpt valid");
    }

    #[test]
    fn test_from_config() {
        let config = make_config();
        let opt = PosixOpt::from_config(&config);
        assert_eq!(opt.source, "wasma.in.conf");
        assert!(opt.validate().is_ok());
        println!(
            "✅ PosixOpt::from_config working, raster: {}",
            opt.xlinx.raster_mode.name()
        );
    }

    #[test]
    fn test_builder_basic() {
        let opt = PosixOptBuilder::new()
            .default_size(1920, 1080)
            .min_size(320, 240)
            .antialiasing(true)
            .vsync(false)
            .color_format(PixelColorFormat::Rgba8888)
            .gamma(2.2)
            .xlinx_cache(XlinxCacheMode::Auto)
            .xlinx_raster(RasterMode::Hardware)
            .backend(DisplayBackend::Wayland)
            .build()
            .unwrap();

        assert_eq!(opt.draw.size.default_width, 1920);
        assert_eq!(opt.draw.size.default_height, 1080);
        assert!(!opt.draw.vsync);
        assert_eq!(opt.pixel.color_format, PixelColorFormat::Rgba8888);
        assert!((opt.pixel.gamma - 2.2).abs() < f32::EPSILON);
        println!("✅ Builder basic working");
    }

    #[test]
    fn test_builder_from_config() {
        let config = make_config();
        let opt = PosixOptBuilder::from_config(&config)
            .toolkit(ToolkitTheme::Gtk(GtkThemeOpt::default()))
            .target_fps(60)
            .build_unchecked();

        assert_eq!(opt.draw.target_fps, Some(60));
        assert!(matches!(opt.draw.toolkit, ToolkitTheme::Gtk(_)));
        println!("✅ Builder from_config + override working");
    }

    #[test]
    fn test_xlinx_effective_raster() {
        let mut xlinx = XlinxOpt::default();
        xlinx.raster_mode = RasterMode::Auto;
        xlinx.hw_raster_supported = true;
        assert_eq!(xlinx.effective_raster_mode(), RasterMode::Hardware);

        xlinx.hw_raster_supported = false;
        assert_eq!(xlinx.effective_raster_mode(), RasterMode::Software);
        println!("✅ XlinxOpt::effective_raster_mode working");
    }

    #[test]
    fn test_xlinx_uset_permission() {
        let mut xlinx = XlinxOpt::default();
        xlinx.uset_permission.allow_cache_change = false;

        assert!(xlinx.check_uset("cache").is_err());
        assert!(xlinx.check_uset("raster").is_ok());
        println!("✅ USET permission check working");
    }

    #[test]
    fn test_backend_effective() {
        let mut backend = BackendOpt::default();
        backend.backend = DisplayBackend::Auto;
        backend.wayland_available = true;
        assert_eq!(backend.effective_backend(), DisplayBackend::Wayland);

        backend.wayland_available = false;
        backend.x11_active = true;
        assert_eq!(backend.effective_backend(), DisplayBackend::X11);

        backend.x11_active = false;
        assert_eq!(backend.effective_backend(), DisplayBackend::Headless);
        println!("✅ BackendOpt::effective_backend working");
    }

    #[test]
    fn test_xwayland_validation() {
        let mut backend = BackendOpt::default();
        backend.backend = DisplayBackend::XWayland;
        backend.x11_active = false;
        assert!(backend.validate_xwayland().is_err());

        backend.x11_active = true;
        assert!(backend.validate_xwayland().is_ok());
        println!("✅ XWayland validation working");
    }

    #[test]
    fn test_x11_settings_active_flag() {
        let mut backend = BackendOpt::default();
        backend.backend = DisplayBackend::X11;
        backend.x11_active = true;
        backend.wayland_available = false;
        assert!(backend.x11_settings_active());

        backend.backend = DisplayBackend::Wayland;
        assert!(!backend.x11_settings_active());
        println!("✅ X11 settings active flag working");
    }

    #[test]
    fn test_runtime_opt_store() {
        let opt = PosixOpt::default();
        let store = RuntimeOptStore::new(opt);

        store.set_toolkit(ToolkitTheme::Qt(QtThemeOpt::default()));
        assert!(matches!(store.read().draw.toolkit, ToolkitTheme::Qt(_)));

        store.set_color_format(PixelColorFormat::Rgb565);
        assert_eq!(store.read().pixel.color_format, PixelColorFormat::Rgb565);

        store.set_cache_mode(XlinxCacheMode::Aggressive).unwrap();
        assert_eq!(store.read().xlinx.cache_mode, XlinxCacheMode::Aggressive);

        assert!(store.read().source.contains("runtime"));
        println!("✅ RuntimeOptStore working");
    }

    #[test]
    fn test_runtime_uset_block() {
        let opt = PosixOptBuilder::new()
            .xlinx_uset(XlinxUsetPermission {
                allow_cache_change: false,
                ..XlinxUsetPermission::default()
            })
            .build_unchecked();

        let store = RuntimeOptStore::new(opt);
        let result = store.set_cache_mode(XlinxCacheMode::NoCache);
        assert!(result.is_err());
        println!("✅ USET runtime block working");
    }

    #[test]
    fn test_pixel_color_format_bpp() {
        assert_eq!(PixelColorFormat::Rgba8888.bytes_per_pixel(), 4);
        assert_eq!(PixelColorFormat::Rgb565.bytes_per_pixel(), 2);
        assert_eq!(PixelColorFormat::Rgba16Float.bytes_per_pixel(), 8);
        assert_eq!(PixelColorFormat::Luma8.bytes_per_pixel(), 1);
        println!("✅ PixelColorFormat bytes_per_pixel working");
    }

    #[test]
    fn test_validation_failures() {
        let result = PosixOptBuilder::new()
            .min_size(1000, 1000) // min > default (800x600)
            .gamma(0.0) // gamma out of range
            .build();

        assert!(result.is_err());
        let errors = result.unwrap_err();
        assert!(errors.len() >= 2);
        println!("✅ Validation correctly caught {} errors", errors.len());
    }

    #[test]
    fn test_xlinx_arch_auto_detect() {
        let arch = XlinxArch::auto_detect();
        println!("✅ XlinxArch auto-detected: {}", arch.name());
        // Should never panic
        assert!(arch.name().len() > 0);
    }

    #[test]
    fn test_grid_options() {
        let opt = PosixOptBuilder::new()
            .screen_dep_grid(true, true)
            .screen_indep_grid(true, 32.0)
            .build_unchecked();

        assert!(opt.pixel.grid_screen_dep.visible);
        assert!(opt.pixel.grid_screen_dep.snap_to_grid);
        assert!(opt.pixel.grid_screen_indep.visible);
        assert!((opt.pixel.grid_screen_indep.cell_size_logical - 32.0).abs() < f32::EPSILON);
        println!("✅ Grid options working");
    }

    #[test]
    fn test_print_summary() {
        let opt = PosixOpt::default();
        opt.print_summary();
        println!("✅ PosixOpt::print_summary working");
    }
}