use crate::{
    common_strings::COMMON_STRINGS,
    helper::{AlignExt, Endianness, ReadExt},
};
use anyhow::Result;
use log::{debug, trace};
use std::io::{Cursor, Read, Seek};

#[derive(Debug)]
pub struct TypeTreeNode {
    pub version: u16,
    pub level: u8,
    pub type_flags: u8,
    pub type_string: String,
    pub name_string: String,
    pub byte_size: i32,
    pub index: i32,
    pub flags: i32,
    pub ref_type_hash: u64,
}

#[derive(Debug)]
pub struct SeralizedType {
    pub class_id: i32,
    pub stripped_type: bool,
    pub script_type_index: i16,
    pub script_id: u128,

    pub type_tree: Vec<TypeTreeNode>,
    pub type_deps: Vec<u32>,
}

#[derive(Debug)]
pub struct ObjectInfo {
    path_id: i64,
    data_offset: u64,
    data_size: u32,
    type_id: i32,
}

#[derive(Debug)]
pub struct Script {
    file_index: u32,
    identifier: i64,
}

#[derive(Debug)]
pub struct External {
    something: String,
    guid: u128,
    r#type: i32,
    path_name: String,
}

#[derive(Debug)]
pub struct SerializedFile {
    pub types: Vec<SeralizedType>,
    pub externals: Vec<External>,
    pub scripts: Vec<Script>,
    pub objects: Vec<ObjectInfo>,
    pub user_string: String,
}

pub fn read_serialized_file(mut file: impl Read + Seek) -> Result<SerializedFile> {
    let mut metadata_size = file.read_u32_be()?;
    let mut file_size = file.read_u32_be()? as u64;
    let format = file.read_u32_be()?;
    let mut data_offset = file.read_u32_be()? as u64;

    debug!("format={format}");

    assert!(format >= 9);
    let e = match file.read_u32_be()? {
        0 => Endianness::Little,
        _ => Endianness::Big,
    };
    debug!("endianess={e:?}");

    if format >= 22 {
        metadata_size = file.read_u32(e)?;
        file_size = file.read_u64(e)?;
        data_offset = file.read_u64(e)?;
        file.read_u64(e)?;
    }
    debug!("metadata_size={metadata_size}");
    debug!("file_size={file_size}");
    debug!("data_offset={data_offset}");

    let generator_version = file.read_cstr()?;
    let target_platform = file.read_u32_le()?;
    debug!("generator_version={generator_version:?}");
    debug!("target_platform={target_platform}");

    let has_type_trees = file.read_u8()? != 0;
    let num_types = file.read_u32(e)?;
    debug!("has_type_trees={has_type_trees:?}");
    debug!("num_types={num_types}");

    let mut types = Vec::new();

    for _ in 0..num_types {
        let class_id = file.read_i32(e)?;
        let stripped_type = file.read_u8()? != 0;
        let script_type_index = file.read_i16(e)?;
        let mut script_id = 0;
        // TODO reftype
        if class_id == 114 {
            script_id = file.read_u128_be()?;
        }
        let _old_hash = file.read_u128_be()?;

        trace!("class_id={class_id}");
        trace!("stripped_type={stripped_type}");
        trace!("script_type_index={script_type_index}");
        trace!("script_id={script_id}");

        let mut type_deps = Vec::new();
        let mut type_tree = Vec::new();
        if has_type_trees {
            let num_nodes = file.read_u32(e)?;
            let size = file.read_u32(e)?;
            trace!("tree:num_nodes={num_nodes}");
            trace!("tree:size={size}");

            let mut node_data = vec![0u8; num_nodes as usize * 32];
            file.read_exact(&mut node_data)?;
            let mut node_data = Cursor::new(node_data);
            let mut string_data = vec![0u8; size as usize];
            file.read_exact(&mut string_data)?;

            let get_string = |off: u32| {
                let data = if off & 0x80000000 != 0 {
                    let off = off & 0x7fffffff;
                    &COMMON_STRINGS[off as usize..]
                } else {
                    &string_data[off as usize..]
                };
                String::from_utf8(
                    data.iter()
                        .copied()
                        .take_while(|e| *e != 0)
                        .collect::<Vec<u8>>(),
                )
            };

            for _ in 0..num_nodes {
                type_tree.push(TypeTreeNode {
                    version: node_data.read_u16(e)?,
                    level: node_data.read_u8()?,
                    type_flags: node_data.read_u8()?,
                    type_string: get_string(node_data.read_u32(e)?)?,
                    name_string: get_string(node_data.read_u32(e)?)?,
                    byte_size: node_data.read_i32(e)?,
                    index: node_data.read_i32(e)?,
                    flags: node_data.read_i32(e)?,
                    ref_type_hash: node_data.read_u64(e)?,
                });
            }

            if format >= 21 {
                let num_deps = file.read_u32(e)?;
                trace!("num_deps={num_deps}");
                for _ in 0..num_deps {
                    type_deps.push(file.read_u32(e)?);
                }
            }
        }

        types.push(SeralizedType {
            class_id,
            script_id,
            script_type_index,
            stripped_type,
            type_deps,
            type_tree,
        })
    }

    let num_objects = file.read_u32(e)?;
    debug!("num_objects={num_objects}");
    let mut objects = Vec::new();
    for _ in 0..num_objects {
        file.align(4)?;
        let path_id = file.read_i64(e)?;
        let data_offset = if format >= 22 {
            file.align(4)?;
            file.read_u64(e)?
        } else {
            file.read_u32(e)? as u64
        } + data_offset;
        let data_size = file.read_u32(e)?;
        let type_id = file.read_i32(e)?;
        objects.push(ObjectInfo {
            data_offset,
            data_size,
            path_id,
            type_id,
        })
    }

    let num_scripts = file.read_u32(e)?;
    debug!("num_scripts={num_scripts}");
    let mut scripts = Vec::new();
    for _ in 0..num_scripts {
        let file_index = file.read_u32(e)?;
        file.align(4)?;
        let identifier = file.read_i64(e)?;
        scripts.push(Script {
            file_index,
            identifier,
        })
    }

    let num_externals = file.read_u32(e)?;
    debug!("num_externals={num_externals}");
    let mut externals = Vec::new();
    for _ in 0..num_externals {
        let something = file.read_cstr()?;
        let guid = file.read_u128_be()?;
        let r#type = file.read_i32(e)?;
        let path_name = file.read_cstr()?;
        externals.push(External {
            guid,
            path_name,
            something,
            r#type,
        })
    }

    if format >= 20 {
        let num_ref_types = file.read_i32(e)?;
        debug!("num_ref_types={num_ref_types}");
        // let mut ref_types = Vec::new();
        for _ in 0..num_ref_types {
            todo!()
        }
    }

    let user_string = file.read_cstr()?;

    Ok(SerializedFile {
        types,
        externals,
        objects,
        scripts,
        user_string,
    })
}