//! Produce text!!!
use std::collections::HashMap;
use assets_manager::{
    loader::{BytesLoader, LoadFrom},
    Asset, AssetCache, ReloadId,
};
use glyphon::{
    Attrs, Buffer, Color, FontSystem, Metrics, Shaping, SwashCache, TextArea, TextBounds,
};
/// Contains the font system, swash cache, and is generally permanent
pub struct TextSystem {
    pub fonts: FontSystem,
    pub swash: SwashCache,
    loaded_fonts: HashMap<String, ReloadId>,
}
impl Default for TextSystem {
    fn default() -> Self {
        Self {
            fonts: FontSystem::new(),
            swash: SwashCache::new(),
            loaded_fonts: HashMap::new(),
        }
    }
}
struct FontData(Vec<u8>);
impl From<Vec<u8>> for FontData {
    fn from(value: Vec<u8>) -> Self {
        Self(value)
    }
}
impl Asset for FontData {
    const EXTENSIONS: &'static [&'static str] = &["ttf"];
    type Loader = LoadFrom<Vec<u8>, BytesLoader>;
}
impl TextSystem {
    /// Loading requested asset fonts here
    pub fn prepare(&mut self, _data: &TextSystemData, assets: &mut AssetCache) {
        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}!");
        }
    }
    /// Produce world space text.
    ///
    /// Moving the camera *should* move this text.
    pub fn produce_world(
        &mut self,
        _data: &TextSystemData,
    ) -> impl IntoIterator<Item = (Buffer, BufferMapper)> {
        vec![todo!()]
    }
    /// Produce camera space text.
    ///
    /// Moving the game camera should *not* move this text.
    pub fn produce_camera(
        &mut self,
        _data: &TextSystemData,
    ) -> impl IntoIterator<Item = (Buffer, BufferMapper)> {
        let metrics = Metrics::new(32.0, 20.0);
        let mut buffer = Buffer::new(&mut self.fonts, metrics);
        {
            let attrs = Attrs::new().family(glyphon::Family::Name("Poiret One"));
            let mut buffer = buffer.borrow_with(&mut self.fonts);
            buffer.set_size(200.0, 25.0);
            buffer.set_text("Hello, Rust! 🦀\n", attrs, Shaping::Advanced);
            buffer.shape_until_scroll();
        }
        vec![(buffer, BufferMapper)]
    }
}
/// Resposible for configuring the TextArea of a given buffer
pub struct BufferMapper;
impl BufferMapper {
    pub(crate) fn produce<'a>(&self, buffer: &'a Buffer) -> TextArea<'a> {
        TextArea {
            buffer,
            left: 32.0,
            top: 32.0,
            scale: 1.0,
            bounds: TextBounds {
                left: 0,
                top: 0,
                ..Default::default()
            },
            default_color: Color::rgba(255, 0, 0, 200),
        }
    }
}
/// Contains ephemural data about what the game wants to display with text
pub struct TextSystemData {}
impl TextSystemData {}

use egui::{ClippedPrimitive, FullOutput};

use egui::{ClippedPrimitive, TexturesDelta};

    glyphon: glyphon::TextRenderer,
    atlas: glyphon::TextAtlas,

pub struct ScreenRenderInput<'a> {
    pub egui_output: &'a FullOutput,

pub struct RenderInput<'a> {
    pub textures_delta: &'a TexturesDelta,

    pub font_system: &'a mut glyphon::FontSystem,
    pub swash_cache: &'a mut glyphon::SwashCache,
    pub camera_text_data: Vec<glyphon::TextArea<'a>>,

