use std::collections::{HashMap, HashSet};
use std::error::Error;
use std::io;
use std::os::fd::AsFd;
use std::path::Path;
use std::time::{Duration, Instant};

pub(crate) mod capture;
mod context;
mod crtc_assignment;
mod diagnostics;
pub(crate) mod feedback;
pub(crate) mod gamma;
mod lid;
mod mirror;
mod output_power;
mod planes;
mod recovery;
mod redraw;
mod scheduling;
mod session_device;
mod topology;
mod transaction;
use diagnostics::{Diagnostics, PrimaryOutcome};
use output_power::{OutputPower, Power};
use redraw::{AnimationFallback, SchedulingMetrics};
use scheduling::{cancel_output_timers, monotonic_now, request_frame, arm_frame, record_frame_schedule};
use smithay::backend::allocator::gbm::{GbmAllocator, GbmBufferFlags, GbmDevice};
use smithay::backend::allocator::{Buffer, Fourcc};
use smithay::backend::drm::compositor::{DrmCompositor, FrameFlags, PrimaryPlaneElement};
use smithay::backend::drm::exporter::gbm::GbmFramebufferExporter;
use smithay::backend::drm::{DrmDevice, DrmDeviceFd, DrmEvent, DrmEventTime, DrmNode, NodeType};
use smithay::backend::egl::EGLDisplay;
use smithay::backend::input::InputEvent;
use smithay::backend::libinput::{LibinputInputBackend, LibinputSessionInterface};
use smithay::backend::renderer::element::{RenderElement, UnderlyingStorage};
use smithay::backend::renderer::gles::{GlesRenderer, GlesTexture};
use smithay::backend::renderer::utils::CommitCounter;
use smithay::backend::renderer::{ImportDma, ImportMemWl, Renderer};
use smithay::backend::session::libseat::LibSeatSession;
use smithay::backend::session::{Event as SessionEvent, Session};
use smithay::backend::udev::{UdevBackend, UdevEvent, all_gpus, primary_gpu};
use smithay::desktop::layer_map_for_output;
use smithay::desktop::utils::OutputPresentationFeedback;
use smithay::output::{Mode as OutputMode, Output, OutputModeSource, PhysicalProperties, Scale, Subpixel};
use smithay::reexports::calloop::timer::{TimeoutAction, Timer};
use smithay::reexports::calloop::{EventLoop, RegistrationToken};
use smithay::reexports::drm::control::{
    Device as ControlDevice, Mode as DrmMode, ModeTypeFlags, connector, crtc, property,
};
use smithay::reexports::input::{Device as LibinputDevice, Libinput};
use smithay::reexports::wayland_protocols::wp::presentation_time::server::wp_presentation_feedback::Kind;
use smithay::reexports::wayland_server::backend::GlobalId;
use smithay::utils::{Monotonic, Time, Transform};
use smithay::wayland::dmabuf::DmabufFeedbackBuilder;
use smithay::wayland::presentation::Refresh;
use topology::{Topology, reconcile_outputs};

use crate::Ferese;
use crate::config::{OutputModeRequest, OutputProfile, OutputSettings, OutputTransform};
use crate::metrics::RenderMetrics;
use crate::monitor_identity::{Identity, IdentityRegistry};
use crate::output_policy::{DesiredOutputConfiguration, ManualOverride, Monitor};
use crate::render::{frame_effect_metrics, sampled_output_elements};

pub struct DirectBackendState {
    pub session: LibSeatSession,
    pub active: bool,
    lid: lid::LidState,
    lid_reader: lid::Reader,
    topology: Topology,
    identities: IdentityRegistry,
    pub(crate) manual_outputs: ManualOverride,
    desired_outputs: DesiredOutputConfiguration,
    monitors: Vec<Monitor>,
    output_error: Option<String>,
    applied_outputs: DesiredOutputConfiguration,
    revert_outputs: Option<DesiredOutputConfiguration>,
    confirmation: Option<(DesiredOutputConfiguration, ManualOverride)>,
    confirmation_timer: Option<RegistrationToken>,
    confirmation_lid: bool,
    pub(crate) low_power: bool,
    devices: HashMap<DrmNode, DirectDevice>,
    input_devices: Vec<LibinputDevice>,
    presentation: HashMap<(DrmNode, crtc::Handle), PresentationClock>,
    pub(crate) connected_outputs: Vec<ConnectedOutputInfo>,
    battery_timer: Option<RegistrationToken>,
    power_retry: Option<RegistrationToken>,
    animation_timer: Option<RegistrationToken>,
    animation_deadline: Option<Instant>,
    scheduling_metrics: SchedulingMetrics,
}

impl DirectBackendState {
    pub(crate) fn physical_outputs(&self) -> impl Iterator<Item = &Output> {
        self.devices
            .values()
            .flat_map(|device| device.outputs.values().map(|output| &output.output))
    }

    pub(crate) fn output_configuration_error(&self) -> Option<&str> {
        self.output_error.as_deref()
    }

    pub(crate) fn confirmation_pending(&self) -> bool {
        self.confirmation.is_some()
    }

    pub(crate) fn reconciling(&self) -> bool {
        self.topology.reconciling
    }

    fn can_render(&self) -> bool {
        self.active && !self.topology.reconciling && !self.lid.pending()
    }

    pub(crate) fn process_dmabuf_imports(
        &mut self,
        imports: &mut crate::dmabuf_imports::ImportManager,
    ) {
        if !self.active || self.topology.reconciling {
            return;
        }

        for device in self
            .devices
            .values_mut()
            .filter(|device| device.drm.is_active())
        {
            imports.process(
                device.dmabuf_global,
                &mut device.renderer,
                Some(device.render_node),
            );
        }
    }

    pub(crate) fn scene_output(&self, state: &Ferese, output: &Output) -> Output {
        let source = self
            .devices
            .values()
            .flat_map(|device| device.outputs.values())
            .find(|candidate| &candidate.output == output)
            .and_then(|candidate| candidate.mirror_source.as_ref());
        source
            .and_then(|key| self.monitors.iter().find(|monitor| &monitor.key == key))
            .and_then(|monitor| state.output_by_identity(&monitor.identity))
            .cloned()
            .unwrap_or_else(|| output.clone())
    }

    pub(crate) fn dump_scheduling_metrics(&self) {
        self.scheduling_metrics.dump();
    }

    pub(crate) fn capture_resize_snapshot(
        &mut self,
        window: &smithay::desktop::Window,
        geometry: smithay::utils::Rectangle<i32, smithay::utils::Logical>,
        output: &Output,
        remaining: usize,
    ) -> Result<Option<crate::render::ResizeSnapshot>, smithay::backend::renderer::gles::GlesError>
    {
        let Some(device) = self.devices.values_mut().find(|device| {
            device
                .outputs
                .values()
                .any(|candidate| &candidate.output == output)
        }) else {
            return Ok(None);
        };
        crate::render::capture_resize_snapshot(
            &mut device.renderer,
            window,
            geometry,
            output.current_scale().fractional_scale(),
            remaining,
        )
    }

    pub(crate) fn clear_stream_capture_targets(&mut self) {
        for device in self.devices.values_mut() {
            crate::render::clear_stream_capture_targets(&mut device.renderer);
        }
    }

    pub(crate) fn capture_renderer(&mut self, output: &Output) -> Option<&mut GlesRenderer> {
        self.devices
            .values_mut()
            .find(|device| {
                device
                    .outputs
                    .values()
                    .any(|candidate| &candidate.output == output)
            })
            .map(|device| &mut device.renderer)
    }

    pub(crate) fn capture_window_buffer(
        &mut self,
        window: &smithay::desktop::Window,
        geometry: smithay::utils::Rectangle<i32, smithay::utils::Logical>,
        output: &Output,
    ) -> Result<crate::handlers::screenshot::CaptureBuffer, String> {
        let device = self
            .devices
            .values_mut()
            .find(|device| {
                device
                    .outputs
                    .values()
                    .any(|candidate| &candidate.output == output)
            })
            .ok_or("Window output is unavailable")?;
        crate::render::capture_window_buffer(
            &mut device.renderer,
            window,
            geometry,
            output.current_scale().fractional_scale(),
        )
    }
    pub(crate) fn capture_window_frame(
        &mut self,
        state: &Ferese,
        window: &smithay::desktop::Window,
        output: &Output,
        cursor: Option<smithay::utils::Rectangle<i32, smithay::utils::Logical>>,
        scale: f64,
    ) -> Result<crate::handlers::screenshot::CaptureBuffer, String> {
        let device = self
            .devices
            .values_mut()
            .find(|device| {
                device
                    .outputs
                    .values()
                    .any(|candidate| &candidate.output == output)
            })
            .ok_or("Window output is unavailable")?;
        crate::render::capture_window_frame(
            &mut device.renderer,
            window,
            window.geometry(),
            scale,
            cursor.map(|rect| (state, rect)),
        )
    }
}

#[derive(Clone, Debug, PartialEq)]
pub(crate) struct ConnectedOutputInfo {
    pub connector: String,
    pub connected: bool,
    pub identity: String,
    pub internal: bool,
    pub requested_enabled: bool,
    pub mirror_source: Option<String>,
    pub enabled: bool,
    pub profile: Option<String>,
    pub requested_profile: Option<String>,
    pub auto_refresh: bool,
    pub physical_size: Option<(u32, u32)>,
    pub current_mode: Option<ConnectedModeInfo>,
    pub available_modes: Vec<ConnectedModeInfo>,
    pub scale: f64,
    pub transform: OutputTransform,
    pub configured_position: Option<[i32; 2]>,
}

#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub(crate) struct ConnectedModeInfo {
    pub width: u16,
    pub height: u16,
    pub refresh_millihertz: i32,
    pub preferred: bool,
}

#[derive(Default)]
struct PresentationClock {
    last_presentation: Option<Duration>,
    presented_frames: u64,
    refresh_interval: Option<Duration>,
    missed_deadlines: u64,
}

type OutputCompositor = DrmCompositor<
    GbmAllocator<DrmDeviceFd>,
    GbmFramebufferExporter<DrmDeviceFd>,
    OutputPresentationFeedback,
    DrmDeviceFd,
>;

struct DirectDevice {
    notifier: RegistrationToken,
    dmabuf_global: smithay::wayland::dmabuf::DmabufGlobal,
    connected_outputs: Vec<ConnectedOutputInfo>,
    drm: DrmDevice,
    gbm: GbmDevice<DrmDeviceFd>,
    renderer: GlesRenderer,
    render_node: DrmNode,
    outputs: HashMap<crtc::Handle, DirectOutput>,
    // Last: release libseat's original FD after renderer/DRM resources.
    _session_device: session_device::SessionDevice<LibSeatSession>,
}

struct DirectOutput {
    gamma: gamma::State,
    internal: bool,
    connector: connector::Handle,
    mode: DrmMode,
    settings: OutputSettings,
    output: Output,
    global: Option<GlobalId>,
    identity: String,
    mirror_source: Option<String>,
    mirror_texture: Option<GlesTexture>,
    mirror_capture_texture: [Option<capture::CaptureTarget>; 2],
    mirror_canvas: Option<Output>,
    mirror_id: smithay::backend::renderer::element::Id,
    mirror_commit: CommitCounter,
    surface: OutputCompositor,
    primary_commit: Option<CommitCounter>,
    capture_texture: [Option<capture::CaptureTarget>; 2],
    render_metrics: RenderMetrics,
    diagnostics: Diagnostics,
    dmabuf_feedback: feedback::OutputFeedback,
    frame_pending: bool,
    completion: recovery::Completion,
    completion_timer: Option<RegistrationToken>,
    animation_fallback: AnimationFallback,
    cursor_visible: bool,
    scheduler: crate::frame_scheduler::FrameScheduler,
    render_timer: Option<RegistrationToken>,
    power: OutputPower,
    callback_timer: Option<RegistrationToken>,
    lock_frame_pending: bool,
}

#[derive(Clone)]
struct OutputSelection {
    connector: connector::Info,
    crtc: crtc::Handle,
    mode: DrmMode,
    settings: OutputSettings,
    identity: String,
    mirror_source: Option<String>,
}

struct OutputScan {
    selections: Vec<OutputSelection>,
    connected_outputs: Vec<ConnectedOutputInfo>,
}

