#!/usr/bin/python
###############################################################################
#                                                                             #
# This file is part of IfcOpenShell.                                          #
#                                                                             #
# IfcOpenShell is free software: you can redistribute it and/or modify        #
# it under the terms of the Lesser GNU General Public License as published by #
# the Free Software Foundation, either version 3.0 of the License, or         #
# (at your option) any later version.                                         #
#                                                                             #
# IfcOpenShell is distributed in the hope that it will be useful,             #
# but WITHOUT ANY WARRANTY; without even the implied warranty of              #
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the                #
# Lesser GNU General Public License for more details.                         #
#                                                                             #
# You should have received a copy of the Lesser GNU General Public License    #
# along with this program. If not, see <http://www.gnu.org/licenses/>.        #
#                                                                             #
###############################################################################

###############################################################################
#                                                                             #
# This script builds IfcOpenShell and its dependencies                        #
#                                                                             #
# Prerequisites for this script to function correctly:                        #
#     * git * bzip2 * tar * c(++) compilers * yacc * autoconf                 #
#                                                                             #
#   if building with USE_OCCT additionally:                                   #
#     * freetype * glx.h                                                      #
#                                                                             #
#     on debian 7.8 these can be obtained with:                               #
#          $ apt-get install git gcc g++ autoconf bison bzip2                 #
#            libfreetype6-dev mesa-common-dev                                 #
#                                                                             #
#     on ubuntu 14.04:                                                        #
#          $ apt-get install git gcc g++ autoconf bison make                  #
#            libfreetype6-dev mesa-common-dev                                 #
#                                                                             #
#     on OS X El Capitan with homebrew:                                       #
#          $ brew install git bison autoconf automake freetype                #
#                                                                             #
###############################################################################

import logging
import os
import sys
import subprocess as sp
import shutil
import time
import tarfile
import multiprocessing
import urllib

logger = logging.getLogger(__name__)
logger.setLevel(logging.INFO)
ch = logging.StreamHandler()
ch.setLevel(logging.INFO)
logger.addHandler(ch)

PROJECT_NAME="IfcOpenShell"
OCE_VERSION="0.18"
# OCCT_VERSION="7.1.0"
# OCCT_HASH="89aebde"
PYTHON_VERSIONS=["2.7.12", "3.2.6", "3.3.6", "3.4.6", "3.5.3", "3.6.2"]
# OCCT_VERSION="7.2.0"
# OCCT_HASH="88af392"
OCCT_VERSION="7.3.0"
BOOST_VERSION="1.59.0"
PCRE_VERSION="8.39"
LIBXML_VERSION="2.9.3"
CMAKE_VERSION="3.4.1"
ICU_VERSION="56.1"
SWIG_VERSION="3.0.12"

# binaries
cp="cp"
bash="bash"
uname="uname"
git="git"
bunzip2="bunzip2"
tar="tar"
cc="cc"
cplusplus="c++"
autoconf="autoconf"
automake="automake"
yacc="yacc"
make="make"
date = "date"
curl="curl"
wget="wget"
strip="strip"

# Helper function for coloured printing

NO_COLOR="\033[0m" # <ref>http://stackoverflow.com/questions/5947742/how-to-change-the-output-color-of-echo-in-linux</ref>
BLACK_ON_WHITE="\033[0;30;107m"
RED="\033[31m"
GREEN="\033[32m"
YELLOW="\033[33m"
MAGENTA="\033[35m"

def cecho(message, color=NO_COLOR):
    """Logs message `message` in color `color`."""
    logger.info("%s%s\033[0m" % (color, message))

def fullpath(arg):
	return os.path.realpath(os.path.dirname(sys.argv[1]))

def which(cmd):
    for path in os.environ["PATH"].split(":"):
        if os.path.exists(path) and cmd in os.listdir(path):
            return cmd
    return None

def get_os():
    ret_value = sp.check_output([uname, "-s"]).strip()
    return ret_value

# Set defaults for missing empty environment variables

USE_OCCT = os.environ.get("USE_OCCT", "true").lower() == "true"

TOOLSET = None
if get_os() == "Darwin":
    # C++11 features used in OCCT 7+ need a more recent stdlib
    TOOLSET = "10.9" if USE_OCCT else "10.6"
   
try:
    IFCOS_NUM_BUILD_PROCS = os.environ["IFCOS_NUM_BUILD_PROCS"]
except KeyError:
    IFCOS_NUM_BUILD_PROCS=multiprocessing.cpu_count() + 1
    os.environ["IFCOS_NUM_BUILD_PROCS"]=str(IFCOS_NUM_BUILD_PROCS)

