# Copyright 2024 The Servo Project Developers. See the COPYRIGHT
# file at the top-level directory of this distribution.
#
# Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
# http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
# <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
# option. This file may not be copied, modified, or distributed
# except according to those terms.

from typing import TypeGuard
import errno
import json
import os
import pathlib
import platform
import shutil
import subprocess
import sys
from enum import Enum

from os import path
from packaging.version import parse as parse_version
from typing import Any, Optional

import servo.platform
import servo.util as util


class SanitizerKind(Enum):
    NONE = 0
    ASAN = 1
    TSAN = 2

    # Apparently enums don't always compare across modules, so we define
    # helper methods.
    def is_asan(self) -> bool:
        return self is self.ASAN

    def is_tsan(self) -> bool:
        return self is self.TSAN

    # Returns true if no sanitizer is enabled.
    def is_none(self) -> bool:
        return self is self.NONE

    # Returns true if a sanitizer is enabled.
    def is_some(self) -> bool:
        return not self.is_none()


class BuildTarget(object):
    def __init__(self, target_triple: str) -> None:
        self.target_triple = target_triple

    @staticmethod
    def from_triple(target_triple: Optional[str]) -> "BuildTarget":
        host_triple = servo.platform.host_triple()
        if target_triple:
            if "android" in target_triple:
                return AndroidTarget(target_triple)
            elif "ohos" in target_triple:
                return OpenHarmonyTarget(target_triple)
            elif target_triple != host_triple:
                raise Exception(f"Unknown build target {target_triple}")
        return BuildTarget(host_triple)

    def triple(self) -> str:
        return self.target_triple

    def binary_name(self) -> str:
        return f"servo{servo.platform.get().executable_suffix()}"

    def configure_build_environment(self, env: dict[str, str], config: dict[str, Any], topdir: pathlib.Path) -> None:
        pass

    def is_cross_build(self) -> bool:
        return False

    def needs_packaging(self) -> bool:
        return False


class CrossBuildTarget(BuildTarget):
    def is_cross_build(self) -> bool:
        return True


