//! Execute block statement syntax tree.

use derive_more::From;
use enum_as_inner::EnumAsInner;
use getset::Getters;

use crate::{
    base::{
        self,
        source_file::{SourceElement, Span},
        Handler, VoidHandler,
    },
    lexical::{
        token::{Keyword, KeywordKind, Punctuation, StringLiteral, Token},
        token_stream::Delimiter,
    },
    syntax::{
        error::{Error, ParseResult, SyntaxKind, UnexpectedSyntax},
        parser::{DelimitedTree, Parser, Reading},
        syntax_tree::condition::ParenthesizedCondition,
    },
};

use super::Block;

/// Represents an execute block statement in the syntax tree.
///
/// Syntax Synopsis:
/// ```ebnf
/// ExecuteBlock:
///    (ExecuteBlockHead ExecuteBlockTail)
///   | (Conditional Block Else)
///   ;
/// ```
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, EnumAsInner)]
#[allow(missing_docs)]
pub enum ExecuteBlock {
    HeadTail(ExecuteBlockHead, ExecuteBlockTail),
    IfElse(Conditional, Block, Else),
}
impl SourceElement for ExecuteBlock {
    fn span(&self) -> Span {
        match self {
            Self::HeadTail(head, tail) => head.span().join(&tail.span()).unwrap(),
            Self::IfElse(conditional, block, else_) => conditional
                .span()
                .join(&block.span())
                .unwrap()
                .join(&else_.span())
                .unwrap(),
        }
    }
}

/// Represents the head of an execute block statement.
///
/// Syntax Synopsis:
///
/// ```ebnf
/// ExecuteBlockHead:
///   Conditional
///  | Align
///  | Anchored
///  | As
///  | AsAt
///  | At
///  | Facing
///  | In
///  | On
///  | Positioned
///  | Rotated
///  | Store
///  | Summon
/// ;
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, EnumAsInner, From)]
#[allow(missing_docs)]
pub enum ExecuteBlockHead {
    Conditional(Conditional),
    Align(Align),
    Anchored(Anchored),
    As(As),
    AsAt(AsAt),
    At(At),
    Facing(Facing),
    In(In),
    On(On),
    Positioned(Positioned),
    Rotated(Rotated),
    Store(Store),
    Summon(Summon),
}

impl SourceElement for ExecuteBlockHead {
    fn span(&self) -> Span {
        match self {
            Self::Conditional(conditional) => conditional.span(),
            Self::Align(align) => align.span(),
            Self::Anchored(anchored) => anchored.span(),
            Self::As(as_) => as_.span(),
            Self::AsAt(as_at) => as_at.span(),
            Self::At(at) => at.span(),
            Self::Facing(facing) => facing.span(),
            Self::In(in_) => in_.span(),
            Self::On(on) => on.span(),
            Self::Positioned(positioned) => positioned.span(),
            Self::Rotated(rotated) => rotated.span(),
            Self::Store(store) => store.span(),
            Self::Summon(summon) => summon.span(),
        }
    }
}

/// Represents the tail of an execute block statement.
///
/// Syntax Synopsis:
/// ```ebnf
/// ExecuteBlockTail:
///  ExecuteBlock
/// | Block
/// ;
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, EnumAsInner, From)]
#[allow(missing_docs)]
pub enum ExecuteBlockTail {
    ExecuteBlock(Punctuation, Box<ExecuteBlock>),
    Block(Block),
}

impl SourceElement for ExecuteBlockTail {
    fn span(&self) -> Span {
        match self {
            Self::ExecuteBlock(punc, execute_block) => punc
                .span
                .join(&execute_block.span())
                .expect("The span of the execute block tail is invalid."),
            Self::Block(block) => block.span(),
        }
    }
}

/// Represents an conditional `if` statement in the syntax tree.
///
/// Syntax Synopsis:
///
/// ``` ebnf
/// Conditional:
/// 'if' ParenthizedCondition
/// ;
/// ```
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Getters)]
pub struct Conditional {
    /// The `if` keyword.
    #[get = "pub"]
    if_keyword: Keyword,
    /// The condition of the conditional.
    #[get = "pub"]
    condition: ParenthesizedCondition,
}

impl Conditional {
    /// Dissolves the [`Conditional`] into its components.
    #[must_use]
    pub fn dissolve(self) -> (Keyword, ParenthesizedCondition) {
        (self.if_keyword, self.condition)
    }
}