pub fn init(event_loop: &mut EventLoop<Ferese>, state: &mut Ferese) -> Result<(), Box<dyn Error>> {
    let (session, notifier) = LibSeatSession::new()?;
    let seat_name = session.seat();
    let udev_backend = UdevBackend::new(&seat_name)?;
    let primary_path = primary_gpu(&seat_name)?
        .or_else(|| {
            udev_backend
                .device_list()
                .next()
                .map(|(_, path)| path.to_owned())
        })
        .ok_or_else(|| io::Error::new(io::ErrorKind::NotFound, "no DRM device found"))?;
    let mut libinput_context =
        Libinput::new_with_udev::<LibinputSessionInterface<LibSeatSession>>(session.clone().into());
    libinput_context
        .udev_assign_seat(&seat_name)
        .map_err(|()| io::Error::other(format!("failed to assign libinput seat {seat_name}")))?;
    let libinput_backend = LibinputInputBackend::new(libinput_context.clone());
    let session_active = session.is_active();
    if !session_active {
        libinput_context.suspend();
    }

    let lid_reader = lid::Reader::start(state)?;
    state.direct_backend = Some(DirectBackendState {
        session,
        active: session_active,
        lid: lid::LidState::default(),
        lid_reader,
        topology: Topology::default(),
        identities: IdentityRegistry::default(),
        manual_outputs: ManualOverride::default(),
        desired_outputs: DesiredOutputConfiguration::default(),
        monitors: Vec::new(),
        output_error: None,
        applied_outputs: DesiredOutputConfiguration::default(),
        revert_outputs: None,
        confirmation: None,
        confirmation_timer: None,
        confirmation_lid: false,
        low_power: super::power::low_power(false, super::power::battery_percent()),
        devices: HashMap::new(),
        input_devices: Vec::new(),
        presentation: HashMap::new(),
        connected_outputs: Vec::new(),
        battery_timer: None,
        power_retry: None,
        animation_timer: None,
        animation_deadline: None,
        scheduling_metrics: SchedulingMetrics::new(),
    });

    state
        .direct_backend
        .as_mut()
        .expect("DRM callbacks require an installed direct backend")
        .topology
        .observe_devices(&[(
            primary_path.clone(),
            topology::device_identity(&primary_path),
        )]);
    lid::request_refresh(state, false);

    event_loop
        .handle()
        .insert_source(libinput_backend, |event, _, state| match event {
            InputEvent::DeviceAdded { mut device } => {
                configure_libinput_device(state, &mut device);
                if let Some(backend) = state.direct_backend.as_mut() {
                    backend.input_devices.push(device);
                }
            }

            InputEvent::DeviceRemoved { device } => {
                state.cancel_window_interaction();
                if let Some(backend) = state.direct_backend.as_mut() {
                    backend
                        .input_devices
                        .retain(|candidate| candidate != &device);
                }
            }

            event => state.process_input_event(event),
        })?;
    event_loop
        .handle()
        .insert_source(notifier, move |event, _, state| match event {
            SessionEvent::PauseSession => {
                state.cancel_window_interaction();
                state.set_binding_mode("default");
                let handle = state.loop_handle.clone();
                if let Some(backend) = state.direct_backend.as_mut() {
                    backend.active = false;
                    backend.lid.pause();
                    backend.lid_reader.set_active(false);
                    if let Some(token) = backend.lid_reader.deadline.take() {
                        handle.remove(token);
                    }
                    backend.topology.dirty = true;
                    backend.topology.coalescer.clear();
                    if let Some(token) = backend.topology.settle_timer.take() {
                        handle.remove(token);
                    }
                    if let Some(token) = backend.topology.retry_timer.take() {
                        handle.remove(token);
                    }
                    if let Some(token) = backend.battery_timer.take() {
                        handle.remove(token);
                    }
                    if let Some(token) = backend.power_retry.take() {
                        handle.remove(token);
                    }
                    for clock in backend.presentation.values_mut() {
                        clock.reset_timing();
                    }
                    for device in backend.devices.values_mut() {
                        for output in device.outputs.values_mut() {
                            output.gamma.suspend();
                            cancel_output_timers(&handle, output);
                            output.surface.reset_buffers();
                            output.dmabuf_feedback.invalidate();
                            output.primary_commit = None;
                            output.capture_texture = Default::default();
                            output.frame_pending = false;
                            output.power.suspended();
                        }
                        device.drm.pause();
                    }
                }

                state.display_presentation.clear();
                state.refresh_idle_inhibition();

                libinput_context.suspend();
                tracing::info!("direct session paused");
            }

            SessionEvent::ActivateSession => {
                if libinput_context.resume().is_err() {
                    tracing::error!("failed to resume libinput");
                }

                if let Some(backend) = state.direct_backend.as_mut() {
                    backend.active = true;
                    backend.lid_reader.set_active(true);
                }

                let seat = state.seat.clone();
                state.idle_notifier_state.notify_activity(&seat);
                lid::request_refresh(state, true);
                tracing::info!("direct session reacquired; refreshing external state");
            }
        })?;
    event_loop
        .handle()
        .insert_source(udev_backend, |event, _, state| {
            if let UdevEvent::Removed { device_id } = event
                && let Some(node) = direct_node_for_device(state, device_id)
                && let Some(backend) = state.direct_backend.as_mut()
            {
                // A remove/re-add may reuse the same dev_t. Retire the old fd
                // even if fresh enumeration already sees its replacement.
                backend.topology.invalidated.insert(node);
            }

            topology::hotplug(state);
        })?;

    tracing::info!(seat = %seat_name, "initialized direct session input and device discovery");
    Ok(())
}

fn configure_libinput_device(state: &Ferese, device: &mut LibinputDevice) {
    let settings = state.input_settings.touchpad;
    let touchpad = device.config_tap_finger_count() > 0 || device.config_dwt_is_available();
    let mouse = state.input_settings.mouse;
    if touchpad {
        if device.config_accel_is_available()
            && let Err(error) = device.config_accel_set_speed(settings.accel_speed)
        {
            tracing::warn!(device = %device.name(), ?error, "failed to configure touchpad acceleration");
        }
        use smithay::reexports::input::SendEventsMode;
        let mode = if settings.disable_while_mouse_connected {
            SendEventsMode::DISABLED_ON_EXTERNAL_MOUSE
        } else {
            SendEventsMode::ENABLED
        };
        if device
            .config_send_events_modes()
            .contains(SendEventsMode::DISABLED_ON_EXTERNAL_MOUSE)
            && let Err(error) = device.config_send_events_set_mode(mode)
        {
            tracing::warn!(device = %device.name(), ?error, "failed to configure touchpad external-mouse policy");
        }
    }
    if !touchpad && device.has_capability(smithay::reexports::input::DeviceCapability::Pointer) {
        if device.config_accel_is_available() {
            if let Err(error) = device.config_accel_set_speed(mouse.accel_speed) {
                tracing::warn!(device = %device.name(), ?error, "failed to configure mouse acceleration");
            }
            use smithay::reexports::input::AccelProfile;
            let profile = match mouse.accel_profile {
                Some(crate::config::AccelerationProfile::Adaptive) => Some(AccelProfile::Adaptive),
                Some(crate::config::AccelerationProfile::Flat) => Some(AccelProfile::Flat),
                None => device.config_accel_default_profile(),
            };
            if let Some(profile) =
                profile.filter(|profile| device.config_accel_profiles().contains(profile))
                && let Err(error) = device.config_accel_set_profile(profile)
            {
                tracing::warn!(device = %device.name(), ?error, "failed to configure mouse acceleration profile");
            }
        }
        if device.config_left_handed_is_available()
            && let Err(error) = device.config_left_handed_set(mouse.left_handed)
        {
            tracing::warn!(device = %device.name(), ?error, "failed to configure mouse handedness");
        }
        if device.config_middle_emulation_is_available()
            && let Err(error) = device.config_middle_emulation_set_enabled(mouse.middle_emulation)
        {
            tracing::warn!(device = %device.name(), ?error, "failed to configure middle button emulation");
        }
    }

    if device.config_tap_finger_count() > 0
        && let Err(error) = device.config_tap_set_enabled(settings.tap)
    {
        tracing::warn!(device = %device.name(), ?error, "failed to configure tap-to-click");
    }
    if device.config_scroll_has_natural_scroll()
        && let Err(error) = device.config_scroll_set_natural_scroll_enabled(if touchpad {
            settings.natural_scroll
        } else {
            mouse.natural_scroll
        })
    {
        tracing::warn!(device = %device.name(), ?error, "failed to configure natural scrolling");
    }
    if device.config_dwt_is_available()
        && let Err(error) = device.config_dwt_set_enabled(settings.disable_while_typing)
    {
        tracing::warn!(
            device = %device.name(),
            ?error,
            "failed to configure disable-while-typing"
        );
    }
}

pub(crate) fn reload_input_devices(state: &mut Ferese) {
    let Some(backend) = state.direct_backend.as_ref() else {
        return;
    };
    // Device clones refer to the same live libinput objects.
    let mut devices = backend.input_devices.clone();
    for device in &mut devices {
        configure_libinput_device(state, device);
    }
}

fn automatic_refresh_active(backend: &DirectBackendState) -> bool {
    backend.active
        && backend.devices.values().any(|device| {
            device
                .outputs
                .values()
                .any(|output| output.settings.auto_refresh)
        })
}

fn sync_battery_timer(state: &mut Ferese) {
    let Some(backend) = state.direct_backend.as_mut() else {
        return;
    };
    if !automatic_refresh_active(backend) {
        if let Some(token) = backend.battery_timer.take() {
            state.loop_handle.remove(token);
        }
        return;
    }
    if backend.battery_timer.is_some() {
        return;
    }

    match state.loop_handle.insert_source(
        Timer::from_duration(Duration::from_secs(5)),
        |_, _, state| {
            if let Some(backend) = state.direct_backend.as_mut() {
                backend.battery_timer = None;
            }
            update_power_policy(state);
            sync_battery_timer(state);
            TimeoutAction::Drop
        },
    ) {
        Ok(token) => backend.battery_timer = Some(token),
        Err(error) => tracing::warn!(%error, "could not arm automatic refresh battery timer"),
    }
}

fn update_power_policy(state: &mut Ferese) {
    if !state
        .direct_backend
        .as_ref()
        .is_some_and(automatic_refresh_active)
    {
        return;
    }
    let Some(backend) = state.direct_backend.as_mut() else {
        return;
    };
    // Keep low_power as the applied policy while paused. A transition sampled
    // during inactivity must still be detected and applied on activation.
    let battery = if backend.active {
        super::power::battery_percent()
    } else {
        None
    };
    if let Some(next) = super::power::policy_change(backend.active, backend.low_power, battery) {
        backend.low_power = next;
        reload_outputs(state, false);
    }
}

pub(crate) fn reload_outputs(state: &mut Ferese, layout_dirty: bool) {
    if let Some(backend) = state.direct_backend.as_mut() {
        backend.topology.layout_dirty |= layout_dirty;
    }
    reconcile_outputs(state, false);
}

pub(crate) fn set_output_profile(state: &mut Ferese, name: &str) -> Result<(), String> {
    let backend = state
        .direct_backend
        .as_mut()
        .ok_or("monitor profiles require the direct DRM backend")?;
    if !backend.active || backend.lid.pending() {
        return Err("output session is inactive or refreshing lid state".into());
    }
    if name != "auto"
        && !state
            .output_profiles
            .iter()
            .any(|profile| profile.name == name)
    {
        return Err(format!("unknown output profile {name:?}"));
    }
    let previous = backend.manual_outputs.clone();
    let known_good = backend.applied_outputs.clone();
    backend.manual_outputs.profile = (name != "auto").then(|| name.to_owned());
    backend.manual_outputs.internal = None;
    backend.manual_outputs.layout = None;
    let desired = crate::output_policy::select_profile(
        &backend.monitors,
        backend.lid.closed(),
        &state.output_profiles,
        &backend.manual_outputs,
    );
    if name != "auto" && desired.profile.as_deref() != Some(name) {
        backend.manual_outputs = previous;
        return Err("profile does not match the connected monitors/lid".into());
    }
    if let Err(error) = validate_live_outputs(state, &state.output_profiles) {
        state
            .direct_backend
            .as_mut()
            .expect("DRM callbacks require an installed direct backend")
            .manual_outputs = previous;
        return Err(error);
    }
    reconcile_outputs(state, false);
    if let Some(error) = state
        .direct_backend
        .as_ref()
        .expect("DRM callbacks require an installed direct backend")
        .output_error
        .clone()
    {
        state
            .direct_backend
            .as_mut()
            .expect("DRM callbacks require an installed direct backend")
            .manual_outputs = previous;
        return Err(error);
    }
    if name != "auto"
        && state
            .direct_backend
            .as_ref()
            .expect("DRM callbacks require an installed direct backend")
            .desired_outputs
            .profile
            .as_deref()
            != Some(name)
    {
        state
            .direct_backend
            .as_mut()
            .expect("DRM callbacks require an installed direct backend")
            .manual_outputs = previous;
        return Err("profile does not match the connected monitors/lid".into());
    }
    arm_output_confirmation(state, known_good, previous);
    state.notify_monitor_state();
    Ok(())
}

