//! Generic icon provider system for Azul

//!

//! This module defines a generic, callback-based icon resolution infrastructure.

//! The actual parsing/loading implementations live in `azul-layout`.

//!

//! # Architecture

//!

//! The icon system is fully generic using RefAny:

//!

//! 1. `IconProviderHandle` - stores icons in nested map: pack_name → (icon_name → RefAny)

//! 2. The resolver callback turns (icon_data, original_dom) into a StyledDom

//! 3. Differentiation between Image/Font/SVG/etc. is via RefAny::downcast

//! 4. Supports any icon source: images, fonts, SVGs, animated icons, etc.

//!

//! # Resolution Flow

//!

//! 1. User creates Icon nodes: `Dom::create_icon("home")`

//! 2. Before layout, `resolve_icons_in_styled_dom()` is called

//! 3. Each Icon node is looked up across all packs (first match wins)

//! 4. The resolver callback is invoked with the found RefAny data + original DOM

//! 5. The callback returns a StyledDom subtree that replaces the icon node

//!

//! # Custom Resolvers

//!

//! Users can provide custom C callbacks for complete control:

//!

//! ```c

//! AzStyledDom my_resolver(

//!     AzRefAny* icon_data,           // NULL if icon not found

//!     AzStyledDom* original_icon_dom, // Contains icon_name, styles, a11y

//!     AzSystemStyle* system_style

//! ) {

//!     // Custom resolution logic - icon_data contains your registered data

//!     return create_my_icon_dom(...);

//! }

//! ```

use alloc::{

    boxed::Box,

    collections::BTreeMap,

    string::{String, ToString},

    sync::Arc,

    vec::Vec,

};

use core::fmt;

use core::mem::ManuallyDrop;

#[cfg(feature = "std")]

use std::sync::Mutex;

#[cfg(not(feature = "std"))]

use self::nostd_lock::Mutex;

/// Minimal `no_std` spinlock that mirrors the slice of the `std::sync::Mutex`

/// API actually used by this module (`new` + `lock` returning a `Result`).

#[cfg(not(feature = "std"))]

mod nostd_lock {

    use core::cell::UnsafeCell;

    use core::ops::{Deref, DerefMut};

    use core::sync::atomic::{AtomicBool, Ordering};

    pub struct Mutex<T> {

        locked: AtomicBool,

        data: UnsafeCell<T>,

    }

    unsafe impl<T: Send> Send for Mutex<T> {}

    unsafe impl<T: Send> Sync for Mutex<T> {}

    pub struct MutexGuard<'a, T> {

        lock: &'a Mutex<T>,

    }

    impl<T> Mutex<T> {

        pub fn new(data: T) -> Self {

            Mutex { locked: AtomicBool::new(false), data: UnsafeCell::new(data) }

        }

        /// Returns `Ok(guard)` to mirror `std::sync::Mutex::lock`. Never poisons.

        pub fn lock(&self) -> Result<MutexGuard<'_, T>, core::convert::Infallible> {

            while self

                .locked

                .compare_exchange(false, true, Ordering::Acquire, Ordering::Relaxed)

                .is_err()

            {

                core::hint::spin_loop();

            }

            Ok(MutexGuard { lock: self })

        }

    }

    impl<'a, T> Deref for MutexGuard<'a, T> {

        type Target = T;

        fn deref(&self) -> &T {

            unsafe { &*self.lock.data.get() }

        }

    }

    impl<'a, T> DerefMut for MutexGuard<'a, T> {

        fn deref_mut(&mut self) -> &mut T {

            unsafe { &mut *self.lock.data.get() }

        }

    }

    impl<'a, T> Drop for MutexGuard<'a, T> {

        fn drop(&mut self) {

            self.lock.locked.store(false, Ordering::Release);

        }

    }

}

use azul_css::{AzString, system::SystemStyle};

use crate::{

    dom::{Dom, NodeType},

    refany::{OptionRefAny, RefAny},

    styled_dom::StyledDom,

};

