use crate::component::*;
use crate::kw;
use crate::parser::{Cursor, Parse, Parser, Peek, Result};
use crate::token::{Id, Index, LParen, NameAnnotation, Span};

/// An `import` statement and entry in a WebAssembly component.
#[derive(Debug)]
pub struct ComponentImport<'a> {
    /// Where this `import` was defined
    pub span: Span,
    /// The name of the item being imported.
    pub name: ComponentExternName<'a>,
    /// The item that's being imported.
    pub item: ItemSig<'a>,
}

impl<'a> Parse<'a> for ComponentImport<'a> {
    fn parse(parser: Parser<'a>) -> Result<Self> {
        let span = parser.parse::<kw::import>()?.0;
        let name = parser.parse()?;
        let item = parser.parens(|p| p.parse())?;
        Ok(ComponentImport { span, name, item })
    }
}

/// Identifiers, and metadata, for component imports and exports.
#[derive(Debug, Copy, Clone)]
pub struct ComponentExternName<'a> {
    /// The string name this is referring to.
    pub name: &'a str,
    /// For imports, an optional `(implements "...")` directive.
    pub implements: Option<&'a str>,
    /// For imports, an optional `(versionsuffix "...")` directive.
    pub version_suffix: Option<&'a str>,
    /// For imports, an optional `(external-id "...")` directive.
    pub external_id: Option<&'a str>,
}

impl<'a> Parse<'a> for ComponentExternName<'a> {
    fn parse(parser: Parser<'a>) -> Result<Self> {
        // Prior to WebAssembly/component-model#263 the syntactic form
        // `(interface "...")` was supported for interface names. This is no
        // longer part of the syntax of the binary format nor the text format,
        // but continue to parse this as "sugar" for the current format. This
        // is intended to avoid breaking folks and provide a smoother transition
        // forward.
        let name = if parser.peek::<LParen>()? {
            parser.parens(|p| {
                p.parse::<kw::interface>()?;
                p.parse()
            })?
        } else {
            parser.parse()?
        };
        let implements = if parser.peek2::<kw::implements>()? {
            Some(parser.parens(|p| {
                p.parse::<kw::implements>()?;
                p.parse()
            })?)
        } else {
            None
        };
        let version_suffix = if parser.peek2::<kw::versionsuffix>()? {
            Some(parser.parens(|p| {
                p.parse::<kw::versionsuffix>()?;
                p.parse()
            })?)
        } else {
            None
        };
        let external_id = if parser.peek2::<kw::external_id>()? {
            Some(parser.parens(|p| {
                p.parse::<kw::external_id>()?;
                p.parse()
            })?)
        } else {
            None
        };
        Ok(ComponentExternName {
            name,
            implements,
            version_suffix,
            external_id,
        })
    }
}

/// An item signature for imported items.
#[derive(Debug)]
pub struct ItemSig<'a> {
    /// Where this item is defined in the source.
    pub span: Span,
    /// An optional identifier used during name resolution to refer to this item
    /// from the rest of the component.
    pub id: Option<Id<'a>>,
    /// An optional name which, for functions, will be stored in the
    /// custom `name` section.
    pub name: Option<NameAnnotation<'a>>,
    /// What kind of item this is.
    pub kind: ItemSigKind<'a>,
}

impl<'a> Parse<'a> for ItemSig<'a> {
    fn parse(parser: Parser<'a>) -> Result<Self> {
        parse_item_sig(parser, true)
    }
}

/// An item signature for imported items.
#[derive(Debug)]
pub struct ItemSigNoName<'a>(pub ItemSig<'a>);

impl<'a> Parse<'a> for ItemSigNoName<'a> {
    fn parse(parser: Parser<'a>) -> Result<Self> {
        Ok(ItemSigNoName(parse_item_sig(parser, false)?))
    }
}

