# Copyright 2004-2026 Tom Rothamel <pytom@bishoujo.us>
#
# Permission is hereby granted, free of charge, to any person
# obtaining a copy of this software and associated documentation files
# (the "Software"), to deal in the Software without restriction,
# including without limitation the rights to use, copy, modify, merge,
# publish, distribute, sublicense, and/or sell copies of the Software,
# and to permit persons to whom the Software is furnished to do so,
# subject to the following conditions:
#
# The above copyright notice and this permission notice shall be
# included in all copies or substantial portions of the Software.
#
# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
# MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
# NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
# LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
# OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
# WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

# This file contains code that creates a few new statements.

init -1200 python in audio:

    # The prompt asking the user to click to play video on the web platform.
    # This can be translated or changed using Ren'Py's translation system.
    __("Click to play the video.")


    # Do not participate in saves.
    _constant = True

init -1200 python:

    config.default_sound_loop = None

    def _audio_eval(expr):
        return eval(expr, locals=store.audio.__dict__)

    def _try_eval(e, what):
        try:
            return _audio_eval(e)
        except Exception:
            renpy.error('unable to evaluate %s %r' % (what, e))

python early hide:

    def warp_audio(p):
        """
        Determines if we should play this statement while warping.
        """

        if p.get("channel", None) is not None:
            channel = eval(p["channel"])
        else:
            channel = "music"

        return renpy.music.is_music(channel)

    def parse_play_music(l):

        file = l.simple_expression()
        if not file:
            renpy.error("play requires a file")

        fadeout = "None"
        fadein = "0"
        channel = None
        loop = None
        if_changed = False
        volume = "1.0"

        while not l.eol():

            if l.keyword('fadeout'):
                fadeout = l.simple_expression()
                if fadeout is None:
                    renpy.error('expected simple expression')

                continue

            if l.keyword('fadein'):
                fadein = l.simple_expression()
                if fadein is None:
                    renpy.error('expected simple expression')

                continue

            if l.keyword('channel'):
                channel = l.simple_expression()
                if channel is None:
                    renpy.error('expected simple expression')

                continue

            if l.keyword('loop'):
                loop = True
                continue

            if l.keyword('noloop'):
                loop = False
                continue

            if l.keyword('if_changed'):
                if_changed = True
                continue

            if l.keyword('volume'):
                volume = l.simple_expression()
                continue

            renpy.error('expected end of line')

        return dict(file=file,
                    fadeout=fadeout,
                    fadein=fadein,
                    channel=channel,
                    loop=loop,
                    if_changed=if_changed,
                    volume=volume)

    def execute_play_music(p):

        if p["channel"] is not None:
            channel = eval(p["channel"])
        else:
            channel = "music"

        renpy.music.play(
            _audio_eval(p["file"]),
            fadeout=eval(p["fadeout"]),
            fadein=eval(p["fadein"]),
            channel=channel,
            loop=p.get("loop", None),
            if_changed=p.get("if_changed", False),
            relative_volume=eval(p.get("volume", "1.0")))

    def predict_play_music(p):
        if renpy.emscripten or os.environ.get('RENPY_SIMULATE_DOWNLOAD', False):
            if p["channel"] is not None:
                channel = eval(p["channel"])
                if channel == 'movie':
                    # Movies cannot be preloaded
                    return [ ]

            fn = _audio_eval(p["file"])
            try:
                with renpy.loader.load(fn, directory="audio") as f:
                    pass
            except renpy.webloader.DownloadNeeded as exception:
                renpy.webloader.enqueue(exception.relpath, 'music', None)
        return [ ]

    def lint_play_music(p, channel="music"):

        file = _try_eval(p["file"], 'filename')

        if p["channel"] is not None:
            channel = _try_eval(p["channel"], 'channel')

        if not isinstance(file, list):
            file = [ file ]

        for fn in file:
            if isinstance(fn, str):
                try:
                    if not renpy.music.playable(fn, channel):
                        renpy.error("%r is not loadable" % fn)
                except Exception:
                    pass

    renpy.register_statement(
        'play music',
        parse=parse_play_music,
        execute=execute_play_music,
        predict=predict_play_music,
        lint=lint_play_music,
        warp=warp_audio)

    # From here on, we'll steal bits of other statements when defining other
    # statements.

    def parse_queue_music(l):

        file = l.simple_expression()
        if not file:
            renpy.error("queue requires a file")

        channel = None
        loop = None
        volume = "1.0"
        fadein = "0"

        while not l.eol():

            if l.keyword('channel'):
                channel = l.simple_expression()
                if channel is None:
                    renpy.error('expected simple expression')

                continue

            if l.keyword('loop'):
                loop = True
                continue

            if l.keyword('noloop'):
                loop = False
                continue

            if l.keyword('volume'):
                volume = l.simple_expression()
                continue

            if l.keyword('fadein'):
                fadein = l.simple_expression()
                if fadein is None:
                    renpy.error('expected simple expression')

                continue

            renpy.error('expected end of line')

        return dict(file=file, channel=channel, loop=loop, volume=volume, fadein=fadein)

    def execute_queue_music(p):
        if p["channel"] is not None:
            channel = eval(p["channel"])
        else:
            channel = "music"

        renpy.music.queue(
            _audio_eval(p["file"]),
            channel=channel,
            loop=p.get("loop", None),
            relative_volume=eval(p.get("volume", "1.0")),
            fadein=eval(p.get("fadein", "0")),
            )


    renpy.register_statement(
        'queue music',
        parse=parse_queue_music,
        execute=execute_queue_music,
        lint=lint_play_music,
        warp=warp_audio)

    def parse_stop_music(l):
        channel = None
        fadeout = "None"

        while not l.eol():

            if l.keyword("fadeout"):
                fadeout = l.simple_expression()
                if fadeout is None:
                    renpy.error('expected simple expression')

                continue

            if l.keyword('channel'):
                channel = l.simple_expression()
                if channel is None:
                    renpy.error('expected simple expression')

                continue

            renpy.error('expected end of line')

        return dict(fadeout=fadeout, channel=channel)

    def execute_stop_music(p):
        if p["channel"] is not None:
            channel = eval(p["channel"])
        else:
            channel = "music"

        renpy.music.stop(fadeout=eval(p["fadeout"]), channel=channel)

    renpy.register_statement(
        'stop music',
        parse=parse_stop_music,
        execute=execute_stop_music,
        warp=warp_audio)


    # Sound statements. They share alot with the equivalent music
    # statements.

    def warp_sound(p):
        """
        Determines if we should play this statement while warping.
        """

        if p.get("channel", None) is not None:
            channel = eval(p["channel"])
        else:
            channel = "sound"

        return renpy.music.is_music(channel)

    def execute_play_sound(p):

        if p["channel"] is not None:
            channel = eval(p["channel"])
        else:
            channel = "sound"

        fadeout = eval(p["fadeout"]) or None

        loop = p.get("loop", False)

        if loop is None:
            loop = config.default_sound_loop

        renpy.sound.play(
            _audio_eval(p["file"]),
            fadeout=fadeout,
            fadein=eval(p["fadein"]),
            loop=loop,
            channel=channel,
            relative_volume=eval(p.get("volume", "1.0")))

    def lint_play_sound(p, lint_play_music=lint_play_music):
        return lint_play_music(p, channel="sound")

    renpy.register_statement(
        'play sound',
        parse=parse_play_music,
        execute=execute_play_sound,
        lint=lint_play_sound,
        warp=warp_sound)

    def execute_queue_sound(p):
        if p["channel"] is not None:
            channel = eval(p["channel"])
        else:
            channel = "sound"

        loop = p.get("loop", False)

        if loop is None:
            loop = config.default_sound_loop

        renpy.sound.queue(
            _audio_eval(p["file"]),
            channel=channel,
            fadein=eval(p.get("fadein", "0")),
            loop=loop,
            relative_volume=eval(p.get("volume", "1.0"))
            )


    renpy.register_statement(
        'queue sound',
        parse=parse_queue_music,
        execute=execute_queue_sound,
        lint=lint_play_sound,
        warp=warp_sound)

    def execute_stop_sound(p):
        if p["channel"] is not None:
            channel = eval(p["channel"])
        else:
            channel = "sound"

        fadeout = eval(p["fadeout"]) or None

        renpy.sound.stop(fadeout=fadeout, channel=channel)

    renpy.register_statement(
        'stop sound',
        parse=parse_stop_music,
        execute=execute_stop_sound,
        warp=warp_sound)


    # Generic play/queue/stop statements. These take a channel name as
    # the second thing.

    def parse_play_generic(l, parse_play_music=parse_play_music):
        channel = l.name()

        if channel is None:
            renpy.error('play requires a channel')

        rv = parse_play_music(l)
        if rv["channel"] is None:
            rv["channel"] = repr(channel)

        return rv

    def parse_queue_generic(l, parse_queue_music=parse_queue_music):
        channel = l.name()

        if channel is None:
            renpy.error('queue requires a channel')

        rv = parse_queue_music(l)
        if rv["channel"] is None:
            rv["channel"] = repr(channel)

        return rv

    def parse_stop_generic(l, parse_stop_music=parse_stop_music):
        channel = l.name()

        if channel is None:
            renpy.error('stop requires a channel')

        rv = parse_stop_music(l)
        if rv["channel"] is None:
            rv["channel"] = repr(channel)

        return rv

    def lint_play_generic(p, lint_play_music=lint_play_music):
        channel = eval(p["channel"])

        if not renpy.music.channel_defined(channel):
            renpy.error("channel %r is not defined" % channel)

        lint_play_music(p, channel)

    def lint_stop_generic(p):
        channel = eval(p["channel"])

        if not renpy.music.channel_defined(channel):
            renpy.error("channel %r is not defined" % channel)

    renpy.register_statement(
        'play',
        parse=parse_play_generic,
        execute=execute_play_music,
        predict=predict_play_music,
        lint=lint_play_generic,
        warp=warp_audio)

    renpy.register_statement(
        'queue',
        parse=parse_queue_generic,
        execute=execute_queue_music,
        lint=lint_play_generic,
        warp=warp_audio)

    renpy.register_statement(
        'stop',
        parse=parse_stop_generic,
        execute=execute_stop_music,
        lint=lint_stop_generic,
        warp=warp_audio)



    ##########################################################################
    # Pause statement.

    # Should the pause statement use the pause Transition?
    config.pause_with_transition = False

    def parse_pause(l):

        delay = l.simple_expression()

        if not l.eol():
            renpy.error("expected end of line.")

        return { "delay" : delay }

    def lint_pause(p):

        if p["delay"]:
            _try_eval(p["delay"], 'pause statement')

    def execute_pause(p):

        if p["delay"]:
            delay = eval(p["delay"])
            if config.pause_with_transition:
                renpy.with_statement(Pause(delay))
            else:
                renpy.pause(delay)
        else:
            renpy.pause()

    renpy.register_statement(
        'pause',
        parse=parse_pause,
        lint=lint_pause,
        execute=execute_pause)


