#!/usr/bin/env python3

import os, sys, stat
import argparse
import urllib.request
import tarfile
import subprocess
import hashlib
import shutil
import tempfile
import configparser
from collections import defaultdict, namedtuple


pj = os.path.join

REMOTE_PREFIX = 'http://download.kiwix.org/dev/'

SCRIPT_DIR = os.path.dirname(os.path.realpath(__file__))


class Defaultdict(defaultdict):
    def __getattr__(self, name):
        return self[name]

def get_sha256(path):
    sha256 = hashlib.sha256()
    with open(path, 'br') as f:
        sha256.update(f.read())
    return sha256.hexdigest()

class SkipCommand(Exception):
    pass

class StopBuild(Exception):
    pass

class Remotefile(namedtuple('Remotefile', ('name', 'sha256', 'url'))):
    def __new__(cls, name, sha256, url=None):
        return super().__new__(cls, name, sha256, url)

class Context:
    def __init__(self, command_name, log_file):
        self.command_name = command_name
        self.log_file = log_file
        self.autoskip_file = None

    def try_skip(self, path):
        self.autoskip_file = pj(path, ".{}_ok".format(self.command_name))
        if os.path.exists(self.autoskip_file):
            raise SkipCommand()

    def _finalise(self):
        if self.autoskip_file is not None:
            with open(self.autoskip_file, 'w') as f: pass


def extract_archive(archive_path, dest_dir, topdir=None, name=None):
    with tarfile.open(archive_path) as archive:
        members = archive.getmembers()
        if not topdir:
            for d in (m for m in members if m.isdir()):
                if not os.path.dirname(d.name):
                    if topdir:
                        # There is already a top dir.
                        # Two topdirs in the same archive.
                        # Extract all
                        topdir = None
                        break
                    topdir = d
        else:
            topdir = archive.getmember(topdir)
        if topdir:
            members_to_extract = [m for m in members if m.name.startswith(topdir.name+'/')]
            os.makedirs(dest_dir, exist_ok=True)
            with tempfile.TemporaryDirectory(prefix=os.path.basename(archive_path), dir=dest_dir) as tmpdir:
                archive.extractall(path=tmpdir, members=members_to_extract)
                name = name or topdir.name
                os.rename(pj(tmpdir, topdir.name), pj(dest_dir, name))
        else:
            if name:
                dest_dir = pj(dest_dir, name)
                os.makedirs(dest_dir)
            archive.extractall(path=dest_dir)


