jvm/src/classfile.rs

use std::io::Read;
use std::error::Error as ErrorTrait;
use core::fmt::{Display, Formatter, Debug};
use core::str::Utf8Error;

use crate::bytecode::Bytecode;
use crate::accessmasks::*;

#[derive(Debug)]
pub enum Error {
    BadFileError(String),
    IOError(std::io::Error),
    Utf8Error(Utf8Error),
    PlatformIntError(core::num::TryFromIntError),
    BadEnumError(String),
}

impl ErrorTrait for Error {}

impl Display for Error {
    fn fmt(&self, formatter: &mut Formatter<'_>) -> Result<(), std::fmt::Error> {
            writeln!(formatter, "{self}")?;
            if let Some(e) = self.source() {
                writeln!(formatter, "\tCaused by: {e:?}")?;
            }
            Ok(())
    }
}

impl From<std::io::Error> for Error {
    fn from(value: std::io::Error) -> Self {
        return Error::IOError(
            value
        );
    }
}

impl From<Utf8Error> for Error {
    fn from(value: Utf8Error) -> Self {
        return Error::Utf8Error(value);
    }
}

impl From<core::num::TryFromIntError> for Error {
    fn from (value: core::num::TryFromIntError) -> Self {
        return Error::PlatformIntError(value);
    }
}

#[derive(Debug)]
pub struct JavaClassFile {
    pub minor_version: u16,
    pub major_version: u16,

    pub constant_pool: Box<[ConstantPoolInfo]>,
    
    pub access_flags: ClassAccessFlagMask,
    
    pub this_class: u16,
    pub super_class: u16,
    
    pub interfaces: Box<[u16]>,
    
    pub fields: Box<[FieldInfo]>,

    pub methods: Box<[MethodInfo]>,
    
    pub attributes: Box<[AttributeInfo]>,
}

impl JavaClassFile {
    pub fn new(reader: &mut dyn Read) -> Result<Self, Error> {

        {
            let magic = read_u32(reader)?;
            if magic != 0xCAFEBABE {
                return Err(
                    Error::BadFileError(
                        format!("Expected magic bytes 0xCAFEBABE but found {:#X}", magic)
                    )
                )
            }
        }

        let minor_version = read_u16(reader)?;
        let major_version = read_u16(reader)?;
        let constant_pool = {
            let constant_pool_count = read_u16(reader)?;
            let constant_pool_size  = constant_pool_count - 1;

            let mut constant_pool_vec   = Vec::with_capacity(constant_pool_size.into());

            let mut i = 0;
            while i < constant_pool_size {
                let cpinfo = ConstantPoolInfo::from_reader(reader)?;
                
                let delta_i = match cpinfo {
                    ConstantPoolInfo::Double(_) | ConstantPoolInfo::Long(_) => 2,
                    _ => 1
                };

                constant_pool_vec.push(cpinfo);

                if delta_i == 2 {
                    constant_pool_vec.push(ConstantPoolInfo::Nothing());
                }
                
                i += delta_i;
            }

            constant_pool_vec.into_boxed_slice()
        };
        let access_flags = ClassAccessFlagMask { mask: read_u16(reader)? };
        let this_class = read_u16(reader)?;
        let super_class = read_u16(reader)?;
        let interfaces = {
            let length = read_u16(reader)?;
            let mut if_vec = Vec::<u16>::with_capacity(length.into());

            for _i in 0..length {
                if_vec.push(read_u16(reader)?);
            }

            if_vec.into_boxed_slice()
        };
        let fields = {
            let length = read_u16(reader)?;
            let mut fields_vec = Vec::with_capacity(length.into());

            for _i in 0..length {
                fields_vec.push(FieldInfo::from_reader(reader, &constant_pool)?);
            }

            fields_vec.into_boxed_slice()
        };
        let methods = {
            let length = read_u16(reader)?;
            let mut methods_vec = Vec::with_capacity(length.into());

            for _i in 0..length {
                methods_vec.push(MethodInfo::from_reader(reader, &constant_pool)?);
            }

            methods_vec.into_boxed_slice()
        };
        let attributes = AttributeInfo::array_from_reader(reader, &constant_pool, true)?;

        Ok(
            JavaClassFile {
                minor_version,
                major_version,
                constant_pool,
                access_flags,
                this_class,
                super_class,
                interfaces,
                fields,
                methods,
                attributes,
            }
        )
    }