impl SourceElement for Conditional {
    fn span(&self) -> Span {
        self.if_keyword
            .span()
            .join(&self.condition.span())
            .expect("The span of the conditional is invalid.")
    }
}

/// Represents an `else` block in the syntax tree.
///
/// Syntax Synopsis:
///
/// ``` ebnf
/// Else:
///     'else' Block
///     ;
/// ```
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Getters)]
pub struct Else {
    /// The `else` keyword.
    #[get = "pub"]
    else_keyword: Keyword,
    /// The block of the else statement.
    #[get = "pub"]
    block: Box<Block>,
}

impl Else {
    /// Dissolves the [`Else`] into its components.
    #[must_use]
    pub fn dissolve(self) -> (Keyword, Box<Block>) {
        (self.else_keyword, self.block)
    }
}

impl SourceElement for Else {
    fn span(&self) -> Span {
        self.else_keyword.span().join(&self.block.span()).unwrap()
    }
}

/// Represents an `as` execute statement in the syntax tree.
///
/// Syntax Synopsis:
///
/// ```ebnf
/// As:
/// 'as' '(' StringLiteral ')'
/// ;
/// ```
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Getters)]
pub struct As {
    /// The `as` keyword.
    #[get = "pub"]
    as_keyword: Keyword,
    /// The open parenthesis.
    #[get = "pub"]
    open_paren: Punctuation,
    /// The selector of the as statement.
    #[get = "pub"]
    as_selector: StringLiteral,
    /// The close parenthesis.
    #[get = "pub"]
    close_paren: Punctuation,
}

impl SourceElement for As {
    fn span(&self) -> Span {
        self.as_keyword
            .span()
            .join(&self.close_paren.span())
            .expect("The span of the as statement is invalid.")
    }
}
impl As {
    /// Dissolves the [`As`] into its components.
    #[must_use]
    pub fn dissolve(self) -> (Keyword, Punctuation, StringLiteral, Punctuation) {
        (
            self.as_keyword,
            self.open_paren,
            self.as_selector,
            self.close_paren,
        )
    }
}

/// Represents an `align` execute statement in the syntax tree.
///
/// Syntax Synopsis:
/// ```ebnf
/// Align:
///     'align' '(' StringLiteral ')'
/// ;
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Getters)]
pub struct Align {
    /// The `align` keyword.
    #[get = "pub"]
    align_keyword: Keyword,
    /// The open parenthesis.
    #[get = "pub"]
    open_paren: Punctuation,
    /// The selector of the align statement.
    #[get = "pub"]
    align_selector: StringLiteral,
    /// The close parenthesis.
    #[get = "pub"]
    close_paren: Punctuation,
}

impl SourceElement for Align {
    fn span(&self) -> Span {
        self.align_keyword
            .span()
            .join(&self.close_paren.span())
            .expect("The span of the align statement is invalid.")
    }
}

impl Align {
    /// Dissolves the [`Align`] into its components.
    #[must_use]
    pub fn dissolve(self) -> (Keyword, Punctuation, StringLiteral, Punctuation) {
        (
            self.align_keyword,
            self.open_paren,
            self.align_selector,
            self.close_paren,
        )
    }
}

/// Represents an `anchored` execute statement in the syntax tree.
///
/// Syntax Synopsis:
/// ```ebnf
/// Anchored:
///    'anchored' '(' StringLiteral ')'
/// ;
/// ```
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Getters)]
pub struct Anchored {
    /// The `anchored` keyword.
    #[get = "pub"]
    anchored_keyword: Keyword,
    /// The open parenthesis.
    #[get = "pub"]
    open_paren: Punctuation,
    /// The selector of the anchored statement.
    #[get = "pub"]
    anchored_selector: StringLiteral,
    /// The close parenthesis.
    #[get = "pub"]
    close_paren: Punctuation,
}
impl SourceElement for Anchored {
    fn span(&self) -> Span {
        self.anchored_keyword
            .span()
            .join(&self.close_paren.span())
            .expect("The span of the anchored statement is invalid.")
    }
}
impl Anchored {
    /// Dissolves the [`Anchored`] into its components.
    #[must_use]
    pub fn dissolve(self) -> (Keyword, Punctuation, StringLiteral, Punctuation) {
        (
            self.anchored_keyword,
            self.open_paren,
            self.anchored_selector,
            self.close_paren,
        )
    }
}

