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

import os, os.path

import sys

import shutil

import types

import warnings

import TaskGen

import Task

import Options

import Build

import Utils

import Constants

import ccroot

ccroot.USE_TOP_LEVEL = True

import wutils

try:

    set

except NameError:

    from sets import Set as set # Python 2.3 fallback

all_modules = [

    'core',

    'network',

    'config-store',

    'internet',

    'propagation',

    'point-to-point',

    'csma',

    'emu',

    'bridge',

    'tap-bridge',

    'virtual-net-device',

    'applications',

    'nix-vector-routing',

    'olsr',

    'aodv',

    'dsdv',

    'click',

    'openflow',

    'mobility',

    'wifi',

    'netanim',

    'stats',

    'uan',

    'spectrum',

    'mesh',   

    'test',

    'test/ns3tcp',

    'test/ns3wifi',

    'flow-monitor',

    'wimax',

    'lte',

    'mpi',

    'topology-read',

    'energy',

    'tools',

    'visualizer',

    'point-to-point-layout',

    'csma-layout',

    'template',

    ]

def set_options(opt):

    opt.sub_options('core')

    opt.sub_options('click')

    opt.sub_options('openflow')

    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('emu')

    conf.sub_config('tap-bridge')

    conf.sub_config('config-store')

    conf.sub_config('internet')

    conf.sub_config('netanim')

    conf.sub_config('test')

    conf.sub_config('click')

    conf.sub_config('openflow')

    conf.sub_config('stats')

    conf.sub_config('visualizer')

    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]

class ns3module_taskgen(TaskGen.task_gen):

    def __init__(self, *args, **kwargs):

        super(ns3module_taskgen, self).__init__(*args, **kwargs)

        self.libs = []

    def apply(self):

        static_enabled = False

        shared_enabled = True

        bld = self.bld

        if bld.env['ENABLE_STATIC_NS3']:

            static_enabled = True

            shared_enabled = False

        if bld.env['ENABLE_SHARED_AND_STATIC_NS3']:

            static_enabled = True

            shared_enabled = True

        assert self.name.startswith("ns3-")

        name = self.name.split("ns3-")[1]

        if static_enabled:

            static = self._create_ns3_module(self.bld, name, self.dependencies, True)

            self.libs.append(static)

        else:

            static = None

        if shared_enabled:

            shared = self._create_ns3_module(self.bld, name, self.dependencies, False)

            self.libs.append(shared)

        else:

            shared = None

        if static is not None and shared is None:

            static.name = self.name + "--lib"

            static.uselib_local = ['ns3-%s--lib' % (dep,) for dep in self.dependencies]

        elif shared is not None and static is None:

            shared.name = self.name + "--lib"

            shared.uselib_local = ['ns3-%s--lib' % (dep,) for dep in self.dependencies]

        else:

            shared.name = self.name + "--lib"

            shared.uselib_local = ['ns3-%s--lib' % (dep,) for dep in self.dependencies]

            static.name = self.name + "--static"

            static.uselib_local = ['ns3-%s--static' % (dep,) for dep in self.dependencies]

        if not self.test:

            pcfile = bld.new_task_gen('ns3pcfile')

            pcfile.module = self

    def _create_ns3_module(self, bld, name, dependencies, static):

        # FIXME: env modifications are overwritten by parent caller

        # Create a separate library for this module.

        if static:

            module = bld.new_task_gen('cxx', 'cstaticlib')

        else:

            module = bld.new_task_gen('cxx', 'cshlib')

        module.source = self.source

        module.env = self.env.copy()

        features = list(self.features)

        features.remove("ns3module")

        module.features.extend(features)

        module.path = self.path

        module.uselib = self.uselib

        if hasattr(self, 'includes'):

            module.includes = self.includes

        if hasattr(self, "is_ns3_module"):

            module.is_ns3_module = self.is_ns3_module

        module.is_static = static

        module.vnum = wutils.VNUM

        # Add the proper path to the module's name.

        module.target = '%s/ns3-%s' % (bld.srcnode.relpath_gen(self.path), name)

        # Set the libraries this module depends on.  

        module.module_deps = list(dependencies)

        if not static:

            module.env.append_value('CXXFLAGS', module.env['shlib_CXXFLAGS'])

            module.env.append_value('CCFLAGS', module.env['shlib_CXXFLAGS'])

            # Turn on the link flags for shared libraries if we have the

            # proper compiler and platform.

            if module.env['CXX_NAME'] in ['gcc', 'icc'] and module.env['WL_SONAME_SUPPORTED']:

                # Get the module library name without any relative paths

                # at its beginning because all of the libraries will end

                # up in the same directory.

                module_library_name = os.path.basename(ccroot.get_target_name(module))

                module.env.append_value('LINKFLAGS', '-Wl,--soname=%s' % module_library_name)

        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('CCFLAGS', '-mcmodel=large')

        module.env.append_value('CXXDEFINES', "NS3_MODULE_COMPILATION")

        module.env.append_value('CCDEFINES', "NS3_MODULE_COMPILATION")

        module.install_path = "${LIBDIR}"

        return module