class AndroidTarget(CrossBuildTarget):
    DEFAULT_TRIPLE = "aarch64-linux-android"

    def ndk_configuration(self) -> dict[str, str]:
        target = self.triple()
        config = {}
        if target == "armv7-linux-androideabi":
            config["platform"] = "android-30"
            config["target"] = target
            config["toolchain_prefix"] = "arm-linux-androideabi"
            config["arch"] = "arm"
            config["lib"] = "armeabi-v7a"
            config["toolchain_name"] = "armv7a-linux-androideabi30"
        elif target == "aarch64-linux-android":
            config["platform"] = "android-30"
            config["target"] = target
            config["toolchain_prefix"] = target
            config["arch"] = "arm64"
            config["lib"] = "arm64-v8a"
            config["toolchain_name"] = "aarch64-linux-androideabi30"
        elif target == "i686-linux-android":
            # https://github.com/jemalloc/jemalloc/issues/1279
            config["platform"] = "android-30"
            config["target"] = target
            config["toolchain_prefix"] = target
            config["arch"] = "x86"
            config["lib"] = "x86"
            config["toolchain_name"] = "i686-linux-android30"
        elif target == "x86_64-linux-android":
            config["platform"] = "android-30"
            config["target"] = target
            config["toolchain_prefix"] = target
            config["arch"] = "x86_64"
            config["lib"] = "x86_64"
            config["toolchain_name"] = "x86_64-linux-android30"
        else:
            raise Exception(f"Unknown android target {target}")

        return config

    def configure_build_environment(self, env: dict[str, str], config: dict[str, Any], topdir: pathlib.Path) -> None:
        # Paths to Android build tools:
        if config["android"]["sdk"]:
            env["ANDROID_SDK_ROOT"] = config["android"]["sdk"]
        if config["android"]["ndk"]:
            env["ANDROID_NDK_ROOT"] = config["android"]["ndk"]

        toolchains = path.join(topdir, "android-toolchains")
        for kind in ["sdk", "ndk"]:
            default = os.path.join(toolchains, kind)
            if os.path.isdir(default):
                env.setdefault(f"ANDROID_{kind.upper()}_ROOT", default)

        if "IN_NIX_SHELL" in env and ("ANDROID_NDK_ROOT" not in env or "ANDROID_SDK_ROOT" not in env):
            print("Please set SERVO_ANDROID_BUILD=1 when starting the Nix shell to include the Android SDK/NDK.")
            sys.exit(1)
        if "ANDROID_NDK_ROOT" not in env:
            print("Please set the ANDROID_NDK_ROOT environment variable.")
            sys.exit(1)
        if "ANDROID_SDK_ROOT" not in env:
            print("Please set the ANDROID_SDK_ROOT environment variable.")
            sys.exit(1)

        ndk_configuration = self.ndk_configuration()
        android_platform = ndk_configuration["platform"]
        android_toolchain_name = ndk_configuration["toolchain_name"]
        android_lib = ndk_configuration["lib"]

        android_api = android_platform.replace("android-", "")

        # Check if the NDK version is 28
        if not os.path.isfile(path.join(env["ANDROID_NDK_ROOT"], "source.properties")):
            print("ANDROID_NDK should have file `source.properties`.")
            print("The environment variable ANDROID_NDK_ROOT may be set at a wrong path.")
            sys.exit(1)
        with open(path.join(env["ANDROID_NDK_ROOT"], "source.properties"), encoding="utf8") as ndk_properties:
            lines = ndk_properties.readlines()
            if lines[1].split(" = ")[1].split(".")[0] != "28":
                print("Servo currently only supports NDK r28.")
                sys.exit(1)

        # Android builds also require having the gcc bits on the PATH and various INCLUDE
        # path munging if you do not want to install a standalone NDK. See:
        # https://dxr.mozilla.org/mozilla-central/source/build/autoconf/android.m4#139-161
        os_type = platform.system().lower()
        if os_type not in ["linux", "darwin"]:
            raise Exception("Android cross builds are only supported on Linux and macOS.")

        llvm_prebuilt = path.join(env["ANDROID_NDK_ROOT"], "toolchains", "llvm", "prebuilt")

        cpu_type = platform.machine().lower()
        host_suffix = "unknown"
        if cpu_type in ["i386", "i486", "i686", "i768", "x86"]:
            host_suffix = "x86"
        elif cpu_type in ["x86_64", "x86-64", "x64", "amd64"]:
            host_suffix = "x86_64"
        else:
            available_prebuilts = os.listdir(llvm_prebuilt)
            available_prebuilts = [prebuilt for prebuilt in available_prebuilts if prebuilt.startswith(os_type)]
            # If there is only one prebuilt option available, it's probably the right one for the host
            # platform. E.g. on Arm macs, only the x86 prebuilts are available, buts that perfectly fine,
            # since there is rosetta.
            if len(available_prebuilts) == 1:
                host_suffix = available_prebuilts[0].removeprefix(f"{os_type}-")
            else:
                print(f"Error: Can't determine LLVM prebuilt. Unknown cpu type {cpu_type}.")
                print(f"Hint: The LLVM prebuilts folder contains the following entries: {available_prebuilts}")
                print("Please open an issue with the above information")
                raise Exception("Can't determine LLVM prebuilt directory.")
        host = os_type + "-" + host_suffix

        host_cc = env.get("HOST_CC") or shutil.which("clang")
        host_cxx = env.get("HOST_CXX") or shutil.which("clang++")

        llvm_toolchain = path.join(llvm_prebuilt, host)
        env["PATH"] = env["PATH"] + ":" + path.join(llvm_toolchain, "bin")

        def to_ndk_bin(prog: str) -> str:
            return path.join(llvm_toolchain, "bin", prog)

        # This workaround is due to an issue in the x86_64 Android NDK that introduces
        # an undefined reference to the symbol '__extendsftf2'.
        # See https://github.com/termux/termux-packages/issues/8029#issuecomment-1369150244
        if "x86_64" in self.triple():
            libclangrt_filename = subprocess.run(
                [to_ndk_bin(f"x86_64-linux-android{android_api}-clang"), "--print-libgcc-file-name"],
                check=True,
                capture_output=True,
                encoding="utf8",
            ).stdout
            env["RUSTFLAGS"] = env.get("RUSTFLAGS", "")
            env["RUSTFLAGS"] += f"-C link-arg={libclangrt_filename}"

        assert host_cc
        assert host_cxx

        env["RUST_TARGET"] = self.triple()
        env["HOST_CC"] = host_cc
        env["HOST_CXX"] = host_cxx
        env["HOST_CFLAGS"] = ""
        env["HOST_CXXFLAGS"] = ""
        env["TARGET_CC"] = to_ndk_bin("clang")
        env["TARGET_CPP"] = to_ndk_bin("clang") + " -E"
        env["TARGET_CXX"] = to_ndk_bin("clang++")

        env["TARGET_AR"] = to_ndk_bin("llvm-ar")
        env["TARGET_RANLIB"] = to_ndk_bin("llvm-ranlib")
        env["TARGET_OBJCOPY"] = to_ndk_bin("llvm-objcopy")
        env["TARGET_YASM"] = to_ndk_bin("yasm")
        env["TARGET_STRIP"] = to_ndk_bin("llvm-strip")
        env["RUST_FONTCONFIG_DLOPEN"] = "on"

        env["LIBCLANG_PATH"] = path.join(llvm_toolchain, "lib")
        env["CLANG_PATH"] = to_ndk_bin("clang")
        env["BINDGEN_EXTRA_CLANG_ARGS"] = (
            f"--target={android_toolchain_name} --sysroot={path.join(llvm_toolchain, 'sysroot')}"
        )

        # A cheat-sheet for some of the build errors caused by getting the search path wrong...
        #
        # fatal error: 'limits' file not found
        #   -- add -I cxx_include
        # unknown type name '__locale_t' (when running bindgen in mozjs_sys)
        #   -- add -isystem sysroot_include
        # error: use of undeclared identifier 'UINTMAX_C'
        #   -- add -D__STDC_CONSTANT_MACROS
        #
        # Also worth remembering: autoconf uses C for its configuration,
        # even for C++ builds, so the C flags need to line up with the C++ flags.
        env["TARGET_CFLAGS"] = env.get("TARGET_CFLAGS", "") + " " + "--target=" + android_toolchain_name
        env["TARGET_CXXFLAGS"] = env.get("TARGET_CXXFLAGS", "") + " " + "--target=" + android_toolchain_name

        # These two variables are needed for the mozjs compilation.
        env["ANDROID_API_LEVEL"] = android_api
        env["ANDROID_NDK_HOME"] = env["ANDROID_NDK_ROOT"]

        # The two variables set below are passed by our custom
        # support/android/toolchain.cmake to the NDK's CMake toolchain file
        env["ANDROID_ABI"] = android_lib
        env["ANDROID_PLATFORM"] = android_platform
        env["NDK_CMAKE_TOOLCHAIN_FILE"] = path.join(
            env["ANDROID_NDK_ROOT"], "build", "cmake", "android.toolchain.cmake"
        )
        env["CMAKE_TOOLCHAIN_FILE"] = path.join(topdir, "support", "android", "toolchain.cmake")

        # Set output dir for gradle aar files
        env["AAR_OUT_DIR"] = path.join(topdir, "target", "android", "aar")
        if not os.path.exists(env["AAR_OUT_DIR"]):
            os.makedirs(env["AAR_OUT_DIR"])

        env["TARGET_PKG_CONFIG_SYSROOT_DIR"] = path.join(llvm_toolchain, "sysroot")

    def binary_name(self) -> str:
        return "libservoshell.so"

    def is_cross_build(self) -> bool:
        return True

    def needs_packaging(self) -> bool:
        return True

    def get_package_path(self, build_type_directory: str) -> str:
        base_path = util.get_target_dir()
        base_path = path.join(base_path, "android", self.triple())
        apk_name = "servoapp.apk"
        return path.join(base_path, build_type_directory, apk_name)


