#include "ns3/everything.h"

#include TYPEID_LIST_PATH

    typeid_list_path = bld.path.find_or_declare("typeid-list.cc").abspath(bld.env)

    core.env.append_value("CXXDEFINES", r"TYPEID_LIST_PATH=\"%s\"" % (typeid_list_path.replace('\\', '\\\\')))

import re

    bld.new_task_gen('all_ns3_headers')

    bld.new_task_gen('gen_typeid_list')

class gen_typeid_list_task(Task.Task):

    before = 'cc cxx'

    after = 'ns3header_task gen_everything_h_task'

    color = 'BLUE'

    def run(self):

        assert len(self.outputs) == 1

        rx = re.compile(r"class\s+(\w+)\s*:\s*public\s+(\w+)(?:\s*// namespace ([a-zA-Z:]+))?")

        inheritance_tree = {} # class_name => parent_class_name

        for header in [node.abspath(self.env) for node in self.inputs]:

            for line in open(header, "rt"):

                match = rx.match(line)

                if match is not None:

                    if match.group(3):

                        name = '::'.join([match.group(3), match.group(1)])

                    else:

                        name = match.group(1)

                    inheritance_tree[name] = match.group(2)

        outfile = file(self.outputs[0].bldpath(self.env), "wt")

        outfile.write("""

static struct GlobalTypeIdRegistrationClass

{

  GlobalTypeIdRegistrationClass ()

  {

""")

        #print inheritance_tree

        def get_root_class(cls):

            parent = cls

            while 1:

                try:

                    parent = inheritance_tree[parent]

                except KeyError:

                    break

            return parent

        num = 0

        for cls in inheritance_tree.iterkeys():

            root = get_root_class(cls)

            if root in ['ObjectBase']:

                num += 1

                outfile.write("""

    TypeId tid%i = %s::GetTypeId (); tid%i.GetParent ();

""" % (num, cls, num))

        outfile.write("""

  }

} g_globalTypeIdRegistrationVariable;

""")

        outfile.close()

        return 0

class gen_typeid_list_taskgen(TaskGen.task_gen):

    """Generates a 'typeid-list.cc' header file that registers all known typeids.

    """

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

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

        self.install_path = None

        #self.inst_dir = 'ns3'

    def apply(self):

        ## get all of the ns3 headers

        ns3_dir_node = Build.bld.path.find_dir("ns3")

        all_headers_inputs = []

        for filename in self.to_list(self.source):

            src_node = ns3_dir_node.find_or_declare(filename)

            if src_node is None:

                raise Utils.WafError("source ns3 header file %s not found" % (filename,))

            all_headers_inputs.append(src_node)

        ## if self.source was empty, include all ns3 headers in enabled modules

        if not all_headers_inputs:

            for ns3headers in Build.bld.all_task_gen:

                if type(ns3headers).__name__ == 'ns3header_taskgen': # XXX: find less hackish way to compare

                    ## skip headers not part of enabled modules

                    if self.env['NS3_ENABLED_MODULES']:

                        if ("ns3-%s" % ns3headers.module) not in self.env['NS3_ENABLED_MODULES']:

                            continue

                    for source in ns3headers.to_list(ns3headers.source):

                        #source = os.path.basename(source)

                        node = ns3_dir_node.find_or_declare(source)

                        if node is None:

                            raise Utils.WafError("missing header file %s" % (source,))

                        all_headers_inputs.append(node)

        assert all_headers_inputs

        outputs = [self.path.find_dir("core").find_or_declare("typeid-list.cc")]

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

        task.set_inputs(all_headers_inputs)

        task.set_outputs(outputs)

    def install(self):

        pass

prio_headers = {

    -2: (

        "string.h", # work around http://www.gccxml.org/Bug/view.php?id=6682

        ),

    -1: (

        "propagation-delay-model.h",

        "propagation-loss-model.h",

        "net-device.h",

        )

     }

def get_header_prio(header):

    for prio, headers in prio_headers.iteritems():

        if header in headers:

            return prio

    return 1

def calc_header_include(path):

    (head, tail) = os.path.split (path)

    if tail == 'ns3':

        return ''

    else:

        return os.path.join (calc_header_include (head), tail)

class gen_everything_h_task(Task.Task):

    before = 'cc cxx'

    after = 'ns3header_task'

    color = 'BLUE'

    def run(self):

        assert len(self.outputs) == 1

        header_files = [calc_header_include(node.abspath(self.env)) for node in self.inputs]

        outfile = file(self.outputs[0].bldpath(self.env), "w")

        def sort_func(h1, h2):

            return cmp((get_header_prio(h1), h1), (get_header_prio(h1), h2))

        header_files.sort(sort_func)

        print >> outfile, """

/* http://www.nsnam.org/bugzilla/show_bug.cgi?id=413 */

#ifdef ECHO

# undef ECHO

#endif

    """

        for header in header_files:

            print >> outfile, "#include \"ns3/%s\"" % (header,)

        print >> outfile, """

namespace ns3 {

static inline Ptr<Object>

__dummy_function_to_force_template_instantiation (Ptr<Object> obj, TypeId typeId)

{

   return obj->GetObject<Object> (typeId);

}

static inline void

__dummy_function_to_force_template_instantiation_v2 ()

{

   Time t1, t2, t3;

   t1 = t2 + t3;

   t1 = t2 - t3;

   TimeSquare tsq = t2*t3;

   Time tsqdiv = tsq/Seconds(1);

   Scalar scal = t2/t3;

   TimeInvert inv = scal/t3;

   t1 = scal*t1;

   t1 = t1/scal;

   t1 < t2;

   t1 <= t2;

   t1 == t2;

   t1 != t2;

   t1 >= t2;

   t1 > t2;

}

}

"""

        outfile.close()

        return 0

class all_ns3_headers_taskgen(TaskGen.task_gen):

    """Generates a 'everything.h' header file that includes some/all public ns3 headers.

    """

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

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

        self.install_path = None

        #self.inst_dir = 'ns3'

    def apply(self):

        ## get all of the ns3 headers

        ns3_dir_node = Build.bld.path.find_dir("ns3")

        all_headers_inputs = []

        for filename in self.to_list(self.source):

            src_node = ns3_dir_node.find_or_declare(filename)

            if src_node is None:

                raise Utils.WafError("source ns3 header file %s not found" % (filename,))

            all_headers_inputs.append(src_node)

        ## if self.source was empty, include all ns3 headers in enabled modules

        if not all_headers_inputs:

            for ns3headers in Build.bld.all_task_gen:

                if type(ns3headers).__name__ == 'ns3header_taskgen': # XXX: find less hackish way to compare

                    ## skip headers not part of enabled modules

                    if self.env['NS3_ENABLED_MODULES']:

                        if ("ns3-%s" % ns3headers.module) not in self.env['NS3_ENABLED_MODULES']:

                            continue

                    for source in ns3headers.to_list(ns3headers.source):

                        #source = os.path.basename(source)

                        node = ns3_dir_node.find_or_declare(source)

                        if node is None:

                            raise Utils.WafError("missing header file %s" % (source,))

                        all_headers_inputs.append(node)

        assert all_headers_inputs

        all_headers_outputs = [Build.bld.path.find_dir('ns3').find_or_declare("everything.h")]

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

        task.set_inputs(all_headers_inputs)

        task.set_outputs(all_headers_outputs)

    def install(self):

        pass

    opt.add_option('--enable-static',

                   help=('Compile NS-3 statically'),

                   dest='enable_static', action='store_true',

                   default=False)

    conf.env['ENABLE_STATIC_NS3'] = Options.options.enable_static

    #program.add_objects = 'ns3'