class BuildEnv:
    build_targets = ['native', 'win32']

    _targets_env = {
        'native' : {},
        'win32'  : {'wrapper': 'mingw32-env'}
    }

    def __init__(self, options):
        self.source_dir = pj(options.working_dir, "SOURCE")
        build_dir = "BUILD_{target}_{libmod}".format(
            target=options.build_target,
            libmod='static' if options.build_static else 'dyn'
        )
        self.build_dir = pj(options.working_dir, build_dir)
        self.archive_dir = pj(options.working_dir, "ARCHIVE")
        self.log_dir = pj(options.working_dir, 'LOGS')
        self.install_dir = pj(self.build_dir, "INSTALL")
        os.makedirs(self.source_dir, exist_ok=True)
        os.makedirs(self.archive_dir, exist_ok=True)
        os.makedirs(self.build_dir, exist_ok=True)
        os.makedirs(self.log_dir, exist_ok=True)
        os.makedirs(self.install_dir, exist_ok=True)
        self.setup_build_target(options.build_target)
        self.ninja_command = self._detect_ninja()
        self.meson_command = self._detect_meson()
        self.options = options
        self.libprefix = options.libprefix or self._detect_libdir()

    def setup_build_target(self, build_target):
        self.build_target = build_target
        self.target_env = self._targets_env[self.build_target]
        getattr(self, 'setup_{}'.format(self.build_target))()

    def setup_native(self):
        self.wrapper = None
        self.cmake_command = "cmake"
        self.configure_option = ""
        self.cmake_option = ""
        self.meson_crossfile = None

    def _get_rpm_mingw32(self, value):
        command = "rpm --eval %{{mingw32_{}}}".format(value)
        output = subprocess.check_output(command, shell=True)
        return output[:-1].decode()

    def _gen_meson_crossfile(self):
        self.meson_crossfile = pj(self.build_dir, 'cross_file.txt')
        config = configparser.ConfigParser()
        config['binaries'] = {
            'c' : repr(self._get_rpm_mingw32('cc')),
            'cpp' : repr(self._get_rpm_mingw32('cxx')),
            'ar' : repr(self._get_rpm_mingw32('ar')),
            'strip' : repr(self._get_rpm_mingw32('strip')),
            'pkgconfig' : repr(self._get_rpm_mingw32('pkg_config')),
            'exe_wrapper' : repr('wine') # A command used to run generated executables.
        }
        config['properties'] = {
            'c_link_args': ['-lwinmm', '-lws2_32', '-lshlwapi', '-lrpcrt4'],
            'cpp_link_args': ['-lwinmm', '-lws2_32', '-lshlwapi', '-lrpcrt4']
        }
        config['host_machine'] = {
            'system' : repr('windows'),
            'cpu_family' : repr('x86'),
            'cpu' : repr('i586'),
            'endian' : repr('little')
        }
        with open(self.meson_crossfile, 'w') as configfile:
            config.write(configfile)

    def setup_win32(self):
        command = "rpm --eval %{mingw32_env}"
        self.wrapper = pj(self.build_dir, 'mingw32-wrapper.sh')
        with open(self.wrapper, 'w') as output:
            output.write("#!/usr/bin/sh\n\n")
            output.flush()
            output.write(self._get_rpm_mingw32('env'))
            output.write('\n\nexec "$@"\n')
            output.flush()
        current_permissions = stat.S_IMODE(os.lstat(self.wrapper).st_mode)
        os.chmod(self.wrapper, current_permissions | stat.S_IXUSR)
        self.configure_option = "--host=i686-w64-mingw32"
        self.cmake_command = "mingw32-cmake"
        self.cmake_option = ""

        self._gen_meson_crossfile()

    def __getattr__(self, name):
        return getattr(self.options, name)

    def _is_debianlike(self):
        return os.path.isfile('/etc/debian_version')

    def _detect_libdir(self):
        if self._is_debianlike():
            try:
                pc = subprocess.Popen(['dpkg-architecture', '-qDEB_HOST_MULTIARCH'],
                                      stdout=subprocess.PIPE,
                                      stderr=subprocess.DEVNULL)
                (stdo, _) = pc.communicate()
                if pc.returncode == 0:
                    archpath = stdo.decode().strip()
                    return 'lib/' + archpath
            except Exception:
                pass
        if os.path.isdir('/usr/lib64') and not os.path.islink('/usr/lib64'):
            return 'lib64'
        return 'lib'

    def _detect_ninja(self):
        for n in ['ninja', 'ninja-build']:
            try:
                retcode = subprocess.check_call([n, '--version'],
                                                stdout=subprocess.DEVNULL)
            except (FileNotFoundError, PermissionError):
                # Doesn't exist in PATH or isn't executable
                continue
            if retcode == 0:
                return n

    def _detect_meson(self):
        for n in ['meson.py', 'meson']:
            try:
                retcode = subprocess.check_call([n, '--version'],
                                                stdout=subprocess.DEVNULL)
            except (FileNotFoundError, PermissionError):
                # Doesn't exist in PATH or isn't executable
                continue
            if retcode == 0:
                return n

    def run_command(self, command, cwd, context, env=None, input=None, allow_wrapper=True):
        os.makedirs(cwd, exist_ok=True)
        if allow_wrapper and self.wrapper:
            command = "{} {}".format(self.wrapper, command)
        if env is None:
            env = dict(os.environ)
        log = None
        try:
            if not self.options.verbose:
                log = open(context.log_file, 'w')
            print("run command '{}'".format(command), file=log)
            print("env is :",file=log)
            for k, v in env.items():
                print("  {} : {!r}".format(k, v), file=log)

            kwargs = dict()
            if input:
                kwargs['stdin'] = input
            return subprocess.check_call(command, shell=True, cwd=cwd, env=env, stdout=log or sys.stdout, stderr=subprocess.STDOUT, **kwargs)
        finally:
            if log:
                log.close()

    def download(self, what, where=None):
        where = where or self.archive_dir
        file_path = pj(where, what.name)
        file_url = what.url or (REMOTE_PREFIX + what.name)
        if os.path.exists(file_path):
            if what.sha256 == get_sha256(file_path):
                raise SkipCommand()
            os.remove(file_path)
        urllib.request.urlretrieve(file_url, file_path)
        if not what.sha256:
            print('Sha256 for {} not set, do no verify download'.format(what.name))
        elif what.sha256 != get_sha256(file_path):
            os.remove(file_path)
            raise StopBuild()


