python early hide:
    import inspect
    __register_params = frozenset(inspect.signature(renpy.register_statement).parameters).difference({"name", "parse"})
    def register_decorator(cls):
        """
        A class decorator which registers a new statement.

        The name of the statement will be the class name unless a `name` class attribute is present, which should be a string.

        The `parse` method should be a static method that returns an object which will be passed to the other methods as `self`.
        Returning an instance of the class is disabled for now.
        """
        # security
        def raiser(*args, **kwargs):
            raise TypeError("Returning an instance of the class is disabled")
        cls.__init__ = raiser

        name = getattr(cls, "name", cls.__name__)
        parse = getattr(cls, "parse", cls) # left in
        renpy.register_statement(name,
            parse=parse,
            **{k:getattr(cls, k) for k in __register_params.intersection(vars(cls))})
        return cls

    @register_decorator
    class dynamic:
        block = "possible"

        @staticmethod
        def parse(l):
            rv = {}

            def parse_simple(ll):
                target = ll.require(ll.name, "variable name")
                if target in rv:
                    ll.error(f"Variable {target} already set in the same dynamic block")
                ll.require("=", "equals sign")
                expression = ll.simple_expression()
                ll.expect_eol()
                rv[target] = expression

            if l.match(":"):
                l.expect_block("dynamic block")
                l.expect_eol()
                ll = l.subblock_lexer()
                while ll.advance():
                    parse_simple(ll)
            else:
                parse_simple(l)

            return rv

        def execute(self):
            evaled = {n: eval(e) for n, e in self.items()}
            renpy.dynamic(**evaled)

python early:
    def parse_chibi(l):
        who = l.simple_expression()
        action = l.simple_expression()

        return (who, action)

    def execute_chibi(p):
        print(f"{p}")
        who, action = p
        func = eval(f"{who}_chibi.{action}")

        # print(f"Execution: {who} {action}")

    def lint_chibi(p):
        who, action = p
        try:
            chibi = eval(f"{who}_chibi")
        except Exception:
            renpy.error(f"Character chibi not defined: {who}")

    def predict_chibi(p):
        who, action = p

        chibi = eval(f"{who}_chibi")
        doll = eval(f"{who}")

        layers = (
            l[0] for pose in chibi.poses.keys()
            for k in doll.states.values() if k[0] and k[2]
            for l in k[0].get_layers(k[0]._hash, subpath=posixpath.join("chibi", pose)).values()
        )

        return layers

    renpy.register_statement(
        name="chibi",
        parse=parse_chibi,
        execute=execute_chibi,
        lint=lint_chibi,
        predict=predict_chibi,
    )

    def parse_random(l):
        l.require(":")
        l.expect_eol()

        ll = l.subblock_lexer()
        blocks = []

        while ll.advance():
            with ll.catch_error():
                weight = 1.0
                condition = "True"

                if ll.keyword("block"):
                    ll.expect_block("block")

                    block = ll.subblock_lexer().renpy_block()

                    if ll.keyword("weight"):
                        weight = float(ll.require(ll.float))

                    if ll.keyword("if"):
                        ll.expect_block("if block")
                        condition = ll.require(ll.python_expression)
                else:
                    block = ll.renpy_statement()

                blocks.append((block, weight, condition))

        return {"blocks": blocks}

    def next_random(p):
        blocks = [(block, weight) for block, weight, condition in p["blocks"] if eval(condition)]
        total_weight = sum(weight for _, weight in blocks)
        n = renpy.random.random() * total_weight

        for block, weight in blocks:
            if n <= weight:
                break
            else:
                n -= weight

        return block

    renpy.register_statement(
        name="random",
        block=True,
        predict_all=True,
        parse=parse_random,
        next=next_random,
    )