from . import util, ast, astsupport
from .object import Object


class Context(object):
    pass


class ATLTransformBase(Object):
    pass


class RawStatement(object):
    pass


class Statement(Object):
    pass


class RawBlock(RawStatement):
    statements = None
    """
    https://www.renpy.org/doc/html/transforms.html#block-statement

    atl_block_stmt ::=  "block" ":"
                         atl_block
    """

    def get_code(self, **kwargs) -> str:
        if (
            not self.animation
            and len(self.statements) == 1
            and isinstance(self.statements[0], RawBlock)
        ):
            return util.get_code(self.statements[0], **kwargs)

        rv = []
        if self.animation:
            """
            https://www.renpy.org/doc/html/transforms.html#animation-statement

            atl_animation ::=  "animation"

            image eileen vhappy moving:
                animation
                "eileen vhappy"
                xalign 0.0
                linear 5.0 xalign 1.0
                repeat
            """
            rv.append("animation")

        statements = self.statements
        if statements:
            for statement in statements:
                if statement is None:
                    rv.append("pass")
                else:
                    rv.append(util.get_code(statement, **kwargs))
        else:
            rv.append("pass")

        return "\n".join(rv)


class Block(Statement):
    pass


class RawMultipurpose(RawStatement):
    """
    https://www.renpy.org/doc/html/transforms.html#interpolation-statement

    atl_interp ::=  ((warper simple_expression) | ("warp" simple_expression simple_expression)) (atl_interp_target+ | (":"
                   atl_interp_target+ ))
    atl_interp_target ::=  (atl_property+ ("knot" simple_expression)* )
                        | atl_transform_expression
                        | "clockwise"
                        | "counterclockwise"
                        | ("circles" simple_expression)
    """

    def get_code(self, **kwargs) -> str:
        start = ""
        warp_fun, duration, wrap = self.warp_function, self.duration, self.warper
        if warp_fun and wrap is None:
            # warp {warp_function:expr} {duration:expr}
            start = f"warp {util.get_code(warp_fun, **kwargs)} {util.get_code(duration, **kwargs)}"
        elif not warp_fun and wrap:
            # {wrap} {duration:expr}
            start = f"{wrap} {util.get_code(duration, **kwargs)}"
        elif not warp_fun and not wrap and duration == "0":
            pass

        rv = []

        revolution = self.revolution
        if revolution:
            rv.append(revolution)

        circles = self.circles
        if circles and circles != "0":
            # circles {expression}
            rv.append(f"circles {util.get_code(circles, **kwargs)}")

        for prop, expr in self.properties:
            rv.append(f"{prop} {util.get_code(expr, **kwargs)}")

        for prop, exprs in self.splines:
            last, exprs = exprs[-1], exprs[:-1]
            knots = " ".join(f"knot {util.get_code(expr, **kwargs)}" for expr in exprs)
            rv.append(f"{prop} {util.get_code(last, **kwargs)} {knots}")

        for expr, with_expr in self.expressions:
            if with_expr is None:
                rv.append(str(expr))
                continue
            if isinstance(with_expr, ast.PyExpr):
                valstr = f"with {with_expr}"
            elif isinstance(with_expr, astsupport.PyExpr):
                valstr = f"with {with_expr}"
            else:
                valstr = str(with_expr)
            rv.append(f"{expr} {valstr}")

        if not start:
            return " ".join(rv)
        if not rv:
            # if no properties, return just the warp
            return start
        if len(rv) < 3:
            # if only few properties, return them in one line
            return start + " " + " ".join(rv)
        return start + ":\n" + util.indent(" ".join(rv))


class RawContainsExpr(RawStatement):
    """
    https://www.renpy.org/doc/html/transforms.html#inline-contains-statement

    atl_contains ::=  "contains" simple_expression
    """

    def get_code(self, **kwargs) -> str:
        """
        Returns the code for a contains expression.
        """
        expression = util.attr(self, "expression")
        if expression:
            return f"contains {util.get_code(expression, **kwargs)}"
        return "contains"


# This allows us to have multiple ATL transforms as children.
class RawChild(RawStatement):
    """
    https://www.renpy.org/doc/html/transforms.html#contains-block-statement

    atl_counts ::=  "contains" ":"
                   atl_block
    """

    def get_code(self, **kwargs) -> str:
        children = util.attr(self, "children")
        if not children:
            return "contains:\n    pass"
        rv = ["contains:"]
        rv.append(util.indent(util.get_code(children, **kwargs)))
        return "\n".join(rv)


# This changes the child of this statement, optionally with a transition.
class Child(Statement):
    pass


# This causes interpolation to occur.
class Interpolation(Statement):
    pass


class RawRepeat(RawStatement):
    """
    https://www.renpy.org/doc/html/transforms.html#repeat-statement

    atl_repeat ::=  "repeat" (simple_expression)?
    """

    def get_code(self, **kwargs) -> str:
        if self.repeats:
            return f"repeat {util.get_code(self.repeats, **kwargs)}"
        return "repeat"


class Repeat(Statement):
    pass


class RawParallel(RawStatement):
    """
    https://www.renpy.org/doc/html/transforms.html#parallel-statement

    atl_parallel ::=  ("parallel" ":"
                     atl_block)+
    """

    def get_code(self, **kwargs) -> str:
        rv = ["parallel:"]
        blocks = util.attr(self, "blocks")
        if not blocks:
            rv.append(util.indent("pass"))
        else:
            rv.append(util.indent(util.get_code(blocks, **kwargs)))
        return "\n".join(rv)


class Parallel(Statement):
    pass


class RawChoice(RawStatement):
    """
    https://www.renpy.org/doc/html/transforms.html#choice-statement

    atl_choice ::=  ("choice" (simple_expression)? ":"
                    atl_block)+
    """

    def get_code(self, **kwargs) -> str:
        rv = []
        for text, stmt in self.choices:
            rv.append(f"choice {text}:")
            rv.append(util.indent(util.get_code(stmt, **kwargs)))
        return "\n".join(rv)


class Choice(Statement):
    pass


class RawTime(RawStatement):
    """
    https://www.renpy.org/doc/html/atl.html#time-statement

    atl_time ::=  "time" (simple_expression)?
    """

    def get_code(self, **kwargs) -> str:
        time = util.attr(self, "time")
        if time:
            return f"time {util.get_code(time, **kwargs)}"
        return "time"


class Time(Statement):
    pass


class RawOn(RawStatement):
    """
    https://www.renpy.org/doc/html/transforms.html#on-statement

    atl_on ::=  "on" name [ "," name ] * ":"
      atl_block

    on show:
        alpha 0.0
        linear .5 alpha 1.0
    on hide:
        linear .5 alpha 0.0
    """

    def get_code(self, **kwargs) -> str:
        rv = []
        for text, stmt in self.handlers.items():
            rv.append(f"on {text}:")
            rv.append(util.indent(util.get_code(stmt, **kwargs)))
        return "\n".join(rv)


class On(Statement):
    pass


class RawEvent(RawStatement):
    """
    https://www.renpy.org/doc/html/transforms.html#event-statement

    atl_event ::=  "event" name
    """

    def get_code(self, **kwargs) -> str:
        name = util.attr(self, "name")
        if name:
            return f"event {name}"
        return "event"


class Event(Statement):
    pass


class RawFunction(RawStatement):
    """
    https://www.renpy.org/doc/html/transforms.html#function-statement

    atl_function ::=  "function" simple_expression
    """

    def get_code(self, **kwargs) -> str:
        if self.expr:
            return "function " + str(self.expr)
        else:
            return "function"


class Function(Statement):
    pass