try:
    TARGET_ARCH = os.environ["TARGET_ARCH"]
    del os.environ["TARGET_ARCH"]
except KeyError:
    TARGET_ARCH = sp.check_output([uname, "-m"]).strip()

CMAKE_DIR=os.path.realpath(os.path.join("..", "cmake"))

try:
    DEPS_DIR = os.environ["DEPS_DIR"]
except KeyError:
    path = ["..", "build", sp.check_output(uname).strip(), TARGET_ARCH]
    if TOOLSET:
        path.append(TOOLSET)
    DEPS_DIR = os.path.realpath(os.path.join(*path))
    os.environ["DEPS_DIR"] = DEPS_DIR
    if not os.path.exists(DEPS_DIR):
        os.makedirs(DEPS_DIR)

try:
    BUILD_CFG=os.environ["BUILD_CFG"]
except KeyError:
    BUILD_CFG="RelWithDebInfo"
    os.environ["BUILD_CFG"]=BUILD_CFG


# Print build configuration information

cecho ("""This script fetches and builds %s and its dependencies
""" % (PROJECT_NAME,), BLACK_ON_WHITE)
cecho("""Script configuration:

""", GREEN)
cecho("""* Target Architecture    = %s""" % (TARGET_ARCH,), MAGENTA)
cecho(" - Whether 32-bit (i686) or 64-bit (x86_64) will be built.")
cecho("""* USE_OCCT               = %r""" % (USE_OCCT,), MAGENTA)
if USE_OCCT:
    cecho(" - Compiling against official Open Cascade")
else:
    cecho(" - Compiling against Open Cascade Community Edition")
cecho("* Dependency Directory   = %s" % (DEPS_DIR,), MAGENTA)
cecho(" - The directory where %s dependencies are installed." % (PROJECT_NAME,))
cecho("* Build Config Type      = %s" % (BUILD_CFG,), MAGENTA)
cecho(""" - The used build configuration type for the dependencies.
   Defaults to RelWithDebInfo if not specified.""")

if BUILD_CFG == "MinSizeRel":
    cecho("     WARNING: MinSizeRel build can suffer from a significant performance loss.", RED)

cecho("* IFCOS_NUM_BUILD_PROCS  = %s" % (IFCOS_NUM_BUILD_PROCS,), MAGENTA)
cecho(""" - How many compiler processes may be run in parallel.
""")

# Check that required tools are in PATH

for cmd in [git, bunzip2, tar, cc, cplusplus, autoconf, automake, yacc, make, "patch"]:
    if which(cmd) is None:
        raise ValueError("Required tool '%s' not installed or not added to PATH" % (cmd,))

# identifiers for the download tool (could be less memory consuming as ints, but are more verbose as strings)
download_tool_curl="curl"
download_tool_wget="wget"
download_tool_git = "git"

if which(wget) != None:
    download_tool_default = download_tool_wget
elif which(curl) != None:
    download_tool_default = download_tool_curl
else:
    raise ValueError("No download application found, tried: curl, wget")

CURL = ["curl", "-sL"]
WGET= ["wget", "-q", "--no-check-certificate"]

# Create log directory and file

log_dir = os.path.join(DEPS_DIR, "logs")
if not os.path.exists(log_dir):
    os.makedirs(log_dir)
LOG_FILE="%s.log" % (os.path.join(log_dir, sp.check_output([date, "+%Y%m%d"]).strip()),)
if not os.path.exists(LOG_FILE):
    open(LOG_FILE, "w").close()
logger.info("using command log file '%s'" % (LOG_FILE,))

def __check_call__(cmds, cwd=None):
    logger.debug("running command %r in directory %r" % (" ".join(cmds), cwd))
    log_file_handle = open(LOG_FILE, "a")
    proc = sp.Popen(cmds, cwd=cwd, stdout=log_file_handle, stderr=sp.PIPE)
    _, stderr = proc.communicate()
    log_file_handle.write(stderr)
    log_file_handle.close()

    if proc.returncode != 0:
        print "-" * 70
        print stderr
        print "-" * 70
        raise Exception("Command `%s` returned exit code %d" % (" ".join(cmds), proc.returncode))

def __check_output__(cmds, cwd=None):
    """Wraps `subprocess.check_output` and logs the command being executed,
    sets up logging `stderr` to `LOG_FILE` (in append mode) and strips the
    return value because it's unlikely that the newline at the end of output is
    useful and it often causes errors"""
    logger.debug("running command '%s' in directory %r" % (" ".join(cmds), cwd))
    log_file_handle = open(LOG_FILE, "a")
    ret_value = sp.check_output(cmds, cwd=cwd, stderr=log_file_handle).strip()
    logger.debug("command returned %r" % ret_value)
    log_file_handle.close()
    return ret_value