pub(crate) fn set_output_layout(
    state: &mut Ferese,
    layout: crate::config::OutputLayout,
) -> Result<(), String> {
    let backend = state
        .direct_backend
        .as_mut()
        .ok_or("display modes require the direct DRM backend")?;
    if !backend.active || backend.lid.pending() {
        return Err("output session is inactive or refreshing lid state".into());
    }
    let usable = backend
        .monitors
        .iter()
        .filter(|monitor| monitor.usable)
        .collect::<Vec<_>>();
    let available = match layout {
        crate::config::OutputLayout::InternalOnly => usable.iter().any(|monitor| monitor.internal),
        crate::config::OutputLayout::ExternalOnly => usable.iter().any(|monitor| !monitor.internal),
        crate::config::OutputLayout::Extend | crate::config::OutputLayout::Mirror => {
            usable.len() >= 2
        }
    };
    if !available {
        return Err("this display mode requires monitors that are not connected".into());
    }
    let previous = backend.manual_outputs.clone();
    let known_good = backend.applied_outputs.clone();
    backend.manual_outputs.profile = None;
    backend.manual_outputs.internal = None;
    backend.manual_outputs.layout = Some(layout);
    if let Err(error) = validate_live_outputs(state, &state.output_profiles) {
        state
            .direct_backend
            .as_mut()
            .expect("DRM callbacks require an installed direct backend")
            .manual_outputs = previous;
        return Err(error);
    }
    reconcile_outputs(state, false);
    if let Some(error) = state
        .direct_backend
        .as_ref()
        .expect("DRM callbacks require an installed direct backend")
        .output_error
        .clone()
    {
        state
            .direct_backend
            .as_mut()
            .expect("DRM callbacks require an installed direct backend")
            .manual_outputs = previous;
        return Err(error);
    }
    arm_output_confirmation(state, known_good, previous);
    state.notify_monitor_state();
    Ok(())
}

pub(crate) fn set_internal_output(state: &mut Ferese, enabled: bool) -> Result<(), String> {
    let backend = state
        .direct_backend
        .as_mut()
        .ok_or("internal panel control requires the direct DRM backend")?;
    if !backend.active || backend.lid.pending() {
        return Err("output session is inactive or refreshing lid state".into());
    }
    if !enabled
        && !backend
            .monitors
            .iter()
            .any(|monitor| !monitor.internal && monitor.usable)
    {
        return Err("cannot disable the last usable output".into());
    }
    let previous = backend.manual_outputs.clone();
    let known_good = backend.applied_outputs.clone();
    backend.manual_outputs.internal = Some(enabled);
    backend.manual_outputs.layout = None;
    reconcile_outputs(state, false);
    if let Some(error) = state
        .direct_backend
        .as_ref()
        .expect("DRM callbacks require an installed direct backend")
        .output_error
        .clone()
    {
        state
            .direct_backend
            .as_mut()
            .expect("DRM callbacks require an installed direct backend")
            .manual_outputs = previous;
        return Err(error);
    }
    arm_output_confirmation(state, known_good, previous);
    state.notify_monitor_state();
    Ok(())
}

fn confirmation_baseline<T>(pending: Option<T>, previous: T) -> T {
    pending.unwrap_or(previous)
}

fn arm_output_confirmation(
    state: &mut Ferese,
    previous: DesiredOutputConfiguration,
    manual: ManualOverride,
) {
    let backend = state
        .direct_backend
        .as_mut()
        .expect("DRM callbacks require an installed direct backend");
    if let Some(token) = backend.confirmation_timer.take() {
        state.loop_handle.remove(token);
    }
    let timeout = backend
        .desired_outputs
        .profile
        .as_ref()
        .and_then(|name| {
            state
                .output_profiles
                .iter()
                .find(|profile| &profile.name == name)
        })
        .map_or(15, |profile| profile.confirm_timeout);
    let baseline = confirmation_baseline(backend.confirmation.take(), (previous, manual));
    if timeout == 0 || baseline.0.outputs.is_empty() {
        return;
    }
    backend.confirmation = Some(baseline);
    backend.confirmation_lid = backend.lid.closed();
    match state.loop_handle.insert_source(
        Timer::from_duration(Duration::from_secs(timeout.into())),
        |_, _, state| {
            if let Some(backend) = state.direct_backend.as_mut() {
                backend.confirmation_timer = None;
            }
            let _ = confirm_output_configuration(state, false);
            TimeoutAction::Drop
        },
    ) {
        Ok(token) => {
            state
                .direct_backend
                .as_mut()
                .expect("DRM callbacks require an installed direct backend")
                .confirmation_timer = Some(token)
        }
        Err(error) => {
            tracing::warn!(%error, "could not arm monitor confirmation; reverting");
            let _ = confirm_output_configuration(state, false);
        }
    }
}

pub(crate) fn confirm_output_configuration(
    state: &mut Ferese,
    confirm: bool,
) -> Result<(), String> {
    let backend = state
        .direct_backend
        .as_mut()
        .ok_or("direct backend unavailable")?;
    if let Some(token) = backend.confirmation_timer.take() {
        state.loop_handle.remove(token);
    }
    if let Some((previous, manual)) = backend.confirmation.take()
        && !confirm
    {
        backend.revert_outputs = Some(crate::output_policy::restore_configuration(
            &previous,
            &backend.monitors,
        ));
        backend.manual_outputs = manual;
        reconcile_outputs(state, false);
        if let Some(error) = state
            .direct_backend
            .as_ref()
            .expect("DRM callbacks require an installed direct backend")
            .output_error
            .clone()
        {
            return Err(error);
        }
    }
    state.notify_monitor_state();
    Ok(())
}

pub(crate) fn validate_live_outputs(
    state: &Ferese,
    profiles: &[OutputProfile],
) -> Result<(), String> {
    let Some(backend) = state.direct_backend.as_ref() else {
        return Ok(());
    };
    if !backend.can_render() || backend.devices.is_empty() {
        // Syntax/config validation still runs; live probing waits for ownership.
        return Ok(());
    }
    for profile in profiles {
        let mut matched = HashSet::new();
        for settings in &profile.outputs {
            let matches = backend
                .monitors
                .iter()
                .filter(|monitor| monitor.matches(&settings.matcher))
                .collect::<Vec<_>>();
            if matches.len() > 1 || matches.iter().any(|monitor| !matched.insert(&monitor.key)) {
                return Err(format!(
                    "profile {:?} contains ambiguous or overlapping monitor selectors",
                    profile.name
                ));
            }
        }
    }
    let mut desired = crate::output_policy::select_profile(
        &backend.monitors,
        backend.lid.closed(),
        profiles,
        &backend.manual_outputs,
    );
    resolve_output_positions(backend, &mut desired)?;
    let usable = validate_output_configuration(backend, &desired)?;
    if usable == 0 {
        return Err("display configuration would leave no usable output".into());
    }
    Ok(())
}

fn open_device(state: &mut Ferese, path: &Path) -> Result<DrmNode, Box<dyn Error>> {
    let session = state
        .direct_backend
        .as_ref()
        .expect("direct backend state is initialized before the DRM device")
        .session
        .clone();
    let node = DrmNode::from_path(path)?;
    let session_device = session_device::SessionDevice::open(session, path)?;
    let fd = DrmDeviceFd::new(session_device.device_fd()?);
    let (drm, notifier) = DrmDevice::new(fd.clone(), true)?;
    let gbm = GbmDevice::new(fd)?;
    // SAFETY: GBM owns a valid DRM descriptor for the lifetime of the EGL display.
    let egl_display = unsafe { EGLDisplay::new(gbm.clone())? };
    let egl_context = context::try_new(&egl_display)?;
    // SAFETY: the new context is not current on another thread and remains renderer-owned.
    let renderer = unsafe { GlesRenderer::new(egl_context)? };
    state.shm_state.update_formats(renderer.shm_formats());
    let dmabuf_formats = renderer.dmabuf_formats();
    let display_handle = state.display_handle.clone();
    // Mesa's Wayland EGL path needs the main device, not just a v3 format
    // list, to choose a hardware render node. Without feedback, nested EGL
    // clients can fall back to llvmpipe despite a GPU-backed DRM compositor.
    let render_node = node
        .node_with_type(NodeType::Render)
        .and_then(Result::ok)
        .unwrap_or(node);
    let feedback = DmabufFeedbackBuilder::new(render_node.dev_id(), dmabuf_formats).build()?;
    let registration = state
        .loop_handle
        .insert_source(notifier, move |event, metadata, state| match event {
            DrmEvent::VBlank(crtc) => {
                #[cfg(feature = "drm-fault-injection")]
                if state
                    .direct_backend
                    .as_ref()
                    .and_then(|backend| backend.devices.get(&node))
                    .and_then(|device| device.outputs.get(&crtc))
                    .is_some_and(|output| output.frame_pending)
                    && recovery::inject("missing-completion")
                {
                    tracing::warn!(?node, ?crtc, "injecting missing DRM completion");
                    return;
                }

                if let Some(metadata) = metadata {
                    let mut retired = false;
                    let mut retirement_failed = false;
                    let feedback = state
                        .direct_backend
                        .as_mut()
                        .and_then(|backend| backend.devices.get_mut(&node))
                        .and_then(|device| device.outputs.get_mut(&crtc))
                        .and_then(|output| {
                            #[cfg(feature = "drm-fault-injection")]
                            if output.frame_pending && recovery::inject("retirement") {
                                tracing::warn!(?node, ?crtc, "injecting DRM retirement failure");
                                retirement_failed = true;
                                output.diagnostics.retirement(false, true);
                                output.diagnostics.report_if_due();
                                return None;
                            }

                            let (feedback, completed, error) = recovery::retirement(output.surface.frame_submitted());
                            retired = completed;
                            output.diagnostics.retirement(completed, error.is_some());
                            output.diagnostics.report_if_due();
                            if let Some(error) = error {
                                tracing::error!(?node, ?crtc, %error, "failed to retire DRM frame");
                                retirement_failed = true;
                            }

                            feedback
                        });

                    if let (Some(mut feedback), DrmEventTime::Monotonic(time)) = (feedback, metadata.time) {
                        feedback.presented(
                            Time::<Monotonic>::from(time),
                            Refresh::fixed(refresh_duration(state, node, crtc)),
                            u64::from(metadata.sequence),
                            Kind::Vsync | Kind::HwClock | Kind::HwCompletion,
                        );
                    }

                    let lock_output = state
                        .direct_backend
                        .as_mut()
                        .and_then(|backend| backend.devices.get_mut(&node))
                        .and_then(|device| device.outputs.get_mut(&crtc))
                        .and_then(|output| {
                            if retired && std::mem::take(&mut output.lock_frame_pending) {
                                Some(output.output.clone())
                            } else {
                                None
                            }
                        });

                    if let Some(output) = lock_output {
                        state.lock_frame_presented(&output);
                    }

                    if let Some(output) = state
                        .direct_backend
                        .as_mut()
                        .and_then(|backend| backend.devices.get_mut(&node))
                        .and_then(|device| device.outputs.get_mut(&crtc))
                        && retired
                    {
                        output.completion.retired();
                        output.frame_pending = false;
                        if output.power.needs_wake() {
                            output.gamma.retry_probe();
                            state.gamma_dirty = true;
                        }
                        output.power.presented();
                        if let DrmEventTime::Monotonic(timestamp) = metadata.time {
                            let now = monotonic_now();
                            if timestamp <= now + refresh_duration_from_mode(output.mode) {
                                if let Some(plan) = output.scheduler.presented(timestamp)
                                    && std::env::var_os("FERESE_TRACE_PERFORMANCE").is_some()
                                {
                                    tracing::debug!(target: "ferese::render", output = %output.output.name(),
                                        target_us = plan.present_at.as_micros(), actual_us = timestamp.as_micros(),
                                        request_to_present_us = timestamp.saturating_sub(plan.requested_at).as_micros(),
                                        missed_deadlines = output.scheduler.missed_deadlines,
                                        "DRM presentation schedule");
                                }
                            } else {
                                output.scheduler.retire_unknown();
                            }
                        } else {
                            output.scheduler.retire_unknown();
                        }
                    }

                    if retired {
                        if let Some(output) = state
                            .direct_backend
                            .as_ref()
                            .and_then(|backend| backend.devices.get(&node))
                            .and_then(|device| device.outputs.get(&crtc))
                        {
                            state.display_presentation.presented(&output.output);
                        }
                        state.refresh_idle_inhibition();
                    }

                    if retirement_failed {
                        recovery::reconcile_device(state, node);
                        return;
                    }

                    apply_output_power(state);

                    state.record_drm_presentation(node, crtc, metadata.time, metadata.sequence);
                    tracing::trace!(?node, ?crtc, sequence = metadata.sequence, "page flip");
                    let active = state
                        .direct_backend
                        .as_ref()
                        .is_some_and(|backend| backend.can_render());
                    if active && retired {
                        schedule_frame_callbacks(state, node, crtc, monotonic_now());
                        let identity = state
                            .direct_backend
                            .as_ref()
                            .and_then(|backend| backend.devices.get(&node))
                            .and_then(|device| device.outputs.get(&crtc))
                            .map(|output| output.output.clone());
                        if identity.is_some_and(|output| state.output_has_animations(&output)) {
                            request_frame(state, node, crtc);
                        } else {
                            arm_frame(state, node, crtc);
                        }

                        arm_animation_timer(state);
                    }
                }
            }

            DrmEvent::Error(error) => {
                tracing::error!(?node, %error, "DRM event error");
            }
        })?;

    let dmabuf_global = state
        .dmabuf_state
        .create_global_with_default_feedback::<Ferese>(&display_handle, &feedback);
    state.dmabuf_imports.register(dmabuf_global);
    state.dmabuf_feedback.register(dmabuf_global, feedback);
    state
        .direct_backend
        .as_mut()
        .expect("direct backend state remains initialized")
        .devices
        .insert(
            node,
            DirectDevice {
                _session_device: session_device,
                drm,
                gbm,
                renderer,
                render_node,
                outputs: HashMap::new(),
                notifier: registration,
                dmabuf_global,
                connected_outputs: Vec::new(),
            },
        );
    tracing::info!(?node, ?path, "initialized DRM/GBM device");
    Ok(node)
}

