pub mod deserializer {
    use log::info;
    use crate::artworkdb::aobjects::{ADataSet, ADatabase, AImageItem, AImageName, SecondTypeTag, ThirdTypeTag};
    use crate::artworkdb::objects::{ChunkHeader, ChunkType, DataSet, Database, ImageFile, ImageItem, ImageName, LocationTag};

    enum ChunkState {
        Header,
        Data
    }

    pub fn parse_bytes(data: &[u8]) -> ADatabase {
        let mut adb = ADatabase {data: None, header: None, children: Vec::new() };
        let mut state = ChunkState::Header;
        let mut chunk_header: Option<ChunkHeader> = None;
        let mut last_type: u32 = 0;
        let mut i = 0;
        while i < data.len() {
            state = match state {
                ChunkState::Header => {
                    if i + 12 >= data.len() { break; }
                    chunk_header = Some(bincode::deserialize(&data[i..i + 12]).unwrap());
                    i += 12;
                    ChunkState::Data
                },
                ChunkState::Data => {
                    let mut u = 0;
                    let header = chunk_header.unwrap();
                    match ChunkType::from(header.chunk_type) {
                        ChunkType::ArtworkDB => {
                            u = usize::try_from(header.end_of_chunk).unwrap() - 12;
                            let db: Database = bincode::deserialize(&data[i..i+u]).unwrap();
                            info!("val: {:?}", db);
                            adb.data = Some(db);
                            adb.header = Some(header);
                        },
                        ChunkType::DataSet => {
                            u = usize::try_from(header.end_of_chunk).unwrap() - 12;
                            let ds: DataSet = bincode::deserialize(&data[i..i + u]).unwrap();
                            last_type = ds.data_type;
                            adb.children.push(ADataSet { header, data: ds, child: Vec::new()});
                        },
                        ChunkType::ImageList | ChunkType::AlbumList | ChunkType::FileList => {
                            u = usize::try_from(header.end_of_chunk).unwrap() - 12;
                        },
                        ChunkType::ImageItem => {
                            info!("ImageItem tag");
                            u = usize::try_from(header.end_of_chunk).unwrap() - 12;
                            let ai: ImageItem = bincode::deserialize(&data[i..i+u]).unwrap();
                            let images = &mut adb.find_dataset(last_type).child;
                            images.push(AImageItem { data: Some(ai), tag: Vec::new(), file: None });
                        },
                        ChunkType::FileImage => {
                            u = usize::try_from(header.end_of_chunk).unwrap() - 12;
                            let ai: ImageFile = bincode::deserialize(&data[i..i+u]).unwrap();
                            let images = &mut adb.find_dataset(last_type).child;
                            images.push(AImageItem { data: None, tag: Vec::new(), file: Some(ai) });
                        },
                        ChunkType::LocationTag => {
                            u = usize::try_from(header.end_of_chunk).unwrap() - 12;
                            let ds: LocationTag = bincode::deserialize(&data[i..i + u]).unwrap();
                            let images = &mut adb.find_dataset(last_type).child;
                            let mut str = None;
                            match ds.tag_type {
                                3 => {
                                    let mut bytes = Vec::new();
                                    let str_end = u32::from_le_bytes(data[i+12..i+16].try_into().unwrap()) as usize;
                                    let mut h = i+24;
                                    u += 12 + str_end;
                                    while h < i+24+str_end {
                                        bytes.push(u16::from_le_bytes(data[h..h+2].try_into().unwrap()));
                                        h+=2;
                                    }
                                    let g = String::from_utf16(&bytes).unwrap();
                                    info!("str: {}", g);
                                    str = Some(g);
                                    images.last_mut().unwrap().tag.last_mut().unwrap().child.as_mut().unwrap().tag = Some(ThirdTypeTag { data: ds, str });
                                },
                                2 => {
                                    images.last_mut().unwrap().tag.push(SecondTypeTag { data: ds, str, child: None });
                                },
                                _ => { u = usize::try_from(header.children_count).unwrap() - 12; }
                            }
                        },
                        ChunkType::ImageName => {
                            info!("ImageName tag");
                            u = usize::try_from(header.end_of_chunk).unwrap() - 12;
                            let ds: ImageName = bincode::deserialize(&data[i..i + u]).unwrap();
                            let images = &mut adb.find_dataset(last_type).child;
                            images.last_mut().unwrap().tag.last_mut().unwrap().child = Some(AImageName { iname: ds, tag: None });
                        },
                        _ => { u = 1; info!("Unknown stuff happened {:X?}", header.chunk_type.to_vec()); }
                    }
                    i += u;
                    chunk_header = None;
                    ChunkState::Header
                }
            }
        }
        adb
    }
}

