use super::tile_image::TileImage;

use integral_geometry::Size;

use png::Decoder;

use std::fs::File;

use std::io::BufReader;

    pub fn load_template<T: Copy + PartialEq + Default>(&self, parameters: &LandGenerationParameters<T>) -> Vec<TileImage<T>> {

        let file = File::open("sample.png").expect("file exists");

        let decoder = Decoder::new(BufReader::new(file));

        let mut reader = decoder.read_info().unwrap();

        let info = reader.info();

        let mut tiles_image = vec2d::Vec2D::new(

            &Size::new(info.width as usize, info.height as usize),

            parameters.zero,

        );

        let mut buf = vec![0; reader.output_buffer_size()];

        let info = reader.next_frame(&mut buf).unwrap();

        let bytes = &buf[..info.buffer_size()];

        let mut tiles_image_pixels = tiles_image.as_mut_slice().into_iter();

        for line in bytes.chunks_exact(info.line_size) {

            for value in line.chunks_exact(info.color_type.samples()) {

                *tiles_image_pixels

                    .next()

                    .expect("vec2d size matching image dimensions") =

                    if value.into_iter().all(|p| *p == 0) {

                        parameters.zero

                    } else {

                        parameters.basic

                    };

            }

        }

        TileImage::<T>::new(tiles_image).split(3, 3)

        let tiles = self.load_template(parameters);

#[cfg(test)]

mod tests {

    use super::WavefrontCollapseLandGenerator;

    use crate::{LandGenerator, LandGenerationParameters};

    use integral_geometry::Size;

    use vec2d::Vec2D;

    #[test]

    fn test_generation() {

        let wfc_gen =WavefrontCollapseLandGenerator::new();

        let landgen_params = LandGenerationParameters::new(0u8, 255u8, 0, true, true);

        wfc_gen.generate_land(&landgen_params, &mut std::iter::repeat(1u32));

    }

}