from .base import ConfigInfo, MixedMixin

from kiwixbuild.utils import pj
from kiwixbuild._global import get_target_step


class MuslConfigInfo(ConfigInfo):
    compatible_hosts = ["fedora", "debian"]

    def get_cross_config(self):
        return {
            "binaries": self.binaries,
            "exe_wrapper_def": "",
            "root_path": self.root_path,
            "extra_libs": [],
            "extra_cflags": [
                "-I{}".format(include_dir) for include_dir in self.get_include_dirs()
            ],
            "host_machine": {
                "system": "linux",
                "lsystem": "linux",
                "cpu_family": self.cpu_family,
                "cpu": self.cpu,
                "endian": "little",
                "abi": "",
            },
        }

    @property
    def toolchain(self):
        return get_target_step(self.build, "neutral")

    @property
    def root_path(self):
        return self.toolchain.build_path

    @property
    def binaries(self):
        binaries = (
            (k, "{}-{}".format(self.arch_full, v))
            for k, v in (
                ("CC", "gcc"),
                ("CXX", "g++"),
                ("AR", "ar"),
                ("STRIP", "strip"),
                ("WINDRES", "windres"),
                ("RANLIB", "ranlib"),
                ("LD", "ld"),
                ("LDSHARED", "g++ -shared"),
            )
        )
        binaries = {k: pj(self.root_path, "bin", v) for k, v in binaries}
        binaries["PKGCONFIG"] = "pkg-config"
        return binaries

    @property
    def exe_wrapper_def(self):
        try:
            which(self.qemu)
        except subprocess.CalledProcessError:
            return ""
        except AttributeError:
            return ""
        else:
            return f"exe_wrapper = '{self.qemu}'"

    @property
    def configure_options(self):
        return [f"--host={self.arch_full}"]

    def get_bin_dir(self):
        return [pj(self.root_path, "bin")]

    def get_env(self):
        env = super().get_env()
        env["LD_LIBRARY_PATH"][0:0] = [
            pj(self.root_path, self.arch_full, "lib64"),
            pj(self.root_path, "lib"),
        ]
        env["PKG_CONFIG_LIBDIR"] = pj(self.root_path, "lib", "pkgconfig")
        env["QEMU_LD_PREFIX"] = pj(self.root_path, self.arch_full, "libc")
        env["QEMU_SET_ENV"] = "LD_LIBRARY_PATH={}".format(
            ":".join(
                [pj(self.root_path, self.arch_full, "lib"), str(env["LD_LIBRARY_PATH"])]
            )
        )
        return env

    def set_comp_flags(self, env):
        super().set_comp_flags(env)
        env["LD_LIBRARY_PATH"].insert(0, pj(self.root_path, self.arch_full, "lib"))
        env["CFLAGS"] = (
            " -fPIC -Wp,-D_FORTIFY_SOURCE=2 -fexceptions --param=ssp-buffer-size=4 "
            + env["CFLAGS"]
        )
        env["CXXFLAGS"] = (
            " -fPIC -Wp,-D_FORTIFY_SOURCE=2 -fexceptions --param=ssp-buffer-size=4 "
            + env["CXXFLAGS"]
        )

    def set_compiler(self, env):
        for k, v in self.binaries.items():
            env[k] = v

    def finalize_setup(self):
        super().finalize_setup()
        self.buildEnv.cmake_crossfile = self._gen_crossfile("cmake_cross_file.txt")
        self.buildEnv.meson_crossfile = self._gen_crossfile("meson_cross_file.txt")


class Aarch64MuslConfigInfo(MuslConfigInfo):
    build = "aarch64_musl"
    arch_full = "aarch64-linux-musl"
    toolchain_names = ["aarch64_musl"]
    libdir = "lib/aarch64-linux-musl"
    cpu_family = "arm"
    cpu = "armhf"
    qemu = "qemu-arm"


class Aarch64MuslDyn(Aarch64MuslConfigInfo):
    name = "aarch64_musl_dyn"
    static = False


class Aarch64MuslStatic(Aarch64MuslConfigInfo):
    name = "aarch64_musl_static"
    static = True


class Aarch64MuslMixed(MixedMixin("aarch64_musl_static"), Aarch64MuslConfigInfo):
    name = "aarch64_musl_mixed"
    static = False


class X86_64MuslConfigInfo(MuslConfigInfo):
    build = "x86-64_musl"
    arch_full = "x86_64-linux-musl"
    toolchain_names = ["x86-64_musl"]
    libdir = "lib/x86_64-linux-musl"
    cpu_family = "x86_64"
    cpu = "x86_64"


class X86_64MuslDyn(X86_64MuslConfigInfo):
    name = "x86-64_musl_dyn"
    static = False


class X86_64MuslStatic(X86_64MuslConfigInfo):
    name = "x86-64_musl_static"
    static = True


class x86_64MuslMixed(MixedMixin("x86-64_musl_static"), X86_64MuslConfigInfo):
    name = "x86-64_musl_mixed"
    static = False