pub(crate) fn sleep_locked_outputs(state: &mut Ferese) {
    if !state.session_lock.active() || !state.session_lock.sleeping {
        return;
    }

    if let Some(backend) = state.direct_backend.as_mut() {
        for device in backend.devices.values_mut() {
            for output in device.outputs.values_mut() {
                output.power.request(Power::Off);
            }
        }
    }
    apply_output_power(state);
}

// Apply runtime requests without changing output globals or workspace ownership.
fn apply_output_power(state: &mut Ferese) {
    let Some(backend) = state
        .direct_backend
        .as_mut()
        .filter(|backend| backend.can_render())
    else {
        return;
    };

    for device in backend
        .devices
        .values_mut()
        .filter(|device| device.drm.is_active())
    {
        for output in device.outputs.values_mut() {
            if !output.power.needs_power_off() || output.frame_pending {
                continue;
            }

            match output.surface.clear() {
                Ok(()) => {
                    cancel_output_timers(&state.loop_handle, output);
                    output.power.powered_off();
                    state.display_presentation.remove_output(&output.output);
                }

                Err(error) => {
                    tracing::warn!(%error, output = %output.output.name(), "could not apply output power-off request")
                }
            }
        }
    }
    let retry = backend.active
        && backend
            .devices
            .values()
            .filter(|device| device.drm.is_active())
            .any(|device| {
                device
                    .outputs
                    .values()
                    .any(|output| output.power.needs_power_off() && !output.frame_pending)
            });
    if !retry {
        if let Some(token) = backend.power_retry.take() {
            state.loop_handle.remove(token);
        }
    } else if backend.power_retry.is_none() {
        match state.loop_handle.insert_source(
            Timer::from_duration(Duration::from_secs(1)),
            |_, _, state| {
                if let Some(backend) = state.direct_backend.as_mut() {
                    backend.power_retry = None;
                }
                apply_output_power(state);
                TimeoutAction::Drop
            },
        ) {
            Ok(token) => backend.power_retry = Some(token),
            Err(error) => tracing::warn!(%error, "could not arm failed power-off retry"),
        }
    }
    state.refresh_idle_inhibition();
}

pub(crate) fn wake_locked_outputs(state: &mut Ferese) {
    state.reset_animation_clock();
    if let Some(backend) = state.direct_backend.as_mut() {
        for device in backend.devices.values_mut() {
            for output in device.outputs.values_mut() {
                if output.power.needs_wake() {
                    output.surface.reset_buffer_ages();
                }
                output.power.request(Power::On);
            }
        }
    }
    apply_output_power(state);
    render_all(state);
}

#[track_caller]
pub fn render_all(state: &mut Ferese) {
    state.image_capture.invalidate_workspaces();
    for output in state.space.outputs() {
        capture::changes::content_changed(output);
    }
    redraw(state, None, std::panic::Location::caller());
}

#[track_caller]
pub(crate) fn render_on(state: &mut Ferese, outputs: &[Output]) {
    for output in outputs {
        capture::changes::content_changed(output);
    }
    redraw(state, Some(outputs), std::panic::Location::caller());
}

/// Consumer demand schedules a frame without invalidating retained scene pixels.
#[track_caller]
pub(crate) fn schedule_capture(state: &mut Ferese, outputs: &[Output]) {
    redraw(state, Some(outputs), std::panic::Location::caller());
}

#[track_caller]
pub(crate) fn render_cursor(state: &mut Ferese) {
    // Include nested outputs and both sides of an output crossing. This does not
    // invalidate the content revision used by cursor-hidden captures.
    for output in state.space.outputs() {
        capture::changes::cursor_changed(output);
    }
    let outputs = cursor_affected_outputs(state);
    redraw(state, Some(&outputs), std::panic::Location::caller());
}

fn cursor_affected_outputs(state: &Ferese) -> Vec<Output> {
    state
        .direct_backend
        .as_ref()
        .into_iter()
        .flat_map(|backend| backend.devices.values())
        .flat_map(|device| device.outputs.values())
        .filter(|output| output.cursor_visible || redraw::cursor_on_output(state, &output.output))
        .map(|output| output.output.clone())
        .collect()
}

pub(crate) fn cursor_animation_visible(state: &Ferese) -> bool {
    if let Some(backend) = state.direct_backend.as_ref() {
        backend.can_render()
            && backend.devices.values().any(|device| {
                device.outputs.values().any(|output| {
                    output.power.can_render() && redraw::cursor_on_output(state, &output.output)
                })
            })
    } else {
        state
            .space
            .outputs()
            .any(|output| redraw::cursor_on_output(state, output))
    }
}

#[track_caller]
pub(crate) fn render_surface(
    state: &mut Ferese,
    surface: &smithay::reexports::wayland_server::protocol::wl_surface::WlSurface,
) {
    use smithay::input::pointer::CursorImageStatus;
    use smithay::wayland::compositor::get_parent;
    let mut root = surface.clone();
    while let Some(parent) = get_parent(&root) {
        root = parent;
    }

    if matches!(&state.cursor_status, CursorImageStatus::Surface(cursor) if cursor == &root) {
        render_cursor(state);
        return;
    }

    let capture_root = state
        .popups
        .find_popup(&root)
        .and_then(|popup| smithay::desktop::find_popup_root_surface(&popup).ok())
        .unwrap_or_else(|| root.clone());
    if let Some(workspace) = state
        .windows
        .id_for_surface(&capture_root)
        .and_then(|id| state.workspaces.workspace_for_window(id))
    {
        state.image_capture.workspace_changed(workspace);
    }
    let outputs = state.surface_outputs(&root);
    render_on(state, &outputs);
}

fn redraw(
    state: &mut Ferese,
    selected: Option<&[Output]>,
    source: &'static std::panic::Location<'static>,
) {
    if let Some(transition) = state.desktop_transition.as_mut() {
        transition.redraw.extend(
            selected
                .map(|outputs| outputs.to_vec())
                .unwrap_or_else(|| state.space.outputs().cloned().collect()),
        );
        return;
    }
    if state
        .direct_backend
        .as_ref()
        .is_none_or(|backend| !backend.can_render())
    {
        return;
    }

    let outputs = state
        .direct_backend
        .as_ref()
        .expect("DRM callbacks require an installed direct backend")
        .devices
        .iter()
        .flat_map(|(node, device)| {
            device
                .outputs
                .iter()
                .map(|(crtc, output)| (*node, *crtc, output.output.clone()))
        })
        .collect::<Vec<_>>();
    // Include animations before advancing, so their final settled frame is
    // drawn too. Advancing shared state must not leave another output stale.
    let affected = outputs
        .iter()
        .map(|(_, _, output)| {
            let scene = state
                .direct_backend
                .as_ref()
                .expect("DRM callbacks require an installed direct backend")
                .scene_output(state, output);
            selected.is_none_or(|selected| selected.contains(output) || selected.contains(&scene))
                || state.output_has_animations(&scene)
                || state.output_has_pending_visual_changes(&scene)
        })
        .collect::<Vec<_>>();
    state.advance_animations(Instant::now());
    let mut requested = 0;
    for ((node, crtc, output), affected) in outputs.iter().zip(affected) {
        if affected || state.output_has_animations(output) {
            request_frame(state, *node, *crtc);
            requested += 1;
        }
    }

    state
        .direct_backend
        .as_mut()
        .expect("DRM callbacks require an installed direct backend")
        .scheduling_metrics
        .redraw(source, selected.is_none(), requested, outputs.len());
    arm_animation_timer(state);
}

pub fn switch_vt(state: &mut Ferese, vt: i32) {
    let Some(backend) = state.direct_backend.as_mut() else {
        return;
    };

    if let Err(error) = backend.session.change_vt(vt) {
        tracing::error!(vt, %error, "failed to switch virtual terminal");
    }
}

pub(crate) fn set_lid_closed(state: &mut Ferese, closed: bool) {
    let Some(backend) = state.direct_backend.as_mut() else {
        return;
    };
    // Even an unchanged switch observation supersedes an in-flight DBus read.
    if backend.lid.observe(closed) {
        tracing::info!(closed, "laptop lid state changed");
        reconcile_outputs(state, false);
    }
}

pub(crate) fn system_resumed(state: &mut Ferese) {
    if state
        .direct_backend
        .as_ref()
        .is_some_and(|backend| backend.active)
    {
        let seat = state.seat.clone();
        state.idle_notifier_state.notify_activity(&seat);
    }
    lid::request_refresh(state, true);
}

pub(crate) fn reconcile_after_monitor_recovery(state: &mut Ferese) {
    lid::request_reconcile(state);
}

fn internal_connector(interface: connector::Interface) -> bool {
    matches!(
        interface,
        connector::Interface::EmbeddedDisplayPort
            | connector::Interface::LVDS
            | connector::Interface::DSI
    )
}

#[cfg(test)]
fn lid_hides_panel(closed: bool, external_available: bool) -> bool {
    closed && external_available
}