pub mod serializer {
    use log::info;
    use crate::artworkdb::aobjects::ADatabase;
    use crate::artworkdb::objects::{ChunkHeader, ChunkType};

    pub fn to_bytes(adb: ADatabase) -> Vec<u8> {
        let mut bytes: Vec<u8> = Vec::new();
        for i in 0..(adb.children.len()) {
            let data_set = adb.children.get(i).unwrap();
            let mut entry_bytes = Vec::new();

            match data_set.data.data_type {
                1 => {
                    entry_bytes.append(&mut generate_header_raw(ChunkType::ImageList, 80, data_set.child.len()));
                    entry_bytes.append(&mut [0; 80].to_vec());
                } // Image List
                _ => { info!("Unknown data_set type!"); }
            }

            for img in data_set.child.iter() {
                let mut args = Vec::new();
                if img.data.is_some() {
                    let mut item = Vec::new();
                    item.append(&mut generate_header(ChunkType::ImageItem, 140, args.len()));
                    item.append(&mut bincode::serialize(img.data.as_ref().unwrap()).unwrap());
                    item.append(&mut [0; 100].to_vec());
                    entry_bytes.append(&mut item);
                    for o in &img.tag {
                        let mut data = [2u32.to_le_bytes(), 0u32.to_le_bytes(), 0u32.to_le_bytes()].concat();
                        entry_bytes.append(&mut generate_header(ChunkType::LocationTag, 12, 0));
                        entry_bytes.append(&mut data);

                        if let Some(name) = &o.child {

                            let mut nb = Vec::new();

                            let arg = name.tag.as_ref().unwrap();
                            let mut str_b = string_to_ipod16(arg.str.as_ref().unwrap());
                            str_b = [3u32.to_le_bytes().to_vec(), 0u32.to_le_bytes().to_vec(), 0u32.to_le_bytes().to_vec(), (str_b.len() as u32).to_le_bytes().to_vec(), 2u32.to_le_bytes().to_vec(), 0u32.to_le_bytes().to_vec(), str_b ].concat();
                            nb.append(&mut generate_header(ChunkType::LocationTag, 12, str_b.len()));
                            nb.append(&mut str_b);
                            
                            entry_bytes.append(&mut generate_header(ChunkType::ImageName, 76, nb.len()));
                            entry_bytes.append(&mut bincode::serialize(&name.iname).unwrap());
                            entry_bytes.append(&mut nb);
                        }
                    }
                }

                if img.file.is_some() {
                    entry_bytes.append(&mut generate_header(ChunkType::FileImage, 12, 0));
                    entry_bytes.append(&mut bincode::serialize(img.file.as_ref().unwrap()).unwrap());
                }

                entry_bytes.append(&mut args);
            }

            bytes.append(&mut generate_header(ChunkType::DataSet, 84, entry_bytes.len()));
            bytes.append(&mut bincode::serialize(&data_set.data).unwrap());
            bytes.append(&mut [0; 80].to_vec());

            bytes.append(&mut entry_bytes);
        }

        bytes
    }

    fn string_to_ipod16(str: &str) -> Vec<u8> {
        str.encode_utf16().flat_map(|f| [f as u8, (f >> 8) as u8]).collect()
    }

    fn generate_header(ct: ChunkType, header_size: usize, data_len: usize) -> Vec<u8> {
        let header_size = 12 + header_size as u32;
        let header = ChunkHeader{ chunk_type: ct.into(), end_of_chunk: header_size, children_count: header_size + data_len as u32};
        bincode::serialize(&header).unwrap()
    }

    fn generate_header_raw(ct: ChunkType, header_size: usize, child_cnt: usize) -> Vec<u8> {
        let header_size = 12 + header_size as u32;
        let header = ChunkHeader{ chunk_type: ct.into(), end_of_chunk: header_size, children_count: child_cnt as u32};
        bincode::serialize(&header).unwrap()
    }
}

pub mod aobjects {
    use crate::artworkdb::objects::{ChunkHeader, DataSet, Database, ImageFile, ImageItem, ImageName, LocationTag};

    #[derive(Debug, serde::Serialize)]
    pub struct ADatabase {
        pub header: Option<ChunkHeader>,
        pub data: Option<Database>,
        pub children: Vec<ADataSet>
    }

    impl ADatabase {
        pub(crate) fn find_dataset(&mut self, p0: u32) -> &mut ADataSet {
            self.children.iter_mut().find(|d| d.data.data_type == p0).unwrap()
        }
    }

    #[derive(Debug, serde::Serialize)]
    pub struct ADataSet {
        pub header: ChunkHeader,
        pub data: DataSet,
        pub child: Vec<AImageItem>
    }

    #[derive(Debug, serde::Serialize)]
    pub struct AImageItem {
        pub tag: Vec<SecondTypeTag>,
        pub data: Option<ImageItem>,
        pub file: Option<ImageFile>,
    }
    