################################################################################
##### PROJECT
################################################################################
class Dependency:
    force_native_build = False
    version = None
    def __init__(self, buildEnv):
        self.buildEnv = buildEnv
        self.source = self.Source(self)
        self.builder = self.Builder(self)

    @property
    def full_name(self):
        if self.version:
            return "{}-{}".format(self.name, self.version)
        return self.name

    @property
    def source_path(self):
        return pj(self.buildEnv.source_dir, self.source.source_dir)

    @property
    def _log_dir(self):
        return self.buildEnv.log_dir

    def command(self, name, function, *args):
        print("  {} {} : ".format(name, self.name), end="", flush=True)
        log = pj(self._log_dir, 'cmd_{}_{}.log'.format(name, self.name))
        context = Context(name, log)
        try:
            ret = function(*args, context=context)
            context._finalise()
            print("OK")
            return ret
        except SkipCommand:
            print("SKIP")
        except subprocess.CalledProcessError:
            print("ERROR")
            try:
                with open(log, 'r') as f:
                    print(f.read())
            except:
                pass
            raise StopBuild()
        except:
            print("ERROR")
            raise


class Source:
    """Base Class to the real preparator
       A source preparator must install source in the self.source_dir attribute
       inside the buildEnv.source_dir."""
    def __init__(self, target):
        self.target = target
        self.buildEnv = target.buildEnv

    @property
    def name(self):
        return self.target.name

    @property
    def source_dir(self):
        return self.target.full_name

    def command(self, *args, **kwargs):
        return self.target.command(*args, **kwargs)


class ReleaseDownload(Source):
    archive_top_dir = None
    @property
    def extract_path(self):
        return pj(self.buildEnv.source_dir, self.source_dir)

    def _download(self, context):
        self.buildEnv.download(self.archive)

    def _extract(self, context):
        context.try_skip(self.extract_path)
        if os.path.exists(self.extract_path):
            shutil.rmtree(self.extract_path)
        extract_archive(pj(self.buildEnv.archive_dir, self.archive.name),
                           self.buildEnv.source_dir,
                           topdir=self.archive_top_dir,
                           name=self.source_dir)

    def _patch(self, context):
        context.try_skip(self.extract_path)
        for p in self.patches:
            with open(pj(SCRIPT_DIR, 'patches', p), 'r') as patch_input:
                self.buildEnv.run_command("patch -p1", self.extract_path, context, input=patch_input, allow_wrapper=False)

    def prepare(self):
        self.command('download', self._download)
        self.command('extract', self._extract)
        if hasattr(self, 'patches'):
            self.command('patch', self._patch)


class GitClone(Source):
    git_ref = "master"
    @property
    def source_dir(self):
        return self.git_dir

    @property
    def git_path(self):
        return pj(self.buildEnv.source_dir, self.git_dir)

    def _git_clone(self, context):
        if os.path.exists(self.git_path):
            raise SkipCommand()
        command = "git clone " + self.git_remote
        self.buildEnv.run_command(command, self.buildEnv.source_dir, context)

    def _git_update(self, context):
        self.buildEnv.run_command("git pull", self.git_path, context)
        self.buildEnv.run_command("git checkout "+self.git_ref, self.git_path, context)

    def prepare(self):
        self.command('gitclone', self._git_clone)
        self.command('gitupdate', self._git_update)


class Builder:
    subsource_dir = None
    def __init__(self, target):
        self.target = target
        self.buildEnv = target.buildEnv

    @property
    def name(self):
        return self.target.name

    @property
    def source_path(self):
        base_source_path = self.target.source_path
        if self.subsource_dir:
            return pj(base_source_path, self.subsource_dir)
        return base_source_path

    @property
    def build_path(self):
        return pj(self.buildEnv.build_dir, self.target.full_name)

    def command(self, *args, **kwargs):
        return self.target.command(*args, **kwargs)

    def build(self):
        self.command('configure', self._configure)
        self.command('compile', self._compile)
        self.command('install', self._install)


