use crate::kw;

use crate::parser::{Cursor, Parse, Parser, Peek, Result};

use crate::token::{Index, Span};

/// A entry in a WebAssembly module's export section.

#[derive(Debug)]

pub struct Export<'a> {

    /// Where this export was defined.

    pub span: Span,

    /// The name of this export from the module.

    pub name: &'a str,

    /// The kind of item being exported.

    pub kind: ExportKind,

    /// What's being exported from the module.

    pub item: Index<'a>,

}

/// Different kinds of elements that can be exported from a WebAssembly module,

/// contained in an [`Export`].

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

#[allow(missing_docs)]

pub enum ExportKind {

    Func,

    Table,

    Memory,

    Global,

    Tag,

}

impl<'a> Parse<'a> for Export<'a> {

    fn parse(parser: Parser<'a>) -> Result<Self> {

        let span = parser.parse::<kw::export>()?.0;

        let name = parser.parse()?;

        let (kind, item) = parser.parens(|p| Ok((p.parse()?, p.parse()?)))?;

        Ok(Export {

            span,

            name,

            kind,

            item,

        })

    }

}

impl<'a> Parse<'a> for ExportKind {

    fn parse(parser: Parser<'a>) -> Result<Self> {

        let mut l = parser.lookahead1();

        if l.peek::<kw::func>()? {

            parser.parse::<kw::func>()?;

            Ok(ExportKind::Func)

        } else if l.peek::<kw::table>()? {

            parser.parse::<kw::table>()?;

            Ok(ExportKind::Table)

        } else if l.peek::<kw::memory>()? {

            parser.parse::<kw::memory>()?;

            Ok(ExportKind::Memory)

        } else if l.peek::<kw::global>()? {

            parser.parse::<kw::global>()?;

            Ok(ExportKind::Global)

        } else if l.peek::<kw::tag>()? {

            parser.parse::<kw::tag>()?;

            Ok(ExportKind::Tag)

        } else {

            Err(l.error())

        }

    }

}

impl Peek for ExportKind {

    fn peek(cursor: Cursor<'_>) -> Result<bool> {

        Ok(kw::func::peek(cursor)?

            || kw::table::peek(cursor)?

            || kw::memory::peek(cursor)?

            || kw::global::peek(cursor)?

            || kw::tag::peek(cursor)?)

    }

    fn display() -> &'static str {

        "export kind"

    }

}

macro_rules! kw_conversions {

    ($($kw:ident => $kind:ident)*) => ($(

        impl From<kw::$kw> for ExportKind {

            fn from(_: kw::$kw) -> ExportKind {

                ExportKind::$kind

            }

Unexecuted instantiation: <wast::core::export::ExportKind as core::convert::From<wast::kw::func>>::from

Unexecuted instantiation: <wast::core::export::ExportKind as core::convert::From<wast::kw::table>>::from

Unexecuted instantiation: <wast::core::export::ExportKind as core::convert::From<wast::kw::global>>::from

Unexecuted instantiation: <wast::core::export::ExportKind as core::convert::From<wast::kw::tag>>::from

Unexecuted instantiation: <wast::core::export::ExportKind as core::convert::From<wast::kw::memory>>::from

        }

        impl Default for kw::$kw {

            fn default() -> kw::$kw {

                kw::$kw(Span::from_offset(0))

            }

Unexecuted instantiation: <wast::kw::func as core::default::Default>::default

Unexecuted instantiation: <wast::kw::table as core::default::Default>::default

Unexecuted instantiation: <wast::kw::global as core::default::Default>::default

Unexecuted instantiation: <wast::kw::tag as core::default::Default>::default

Unexecuted instantiation: <wast::kw::memory as core::default::Default>::default

        }

    )*);

}

kw_conversions! {

    func => Func

    table => Table

    global => Global

    tag => Tag

    memory => Memory

}

/// A listing of inline `(export "foo")` statements on a WebAssembly item in

/// its textual format.

#[derive(Debug, Default)]

pub struct InlineExport<'a> {

    /// The extra names to export an item as, if any.

    pub names: Vec<&'a str>,

}

impl<'a> Parse<'a> for InlineExport<'a> {

    fn parse(parser: Parser<'a>) -> Result<Self> {

        let mut names = Vec::new();

        while parser.peek::<Self>()? {

            names.push(parser.parens(|p| {

                p.parse::<kw::export>()?;

                p.parse::<&str>()

            })?);

        }

        Ok(InlineExport { names })

    }

}

impl Peek for InlineExport<'_> {

    fn peek(cursor: Cursor<'_>) -> Result<bool> {

        let cursor = match cursor.lparen()? {

            Some(cursor) => cursor,

            None => return Ok(false),

        };

        let cursor = match cursor.keyword()? {

            Some(("export", cursor)) => cursor,

            _ => return Ok(false),

        };

        let cursor = match cursor.string()? {

            Some((_, cursor)) => cursor,

            None => return Ok(false),

        };

        Ok(cursor.rparen()?.is_some())

    }

    fn display() -> &'static str {

        "inline export"

    }

}