    #[derive(Debug, serde::Serialize)]
    pub struct AImageName {
        pub iname: ImageName,
        pub tag: Option<ThirdTypeTag>,
    }

    #[derive(Debug, serde::Serialize)]
    pub struct SecondTypeTag {
        pub data: LocationTag,
        pub str: Option<String>,
        pub child: Option<AImageName>
    }

    #[derive(Debug, serde::Serialize)]
    pub struct ThirdTypeTag {
        pub data: LocationTag,
        pub str: Option<String>
    }
}

pub mod objects {
    use serde::{Deserialize, Serialize};

    pub enum ChunkType {
        ArtworkDB,
        DataSet,
        ImageList,
        AlbumList,
        FileList,
        ImageItem,
        LocationTag,
        ImageName,
        FileImage,
        Unknown,
    }

    impl From<[u8; 4]> for ChunkType {
        fn from(value: [u8; 4]) -> Self {
            match value {
                [0x6D, 0x68, 0x66, 0x64] => ChunkType::ArtworkDB,
                [0x6D, 0x68, 0x73, 0x64] => ChunkType::DataSet,
                [0x6D, 0x68, 0x6C, 0x69] => ChunkType::ImageList,
                [0x6D, 0x68, 0x69, 0x69] => ChunkType::ImageItem,
                [0x6D, 0x68, 0x6F, 0x64] => ChunkType::LocationTag,
                [0x6D, 0x68, 0x6E, 0x69] => ChunkType::ImageName,
                [0x6D, 0x68, 0x6C, 0x61] => ChunkType::AlbumList,
                [0x6D, 0x68, 0x6C, 0x66] => ChunkType::FileList,
                [0x6D, 0x68, 0x69, 0x66] => ChunkType::FileImage,
                _ => ChunkType::Unknown,
            }
        }
    }

    impl From<ChunkType> for [u8; 4] {
        fn from(value: ChunkType) -> Self {
            match value {
                ChunkType::ArtworkDB => [0x6D, 0x68, 0x66, 0x64],
                ChunkType::DataSet => [0x6D, 0x68, 0x73, 0x64],
                ChunkType::Unknown => [0x00, 0x00, 0x00, 0x00],
                ChunkType::ImageList => [0x6D, 0x68, 0x6C, 0x69],
                ChunkType::ImageItem => [0x6D, 0x68, 0x69, 0x69],
                ChunkType::LocationTag => [0x6D, 0x68, 0x6F, 0x64],
                ChunkType::ImageName => [0x6D, 0x68, 0x6E, 0x69],
                ChunkType::AlbumList => [0x6D, 0x68, 0x6C, 0x61],
                ChunkType::FileList => [0x6D, 0x68, 0x6C, 0x66],
                ChunkType::FileImage => [0x6D, 0x68, 0x69, 0x66],
            }
        }
    }

    #[derive(Serialize, Deserialize, PartialEq, Debug, Clone, Copy)]
    pub struct ChunkHeader {
        pub chunk_type: [u8; 4],
        pub end_of_chunk: u32,
        pub children_count: u32,
    }

    #[derive(Serialize, Deserialize, PartialEq, Debug)]
    pub struct Database {
        unknown1: u32,
        unknown2: u32,
        number_of_children: u32,
        unknown3: u32,
        next_id_for_mhii: u32,
        unknown5: u64,
        unknown6: u64,
        unknown7: u32,
        unknown8: u32,
        unknown9: u32,
        unknown10: u64
    }

    #[derive(Serialize, Deserialize, PartialEq, Debug, Clone, Copy)]
    pub struct DataSet {
        pub data_type: u32,
    }

    #[derive(Serialize, Deserialize, PartialEq, Debug, Clone, Copy)]
    pub struct LocationTag {
        pub tag_type: u32,
        unk1: u32,
        unk2: u32,
    }

    #[derive(Serialize, Deserialize, PartialEq, Debug)]
    pub struct ImageItem {
        number_of_children: u32,
        id: u32,
        song_dbid: u64,
        unknown4: u32,
        rating: u32,
        unknown6: u32,
        original_date: u32,
        digitized_date: u32,
        source_image_size: u32
    }

    #[derive(Serialize, Deserialize, PartialEq, Debug)]
    pub struct ImageFile {
        unknown1: u32,
        correlation_id: u32,
        image_size: u32
    }

    #[derive(Serialize, Deserialize, PartialEq, Debug)]
    pub struct ImageName {
        number_of_children: u32,
        correlation_id: u32,
        ithmb_offset: u32,
        image_size: u32,
        vertical_padding: u16,
        horizontal_padding: u16,
        image_height: u16,
        image_width: u16,
        unknown: u32,
        image_size_n: u32,
    }
}