# Copyright (c) 2019 Egor Tensin <egor@tensin.name>
# This file is part of the "cmake-common" project.
# For details, see https://github.com/egor-tensin/cmake-common.
# Distributed under the MIT License.

R"""Build a CMake project.

This script works nicely with boost-build from this package - it will set the
correct BOOST_ROOT value automatically.

Also, it facilitates building with different toolsets/for different platforms
with the help from the --toolset and --platform parameters.

Usage example:

    $ project-build --configuration Release --install path/to/somewhere -- examples/simple build/
    ...

    $ ./path/to/somewhere/bin/foo
    foo
"""

import argparse
from contextlib import contextmanager
import logging
import os
import sys
import tempfile

from project.configuration import Configuration
from project.linkage import Linkage
from project.platform import Platform
from project.toolset import Toolset, ToolsetVersion
from project.utils import normalize_path, mkdir_parent, run, setup_logging
import project.version

DEFAULT_PLATFORM = Platform.AUTO
DEFAULT_CONFIGURATION = Configuration.DEBUG
DEFAULT_TOOLSET_VERSION = ToolsetVersion.default()


# This way of basically passing `-j` to make is more universal compared to
# _guessing_ that the build system is make and passing -j explicitly.  Plus it
# works with older CMake versions, which don't support the --parallel flag.
cmake_env = os.environ.copy()
cmake_env["CMAKE_BUILD_PARALLEL_LEVEL"] = str(os.cpu_count())


def run_cmake(cmake_args):
    return run(["cmake"] + cmake_args, env=cmake_env)


class GenerationPhase:
    def __init__(
        self,
        src_dir,
        build_dir,
        platform=None,
        configuration=None,
        boost_dir=None,
        link=None,
        runtime_link=None,
        install_dir=None,
        cmake_args=None,
    ):

        self.src_dir = normalize_path(src_dir)
        self.build_dir = normalize_path(build_dir)
        self.platform = platform or DEFAULT_PLATFORM
        self.configuration = configuration or DEFAULT_CONFIGURATION
        self.boost_dir = normalize_path(boost_dir) if boost_dir else None
        link = link or Linkage.default_link()
        runtime_link = runtime_link or Linkage.default_runtime_link()
        self.link, self.runtime_link = Linkage.validate_linkage(link, runtime_link)
        self.install_dir = normalize_path(install_dir) if install_dir else None
        self.cmake_args = cmake_args or []

    def _cmake_args(self, toolset):
        result = []
        result += toolset.cmake_args(self.build_dir, self.platform)
        result += self.configuration.cmake_args()
        result += self._cmake_boost_args()
        result += self._cmake_extra_args()
        result += self.runtime_link.cmake_args_runtime_link()
        result += self.cmake_args
        result += self._cmake_dir_args()
        return result

    def _cmake_boost_args(self):
        if self.boost_dir is None:
            return []
        root = self.boost_dir
        root = os.path.join(root, self.platform.boost_installdir(self.configuration))
        args = [
            f"-DBoost_ROOT={root}",
            f"-DBOOST_ROOT={root}",
        ]
        args += self.link.cmake_args_link()
        return args

    @staticmethod
    def _cmake_extra_args():
        return ["-DCMAKE_EXPORT_COMPILE_COMMANDS=ON"]

    def _cmake_dir_args(self):
        args = []
        if self.install_dir is not None:
            args += [f"-DCMAKE_INSTALL_PREFIX={self.install_dir}"]
        # Important! -H must come as the last parameter, older CMake versions
        # don't like it when it's not.
        args += [f"-B{self.build_dir}", f"-H{self.src_dir}"]
        return args

    def run(self, toolset):
        run_cmake(self._cmake_args(toolset))


class BuildPhase:
    def __init__(self, build_dir, install_dir=None, configuration=None):
        self.build_dir = normalize_path(build_dir)
        self.install_dir = install_dir
        self.configuration = configuration or DEFAULT_CONFIGURATION

    def _cmake_args(self, toolset):
        result = ["--build", self.build_dir]
        result += ["--config", str(self.configuration)]
        if self.install_dir is not None:
            result += ["--target", "install"]
        result += ["--"] + toolset.build_system_args()
        return result

    def run(self, toolset):
        run_cmake(self._cmake_args(toolset))


