# -*- Mode: python; indent-tabs-mode: nil; tab-width: 40 -*-
# vim: set filetype=python:
# This Source Code Form is subject to the terms of the Mozilla Public
# License, v. 2.0. If a copy of the MPL was not distributed with this
# file, You can obtain one at http://mozilla.org/MPL/2.0/.


m4 = check_prog(
    "M4",
    (
        "gm4",
        "m4",
    ),
    paths=prefer_mozillabuild_path,
)


@depends(mozconfig)
def prepare_mozconfig(mozconfig):
    if mozconfig["path"]:
        items = {}
        for key, value in mozconfig["vars"]["added"].items():
            items[key] = (value, "added")
        for key, (old, value) in mozconfig["vars"]["modified"].items():
            items[key] = (value, "modified")
        for t in ("env", "vars"):
            for key in mozconfig[t]["removed"].keys():
                items[key] = (None, "removed " + t)
        return items


@depends("OLD_CONFIGURE", build_project)
def old_configure(old_configure, build_project):
    if not old_configure:
        die("The OLD_CONFIGURE environment variable must be set")

    # os.path.abspath in the sandbox will ensure forward slashes on Windows,
    # which is actually necessary because this path actually ends up literally
    # as $0, and backslashes there breaks autoconf's detection of the source
    # directory.
    old_configure = os.path.abspath(old_configure[0])
    if build_project == "js":
        old_configure_dir = os.path.dirname(old_configure)
        if not old_configure_dir.endswith("/js/src"):
            old_configure = os.path.join(
                old_configure_dir, "js", "src", os.path.basename(old_configure)
            )
    return old_configure


@depends(prepare_mozconfig, old_configure_assignments)
@imports(_from="__builtin__", _import="open")
@imports(_from="__builtin__", _import="print")
@imports(_from="mozbuild.shellutil", _import="quote")
def prepare_configure(mozconfig, old_configure_assignments):
    with open("old-configure.vars", "w") as out:
        log.debug("Injecting the following to old-configure:")

        def inject(command):
            print(command, file=out)  # noqa Python 2vs3
            log.debug("| %s", command)

        if mozconfig:
            inject("# start of mozconfig values")
            for key, (value, action) in sorted(mozconfig.items()):
                if action.startswith("removed "):
                    inject("unset %s # from %s" % (key, action[len("removed ") :]))
                else:
                    inject("%s=%s # %s" % (key, quote(value), action))

            inject("# end of mozconfig values")

        for k, v in old_configure_assignments:
            inject("%s=%s" % (k, quote(v)))


@template
def old_configure_options(*options):
    for opt in options:
        option(opt, nargs="*", help="Help missing for old configure options")

    @dependable
    def all_options():
        return list(options)

    return depends(
        host_for_sub_configure, target_for_sub_configure, all_options, *options
    )


@old_configure_options(
    "--cache-file",
    "--datadir",
    "--enable-official-branding",
    "--includedir",
    "--libdir",
    "--prefix",
    "--with-branding",
    "--with-distribution-id",
    "--with-macbundlename-prefix",
    "--x-includes",
    "--x-libraries",
)
def prepare_configure_options(host, target, all_options, *options):
    # old-configure only supports the options listed in @old_configure_options
    # so we don't need to pass it every single option we've been passed. Only
    # the ones that are not supported by python configure need to.
    options = [
        value.format(name)
        for name, value in zip(all_options, options)
        if value.origin != "default"
    ] + [host, target]

    return namespace(options=options, all_options=all_options)


