# Copyright (c) 2017 CEF Python, see the Authors file.
# All rights reserved. Licensed under BSD 3-clause license.
# Project website: https://github.com/cztomczak/cefpython

"""Called by build.py internally. Builds C++ projects using
distutils/setuptools compilers. This tool is executed by build.py
on Windows only currently. Output directories are in
build/build_cefpython/.

Usage:
 build_cpp_projects.py [--force]

TODO: Linux/Mac support, see makefiles, add include dirs using
 compiler.add_include_dir, compiler/linker flags,
 refactor macros.
"""

# import setuptools so that distutils msvc compiler is patched
# noinspection PyUnresolvedReferences
import setuptools
from distutils.ccompiler import new_compiler
from common import *
import shutil
from pprint import pprint

# Macros
MACROS = [
 "WIN32", "_WIN32", "_WINDOWS",
 # Windows 7+ minimum supported
 ("NTDDI_VERSION", "0x06010000"),
 ("WINVER", "0x0601"),
 ("_WIN32_WINNT", "0x0601"),
 "NDEBUG", "_NDEBUG",
 "_CRT_SECURE_NO_WARNINGS",
]
cefpython_app_MACROS = MACROS + [
 "BROWSER_PROCESS",
]
subprocess_MACROS = MACROS + [
 "RENDERER_PROCESS",
 "UNICODE", "_UNICODE",
 "NOMINMAX",
 "WIN32_LEAN_AND_MEAN",
 ("_HAS_EXCEPTIONS", "0"),
]

# Compiler args
COMPILER_ARGS = [
 "/EHsc",
]
subprocess_COMPILER_ARGS = [
 "/MT",
]

# Linker args
subprocess_LINKER_ARGS = [
 "/MANIFEST:NO",
 "/LARGEADDRESSAWARE",
]

# Command line args
FORCE_FLAG = False


def main():
 command_line_args()
 clean_build_directories_if_forced()
 print_compiler_options()
 build_cefpython_app_library()
 build_library(lib_name="client_handler",
 macros=MACROS,
 sources_dir=CLIENT_HANDLER_DIR,
 output_dir=BUILD_CLIENT_HANDLER)
 build_library(lib_name="cpp_utils",
 macros=MACROS,
 sources_dir=CPP_UTILS_DIR,
 output_dir=BUILD_CPP_UTILS)
 build_subprocess_executable()
 print("[build_cpp_projects.py] Done building C++ projects")


def command_line_args():
 global FORCE_FLAG
 if "--force" in sys.argv:
 FORCE_FLAG = True


def clean_build_directories_if_forced():
 build_dirs = [BUILD_CEFPYTHON_APP, BUILD_CLIENT_HANDLER, BUILD_CPP_UTILS,
 BUILD_SUBPROCESS]
 if FORCE_FLAG:
 print("[build_cpp_projects.py] Clean C++ projects build directories")
 for bdir in build_dirs:
 if os.path.isdir(bdir):
 shutil.rmtree(bdir)


def print_compiler_options():
 compiler = get_compiler()
 print("build_cpp_projects.py] Shared macros:")
 pprint(MACROS, indent=3, width=160)
 print("[build_cpp_projects.py] cefpython_app library macros:")
 pprint(cefpython_app_MACROS, indent=3, width=160)
 print("[build_cpp_projects.py] subprocess executable macros:")
 pprint(subprocess_MACROS, indent=3, width=160)
 print("[build_cpp_projects.py] Compiler options:")
 pprint(vars(compiler), indent=3, width=160)


def get_compiler(static=False):
 # NOTES:
 # - VS2008 and VS2010 are both using distutils/msvc9compiler.py
 compiler = new_compiler()
 # Must initialize so that "compile_options" and others are available
 compiler.initialize()
 if static:
 compiler.compile_options.remove("/MD")
 # Overwrite function that adds /MANIFESTFILE, as for subprocess
 # manifest is disabled. Otherwise warning LNK4075 is generated.
 if hasattr(compiler, "manifest_setup_ldargs"):
 compiler.manifest_setup_ldargs = lambda *_: None
 return compiler


def build_library(lib_name, macros, output_dir,
 sources=None, sources_dir=None):
 assert bool(sources_dir) ^ bool(sources) # xor
 print("[build_cpp_projects.py] Build library: {lib_name}"
 .format(lib_name=lib_name))
 compiler = get_compiler()
 if not os.path.exists(output_dir):
 os.makedirs(output_dir)
 if sources_dir:
 assert not sources
 sources = get_sources(sources_dir)
 (changed, objects) = smart_compile(compiler,
 macros=macros,
 extra_args=COMPILER_ARGS,
 sources=sources,
 output_dir=output_dir)
 lib_path = os.path.join(output_dir, lib_name + LIB_EXT)
 if changed or not os.path.exists(lib_path):
 compiler.create_static_lib(objects, lib_name,
 output_dir=output_dir)
 print("[build_cpp_projects.py] Created library: {lib_name}"
 .format(lib_name=lib_name))
 else:
 print("[build_cpp_projects.py] Library is up-to-date: {lib_name}"
 .format(lib_name=lib_name))


def build_cefpython_app_library():
 sources = get_sources(SUBPROCESS_DIR, exclude_names=["main.cpp"])
 main_message_loop_dir = os.path.join(SUBPROCESS_DIR, "main_message_loop")
 sources.extend(get_sources(main_message_loop_dir))
 build_library(lib_name="cefpython_app",
 macros=cefpython_app_MACROS,
 sources=sources,
 output_dir=BUILD_CEFPYTHON_APP)


