import argparse
import os.path
from typing import List

from pydep.packages.cryptopp import CryptoppCMakePackage, CryptoppCMakeOptions
from pydep.packages.cxxopts import CxxoptsPackage, CxxoptsOptions
from pydep.packages.jsoncpp import JsonCppPackage, JsonCppOptions
from pydep.packages.pybind11 import Pybind11Package, Pybind11Options
from pydep.packages.spdlog import SpdlogPackage, SpdlogOptions
from pydep.tools.builder import PackageBuilder
from pydep.packages.cpphttplib import CppHttpLibPackage
from pydep.tools.cmakelists import *

THIRD_PARTY_ROOT_DIR = "./3rdparty"
BUILD_ROOT_DIR = f"{THIRD_PARTY_ROOT_DIR}/build"
PKGS_ROOT_DIR = f"{THIRD_PARTY_ROOT_DIR}/pkgs"
PYTHON_DIR = "./python"

ANDROID_ARCH_ABI = [
    "x86",
    "x86_64",
    "arm64-v8a",
    "armeabi-v7a",
]


def get_android_builder(cls, name, options=None) -> list:
    builders = []

    cmake = CMakeLists()
    cmake.set_generator(CMakeGenerator.MinGW_Makefiles).add_option([
        CMakeSystemName("Android"),
        CMakeToolChainFile(f"{NDK_ROOT}/build/cmake/android.toolchain.cmake"),
        CMakeDefine("ANDROID_PLATFORM", "21"),
    ])
    for abi in ANDROID_ARCH_ABI:
        android = cls()
        android.set_cmakelists(cmake) \
            .set_source_dir(f"{THIRD_PARTY_ROOT_DIR}/{name}") \
            .set_build_dir(f"{BUILD_ROOT_DIR}/{name}-android-{abi}") \
            .set_install_dir(f"{PKGS_ROOT_DIR}/{name}-android-{abi}") \
            .add_cmake_option(CMakeDefine("ANDROID_ABI", abi)) \
            .set_options(options)
        builders.append(android)
    return builders


def get_windows_builder(cls, name, options=None) -> list:
    builders = []
    windows = cls()
    windows.set_source_dir(f"{THIRD_PARTY_ROOT_DIR}/{name}") \
        .set_build_dir(f"{BUILD_ROOT_DIR}/{name}-windows") \
        .set_install_dir(f"{PKGS_ROOT_DIR}/{name}-windows") \
        .set_options(options)
    builders.append(windows)
    return builders


def get_linux_builder(cls, name, options=None) -> list:
    builders = []
    # TODO: linux platform package
    return builders


def get_all_platform_builder(cls, name, options=None) -> list:
    builders = []

    builders.extend(get_android_builder(cls, name, options))
    builders.extend(get_windows_builder(cls, name, options))
    builders.extend(get_linux_builder(cls, name, options))

    return builders


def get_cpp_httplib_builders() -> List[CppHttpLibPackage]:
    return get_all_platform_builder(CppHttpLibPackage, "cpp-httplib")


def get_jsoncpp_builders() -> List[JsonCppPackage]:
    return get_all_platform_builder(JsonCppPackage, "jsoncpp", JsonCppOptions(
        JSONCPP_WITH_TESTS=False,
        JSONCPP_WITH_POST_BUILD_UNITTEST=False,
        BUILD_SHARED_LIBS=False,
        BUILD_OBJECT_LIBS=False,
    ))


def get_spdlog_builders() -> List[SpdlogPackage]:
    return get_all_platform_builder(SpdlogPackage, "spdlog", SpdlogOptions(
        SPDLOG_BUILD_EXAMPLE=False,
    ))


def get_cxxopts_builders() -> List[CxxoptsPackage]:
    return get_all_platform_builder(CxxoptsPackage, "cxxopts", CxxoptsOptions(
        CXXOPTS_BUILD_EXAMPLES=False,
        CXXOPTS_BUILD_TESTS=False,
    ))


def get_cryptopp_builders() -> List[CryptoppCMakePackage]:
    builders = []
    options = CryptoppCMakeOptions(
        CRYPTOPP_BUILD_TESTING=False,
    )

    cmake = CMakeLists()
    cmake.set_generator(CMakeGenerator.MinGW_Makefiles).add_option([
        CMakeSystemName("Android"),
        CMakeToolChainFile(f"{NDK_ROOT}/build/cmake/android.toolchain.cmake"),
        CMakeDefine("ANDROID_PLATFORM", "21"),
    ])
    for abi in ANDROID_ARCH_ABI:
        android = CryptoppCMakePackage()
        android.set_cmakelists(cmake) \
            .set_source_dir(f"{THIRD_PARTY_ROOT_DIR}/cryptopp", f"{THIRD_PARTY_ROOT_DIR}/cryptopp-cmake") \
            .set_build_dir(f"{BUILD_ROOT_DIR}/cryptopp-android-{abi}") \
            .set_install_dir(f"{PKGS_ROOT_DIR}/cryptopp-android-{abi}") \
            .add_cmake_option(CMakeDefine("ANDROID_ABI", abi)) \
            .set_options(options)
        builders.append(android)

    windows = CryptoppCMakePackage()
    windows.set_source_dir(f"{THIRD_PARTY_ROOT_DIR}/cryptopp", f"{THIRD_PARTY_ROOT_DIR}/cryptopp-cmake") \
        .set_build_dir(f"{BUILD_ROOT_DIR}/cryptopp-windows") \
        .set_install_dir(f"{PKGS_ROOT_DIR}/cryptopp-windows") \
        .set_options(options)
    builders.append(windows)

    # TODO: cryptopp on linux

    return builders


def get_pybind11_builders() -> List[Pybind11Package]:
    builders = []
    builders.extend(get_windows_builder(Pybind11Package, "pybind11", Pybind11Options(
        PYBIND11_TEST=False,
        PYBIND11_NOPYTHON=True,
    )))

    # TODO: pybind11 on linux and macos

    return builders


NDK_ROOT = "E:/ndk"


def main():
    parser = argparse.ArgumentParser()
    parser.add_argument("--ndk", type=str, help="ndk install dir")
    args = parser.parse_args()

    global NDK_ROOT
    NDK_ROOT = args.ndk

    if not os.path.exists(BUILD_ROOT_DIR):
        os.makedirs(BUILD_ROOT_DIR)
    if not os.path.exists(PKGS_ROOT_DIR):
        os.makedirs(PKGS_ROOT_DIR)

    pkg_builders: List[PackageBuilder] = []

    pkg_builders.extend(get_cpp_httplib_builders())
    pkg_builders.extend(get_jsoncpp_builders())
    pkg_builders.extend(get_spdlog_builders())
    pkg_builders.extend(get_cxxopts_builders())
    pkg_builders.extend(get_cryptopp_builders())
    pkg_builders.extend(get_pybind11_builders())

    for p in pkg_builders:
        p.configure()
        p.build()
        p.install()


if __name__ == "__main__":
    main()