@template
def old_configure_for(old_configure_path, extra_env=None):
    if extra_env is None:
        extra_env = dependable(None)

    @depends(
        prepare_configure,
        prepare_configure_options,
        prefer_mozillabuild_path,
        altered_path,
        extra_env,
        build_environment,
        old_configure_path,
        awk,
        m4,
        shell,
    )
    @imports(_from="__builtin__", _import="compile")
    @imports(_from="__builtin__", _import="open")
    @imports(_from="__builtin__", _import="OSError")
    @imports("glob")
    @imports("itertools")
    @imports("logging")
    @imports("os")
    @imports("subprocess")
    @imports("sys")
    @imports(_from="mozbuild.shellutil", _import="quote")
    @imports(_from="mozbuild.shellutil", _import="split")
    @imports(_from="tempfile", _import="NamedTemporaryFile")
    @imports(_from="subprocess", _import="CalledProcessError")
    @imports(_from="__builtin__", _import="exec")
    def old_configure(
        prepare_configure,
        prepare_configure_options,
        prefer_mozillabuild_path,
        altered_path,
        extra_env,
        build_env,
        old_configure,
        awk,
        m4,
        shell,
    ):
        # Use prepare_configure to make lint happy
        prepare_configure

        if altered_path:
            path = altered_path
        else:
            path = os.pathsep.join(prefer_mozillabuild_path)

        refresh = True
        if os.path.exists(old_configure):
            mtime = os.path.getmtime(old_configure)
            aclocal = os.path.join(build_env.topsrcdir, "build", "autoconf", "*.m4")
            for input in itertools.chain(
                (
                    old_configure + ".in",
                    os.path.join(os.path.dirname(old_configure), "aclocal.m4"),
                ),
                glob.iglob(aclocal),
            ):
                if os.path.getmtime(input) > mtime:
                    break
            else:
                refresh = False

        if refresh:
            autoconf = os.path.join(
                build_env.topsrcdir, "build", "autoconf", "autoconf.sh"
            )
            log.info("Refreshing %s with %s", old_configure, autoconf)
            env = dict(os.environ)
            env["M4"] = m4
            env["AWK"] = awk
            env["AC_MACRODIR"] = os.path.join(build_env.topsrcdir, "build", "autoconf")
            env["PATH"] = path

            try:
                script = subprocess.check_output(
                    [
                        shell,
                        autoconf,
                        "--localdir=%s" % os.path.dirname(old_configure),
                        old_configure + ".in",
                    ],
                    # Fix the working directory, so that when m4 is called, that
                    # includes of relative paths are deterministically resolved
                    # relative to the directory containing old-configure.
                    cwd=os.path.dirname(old_configure),
                    env=env,
                )
            except CalledProcessError as exc:
                die("autoconf exited with return code {}".format(exc.returncode))

            if not script:
                die(
                    "Generated old-configure is empty! Check that your autoconf 2.13 program works!"
                )

            # Make old-configure append to config.log, where we put our own log.
            # This could be done with a m4 macro, but it's way easier this way
            script = script.replace(b">./config.log", b">>${CONFIG_LOG=./config.log}")

            with NamedTemporaryFile(
                mode="wb",
                prefix=os.path.basename(old_configure),
                dir=os.path.dirname(old_configure),
                delete=False,
            ) as fh:
                fh.write(script)

            try:
                os.rename(fh.name, old_configure)
            except OSError:
                try:
                    # Likely the file already existed (on Windows). Retry after removing it.
                    os.remove(old_configure)
                    os.rename(fh.name, old_configure)
                except OSError as e:
                    die("Failed re-creating old-configure: %s" % e.message)

        cmd = [shell, old_configure] + prepare_configure_options.options

        env = dict(os.environ)

        # For debugging purpose, in case it's not what we'd expect.
        log.debug("Running %s", quote(*cmd))

        # Our logging goes to config.log, the same file old.configure uses.
        # We can't share the handle on the file, so close it.
        logger = logging.getLogger("moz.configure")
        config_log = None
        for handler in logger.handlers:
            if isinstance(handler, logging.FileHandler):
                config_log = handler
                config_log.close()
                logger.removeHandler(config_log)
                env["CONFIG_LOG"] = config_log.baseFilename
                log_size = os.path.getsize(config_log.baseFilename)
                break

        env["PATH"] = path

        if extra_env:
            env.update(extra_env)

        env["OLD_CONFIGURE_VARS"] = os.path.join(
            build_env.topobjdir, "old-configure.vars"
        )
        proc = subprocess.Popen(
            cmd, stdout=subprocess.PIPE, stderr=subprocess.STDOUT, env=env
        )
        while True:
            line = proc.stdout.readline()
            if not line:
                break
            log.info(line.rstrip())

        ret = proc.wait()
        if ret:
            with log.queue_debug():
                if config_log:
                    with open(config_log.baseFilename, "r") as fh:
                        fh.seek(log_size)
                        for line in fh:
                            log.debug(line.rstrip())
                log.error("old-configure failed")
            sys.exit(ret)

        if config_log:
            # Create a new handler in append mode
            handler = logging.FileHandler(config_log.baseFilename, mode="a", delay=True)
            handler.setFormatter(config_log.formatter)
            logger.addHandler(handler)

        raw_config = {
            "split": split,
            "unique_list": unique_list,
        }
        with open("config.data", "r") as fh:
            code = compile(fh.read(), "config.data", "exec")
            exec(code, raw_config)

        # Ensure all the flags known to old-configure appear in the
        # @old_configure_options above.
        all_options = set(prepare_configure_options.all_options)
        for flag in raw_config["flags"]:
            if flag not in all_options:
                die(
                    "Missing option in `@old_configure_options` in %s: %s",
                    __file__,
                    flag,
                )

        # If the code execution above fails, we want to keep the file around for
        # debugging.
        os.remove("config.data")

        return namespace(
            **{
                c: [
                    (k[1:-1], v[1:-1] if isinstance(v, str) else v)
                    for k, v in raw_config[c]
                ]
                for c in ("substs", "defines")
            }
        )

    return old_configure


old_configure = old_configure_for(old_configure)
set_config("OLD_CONFIGURE_SUBSTS", old_configure.substs)
set_config("OLD_CONFIGURE_DEFINES", old_configure.defines)


# Assuming no other option is declared after this function, handle the
# env options that were injected by mozconfig_options by creating dummy
# Option instances and having the sandbox's CommandLineHelper handle
# them. We only do so for options that haven't been declared so far,
# which should be a proxy for the options that old-configure handles
# and that we don't know anything about.
@depends("--help")
@imports("__sandbox__")
@imports(_from="mozbuild.configure.options", _import="Option")
def remaining_mozconfig_options(_):
    helper = __sandbox__._helper
    for arg in list(helper):
        if helper._origins[arg] != "mozconfig":
            continue
        name = arg.split("=", 1)[0]
        if name.isupper() and name not in __sandbox__._options:
            option = Option(env=name, nargs="*", help=name)
            helper.handle(option)


# Please do not add anything after remaining_mozconfig_options()