    pub fn get_classname(&self) -> Result<String, Error> {
        let class_info_entry = pool_entry(&self.constant_pool, self.this_class as usize)?;

        let class_info_entry = match class_info_entry {
            ConstantPoolInfo::Class(data) => data,
            _ => return Err(Error::BadFileError(format!("Invalid this_class index, expected index to ClassInfo but found {:?}", class_info_entry)))
        };

        let name_entry = pool_entry(&self.constant_pool, class_info_entry.name_index.into())?;
        let name_entry = match name_entry {
            ConstantPoolInfo::Utf8(utf8data) => utf8data,
            _ => return Err(Error::BadFileError(format!("Invalid name_index class_info from this_class, expected index to Utf8 but found {:?}", name_entry)))
        };

        return Ok(name_entry.utf8.clone());
    }


    pub fn find_method_index(&self, name: &String) -> Option<usize> {

        for (index, method_info) in self.methods.iter().enumerate() {
            if method_info.name == *name {
                return Some(index);
            }
        }

        return None;
    }
}

#[derive(Debug)]
pub struct ConstantClassInfo {
    name_index: u16,
}

#[derive(Debug)]
pub struct ConstantFieldRefInfo {
    class_index: u16,
    name_and_type_index: u16,
}

#[derive(Debug)]
pub struct ConstantMethodRefInfo {
    class_index: u16,
    name_and_type_index: u16,
}

#[derive(Debug)]
pub struct ConstantInterfaceMethodRefInfo {
    class_index: u16,
    name_and_type_index: u16,
}

#[derive(Debug)]
pub struct ConstantStringInfo {
    string_index: u16,
}

#[derive(Debug)]
pub struct ConstantIntegerInfo {
    value: i32,
}

#[derive(Debug)]
pub struct ConstantFloatInfo {
    value: f32,
}

#[derive(Debug)]
pub struct ConstantLongInfo {
    value: u64,
}

#[derive(Debug)]
pub struct ConstantDoubleInfo {
    value: f64,
}

#[derive(Debug)]
pub struct ConstantNameAndTypeInfo {
    name_index: u16,
    descriptor_index: u16,
}

#[derive(Debug)]
pub struct ConstantUtf8Info {
    utf8: String
}

#[derive(Debug)]
#[repr(u8)]
pub enum ConstantMethodHandleType {
    RefGetField(u8)         = 1,
    RefGetStatic(u8)        = 2,
    RefPutField(u8)         = 3,
    RefPutStatic(u8)        = 4,
    RefInvokeVirtual(u8)    = 5,
    RefInvokeStatic(u8)     = 6,
    RefInvokeSpecial(u8)    = 7,
    RefNewInvokeSpecial(u8) = 8,
    RefInvokeInterface(u8)  = 9,
}

impl TryFrom<u8> for ConstantMethodHandleType {
    type Error = Error;

    fn try_from(value: u8) -> Result<Self, Self::Error> {
        return match value {
            1 => Ok(Self::RefGetField(value)),
            2 => Ok(Self::RefGetStatic(value)),
            3 => Ok(Self::RefPutField(value)),
            4 => Ok(Self::RefPutStatic(value)),
            5 => Ok(Self::RefInvokeVirtual(value)),
            6 => Ok(Self::RefInvokeStatic(value)),
            7 => Ok(Self::RefInvokeSpecial(value)),
            8 => Ok(Self::RefNewInvokeSpecial(value)),
            9 => Ok(Self::RefInvokeInterface(value)),
            _ => Err(
                Error::BadEnumError(format!("Unexpected MethodHandleType: {}", value))
            ),
        }
    }
}

