use crate::{
    common_strings::COMMON_STRINGS,
    helper::{AlignExt, Endianness, ReadExt},
    object::Value,
    unityfs::{UnityFS, header::NodeInfo},
};
use anyhow::{Result, anyhow, bail};
use log::{debug, info, trace, warn};
use std::io::{Cursor, Read, Seek, SeekFrom};

#[derive(Debug, Clone)]
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,

    pub children: Vec<TypeTreeNode>,
}

#[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: Option<TypeTreeNode>,
    pub type_deps: Vec<u32>,
}

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

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

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

pub struct SerializedFile<T> {
    pub file: T,
    pub file_source_id: usize,
    pub header: SerializedFileHeader,
    pub types: Vec<SeralizedType>,
    pub externals: Vec<External>,
    pub scripts: Vec<Script>,
    pub objects: Vec<ObjectInfo>,
    pub user_string: String,
    pub endianness: Endianness,
}

impl<T> std::fmt::Debug for SerializedFile<T> {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        f.debug_struct("SerializedFile")
            .field("header", &self.header)
            .field("types", &self.types)
            .field("externals", &self.externals)
            .field("scripts", &self.scripts)
            .field("objects", &self.objects)
            .field("user_string", &self.user_string)
            .field("endianness", &self.endianness)
            .finish()
    }
}

#[derive(Debug)]
pub struct SerializedFileHeader {
    _metadata_size: u32,
    _file_size: u64,
    pub format: u32,
    data_offset: u64,
    endianness: Endianness,
    pub generator_version: String,
    pub target_platform: u32,
}

impl SerializedFileHeader {
    pub fn read(mut file: impl Read + Seek) -> Result<Self> {
        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;

        if format >= 1000 {
            bail!("bad format version {format:x}")
        }
        info!("File format version: {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_be()?;
            file_size = file.read_u64_be()?;
            data_offset = file.read_u64_be()?;
            file.read_u64_be()?;
        }
        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()?;
        info!("Generator version: {generator_version:?}");
        debug!("target_platform={target_platform}");
        Ok(Self {
            data_offset,
            _file_size: file_size,
            endianness: e,
            format,
            _metadata_size: metadata_size,
            target_platform,
            generator_version,
        })
    }
}

impl<T: Read + Seek> SerializedFile<T> {
    pub fn read(mut file: T, file_source_id: usize) -> Result<SerializedFile<T>> {
        let h = SerializedFileHeader::read(&mut file)?;
        let e = h.endianness;

        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 = None;
            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;
                        if off as usize > COMMON_STRINGS.len() {
                            warn!("common strings missing index {off:08x}");
                            b"<common string missing>"
                        } else {
                            &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>>(),
                    )
                };

                let mut parents: Vec<TypeTreeNode> = vec![];
                for _ in 0..num_nodes {
                    let node = 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)?,
                        children: vec![],
                    };
                    if node.level == 0 && !parents.is_empty() {
                        warn!("unexpected toplevel typetree node");
                        parents.clear();
                    }
                    while parents.len() > node.level as usize {
                        let n = parents.pop().unwrap();
                        parents.last_mut().unwrap().children.push(n)
                    }
                    parents.push(node);
                }
                while parents.len() > 1 {
                    let n = parents.pop().unwrap();
                    parents.last_mut().unwrap().children.push(n)
                }
                type_tree = parents.pop();

                if h.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 h.format >= 22 {
                file.read_u64(e)?
            } else {
                file.read_u32(e)? as u64
            } + h.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 h.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 {
            file,
            header: h,
            types,
            externals,
            endianness: e,
            objects,
            scripts,
            user_string,
            file_source_id,
        })
    }

    pub fn find_fs_shared_assets(&self, fs: &UnityFS<impl Read + Seek>) -> Option<NodeInfo> {
        let s = self
            .externals
            .iter()
            .find(|e| e.path_name.starts_with("archive:"))?;
        fs.header
            .nodes()
            .iter()
            .find(|n| s.path_name.ends_with(&n.name))
            .cloned()
    }

    pub fn get_object_type_tree(&self, ob: &ObjectInfo) -> Result<&'_ TypeTreeNode> {
        let r#type = if ob.type_id < 0 {
            unimplemented!()
        } else {
            &self.types[ob.type_id as usize]
        };
        r#type
            .type_tree
            .as_ref()
            .ok_or(anyhow!("type tree missing"))
    }
    pub fn read_object(&mut self, ob: ObjectInfo) -> Result<Value> {
        self.file.seek(SeekFrom::Start(ob.data_offset))?;
        //? Duplicated impl from get_object_type_tree because borrow problem
        let r#type = if ob.type_id < 0 {
            unimplemented!()
        } else {
            &self.types[ob.type_id as usize]
        };
        let typetree = r#type
            .type_tree
            .as_ref()
            .ok_or(anyhow!("type tree missing"))?;
        Value::read(
            typetree,
            self.endianness,
            self.file_source_id,
            &mut self.file,
        )
    }

    pub fn all_objects_of_class(&self, class_name: &str) -> impl Iterator<Item = &ObjectInfo> {
        self.objects.iter().filter(move |o| {
            self.get_object_type_tree(&o)
                .map_or(false, |t| t.type_string == class_name)
        })
    }
}

impl TypeTreeNode {
    pub fn post_align(&self) -> bool {
        self.flags & 0x4000 != 0
    }
}