// Type name constants for RefAny-based icon type detection in debug output

const IMAGE_ICON_DATA_TYPE_NAME: &str = "ImageIconData";

const FONT_ICON_DATA_TYPE_NAME: &str = "FontIconData";

// Icon Resolver Callback

/// Callback type for resolving icon data to a StyledDom.

///

/// Parameters:

/// - `icon_data`: The RefAny data from the icon pack (cloned, or None if not found)

/// - `original_icon_dom`: The original icon node's StyledDom (contains inline styles, a11y info, icon_name)

/// - `system_style`: Current system style (theme, colors, etc.)

///

/// Returns: A StyledDom that will replace the icon node.

/// The resolver should copy relevant styles from original_icon_dom to the result.

/// Return an empty StyledDom to show a placeholder or nothing.

///

/// Note: icon_name is accessible via `original_icon_dom.node_data[0].get_node_type()` → `NodeType::Icon(name)`

pub type IconResolverCallbackType = extern "C" fn(

    icon_data: OptionRefAny,

    original_icon_dom: &StyledDom,

    system_style: &SystemStyle,

) -> StyledDom;

/// Default resolver that returns an empty StyledDom (shows placeholder)

    // Default: return empty DOM (icon won't be visible)

// Icon Provider Inner (single mutex)

/// Inner data for IconProviderHandle - all fields behind single mutex

#[derive(Clone)]

pub struct IconProviderInner {

    /// Nested map: pack_name → (icon_name → RefAny)

    /// Differentiation between Image/Font/SVG is via RefAny::downcast

    pub icons: BTreeMap<String, BTreeMap<String, RefAny>>,

    /// The resolver callback

    pub resolver: IconResolverCallbackType,

}

impl Default for IconProviderInner {

}

// Icon Provider Handle

/// Icon provider stored in AppConfig.

///

/// This is a Box<IconProviderInner> for C FFI compatibility.

/// When App::run() is called, it gets converted to Arc<Mutex<IconProviderInner>>

/// and cloned to each window.

///

/// Icons are stored in a nested map: pack_name → (icon_name → RefAny)

/// This allows:

/// - Multiple packs with different sources (app-images, material-icons, etc.)

/// - Easy unregistration of entire packs

/// - First-match-wins lookup across all packs

#[repr(C)]

pub struct IconProviderHandle {

    /// Boxed inner data - Box<T> is repr(C) compatible (single pointer).

    /// `ManuallyDrop` so the Box is freed ONLY by our `Drop` (gated on

    /// `run_destructor`), never by drop-glue. The codegen Az wrapper nests an

    /// `AzIconProviderHandle` field (in `AzAppConfig`) whose own `Drop` re-runs

    /// `_delete` -> `drop_in_place::<IconProviderHandle>` on the SAME bytes; with

    /// a bare `Box` the glue freed it a second time -> double free. Same

    /// convention as GlContextPtr / CssPropertyCachePtr.

    pub inner: ManuallyDrop<Box<IconProviderInner>>,

    pub run_destructor: bool,

}

impl Clone for IconProviderHandle {

}

impl Drop for IconProviderHandle {

        // First drop (run_destructor still true) frees the Box and clears the flag

        // in the shared bytes; the codegen's redundant second drop sees false -> no-op.

}

impl fmt::Debug for IconProviderHandle {

}

impl Default for IconProviderHandle {

}

impl IconProviderHandle {

    /// Create a new empty icon provider with the default (no-op) resolver.

    /// 

    /// Note: The default resolver in core crate returns an empty StyledDom.

    /// Use `set_resolver()` to set a proper resolver from the layout crate,

    /// or use `with_resolver()` to create with a custom resolver.

    /// Create with a custom resolver callback

    /// Convert this handle into an Arc<Mutex<IconProviderInner>> for use in windows.

    ///

    /// This consumes the Box and creates an Arc. Called by App::run() to create