#[derive(Debug)]
pub struct ConstantMethodHandleInfo {
    reference_kind: ConstantMethodHandleType,
    reference_index: u16,
}

#[derive(Debug)]
pub struct ConstantMethodTypeInfo {
    descriptor_index: u16,
}

#[derive(Debug)]
pub struct ConstantInvokeDynamicInfo {
    bootstrap_method_attr_index: u16,
    name_and_type_index: u16,
}


#[derive(Debug)]
#[repr(u8)]
pub enum ConstantPoolInfo {
    Class(ConstantClassInfo)                            = 7,
    FieldRef(ConstantFieldRefInfo)                      = 9,
    MethodRef(ConstantMethodRefInfo)                    = 10,
    InterfaceMethodRef(ConstantInterfaceMethodRefInfo)  = 11,
    String(ConstantStringInfo)                          = 8,
    Integer(ConstantIntegerInfo)                        = 3,
    Float(ConstantFloatInfo)                            = 4,
    Long(ConstantLongInfo)                              = 5,
    Double(ConstantDoubleInfo)                          = 6,
    NameAndType(ConstantNameAndTypeInfo)                = 12,
    Utf8(ConstantUtf8Info)                              = 1,
    MethodHandle(ConstantMethodHandleInfo)              = 15,
    MethodType(ConstantMethodTypeInfo)                  = 16,
    InvokeDynamic(ConstantInvokeDynamicInfo)            = 18,
    Nothing()                                           = 255,
}

impl ConstantPoolInfo {
    fn from_reader(reader: &mut dyn Read) -> Result<Self, Error> {
        let tag = read_u8(reader)?;

        Ok(
            match tag {

                1 => {
                    ConstantPoolInfo::Utf8(
                        ConstantUtf8Info {
                            utf8: {
                                let length = read_u16(reader)?;
                                let mut buffer: Box<[u8]> = vec![0; length.into()].into_boxed_slice();

                                reader.read_exact(&mut buffer)?;

                                std::str::from_utf8(&buffer)?.to_string()
                            }
                        }
                    )
                }

                3 => {
                    ConstantPoolInfo::Integer(
                        ConstantIntegerInfo {
                            value: read_i32(reader)?
                        }
                    )
                }

                4 => {
                    ConstantPoolInfo::Float(
                        ConstantFloatInfo {
                            value: read_f32(reader)?
                        }
                    )
                }

                5 => {
                    ConstantPoolInfo::Long(
                        ConstantLongInfo {
                            value: read_u64(reader)?
                        }
                    )
                }

                6 => {
                    ConstantPoolInfo::Double(
                        ConstantDoubleInfo {
                            value: read_f64(reader)?
                        }
                    )
                }

                7 => {
                    ConstantPoolInfo::Class(
                        ConstantClassInfo {
                            name_index: read_u16(reader)?
                        }
                    )
                }

                8 => {
                    ConstantPoolInfo::String(
                        ConstantStringInfo {
                            string_index: read_u16(reader)?
                        }
                    )
                }
                
                9 => {
                    ConstantPoolInfo::FieldRef(
                        ConstantFieldRefInfo {
                            class_index: read_u16(reader)?,
                            name_and_type_index: read_u16(reader)?
                        }
                    )
                }

                10 => {
                    ConstantPoolInfo::MethodRef(
                        ConstantMethodRefInfo {
                            class_index: read_u16(reader)?,
                            name_and_type_index: read_u16(reader)?
                        }
                    )
                }

                11 => {
                    ConstantPoolInfo::InterfaceMethodRef(
                        ConstantInterfaceMethodRefInfo {
                            class_index: read_u16(reader)?,
                            name_and_type_index: read_u16(reader)?
                        }
                    )
                }

                12 => {
                    ConstantPoolInfo::NameAndType(
                        ConstantNameAndTypeInfo {
                            name_index: read_u16(reader)?,
                            descriptor_index: read_u16(reader)?
                        }
                    )
                }

                15 => {
                    ConstantPoolInfo::MethodHandle(
                        ConstantMethodHandleInfo {
                            reference_kind: ConstantMethodHandleType::try_from(read_u8(reader)?)?,
                            reference_index: read_u16(reader)?,
                        }
                    )
                }

                16 => {
                    ConstantPoolInfo::MethodType(
                        ConstantMethodTypeInfo {
                            descriptor_index: read_u16(reader)?,
                        }
                    )
                }

                18 => {
                    ConstantPoolInfo::InvokeDynamic(
                        ConstantInvokeDynamicInfo {
                            bootstrap_method_attr_index: read_u16(reader)?,
                            name_and_type_index: read_u16(reader)?,
                        }
                    )
                }

                _ => unreachable!()
            }
        )
    }
}

