zng-ext-window 0.13.0

use core::fmt;
use std::sync::Arc;

use zng_app::event::{event, event_args};
use zng_app::view_process::raw_events::RAW_MONITORS_CHANGED_EVENT;
use zng_app::window::{MonitorId, WindowId};
use zng_app_context::app_local;
use zng_layout::unit::{
    Dip, DipRect, DipSize, DipToPx, Factor, FactorUnits, Frequency, FrequencyUnits as _, Px, PxDensity, PxPoint, PxRect, PxSize, PxToDip,
};
use zng_txt::{ToTxt, Txt};
use zng_unique_id::IdMap;
use zng_var::{Var, VarValue, impl_from_and_into_var, var};
use zng_view_api::window::VideoMode;

use crate::WINDOWS;

app_local! {
    static MONITORS_SV: MonitorsService = MonitorsService::new();
}

/// Monitors service.
///
/// List monitor screens and configure the pixel density of a given monitor.
///
/// # Uses
///
/// Uses of this service:
///
/// #### Start Position
///
/// Windows are positioned on a virtual screen that overlaps all monitors, but all position configuration is done relative to
/// an specific parent monitor, it is important to track the parent monitor as it defines properties that affect the layout of the window.
/// This service is used to provide information to implement this feature.
///
/// #### Fullscreen
///
/// To set a window to fullscreen a monitor must be selected, by default it can be the one the window is at but
/// the users may want to select a monitor. To enter fullscreen exclusive the video mode must also be decided, all video
/// modes supported by the monitor are available in the [`MonitorInfo`] value.
///
/// #### Real-Size Preview
///
/// Some apps, like image editors, may implement a feature where the user can preview the *real* dimensions of
/// the content they are editing, to accurately implement this you must known the real dimensions of the monitor screen,
/// unfortunately this information is not provided by display drivers. You can ask the user to measure their screen and
/// set the pixel density for the screen using the [`density`] variable, this value is then available in the [`LayoutMetrics`]
/// for the next layout. If not set, the default is `96.0ppi`.
///
/// [`density`]: MonitorInfo::density
/// [`scale_factor`]: MonitorInfo::scale_factor
/// [`LayoutMetrics`]: zng_layout::context::LayoutMetrics
pub struct MONITORS;
impl MONITORS {
    /// Get monitor info.
    ///
    /// Returns `None` if the monitor was not found or the app is running in headless mode without renderer.
    pub fn monitor(&self, monitor_id: MonitorId) -> Option<MonitorInfo> {
        MONITORS_SV.read().monitors.with(|m| m.get(&monitor_id).cloned())
    }

    /// List all available monitors.
    ///
    /// Is empty if no monitor was found or the app is running in headless mode without renderer.
    pub fn available_monitors(&self) -> Var<Vec<MonitorInfo>> {
        MONITORS_SV.read().monitors.map(|w| {
            let mut list: Vec<_> = w.values().cloned().collect();
            list.sort_by(|a, b| a.name.with(|a| b.name.with(|b| a.cmp(b))));
            list
        })
    }

    /// Gets the monitor info marked as primary.
    pub fn primary_monitor(&self) -> Var<Option<MonitorInfo>> {
        MONITORS_SV
            .read()
            .monitors
            .map(|w| w.values().find(|m| m.is_primary().get()).cloned())
    }
}

