use crate::limits::{MAX_WASM_INSTANTIATION_ARGS, MAX_WASM_INSTANTIATION_EXPORTS};

use crate::prelude::*;

use crate::{

    BinaryReader, ComponentExport, ComponentExternalKind, Export, FromReader, Result,

    SectionLimited,

};

/// Represents the kind of an instantiation argument for a core instance.

#[derive(Debug, Copy, Clone, PartialEq, Eq)]

pub enum InstantiationArgKind {

    /// The instantiation argument is a core instance.

    Instance,

}

/// Represents an argument to instantiating a WebAssembly module.

#[derive(Debug, Clone, Eq, PartialEq)]

pub struct InstantiationArg<'a> {

    /// The name of the module argument.

    pub name: &'a str,

    /// The kind of the module argument.

    pub kind: InstantiationArgKind,

    /// The index of the argument item.

    pub index: u32,

}

/// Represents an instance of a WebAssembly module.

#[derive(Debug, Clone, Eq, PartialEq)]

pub enum Instance<'a> {

    /// The instance is from instantiating a WebAssembly module.

    Instantiate {

        /// The module index.

        module_index: u32,

        /// The module's instantiation arguments.

        args: Box<[InstantiationArg<'a>]>,

    },

    /// The instance is a from exporting local items.

    FromExports(Box<[Export<'a>]>),

}

/// A reader for the core instance section of a WebAssembly component.

///

/// # Examples

///

/// ```

/// use wasmparser::{InstanceSectionReader, BinaryReader};

/// # let data: &[u8] = &[0x01, 0x00, 0x00, 0x01, 0x03, b'f', b'o', b'o', 0x12, 0x00];

/// let reader = BinaryReader::new(data, 0);

/// let mut reader = InstanceSectionReader::new(reader).unwrap();

/// for inst in reader {

///     println!("Instance {:?}", inst.expect("instance"));

/// }

/// ```

pub type InstanceSectionReader<'a> = SectionLimited<'a, Instance<'a>>;

impl<'a> FromReader<'a> for Instance<'a> {

    fn from_reader(reader: &mut BinaryReader<'a>) -> Result<Self> {

        Ok(match reader.read_u8()? {

            0x00 => Instance::Instantiate {

                module_index: reader.read_var_u32()?,

                args: reader

                    .read_iter(MAX_WASM_INSTANTIATION_ARGS, "core instantiation arguments")?

                    .collect::<Result<_>>()?,

            },

            0x01 => Instance::FromExports(

                reader

                    .read_iter(MAX_WASM_INSTANTIATION_ARGS, "core instantiation arguments")?

                    .collect::<Result<_>>()?,

            ),

            x => return reader.invalid_leading_byte(x, "core instance"),

        })

    }

}

impl<'a> FromReader<'a> for InstantiationArg<'a> {

    fn from_reader(reader: &mut BinaryReader<'a>) -> Result<Self> {

        Ok(InstantiationArg {

            name: reader.read()?,

            kind: reader.read()?,

            index: reader.read()?,

        })

    }

}

impl<'a> FromReader<'a> for InstantiationArgKind {

    fn from_reader(reader: &mut BinaryReader<'a>) -> Result<Self> {

        Ok(match reader.read_u8()? {

            0x12 => InstantiationArgKind::Instance,

            x => return reader.invalid_leading_byte(x, "instantiation arg kind"),

        })

    }

}

/// Represents an argument to instantiating a WebAssembly component.

#[derive(Debug, Clone, Eq, PartialEq)]

pub struct ComponentInstantiationArg<'a> {

    /// The name of the component argument.

    pub name: &'a str,

    /// The kind of the component argument.

    pub kind: ComponentExternalKind,

    /// The index of the argument item.

    pub index: u32,

}

/// Represents an instance in a WebAssembly component.

#[derive(Debug, Clone, Eq, PartialEq)]

pub enum ComponentInstance<'a> {

    /// The instance is from instantiating a WebAssembly component.

    Instantiate {

        /// The component index.

        component_index: u32,

        /// The component's instantiation arguments.

        args: Box<[ComponentInstantiationArg<'a>]>,

    },

    /// The instance is a from exporting local items.

    FromExports(Box<[ComponentExport<'a>]>),

}

/// A reader for the component instance section of a WebAssembly component.

///

/// # Examples

///

/// ```

/// use wasmparser::{ComponentInstanceSectionReader, BinaryReader};

/// # let data: &[u8] = &[0x01, 0x00, 0x00, 0x01, 0x03, b'f', b'o', b'o', 0x01, 0x00];

/// let reader = BinaryReader::new(data, 0);

/// let mut reader = ComponentInstanceSectionReader::new(reader).unwrap();

/// for inst in reader {

///     println!("Instance {:?}", inst.expect("instance"));

/// }

/// ```

pub type ComponentInstanceSectionReader<'a> = SectionLimited<'a, ComponentInstance<'a>>;

impl<'a> FromReader<'a> for ComponentInstance<'a> {

    fn from_reader(reader: &mut BinaryReader<'a>) -> Result<Self> {

        Ok(match reader.read_u8()? {

            0x00 => ComponentInstance::Instantiate {

                component_index: reader.read_var_u32()?,

                args: reader

                    .read_iter(MAX_WASM_INSTANTIATION_ARGS, "instantiation arguments")?

                    .collect::<Result<_>>()?,

            },

            0x01 => ComponentInstance::FromExports(

                (0..reader.read_size(MAX_WASM_INSTANTIATION_EXPORTS, "instantiation exports")?)

                    .map(|_| {

                        Ok(ComponentExport {

                            name: reader.read()?,

                            kind: reader.read()?,

                            index: reader.read()?,

                            ty: None,

                        })

                    })

                    .collect::<Result<_>>()?,

            ),

            x => return reader.invalid_leading_byte(x, "instance"),

        })

    }

}

impl<'a> FromReader<'a> for ComponentInstantiationArg<'a> {

    fn from_reader(reader: &mut BinaryReader<'a>) -> Result<Self> {

        Ok(ComponentInstantiationArg {

            name: reader.read()?,

            kind: reader.read()?,

            index: reader.read()?,

        })

    }

}