/// Represents an `asat` execute statement in the syntax tree.
///
/// Syntax Synopsis:
/// ```ebnf
/// AsAt:
///   'asat' '(' StringLiteral ')'
/// ;
/// ```
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Getters)]
pub struct AsAt {
    /// The `asat` keyword.
    #[get = "pub"]
    asat_keyword: Keyword,
    /// The open parenthesis.
    #[get = "pub"]
    open_paren: Punctuation,
    /// The selector of the asat statement.
    #[get = "pub"]
    asat_selector: StringLiteral,
    /// The close parenthesis.
    #[get = "pub"]
    close_paren: Punctuation,
}
impl SourceElement for AsAt {
    fn span(&self) -> Span {
        self.asat_keyword
            .span()
            .join(&self.close_paren.span())
            .expect("The span of the asat statement is invalid.")
    }
}
impl AsAt {
    /// Dissolves the [`AsAt`] into its components.
    #[must_use]
    pub fn dissolve(self) -> (Keyword, Punctuation, StringLiteral, Punctuation) {
        (
            self.asat_keyword,
            self.open_paren,
            self.asat_selector,
            self.close_paren,
        )
    }
}

/// Represents an `at` execute statement in the syntax tree.
///
/// Syntax Synopsis:
/// ```ebnf
/// At:
///  'at' '(' StringLiteral ')'
/// ;
/// ```
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Getters)]
pub struct At {
    /// The `at` keyword.
    #[get = "pub"]
    at_keyword: Keyword,
    /// The open parenthesis.
    #[get = "pub"]
    open_paren: Punctuation,
    /// The selector of the at statement.
    #[get = "pub"]
    at_selector: StringLiteral,
    /// The close parenthesis.
    #[get = "pub"]
    close_paren: Punctuation,
}
impl SourceElement for At {
    fn span(&self) -> Span {
        self.at_keyword
            .span()
            .join(&self.close_paren.span())
            .expect("The span of the at statement is invalid.")
    }
}
impl At {
    /// Dissolves the [`At`] into its components.
    #[must_use]
    pub fn dissolve(self) -> (Keyword, Punctuation, StringLiteral, Punctuation) {
        (
            self.at_keyword,
            self.open_paren,
            self.at_selector,
            self.close_paren,
        )
    }
}

/// Represents a `facing` execute statement in the syntax tree.
///
/// Syntax Synopsis:
/// ```ebnf
/// Facing:
///  'facing' '(' StringLiteral ')'
/// ;
/// ```
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Getters)]
pub struct Facing {
    /// The `facing` keyword.
    #[get = "pub"]
    facing_keyword: Keyword,
    /// The open parenthesis.
    #[get = "pub"]
    open_paren: Punctuation,
    /// The selector of the facing statement.
    #[get = "pub"]
    facing_selector: StringLiteral,
    /// The close parenthesis.
    #[get = "pub"]
    close_paren: Punctuation,
}
impl SourceElement for Facing {
    fn span(&self) -> Span {
        self.facing_keyword
            .span()
            .join(&self.close_paren.span())
            .expect("The span of the facing statement is invalid.")
    }
}
impl Facing {
    /// Dissolves the [`Facing`] into its components.
    #[must_use]
    pub fn dissolve(self) -> (Keyword, Punctuation, StringLiteral, Punctuation) {
        (
            self.facing_keyword,
            self.open_paren,
            self.facing_selector,
            self.close_paren,
        )
    }
}

/// Represents an `in` execute statement in the syntax tree.
///
/// Syntax Synopsis:
/// ```ebnf
/// In:
/// 'in' '(' StringLiteral ')'
/// ;
/// ```
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Getters)]
pub struct In {
    /// The `in` keyword.
    #[get = "pub"]
    in_keyword: Keyword,
    /// The open parenthesis.
    #[get = "pub"]
    open_paren: Punctuation,
    /// The selector of the in statement.
    #[get = "pub"]
    in_selector: StringLiteral,
    /// The close parenthesis.
    #[get = "pub"]
    close_paren: Punctuation,
}
impl SourceElement for In {
    fn span(&self) -> Span {
        self.in_keyword
            .span()
            .join(&self.close_paren.span())
            .expect("The span of the in statement is invalid.")
    }
}
impl In {
    /// Dissolves the [`In`] into its components.
    #[must_use]
    pub fn dissolve(self) -> (Keyword, Punctuation, StringLiteral, Punctuation) {
        (
            self.in_keyword,
            self.open_paren,
            self.in_selector,
            self.close_paren,
        )
    }
}