struct MonitorsService {
    monitors: Var<IdMap<MonitorId, MonitorInfo>>,
}
impl MonitorsService {
    fn new() -> Self {
        // track monitor scale factors
        #[allow(deprecated)]
        zng_app::view_process::raw_events::RAW_SCALE_FACTOR_CHANGED_EVENT
            .hook(|args| {
                MONITORS_SV.read().monitors.with(|a| {
                    if let Some(m) = a.get(&args.monitor_id) {
                        tracing::trace!("monitor scale factor changed, {:?} {:?}", args.monitor_id, args.scale_factor);
                        m.scale_factor.set(args.scale_factor);
                    }
                });
                true
            })
            .perm();

        // track monitors
        RAW_MONITORS_CHANGED_EVENT
            .hook(|args| {
                let mut available_monitors: IdMap<_, _> = args.available_monitors.iter().cloned().collect();
                let event_ts = args.timestamp;
                let event_propagation = args.propagation.clone();

                MONITORS_SV.read().monitors.modify(move |m| {
                    let mut removed = vec![];
                    let mut changed = vec![];

                    m.retain(|key, value| {
                        if let Some(new) = available_monitors.remove(key) {
                            if value.update(new) {
                                tracing::trace!(
                                    "monitor update, {:?} {:?}",
                                    key,
                                    (&value.name.get(), value.position.get(), value.size.get(), value.density.get())
                                );
                                changed.push(*key);
                            }
                            true
                        } else {
                            tracing::trace!(
                                "monitor removed, {:?} {:?}",
                                key,
                                (&value.name.get(), value.position.get(), value.size.get(), value.density.get())
                            );
                            removed.push(*key);
                            false
                        }
                    });

                    let mut added = Vec::with_capacity(available_monitors.len());

                    for (id, info) in available_monitors {
                        added.push(id);
                        tracing::trace!(
                            "monitor added, {:?} {:?}",
                            id,
                            (&info.name, info.position, info.size, info.scale_factor)
                        );
                        m.insert(id, MonitorInfo::from_gen(id, info));
                    }

                    if !removed.is_empty() || !added.is_empty() || !changed.is_empty() {
                        let args = MonitorsChangedArgs::new(event_ts, event_propagation, removed, added, changed);
                        MONITORS_CHANGED_EVENT.notify(args);
                    }
                });
                true
            })
            .perm();

        Self {
            monitors: var(IdMap::new()),
        }
    }
}

/// "Monitor" configuration used by windows in [headless mode].
///
/// [headless mode]: zng_app::window::WindowMode::is_headless
#[derive(Clone, Copy, PartialEq)]
#[non_exhaustive]
pub struct HeadlessMonitor {
    /// The scale factor used for the headless layout and rendering.
    ///
    /// If set to `None`, falls back to the [`parent`] scale-factor, or `1.0` if the headless window has not parent.
    ///
    /// `None` by default.
    ///
    /// [`parent`]: crate::WindowVars::parent
    pub scale_factor: Option<Factor>,

    /// Size of the imaginary monitor screen that contains the headless window.
    ///
    /// This is used to calculate relative lengths in the window size definition and is defined in
    /// layout pixels instead of device like in a real monitor info.
    ///
    /// `(11608, 8708)` by default.
    pub size: DipSize,

    /// Pixel density used for the headless layout and rendering.
    pub density: PxDensity,
}
impl fmt::Debug for HeadlessMonitor {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        if f.alternate() || self.density != PxDensity::default() {
            f.debug_struct("HeadlessMonitor")
                .field("scale_factor", &self.scale_factor)
                .field("screen_size", &self.size)
                .field("density", &self.density)
                .finish()
        } else {
            write!(f, "({:?}, ({}, {}))", self.scale_factor, self.size.width, self.size.height)
        }
    }
}
impl HeadlessMonitor {
    /// New with custom size at `None` scale.
    pub fn new(size: DipSize) -> Self {
        HeadlessMonitor {
            scale_factor: None,
            size,
            density: PxDensity::default(),
        }
    }

    /// New with custom size and scale.
    pub fn new_scaled(size: DipSize, scale_factor: Factor) -> Self {
        HeadlessMonitor {
            scale_factor: Some(scale_factor),
            size,
            density: PxDensity::default(),
        }
    }

    /// New with default size `(11608, 8708)` and custom scale.
    pub fn new_scale(scale_factor: Factor) -> Self {
        HeadlessMonitor {
            scale_factor: Some(scale_factor),
            ..Self::default()
        }
    }
}
impl Default for HeadlessMonitor {
    /// New `(1920, 1080)` at `None` scale.
    fn default() -> Self {
        (1920, 1080).into()
    }
}
impl_from_and_into_var! {
    fn from<W: Into<Dip>, H: Into<Dip>>((width, height): (W, H)) -> HeadlessMonitor {
        HeadlessMonitor::new(DipSize::new(width.into(), height.into()))
    }
    fn from<W: Into<Dip>, H: Into<Dip>, F: Into<Factor>>((width, height, scale): (W, H, F)) -> HeadlessMonitor {
        HeadlessMonitor::new_scaled(DipSize::new(width.into(), height.into()), scale.into())
    }
}