##############################################################################
# Screen-related statements.

python early hide:

    # Should we predict screens?
    config.predict_screen_statements = True

    def _get_screen_name(p):
        """
        Returns screen name from the parsed data, evals it
        if it's an expression
        """
        name = p["name"]
        if p.get("expression", False):
            return eval(name)

        return name

    def _parse_screen_name(l):
        """
        Parses screen name from the lexer, returns tuple of 2 items

        OUT:
            tuple:
                (name, is_expression)
        """
        # Check if this screen name is an expression
        if l.keyword("expression"):
            is_expression = True
            name = l.require(l.simple_expression)

        # Otherwise just parse a name
        else:
            is_expression = False
            name = l.require(l.name)

        return (name, is_expression)

    def _get_screen_props(p):
        """
        Returns screen properties from the parsed data,
        they keys are prefixed with _ and can be used as arguments
        to the appropriate functions

        OUT:
            dict
        """
        layer = p.get("layer", None)
        zorder = p.get("zorder", None)
        if zorder is not None:
            zorder = eval(zorder)
        tag = p.get("tag", None)

        return dict(_layer=layer, _zorder=zorder, _tag=tag)

    def warp_true(p):
        return True

    def parse_show_call_screen(l):
        # Parse a name
        name, expression = _parse_screen_name(l)

        # Add pass between name and arguments if the name is an expression
        # so it works akin to "call expression 'label_name' pass (count=1)"
        if expression:
            l.keyword('pass')

        # Parse the list of arguments.
        arguments = renpy.parser.parse_arguments(l)

        predict = True
        transition_expr = None
        layer = None
        zorder = None
        tag = None

        while True:

            if l.keyword('nopredict'):
                predict = False

            elif l.keyword('with'):
                transition_expr = l.require(l.simple_expression)

            elif l.keyword("onlayer"):
                layer = l.require(l.name)

            elif l.keyword("zorder"):
                zorder = l.require(l.simple_expression)

            elif l.keyword("as"):
                tag = l.require(l.name)

            else:
                break

        l.expect_eol()

        return dict(
            name=name,
            arguments=arguments,
            predict=predict,
            transition_expr=transition_expr,
            layer=layer,
            zorder=zorder,
            tag=tag,
            expression=expression
        )

    def parse_hide_screen(l):
        # Parse a name
        name, expression = _parse_screen_name(l)

        transition_expr = None
        layer = None

        while True:
            if l.keyword('with'):
                transition_expr = l.require(l.simple_expression)

            elif l.keyword("onlayer"):
                layer = l.require(l.name)

            else:
                break

        l.expect_eol()

        return dict(name=name, transition_expr=transition_expr, layer=layer, expression=expression)

    def predict_screen(p):

        if not config.predict_screen_statements:
            return

        predict = p.get("predict", False)

        if not predict:
            return

        try:
            name = _get_screen_name(p)
        except Exception:
            return

        a = p["arguments"]

        if a is not None:
            args, kwargs = a.evaluate()
        else:
            args = [ ]
            kwargs = { }

        screen_props = _get_screen_props(p)
        kwargs.update(screen_props)

        renpy.predict_screen(name, *args, **kwargs)

    def execute_show_screen(p):

        name = _get_screen_name(p)
        a = p["arguments"]

        if a is not None:
            args, kwargs = a.evaluate()
        else:
            args = [ ]
            kwargs = { }

        screen_props = _get_screen_props(p)
        kwargs.update(screen_props)

        transition_expr = p.get("transition_expr", None)
        if transition_expr is not None:
            renpy.with_statement(None)

        renpy.show_screen(name, *args, **kwargs)

        if transition_expr is not None:
            renpy.with_statement(eval(transition_expr))

    def execute_call_screen(p):

        name = _get_screen_name(p)
        a = p["arguments"]

        transition_expr = p.get("transition_expr", None)

        if transition_expr is not None:
            renpy.transition(eval(transition_expr))

        if a is not None:
            args, kwargs = a.evaluate()
        else:
            args = [ ]
            kwargs = { }

        screen_props = _get_screen_props(p)
        kwargs.update(screen_props)

        store._return = renpy.call_screen(name, *args, **kwargs)

    def execute_hide_screen(p):
        name = _get_screen_name(p)

        transition_expr = p.get("transition_expr", None)
        if transition_expr is not None:
            renpy.with_statement(None)

        layer = p.get("layer", None)

        renpy.hide_screen(name, layer=layer)

        if transition_expr is not None:
            renpy.with_statement(eval(transition_expr))


    def lint_show_call_screen(p):
        is_expression = p.get("expression", False)

        name = p["name"]
        if not is_expression and not renpy.has_screen(name):
            renpy.error("Screen %s does not exist." % name)

        layer = p.get("layer", None)
        if (
            layer is not None
            and layer not in renpy.display.scenelists.layers
        ):
            renpy.error("Screen is being shown on unknown layer %s." % layer)

    def lint_hide_screen(p):
        layer = p.get("layer", None)
        if (
            layer is not None
            and layer not in renpy.display.scenelists.layers
        ):
            renpy.error("Screen is being hidden on unknown layer %s." % layer)


    renpy.register_statement(
        "show screen",
        parse=parse_show_call_screen,
        execute=execute_show_screen,
        predict=predict_screen,
        lint=lint_show_call_screen,
        warp=warp_true)

    renpy.register_statement(
        "call screen",
        parse=parse_show_call_screen,
        execute=execute_call_screen,
        predict=predict_screen,
        lint=lint_show_call_screen,
        force_begin_rollback=True)

    renpy.register_statement(
        "hide screen",
        parse=parse_hide_screen,
        execute=execute_hide_screen,
        lint=lint_hide_screen,
        warp=warp_true)