BOOST_VERSION_UNDERSCORE=BOOST_VERSION.replace(".", "_")
ICU_VERSION_UNDERSCORE=ICU_VERSION.replace(".", "_")
CMAKE_VERSION_2=CMAKE_VERSION[:CMAKE_VERSION.rindex('.')]

OCE_LOCATION="https://github.com/tpaviot/oce/archive/OCE-%s.tar.gz" % (OCE_VERSION,)
BOOST_LOCATION="http://downloads.sourceforge.net/project/boost/boost/%s/boost_%s.tar.bz2" % (BOOST_VERSION, BOOST_VERSION_UNDERSCORE)
OPENCOLLADA_LOCATION="https://github.com/KhronosGroup/OpenCOLLADA.git"
#OPENCOLLADA_COMMIT="f99d59e73e565a41715eaebc00c7664e1ee5e628"
OPENCOLLADA_COMMIT="v1.6.63"

# Helper functions

def run_autoconf(arg1, configure_args, cwd):
    configure_path = os.path.realpath(os.path.join(cwd, "..", "configure"))
    if not os.path.exists(configure_path):
        __check_call__([bash, "./autogen.sh"], cwd=os.path.realpath(os.path.join(cwd, ".."))) # only run autogen.sh in the directory it is located and use cwd to achieve that in order to not mess up things
    # Using `sh` over `bash` fixes issues with building swig 
    __check_call__(["/bin/sh", "../configure"]+configure_args+["--prefix=%s" % (os.path.realpath("%s/install/%s" % (DEPS_DIR, arg1)),)], cwd=cwd)

def run_cmake(arg1, cmake_args, cmake_dir=None, cwd=None):
    if cmake_dir is None:
        P=".."
    else:
        P=cmake_dir
    cmake_path= os.path.join(DEPS_DIR, "install", "cmake-%s" % (CMAKE_VERSION,), "bin", "cmake")
    __check_call__([cmake_path, P]+cmake_args+["-DCMAKE_BUILD_TYPE=%s" % (BUILD_CFG,)], cwd=cwd)

def run_icu(arg1, icu_args, cwd):
    PLATFORM=get_os()
    if PLATFORM == "Darwin":
        PLATFORM="MacOSX"
    __check_call__([bash, "../source/runConfigureICU", PLATFORM]+icu_args+["--prefix=%s/install/%s" % (DEPS_DIR, arg1)], cwd=cwd)

def git_clone(clone_url, target_dir, revision=None):
    """Lazily clones the `git` repository denoted by `clone_url` into
    `target_dir`, i.e. skips cloning if `target_dir` exists (naively assumes
    that a working clone exists there) and optionally checks out a revision
    `revision` after cloning or in the existing clone if `revision` is not
    `None`."""
    if not os.path.exists(target_dir):
        logger.info("cloning '%s' into '%s'" % (clone_url, target_dir))
        __check_call__([git, "clone", clone_url, target_dir])
    else:
        logger.info("directory '%s' exists, skipping cloning" % (target_dir,))
    if revision != None:
        __check_call__([git, "checkout", revision], cwd=target_dir)