/// All information about a monitor that [`MONITORS`] can provide.
#[derive(Clone)]
pub struct MonitorInfo {
    id: MonitorId,
    is_primary: Var<bool>,
    name: Var<Txt>,
    position: Var<PxPoint>,
    size: Var<PxSize>,
    video_modes: Var<Vec<VideoMode>>,
    scale_factor: Var<Factor>,
    density: Var<PxDensity>,
    refresh_rate: Var<Frequency>,
}
impl fmt::Debug for MonitorInfo {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        f.debug_struct("MonitorInfo")
            .field("id", &self.id)
            .field("name", &self.name.get())
            .field("position", &self.position.get())
            .field("size", &self.size.get())
            .field("refresh_rate", &self.refresh_rate.get())
            .finish_non_exhaustive()
    }
}
impl PartialEq for MonitorInfo {
    fn eq(&self, other: &Self) -> bool {
        self.id == other.id && self.name.var_eq(&other.name)
    }
}
impl MonitorInfo {
    /// New from a [`zng_view_api::MonitorInfo`].
    fn from_gen(id: MonitorId, info: zng_view_api::window::MonitorInfo) -> Self {
        MonitorInfo {
            id,
            is_primary: var(info.is_primary),
            name: var(info.name.to_txt()),
            position: var(info.position),
            size: var(info.size),
            scale_factor: var(info.scale_factor),
            video_modes: var(info.video_modes),
            refresh_rate: var(info.refresh_rate),
            density: var(PxDensity::default()),
        }
    }

    /// Update variables from fresh [`zng_view_api::MonitorInfo`],
    /// returns if any value changed.
    fn update(&self, info: zng_view_api::window::MonitorInfo) -> bool {
        fn check_set<T: VarValue + PartialEq>(var: &Var<T>, value: T) -> bool {
            let ne = var.with(|v| v != &value);
            var.set(value);
            ne
        }

        check_set(&self.is_primary, info.is_primary)
            | check_set(&self.name, info.name.to_txt())
            | check_set(&self.position, info.position)
            | check_set(&self.size, info.size)
            | check_set(&self.scale_factor, info.scale_factor)
            | check_set(&self.video_modes, info.video_modes)
            | check_set(&self.refresh_rate, info.refresh_rate)
    }

    /// Unique ID in this process instance.
    pub fn id(&self) -> MonitorId {
        self.id
    }

    /// If this monitor is the primary screen.
    pub fn is_primary(&self) -> Var<bool> {
        self.is_primary.read_only()
    }

    /// Name of the monitor.
    pub fn name(&self) -> Var<Txt> {
        self.name.read_only()
    }
    /// Top-left offset of the monitor region in the virtual screen, in pixels.
    pub fn position(&self) -> Var<PxPoint> {
        self.position.read_only()
    }
    /// Width/height of the monitor region in the virtual screen, in pixels.
    pub fn size(&self) -> Var<PxSize> {
        self.size.read_only()
    }

    /// Exclusive fullscreen video modes.
    pub fn video_modes(&self) -> Var<Vec<VideoMode>> {
        self.video_modes.read_only()
    }

    /// The monitor scale factor.
    ///
    /// Can update if the user changes system settings.
    pub fn scale_factor(&self) -> Var<Factor> {
        self.scale_factor.read_only()
    }
    /// Pixel density config var.
    pub fn density(&self) -> Var<PxDensity> {
        self.density.clone()
    }

    /// The monitor refresh rate.
    pub fn refresh_rate(&self) -> Var<Frequency> {
        self.refresh_rate.read_only()
    }

    /// Gets the monitor area in pixels.
    pub fn px_rect(&self) -> PxRect {
        let pos = self.position.get();
        let size = self.size.get();

        PxRect::new(pos, size)
    }

    /// Gets the monitor area in device independent pixels.
    pub fn dip_rect(&self) -> DipRect {
        let pos = self.position.get();
        let size = self.size.get();
        let factor = self.scale_factor.get();

        PxRect::new(pos, size).to_dip(factor)
    }

    /// Bogus metadata for the [`MonitorId::fallback`].
    ///
    /// [`MonitorId::fallback`]: crate::monitor::MonitorId::fallback
    pub fn fallback() -> Self {
        let defaults = HeadlessMonitor::default();
        let fct = 1.fct();

        Self {
            id: MonitorId::fallback(),
            is_primary: var(false),
            name: var("<fallback>".into()),
            position: var(PxPoint::zero()),
            size: var(defaults.size.to_px(fct)),
            video_modes: var(vec![]),
            scale_factor: var(fct),
            density: var(PxDensity::default()),
            refresh_rate: var(60.hertz()),
        }
    }
}