#[derive(Debug)] 
pub struct FieldInfo {
    access_flags: FieldAccessFlagMask,
    name: String,
    descriptor: AbstractTypeDescription,
    attributes: Box<[AttributeInfo]>,
}

impl FieldInfo {
    fn from_reader(reader: &mut dyn Read, pool: &Box<[ConstantPoolInfo]>) -> Result<Self, Error> {
       let access_flags = FieldAccessFlagMask { mask: read_u16(reader)? };
        let name = {
            let name_index = read_u16(reader)?;

            let name_entry = pool_entry(pool, name_index.into())?;

            match name_entry {
                ConstantPoolInfo::Utf8(utf8info) => utf8info.utf8.clone(),
                _ => return Err(Error::BadFileError(format!("Bad index into constant pool, expected type Utf8 but found {:?}", name_entry))),
            }
        };
        let descriptor: AbstractTypeDescription = {
            let descriptor_index = read_u16(reader)?;

            let descriptor_entry = pool_entry(pool, descriptor_index.into())?;

            match descriptor_entry {
                ConstantPoolInfo::Utf8(utf8info) => {
                    let borrow = &utf8info.utf8;

                    let (length_parsed, type_desc) = AbstractTypeDescription::parse_first(borrow)?;
                    if length_parsed != borrow.len() {
                        Err(Error::BadFileError(format!("Bad field descriptor found: {}", borrow)))?
                    }

                    type_desc
                }
                _ => return Err(Error::BadFileError(format!("Bad index into constant pool, expected type Utf8 but found {:?}", descriptor_entry))),
            }
        };
       let attributes = AttributeInfo::array_from_reader(reader, pool, true)?;

        Ok(
            FieldInfo {
                access_flags,
                name,
                descriptor,
                attributes
            }
        )
    }
}

#[derive(Debug)] 
pub struct ConstantValueAttributeData {
    constant_value_index: u16,
}

#[derive(Debug)] 
pub struct UnknownAttributeData {
    info: Box<[u8]>
}

#[derive(Debug)]
pub struct LineNumberTableEntry {
    start_pc: u16,
    line_number: u16,
}

impl LineNumberTableEntry {
    fn from_reader(reader: &mut dyn Read) -> Result<Self, Error> {
        let start_pc    = read_u16(reader)?;
        let line_number = read_u16(reader)?;

        Ok(
            LineNumberTableEntry {
                start_pc,
                line_number
            }
        )
    }
}

#[derive(Debug)] 
pub struct LineNumberTableAttributeData {
    entries: Box<[LineNumberTableEntry]>
}

impl LineNumberTableAttributeData {
    fn from_reader(reader: &mut dyn Read) -> Result<Self, Error> {
        let length = read_u16(reader)?;
        let mut entry_vec = Vec::with_capacity(length.into());

        for _i in 0..length {
            entry_vec.push(LineNumberTableEntry::from_reader(reader)?);
        }

        Ok(
            LineNumberTableAttributeData {
                entries: entry_vec.into_boxed_slice()
            }
        )
    }
}

#[derive(Debug)] 
pub struct ExceptionTableEntry {
    start_pc: u16,
    end_pc: u16,
    handler_pc: u16,
    catch_type: u16,
}