/// Represents an `on` execute statement in the syntax tree.
///
/// Syntax Synopsis:
/// ```ebnf
/// On:
/// 'on' '(' StringLiteral ')'
/// ;
/// ```
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Getters)]
pub struct On {
    /// The `on` keyword.
    #[get = "pub"]
    on_keyword: Keyword,
    /// The open parenthesis.
    #[get = "pub"]
    open_paren: Punctuation,
    /// The selector of the on statement.
    #[get = "pub"]
    on_selector: StringLiteral,
    /// The close parenthesis.
    #[get = "pub"]
    close_paren: Punctuation,
}
impl SourceElement for On {
    fn span(&self) -> Span {
        self.on_keyword
            .span()
            .join(&self.close_paren.span())
            .expect("The span of the on statement is invalid.")
    }
}
impl On {
    /// Dissolves the [`On`] into its components.
    #[must_use]
    pub fn dissolve(self) -> (Keyword, Punctuation, StringLiteral, Punctuation) {
        (
            self.on_keyword,
            self.open_paren,
            self.on_selector,
            self.close_paren,
        )
    }
}

/// Represents a `positioned` execute statement in the syntax tree.
///
/// Syntax Synopsis:
/// ```ebnf
/// Positioned:
/// 'positioned' '(' StringLiteral ')'
/// ;
/// ```
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Getters)]
pub struct Positioned {
    /// The `positioned` keyword.
    #[get = "pub"]
    positioned_keyword: Keyword,
    /// The open parenthesis.
    #[get = "pub"]
    open_paren: Punctuation,
    /// The selector of the positioned statement.
    #[get = "pub"]
    positioned_selector: StringLiteral,
    /// The close parenthesis.
    #[get = "pub"]
    close_paren: Punctuation,
}
impl SourceElement for Positioned {
    fn span(&self) -> Span {
        self.positioned_keyword
            .span()
            .join(&self.close_paren.span())
            .expect("The span of the positioned statement is invalid.")
    }
}
impl Positioned {
    /// Dissolves the [`Positioned`] into its components.
    #[must_use]
    pub fn dissolve(self) -> (Keyword, Punctuation, StringLiteral, Punctuation) {
        (
            self.positioned_keyword,
            self.open_paren,
            self.positioned_selector,
            self.close_paren,
        )
    }
}

/// Represents a `rotated` execute statement in the syntax tree.
///
/// Syntax Synopsis:
/// ```ebnf
/// Rotated:
/// 'rotated' '(' StringLiteral ')'
/// ;
/// ```
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Getters)]
pub struct Rotated {
    /// The `rotated` keyword.
    #[get = "pub"]
    rotated_keyword: Keyword,
    /// The open parenthesis.
    #[get = "pub"]
    open_paren: Punctuation,
    /// The selector of the rotated statement.
    #[get = "pub"]
    rotated_selector: StringLiteral,
    /// The close parenthesis.
    #[get = "pub"]
    close_paren: Punctuation,
}
impl SourceElement for Rotated {
    fn span(&self) -> Span {
        self.rotated_keyword
            .span()
            .join(&self.close_paren.span())
            .expect("The span of the rotated statement is invalid.")
    }
}
impl Rotated {
    /// Dissolves the [`Rotated`] into its components.
    #[must_use]
    pub fn dissolve(self) -> (Keyword, Punctuation, StringLiteral, Punctuation) {
        (
            self.rotated_keyword,
            self.open_paren,
            self.rotated_selector,
            self.close_paren,
        )
    }
}

