"""
Python classes for storing the representation of Web Assembly code
"""

from typing import Iterable, List, Optional, Tuple

class Import:
    """
    Represents a Web Assembly import
    """
    def __init__(
            self,
            module: str,
            name: str,
            intname: str,
            params: Iterable[Tuple[str, str]],
        ) -> None:
        self.module = module
        self.name = name
        self.intname = intname
        self.params = [*params]

    def generate(self) -> str:
        """
        Generates the text version
        """
        return '(import "{}" "{}" (func ${}{}))'.format(
            self.module,
            self.name,
            self.intname,
            ''.join(' (param {})'.format(x[1]) for x in self.params)
        )

class Statement:
    """
    Represents a Web Assembly statement
    """
    def __init__(self, name: str, *args: str):
        self.name = name
        self.args = args

    def generate(self) -> str:
        """
        Generates the text version
        """
        return '{} {}'.format(self.name, ' '.join(self.args))

class Function:
    """
    Represents a Web Assembly function
    """
    def __init__(
            self,
            name: str,
            exported: bool,
            result: Optional[str],
            statements: Iterable[Statement],
        ) -> None:
        self.name = name
        self.exported = exported
        self.params: List[Tuple[str, str]] = []
        self.result = result
        self.statements = [*statements]

    def generate(self) -> str:
        """
        Generates the text version
        """
        header = ('(export "{}")' if self.exported else '${}').format(self.name)

        for nam, typ in self.params:
            header += ' (param ${} {})'.format(nam, typ)

        if self.result:
            header += ' (result {})'.format(self.result)

        return '(func {}\n    {})'.format(
            header,
            '\n    '.join(x.generate() for x in self.statements),
        )

class Module:
    """
    Represents a Web Assembly module
    """
    def __init__(self) -> None:
        self.imports: List[Import] = []
        self.functions: List[Function] = []

    def generate(self) -> str:
        """
        Generates the text version
        """
        return '(module\n  {}\n  {})\n'.format(
            '\n  '.join(x.generate() for x in self.imports),
            '\n  '.join(x.generate() for x in self.functions),
        )