impl ExceptionTableEntry {
    fn from_reader(reader: &mut dyn Read) -> Result<Self, Error> {
        Ok(
            ExceptionTableEntry {
                start_pc: read_u16(reader)?,
                end_pc: read_u16(reader)?,
                handler_pc: read_u16(reader)?,
                catch_type: read_u16(reader)?,
            }
        )
    }
}

#[derive(Debug)] 
pub struct CodeAttributeData {
    pub max_stack: u16,
    pub max_locals: u16,
    pub code: Bytecode,
    pub exception_table: Box<[ExceptionTableEntry]>,
    pub attributes: Box<[AttributeInfo]>,
}

impl CodeAttributeData {
    fn from_reader(reader: &mut dyn Read, pool: &Box<[ConstantPoolInfo]>) -> Result<Self, Error> {
        let max_stack  = read_u16(reader)?;
        let max_locals = read_u16(reader)?;

        let code_length = read_u32(reader)?;
        let code        = read_buffer(reader, code_length.try_into()?)?;

        let exception_length = read_u16(reader)?;
        let exception_table  = {
            let mut v = Vec::with_capacity(exception_length.into());
            
            for _i in 0..exception_length {
                v.push(ExceptionTableEntry::from_reader(reader)?);
            }

            v.into_boxed_slice()
        };

        let attributes = AttributeInfo::array_from_reader(reader, pool, false)?;

        Ok(
            CodeAttributeData {
                max_stack,
                max_locals,
                code: Bytecode { code },
                exception_table,
                attributes
            }
        )
    }
}

#[derive(Debug)] 
pub struct SourceFileAttributeData {
    source_file_index: u16,
}

impl SourceFileAttributeData {
    fn from_reader(reader: &mut dyn Read) -> Result<Self, Error> {
        Ok(
            SourceFileAttributeData {
                source_file_index: read_u16(reader)?,
            }
        )
    }
}

#[derive(Debug)] 
pub struct SignatureAttributeData {
    signature_index: u16,
}

impl SignatureAttributeData {
    fn from_reader(reader: &mut dyn Read) -> Result<Self, Error> {
        Ok(
            SignatureAttributeData {
                signature_index: read_u16(reader)?,
            }
        )
    }
}

#[derive(Debug)] 
pub struct InnerClassesAttributeEntry {
    inner_class_info_index: u16,
    outer_class_info_index: u16,
    inner_name_index: u16,
    outer_name_index: u16,
}

impl InnerClassesAttributeEntry {
    fn from_reader(reader: &mut dyn Read) -> Result<Self, Error> {
        Ok(
            InnerClassesAttributeEntry {
                inner_class_info_index: read_u16(reader)?,
                outer_class_info_index: read_u16(reader)?,
                inner_name_index: read_u16(reader)?,
                outer_name_index: read_u16(reader)?,
            }
        )
    }
}

#[derive(Debug)] 
pub struct InnerClassesAttributeData {
    classes: Box<[InnerClassesAttributeEntry]>
}

impl InnerClassesAttributeData {
    fn from_reader(reader: &mut dyn Read) -> Result<Self, Error> {
        Ok(
            InnerClassesAttributeData {
                classes: {
                    let length = read_u16(reader)?;
                    let mut v = Vec::with_capacity(length.into());

                    for _i in 0..length {
                        v.push(InnerClassesAttributeEntry::from_reader(reader)?);
                    }

                    v.into_boxed_slice()
                }
            }
        )
    }
}

#[derive(Debug)] 
pub struct NestMembersAttributeData {
    class_indices: Box<[u16]>
}

impl NestMembersAttributeData {
    fn from_reader(reader: &mut dyn Read) -> Result<Self, Error> {
        Ok(
            NestMembersAttributeData {
                class_indices: {
                    let length = read_u16(reader)?;
                    let mut v = Vec::with_capacity(length.into());

                    for _i in 0..length {
                        v.push(read_u16(reader)?);
                    }

                    v.into_boxed_slice()
                }
            }
        )
    }
}