// Return the sampled scene's activity so dispatch does not rescan the windows.
fn render_output(
    state: &mut Ferese,
    node: DrmNode,
    crtc: crtc::Handle,
    plan: crate::frame_scheduler::FramePlan,
) -> bool {
    if state.session_lock.active() && state.session_lock.sleeping {
        sleep_locked_outputs(state);
        let asleep = state
            .direct_backend
            .as_ref()
            .and_then(|backend| backend.devices.get(&node))
            .and_then(|device| device.outputs.get(&crtc))
            .is_none_or(|output| !output.power.can_render() || output.frame_pending);
        if asleep {
            return false;
        }
    }

    let missed_deadlines = state
        .direct_backend
        .as_ref()
        .and_then(|backend| backend.devices.get(&node))
        .and_then(|device| device.outputs.get(&crtc))
        .map_or(0, |output| output.scheduler.missed_deadlines);
    let scene_output = state.direct_backend.as_ref().map(|backend| {
        let physical = &backend.devices[&node].outputs[&crtc].output;
        backend.scene_output(state, physical)
    });
    let Some(mut device) = state
        .direct_backend
        .as_mut()
        .and_then(|backend| backend.devices.remove(&node))
    else {
        return false;
    };

    let Some(mut output) = device.outputs.remove(&crtc) else {
        restore_device(state, node, device);
        return false;
    };

    if !device.drm.is_active() || !output.power.can_render() || output.frame_pending {
        device.outputs.insert(crtc, output);
        restore_device(state, node, device);
        return false;
    }

    let render_started = Instant::now();
    let now = monotonic_now();
    let horizon = output
        .scheduler
        .forecast_time(now, plan)
        .map_or(Duration::ZERO, |target| target.saturating_sub(now));
    let scene_output = scene_output.unwrap_or_else(|| output.output.clone());
    let frame = state.sample_frame(&scene_output, horizon);
    let rendered = {
        (|| -> Result<bool, Box<dyn Error>> {
            let elements = if output.mirror_source.is_some() {
                mirror::elements(
                    state,
                    &mut device.renderer,
                    &scene_output,
                    &frame,
                    &mut output,
                )?
            } else {
                sampled_output_elements(state, &mut device.renderer, &output.output, true, &frame)
            };
            let effects =
                frame_effect_metrics(&elements, output.output.current_scale().fractional_scale());
            let fullscreen = state
                .output_has_fullscreen_for_frame(&output.output, frame.overview.is_presenting());
            let locked = state.session_lock.active();
            let flags = planes::frame_flags(fullscreen, frame.animating, locked);
            output
                .diagnostics
                .attempt(fullscreen, frame.animating, locked);
            let result = output
                .surface
                .render_frame(
                    &mut device.renderer,
                    &elements,
                    if output.mirror_source.is_some() {
                        [0.0, 0.0, 0.0, 1.0]
                    } else {
                        [0.035, 0.04, 0.055, 1.0]
                    },
                    flags,
                )
                .inspect_err(|_| output.diagnostics.render_failed())?;

            let primary_format = match &result.primary_element {
                PrimaryPlaneElement::Swapchain(primary) => Some(primary.buffer().format()),
                PrimaryPlaneElement::Element(element) => {
                    match element.underlying_storage(&mut device.renderer) {
                        Some(UnderlyingStorage::Wayland(buffer)) => {
                            smithay::wayland::dmabuf::get_dmabuf(buffer)
                                .ok()
                                .map(|buffer| buffer.format())
                        }
                        _ => None,
                    }
                }
            };
            let feedback_candidates = feedback::candidates(
                &mut device.renderer,
                &elements,
                &output.output,
                flags.contains(FrameFlags::ALLOW_PRIMARY_PLANE_SCANOUT),
            );

            if result.needs_sync()
                && let PrimaryPlaneElement::Swapchain(primary) = &result.primary_element
            {
                primary
                    .sync
                    .wait()
                    .inspect_err(|_| output.diagnostics.sync_failed())?;
            }

            if result.is_empty {
                output.diagnostics.no_damage();
                let capture_started = output.diagnostics.capture_start(|| {
                    [true, false]
                        .into_iter()
                        .any(|cursor| state.has_pending_screencopy(&output.output, cursor))
                });
                output.dmabuf_feedback.observed_frame(
                    primary_format,
                    &result.states,
                    feedback_candidates,
                );
                if output.mirror_source.is_some() {
                    capture::capture_mirror(
                        state,
                        &mut device.renderer,
                        &scene_output,
                        &frame,
                        &mut output,
                    );
                } else {
                    capture::capture_output(
                        state,
                        &mut device.renderer,
                        &mut output.capture_texture,
                        &output.output,
                        &frame,
                    );
                }

                output.diagnostics.capture_finished(capture_started);
                output
                    .render_metrics
                    .record_no_damage(render_started.elapsed(), missed_deadlines);
                return Ok(false);
            }

            // Count GPU composition damage; direct scanout and cursor-only
            // updates do not redraw the primary swapchain.
            let (damage, primary_commit) = match &result.primary_element {
                PrimaryPlaneElement::Swapchain(primary) => {
                    let damage = primary.damage.damage_since(output.primary_commit);
                    let damage = damage.map_or_else(
                        || {
                            vec![smithay::utils::Rectangle::from_size(
                                output
                                    .output
                                    .current_mode()
                                    .expect("a rendered output must have a current mode")
                                    .size,
                            )]
                        },
                        |damage| {
                            damage
                                .iter()
                                .map(|rect| {
                                    smithay::utils::Rectangle::new(
                                        (rect.loc.x, rect.loc.y).into(),
                                        (rect.size.w, rect.size.h).into(),
                                    )
                                })
                                .collect()
                        },
                    );
                    (damage, Some(primary.damage.current_commit()))
                }

                PrimaryPlaneElement::Element(_) => (Vec::new(), None),
            };
            let presentation = if output.mirror_source.is_some() {
                OutputPresentationFeedback::new(&output.output)
            } else {
                crate::presentation::take_output_feedback(
                    state,
                    &output.output,
                    &result.states,
                    Kind::Vsync | Kind::HwClock | Kind::HwCompletion,
                )
            };
            let primary_outcome = PrimaryOutcome::classify(
                matches!(result.primary_element, PrimaryPlaneElement::Element(_)),
                !damage.is_empty(),
            );
            let cursor_plane = result.cursor_element.is_some();
            let visibility = result.states.clone();
            drop(result);

            let queued = output.surface.queue_frame(presentation);
            output.diagnostics.queue_result(
                &queued,
                primary_outcome,
                cursor_plane,
                flags.contains(FrameFlags::ALLOW_PRIMARY_PLANE_SCANOUT),
            );
            capture::after_queue(queued, || {
                output.dmabuf_feedback.observed_frame(
                    primary_format,
                    &visibility,
                    feedback_candidates,
                );
                if output.mirror_source.is_none() {
                    state
                        .display_presentation
                        .queued(&output.output, &visibility);
                }
                output.primary_commit = primary_commit;
                output.render_metrics.record_frame(
                    render_started.elapsed(),
                    &damage,
                    missed_deadlines,
                    effects,
                );
                output.frame_pending = true;
                if !recovery::arm_completion(&state.loop_handle, node, crtc, &mut output) {
                    recovery::reconcile_device(state, node);
                }

                output.lock_frame_pending = state.session_lock.active();
                let capture_started = output.diagnostics.capture_start(|| {
                    [true, false]
                        .into_iter()
                        .any(|cursor| state.has_pending_screencopy(&output.output, cursor))
                });

                if output.mirror_source.is_some() {
                    capture::capture_mirror(
                        state,
                        &mut device.renderer,
                        &scene_output,
                        &frame,
                        &mut output,
                    );
                } else {
                    capture::capture_output(
                        state,
                        &mut device.renderer,
                        &mut output.capture_texture,
                        &output.output,
                        &frame,
                    );
                }
                output.diagnostics.capture_finished(capture_started);
            })?;

            Ok(true)
        })()
    };

    output.diagnostics.report_if_due();

    // Keep the footprint of the last successful scene, including queued
    // cursor planes. Requests do not read the pointer while a grab holds it.
    if rendered.is_ok() {
        output.cursor_visible = redraw::cursor_on_output(state, &output.output);
    }

    let submitted = rendered.as_ref().is_ok_and(|submitted| *submitted);
    record_frame_schedule(&mut output, plan, render_started.elapsed(), submitted);

    if submitted && let Some(token) = output.callback_timer.take() {
        state.loop_handle.remove(token);
    }

    match rendered {
        Ok(true) => tracing::trace!(?node, ?crtc, "queued DRM frame"),
        Ok(false) => (),
        Err(error) => tracing::error!(?node, ?crtc, %error, "failed to render DRM frame"),
    }

    device.outputs.insert(crtc, output);
    restore_device(state, node, device);
    if !submitted
        && scene_output
            == state
                .direct_backend
                .as_ref()
                .expect("DRM callbacks require an installed direct backend")
                .devices[&node]
                .outputs[&crtc]
                .output
    {
        schedule_frame_callbacks(state, node, crtc, plan.present_at);
    }

    frame.animating
}

fn restore_device(state: &mut Ferese, node: DrmNode, device: DirectDevice) {
    if let Some(backend) = state.direct_backend.as_mut() {
        backend.devices.insert(node, device);
    }
}

fn direct_node_for_device(state: &Ferese, device_id: libc::dev_t) -> Option<DrmNode> {
    state
        .direct_backend
        .as_ref()?
        .devices
        .keys()
        .copied()
        .find(|node| node.dev_id() == device_id)
}

fn rescan_device(state: &mut Ferese, node: DrmNode) -> Result<bool, ()> {
    let Some(backend) = state
        .direct_backend
        .as_mut()
        .filter(|backend| backend.active)
    else {
        return Err(());
    };
    let Some(mut device) = backend.devices.remove(&node) else {
        return Err(());
    };
    let scan = select_outputs(
        &device,
        &backend.monitors,
        &backend.desired_outputs,
        backend.low_power,
    );
    let result = scan
        .map_err(|error| error.to_string())
        .and_then(|scan| transaction::apply_device(state, node, &mut device, scan));
    if let Err(error) = &result {
        tracing::warn!(?node, %error, "output transaction failed; restored known-good outputs where possible");
        state
            .direct_backend
            .as_mut()
            .expect("DRM callbacks require an installed direct backend")
            .output_error = Some(error.clone());
        transaction::update_applied_info(&mut device);
    }
    restore_device(state, node, device);
    Ok(result.is_ok())
}

fn refresh_connected_info(state: &mut Ferese) {
    let backend = state
        .direct_backend
        .as_mut()
        .expect("DRM callbacks require an installed direct backend");
    for device in backend.devices.values_mut() {
        if let Ok(scan) = select_outputs(
            device,
            &backend.monitors,
            &backend.desired_outputs,
            backend.low_power,
        ) {
            device.connected_outputs = scan.connected_outputs;
        }
        transaction::update_applied_info(device);
        for info in &mut device.connected_outputs {
            info.profile = backend.applied_outputs.profile.clone();
        }
    }
    let mut inventory = backend
        .devices
        .values()
        .flat_map(|device| device.connected_outputs.clone())
        .collect::<Vec<_>>();
    for previous in &backend.connected_outputs {
        if !inventory
            .iter()
            .any(|output| output.identity == previous.identity)
        {
            let mut missing = previous.clone();
            missing.connected = false;
            missing.enabled = false;
            missing.requested_enabled = false;
            missing.current_mode = None;
            inventory.push(missing);
        }
    }
    let identities = inventory
        .iter()
        .map(|output| output.identity.clone())
        .collect::<Vec<_>>();
    backend.connected_outputs = inventory;
    for identity in identities {
        state.ensure_output_identity(&identity);
    }
}

fn remember_applied_configuration(state: &mut Ferese) {
    let backend = state
        .direct_backend
        .as_mut()
        .expect("DRM callbacks require an installed direct backend");
    if backend.topology.reconciling {
        // Applied positions are read only after the coherent logical publish.
        backend.topology.remember_applied = true;
        return;
    }
    let mut applied = backend.desired_outputs.clone();
    for desired in &mut applied.outputs {
        let monitor = backend
            .monitors
            .iter()
            .find(|monitor| monitor.key == desired.key);
        let output = monitor.and_then(|monitor| {
            backend
                .devices
                .values()
                .flat_map(|device| device.outputs.values())
                .find(|output| output.identity == monitor.identity)
        });
        desired.settings.enabled = output.is_some();
        if let Some(output) = output {
            desired.settings = output.settings.clone();
            let (width, height) = output.mode.size();
            desired.settings.mode = Some(OutputModeRequest {
                width,
                height,
                refresh_millihertz: Some(OutputMode::from(output.mode).refresh as u32),
            });
            let position = output.output.current_location();
            desired.settings.position = Some([position.x, position.y]);
            desired.mirror_source = output.mirror_source.clone();
        }
    }
    backend.applied_outputs = applied;
}

fn validate_desired_outputs(state: &Ferese) -> Result<(), String> {
    let backend = state
        .direct_backend
        .as_ref()
        .ok_or("direct backend unavailable")?;
    validate_output_configuration(backend, &backend.desired_outputs).map(|_| ())
}

fn validate_output_configuration(
    backend: &DirectBackendState,
    desired: &DesiredOutputConfiguration,
) -> Result<usize, String> {
    let scans = backend
        .devices
        .values()
        .map(|device| {
            select_outputs(device, &backend.monitors, desired, backend.low_power)
                .map(|scan| (device, scan))
                .map_err(|error| error.to_string())
        })
        .collect::<Result<Vec<_>, _>>()?;
    let selected = scans
        .iter()
        .flat_map(|(device, scan)| {
            let device_key = drm_device_key(&device.drm);
            scan.selections
                .iter()
                .map(move |selection| format!("{device_key}/{}", selection.connector))
        })
        .collect::<Vec<_>>();
    validate_output_plan(desired, &selected, || {
        for (device, scan) in &scans {
            transaction::validate_device(device, scan).map_err(|error| error.to_string())?;
        }
        Ok(())
    })?;
    Ok(selected.len())
}

/// Keep plan completeness separate from the hardware probe so a partial scan
/// cannot be accepted merely because the driver accepts its selected subset.
fn validate_output_plan(
    desired: &DesiredOutputConfiguration,
    selected: &[String],
    test_hardware: impl FnOnce() -> Result<(), String>,
) -> Result<(), String> {
    validate_selected_outputs(&desired.outputs, selected)?;
    test_hardware()
}

fn validate_selected_outputs<'a>(
    outputs: impl IntoIterator<Item = &'a crate::output_policy::DesiredOutput>,
    selected: &[String],
) -> Result<(), String> {
    for output in outputs.into_iter().filter(|output| output.settings.enabled) {
        if !selected.contains(&output.key) {
            return Err(format!(
                "enabled output {} has no usable CRTC assignment",
                output.key
            ));
        }
    }
    Ok(())
}

fn remove_device(state: &mut Ferese, node: DrmNode) {
    let Some(device) = state
        .direct_backend
        .as_mut()
        .and_then(|backend| backend.devices.remove(&node))
    else {
        return;
    };

    state.loop_handle.remove(device.notifier);
    state.dmabuf_imports.remove(device.dmabuf_global);
    state.dmabuf_feedback.remove(device.dmabuf_global);
    state
        .dmabuf_state
        .disable_global::<Ferese>(&state.display_handle, &device.dmabuf_global);
    let context = device.renderer.context_id().erased();
    state.wallpaper.forget_context(&context);
    state.render.forget_context(&context);
    state.capture_render.forget_context(&context);
    for (crtc, mut output) in device.outputs {
        cancel_output_timers(&state.loop_handle, &mut output);
        if let Some(global) = output.global.take() {
            state.display_handle.disable_global::<Ferese>(global);
        }
        state.unregister_output(&output.output);
        if let Some(backend) = state.direct_backend.as_mut() {
            backend.presentation.remove(&(node, crtc));
        }
    }

    tracing::info!(?node, "removed DRM device");
}

