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

from typing import Iterable, List, Optional, Tuple, Union

Param = Tuple[str, str]

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

    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,
            params: Iterable[Param],
            result: Optional[str],
            statements: Iterable[Statement],
        ) -> None:
        self.name = name
        self.exported = exported
        self.params = [*params]
        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 Constant:
    """
    TODO
    """
    def __init__(self, value: Union[None, bool, int, float]) -> None:
        self.value = value

class ClassMember:
    """
    Represents a Web Assembly class member
    """
    def __init__(self, name: str, type_: str, default: Optional[Constant]) -> None:
        self.name = name
        self.type = type_
        self.default = default

class Class:
    """
    Represents a Web Assembly class
    """
    def __init__(self, name: str, members: List[ClassMember]) -> None:
        self.name = name
        self.members = members

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

    def generate(self) -> str:
        """
        Generates the text version
        """
        return '(module\n  (memory 1)\n  (data (memory 0) (i32.const 0) {})\n  {}\n  {})\n'.format(
            '"\\\\04\\\\00\\\\00\\\\00"',
            '\n  '.join(x.generate() for x in self.imports),
            '\n  '.join(x.generate() for x in self.functions),
        )