def build_dependency(name, mode, build_tool_args, download_url, download_name, download_tool=download_tool_default, revision=None, patch=None, additional_files={}, no_append_name=False):
    """Handles building of dependencies with different tools (which are
    distinguished with the `mode` argument. `build_tool_args` is expected to be
    a list which is necessary in order to not mess up quoting of compiler and
    linker flags."""
    check_dir = os.path.join(DEPS_DIR, "install", name)
    if os.path.exists(check_dir):
        logger.info( "Found existing %s, skipping" % (name,))
        return
    build_dir = os.path.join(DEPS_DIR, "build")
    if not os.path.exists(build_dir):
        os.makedirs(build_dir)
    
    logger.info("\rFetching %s...   " % (name,))
    
    if download_tool == download_tool_curl or download_tool == download_tool_wget:
        if no_append_name:
            url = download_url
        else:
            url = os.path.join(download_url, download_name)
    
    if download_tool == download_tool_curl:
        download_path = os.path.join(build_dir, download_name)
        if not os.path.exists(download_path):
            __check_call__(CURL + ["-o", download_name, url], cwd=build_dir)
        else:
            logger.info("Download '%s' already exists, assuming it's an undamaged download and that it has been extracted if possible, skipping" % (download_path,))
    elif download_tool == download_tool_wget:
        download_path = os.path.join(build_dir, download_name)
        if not os.path.exists(download_path):
            __check_call__(WGET + ["-O", download_name, url], cwd=build_dir)
        else:
            logger.info("Download '%s' already exists, assuming it's an undamaged download and that it has been extracted if possible, skipping" % (download_path,))
    elif download_tool == download_tool_git:
        git_clone(download_url, target_dir=os.path.join(build_dir, download_name), revision=revision)
    else:
        raise ValueError("download tool '%s' is not supported" % (download_tool,))
    download_dir = os.path.join(build_dir, download_name)
    
    if os.path.isdir(download_dir):
        extract_dir_name=download_name
        extract_dir = os.path.join(build_dir, extract_dir_name)
    else:
        download_tarfile_path = os.path.join(build_dir, download_name)
        if download_name.endswith(".tar.gz") or download_name.endswith(".tgz"):
            compr = "gz"
        elif download_name.endswith(".tar.bz2"):
            compr = "bz2"
        else:
            raise RuntimeError("fix source for new download type")
        download_tarfile = tarfile.open(name=download_tarfile_path, mode="r:%s" % (compr,))
        extract_dir_name= os.path.commonprefix(download_tarfile.getnames()) # tarfile seriously doesn't have a function to retrieve the root directory more easily
        #__check_output__([tar, "--exclude=\"*/*\"", "-tf", download_name], cwd=build_dir).strip() no longer works
        if extract_dir_name is None:
            extract_dir_name= __check_output__([bash, "-c", "tar -tf %s 2> /dev/null | head -n 1 | cut -f1 -d /" % (download_name,)], cwd=build_dir)
        extract_dir = os.path.join(build_dir, extract_dir_name)
        if not os.path.exists(extract_dir):
            __check_call__([tar, "-xf", download_name], cwd=build_dir)
    
    for path, url in additional_files.items():
        if not os.path.exists(path):
            urllib.urlretrieve(url, os.path.join(extract_dir, path))
            
    if patch is not None:
        patch_abs = os.path.abspath(os.path.join(os.path.dirname(__file__), patch))
        if os.path.exists(patch_abs):
            try: __check_call__(["patch", "-p1", "--batch", "--forward", "-i", patch_abs], cwd=extract_dir)
            except Exception as e:
                # Assert that the patch has already been applied
                __check_call__(["patch", "-p1", "--batch", "--reverse", "--dry-run", "-i", patch_abs], cwd=extract_dir)
            
    if mode != "bjam":
        extract_build_dir = os.path.join(extract_dir, "build")
        if os.path.exists(extract_build_dir):
            shutil.rmtree(extract_build_dir)
        os.makedirs(extract_build_dir)

        logger.info("\rConfiguring %s..." % (name,))
        if mode == "icu":
            run_icu(name, build_tool_args, cwd=extract_build_dir)
        elif mode == "autoconf":
            run_autoconf(name, build_tool_args, cwd=extract_build_dir)
        elif mode == "cmake":
            run_cmake(name, build_tool_args, cwd=extract_build_dir)
        else:
            raise ValueError()
        logger.info("\rBuilding %s...   " % (name,))
        __check_call__([make, "-j%s" % (IFCOS_NUM_BUILD_PROCS,)], cwd=extract_build_dir)
        logger.info( "\rInstalling %s... " % (name,))
        __check_call__([make, "install"], cwd=extract_build_dir)
        logger.info( "\rInstalled %s     \n" % (name,))
    else:
        logger.info( "\rConfiguring %s..." % (name,))
        __check_call__([bash, "./bootstrap.sh"], cwd=extract_dir)
        logger.info("\rBuilding %s...   " % (name,))
        __check_call__(["./b2", "-j%s" % (IFCOS_NUM_BUILD_PROCS,)]+build_tool_args, cwd=extract_dir)
        logger.info("\rInstalling %s... " % (name,))
        shutil.copytree(os.path.join(extract_dir, "boost"), os.path.join(DEPS_DIR, "install", "boost-%s" % BOOST_VERSION, "boost"))
        logger.info("\rInstalled %s     \n" % (name,))

cecho("Collecting dependencies:", GREEN)

# Set compiler flags for 32bit builds on 64bit system
# TODO: This is untested

ADDITIONAL_ARGS=[]
BOOST_ADDRESS_MODEL=[]
if TARGET_ARCH == "i686" and __check_output__([uname, "-m"]).strip() == "x86_64":
    ADDITIONAL_ARGS=["-m32", "-arch i386"]
    BOOST_ADDRESS_MODEL=["architecture=x86", "address-model=32"]

if get_os() == "Darwin":
    ADDITIONAL_ARGS=["-mmacosx-version-min=%s" % TOOLSET]+ADDITIONAL_ARGS