#[derive(thiserror::Error, Debug)]
pub enum RenderError {
    #[error(transparent)]
    Wgpu(#[from] wgpu::SurfaceError),
    #[error(transparent)]
    Glphon(#[from] glyphon::RenderError),
}

        let mut atlas = glyphon::TextAtlas::new(&device, &queue, surface_format);
        let glyphon = glyphon::TextRenderer::new(
            &mut atlas,
            &device,
            wgpu::MultisampleState::default(),
            None,
        );

            atlas,
            glyphon,

    pub fn render(&mut self, input: ScreenRenderInput) -> Result<(), wgpu::SurfaceError> {

    pub fn render(&mut self, input: RenderInput) -> Result<(), RenderError> {

        for (tex_id, delta) in &input.egui_output.textures_delta.set {

        for (tex_id, delta) in &input.textures_delta.set {

        // Prepare world layer text
        // TODO
        // The render pass manages world rendering (w/o camera adjustment)
        {
            // let mut _world_render_pass = encoder.begin_render_pass(&wgpu::RenderPassDescriptor {
            //     label: Some("World Render Pass"),
            //     color_attachments: &[],
            //     depth_stencil_attachment: None,
            //     timestamp_writes: None,
            //     occlusion_query_set: None,
            // });
        }
        let scale_factor = self.window.scale_factor();
        let logical_width = inner_size.width as f64 / scale_factor;
        let logical_height = inner_size.height as f64 / scale_factor;
        let screen_resolution = glyphon::Resolution {
            width: logical_width as u32,
            height: logical_height as u32,
        };

        // Prepare camera layer text
        match self.glyphon.prepare(
            &self.device,
            &self.queue,
            input.font_system,
            &mut self.atlas,
            screen_resolution,
            input.camera_text_data.clone(),
            input.swash_cache,
        ) {
            Ok(()) => {}
            Err(glyphon::PrepareError::AtlasFull) => {
                // Try on a completely empty atlas
                let mut new_atlas =
                    glyphon::TextAtlas::new(&self.device, &self.queue, self.config.format);
                if self
                    .glyphon
                    .prepare(
                        &self.device,
                        &self.queue,
                        input.font_system,
                        &mut new_atlas,
                        screen_resolution,
                        input.camera_text_data,
                        input.swash_cache,
                    )
                    .is_ok()
                {
                    self.atlas = new_atlas;
                } else {
                    log::error!(
                        "failed to render camera level text with a reinitialized atlas, giving up..."
                    );
                }
            }
        }

                label: Some("Render Pass"),

                label: Some("Final Render Pass"),

            self.glyphon.render(&self.atlas, &mut final_render_pass)?;

        for tex_id in &input.egui_output.textures_delta.free {

        for tex_id in &input.textures_delta.free {

mod text;

use screen::ScreenRenderInput;

                        // Any resources only used for the rendering process go here
                        let (egui_output, paint_jobs) = game.gui_egui();
                        // Build the renderer input
                        let input = ScreenRenderInput {
                            egui_output: &egui_output,
                            paint_jobs: &paint_jobs,
                        };

                        match game.screen_mut().render(input) {

                        match game.render() {

                            Err(wgpu::SurfaceError::Lost) => game.screen().reconfigure(),

                            Err(screen::RenderError::Wgpu(wgpu::SurfaceError::Lost)) => {
                                game.screen().reconfigure()
                            }

                            Err(wgpu::SurfaceError::OutOfMemory) => elwt.exit(),

                            Err(screen::RenderError::Wgpu(wgpu::SurfaceError::OutOfMemory)) => {
                                elwt.exit()
                            }

                            Err(e) => log::info!("Encountered wgpu surface error: {e:?}"),

                            Err(e) => log::info!("Encountered render error: {e:?}"),

            game.render();

            game.screen().window().request_redraw();

use crate::screen::Screen;

use crate::{
    screen::{RenderError, RenderInput, Screen},
    text::{TextSystem, TextSystemData},
};

    text: TextSystem,

            text: TextSystem::default(),

    pub fn render(&mut self) {
        self.screen.window().request_redraw();

    pub fn render(&mut self) -> Result<(), RenderError> {
        // Any resources only used for the rendering process go here
        let (egui_output, paint_jobs) = self.gui_egui();
        let text_data = self.prepare_text_data();
        self.text.prepare(&text_data, &mut self.assets);
        let camera_text_data_info: Vec<_> =
            self.text.produce_camera(&text_data).into_iter().collect();
        let camera_text_data = camera_text_data_info
            .iter()
            .map(|(buf, mapper)| mapper.produce(buf))
            .collect();
        // Build the renderer input
        let input = RenderInput {
            paint_jobs: &paint_jobs,
            textures_delta: &egui_output.textures_delta,
            font_system: &mut self.text.fonts,
            swash_cache: &mut self.text.swash,
            camera_text_data,
        };
        self.screen.render(input)

    /// Prepares the text to display using the text system
    pub fn prepare_text_data(&mut self) -> TextSystemData {
        TextSystemData {}
    }

        let _ = ctx;

        egui::SidePanel::left("gama").show(ctx, |ui| {
            ui.label(">> Welcome to Cat Waiter <<");
            if ui
                .text_edit_singleline(&mut self.voop)
                .on_hover_text("the best textbox of your life")
                .changed()
            {
                log::info!(">> new text: {}", self.voop);
            }
        });

        // egui::SidePanel::left("gama").show(ctx, |ui| {
        //     ui.label(">> Welcome to Cat Waiter <<");
        //     if ui
        //         .text_edit_singleline(&mut self.voop)
        //         .on_hover_text("the best textbox of your life")
        //         .changed()
        //     {
        //         log::info!(">> new text: {}", self.voop);
        //     }
        // });