#!/usr/bin/env python
# -*- coding: utf-8 -*-
# vim:ts=4:sw=4:expandtab

import threading
import os
import sys
import optparse

__full_file_path__ = os.path.abspath(os.path.dirname(__file__))
sys.path.append(os.path.join(__full_file_path__, '..'))
import makefile_parser
from BuildUtil import get_cpu_number

def run_nmake(target):
    return os.system('nmake -f "%s" /nologo MAKE="nmake /nologo" %s' % (
        makefile, target))

def nmake_thread(target):
    S.acquire()
    run_nmake(target)
    S.release()

def parallel_build():
    if base_target == 'release':
        _base_target = 'sub_Release'
    else:
        _base_target = 'sub_Debug'
    target_graph = makefile_parser.get_target_graph(makefile)
    while True:
        if not target_graph:
            break
        indep_targets = []
        for t in target_graph:
            if target_graph[t]['deps']:
                continue
            indep_targets.append(t)
        thread_list = []
        for target in indep_targets:
            for parent_t in target_graph[target]['in_deps']:
                target_graph[parent_t]['deps'].remove(target)
            del target_graph[target]
            t = threading.Thread(
                target = nmake_thread,
                args = ['%s-%s' % (target, _base_target)])
            t.setDaemon(True)
            thread_list.append(t)
            t.start()
        map(lambda t: t.join(), thread_list)

def serial_build():
    return run_nmake(base_target)

def main():
    global S
    global base_target
    global makefile

    parser = optparse.OptionParser()
    parser.add_option(
        '-f',
        dest = 'makefile',
        default = os.path.join(os.getcwd(), 'Makefile'))
    parser.add_option(
        '-j',
        dest = 'nproc',
        default = get_cpu_number())
    opts, args = parser.parse_args()

    makefile = opts.makefile
    nproc = int(opts.nproc)
    S = threading.Semaphore(nproc)
    if args:
        base_target = args[0]
    else:
        base_target = 'debug'

    if base_target in ('release', 'debug'):
        parallel_build()
    return serial_build()

if __name__ == '__main__':
    sys.exit(main())