# If the linker supports GC sections, set it up to reduce binary file size
# -fPIC is required for the shared libraries to work

try:
    CXXFLAGS=os.environ["CXXFLAGS"]
except KeyError:
    CXXFLAGS=""
try:
    CFLAGS=os.environ["CFLAGS"]
except KeyError:
    CFLAGS=""
try:
    LDFLAGS=os.environ["LDFLAGS"]
except KeyError:
    LDFLAGS=""

if sp.call([bash, "-c", "ld --gc-sections 2>&1 | grep -- --gc-sections &> /dev/null"]) != 0:
    CXXFLAGS_MINIMAL="%s -fPIC %s" % (CXXFLAGS, str.join(" ", ADDITIONAL_ARGS))
    os.environ["CXXFLAGS_MINIMAL"]=CXXFLAGS_MINIMAL
    CFLAGS_MINIMAL="%s -fPIC %s" % (CFLAGS, str.join(" ", ADDITIONAL_ARGS))
    os.environ["CFLAGS_MINIMAL"]=CFLAGS_MINIMAL
    CXXFLAGS="%s -fPIC -fdata-sections -ffunction-sections -fvisibility=hidden -fvisibility-inlines-hidden %s" % (CXXFLAGS, str.join(" ", ADDITIONAL_ARGS))
    os.environ["CXXFLAGS"]=CXXFLAGS
    CFLAGS="%s   -fPIC -fdata-sections -ffunction-sections -fvisibility=hidden %s"% (CFLAGS, str.join(" ", ADDITIONAL_ARGS))
    os.environ["CFLAGS"]=CFLAGS
    LDFLAGS="%s  -Wl,--gc-sections %s" % (LDFLAGS, str.join(" ", ADDITIONAL_ARGS))
    os.environ["LDFLAGS"]=LDFLAGS
else:
    CXXFLAGS_MINIMAL="%s -fPIC %s" % (CXXFLAGS, str.join(" ", ADDITIONAL_ARGS))
    os.environ["CXXFLAGS_MINIMAL"]=CXXFLAGS_MINIMAL
    CFLAGS_MINIMAL="%s   -fPIC %s" % (CFLAGS, str.join(" ", ADDITIONAL_ARGS))
    os.environ["CFLAGS_MINIMAL"]=CFLAGS_MINIMAL
    CXXFLAGS="%s -fPIC -fvisibility=hidden -fvisibility-inlines-hidden %s" % (CXXFLAGS, str.join(" ", ADDITIONAL_ARGS))
    os.environ["CXXFLAGS"]=CXXFLAGS
    CFLAGS="%s   -fPIC -fvisibility=hidden -fvisibility-inlines-hidden %s" % (CFLAGS, str.join(" ", ADDITIONAL_ARGS))
    os.environ["CFLAGS"]=CFLAGS
    LDFLAGS="%s %s" % (LDFLAGS, str.join(" ", ADDITIONAL_ARGS))
    os.environ["LDFLAGS"]=LDFLAGS

# Some dependencies need a more recent CMake version than most distros provide
build_dependency(name="cmake-%s" % (CMAKE_VERSION,), mode="autoconf", build_tool_args=[], download_url="https://cmake.org/files/v%s" % (CMAKE_VERSION_2,), download_name="cmake-%s.tar.gz" % (CMAKE_VERSION,))

# Extract compiler flags from CMake to harmonize settings with other autoconf dependencies
CMAKE_FLAG_EXTRACT_DIR="ifcopenshell_cmake_test_%s" % (time.time(),)
# was sp.check_output([bash, "-c", "cat /dev/urandom | env LC_CTYPE=C tr -dc 'a-zA-Z0-9' | head -c 32"]), in bash script, unclear what the exact required format is and whether it's needed
if os.path.exists(CMAKE_FLAG_EXTRACT_DIR):
    shutil.rmtree(CMAKE_FLAG_EXTRACT_DIR)
os.makedirs(CMAKE_FLAG_EXTRACT_DIR)
BUILD_CFG_UPPER=BUILD_CFG.upper()
for FL in ["C", "CXX"]:
    __check_call__([bash, "-c", """echo "
    message(\"\${CMAKE_%s_FLAGS_%s}\")
    " > CMakeLists.txt""" % (FL, BUILD_CFG_UPPER)], cwd=CMAKE_FLAG_EXTRACT_DIR)
    FL="%sFLAGS" % (FL,)
    FLM="%sFLAGS_MINIMAL" % (FL,)