fn refresh_duration(state: &Ferese, node: DrmNode, crtc: crtc::Handle) -> Duration {
    state
        .direct_backend
        .as_ref()
        .and_then(|backend| backend.devices.get(&node))
        .and_then(|device| device.outputs.get(&crtc))
        .and_then(|output| output.output.current_mode())
        .filter(|mode| mode.refresh > 0)
        .map(|mode| Duration::from_nanos(1_000_000_000_000_u64 / mode.refresh as u64))
        .unwrap_or_else(|| Duration::from_millis(16))
}

fn refresh_duration_from_mode(mode: DrmMode) -> Duration {
    Duration::from_nanos(1_000_000_000_000 / OutputMode::from(mode).refresh.max(1) as u64)
}

fn animation_fallbacks(state: &mut Ferese) -> Vec<(DrmNode, crtc::Handle, Instant)> {
    let now = Instant::now();
    let outputs = state
        .direct_backend
        .as_ref()
        .into_iter()
        .flat_map(|backend| backend.devices.iter())
        .flat_map(|(node, device)| {
            device.outputs.iter().map(move |(crtc, output)| {
                (*node, *crtc, output.output.clone(), device.drm.is_active())
            })
        })
        .collect::<Vec<_>>();
    let mut fallbacks = Vec::new();
    for (node, crtc, identity, device_active) in outputs {
        let enabled = device_active
            && !state.session_lock.sleeping
            && state
                .direct_backend
                .as_ref()
                .is_some_and(|backend| backend.can_render());
        let scene = state
            .direct_backend
            .as_ref()
            .expect("DRM callbacks require an installed direct backend")
            .scene_output(state, &identity);
        let animating = enabled && state.output_has_animations(&scene);
        let backend = state
            .direct_backend
            .as_mut()
            .expect("DRM callbacks require an installed direct backend");
        let output = backend
            .devices
            .get_mut(&node)
            .expect("the selected DRM device remains registered during this operation")
            .outputs
            .get_mut(&crtc)
            .expect("the selected DRM device remains registered during this operation");
        // Preserve recovery of a requested final frame if another output
        // advances this animation to rest before the watchdog is dispatched.
        let active = enabled
            && (animating
                || (output.animation_fallback.waiting_for_frame()
                    && output.scheduler.has_pending_request()));
        let chained = output.render_timer.is_some() || output.frame_pending;
        if active && chained {
            backend.scheduling_metrics.chained_animation_observations += 1;
        }

        if let Some(deadline) = output.animation_fallback.deadline(
            now,
            refresh_duration_from_mode(output.mode),
            active && output.power.can_render(),
            chained,
        ) {
            fallbacks.push((node, crtc, deadline));
        }
    }

    fallbacks
}

// Pending buffers are events with deadlines, not visual animations. Recompute
// from current output identities and waits so commit, replacement and teardown
// cancel stale wakeups, including mirrored and sleeping outputs.
fn resize_deadlines(state: &Ferese) -> Vec<(Output, Instant)> {
    let Some(backend) = state
        .direct_backend
        .as_ref()
        .filter(|backend| backend.can_render())
    else {
        return Vec::new();
    };
    if state.session_lock.sleeping {
        return Vec::new();
    }
    backend
        .devices
        .values()
        .filter(|device| device.drm.is_active())
        .flat_map(|device| device.outputs.values())
        .filter(|output| output.power.can_render())
        .filter_map(|output| {
            let scene = backend.scene_output(state, &output.output);
            Some((
                output.output.clone(),
                state.start_time + state.output_resize_deadline(&scene)?,
            ))
        })
        .collect()
}

fn arm_animation_timer(state: &mut Ferese) {
    let deadline = animation_fallbacks(state)
        .iter()
        .map(|(_, _, deadline)| *deadline)
        .chain(
            resize_deadlines(state)
                .into_iter()
                .map(|(_, deadline)| deadline),
        )
        .min();
    let Some(backend) = state.direct_backend.as_mut() else {
        return;
    };
    if backend.animation_deadline == deadline {
        return;
    }

    if let Some(token) = backend.animation_timer.take() {
        state.loop_handle.remove(token);
        backend.scheduling_metrics.fallback_cancels += 1;
    }

    backend.animation_deadline = None;
    let Some(deadline) = deadline else {
        return;
    };
    match state
        .loop_handle
        .insert_source(Timer::from_deadline(deadline), |_, _, state| {
            if let Some(backend) = state.direct_backend.as_mut() {
                backend.animation_timer = None;
                backend.animation_deadline = None;
                backend.scheduling_metrics.fallback_wakes += 1;
            }

            let now = Instant::now();
            let expired_outputs = resize_deadlines(state)
                .into_iter()
                .filter_map(|(output, deadline)| (deadline <= now).then_some(output))
                .collect::<Vec<_>>();
            if !expired_outputs.is_empty() {
                // Retire waits before rearming, even if a DRM submission is
                // in flight. redraw advances the shared clock and requests the
                // released outputs plus any final animation frames elsewhere.
                render_on(state, &expired_outputs);
            }

            // Revalidate identities, power state, activity and normal frame chains
            // at dispatch. Disconnected/replaced outputs never get a stale request.
            for (node, crtc, deadline) in animation_fallbacks(state) {
                if deadline <= Instant::now() {
                    state
                        .direct_backend
                        .as_mut()
                        .expect("DRM callbacks require an installed direct backend")
                        .scheduling_metrics
                        .fallback_recoveries += 1;
                    state
                        .direct_backend
                        .as_mut()
                        .expect("DRM callbacks require an installed direct backend")
                        .devices
                        .get_mut(&node)
                        .expect(
                            "the selected DRM device must remain registered during this operation",
                        )
                        .outputs
                        .get_mut(&crtc)
                        .expect("the selected CRTC must remain registered during this operation")
                        .animation_fallback = AnimationFallback::default();
                    request_frame(state, node, crtc);
                }
            }

            arm_animation_timer(state);
            TimeoutAction::Drop
        }) {
        Ok(token) => {
            let backend = state
                .direct_backend
                .as_mut()
                .expect("DRM callbacks require an installed direct backend");
            backend.animation_timer = Some(token);
            backend.animation_deadline = Some(deadline);
            backend.scheduling_metrics.fallback_arms += 1;
        }

        Err(error) => tracing::warn!(%error, "could not schedule DRM animation fallback"),
    }
}

fn schedule_frame_callbacks(
    state: &mut Ferese,
    node: DrmNode,
    crtc: crtc::Handle,
    target: Duration,
) {
    if state.session_lock.sleeping {
        return;
    }

    let now = Instant::now();
    let timestamp = monotonic_now();
    let Some(output) = state
        .direct_backend
        .as_ref()
        .filter(|backend| backend.can_render())
        .and_then(|backend| backend.devices.get(&node))
        .filter(|device| device.drm.is_active())
        .and_then(|device| device.outputs.get(&crtc))
    else {
        return;
    };

    if output.mirror_source.is_some() || output.callback_timer.is_some() || output.frame_pending {
        return;
    }

    let identity = output.output.clone();
    let Some(callback_at) = output.scheduler.callback_deadline(timestamp, target) else {
        return;
    };

    if callback_at <= timestamp {
        deliver_frame_callbacks(state, node, crtc, &identity);
        return;
    }

    let deadline = now + callback_at.saturating_sub(timestamp);
    match state
        .loop_handle
        .insert_source(Timer::from_deadline(deadline), move |_, _, state| {
            deliver_frame_callbacks(state, node, crtc, &identity);
            TimeoutAction::Drop
        }) {
        Ok(token) => {
            if let Some(output) = state
                .direct_backend
                .as_mut()
                .and_then(|backend| backend.devices.get_mut(&node))
                .and_then(|device| device.outputs.get_mut(&crtc))
            {
                output.callback_timer = Some(token);
            }
        }

        Err(error) => tracing::warn!(%error, "could not schedule DRM frame callbacks"),
    }
}

fn deliver_frame_callbacks(
    state: &mut Ferese,
    node: DrmNode,
    crtc: crtc::Handle,
    identity: &Output,
) {
    let Some(backend) = state.direct_backend.as_mut() else {
        return;
    };

    let Some(device) = backend.devices.get_mut(&node) else {
        return;
    };

    let Some(output) = device
        .outputs
        .get_mut(&crtc)
        .filter(|output| &output.output == identity)
    else {
        return;
    };

    output.callback_timer = None;
    if !backend.active
        || backend.topology.reconciling
        || backend.lid.pending()
        || !device.drm.is_active()
        || !output.power.can_render()
        || state.session_lock.sleeping
        || output.frame_pending
    {
        return;
    }

    let timestamp = monotonic_now();
    let Some(next) = output.scheduler.callback_deadline(timestamp, timestamp) else {
        return;
    };

    if next > timestamp {
        schedule_frame_callbacks(state, node, crtc, next);
        return;
    }

    output.scheduler.callback_sent(timestamp);
    send_frame_callbacks(state, identity);
}

fn send_frame_callbacks(state: &mut Ferese, output: &Output) {
    let eligible = state.callback_outputs();
    if state.session_lock.active() {
        state.lock_frame_callbacks(output);
        return;
    }
    let visible_windows = state.space.elements().filter(|window| {
        state
            .windows
            .ids()
            .get(*window)
            .is_some_and(|id| state.window_belongs_to_output(*id, output))
    });
    for window in visible_windows {
        window.send_frame(output, state.start_time.elapsed(), None, |surface, _| {
            eligible.get(&surface.into()).cloned()
        });
    }
    let layers = layer_map_for_output(output)
        .layers()
        .cloned()
        .collect::<Vec<_>>();
    for layer in &layers {
        layer.send_frame(output, state.start_time.elapsed(), None, |surface, _| {
            eligible.get(&surface.into()).cloned()
        });
    }
    state.send_cursor_frame(output);
    state.space.refresh();
    state.popups.cleanup();
    layer_map_for_output(output).cleanup();
    if let Err(error) = state.display_handle.flush_clients() {
        tracing::debug!(%error, "failed to flush clients after DRM frame");
    }
}

fn select_outputs(
    device: &DirectDevice,
    monitors: &[Monitor],
    desired: &DesiredOutputConfiguration,
    low_power: bool,
) -> io::Result<OutputScan> {
    let drm = &device.drm;
    let resources = drm.resource_handles()?;
    let connected = resources
        .connectors()
        .iter()
        .map(|handle| drm.get_connector(*handle, true))
        .collect::<io::Result<Vec<_>>>()?
        .into_iter()
        .filter(|connector| connector.state() == connector::State::Connected)
        .collect::<Vec<_>>();
    let device_key = drm_device_key(drm);
    let mut selections = Vec::new();
    let mut connected_outputs = Vec::new();
    let mut candidates = Vec::new();
    let mut requests = Vec::new();

    for connector in connected {
        let key = format!("{device_key}/{}", connector);
        let monitor = monitors
            .iter()
            .find(|monitor| monitor.key == key)
            .ok_or_else(|| io::Error::other("connector topology changed during reconciliation"))?;
        let desired_output = desired
            .outputs
            .iter()
            .find(|output| output.key == key)
            .ok_or_else(|| io::Error::other("connector missing from desired configuration"))?;
        let identity = monitor.identity.clone();
        let settings = desired_output.settings.clone();
        let selected_mode = settings
            .enabled
            .then(|| {
                let normal = select_mode(&connector, settings.mode)?;
                if settings.auto_refresh && low_power {
                    let modes = connector
                        .modes()
                        .iter()
                        .map(|mode| {
                            let (width, height) = mode.size();
                            (width, height, OutputMode::from(*mode).refresh)
                        })
                        .collect::<Vec<_>>();
                    super::power::low_refresh_mode(normal.size(), &modes)
                        .map(|index| connector.modes()[index])
                        .or(Some(normal))
                } else {
                    Some(normal)
                }
            })
            .flatten();
        if settings.enabled && selected_mode.is_none() && settings.mode.is_some() {
            return Err(io::Error::other(format!(
                "requested mode for {} is unavailable",
                connector
            )));
        }
        if let Some(mode) = selected_mode {
            let size =
                output_transform(settings.transform).transform_size(OutputMode::from(mode).size);
            let width = (size.w as f64 / settings.scale).round();
            let height = (size.h as f64 / settings.scale).round();
            if width < 1.0 || height < 1.0 || width > i32::MAX as f64 || height > i32::MAX as f64 {
                return Err(io::Error::other(format!(
                    "scale for {} creates invalid logical geometry",
                    connector
                )));
            }
            if let Some([x, y]) = settings.position
                && (x.checked_add(width as i32).is_none() || y.checked_add(height as i32).is_none())
            {
                return Err(io::Error::other(format!(
                    "position for {} overflows logical geometry",
                    connector
                )));
            }
        }
        connected_outputs.push(ConnectedOutputInfo {
            connector: connector.to_string(),
            connected: true,
            identity: identity.clone(),
            internal: monitor.internal,
            requested_enabled: settings.enabled,
            mirror_source: desired_output.mirror_source.clone(),
            enabled: settings.enabled,
            profile: desired.profile.clone(),
            requested_profile: desired.profile.clone(),
            auto_refresh: settings.auto_refresh,
            physical_size: connector.size(),
            current_mode: selected_mode.map(connected_mode_info),
            available_modes: connector
                .modes()
                .iter()
                .copied()
                .map(connected_mode_info)
                .collect(),
            scale: settings.scale,
            transform: settings.transform,
            configured_position: settings.position,
        });
        if !settings.enabled {
            tracing::info!(output = %connector, "output disabled by active profile");
            continue;
        }
        let Some(mode) = selected_mode else {
            continue;
        };

        let applied = device
            .outputs
            .iter()
            .find(|(_, output)| output.connector == connector.handle())
            .map(|(crtc, _)| *crtc);
        let kernel = connector
            .current_encoder()
            .and_then(|handle| drm.get_encoder(handle).ok())
            .and_then(|encoder| encoder.crtc());
        let mut compatible = Vec::new();
        for handle in connector.encoders() {
            if let Ok(encoder) = drm.get_encoder(*handle) {
                for crtc in resources.filter_crtcs(encoder.possible_crtcs()) {
                    if !compatible.contains(&crtc) {
                        compatible.push(crtc);
                    }
                }
            }
        }
        requests.push(crtc_assignment::Candidates {
            applied,
            kernel,
            compatible,
        });
        candidates.push((
            connector,
            mode,
            settings,
            identity,
            desired_output.mirror_source.clone(),
        ));
    }

    for ((connector, mode, settings, identity, mirror_source), crtc) in candidates
        .into_iter()
        .zip(crtc_assignment::assign(&requests))
    {
        if let Some(crtc) = crtc {
            selections.push(OutputSelection {
                connector,
                crtc,
                mode,
                settings,
                identity,
                mirror_source,
            });
        }
    }

    let prefix = format!("{device_key}/");
    let selected = selections
        .iter()
        .map(|selection| format!("{prefix}{}", selection.connector))
        .collect::<Vec<_>>();
    // Also guard the rescan immediately before applying a device transaction:
    // hotplug can invalidate the earlier configuration-wide validation.
    validate_selected_outputs(
        desired
            .outputs
            .iter()
            .filter(|output| output.key.starts_with(&prefix)),
        &selected,
    )
    .map_err(io::Error::other)?;

    selections.sort_by_key(|selection| selection.settings.position.is_none());
    Ok(OutputScan {
        selections,
        connected_outputs,
    })
}

