use super::Value;
use crate::helper::{AlignExt, Endianness, ReadExt};
use crate::serialized_file::TypeTreeNode;
use anyhow::{Result, bail};
use log::trace;
use std::io::Seek;
use std::{collections::BTreeMap, io::Read};

impl Value {
    pub fn read(ty: &TypeTreeNode, e: Endianness, data: &mut (impl Read + Seek)) -> Result<Value> {
        let mut align = false;
        let pos_before = data.stream_position()?;
        let r = match ty.type_string.as_str() {
            "char" => {
                assert_eq!(ty.byte_size, 1);
                Ok(Value::U8(data.read_u8()?))
            }
            "Type*" => Ok(Value::U32(data.read_u32(e)?)),
            "int" => Ok(Value::I32(data.read_i32(e)?)),
            "unsigned int" => Ok(Value::U32(data.read_u32(e)?)),
            "UInt8" => Ok(Value::U8(data.read_u8()?)),
            "UInt16" => Ok(Value::U16(data.read_u16(e)?)),
            "UInt32" => Ok(Value::U32(data.read_u32(e)?)),
            "UInt64" => Ok(Value::U64(data.read_u64(e)?)),
            "SInt8" => Ok(Value::I8(data.read_i8()?)),
            "SInt16" => Ok(Value::I16(data.read_i16(e)?)),
            "SInt32" => Ok(Value::I32(data.read_i32(e)?)),
            "SInt64" => Ok(Value::I64(data.read_i64(e)?)),
            "bool" => Ok(Value::Bool(data.read_u8()? != 0)),
            "float" => {
                data.align(4)?;
                Ok(Value::F32(data.read_f32(e)?))
            }
            "double" => {
                data.align(4)?;
                Ok(Value::F64(data.read_f64(e)?))
            }
            "string" => {
                let Value::Array(arr) = Value::read(&ty.children[0], e, data)? else {
                    unreachable!()
                };
                let bytes = arr
                    .into_iter()
                    .map(|e| match e {
                        Value::U8(x) => x,
                        _ => unreachable!(),
                    })
                    .collect::<Vec<_>>();
                Ok(Value::String(String::from_utf8(bytes)?))
            }
            "Array" => {
                align |= ty.children[0].post_align();
                assert_eq!(ty.byte_size, -1);
                let Value::I32(size) = Value::read(&ty.children[0], e, data)? else {
                    unreachable!()
                };
                trace!("array of size {size}");
                let mut elems = Vec::new();
                for _ in 0..size {
                    elems.push(Value::read(&ty.children[1], e, data)?);
                }
                Ok(Value::Array(elems))
            }
            "TypelessData" => {
                let len = data.read_u32(e)?;
                let mut buf = vec![0u8; len as usize];
                data.read_exact(&mut buf)?;
                Ok(Value::Typeless(buf))
            }
            _ => {
                if ty.children.is_empty() && ty.byte_size != 0 {
                    todo!("need type {:?}", ty.type_string);
                }
                let mut fields = BTreeMap::new();
                for c in &ty.children {
                    fields.insert(c.name_string.clone(), Value::read(&c, e, data)?);
                }
                Ok(Value::Object {
                    fields,
                    class: ty.type_string.clone(),
                })
            }
        };
        let pos_after = data.stream_position()?;
        if ty.byte_size != -1 && pos_after - pos_before < ty.byte_size as u64 {
            bail!(
                "did not read enough data ({} expected, {} actual)",
                ty.byte_size,
                pos_after - pos_before
            );
        }
        if align || ty.post_align() {
            trace!("post align");
            data.align(4)?;
        }
        r
    }
}