## -*- Mode: python; py-indent-offset: 4; indent-tabs-mode: nil; coding: utf-8; -*-

import os, os.path
import shutil
import types
import warnings

import TaskGen
import Task
import Options
import Build
import Utils

all_modules = (
    'core',
    'common',
    'simulator',
    'contrib',
    'node',
    'internet-stack',
    'devices/point-to-point',
    'devices/csma',
    'devices/emu',
    'devices/bridge',
    'devices/tap-bridge',
    'devices/virtual-net-device',
    'applications/onoff',
    'applications/packet-sink',
    'applications/udp-echo',
    'routing/nix-vector-routing',
    'routing/olsr',
    'routing/global-routing',
    'routing/static-routing',
    'routing/list-routing',
    'mobility',
    'devices/wifi',
    'helper',
    'contrib/stats',
    'applications/v4ping',
    'devices/mesh',
    'devices/mesh/dot11s',
    'devices/mesh/flame',
    'applications/ping6',
    'applications/radvd',
    'test',
    'test/ns3tcp',
    'test/ns3wifi',
    'contrib/flow-monitor',
    'contrib/net-anim',
    )

def set_options(opt):
    opt.sub_options('simulator')

    opt.add_option('--enable-rpath',
                   help=("Link programs with rpath"
                         " (normally not needed, see "
                         " --run and --shell; moreover, only works in some"
                         " specific platforms, such as Linux and Solaris)"),
                   action="store_true", dest='enable_rpath', default=False)
    
    opt.add_option('--enable-modules',
                   help=("Build only these modules (and dependencies)"),
                   dest='enable_modules')

def configure(conf):
    conf.sub_config('core')
    conf.sub_config('simulator')
    conf.sub_config('devices/emu')
    conf.sub_config('devices/tap-bridge')
    conf.sub_config('contrib')
    conf.sub_config('internet-stack')

    blddir = os.path.abspath(os.path.join(conf.blddir, conf.env.variant()))
    conf.env.append_value('NS3_MODULE_PATH', blddir)
    if Options.options.enable_rpath:
        conf.env.append_value('RPATH', '-Wl,-rpath=%s' % (os.path.join(blddir),))

    ## Used to link the 'test-runner' program with all of ns-3 code
    conf.env['NS3_MODULES'] = ['ns3-' + module.split('/')[-1] for module in all_modules]


def create_ns3_module(bld, name, dependencies=()):
    module = bld.new_task_gen('cxx')
    module.name = 'ns3-' + name
    module.target = module.name
    module.add_objects = ['ns3-' + dep for dep in dependencies]
    module.module_deps = list(dependencies)
    if not module.env['ENABLE_STATIC_NS3']:
        module.env.append_value('CXXFLAGS', module.env['shlib_CXXFLAGS'])
    elif module.env['CXX_NAME'] in ['gcc', 'icc'] and \
            os.uname()[4] == 'x86_64' and \
            module.env['ENABLE_PYTHON_BINDINGS']:
        # enable that flag for static builds only on x86-64 platforms
        # when gcc is present and only when we want python bindings
        # (it's more efficient to not use this option if we can avoid it)
        module.env.append_value('CXXFLAGS', '-mcmodel=large')
        
    module.env.append_value('CXXDEFINES', "NS3_MODULE_COMPILATION")
    return module

def create_obj(bld, *args):
    warnings.warn("(in %s) Use bld.new_task_gen(...) now, instead of bld.create_obj(...)" % str(bld.path),
                  DeprecationWarning, stacklevel=2)
    return bld.new_task_gen(*args)

def build(bld):
    bld.create_ns3_module = types.MethodType(create_ns3_module, bld)
    bld.create_obj = types.MethodType(create_obj, bld)
    
    bld.add_subdirs(list(all_modules))

    for module in all_modules:
        modheader = bld.new_task_gen('ns3moduleheader')
        modheader.module = module.split('/')[-1]