# @TODO: bash code unclear
#    exec("%sFLAGS=%s" % (FL, sp.check_output([os.path.join(DEPS_DIR, "install", "cmake-%s" % (CMAKE_VERSION,), "bin", "cmake"), "."
#    declare ${FL}FLAGS_MINIMAL="`$DEPS_DIR/install/cmake-$CMAKE_VERSION/bin/cmake . 2>&1 >/dev/null` ${!FLM}"
shutil.rmtree(CMAKE_FLAG_EXTRACT_DIR)

build_dependency(name="pcre-%s" % (PCRE_VERSION,), mode="autoconf", build_tool_args=["--disable-shared"], download_url="https://downloads.sourceforge.net/project/pcre/pcre/%s/" % (PCRE_VERSION,), download_name="pcre-%s.tar.bz2" % (PCRE_VERSION,))

# An issue exists with swig-1.3 and python >= 3.2
# Therefore, build a recent copy from source
build_dependency(name="swig", mode="autoconf", build_tool_args=["--with-pcre-prefix=%s/install/pcre-%s" % (DEPS_DIR, PCRE_VERSION)], download_url="https://github.com/swig/swig.git", download_name="swig", download_tool=download_tool_git, revision="rel-%s" % SWIG_VERSION)

if USE_OCCT:
    build_dependency(
        name="occt-%s" % OCCT_VERSION,
        mode="cmake",
        build_tool_args=[
            "-DINSTALL_DIR=%s/install/occt-%s" % (DEPS_DIR, OCCT_VERSION),
            "-DBUILD_LIBRARY_TYPE=Static",
            "-DBUILD_MODULE_Draw=0",
        ],
        download_url = "https://git.dev.opencascade.org/repos/occt.git",
        download_name = "occt",
        download_tool=download_tool_git,
        patch="./patches/occt/enable-exception-handling.patch",
        revision="V%s" % OCCT_VERSION.replace('.', '_'))
else:
    build_dependency(name="oce-%s" % (OCE_VERSION,), mode="cmake", build_tool_args=["-DOCE_DISABLE_TKSERVICE_FONT=ON", "-DOCE_TESTING=OFF", "-DOCE_BUILD_SHARED_LIB=OFF", "-DOCE_DISABLE_X11=ON", "-DOCE_VISUALISATION=OFF", "-DOCE_OCAF=OFF", "-DOCE_INSTALL_PREFIX=%s/install/oce-%s" % (DEPS_DIR, OCE_VERSION)], download_url="https://github.com/tpaviot/oce/archive/", download_name="OCE-%s.tar.gz" % (OCE_VERSION,))
        
build_dependency("libxml2-%s" % (LIBXML_VERSION,), "autoconf", build_tool_args=["--without-python", "--disable-shared", "--without-zlib", "--without-iconv", "--without-lzma"], download_url="ftp://xmlsoft.org/libxml2/", download_name="libxml2-%s.tar.gz" % (LIBXML_VERSION,))
build_dependency("OpenCOLLADA", "cmake", build_tool_args=["-DLIBXML2_INCLUDE_DIR=%s/install/libxml2-%s/include/libxml2" % (DEPS_DIR, LIBXML_VERSION), "-DLIBXML2_LIBRARIES=%s/install/libxml2-%s/lib/libxml2.a" % (DEPS_DIR, LIBXML_VERSION), "-DPCRE_INCLUDE_DIR=%s/install/pcre-%s/include" % (DEPS_DIR, PCRE_VERSION), "-DPCRE_PCREPOSIX_LIBRARY=%s/install/pcre-%s/lib/libpcreposix.a" % (DEPS_DIR, PCRE_VERSION), "-DPCRE_PCRE_LIBRARY=%s/install/pcre-%s/lib/libpcre.a" % (DEPS_DIR, PCRE_VERSION), "-DCMAKE_INSTALL_PREFIX=%s/install/OpenCOLLADA/" % (DEPS_DIR,)], download_url="https://github.com/KhronosGroup/OpenCOLLADA.git", download_name="OpenCOLLADA", download_tool=download_tool_git, revision=OPENCOLLADA_COMMIT)

# Python should not be built with -fvisibility=hidden, from experience that introduces segfaults

OLD_CXX_FLAGS=os.environ["CXXFLAGS"]
OLD_C_FLAGS=os.environ["CFLAGS"]
os.environ["CXXFLAGS"]=CXXFLAGS_MINIMAL
os.environ["CFLAGS"]=CFLAGS_MINIMAL

# On OSX a dynamic python library is built or it would not be compatible
# with the system python because of some threading initialization
PYTHON_CONFIGURE_ARGS=[]
if get_os() == "Darwin":
    PYTHON_CONFIGURE_ARGS=["--disable-static", "--enable-shared"]
    