fn connected_mode_info(mode: DrmMode) -> ConnectedModeInfo {
    let (width, height) = mode.size();
    ConnectedModeInfo {
        width,
        height,
        refresh_millihertz: OutputMode::from(mode).refresh,
        preferred: mode.mode_type().contains(ModeTypeFlags::PREFERRED),
    }
}

fn select_mode(
    connector: &connector::Info,
    requested: Option<OutputModeRequest>,
) -> Option<DrmMode> {
    let fallback = || {
        connector
            .modes()
            .iter()
            .find(|mode| mode.mode_type().contains(ModeTypeFlags::PREFERRED))
            .or_else(|| connector.modes().first())
            .copied()
    };
    let Some(requested) = requested else {
        return fallback();
    };

    let matching = connector
        .modes()
        .iter()
        .filter(|mode| mode.size() == (requested.width, requested.height));
    if let Some(refresh) = requested.refresh_millihertz {
        matching
            .min_by_key(|mode| {
                OutputMode::from(**mode)
                    .refresh
                    .unsigned_abs()
                    .abs_diff(refresh)
            })
            .filter(|mode| {
                OutputMode::from(**mode)
                    .refresh
                    .unsigned_abs()
                    .abs_diff(refresh)
                    <= 1_000
            })
            .copied()
    } else {
        matching
            .max_by_key(|mode| OutputMode::from(**mode).refresh)
            .copied()
    }
}

fn create_direct_output(
    state: &mut Ferese,
    drm: &mut DrmDevice,
    gbm: &GbmDevice<DrmDeviceFd>,
    renderer: &GlesRenderer,
    selection: OutputSelection,
    publish: bool,
) -> Result<DirectOutput, Box<dyn Error>> {
    let OutputSelection {
        connector,
        crtc,
        mode,
        settings,
        identity,
        mirror_source,
    } = selection;
    let drm_surface = drm.create_surface(crtc, mode, &[connector.handle()])?;
    let allocator = GbmAllocator::new(
        gbm.clone(),
        GbmBufferFlags::RENDERING | GbmBufferFlags::SCANOUT,
    );
    let node = DrmNode::from_file(gbm.as_fd())?;
    let render_node = node
        .node_with_type(NodeType::Render)
        .and_then(Result::ok)
        .unwrap_or(node);
    let mut surface = DrmCompositor::new(
        OutputModeSource::Static {
            size: OutputMode::from(mode).size,
            scale: settings.scale.into(),
            transform: output_transform(settings.transform),
        },
        drm_surface,
        None,
        allocator,
        GbmFramebufferExporter::new(gbm.clone(), Some(render_node).into()),
        [Fourcc::Argb8888, Fourcc::Abgr8888],
        renderer.dmabuf_formats(),
        drm.cursor_size(),
        Some(gbm.clone()),
    )?;
    // Publish only after DRM/GBM creation succeeds; failed activation must not
    // leave a phantom output/workspace that could receive evacuated windows.
    let (output, global) = create_output(
        state,
        &connector,
        mode,
        identity.clone(),
        &settings,
        publish && mirror_source.is_none(),
    );
    surface.set_output_mode_source((&output).into());
    let render_metrics = RenderMetrics::from_environment(output.name());
    let diagnostics = Diagnostics::from_environment(output.name());
    let dmabuf_feedback = feedback::OutputFeedback::new(
        render_node.dev_id(),
        node.dev_id(),
        renderer.dmabuf_formats(),
        surface.surface().plane_info().formats.clone(),
    );

    tracing::info!(?crtc, connector = %connector, "initialized DRM output");
    Ok(DirectOutput {
        gamma: Default::default(),
        internal: internal_connector(connector.interface()),
        connector: connector.handle(),
        mode,
        settings: settings.clone(),
        output,
        global,
        identity,
        mirror_source,
        mirror_texture: None,
        mirror_capture_texture: Default::default(),
        mirror_canvas: None,
        mirror_id: smithay::backend::renderer::element::Id::new(),
        mirror_commit: CommitCounter::default(),
        surface,
        primary_commit: None,
        capture_texture: Default::default(),
        render_metrics,
        diagnostics,
        dmabuf_feedback,
        frame_pending: false,
        completion: Default::default(),
        completion_timer: None,
        animation_fallback: AnimationFallback::default(),
        cursor_visible: false,
        power: OutputPower::default(),
        scheduler: crate::frame_scheduler::FrameScheduler::new(refresh_duration_from_mode(mode)),
        render_timer: None,
        callback_timer: None,
        lock_frame_pending: false,
    })
}

fn create_output(
    state: &mut Ferese,
    connector: &connector::Info,
    mode: DrmMode,
    identity: String,
    settings: &OutputSettings,
    publish: bool,
) -> (Output, Option<GlobalId>) {
    let name = connector.to_string();
    let physical_size = connector.size().unwrap_or((0, 0));
    let edid_identity = identity
        .strip_prefix("edid:")
        .map(|value| value.split(':').collect::<Vec<_>>());
    let output = Output::new(
        name,
        PhysicalProperties {
            serial_number: String::new(),
            size: (physical_size.0 as i32, physical_size.1 as i32).into(),
            subpixel: Subpixel::from(connector.subpixel()),
            make: edid_identity
                .as_ref()
                .and_then(|parts| parts.first())
                .copied()
                .unwrap_or("Unknown")
                .into(),
            model: edid_identity
                .as_ref()
                .and_then(|parts| parts.get(1))
                .copied()
                .unwrap_or("Unknown")
                .into(),
        },
    );
    let output_mode = OutputMode::from(mode);

    let global = publish.then(|| output.create_global::<Ferese>(&state.display_handle));
    for mode in connector.modes().iter().copied().map(OutputMode::from) {
        output.add_mode(mode);
    }
    output.set_preferred(output_mode);
    let position = settings.position.unwrap_or_else(|| {
        let x = state
            .space
            .outputs()
            .filter_map(|output| state.space.output_geometry(output))
            .map(|geometry| geometry.loc.x + geometry.size.w)
            .max()
            .unwrap_or(0);
        [x, 0]
    });
    output.change_current_state(
        Some(output_mode),
        Some(output_transform(settings.transform)),
        Some(Scale::Fractional(settings.scale)),
        Some((position[0], position[1]).into()),
    );
    if publish {
        state.space.map_output(&output, (position[0], position[1]));
        state.register_output(&output, identity);
    }
    (output, global)
}

fn output_transform(transform: OutputTransform) -> Transform {
    match transform {
        OutputTransform::Normal => Transform::Normal,
        OutputTransform::Rotate90 => Transform::_90,
        OutputTransform::Rotate180 => Transform::_180,
        OutputTransform::Rotate270 => Transform::_270,
        OutputTransform::Flipped => Transform::Flipped,
        OutputTransform::Flipped90 => Transform::Flipped90,
        OutputTransform::Flipped180 => Transform::Flipped180,
        OutputTransform::Flipped270 => Transform::Flipped270,
    }
}

fn connector_edid(drm: &DrmDevice, connector: &connector::Info) -> Option<Vec<u8>> {
    drm.get_properties(connector.handle())
        .ok()
        .and_then(|properties| {
            properties.iter().find_map(|(handle, raw)| {
                let info = drm.get_property(*handle).ok()?;
                if info.name().to_bytes() != b"EDID" {
                    return None;
                }
                match info.value_type().convert_value(*raw) {
                    property::Value::Blob(blob) if blob != 0 => drm.get_property_blob(blob).ok(),
                    _ => None,
                }
            })
        })
}

fn drm_device_key(drm: &DrmDevice) -> String {
    let node = DrmNode::from_file(drm.as_fd()).expect("DRM descriptor has a device identity");
    let path = node
        .dev_path()
        .and_then(|path| {
            path.file_name()
                .map(|name| Path::new("/sys/class/drm").join(name).join("device"))
        })
        .and_then(|path| std::fs::canonicalize(path).ok());
    path.map_or_else(
        || format!("gpu-{}", node.dev_id()),
        |path| path.to_string_lossy().into_owned(),
    )
}

fn resolve_output_positions(
    backend: &DirectBackendState,
    desired: &mut DesiredOutputConfiguration,
) -> Result<(), String> {
    let mut placements = Vec::new();
    for device in backend.devices.values() {
        let scan = select_outputs(device, &backend.monitors, desired, backend.low_power)
            .map_err(|error| error.to_string())?;
        for selection in scan.selections {
            let size = output_transform(selection.settings.transform)
                .transform_size(OutputMode::from(selection.mode).size);
            let key = format!("{}/{}", drm_device_key(&device.drm), selection.connector);
            let previous = device
                .outputs
                .values()
                .find(|output| output.identity == selection.identity)
                .filter(|output| output.mirror_source.is_none())
                .map(|output| {
                    let position = output.output.current_location();
                    [position.x, position.y]
                });
            placements.push(crate::output_policy::Placement {
                key,
                size: (
                    (size.w as f64 / selection.settings.scale).round() as i32,
                    (size.h as f64 / selection.settings.scale).round() as i32,
                ),
                previous,
            });
        }
    }
    crate::output_policy::arrange_positions(desired, &placements)
}

fn refresh_monitor_policy(state: &mut Ferese) -> Result<(), String> {
    let backend = state
        .direct_backend
        .as_mut()
        .ok_or("direct backend unavailable")?;
    let mut discovered = Vec::new();
    for device in backend.devices.values() {
        let drm = &device.drm;
        let key = drm_device_key(drm);
        for handle in drm
            .resource_handles()
            .map_err(|error| error.to_string())?
            .connectors()
        {
            let connector = drm
                .get_connector(*handle, true)
                .map_err(|error| error.to_string())?;
            if connector.state() != connector::State::Connected {
                continue;
            }
            let edid = connector_edid(drm, &connector);
            discovered.push((format!("{key}/{}", connector), connector, edid));
        }
    }
    discovered.sort_by(|a, b| a.0.cmp(&b.0));
    let identities = backend.identities.resolve(
        &discovered
            .iter()
            .map(|(key, _, edid)| (key.clone(), edid.as_deref().and_then(Identity::from_edid)))
            .collect::<Vec<_>>(),
    );
    backend.monitors = discovered
        .into_iter()
        .zip(identities)
        .map(|((key, connector, edid), identity)| {
            let mut aliases = vec![format!("drm:{connector}")];
            if let Some(edid) = edid {
                aliases.push(format!("drm-edid:{:016x}", stable_hash(&edid)));
            }
            Monitor {
                key,
                identity,
                connector: connector.to_string(),
                aliases,
                internal: internal_connector(connector.interface()),
                usable: !connector.modes().is_empty(),
            }
        })
        .collect();
    if backend.confirmation.is_some() {
        let previous_keys = backend
            .applied_outputs
            .outputs
            .iter()
            .map(|output| &output.key)
            .collect::<HashSet<_>>();
        let current_keys = backend
            .monitors
            .iter()
            .map(|monitor| &monitor.key)
            .collect::<HashSet<_>>();
        if previous_keys != current_keys || backend.confirmation_lid != backend.lid.closed() {
            backend.confirmation = None;
            if let Some(token) = backend.confirmation_timer.take() {
                state.loop_handle.remove(token);
            }
        }
    }
    let previous_override = (
        backend.manual_outputs.profile.clone(),
        backend.manual_outputs.internal,
        backend.manual_outputs.layout,
    );
    backend.manual_outputs.observe(
        &backend.monitors,
        backend.lid.closed(),
        &state.output_profiles,
    );
    if previous_override
        != (
            backend.manual_outputs.profile.clone(),
            backend.manual_outputs.internal,
            backend.manual_outputs.layout,
        )
    {
        backend.confirmation = None;
        if let Some(token) = backend.confirmation_timer.take() {
            state.loop_handle.remove(token);
        }
    }
    let mut desired = crate::output_policy::select_profile(
        &backend.monitors,
        backend.lid.closed(),
        &state.output_profiles,
        &backend.manual_outputs,
    );
    resolve_output_positions(backend, &mut desired)?;
    tracing::debug!(profile = ?desired.profile, changed = ?crate::output_policy::changed_outputs(&backend.desired_outputs, &desired), "selected monitor configuration");
    if let Some(previous) = backend.revert_outputs.take() {
        desired = crate::output_policy::restore_configuration(&previous, &backend.monitors);
        resolve_output_positions(backend, &mut desired)?;
    }
    backend.desired_outputs = desired;
    Ok(())
}