def create_ns3_module(bld, name, dependencies=(), test=False):

    module = bld.new_task_gen('ns3module')

    module.bld = bld

    module.name = "ns3-" + name

    module.dependencies = dependencies

    # Initially create an empty value for this because the pcfile

    # writing task assumes every module has a uselib attribute.

    module.uselib = ''

    module.uselib_local = ['ns3-' + dep for dep in dependencies]

    module.module_deps = list(dependencies)

    module.test = test

    module.is_ns3_module = True

    return module

def create_ns3_module_test_library(bld, name):

    # Create an ns3 module for the test library that depends only on

    # the module being tested.

    library_name = name + "-test"

    library = bld.create_ns3_module(library_name, [name], test = True)

    # Modify attributes for the test library that are different from a

    # normal module.

    del library.is_ns3_module

    library.is_ns3_module_test_library = True

    library.module_name = 'ns3-' + name

    # Add this module and test library to the list.

    bld.env.append_value('NS3_MODULES_WITH_TEST_LIBRARIES', (library.module_name, library.name))

    # Set the include path from the build directory to modules. 

    relative_path_from_build_to_here = bld.path.relpath_gen(bld.bldnode)

    include_flag = '-I' + relative_path_from_build_to_here

    library.env.append_value('CXXFLAGS', include_flag)

    library.env.append_value('CCFLAGS',  include_flag)

    return library

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 ns3_python_bindings(bld):

    # this method is called from a module wscript, so remember bld.path is not bindings/python!

    module_abs_src_path = bld.path.abspath()

    module = os.path.basename(module_abs_src_path)

    env = bld.env

    env.append_value("MODULAR_BINDINGS_MODULES", "ns3-"+module)

    if not env['ENABLE_PYTHON_BINDINGS']:

        return

    if env['BINDINGS_TYPE'] not in ('modular', 'both'):

        return

    bindings_dir = bld.path.find_dir("bindings")

    if bindings_dir is None or not os.path.exists(bindings_dir.abspath()):

        warnings.warn("(in %s) Requested to build modular python bindings, but apidefs dir not found "

                      "=> skipped the bindings." % str(bld.path),

                      Warning, stacklevel=2)

        return

    if ("ns3-%s" % (module,)) not in env.NS3_ENABLED_MODULES:

        #print "bindings for module %s which is not enabled, skip" % module

        return

    env.append_value('PYTHON_MODULES_BUILT', module)

    apidefs = env['PYTHON_BINDINGS_APIDEFS'].replace("-", "_")

    #debug = ('PYBINDGEN_DEBUG' in os.environ)

    debug = True # XXX

    source = [bld.srcnode.find_resource('bindings/python/ns3modulegen-modular.py').relpath_gen(bld.path),

              "bindings/modulegen__%s.py" % apidefs]

    if bindings_dir.find_resource("modulegen_customizations.py") is not None:

        source.append("bindings/modulegen_customizations.py")

    # the local customization file may or not exist

    if bld.path.find_resource("bindings/modulegen_local.py"):

        source.append("bindings/modulegen_local.py")

    module_py_name = module.replace('-', '_')

    module_target_dir = bld.srcnode.find_dir("bindings/python/ns").relpath_gen(bld.path)

    # if bindings/<module>.py exists, it becomes the module frontend, and the C extension befomes _<module>

    if bld.path.find_resource("bindings/%s.py" % (module_py_name,)) is not None:

        bld.new_task_gen(

            features='copy',

            source=("bindings/%s.py" % (module_py_name,)),

            target=('%s/%s.py' % (module_target_dir, module_py_name)))

        extension_name = '_%s' % (module_py_name,)

    else:

        extension_name = module_py_name

    target = ['bindings/ns3module.cc', 'bindings/ns3module.h', 'bindings/ns3modulegen.log']

    #if not debug:

    #    target.append('ns3modulegen.log')

    argv = ['NS3_ENABLED_FEATURES=${FEATURES}', '${PYTHON}']

    #if debug:

    #    argv.extend(["-m", "pdb"])

    argv.extend(['${SRC[0]}', module_abs_src_path, apidefs, extension_name, '${TGT[0]}'])

    argv.extend(['2>', '${TGT[2]}']) # 2> ns3modulegen.log

    features = []

    for (name, caption, was_enabled, reason_not_enabled) in env['NS3_OPTIONAL_FEATURES']:

        if was_enabled:

            features.append(name)

    bindgen = bld.new_task_gen('command', source=source, target=target, command=argv)

    bindgen.env['FEATURES'] = ','.join(features)

    bindgen.dep_vars = ['FEATURES']

    bindgen.before = 'cxx'

    bindgen.after = 'gen_ns3_module_header_task'

    bindgen.name = "pybindgen(ns3 module %s)" % module

    # generate the extension module

    pymod = bld.new_task_gen(features='cxx cshlib pyext')

    pymod.source = ['bindings/ns3module.cc']

    pymod.target = '%s/%s' % (module_target_dir, extension_name)

    pymod.name = 'ns3module_%s' % module

    pymod.uselib_local = ["%s--lib" % mod for mod in pymod.env['NS3_ENABLED_MODULES']] #  Should be '"ns3-"+module', but see bug 1117

    if pymod.env['ENABLE_STATIC_NS3']:

        if sys.platform == 'darwin':

            pymod.env.append_value('LINKFLAGS', '-Wl,-all_load')

            for mod in pymod.uselib_local:

                mod = mod.split("--lib")[0]

                pymod.env.append_value('LINKFLAGS', '-l' + mod)

        else:

            pymod.env.append_value('LINKFLAGS', '-Wl,--whole-archive,-Bstatic')

            for mod in pymod.uselib_local:

                mod = mod.split("--lib")[0]

                pymod.env.append_value('LINKFLAGS', '-l' + mod)

            pymod.env.append_value('LINKFLAGS', '-Wl,-Bdynamic,--no-whole-archive')

    defines = list(pymod.env['CXXDEFINES'])

    defines.extend(['NS_DEPRECATED=', 'NS3_DEPRECATED_H'])

    if Options.platform == 'win32':

        try:

            defines.remove('_DEBUG') # causes undefined symbols on win32

        except ValueError:

            pass

    pymod.env['CXXDEFINES'] = defines

    pymod.includes = 'bindings'

    return pymod