#[derive(Debug)] 
pub enum AttributeData {
    Code(CodeAttributeData),
    Signature(SignatureAttributeData),
    NestMembers(NestMembersAttributeData),
    SourceFile(SourceFileAttributeData),
    InnerClasses(InnerClassesAttributeData),
    ConstantValue(ConstantValueAttributeData),
    LineNumberTable(LineNumberTableAttributeData),
    Unknown(UnknownAttributeData),
}

#[derive(Debug)] 
pub struct AttributeInfo {
    pub attribute_name_index: u16,
    pub data: AttributeData
}

impl AttributeInfo {
    fn array_from_reader(reader: &mut dyn Read, pool: &Box<[ConstantPoolInfo]>, allow_code_attr: bool) -> Result<Box<[Self]>, Error> {
       let length = read_u16(reader)?;
       let mut attr_vec = Vec::with_capacity(length.into());

       for _i in 0..length {
            let attribute = AttributeInfo::from_reader(reader, &pool, allow_code_attr)?;
            attr_vec.push(attribute);
       }

       Ok(attr_vec.into_boxed_slice())
    }

    fn from_reader(reader: &mut dyn Read, pool: &Box<[ConstantPoolInfo]>, allow_code_attr: bool) -> Result<Self, Error> {
        let attribute_name_index: u16   = read_u16(reader)? - 1;
        let _attribute_byte_size: usize = read_u32(reader)?.try_into()?;

        let data = {
            let name_entry = &pool[attribute_name_index as usize];
            let utf8 = match name_entry {
                ConstantPoolInfo::Utf8( ConstantUtf8Info { utf8 } ) => utf8,
                _ => return Err(Error::BadFileError(format!("Bad name index for attribute info: {}", attribute_name_index))),
            };

            match &utf8[..] {
               "ConstantValue" => AttributeData::ConstantValue(
                   ConstantValueAttributeData {
                       constant_value_index: read_u16(reader)?,
                   }
               ),

               "LineNumberTable" => AttributeData::LineNumberTable(
                   LineNumberTableAttributeData::from_reader(reader)?
               ),

               "Code" => if allow_code_attr { 
                   AttributeData::Code(
                    CodeAttributeData::from_reader(reader, pool)?
                    ) 
               } else {
                   return Err(Error::BadFileError("Nested Code attributes are forbidden.".to_string()));
               },

               "SourceFile" => AttributeData::SourceFile(SourceFileAttributeData::from_reader(reader)?),

               "Signature" =>  AttributeData::Signature(SignatureAttributeData::from_reader(reader)?),

               "InnerClasses" =>  AttributeData::InnerClasses(InnerClassesAttributeData::from_reader(reader)?),

               "NestMembers" => AttributeData::NestMembers(NestMembersAttributeData::from_reader(reader)?),

                &_ => AttributeData::Unknown(
                    UnknownAttributeData {
                        info: read_buffer(reader, _attribute_byte_size)?,
                    }
                )
            }
        };

        Ok(
            AttributeInfo {
                attribute_name_index,
                data
            }
        )
    }
}

#[repr(u8)]
#[derive(Debug)]
pub enum AbstractTypeKind {
    Void()              = b'V', // void
    Byte()              = b'B', //  signed byte
    Char()              = b'C', //  Unicode character code point in the Basic Multilingual Plane, encoded with UTF-16
    Double()            = b'D', //  double-precision floating-point value
    Float()             = b'F', //  single-precision floating-point value
    Int()               = b'I', //  integer
    Long()              = b'J', //  long integer
    Classname(String)   = b'L', //  an instance of class ClassName
    Short()             = b'S', //  signed short
    Boolean()           = b'Z', //  true or false
}

#[derive(Debug)]
pub struct AbstractTypeDescription {
    array_level: u8,
    kind: AbstractTypeKind,
}