class MakeBuilder(Builder):
    configure_option = ""
    make_option = ""
    install_option = ""
    configure_script = "configure"
    configure_env = None
    make_target = ""
    make_install_target = "install"

    def _configure(self, context):
        context.try_skip(self.build_path)
        command = "{configure_script} {configure_option} --prefix {install_dir} --libdir {libdir}"
        command = command.format(
            configure_script = pj(self.source_path, self.configure_script),
            configure_option = "{} {}".format(self.configure_option, self.buildEnv.configure_option),
            install_dir = self.buildEnv.install_dir,
            libdir = pj(self.buildEnv.install_dir, self.buildEnv.libprefix)
        )
        env = Defaultdict(str, os.environ)
        if self.buildEnv.build_static:
            env['CFLAGS'] = env['CFLAGS'] + ' -fPIC'
        if self.configure_env:
           for k in self.configure_env:
               if k.startswith('_format_'):
                   v = self.configure_env.pop(k)
                   v = v.format(buildEnv=self.buildEnv, env=env)
                   self.configure_env[k[8:]] = v
           env.update(self.configure_env)
        self.buildEnv.run_command(command, self.build_path, context, env=env)

    def _compile(self, context):
        context.try_skip(self.build_path)
        command = "make -j4 {make_target} {make_option}".format(
            make_target = self.make_target,
            make_option = self.make_option
        )
        self.buildEnv.run_command(command, self.build_path, context)

    def  _install(self, context):
        context.try_skip(self.build_path)
        command = "make {make_install_target} {make_option}".format(
            make_install_target = self.make_install_target,
            make_option = self.make_option
        )
        self.buildEnv.run_command(command, self.build_path, context)


class CMakeBuilder(MakeBuilder):
    def _configure(self, context):
        context.try_skip(self.build_path)
        command = "{command} {configure_option} -DCMAKE_VERBOSE_MAKEFILE:BOOL=ON -DCMAKE_INSTALL_PREFIX={install_dir} -DCMAKE_INSTALL_LIBDIR={libdir} {source_path}"
        command = command.format(
            command = self.buildEnv.cmake_command,
            configure_option = "{} {}".format(self.buildEnv.cmake_option, self.configure_option),
            install_dir = self.buildEnv.install_dir,
            libdir = self.buildEnv.libprefix,
            source_path = self.source_path
        )
        env = Defaultdict(str, os.environ)
        if self.buildEnv.build_static:
            env['CFLAGS'] = env['CFLAGS'] + ' -fPIC'
        if self.configure_env:
           for k in self.configure_env:
               if k.startswith('_format_'):
                   v = self.configure_env.pop(k)
                   v = v.format(buildEnv=self.buildEnv, env=env)
                   self.configure_env[k[8:]] = v
           env.update(self.configure_env)
        self.buildEnv.run_command(command, self.build_path, context, env=env, allow_wrapper=False)

class MesonBuilder(Builder):
    configure_option = ""
    def _gen_env(self):
        env = Defaultdict(str, os.environ)
        env['PKG_CONFIG_PATH'] = (env['PKG_CONFIG_PATH'] + ':' + pj(self.buildEnv.install_dir, self.buildEnv.libprefix, 'pkgconfig')
                                  if env['PKG_CONFIG_PATH']
                                  else pj(self.buildEnv.install_dir, self.buildEnv.libprefix, 'pkgconfig')
                                 )
        env['PATH'] = ':'.join([pj(self.buildEnv.install_dir, 'bin'), env['PATH']])
        if self.buildEnv.build_static:
            env['LDFLAGS'] = env['LDFLAGS'] + " -static-libstdc++ --static"
        return env

    def _configure(self, context):
        context.try_skip(self.build_path)
        if os.path.exists(self.build_path):
            shutil.rmtree(self.build_path)
        os.makedirs(self.build_path)
        env = self._gen_env()
        if self.buildEnv.build_static:
            library_type = 'static'
        else:
            library_type = 'shared'
        configure_option = self.configure_option.format(buildEnv=self.buildEnv)
        command = "{command} --default-library={library_type} {configure_option} . {build_path} --prefix={buildEnv.install_dir} --libdir={buildEnv.libprefix} {cross_option}".format(
            command = self.buildEnv.meson_command,
            library_type=library_type,
            configure_option=configure_option,
            build_path = self.build_path,
            buildEnv=self.buildEnv,
            cross_option = "--cross-file {}".format(self.buildEnv.meson_crossfile) if self.buildEnv.meson_crossfile else ""
        )
        self.buildEnv.run_command(command, self.source_path, context, env=env, allow_wrapper=False)

    def _compile(self, context):
        env = self._gen_env()
        command = "{} -v".format(self.buildEnv.ninja_command)
        self.buildEnv.run_command(command, self.build_path, context, env=env, allow_wrapper=False)

    def _install(self, context):
        env = self._gen_env()
        command = "{} -v install".format(self.buildEnv.ninja_command)
        self.buildEnv.run_command(command, self.build_path, context, allow_wrapper=False)