def get_python_unicode_confs(py_ver):
    if py_ver < "3.3":
        return [("--enable-unicode=ucs2",""), ("--enable-unicode=ucs4","u")]
    else: return [("","")]
    
def PYTHON_VERSION_CONFS():
    for v in PYTHON_VERSIONS:
        for unicode_conf, abi_tag in get_python_unicode_confs(v):
            yield v, unicode_conf, abi_tag

for PYTHON_VERSION, unicode_conf, abi_tag in PYTHON_VERSION_CONFS():
    build_dependency("python-%s%s" % (PYTHON_VERSION,abi_tag), "autoconf", PYTHON_CONFIGURE_ARGS + [unicode_conf], "http://www.python.org/ftp/python/%s/" % (PYTHON_VERSION,), "Python-%s.tgz" % (PYTHON_VERSION,))

os.environ["CXXFLAGS"]=OLD_CXX_FLAGS
os.environ["CFLAGS"]=OLD_C_FLAGS

str_concat = lambda prefix: lambda postfix: "" if postfix.strip() == "" else "=".join((prefix, postfix.strip()))
build_dependency("boost-%s" % (BOOST_VERSION,), mode="bjam", build_tool_args=["--stagedir=%s/install/boost-%s" % (DEPS_DIR, BOOST_VERSION), "--with-system", "--with-program_options", "--with-regex", "--with-thread", "--with-date_time", "--with-iostreams", "link=static"]+BOOST_ADDRESS_MODEL+list(map(str_concat("cxxflags"), CXXFLAGS.strip().split(' '))) + list(map(str_concat("linkflags"), LDFLAGS.strip().split(' '))) + ["stage", "-s", "NO_BZIP2=1"], download_url="http://downloads.sourceforge.net/project/boost/boost/%s/" % (BOOST_VERSION,), download_name="boost_%s.tar.bz2" % (BOOST_VERSION_UNDERSCORE,))

build_dependency(name="icu-%s" % (ICU_VERSION,), mode="icu", build_tool_args=["--enable-static", "--disable-shared"], download_url="http://download.icu-project.org/files/icu4c/%s/" % (ICU_VERSION,), download_name="icu4c-%s-src.tgz" % (ICU_VERSION_UNDERSCORE,))

cecho("Building IfcOpenShell:", GREEN)

IFCOS_DIR=os.path.join(DEPS_DIR, "build", "ifcopenshell")
if os.path.exists(IFCOS_DIR):
    shutil.rmtree(IFCOS_DIR)
os.makedirs(IFCOS_DIR)

executables_dir = os.path.join(IFCOS_DIR, "executables")
if not os.path.exists(executables_dir):
    os.makedirs(executables_dir)

logger.info("\rConfiguring executables...")

if USE_OCCT:
    occ_include_dir = "%s/install/occt-%s/include/opencascade" % (DEPS_DIR, OCCT_VERSION)
    occ_library_dir = "%s/install/occt-%s/lib" % (DEPS_DIR, OCCT_VERSION)
else:
    occ_include_dir = "%s/install/oce-%s/include/oce" % (DEPS_DIR, OCE_VERSION)
    occ_library_dir = "%s/install/oce-%s/lib" % (DEPS_DIR, OCE_VERSION)

run_cmake("", cmake_args=[
    "-DBOOST_ROOT="              "%s/install/boost-%s" % (DEPS_DIR, BOOST_VERSION),
    "-DOCC_INCLUDE_DIR="        +occ_include_dir,
    "-DOCC_LIBRARY_DIR="        +occ_library_dir,
    "-DOPENCOLLADA_INCLUDE_DIR=" "%s/install/OpenCOLLADA/include/opencollada" % (DEPS_DIR,),
    "-DOPENCOLLADA_LIBRARY_DIR=" "%s/install/OpenCOLLADA/lib/opencollada" % (DEPS_DIR,),
    "-DICU_INCLUDE_DIR="         "%s/install/icu-%s/include" % (DEPS_DIR, ICU_VERSION),
    "-DICU_LIBRARY_DIR="         "%s/install/icu-%s/lib" % (DEPS_DIR, ICU_VERSION),
    "-DPCRE_LIBRARY_DIR="        "%s/install/pcre-%s/lib" % (DEPS_DIR, PCRE_VERSION),
    "-DBUILD_IFCPYTHON="         "OFF",
    "-DUSE_MMAP="                "OFF",
    "-DCMAKE_INSTALL_PREFIX="    "%s/install/ifcopenshell" % (DEPS_DIR,)], cmake_dir=CMAKE_DIR, cwd=executables_dir)

logger.info("\rBuilding executables...   ")