impl AbstractTypeDescription {
    fn parse_first(s: &str) -> Result<(usize, Self), Error> {
        let mut offset: usize = 0;
        let arrays_parsed = s.trim_start_matches("[");
        let array_level = (s.len() - arrays_parsed.len()).try_into();
        let array_level: u8 = match array_level {
            Ok(s) => s,
            Err(_e) => return Err(Error::BadFileError(format!("Too many array levels in method descriptor! Max is 255 but found {}", s.len() - arrays_parsed.len()))),
        };
        offset += array_level as usize;

        let type_char = arrays_parsed.chars().nth(0).ok_or(Error::BadFileError("Missing type char in method descriptor".to_string()))?;
        offset += 1;
        let kind = match type_char {
            'B' => AbstractTypeKind::Byte(),
            'C' => AbstractTypeKind::Char(),
            'D' => AbstractTypeKind::Double(),
            'F' => AbstractTypeKind::Float(),
            'I' => AbstractTypeKind::Int(),
            'J' => AbstractTypeKind::Long(),
            'S' => AbstractTypeKind::Short(),
            'Z' => AbstractTypeKind::Boolean(),
            'V' => AbstractTypeKind::Void(),
            'L' => {
                let semicolon_index = s.get(offset..).unwrap().find(";").ok_or(Error::BadFileError(format!("Missing ';' in type descriptor: {}", s)))?;
                let classname_start = offset;
                let classname_end   = offset + semicolon_index;
                let classname_string = s.get(classname_start..classname_end).unwrap();

                offset += classname_string.len() + 1;

                AbstractTypeKind::Classname(classname_string.to_string())
            }
            _ => return Err(Error::BadFileError(format!("Invalid Type character: '{}' in string \"{}\"", type_char, s))),
        };

        return Ok((offset, AbstractTypeDescription { array_level, kind }))
    }
}

#[derive(Debug)] 
pub struct MethodDescriptor {
    argument_types: Box<[AbstractTypeDescription]>,
    return_type: AbstractTypeDescription,
}

impl TryFrom<&String> for MethodDescriptor {
    type Error = Error;

    fn try_from(s: &String) -> Result<Self, Error> {

        let mut total_offset: usize = 0;
        s.strip_prefix("(")
            .ok_or(Error::BadFileError(format!("Bad method descriptor: '{}'", s)))?;
        total_offset += 1;

        let mut args = Vec::new();

        while ! s.get(total_offset..).unwrap().starts_with(")") {
            let (offset, arg_type) = AbstractTypeDescription::parse_first(s.get(total_offset..).unwrap())?;

            total_offset += offset;
            args.push(arg_type);
        }

        s.get(total_offset..).unwrap()
            .strip_prefix(")")
            .ok_or(Error::BadFileError(format!("Bad method descriptor")))?;
        total_offset += 1;


        let (offset, return_type) = AbstractTypeDescription::parse_first(s.get(total_offset..).unwrap())?;
        if offset != s.get(total_offset..).unwrap().len() {
            return Err(Error::BadFileError(format!("Trailing characters in method descriptor string: \"{}\"", s)))
        }

        Ok(
            MethodDescriptor {
                argument_types: args.into_boxed_slice(),
                return_type,
            }
        )
    }
}

#[derive(Debug)] 
pub struct MethodInfo {
    pub access_flags: MethodAccessFlagMask,
    pub name: String,
    pub descriptor: MethodDescriptor,
    pub code_attribute_index: usize,
    pub attributes: Box<[AttributeInfo]>,
}

