use std::{fs::File, io::Write, path::Path};

use crate::{
    block::{extension::Extension, Block, ColorTable, ScreenDescriptor, Version},
    writer::GifBuilder,
};
pub struct Gif {
    pub header: Version,
    pub screen_descriptor: ScreenDescriptor,
    pub global_color_table: Option<ColorTable>,
    pub blocks: Vec<Block>, // Trailer at the end of this struct is 0x3B //
}

impl Gif {
    pub fn builder(width: u16, height: u16) -> GifBuilder {
        GifBuilder::new(width, height)
    }

    pub fn to_vec(&self) -> Vec<u8> {
        let mut out = vec![];

        out.extend_from_slice((&self.header).into());

        let mut boxed: Box<[u8]> = (&self.screen_descriptor).into();
        out.extend_from_slice(&*boxed);

        // While we output the color table, grab it's length to use when
        // outputting the image, or 0 if we don't have a GCT
        let mcs = if let Some(gct) = &self.global_color_table {
            boxed = gct.into();
            out.extend_from_slice(&*boxed);

            gct.packed_len()
        } else {
            0
        };

        for block in self.blocks.iter() {
            match block {
                Block::IndexedImage(image) => {
                    boxed = image.as_boxed_slice(mcs);
                    out.extend_from_slice(&*boxed);
                }
                //Block::BlockedImage(_) => unreachable!(),
                Block::Extension(ext) => {
                    boxed = ext.into();
                    out.extend_from_slice(&*boxed);
                }
            }
        }

        // Write Trailer
        out.push(0x3B);

        out
    }

    pub fn save<P: AsRef<Path>>(&self, path: P) -> std::io::Result<()> {
        File::create(path.as_ref())?.write_all(&self.to_vec())
    }
}

/*struct FrameIterator {

}

impl Iterator for FrameIterator {
    type Item = ();

    fn next(&mut self) -> Option<Self::Item> {
        todo!()
    }
}*/

#[cfg(test)]
pub mod gif {
    use std::convert::TryInto;
    use std::io::Write;

    use crate::block::extension::DisposalMethod;
    use crate::writer::{GifBuilder, ImageBuilder};
    use crate::Color;

    #[test]
    fn to_vec_gif87a() {
        let gct = vec![Color::new(1, 2, 3), Color::new(253, 254, 255)];
        let colortable = vec![Color::new(0, 0, 0), Color::new(128, 0, 255)];
        let indicies = vec![0, 0, 0, 0, 0, 1, 1, 0, 0, 1, 1, 0, 0, 0, 0, 0];

        let expected_out = vec![
            0x47,
            0x49,
            0x46,
            0x38,
            0x37,
            0x61, // Version - GIF87a
            0x04,
            0x00,
            0x04,
            0x00,
            0b1000_0000,
            0x00,
            0x00, // Logical Screen Descriptor
            1,
            2,
            3,
            253,
            254,
            255, // Global Color Table
            0x2C,
            0x00,
            0x00,
            0x00,
            0x00,
            0x04,
            0x00,
            0x04,
            0x00,
            0b1000_0000, // Image Descriptor 1
            0,
            0,
            0,
            128,
            0,
            255, // Color Table
            0x02,
            0x05,
            0x84,
            0x1D,
            0x81,
            0x7A,
            0x50,
            0x00, // Image Data 1
            0x2C,
            0x00,
            0x00,
            0x00,
            0x00,
            0x04,
            0x00,
            0x04,
            0x00,
            0b0000_0000, // Image Descriptor 2
            0x02,
            0x05,
            0x84,
            0x1D,
            0x81,
            0x7A,
            0x50,
            0x00, // Image Data 2
            0x3B, // Trailer
        ];

        let actual = GifBuilder::new(4, 4)
            .palette(gct.try_into().unwrap())
            .image(
                ImageBuilder::new(4, 4)
                    .palette(colortable.try_into().unwrap())
                    .indicies(&indicies),
            )
            .image(ImageBuilder::new(4, 4).indicies(&indicies));

        let bytes = actual.build().unwrap().to_vec();
        assert_eq!(bytes, expected_out);
    }

    #[test]
    fn to_vec_gif89a() {
        let gct = vec![Color::new(1, 2, 3), Color::new(253, 254, 255)];
        let colortable = vec![Color::new(0, 0, 0), Color::new(128, 0, 255)];
        let indicies = vec![0, 0, 0, 0, 0, 1, 1, 0, 0, 1, 1, 0, 0, 0, 0, 0];

        let expected_out = vec![
            71, 73, 70, 56, 57, 97, 4, 0, 4, 0, 128, 0, 0, 1, 2, 3, 253, 254, 255, 33, 249, 4, 8,
            64, 0, 0, 0, 44, 0, 0, 0, 0, 4, 0, 4, 0, 128, 0, 0, 0, 128, 0, 255, 2, 5, 132, 29, 129,
            122, 80, 0, 44, 0, 0, 0, 0, 4, 0, 4, 0, 0, 2, 5, 132, 29, 129, 122, 80, 0, 59,
        ];

        let actual_out = GifBuilder::new(4, 4)
            .palette(gct.try_into().unwrap())
            .image(
                ImageBuilder::new(4, 4)
                    .palette(colortable.try_into().unwrap())
                    .indicies(&indicies)
                    .disposal_method(DisposalMethod::RestoreBackground)
                    .delay(64),
            )
            .image(ImageBuilder::new(4, 4).indicies(&indicies))
            .build()
            .unwrap()
            .to_vec();

        std::fs::File::create("ah.gif")
            .unwrap()
            .write_all(&actual_out)
            .unwrap();
        std::fs::File::create("ah_hand.gif")
            .unwrap()
            .write_all(&expected_out)
            .unwrap();

        assert_eq!(actual_out, expected_out);
    }
}