def build_subprocess_executable():
 print("[buil_cpp_projects.py] Build executable: subprocess")
 compiler = get_compiler(static=True)
 sources = get_sources(SUBPROCESS_DIR,
 exclude_names=["print_handler_gtk.cpp"])
 (changed, objects) = smart_compile(compiler,
 macros=subprocess_MACROS,
 extra_args=subprocess_COMPILER_ARGS,
 sources=sources,
 output_dir=BUILD_SUBPROCESS)
 executable_path = os.path.join(BUILD_SUBPROCESS,
 "subprocess" + EXECUTABLE_EXT)
 if changed or not os.path.exists(executable_path):
 lib_dir = os.path.join(CEF_BINARIES_LIBRARIES, "lib")
 lib_dir_vs = os.path.join(lib_dir,
 get_msvs_for_python(vs_prefix=True))
 compiler.link_executable(objects,
 output_progname="subprocess",
 output_dir=BUILD_SUBPROCESS,
 libraries=["libcef",
 "libcef_dll_wrapper_MT"],
 library_dirs=[lib_dir, lib_dir_vs],
 # TODO linker flags for Linux/Mac
 extra_preargs=None,
 extra_postargs=subprocess_LINKER_ARGS)
 else:
 print("[build_cpp_projects.py] Executable is up-to-date: subprocess")


def get_sources(sources_dir, exclude_names=None):
 if not exclude_names:
 exclude_names = list()
 sources = glob.glob(os.path.join(sources_dir, "*.cpp"))
 if MAC:
 sources.extend(glob.glob(os.path.join(sources_dir, "*.mm")))
 ret = list()
 for source_file in sources:
 filename = os.path.basename(source_file)
 if "_win.cpp" in filename and not WINDOWS:
 continue
 if "_linux.cpp" in filename and not LINUX:
 continue
 if "x11" in filename and not LINUX:
 continue
 if "gtk" in filename and not LINUX:
 continue
 if "_mac.cpp" in filename and not MAC:
 continue
 exclude = False
 for name in exclude_names:
 if name in filename:
 exclude = True
 break
 if not exclude:
 ret.append(source_file)
 return ret


def smart_compile(compiler, macros, extra_args, sources, output_dir):
 """Smart compile will only recompile files that need recompiling."""
 if not os.path.exists(output_dir):
 os.makedirs(output_dir)
 any_changed = False
 objects = list()
 for source_file in sources:
 header_file = source_file.replace(".cpp", ".h")
 header_file = header_file.replace(".mm", ".h")
 assert header_file.endswith(".h")
 if not os.path.isfile(header_file):
 header_file = None
 obj_file = os.path.join(output_dir, os.path.basename(source_file))
 obj_file = obj_file.replace(".cpp", OBJ_EXT)
 obj_file = obj_file.replace(".mm", OBJ_EXT)
 assert obj_file.endswith(OBJ_EXT)
 if os.path.exists(obj_file):
 # Recompile source file if its time is newer than obj file,
 # Also check its header file time. Also check times of any
 # possible includes: cefpython_fixed.h, src/common/ files.
 obj_time = os.path.getmtime(obj_file)
 source_time = os.path.getmtime(source_file)
 header_time = os.path.getmtime(header_file) if header_file else 0
 cefpython_h_fixed_time = os.path.getmtime(
 CEFPYTHON_API_HFILE_FIXED)
 common_files_time = get_directory_mtime(os.path.join(SRC_DIR,
 "common"))
 changed = ((source_time > obj_time)
 or (header_time > obj_time)
 or (cefpython_h_fixed_time > obj_time)
 or (common_files_time > obj_time))
 else:
 changed = True
 if changed:
 any_changed = True
 else:
 objects.append(obj_file)
 if any_changed:
 # If any has changed must recompile all given sources (for a library
 # or executable). This is because we don't know which sources include
 # which header files so must recompile everything.
 objects = list()
 # Compile each source file separately so that when compiling
 # source files from different directories, object files are
 # all put in the same output_directory. Otherwise distutils
 # will create lots of subdirs in output_directory.
 macros = macros_as_tuples(macros)
 common_dir = os.path.join(SRC_DIR, "common")
 original_dir = os.getcwd()
 for source_file in sources:
 source_dir = os.path.dirname(source_file)
 os.chdir(source_dir)
 source_basename = os.path.basename(source_file)
 oneobj = compiler.compile([source_basename],
 output_dir=output_dir,
 macros=macros,
 # TODO include dirs for Linux/Mac
 include_dirs=[SRC_DIR,
 common_dir,
 get_python_include_path()],
 # TODO compiler flags for Linux/Mac
 extra_preargs=None,
 extra_postargs=extra_args)
 assert len(oneobj) == 1
 objects.append(os.path.join(source_dir, oneobj[0]))
 os.chdir(original_dir)
 assert len(objects)
 return any_changed, objects


def macros_as_tuples(macros):
 """Return all macros as tuples. Required by distutils.ccompiler."""
 ret_macros = list()
 for macro in macros:
 if isinstance(macro, str):
 ret_macros.append((macro, ""))
 else:
 assert isinstance(macro, tuple)
 ret_macros.append(macro)
 return ret_macros


def get_directory_mtime(directory):
 # For example check src/common/ directory for newest modification time
 assert os.path.isdir(directory)
 files = glob.glob(os.path.join(directory, "*"))
 ret_mtime = 0
 for header_file in files:
 mtime = os.path.getmtime(header_file)
 if mtime > ret_mtime:
 ret_mtime = mtime
 assert ret_mtime
 return ret_mtime


if __name__ == "__main__":
 main()