use std::collections::HashMap;

use std::sync::Arc;

    Asset, AssetCache, ReloadId,

    Asset, AssetCache,

    Attrs, Buffer, Color, FontSystem, Metrics, Shaping, SwashCache, TextArea, TextBounds,

    fontdb::Source, Attrs, Buffer, Color, FontSystem, Metrics, Shaping, SwashCache, TextArea,
    TextBounds,

    loaded_fonts: HashMap<String, ReloadId>,

impl Default for TextSystem {
    fn default() -> Self {
        Self {
            fonts: FontSystem::new(),

impl TextSystem {
    pub fn new<S: assets_manager::source::Source>(
        assets: &AssetCache<S>,
    ) -> color_eyre::Result<Self> {
        let required_fonts = [
            "fonts.poiret_one.PoiretOne-Regular",
            "fonts.noto_color_emoji.NotoColorEmoji-Regular",
        ];
        let fonts: Vec<_> = required_fonts
            .into_iter()
            .map(|id| {
                let font_data_handle = assets.load::<FontData>(id)?;
                let font_data: Arc<Vec<u8>> = Arc::new(font_data_handle.read().0.clone());
                Ok((id, Source::Binary(font_data)))
            })
            .collect::<Result<Vec<_>, color_eyre::Report>>()?;
        // Until we can assume otherwise, hardcode this
        let locale = "en-US".to_string();
        let mut db = glyphon::fontdb::Database::new();
        #[cfg(not(target_arch = "wasm32"))]
        {
            db.load_system_fonts();
        }
        for (id, source) in fonts.into_iter() {
            let ids = db.load_font_source(source);
            log::warn!("laoded {id} into {ids}");
        }
        // Set up default families
        // Default to emoji for sans serif
        db.set_sans_serif_family("Noto Color Emoji");
        let fonts = FontSystem::new_with_locale_and_db(locale, db);
        Ok(Self {
            fonts,

            loaded_fonts: HashMap::new(),

        }

        })

    /// Loading requested asset fonts here

    /// Loading requested data here

        assets: &AssetCache<S>,

        _assets: &AssetCache<S>,

        let font_name = "fonts.poiret_one.PoiretOne-Regular";
        let font_data_handle = match assets.load::<FontData>(font_name) {
            Ok(hnd) => hnd,
            Err(e) => {
                log::error!("failed to load font {font_name}: {e}");
                return;
            }
        };
        let current_reload_id = self.loaded_fonts.get(font_name);
        if current_reload_id.is_none()
            || current_reload_id.is_some_and(|old_id| old_id < &font_data_handle.last_reload_id())
        {
            // Load the font into the system
            self.loaded_fonts
                .insert(font_name.to_string(), font_data_handle.last_reload_id());
            self.fonts
                .db_mut()
                .load_font_data(font_data_handle.read().0.clone());
            log::info!("successfully loaded font {font_name}!");
        }

            internal_state: GameState {
                world,
                assets,
                camera,
                render_options,
            },

            text: TextSystem::default(),

            text: TextSystem::new(&assets)?,

            internal_state: GameState {
                world,
                assets,
                camera,
                render_options,
            },

assets/*