/// A selector that returns a [`MonitorInfo`].
#[derive(Clone, Default)]
pub enum MonitorQuery {
    /// The parent window monitor, or `Primary` if the window has no parent.
    ///
    /// Note that the window is not moved automatically if the parent window is moved to another monitor, only
    /// after the query variable updates.
    ///
    /// This is the default value.
    #[default]
    ParentOrPrimary,

    /// The primary monitor, if there is any monitor.
    Primary,
    /// Custom query closure.
    ///
    /// If the closure returns `None` the `ParentOrPrimary` query is used, if there is any.
    ///
    /// You can use the [`MONITORS`] service in the query closure to select a monitor.
    Query(Arc<dyn Fn() -> Option<MonitorInfo> + Send + Sync>),
}
impl std::fmt::Debug for MonitorQuery {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        if f.alternate() {
            write!(f, "MonitorQuery::")?;
        }
        match self {
            Self::ParentOrPrimary => write!(f, "ParentOrPrimary"),
            Self::Primary => write!(f, "Primary"),
            Self::Query(_) => write!(f, "Query(_)"),
        }
    }
}
impl MonitorQuery {
    /// New query.
    pub fn new(query: impl Fn() -> Option<MonitorInfo> + Send + Sync + 'static) -> Self {
        Self::Query(Arc::new(query))
    }

    /// Runs the query.
    pub fn select(&self, window_id: WindowId) -> Option<MonitorInfo> {
        match self {
            MonitorQuery::ParentOrPrimary => Self::parent_or_primary_query(window_id),
            MonitorQuery::Primary => Self::primary_query(),
            MonitorQuery::Query(q) => q(),
        }
    }

    /// Runs the query. Falls back to `Primary`, or the largest or [`MonitorInfo::fallback`].
    pub fn select_fallback(&self, window_id: WindowId) -> MonitorInfo {
        match self {
            MonitorQuery::ParentOrPrimary => Self::parent_or_primary_query(window_id),
            MonitorQuery::Primary => Self::primary_query(),
            MonitorQuery::Query(q) => q().or_else(Self::primary_query),
        }
        .unwrap_or_else(Self::fallback)
    }

    fn fallback() -> MonitorInfo {
        MONITORS_SV.read().monitors.with(|m| {
            let mut best = None;
            let mut best_area = Px(0);
            for m in m.values() {
                let m_area = m.px_rect().area();
                if m_area > best_area {
                    best = Some(m);
                    best_area = m_area;
                }
            }
            best.cloned().unwrap_or_else(MonitorInfo::fallback)
        })
    }

    fn parent_or_primary_query(win_id: WindowId) -> Option<MonitorInfo> {
        if let Some(parent) = WINDOWS.vars(win_id).unwrap().parent().get()
            && let Some(w) = WINDOWS.vars(parent)
        {
            return if let Some(monitor) = w.actual_monitor().get() {
                MONITORS.monitor(monitor)
            } else {
                w.monitor().get().select(parent)
            };
        }
        MONITORS.primary_monitor().get()
    }

    fn primary_query() -> Option<MonitorInfo> {
        MONITORS.primary_monitor().get()
    }
}
impl PartialEq for MonitorQuery {
    /// Returns `true` only if both are [`MonitorQuery::Primary`].
    fn eq(&self, other: &Self) -> bool {
        matches!((self, other), (Self::Primary, Self::Primary))
    }
}
impl_from_and_into_var! {
    fn from(id: MonitorId) -> MonitorQuery {
        MonitorQuery::new(move || MONITORS.monitor(id))
    }
}

event_args! {
    /// [`MONITORS_CHANGED_EVENT`] args.
    pub struct MonitorsChangedArgs {
        /// Removed monitors.
        pub removed: Vec<MonitorId>,

        /// Added monitors.
        ///
        /// Use the [`MONITORS`] service to get metadata about the added monitors.
        pub added: Vec<MonitorId>,

        /// Modified monitors.
        ///
        /// The monitor metadata is tracked using variables that are now flagged new.
        pub modified: Vec<MonitorId>,

        ..

        /// Broadcast to all widgets.
        fn is_in_target(&self, _id: WidgetId) -> bool {
            true
        }
    }
}

event! {
    /// Monitors added, removed or modified event.
    pub static MONITORS_CHANGED_EVENT: MonitorsChangedArgs;
}