/// Represents a `store` execute statement in the syntax tree.
///
/// Syntax Synopsis:
/// ```ebnf
/// Store:
/// 'store' '(' StringLiteral ')'
/// ;
/// ```
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Getters)]
pub struct Store {
    /// The `store` keyword.
    #[get = "pub"]
    store_keyword: Keyword,
    /// The open parenthesis.
    #[get = "pub"]
    open_paren: Punctuation,
    /// The selector of the store statement.
    #[get = "pub"]
    store_selector: StringLiteral,
    /// The close parenthesis.
    #[get = "pub"]
    close_paren: Punctuation,
}
impl SourceElement for Store {
    fn span(&self) -> Span {
        self.store_keyword
            .span()
            .join(&self.close_paren.span())
            .expect("The span of the store statement is invalid.")
    }
}
impl Store {
    /// Dissolves the [`Store`] into its components.
    #[must_use]
    pub fn dissolve(self) -> (Keyword, Punctuation, StringLiteral, Punctuation) {
        (
            self.store_keyword,
            self.open_paren,
            self.store_selector,
            self.close_paren,
        )
    }
}

/// Represents a `summon` execute statement in the syntax tree.
///
/// Syntax Synopsis:
/// ```ebnf
/// Summon:
/// 'summon' '(' StringLiteral ')'
/// ;
/// ```
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Getters)]
pub struct Summon {
    /// The `summon` keyword.
    #[get = "pub"]
    summon_keyword: Keyword,
    /// The open parenthesis.
    #[get = "pub"]
    open_paren: Punctuation,
    /// The selector of the summon statement.
    #[get = "pub"]
    summon_selector: StringLiteral,
    /// The close parenthesis.
    #[get = "pub"]
    close_paren: Punctuation,
}
impl SourceElement for Summon {
    fn span(&self) -> Span {
        self.summon_keyword
            .span()
            .join(&self.close_paren.span())
            .expect("The span of the summon statement is invalid.")
    }
}
impl Summon {
    /// Dissolves the [`Summon`] into its components.
    #[must_use]
    pub fn dissolve(self) -> (Keyword, Punctuation, StringLiteral, Punctuation) {
        (
            self.summon_keyword,
            self.open_paren,
            self.summon_selector,
            self.close_paren,
        )
    }
}

impl<'a> Parser<'a> {
    /// Parses an [`ExecuteBlock`].
    ///
    /// # Errors
    /// - if not at the start of an execute block statement.
    /// - if the parsing of the execute block statement fails.
    pub fn parse_execute_block_statement(
        &mut self,
        handler: &impl Handler<base::Error>,
    ) -> ParseResult<ExecuteBlock> {
        match self.stop_at_significant() {
            Reading::Atomic(Token::Keyword(if_keyword))
                if if_keyword.keyword == KeywordKind::If =>
            {
                // eat the if keyword
                self.forward();

                let condition = self.parse_parenthesized_condition(handler)?;

                let conditional = Conditional {
                    if_keyword,
                    condition,
                };

                let else_tail = self.try_parse(|parser| {
                    let block = parser.parse_block(&VoidHandler)?;
                    let (else_keyword, else_block) = match parser.stop_at_significant() {
                        // else statement
                        Reading::Atomic(Token::Keyword(else_keyword))
                            if else_keyword.keyword == KeywordKind::Else =>
                        {
                            // eat the else keyword
                            parser.forward();

                            let else_block = parser.parse_block(&VoidHandler)?;

                            Ok((else_keyword, else_block))
                        }
                        unexpected => Err(UnexpectedSyntax {
                            expected: SyntaxKind::Keyword(KeywordKind::Else),
                            found: unexpected.into_token(),
                        }),
                    }?;

                    Ok((
                        block,
                        Else {
                            else_keyword,
                            block: Box::new(else_block),
                        },
                    ))
                });

                if let Ok((block, else_tail)) = else_tail {
                    Ok(ExecuteBlock::IfElse(conditional, block, else_tail))
                } else {
                    let tail = self.parse_execute_block_tail(handler)?;
                    Ok(ExecuteBlock::HeadTail(
                        ExecuteBlockHead::Conditional(conditional),
                        tail,
                    ))
                }
            }

            Reading::Atomic(Token::Keyword(keyword)) if keyword.keyword.starts_execute_block() => {
                // eat the as keyword
                self.forward();

                let argument = match self.stop_at_significant() {
                    Reading::IntoDelimited(punc) if punc.punctuation == '(' => self.step_into(
                        Delimiter::Parenthesis,
                        |parser| parser.parse_string_literal(handler),
                        handler,
                    ),
                    unexpected => {
                        let err = Error::UnexpectedSyntax(UnexpectedSyntax {
                            expected: SyntaxKind::Punctuation('('),
                            found: unexpected.into_token(),
                        });
                        handler.receive(err.clone());
                        Err(err)
                    }
                }?;

                let tail = self.parse_execute_block_tail(handler)?;

                let head = head_from_keyword(keyword, argument)?;

                Ok(ExecuteBlock::HeadTail(head, tail))
            }

            // unexpected
            unexpected => {
                let err = Error::UnexpectedSyntax(UnexpectedSyntax {
                    expected: SyntaxKind::ExecuteBlock,
                    found: unexpected.into_token(),
                });
                handler.receive(err.clone());
                Err(err)
            }
        }
    }