impl MethodInfo {
    fn from_reader(reader: &mut dyn Read, pool: &Box<[ConstantPoolInfo]>) -> Result<Self, Error> {
        let access_flags = MethodAccessFlagMask { mask: read_u16(reader)? };
        let name = {
            let name_index = read_u16(reader)?;

            let name_entry = pool_entry(pool, name_index.into())?;

            match name_entry {
                ConstantPoolInfo::Utf8(utf8info) => utf8info.utf8.clone(),
                _ => return Err(Error::BadFileError(format!("Bad index into constant pool, expected type Utf8 but found {:?}", name_entry))),
            }
        };
        let descriptor: MethodDescriptor = {
            let descriptor_index = read_u16(reader)?;

            let descriptor_entry = pool_entry(pool, descriptor_index.into())?;

            match descriptor_entry {
                ConstantPoolInfo::Utf8(utf8info) => {
                    let borrow = &utf8info.utf8;

                    borrow.try_into()?
                }
                _ => return Err(Error::BadFileError(format!("Bad index into constant pool, expected type Utf8 but found {:?}", descriptor_entry))),
            }
        };
        let attributes = AttributeInfo::array_from_reader(reader, pool, true)?;

        let code_attribute_index = attributes.iter()
            .position(|info| match info.data {AttributeData::Code(_) => true, _ => false })
            .unwrap_or(attributes.len());

        Ok(
            MethodInfo {
                access_flags,
                name,
                descriptor,
                code_attribute_index,
                attributes
            }
        )
    }
}


fn read_buffer(reader: &mut dyn Read, size: usize) -> Result<Box<[u8]>, Error> {
    let mut buffer: Box<[u8]> = vec![0; size].into_boxed_slice();

    reader.read_exact(&mut buffer)?;

    Ok(buffer)
}

fn read_f64(reader: &mut dyn Read) -> Result<f64, std::io::Error> {
//    let bytes = read_u64(reader)?;
// 
//    let sign = if (bytes >> 63) == 0 { 1 } else { -1 } as f64;
//    let exponent: f64 = ((bytes >> 52) & 0x7FF) as f64;
//    let mantissa: f64 = if exponent == 0.0 {
//            (bytes & 0xfffffffffffff) << 1
//        } else {
//           (bytes & 0xfffffffffffff) | 0x10000000000000
//        } as f64;
//    let base: f64 = 2.0;
// 
// 
//    return Ok(sign * mantissa * base.powf(exponent-1075.0));

    let mut buffer: [u8; 8] = [0; 8];
    reader.read_exact(&mut buffer)?;

    return Ok(f64::from_be_bytes(buffer));
}

fn read_f32(reader: &mut dyn Read) -> Result<f32, std::io::Error> {
    let mut buffer: [u8; 4] = [0; 4];
    reader.read_exact(&mut buffer)?;

    return Ok(f32::from_be_bytes(buffer));
}

fn read_i32(reader: &mut dyn Read) -> Result<i32, std::io::Error> {
    let mut buffer: [u8; 4] = [0; 4];
    reader.read_exact(&mut buffer)?;

    return Ok(i32::from_be_bytes(buffer));
}

fn read_u64(reader: &mut dyn Read) -> Result<u64, std::io::Error> {
    let high_bytes: u64 = read_u32(reader)?.into();
    let low_bytes:  u64 = read_u32(reader)?.into();

    return Ok((high_bytes << 32) | low_bytes);
}

fn read_u32(reader: &mut dyn Read) -> Result<u32, std::io::Error> {
        let mut u32_buffer: [u8; 4] = [0; 4];

        reader.read_exact(&mut u32_buffer)?;

        return Ok(u32::from_be_bytes(u32_buffer));
}

fn read_u16(reader: &mut dyn Read) -> Result<u16, std::io::Error> {
        let mut u16_buffer: [u8; 2] = [0; 2];

        reader.read_exact(&mut u16_buffer)?;

        return Ok(u16::from_be_bytes(u16_buffer));
}

fn read_u8(reader: &mut dyn Read) -> Result<u8, std::io::Error> {
        let mut u8_buffer: [u8; 1] = [0; 1];

        reader.read_exact(&mut u8_buffer)?;

        return Ok(u8::from_be_bytes(u8_buffer));
}

fn pool_entry<'a>(pool: &Box<[ConstantPoolInfo]>, index: usize) -> Result<&ConstantPoolInfo, Error> {
    if index == 0 {
        return Err(Error::BadFileError(format!("Bad pool index: 0")));
    }
    if index - 1 >= pool.len() {
        return Err(Error::BadFileError(format!("Bad pool index: {}", index - 1)));
    }

    return Ok(&pool[index - 1]);
}