fn parse_item_sig<'a>(parser: Parser<'a>, name: bool) -> Result<ItemSig<'a>> {
    let mut l = parser.lookahead1();
    let (span, parse_kind): (_, fn(Parser<'a>) -> Result<ItemSigKind<'a>>) =
        if l.peek::<kw::core>()? {
            let span = parser.parse::<kw::core>()?.0;
            parser.parse::<kw::module>()?;
            (span, |parser| Ok(ItemSigKind::CoreModule(parser.parse()?)))
        } else if l.peek::<kw::func>()? {
            let span = parser.parse::<kw::func>()?.0;
            (span, |parser| Ok(ItemSigKind::Func(parser.parse()?)))
        } else if l.peek::<kw::component>()? {
            let span = parser.parse::<kw::component>()?.0;
            (span, |parser| Ok(ItemSigKind::Component(parser.parse()?)))
        } else if l.peek::<kw::instance>()? {
            let span = parser.parse::<kw::instance>()?.0;
            (span, |parser| Ok(ItemSigKind::Instance(parser.parse()?)))
        } else if l.peek::<kw::value>()? {
            let span = parser.parse::<kw::value>()?.0;
            (span, |parser| Ok(ItemSigKind::Value(parser.parse()?)))
        } else if l.peek::<kw::r#type>()? {
            let span = parser.parse::<kw::r#type>()?.0;
            (span, |parser| {
                Ok(ItemSigKind::Type(parser.parens(|parser| parser.parse())?))
            })
        } else {
            return Err(l.error());
        };
    Ok(ItemSig {
        span,
        id: if name { parser.parse()? } else { None },
        name: if name { parser.parse()? } else { None },
        kind: parse_kind(parser)?,
    })
}

/// The kind of signatures for imported items.
#[derive(Debug)]
pub enum ItemSigKind<'a> {
    /// The item signature is for a core module.
    CoreModule(CoreTypeUse<'a, ModuleType<'a>>),
    /// The item signature is for a function.
    Func(ComponentTypeUse<'a, ComponentFunctionType<'a>>),
    /// The item signature is for a component.
    Component(ComponentTypeUse<'a, ComponentType<'a>>),
    /// The item signature is for an instance.
    Instance(ComponentTypeUse<'a, InstanceType<'a>>),
    /// The item signature is for a value.
    Value(ComponentValTypeUse<'a>),
    /// The item signature is for a type.
    Type(TypeBounds<'a>),
}

/// Represents the bounds applied to types being imported.
#[derive(Debug)]
pub enum TypeBounds<'a> {
    /// The equality type bounds.
    Eq(Index<'a>),
    /// A resource type is imported/exported,
    SubResource,
}

impl<'a> Parse<'a> for TypeBounds<'a> {
    fn parse(parser: Parser<'a>) -> Result<Self> {
        let mut l = parser.lookahead1();
        if l.peek::<kw::eq>()? {
            parser.parse::<kw::eq>()?;
            Ok(Self::Eq(parser.parse()?))
        } else if l.peek::<kw::sub>()? {
            parser.parse::<kw::sub>()?;
            parser.parse::<kw::resource>()?;
            Ok(Self::SubResource)
        } else {
            Err(l.error())
        }
    }
}

/// A listing of a inline `(import "foo")` statement.
///
/// This is the same as `core::InlineImport` except only one string import is
/// required.
#[derive(Debug, Clone)]
pub struct InlineImport<'a> {
    /// The name of the item being imported.
    pub name: ComponentExternName<'a>,
}

impl<'a> Parse<'a> for InlineImport<'a> {
    fn parse(parser: Parser<'a>) -> Result<Self> {
        parser.parens(|p| {
            p.parse::<kw::import>()?;
            Ok(InlineImport { name: p.parse()? })
        })
    }
}

impl Peek for InlineImport<'_> {
    fn peek(cursor: Cursor<'_>) -> Result<bool> {
        let cursor = match cursor.lparen()? {
            Some(cursor) => cursor,
            None => return Ok(false),
        };
        let cursor = match cursor.keyword()? {
            Some(("import", cursor)) => cursor,
            _ => return Ok(false),
        };

        // (import "foo")
        if let Some((_, cursor)) = cursor.string()? {
            return Ok(cursor.rparen()?.is_some());
        }

        // (import (interface "foo"))
        let cursor = match cursor.lparen()? {
            Some(cursor) => cursor,
            None => return Ok(false),
        };
        let cursor = match cursor.keyword()? {
            Some(("interface", cursor)) => cursor,
            _ => return Ok(false),
        };
        let cursor = match cursor.string()? {
            Some((_, cursor)) => cursor,
            _ => return Ok(false),
        };
        let cursor = match cursor.rparen()? {
            Some(cursor) => cursor,
            _ => return Ok(false),
        };
        Ok(cursor.rparen()?.is_some())
    }

    fn display() -> &'static str {
        "inline import"
    }
}