    /// the shared icon provider that gets cloned to each window.

        // Take the Box out and disarm our Drop so it doesn't free the moved-out

        // allocation (ManuallyDrop::take leaves `inner` logically uninitialized).

    /// Set the resolver callback

    /// Register a single icon in a pack (creates pack if needed).

    ///

    /// Note: `pack_name` is case-sensitive, while `icon_name` is normalized to lowercase.

    /// Unregister a single icon from a pack

    /// Unregister an entire icon pack

    /// Look up an icon across all packs, returning the pack name and data reference (first match wins)

        }

    /// Look up an icon across all packs (first match wins)

    /// Check if an icon exists in any pack

    /// List all pack names

    /// List all icon names in a specific pack

    /// Debug lookup: returns detailed info about an icon's RefAny contents

        // Report registered packs

        }

        // Find the icon using shared lookup helper

            }

        }

}

/// Thread-safe icon provider for use in windows.

/// 

/// This is created from IconProviderHandle::into_shared() in App::run()

/// and cloned to each window.

#[derive(Clone)]

pub struct SharedIconProvider {

    inner: Arc<Mutex<IconProviderInner>>,

}

impl SharedIconProvider {

    /// Create from an IconProviderHandle (consumes the handle)

    /// Resolve an icon to a StyledDom using the registered callback

            };

        };

    /// Look up an icon across all packs

            }

    /// Check if an icon exists

}

// Icon Resolution in StyledDom

/// Collected icon node info for replacement

struct CollectedIcon {

    /// Index in the node_data array

    node_idx: usize,

    /// The icon name

    icon_name: AzString,

}

/// Replacement result after resolving an icon

struct IconReplacement {

    /// Index of the icon node to replace

    node_idx: usize,

    /// The resolved StyledDom (may be empty, single node, or multi-node tree)

    replacement: StyledDom,

}

/// Collect all Icon nodes from the StyledDom

    }

/// Extract a single-node StyledDom from a parent StyledDom at the given index.

/// This creates a minimal StyledDom containing just that node for the resolver.

    use crate::dom::{NodeDataVec, DomId};

    use crate::id::NodeId;

    use crate::styled_dom::{

        StyledNodeVec, NodeHierarchyItemIdVec, TagIdToNodeIdMappingVec,

        NodeHierarchyItemVec, NodeHierarchyItem, NodeHierarchyItemId,

        ParentWithNodeDepthVec, ParentWithNodeDepth,

    };

    use crate::style::{CascadeInfoVec, CascadeInfo};

    use crate::prop_cache::{CssPropertyCachePtr, CssPropertyCache};

    // Clone the single node

    } else {

    };

/// Resolve all collected icons to their StyledDom representations

        // Extract the original icon node as a StyledDom

/// Check if a replacement is a single-node replacement (fast path)

/// Apply a single-node replacement (fast path: swap NodeType and copy properties)

        // Empty replacement - convert to empty div

    } else {

        // Get the root node from the replacement and copy its properties

            // Swap node type

            // Copy inline style from replacement

            // Copy accessibility info if present

        // Also update the styled_nodes to reflect the new styling

    }

/// Apply multi-node replacement using subtree splicing

    // For now, just apply the root node (same as single-node)

/// Resolve all Icon nodes in a StyledDom to their actual content.

///

/// This function:

/// 1. Collects all Icon nodes from the StyledDom

/// 2. Resolves each icon via the provider's callback (passing original icon DOM)

/// 3. Applies replacements (single-node fast path or multi-node splicing)

///

/// This should be called after StyledDom creation but before layout.

    // Step 1: Collect all icon nodes

    // Step 2: Resolve all icons to their StyledDom representations

    // Note: We pass styled_dom to extract each icon's original node

    // Step 3: Apply replacements (reverse order to preserve indices)

    }

// FFI Option Types

impl_option!(

    IconProviderHandle,

    OptionIconProviderHandle,

    [Clone]

);