# *************************************
# Missing dependencies
# Is this ok to assume that those libs
# exist in your "distri" (linux/mac) ?
# If not, we need to compile them here
# *************************************
# Zlib
# LZMA
# aria2
# Argtable
# MSVirtual
# Android
# libiconv
# gettext
# *************************************

class UUID(Dependency):
    name = 'uuid'
    version = "1.42"

    class Source(ReleaseDownload):
        archive = Remotefile('e2fsprogs-1.42.tar.gz',
                             '55b46db0cec3e2eb0e5de14494a88b01ff6c0500edf8ca8927cad6da7b5e4a46')
        extract_dir = 'e2fsprogs-1.42'

    class Builder(MakeBuilder):
        configure_option = "--enable-libuuid"
        configure_env = {'_format_CFLAGS' : "{env.CFLAGS} -fPIC"}
        make_target = 'libs'
        make_install_target = 'install-libs'


class Xapian(Dependency):
    name = "xapian-core"
    version = "1.4.0"

    class Source(ReleaseDownload):
        archive = Remotefile('xapian-core-1.4.0.tar.xz',
                             '10584f57112aa5e9c0e8a89e251aecbf7c582097638bfee79c1fe39a8b6a6477')
        patches = ["xapian_pkgconfig.patch"]

    class Builder(MakeBuilder):
        configure_option = ("--enable-shared --enable-static --disable-sse "
                            "--disable-backend-inmemory --disable-documentation")
        configure_env = {'_format_LDFLAGS' : "-L{buildEnv.install_dir}/{buildEnv.libprefix}",
                         '_format_CXXFLAGS' : "-I{buildEnv.install_dir}/include"}


class CTPP2(Dependency):
    name = "ctpp2"
    version = "2.8.3"

    class Source(ReleaseDownload):
         archive = Remotefile('ctpp2-2.8.3.tar.gz',
                              'a83ffd07817adb575295ef40fbf759892512e5a63059c520f9062d9ab8fb42fc')
         patches = ["ctpp2_include.patch",
               "ctpp2_no_src_modification.patch",
               "ctpp2_fix-static-libname.patch",
               "ctpp2_mingw32.patch",
               "ctpp2_dll_export_VMExecutable.patch",
               "ctpp2_win_install_lib_in_lib_dir.patch"]

    class Builder(CMakeBuilder):
        configure_option = "-DMD5_SUPPORT=OFF"


class Pugixml(Dependency):
    name = "pugixml"
    version = "1.2"

    class Source(ReleaseDownload):
        archive = Remotefile('pugixml-1.2.tar.gz',
                             '0f422dad86da0a2e56a37fb2a88376aae6e931f22cc8b956978460c9db06136b')
        patches = ["pugixml_meson.patch"]

    Builder = MesonBuilder


class MicroHttpd(Dependency):
    name = "libmicrohttpd"
    version = "0.9.46"

    class Source(ReleaseDownload):
        archive = Remotefile('libmicrohttpd-0.9.46.tar.gz',
                             '06dbd2654f390fa1e8196fe063fc1449a6c2ed65a38199a49bf29ad8a93b8979',
                             'http://ftp.gnu.org/gnu/libmicrohttpd/libmicrohttpd-0.9.46.tar.gz')

    class Builder(MakeBuilder):
        configure_option = "--enable-shared --enable-static --disable-https --without-libgcrypt --without-libcurl"


class Icu(Dependency):
    name = "icu4c"
    version = "56_1"

    class Source(ReleaseDownload):
        archive = Remotefile('icu4c-56_1-src.tgz',
                             '3a64e9105c734dcf631c0b3ed60404531bce6c0f5a64bfe1a6402a4cc2314816'
                            )
        patches = ["icu4c_fix_static_lib_name_mingw.patch"]
        data = Remotefile('icudt56l.dat',
                          'e23d85eee008f335fc49e8ef37b1bc2b222db105476111e3d16f0007d371cbca')

        def _download_data(self, context):
            self.buildEnv.download(self.data)

        def _copy_data(self, context):
            context.try_skip(self.extract_path)
            shutil.copyfile(pj(self.buildEnv.archive_dir, self.data.name), pj(self.extract_path, 'source', 'data', 'in', self.data.name))

        def prepare(self):
            super().prepare()
            self.command("download_data", self._download_data)
            self.command("copy_data", self._copy_data)

    class Builder(MakeBuilder):
        subsource_dir = "source"

        @property
        def configure_option(self):
            default_configure_option = "--disable-samples --disable-tests --disable-extras --disable-dyload"
            if self.buildEnv.build_static:
                default_configure_option += " --enable-static --disable-shared"
            else:
                default_configure_option += " --enable-shared --enable-shared"
            return default_configure_option