fn stable_hash(bytes: &[u8]) -> u64 {
    const FNV_OFFSET: u64 = 0xcbf2_9ce4_8422_2325;
    const FNV_PRIME: u64 = 0x0000_0100_0000_01b3;

    bytes.iter().fold(FNV_OFFSET, |hash, byte| {
        (hash ^ u64::from(*byte)).wrapping_mul(FNV_PRIME)
    })
}

impl DirectBackendState {
    pub fn record_presentation(
        &mut self,
        node: DrmNode,
        crtc: crtc::Handle,
        time: DrmEventTime,
        sequence: u32,
    ) -> Option<Duration> {
        let missed = self
            .devices
            .get(&node)
            .and_then(|device| device.outputs.get(&crtc))
            .map_or(0, |output| output.scheduler.missed_deadlines);
        self.presentation.get_mut(&(node, crtc)).and_then(|clock| {
            clock.missed_deadlines = missed;
            clock.record(time, sequence)
        })
    }
}

impl PresentationClock {
    fn reset_timing(&mut self) {
        self.last_presentation = None;
    }

    fn set_refresh(&mut self, refresh_millihertz: i32) {
        if refresh_millihertz > 0 {
            self.refresh_interval = Some(Duration::from_nanos(
                1_000_000_000_000_u64 / refresh_millihertz as u64,
            ));
        }
    }

    fn record(&mut self, time: DrmEventTime, sequence: u32) -> Option<Duration> {
        let DrmEventTime::Monotonic(time) = time else {
            tracing::warn!(
                sequence,
                "DRM driver reported a realtime page-flip timestamp"
            );
            return None;
        };
        let delta = self
            .last_presentation
            .map(|previous| time.saturating_sub(previous));

        self.last_presentation = Some(time);
        self.presented_frames = self.presented_frames.saturating_add(1);
        delta
    }
}

#[cfg(test)]
mod tests {
    use std::time::SystemTime;

    use super::*;

    fn three_monitor_plan(layout: crate::config::OutputLayout) -> DesiredOutputConfiguration {
        let monitors = ["A", "B", "C"].map(|key| Monitor {
            key: key.into(),
            connector: key.into(),
            identity: key.into(),
            aliases: vec![],
            internal: key == "A",
            usable: true,
        });
        let profile = OutputProfile {
            name: "three".into(),
            outputs: monitors
                .iter()
                .map(|monitor| crate::output_policy::defaults(monitor.key.clone()))
                .collect(),
            layout,
            confirm_timeout: 15,
            lid_policy: crate::config::LidPolicy::Ignore,
            lid_closed: None,
            mirror_source: None,
        };
        crate::output_policy::select_profile(
            &monitors,
            false,
            &[profile],
            &ManualOverride::default(),
        )
    }

    #[test]
    fn complete_live_plan_still_requires_hardware_success() {
        let desired = three_monitor_plan(crate::config::OutputLayout::Extend);
        let selected = vec!["A".into(), "B".into(), "C".into()];
        assert!(validate_output_plan(&desired, &selected, || Ok(())).is_ok());
        assert_eq!(
            validate_output_plan(
                &desired,
                &selected,
                || Err("atomic TEST_ONLY failed".into())
            ),
            Err("atomic TEST_ONLY failed".into())
        );
    }

    #[test]
    fn requiredness_does_not_allow_a_connected_enabled_output_to_be_omitted() {
        let mut desired = three_monitor_plan(crate::config::OutputLayout::Extend);
        desired.outputs[2].settings.required = false;
        let error =
            validate_output_plan(&desired, &["A".into(), "B".into()], || Ok(())).unwrap_err();
        assert!(error.contains("C"));
        desired.outputs[2].settings.enabled = false;
        assert!(validate_output_plan(&desired, &["A".into(), "B".into()], || Ok(())).is_ok());
    }

    #[test]
    fn disconnected_monitors_affect_profile_matching_and_do_not_need_assignments() {
        let connected = ["A", "B"].map(|key| Monitor {
            key: key.into(),
            connector: key.into(),
            identity: key.into(),
            aliases: vec![],
            internal: key == "A",
            usable: true,
        });
        let mut profile = OutputProfile {
            name: "dock".into(),
            outputs: ["A", "B", "C"]
                .map(|key| crate::output_policy::defaults(key.into()))
                .into(),
            layout: crate::config::OutputLayout::Extend,
            confirm_timeout: 15,
            lid_policy: crate::config::LidPolicy::Ignore,
            lid_closed: None,
            mirror_source: None,
        };
        for required in [true, false] {
            profile.outputs[2].required = required;
            let desired = crate::output_policy::select_profile(
                &connected,
                false,
                &[profile.clone()],
                &ManualOverride::default(),
            );
            assert_eq!(
                desired.profile.as_deref(),
                if required { None } else { Some("dock") }
            );
            assert_eq!(desired.outputs.len(), 2);
            assert!(validate_output_plan(&desired, &["A".into(), "B".into()], || Ok(())).is_ok());
        }
    }

    #[test]
    fn device_scans_cannot_satisfy_another_gpus_missing_output() {
        let mut desired = three_monitor_plan(crate::config::OutputLayout::Extend);
        desired.outputs[0].key = "gpu-one/A".into();
        desired.outputs[1].key = "gpu-two/B".into();
        desired.outputs[2].key = "gpu-two/C".into();
        let selected = vec!["gpu-one/A".into(), "gpu-two/B".into(), "gpu-one/C".into()];
        assert!(validate_output_plan(&desired, &selected, || Ok(())).is_err());
        // A device-local rescan checks only its own enabled outputs.
        assert!(
            validate_selected_outputs(
                desired
                    .outputs
                    .iter()
                    .filter(|output| output.key.starts_with("gpu-one/")),
                &selected
            )
            .is_ok()
        );
    }

    #[test]
    fn impossible_assignment_reaches_live_validation_as_an_error() {
        let desired = three_monitor_plan(crate::config::OutputLayout::Extend);
        let crtc = std::num::NonZeroU32::new(1).unwrap().into();
        let requests = (0..3)
            .map(|_| crtc_assignment::Candidates {
                applied: None,
                kernel: None,
                compatible: vec![crtc],
            })
            .collect::<Vec<_>>();
        let selected = desired
            .outputs
            .iter()
            .zip(crtc_assignment::assign(&requests))
            .filter(|(_, assignment)| assignment.is_some())
            .map(|(output, _)| output.key.clone())
            .collect::<Vec<_>>();
        assert!(validate_output_plan(&desired, &selected, || Ok(())).is_err());
    }

    #[test]
    fn feasible_three_monitor_assignment_passes_live_plan_validation() {
        let desired = three_monitor_plan(crate::config::OutputLayout::Extend);
        let requests =
            [&[1, 2][..], &[1, 3][..], &[1, 3][..]].map(|compatible| crtc_assignment::Candidates {
                applied: None,
                kernel: None,
                compatible: compatible
                    .iter()
                    .map(|value| std::num::NonZeroU32::new(*value).unwrap().into())
                    .collect(),
            });
        let selected = desired
            .outputs
            .iter()
            .zip(crtc_assignment::assign(&requests))
            .filter(|(_, assignment)| assignment.is_some())
            .map(|(output, _)| output.key.clone())
            .collect::<Vec<_>>();
        assert_eq!(selected.len(), 3);
        assert!(validate_output_plan(&desired, &selected, || Ok(())).is_ok());
    }

    #[test]
    fn live_plan_rejects_partial_extend_and_mirror_before_hardware_validation() {
        for layout in [
            crate::config::OutputLayout::Extend,
            crate::config::OutputLayout::Mirror,
        ] {
            let desired = three_monitor_plan(layout);
            for omitted in ["A", "B", "C"] {
                let selected = ["A", "B", "C"]
                    .into_iter()
                    .filter(|key| *key != omitted)
                    .map(String::from)
                    .collect::<Vec<_>>();
                let probed = std::cell::Cell::new(false);
                let result = validate_output_plan(&desired, &selected, || {
                    probed.set(true);
                    Ok(()) // A driver can accept the incomplete two-output request.
                });
                assert!(
                    result.is_err(),
                    "accepted a partial {layout:?} configuration without {omitted}"
                );
                assert!(!probed.get());
            }
        }
    }

    #[test]
    fn repeated_unconfirmed_changes_keep_original_rollback_and_manual_state() {
        let a = ("confirmed A", "automatic");
        let b = confirmation_baseline(None, a);
        let c = confirmation_baseline(Some(b), ("unconfirmed B", "profile B"));
        assert_eq!(c, a);
        let d = confirmation_baseline(Some(c), ("unconfirmed C", "profile C"));
        assert_eq!(d, a);
        assert_eq!(
            confirmation_baseline(None, ("confirmed C", "profile C")),
            ("confirmed C", "profile C")
        );
    }

    #[test]
    fn lid_only_hides_panels_with_a_usable_external_output() {
        assert!(lid_hides_panel(true, true));
        assert!(!lid_hides_panel(false, true));
        assert!(!lid_hides_panel(true, false));
        assert!(!lid_hides_panel(false, false));
    }

    #[test]
    fn panel_detection_uses_connector_type_not_monitor_name() {
        assert!(internal_connector(
            connector::Interface::EmbeddedDisplayPort
        ));
        assert!(internal_connector(connector::Interface::LVDS));
        assert!(internal_connector(connector::Interface::DSI));
        assert!(!internal_connector(connector::Interface::HDMIA));
        assert!(!internal_connector(connector::Interface::DisplayPort));
    }

    #[test]
    fn connector_identity_hash_is_stable() {
        assert_eq!(stable_hash(b"hello"), 0xa430_d846_80aa_bd0b);
    }

    #[test]
    fn presentation_clock_uses_measured_monotonic_deltas() {
        let mut clock = PresentationClock::default();
        clock.set_refresh(60_000);

        assert_eq!(
            clock.record(DrmEventTime::Monotonic(Duration::from_millis(100)), 1),
            None
        );
        assert_eq!(
            clock.record(DrmEventTime::Monotonic(Duration::from_millis(116)), 2),
            Some(Duration::from_millis(16))
        );
        assert_eq!(clock.presented_frames, 2);
        assert_eq!(clock.missed_deadlines, 0);
    }

    #[test]
    fn presentation_clock_rejects_realtime_timestamps() {
        let mut clock = PresentationClock::default();

        assert_eq!(
            clock.record(DrmEventTime::Realtime(SystemTime::now()), 1),
            None
        );
        assert_eq!(clock.presented_frames, 0);
    }

    #[test]
    fn presentation_clock_does_not_count_idle_gaps_as_missed_deadlines() {
        let mut clock = PresentationClock::default();
        clock.set_refresh(60_000);

        clock.record(DrmEventTime::Monotonic(Duration::ZERO), 1);
        clock.record(DrmEventTime::Monotonic(Duration::from_millis(50)), 2);

        assert_eq!(clock.missed_deadlines, 0);
    }

    #[test]
    fn presentation_clock_excludes_inactive_session_time() {
        let mut clock = PresentationClock::default();
        clock.set_refresh(60_000);
        clock.record(DrmEventTime::Monotonic(Duration::from_millis(100)), 1);

        clock.reset_timing();

        assert_eq!(
            clock.record(DrmEventTime::Monotonic(Duration::from_secs(10)), 2),
            None
        );
        assert_eq!(clock.presented_frames, 2);
        assert_eq!(clock.missed_deadlines, 0);
    }
}