class OpenHarmonyTarget(CrossBuildTarget):
    DEFAULT_TRIPLE = "aarch64-unknown-linux-ohos"

    def configure_build_environment(self, env: dict[str, str], config: dict[str, Any], topdir: pathlib.Path) -> None:
        # Paths to OpenHarmony SDK and build tools:
        # Note: `OHOS_SDK_NATIVE` is the CMake variable name the `hvigor` build-system
        # uses for the native directory of the SDK, so we use the same name to be consistent.
        if "OHOS_SDK_NATIVE" not in env and config["ohos"]["ndk"]:
            env["OHOS_SDK_NATIVE"] = config["ohos"]["ndk"]

        if "OHOS_SDK_NATIVE" not in env:
            print(
                "Please set the OHOS_SDK_NATIVE environment variable to the location of the `native` directory "
                "in the OpenHarmony SDK."
            )
            sys.exit(1)

        ndk_root = pathlib.Path(env["OHOS_SDK_NATIVE"])

        if not ndk_root.is_dir():
            print(f"OHOS_SDK_NATIVE is not set to a valid directory: `{ndk_root}`")
            sys.exit(1)

        ndk_root = ndk_root.resolve()
        package_info = ndk_root.joinpath("oh-uni-package.json")
        try:
            with open(package_info) as meta_file:
                meta = json.load(meta_file)
            ohos_api_version = int(meta["apiVersion"])
            ohos_sdk_version = parse_version(meta["version"])
            if ohos_sdk_version < parse_version("5.0") or ohos_api_version < 14:
                raise RuntimeError("Building servo for OpenHarmony requires SDK version 5.0.2 (API-14) or newer.")
            print(f"Info: The OpenHarmony SDK {ohos_sdk_version} is targeting API-level {ohos_api_version}")
        except (OSError, json.JSONDecodeError) as e:
            print(f"Failed to read metadata information from {package_info}")
            print(f"Exception: {e}")

        llvm_toolchain = ndk_root.joinpath("llvm")
        llvm_bin = llvm_toolchain.joinpath("bin")
        ohos_sysroot = ndk_root.joinpath("sysroot")
        if not (llvm_toolchain.is_dir() and llvm_bin.is_dir()):
            print(f"Expected to find `llvm` and `llvm/bin` folder under $OHOS_SDK_NATIVE at `{llvm_toolchain}`")
            sys.exit(1)
        if not ohos_sysroot.is_dir():
            print(f"Could not find OpenHarmony sysroot in {ndk_root}")
            sys.exit(1)
        # When passing the sysroot to Rust crates such as `cc-rs` or bindgen, we should pass
        # POSIX paths, since otherwise the backslashes in windows paths may be interpreted as
        # escapes and lead to errors.
        ohos_sysroot_posix = ohos_sysroot.as_posix()

        # Note: We don't use the `<target_triple>-clang` wrappers on purpose, since
        # a) the OH 4.0 SDK does not have them yet AND
        # b) the wrappers in the newer SDKs are bash scripts, which can cause problems
        # on windows, depending on how the wrapper is called.
        # Instead, we ensure that all the necessary flags for the c-compiler are set
        # via environment variables such as `TARGET_CFLAGS`.
        def to_sdk_llvm_bin(prog: str) -> str:
            if sys.platform == "win32":
                prog = prog + ".exe"
            llvm_prog = llvm_bin.joinpath(prog)
            if not llvm_prog.is_file():
                raise FileNotFoundError(errno.ENOENT, os.strerror(errno.ENOENT), llvm_prog)
            return llvm_bin.joinpath(prog).as_posix()

        # CC and CXX should already be set to appropriate host compilers by `build_env()`
        env["HOST_CC"] = env["CC"]
        env["HOST_CXX"] = env["CXX"]
        env["TARGET_AR"] = to_sdk_llvm_bin("llvm-ar")
        env["TARGET_RANLIB"] = to_sdk_llvm_bin("llvm-ranlib")
        env["TARGET_READELF"] = to_sdk_llvm_bin("llvm-readelf")
        env["TARGET_OBJCOPY"] = to_sdk_llvm_bin("llvm-objcopy")
        env["TARGET_STRIP"] = to_sdk_llvm_bin("llvm-strip")

        target_triple = self.triple()
        rust_target_triple = str(target_triple).replace("-", "_")
        ndk_clang = to_sdk_llvm_bin("clang")
        ndk_clangxx = to_sdk_llvm_bin("clang++")
        env[f"CC_{rust_target_triple}"] = ndk_clang
        env[f"CXX_{rust_target_triple}"] = ndk_clangxx
        # The clang target name is different from the LLVM target name
        clang_target_triple = str(target_triple).replace("-unknown-", "-")
        clang_target_triple_underscore = clang_target_triple.replace("-", "_")
        env[f"CC_{clang_target_triple_underscore}"] = ndk_clang
        env[f"CXX_{clang_target_triple_underscore}"] = ndk_clangxx
        # rustc linker
        env[f"CARGO_TARGET_{rust_target_triple.upper()}_LINKER"] = ndk_clang

        link_args = [
            "-fuse-ld=lld",
            f"--target={clang_target_triple}",
            f"--sysroot={ohos_sysroot_posix}",
            "-Wl,--build-id",
        ]

        env["HOST_CFLAGS"] = ""
        env["HOST_CXXFLAGS"] = ""
        ohos_cflags = [
            "-D__MUSL__",
            "-DMDB_USE_ROBUST=0",
            f" --target={clang_target_triple}",
            f" --sysroot={ohos_sysroot_posix}",
            "-Wno-error=unused-command-line-argument",
        ]
        if clang_target_triple.startswith("armv7-"):
            ohos_cflags.extend(["-march=armv7-a", "-mfloat-abi=softfp", "-mtune=generic-armv7-a", "-mthumb"])
        ohos_cflags_str = " ".join(ohos_cflags)

        env["TARGET_CFLAGS"] = env.get("TARGET_CFLAGS", "") + " " + ohos_cflags_str
        env["TARGET_CPPFLAGS"] = env.get("TARGET_CPPFLAGS", "") + " " + "-D__MUSL__"
        env["TARGET_CXXFLAGS"] = env.get("TARGET_CXXFLAGS", "") + " " + ohos_cflags_str

        # CMake related flags
        env["CMAKE"] = ndk_root.joinpath("build-tools", "cmake", "bin", "cmake").as_posix()
        cmake_toolchain_file = ndk_root.joinpath("build", "cmake", "ohos.toolchain.cmake")
        if cmake_toolchain_file.is_file():
            env[f"CMAKE_TOOLCHAIN_FILE_{rust_target_triple}"] = cmake_toolchain_file.as_posix()
        else:
            print(
                f"Warning: Failed to find the OpenHarmony CMake Toolchain file - Expected it at {cmake_toolchain_file}"
            )
        env[f"CMAKE_C_COMPILER_{rust_target_triple}"] = ndk_clang
        env[f"CMAKE_CXX_COMPILER_{rust_target_triple}"] = ndk_clangxx

        # pkg-config
        pkg_config_path = "{}:{}".format(
            ohos_sysroot.joinpath("usr", "lib", "pkgconfig").as_posix(),
            ohos_sysroot.joinpath("usr", "share", "pkgconfig").as_posix(),
        )
        env[f"PKG_CONFIG_SYSROOT_DIR_{rust_target_triple}"] = ohos_sysroot_posix
        env[f"PKG_CONFIG_PATH_{rust_target_triple}"] = pkg_config_path

        # bindgen / libclang-sys
        env["LIBCLANG_PATH"] = path.join(llvm_toolchain, "lib")
        env["CLANG_PATH"] = ndk_clangxx
        env[f"CXXSTDLIB_{clang_target_triple_underscore}"] = "c++"
        bindgen_extra_clangs_args_var = f"BINDGEN_EXTRA_CLANG_ARGS_{rust_target_triple}"
        bindgen_extra_clangs_args = env.get(bindgen_extra_clangs_args_var, "")
        bindgen_extra_clangs_args = bindgen_extra_clangs_args + " " + ohos_cflags_str
        env[bindgen_extra_clangs_args_var] = bindgen_extra_clangs_args

        sanitizer: SanitizerKind = config["build"]["sanitizer"]
        san_compile_flags = []
        if sanitizer.is_some():
            # Lookup `<sdk>/native/llvm/lib/clang/15.0.4/lib/aarch64-linux-ohos/libclang_rt.asan.so`
            lib_clang = llvm_toolchain.joinpath("lib", "clang")
            children = [f.path for f in os.scandir(lib_clang) if f.is_dir()]
            if len(children) != 1:
                raise RuntimeError(f"Expected exactly 1 libclang version: `{children}`")
            lib_clang_version_dir = pathlib.Path(children[0])
            libclang_arch = lib_clang_version_dir.joinpath("lib", clang_target_triple).resolve()
            # Use the clangrt from the NDK to use the same library for both C++ and Rust.
            env["RUSTFLAGS"] += " -Zexternal-clangrt"
            san_compile_flags.append("-fno-omit-frame-pointer")

        # On OpenHarmony we add some additional flags when asan is enabled
        if sanitizer.is_asan():
            libasan_so_path = libclang_arch.joinpath("libclang_rt.asan.so")
            libasan_preinit_path = libclang_arch.joinpath("libclang_rt.asan-preinit.a")
            if not libasan_so_path.exists():
                raise RuntimeError(f"Couldn't find ASAN runtime library at {libasan_so_path}")
            link_args.extend(
                [
                    "-fsanitize=address",
                    "--rtlib=compiler-rt",
                    "-shared-libasan",
                    str(libasan_so_path),
                    "-Wl,--whole-archive",
                    "-Wl," + str(libasan_preinit_path),
                    "-Wl,--no-whole-archive",
                ]
            )

            san_compile_flags.extend(["-fsanitize=address", "-shared-libasan", "-fsanitize-recover=address"])

            arch_asan_ignore_list = lib_clang_version_dir.joinpath("share", "asan_ignorelist.txt")
            if arch_asan_ignore_list.exists():
                san_compile_flags.append("-fsanitize-system-ignorelist=" + str(arch_asan_ignore_list))
            else:
                print(f"Warning: Couldn't find system ASAN ignorelist at `{arch_asan_ignore_list}`")
        elif sanitizer.is_tsan():
            libtsan_so_path = libclang_arch.joinpath("libclang_rt.tsan.so")
            builtins_path = libclang_arch.joinpath("libclang_rt.builtins.a")

            link_args.extend(
                ["-fsanitize=thread", "--rtlib=compiler-rt", "-shared-libsan", str(libtsan_so_path), str(builtins_path)]
            )
            san_compile_flags.append("-shared-libsan")

        link_args = [f"-Clink-arg={arg}" for arg in link_args]
        env["RUSTFLAGS"] += " " + " ".join(link_args)
        env["TARGET_CFLAGS"] += " " + " ".join(san_compile_flags)
        env["TARGET_CXXFLAGS"] += " " + " ".join(san_compile_flags)

    def binary_name(self) -> str:
        return "libservoshell.so"

    def needs_packaging(self) -> bool:
        return True

    def get_package_path(self, build_type_directory: str, flavor: Optional[str] = None) -> str:
        base_path = util.get_target_dir()
        base_path = path.join(base_path, "openharmony", self.triple())
        hap_name = "servoshell-default-signed.hap"
        if not flavor:
            flavor = "default"
        build_output_path = path.join("entry", "build", flavor, "outputs", "default")
        return path.join(base_path, build_type_directory, build_output_path, hap_name)

    def abi_string(self) -> str:
        abi_map = {"aarch64-unknown-linux-ohos": "arm64-v8a", "x86_64-unknown-linux-ohos": "x86_64"}
        return abi_map[self.triple()]


def is_android(target: BuildTarget) -> TypeGuard[AndroidTarget]:
    return isinstance(target, AndroidTarget)


def is_openharmony(target: BuildTarget) -> TypeGuard[OpenHarmonyTarget]:
    return isinstance(target, OpenHarmonyTarget)