class Icu_native(Icu):
    force_native_build = True

    class Builder(Icu.Builder):
        @property
        def build_path(self):
            return super().build_path+"_native"

        def _install(self, context):
            raise SkipCommand()


class Icu_cross_compile(Icu):
    dependencies = ['Icu_native']

    class Builder(Icu.Builder):
        @property
        def configure_option(self):
            Icu_native = self.buildEnv.targetsDict['Icu_native']
            return super().configure_option + " --with-cross-build=" + Icu_native.builder.build_path


class Zimlib(Dependency):
    name = "zimlib"

    class Source(GitClone):
        #git_remote = "https://gerrit.wikimedia.org/r/p/openzim.git"
        git_remote = "https://github.com/mgautierfr/openzim"
        git_dir = "openzim"
        git_ref = "meson"

    class Builder(MesonBuilder):
        subsource_dir = "zimlib"


class Kiwixlib(Dependency):
    name = "kiwix-lib"

    class Source(GitClone):
        git_remote = "https://github.com/kiwix/kiwix-lib.git"
        git_dir = "kiwix-lib"

    class Builder(MesonBuilder):
        configure_option = "-Dctpp2-install-prefix={buildEnv.install_dir}"


class KiwixTools(Dependency):
    name = "kiwix-tools"

    class Source(GitClone):
        git_remote = "https://github.com/kiwix/kiwix-tools.git"
        git_dir = "kiwix-tools"

    class Builder(MesonBuilder):
        configure_option = "-Dctpp2-install-prefix={buildEnv.install_dir}"


class Builder:
    def __init__(self, buildEnv):
        self.buildEnv = buildEnv
        if buildEnv.build_target != 'native':
            subBuildEnv = BuildEnv(buildEnv.options)
            subBuildEnv.setup_build_target('native')
            nativeICU = Icu_native(subBuildEnv)
            self.dependencies = [
                             Xapian(buildEnv),
                             CTPP2(buildEnv),
                             Pugixml(buildEnv),
                             Zimlib(buildEnv),
                             MicroHttpd(buildEnv),
                             nativeICU,
                             Icu_cross_compile(buildEnv, True, nativeICU),
                             Kiwixlib(buildEnv),
                             KiwixTools(buildEnv)
                            ]
        else:
            self.dependencies = [UUID(buildEnv),
                             Xapian(buildEnv),
                             CTPP2(buildEnv),
                             Pugixml(buildEnv),
                             Zimlib(buildEnv),
                             MicroHttpd(buildEnv),
                             Icu(buildEnv),
                             Kiwixlib(buildEnv),
                             KiwixTools(buildEnv)
                            ]

    def prepare(self):
        for dependency in self.dependencies:
            source = dependency.source
            print("prepare {} :".format(source.name))
            source.prepare()

    def build(self):
        for dependency in self.dependencies:
            builder = dependency.builder
            print("build {} :".format(builder.name))
            builder.build()

def parse_args():
    parser = argparse.ArgumentParser()
    parser.add_argument('working_dir', default=".", nargs='?')
    parser.add_argument('--libprefix', default=None)
    parser.add_argument('--build-static', action="store_true")
    parser.add_argument('--build-target', default="native", choices=BuildEnv.build_targets)
    parser.add_argument('--verbose', '-v', action="store_true",
                        help=("Print all logs on stdout instead of in specific"
                              " log files per commands"))
    return parser.parse_args()

if __name__ == "__main__":
    options = parse_args()
    options.working_dir = os.path.abspath(options.working_dir)
    buildEnv = BuildEnv(options)
    builder = Builder(buildEnv)
    try:
        print("[PREPARE]")
        builder.prepare()
        print("[BUILD]")
        builder.build()
    except StopBuild:
        print("Stopping build due to errors")