use super::{atlas::AtlasCollection, gl::Texture2D};

use integral_geometry::{Rect, Size};

use crate::render::atlas::SpriteIndex;

use std::path::PathBuf;

    collections::HashMap,

    ffi::OsString,

struct SpriteData {

    size: Size,

    filename: PathBuf,

}

const ATLAS_SIZE: Size = Size::square(2024);

        let mut lookup = Vec::with_capacity(2048);

        let mut sprites = load_sprites(Path::new("../../share/hedgewars/Data/Graphics/"))

        let max_size = sprites

            .iter()

            .fold(Size::EMPTY, |size, sprite| size.join(sprite.size));

        for sprite in sprites.drain(..) {

            lookup.push((sprite.filename, atlas.insert_sprite(sprite.size).unwrap()));

        let texture = Texture2D::new(max_size, gl::RGBA8, gl::LINEAR);

        let mut pixels = Vec::with_capacity(max_size.area()).into_boxed_slice();

        for (path, sprite_index) in lookup.drain(..) {

            if let Some((atlas_index, rect)) = atlas.get_rect(sprite_index) {

                load_sprite_pixels(&path, &mut pixels[..]).expect("Unable to load Graphics");

                texture.update(rect, &pixels, 0, gl::RGBA, gl::UNSIGNED_BYTE);

            }

        }

fn load_sprite_pixels(path: &Path, buffer: &mut [u8]) -> io::Result<()> {

    let decoder = Decoder::new(BufReader::new(File::open(path)?));

    let (info, mut reader) = decoder.read_info()?;

    let size = Size::new(info.width as usize, info.height as usize);

    reader.next_frame(buffer)?;

    Ok(())

}

fn load_sprite_size(path: &Path) -> io::Result<Size> {

fn load_sprites(path: &Path) -> io::Result<Vec<SpriteData>> {

                let path = file.path();

                let sprite = load_sprite_size(&path)?;

                result.push(SpriteData {

                    size: sprite,

                    filename: path,

                });