__check_call__([make, "-j%s" % (IFCOS_NUM_BUILD_PROCS,)], cwd=executables_dir)
__check_call__([make, "install/strip" if BUILD_CFG == "Release" else "install"], cwd=executables_dir)

# On OSX the actual Python library is not linked against.
ADDITIONAL_ARGS=""
if get_os() == "Darwin":
    ADDITIONAL_ARGS="-Wl,-flat_namespace,-undefined,suppress"

os.environ["CXXFLAGS"]="%s %s" % (CXXFLAGS_MINIMAL, ADDITIONAL_ARGS)
os.environ["CFLAGS"]="%s %s" % (CFLAGS_MINIMAL, ADDITIONAL_ARGS)
os.environ["LDFLAGS"]="%s %s" % (LDFLAGS, ADDITIONAL_ARGS)

for PYTHON_VERSION, _, TAG in PYTHON_VERSION_CONFS():
    logger.info("\rConfiguring python %s%s wrapper..." % (PYTHON_VERSION, TAG))
    
    python_dir = os.path.join(IFCOS_DIR, "python-%s%s" % (PYTHON_VERSION, TAG))
    if not os.path.exists(python_dir):
        os.makedirs(python_dir)

    PYTHON_LIBRARY=__check_output__([bash, "-c", "ls    %s/install/python-%s%s/lib/libpython*.*" % (DEPS_DIR, PYTHON_VERSION, TAG)], cwd=None).strip()
    PYTHON_INCLUDE=__check_output__([bash, "-c", "ls -d %s/install/python-%s%s/include/python*" % (DEPS_DIR, PYTHON_VERSION, TAG)], cwd=None).strip()
    PYTHON_EXECUTABLE=os.path.join(DEPS_DIR, "install", "python-%s%s" % (PYTHON_VERSION, TAG), "bin", "python%s" % (PYTHON_VERSION[0],))
    os.environ["PYTHON_LIBRARY_BASENAME"]=os.path.basename(PYTHON_LIBRARY)
    
    run_cmake("", cmake_args=["-DBOOST_ROOT=%s/install/boost-%s" % (DEPS_DIR, BOOST_VERSION),
    "-DOCC_INCLUDE_DIR="+occ_include_dir,
    "-DOCC_LIBRARY_DIR="+occ_library_dir,
    "-DOPENCOLLADA_INCLUDE_DIR=%s/install/OpenCOLLADA/include/opencollada" % (DEPS_DIR,),
    "-DOPENCOLLADA_LIBRARY_DIR=%s/install/OpenCOLLADA/lib/opencollada" % (DEPS_DIR,),
    "-DICU_INCLUDE_DIR=%s/install/icu-%s/include" % (DEPS_DIR, ICU_VERSION),
    "-DICU_LIBRARY_DIR=%s/install/icu-%s/lib" % (DEPS_DIR, ICU_VERSION),
    "-DPYTHON_LIBRARY=%s" % (PYTHON_LIBRARY,),
    "-DPYTHON_EXECUTABLE=%s" % (PYTHON_EXECUTABLE,),
    "-DPYTHON_INCLUDE_DIR=%s" % (PYTHON_INCLUDE,),
    "-DSWIG_EXECUTABLE=%s/install/swig/bin/swig"  % (DEPS_DIR,),
    "-DCMAKE_INSTALL_PREFIX=%s/install/ifcopenshell/tmp" % (DEPS_DIR,),
    "-DCOLLADA_SUPPORT=OFF"], cmake_dir=CMAKE_DIR, cwd=python_dir)
    
    logger.info("\rBuilding python %s%s wrapper...   " % (PYTHON_VERSION, TAG))
    
    __check_call__([make, "-j%s" % (IFCOS_NUM_BUILD_PROCS,), "_ifcopenshell_wrapper"], cwd=python_dir)
    __check_call__([make, "install/local"], cwd=os.path.join(python_dir, "ifcwrap"))
    
    module_dir = os.path.dirname(__check_output__([PYTHON_EXECUTABLE, "-c", "from __future__ import print_function; import inspect, ifcopenshell; print(inspect.getfile(ifcopenshell))"]))
    
    if get_os() != "Darwin":
        # TODO: This symbol name depends on the Python version?
        __check_call__([strip, "-s", "-K", "PyInit__ifcopenshell_wrapper", "_ifcopenshell_wrapper.so"], cwd=module_dir)
        
    __check_call__([cp, "-R", module_dir, os.path.join(DEPS_DIR, "install", "ifcopenshell", "python-%s%s" % (PYTHON_VERSION, TAG))])

logger.info("\rBuilt IfcOpenShell...\n\n")