class BuildParameters:
    def __init__(
        self,
        src_dir,
        build_dir,
        install_dir=None,
        platform=None,
        configuration=None,
        boost_dir=None,
        link=None,
        runtime_link=None,
        toolset_version=None,
        cmake_args=None,
    ):

        self.src_dir = normalize_path(src_dir)
        self.build_dir = normalize_path(build_dir) if build_dir else None
        self.install_dir = normalize_path(install_dir) if install_dir else None
        self.platform = platform or DEFAULT_PLATFORM
        self.configuration = configuration or DEFAULT_CONFIGURATION
        self.boost_dir = normalize_path(boost_dir) if boost_dir else None
        self.link = link or Linkage.default_link()
        self.runtime_link = runtime_link or Linkage.default_runtime_link()
        self.toolset_version = toolset_version or DEFAULT_TOOLSET_VERSION
        self.cmake_args = cmake_args or []

    @staticmethod
    def from_args(args):
        args = vars(args)
        args.pop("help_toolsets", None)
        return BuildParameters(**args)

    @contextmanager
    def create_build_dir(self):
        if self.build_dir is not None:
            logging.info("Build directory: %s", self.build_dir)
            mkdir_parent(self.build_dir)
            yield self.build_dir
            return

        with tempfile.TemporaryDirectory(
            dir=os.path.dirname(self.src_dir)
        ) as build_dir:
            logging.info("Build directory: %s", build_dir)
            try:
                yield build_dir
            finally:
                logging.info("Removing build directory: %s", build_dir)


def build(params):
    with params.create_build_dir() as build_dir:
        toolset = Toolset.make(params.toolset_version, params.platform)

        gen_phase = GenerationPhase(
            params.src_dir,
            build_dir,
            platform=params.platform,
            configuration=params.configuration,
            boost_dir=params.boost_dir,
            link=params.link,
            runtime_link=params.runtime_link,
            install_dir=params.install_dir,
            cmake_args=params.cmake_args,
        )
        gen_phase.run(toolset)
        build_phase = BuildPhase(
            build_dir,
            install_dir=params.install_dir,
            configuration=params.configuration,
        )
        build_phase.run(toolset)


def _parse_args(argv=None):
    if argv is None:
        argv = sys.argv[1:]

    if "--help-toolsets" in argv:
        sys.stdout.write(ToolsetVersion.help_toolsets())
        sys.exit(0)

    parser = argparse.ArgumentParser(
        description=__doc__, formatter_class=argparse.RawDescriptionHelpFormatter
    )

    parser.add_argument(
        "--help-toolsets",
        action="store_true",
        help="show detailed info about supported toolsets",
    )

    project.version.add_to_arg_parser(parser)

    parser.add_argument(
        "--toolset",
        metavar="TOOLSET",
        dest="toolset_version",
        type=ToolsetVersion.parse,
        default=DEFAULT_TOOLSET_VERSION,
        help=f"toolset to use ({ToolsetVersion.usage()})",
    )

    platform_options = "/".join(map(str, Platform.all()))
    configuration_options = "/".join(map(str, Configuration.all()))

    parser.add_argument(
        "--platform",
        metavar="PLATFORM",
        type=Platform.parse,
        help=f"target platform ({platform_options})",
    )
    parser.add_argument(
        "--configuration",
        metavar="CONFIG",
        type=Configuration.parse,
        default=DEFAULT_CONFIGURATION,
        help=f"build configuration ({configuration_options})",
    )

    parser.add_argument(
        "--boost",
        metavar="DIR",
        dest="boost_dir",
        type=normalize_path,
        help="set Boost directory path",
    )

    linkage_options = "/".join(map(str, Linkage.all()))
    parser.add_argument(
        "--link",
        metavar="LINKAGE",
        type=Linkage.parse,
        default=Linkage.default_link(),
        help=f"how Boost libraries are linked ({linkage_options})",
    )
    parser.add_argument(
        "--runtime-link",
        metavar="LINKAGE",
        type=Linkage.parse,
        default=Linkage.default_runtime_link(),
        help=f"which runtime to link to ({linkage_options})",
    )

    parser.add_argument(
        "--install",
        metavar="DIR",
        dest="install_dir",
        type=normalize_path,
        help="install directory",
    )

    parser.add_argument(
        "--cmake-arg",
        metavar="ARG",
        dest="cmake_args",
        action="extend",
        nargs="*",
        help="additional CMake arguments, to be passed verbatim",
    )

    parser.add_argument("src_dir", type=normalize_path, help="source directory")
    parser.add_argument(
        "build_dir",
        type=normalize_path,
        nargs="?",
        help="build directory (a temporary directory if omitted)",
    )

    return parser.parse_args(argv)


def main(argv=None):
    args = _parse_args(argv)
    with setup_logging():
        build(BuildParameters.from_args(args))


if __name__ == "__main__":
    main()