class ns3header_taskgen(TaskGen.task_gen):
    """A set of NS-3 header files"""
    COLOR = 'BLUE'
    def __init__(self, *args, **kwargs):
        super(ns3header_taskgen, self).__init__(*args, **kwargs)
        self.install_path = None
        self.sub_dir = None # if not None, header files will be published as ns3/sub_dir/file.h
        self.module = None # module name

    def apply(self):
        if self.module is None:
            raise Utils.WafError("'module' missing on ns3headers object %s" % self)
        ns3_dir_node = self.bld.path.find_dir("ns3")
        if self.sub_dir is not None:
            ns3_dir_node = ns3_dir_node.find_dir(self.sub_dir)
        for filename in self.to_list(self.source):
            src_node = self.path.find_resource(filename)
            if src_node is None:
                raise Utils.WafError("source ns3 header file %s not found" % (filename,))
            dst_node = ns3_dir_node.find_or_declare(os.path.basename(filename))
            assert dst_node is not None
            task = self.create_task('ns3header', self.env)
            task.set_inputs([src_node])
            task.set_outputs([dst_node])

class ns3header_task(Task.Task):
    before = 'cc cxx gen_ns3_module_header_task'
    color = 'BLUE'
    def run(self):
        assert len(self.inputs) == len(self.outputs)
        inputs = [node.srcpath(self.env) for node in self.inputs]
        outputs = [node.bldpath(self.env) for node in self.outputs]
        for src, dst in zip(inputs, outputs):
            try:
                os.chmod(dst, 0600)
            except OSError:
                pass
            shutil.copy2(src, dst)
            ## make the headers in builddir read-only, to prevent
            ## accidental modification
            os.chmod(dst, 0400)
        return 0



class gen_ns3_module_header_task(Task.Task):
    before = 'cc cxx'
    after = 'ns3header_task'
    color = 'BLUE'
    def run(self):
        assert len(self.outputs) == 1
        header_files = [os.path.basename(node.abspath(self.env)) for node in self.inputs]
        outfile = file(self.outputs[0].bldpath(self.env), "w")
        header_files.sort()

        print >> outfile, """
#ifdef NS3_MODULE_COMPILATION
# error "Do not include ns3 module aggregator headers from other modules; these are meant only for end user scripts."
#endif

#ifndef NS3_MODULE_%s
    """ % (self.module.upper().replace('-', '_'),)

    #     if self.module_deps:
    #         print >> outfile, "// Module dependencies:"
    #     for dep in self.module_deps:
    #         print >> outfile, "#include \"%s-module.h\"" % dep

        print >> outfile
        print >> outfile, "// Module headers:"
        for header in header_files:
            print >> outfile, "#include \"%s\"" % (header,)

        print >> outfile, "#endif"

        outfile.close()
        return 0

    def sig_explicit_deps(self):
        m = Utils.md5()
        m.update('\n'.join([node.abspath(self.env) for node in self.inputs]))
        return m.digest()

    def unique_id(self):
        try:
            return self.uid
        except AttributeError:
            "this is not a real hot zone, but we want to avoid surprizes here"
            m = Utils.md5()
            m.update("ns-3-module-header-%s" % self.module)
            self.uid = m.digest()
            return self.uid


class ns3moduleheader_taskgen(TaskGen.task_gen):
    """
    Generates a 'ns3/foo-module.h' header file that includes all
    public ns3 headers of a certain module.
    """
    COLOR = 'BLUE'
    def __init__(self, *args, **kwargs):
        super(ns3moduleheader_taskgen, self).__init__(*args, **kwargs)

    def apply(self):
        ## get all of the ns3 headers
        ns3_dir_node = self.bld.path.find_dir("ns3")
        all_headers_inputs = []
        found_the_module = False
        for ns3headers in self.bld.all_task_gen:
            if isinstance(ns3headers, ns3header_taskgen):
                if ns3headers.module != self.module:
                    continue
                found_the_module = True
                for source in ns3headers.to_list(ns3headers.source):
                    source = os.path.basename(source)
                    node = ns3_dir_node.find_or_declare(os.path.basename(source))
                    if node is None:
                        fatal("missing header file %s" % (source,))
                    all_headers_inputs.append(node)
        if not found_the_module:
            raise Utils.WscriptError("error finding headers for module %s" % self.module)
        if not all_headers_inputs:
            return
        module_obj = self.bld.name_to_obj("ns3-" + self.module, self.env)
        assert module_obj is not None
        all_headers_outputs = [ns3_dir_node.find_or_declare("%s-module.h" % self.module)]
        task = self.create_task('gen_ns3_module_header', self.env)
        task.set_inputs(all_headers_inputs)
        task.set_outputs(all_headers_outputs)
        task.module = self.module
        task.module_deps = module_obj.module_deps

    def install(self):
        pass