    fn parse_execute_block_tail(
        &mut self,
        handler: &impl Handler<base::Error>,
    ) -> ParseResult<ExecuteBlockTail> {
        match self.stop_at_significant() {
            // nested execute block
            Reading::Atomic(Token::Punctuation(punc)) if punc.punctuation == ',' => {
                // eat the comma
                self.forward();

                let execute_block = self.parse_execute_block_statement(handler)?;

                Ok(ExecuteBlockTail::ExecuteBlock(
                    punc,
                    Box::new(execute_block),
                ))
            }

            // end block
            Reading::IntoDelimited(punc) if punc.punctuation == '{' => {
                let block = self.parse_block(handler)?;

                Ok(ExecuteBlockTail::Block(block))
            }

            unexpected => {
                let err = Error::UnexpectedSyntax(UnexpectedSyntax {
                    expected: SyntaxKind::ExecuteBlockTail,
                    found: unexpected.into_token(),
                });
                handler.receive(err.clone());
                Err(err)
            }
        }
    }
}

fn head_from_keyword(
    keyword: Keyword,
    argument: DelimitedTree<StringLiteral>,
) -> ParseResult<ExecuteBlockHead> {
    Ok(match keyword.keyword {
        KeywordKind::Align => Align {
            align_keyword: keyword,
            open_paren: argument.open,
            align_selector: argument.tree?,
            close_paren: argument.close,
        }
        .into(),
        KeywordKind::Anchored => Anchored {
            anchored_keyword: keyword,
            open_paren: argument.open,
            anchored_selector: argument.tree?,
            close_paren: argument.close,
        }
        .into(),
        KeywordKind::As => As {
            as_keyword: keyword,
            open_paren: argument.open,
            as_selector: argument.tree?,
            close_paren: argument.close,
        }
        .into(),
        KeywordKind::AsAt => AsAt {
            asat_keyword: keyword,
            open_paren: argument.open,
            asat_selector: argument.tree?,
            close_paren: argument.close,
        }
        .into(),
        KeywordKind::At => At {
            at_keyword: keyword,
            open_paren: argument.open,
            at_selector: argument.tree?,
            close_paren: argument.close,
        }
        .into(),
        KeywordKind::Facing => Facing {
            facing_keyword: keyword,
            open_paren: argument.open,
            facing_selector: argument.tree?,
            close_paren: argument.close,
        }
        .into(),
        KeywordKind::In => In {
            in_keyword: keyword,
            open_paren: argument.open,
            in_selector: argument.tree?,
            close_paren: argument.close,
        }
        .into(),
        KeywordKind::On => On {
            on_keyword: keyword,
            open_paren: argument.open,
            on_selector: argument.tree?,
            close_paren: argument.close,
        }
        .into(),
        KeywordKind::Positioned => Positioned {
            positioned_keyword: keyword,
            open_paren: argument.open,
            positioned_selector: argument.tree?,
            close_paren: argument.close,
        }
        .into(),
        KeywordKind::Rotated => Rotated {
            rotated_keyword: keyword,
            open_paren: argument.open,
            rotated_selector: argument.tree?,
            close_paren: argument.close,
        }
        .into(),
        KeywordKind::Store => Store {
            store_keyword: keyword,
            open_paren: argument.open,
            store_selector: argument.tree?,
            close_paren: argument.close,
        }
        .into(),
        KeywordKind::Summon => Summon {
            summon_keyword: keyword,
            open_paren: argument.open,
            summon_selector: argument.tree?,
            close_paren: argument.close,
        }
        .into(),
        _ => unreachable!("The keyword is not a valid execute block head."),
    })
}