def build(bld):

    bld.create_ns3_module = types.MethodType(create_ns3_module, bld)

    bld.create_ns3_module_test_library = types.MethodType(create_ns3_module_test_library, bld)

    bld.create_obj = types.MethodType(create_obj, bld)

    bld.ns3_python_bindings = types.MethodType(ns3_python_bindings, bld)

    # Remove these modules from the list of all modules.

    for not_built in bld.env['MODULES_NOT_BUILT']:

        # XXX Becaue these modules are located in subdirectories of

        # test, their names in the all_modules list include the extra

        # relative path "test/".  If these modules are moved into the

        # src directory, then this if block should be removed.

        if not_built == 'ns3tcp' or not_built == 'ns3wifi':

            not_built = 'test/' + not_built

        if not_built in all_modules:

            all_modules.remove(not_built)

    bld.add_subdirs(list(all_modules))

    for module in all_modules:

        modheader = bld.new_task_gen('ns3moduleheader')

        modheader.module = module.split('/')[-1]

class ns3pcfile_task(Task.Task):

    after = 'cc cxx'

    def __str__(self):

        "string to display to the user"

        tgt_str = ' '.join([a.nice_path(self.env) for a in self.outputs])

        return 'pcfile: %s\n' % (tgt_str)

    def runnable_status(self):

        return super(ns3pcfile_task, self).runnable_status()

    def _self_libs(self, env, name, libdir):

        if env['ENABLE_STATIC_NS3']:

            path_st = 'STATICLIBPATH_ST'

            lib_st = 'STATICLIB_ST'

            lib_marker = 'STATICLIB_MARKER'

        else:

            path_st = 'LIBPATH_ST'

            lib_st = 'LIB_ST'

            lib_marker = 'SHLIB_MARKER'

        retval = [env[path_st] % libdir,

                  env[lib_marker],

                  env[lib_st] % name]

        return retval

    def _lib(self, env, dep):

        libpath = env['LIBPATH_%s' % dep]

        linkflags = env['LINKFLAGS_%s' % dep]

        libs = env['LIB_%s' % dep]

        retval = []

        for path in libpath:

            retval.append(env['LIBPATH_ST'] % path)

            retval = retval + linkflags

        for lib in libs:

            retval.append(env['LIB_ST'] % lib)

        return retval

    def _listify(self, v):

        if isinstance(v, list):

            return v

        else:

            return [v]

    def _cflags(self, dep):

        flags = self.env['CFLAGS_%s' % dep]

        return self._listify(flags)

    def _cxxflags(self, dep):

        return self._listify(self.env['CXXFLAGS_%s' % dep])

    def _defines(self, dep):

        defines = self.env['CCDEFINES_%s' % dep] + self.env['CXXDEFINES_%s' % dep]

        return [self.env['CCDEFINES_ST'] % define for define in self.env['CCDEFINES_%s' % dep]] + \

            [self.env['CXXDEFINES_ST'] % define for define in self.env['CXXDEFINES_%s' % dep]] 

    def _includes(self, dep):

        includes = self.env['CPPPATH_%s' % dep]

        return [self.env['CPPPATH_ST'] % include for include in includes]

    def _generate_pcfile(self, name, use, uselib_local, prefix, outfilename):

        outfile = open(outfilename, 'w')

        includedir = os.path.join(prefix, 'include')

        libdir = os.path.join(prefix, 'lib')

        libs = self._self_libs(self.env, name, '${libdir}')

        for dep in use:

            libs = libs + self._lib(self.env, dep)

        for dep in uselib_local:

            libs = libs + [self.env['LIB_ST'] % dep]

        cflags = [self.env['CPPPATH_ST'] % '${includedir}']

        for dep in use:

            cflags = cflags + self._cflags(dep) + self._cxxflags(dep) + \

                self._defines(dep) + self._includes(dep)

        print >> outfile, """

prefix=%s

libdir=%s

includedir=%s

Name: lib%s

Description: ns-3 module %s

Version: devel

Libs: %s

Cflags: %s

""" % (prefix, libdir, includedir,

       name, name, ' '.join(libs), ' '.join(cflags))

        outfile.close()

    def run(self):

        output_filename = self.outputs[0].bldpath(self.env)

        self._generate_pcfile(self.module.name, self.module.uselib, 

                              self.module.uselib_local,

                              self.env['PREFIX'], output_filename)

class ns3pcfile_taskgen(TaskGen.task_gen):

    def __init__(self, *args, **kwargs):

        super(ns3pcfile_taskgen, self).__init__(*args, **kwargs)

    def apply(self):

        output_filename = 'lib%s.pc' % self.module.name

        output_node = self.path.find_or_declare(output_filename)

        assert output_node is not None, str(self)

        task = self.create_task('ns3pcfile', env=self.env)

        self.bld.install_files(os.path.join('${PREFIX}', 'lib', 'pkgconfig'),

                               output_node)

        task.set_outputs([output_node])

        task.module = self.module

class ns3header_taskgen(TaskGen.task_gen):

    """A set of NS-3 header files"""

    COLOR = 'BLUE'

    def __init__(self, *args, **kwargs):