from pybindgen import Module, FileCodeSink, param, retval, cppclass, typehandlers

from pybindgen.typehandlers.smart_ptr import StdSharedPtr

from ns3_ptr import Ns3PtrMemoryPolicy

import pybindgen.settings
import warnings

import sys

def module_init():
    root_module = Module('ns.ndnSIM', cpp_namespace='::ns3')
    return root_module

def register_types(module):
    module.add_class('ObjectBase', allow_subclassing=True, import_from_module='ns.core')
    module.add_class('SimpleRefCount', automatic_type_narrowing=True, import_from_module='ns.core',
                     template_parameters=['ns3::Object', 'ns3::ObjectBase', 'ns3::ObjectDeleter'],
                     parent=module['ns3::ObjectBase'],
                     memory_policy=cppclass.ReferenceCountingMethodsPolicy(incref_method='Ref', decref_method='Unref', peekref_method='GetReferenceCount'))
    module.add_class('Object', import_from_module='ns.core', parent=module['ns3::SimpleRefCount< ns3::Object, ns3::ObjectBase, ns3::ObjectDeleter >'])

    module.add_class('TypeId', import_from_module='ns.core')
    module.add_class('AttributeValue', import_from_module='ns.core')

    module.add_class('NodeContainer', import_from_module='ns.network')
    module.add_class('Node', import_from_module='ns.network', parent=module['ns3::Object'])
    module.add_class('ApplicationContainer', import_from_module='ns.network')

    def reg_ndn(module):
        module.add_class('StackHelper')
        module.add_class('FibHelper')
        module.add_class('StrategyChoiceHelper')
        module.add_class('AppHelper')
        module.add_class('GlobalRoutingHelper')

        module.add_class('L3Protocol', parent=module.get_root()['ns3::Object'])

        module.add_class('Name')
        module.add_class('Interest')
        module.add_class('Data')
        module.add_class('Face', memory_policy=StdSharedPtr('ns3::ndn::Face'))
        module.add_class('FaceContainer', memory_policy=Ns3PtrMemoryPolicy('::ns3::ndn::FaceContainer'))

        def reg_name(module):
            module.add_class('Component')
        reg_name(module.add_cpp_namespace('name'))

        def reg_nfd(module):
            module.add_class('Forwarder', memory_policy=StdSharedPtr('::ns3::ndn::nfd::Forwarder'), is_singleton=True)
            module.add_class('Fib')
            module.add_class('Pit')
            module.add_class('Cs')

            def reg_fib(module):
                module.add_class('Entry')#, memory_policy=StdSharedPtr('ns3::ndn::nfd::fib::Entry'))
                module.add_class('NextHop')
                module.add_class('NextHopList')
            reg_fib(module.add_cpp_namespace('fib'))

            def reg_pit(module):
                module.add_class('Entry')#, memory_policy=StdSharedPtr('ns3::ndn::nfd::pit::Entry'))
            reg_pit(module.add_cpp_namespace('pit'))

            def reg_cs(module):
                module.add_class('Entry')#, memory_policy=StdSharedPtr('ns3::ndn::nfd::cs::Entry'))
            reg_cs(module.add_cpp_namespace('cs'))

        reg_nfd(module.add_cpp_namespace('nfd'))
    reg_ndn(module.add_cpp_namespace('ndn'))

def register_methods(root_module):
    reg_other_modules(root_module)

    def reg_stackhelper(cls):
        cls.add_constructor([])

        cls.add_method('Install', 'ns3::Ptr<ns3::ndn::FaceContainer>', [param('ns3::Ptr<ns3::Node>', 'node')], is_const=True)
        cls.add_method('Install', 'ns3::Ptr<ns3::ndn::FaceContainer>', [param('std::string const&', 'nodeName')], is_const=True)
        cls.add_method('Install', 'ns3::Ptr<ns3::ndn::FaceContainer>', [param('const ns3::NodeContainer&', 'c')], is_const=True)
        cls.add_method('InstallAll', 'ns3::Ptr<ns3::ndn::FaceContainer>', [], is_const=True)

        cls.add_method('SetDefaultRoutes', retval('void'), [param('bool', 'isEnabled', default_value='true')], is_const=True)
        cls.add_method('SetStackAttributes',
                       retval('void'),
                       [param('const std::string&', 'attr1', default_value='""'), param('const std::string&', 'value1', default_value='""'),
                        param('const std::string&', 'attr2', default_value='""'), param('const std::string&', 'value2', default_value='""'),
                        param('const std::string&', 'attr3', default_value='""'), param('const std::string&', 'value3', default_value='""'),
                        param('const std::string&', 'attr4', default_value='""'), param('const std::string&', 'value4', default_value='""')])

        cls.add_method('setCsSize', retval('void'), [param('size_t', 'maxSize')])
        cls.add_method('SetOldContentStore',
                       retval('void'),
                       [param('const std::string&', 'contentStoreClass'),
                        param('const std::string&', 'attr1', default_value='""'), param('const std::string&', 'value1', default_value='""'),
                        param('const std::string&', 'attr2', default_value='""'), param('const std::string&', 'value2', default_value='""'),
                        param('const std::string&', 'attr3', default_value='""'), param('const std::string&', 'value3', default_value='""'),
                        param('const std::string&', 'attr4', default_value='""'), param('const std::string&', 'value4', default_value='""')])
    reg_stackhelper(root_module['ns3::ndn::StackHelper'])

    def reg_fibhelper(cls):
        cls.add_method('AddRoute', retval('void'), [
            param('const std::string&', 'nodeName'), param('const std::string&', 'prefix'),
            param('uint32_t', 'faceId'), param('int32_t', 'metric'),
            ], is_const=True, is_static=True)
        cls.add_method('AddRoute', retval('void'), [
            param('ns3::Ptr<ns3::Node>', 'node'), param('const ns3::ndn::Name&', 'prefix'),
            param('uint32_t', 'faceId'), param('int32_t', 'metric')
            ], is_const=True, is_static=True)
        cls.add_method('AddRoute', retval('void'), [
            param('ns3::Ptr<ns3::Node>', 'node'), param('const ns3::ndn::Name&', 'prefix'),
            param('std::shared_ptr<ns3::ndn::Face>', 'face'),
            param('int32_t', 'metric'),
            ], is_const=True, is_static=True)
        cls.add_method('AddRoute', retval('void'), [
            param('ns3::Ptr<ns3::Node>', 'node'), param('const ns3::ndn::Name&', 'prefix'),
            param('ns3::Ptr<ns3::Node>', 'otherNode'),
            param('int32_t', 'metric'),
            ], is_const=True, is_static=True)
        cls.add_method('AddRoute', retval('void'), [
            param('const std::string&', 'nodeName'), param('const std::string&', 'prefix'),
            param('const std::string&', 'otherNodeName'),
            param('int32_t', 'metric'),
            ], is_const=True, is_static=True)
    reg_fibhelper(root_module['ns3::ndn::FibHelper'])

    def reg_strategychoicehelper(cls):
        cls.add_method('Install', retval('void'), [param('ns3::Ptr<ns3::Node>', 'node'),
                                                   param('const const std::string&', 'name'),
                                                   param('const const std::string&', 'strategy')], is_const=True, is_static=True)
        cls.add_method('Install', retval('void'), [param('const ns3::NodeContainer&', 'c'),
                                                   param('const const std::string&', 'name'),
                                                   param('const const std::string&', 'strategy')], is_const=True, is_static=True)
        cls.add_method('InstallAll', retval('void'), [param('const std::string&', 'name'),
                                                      param('const std::string&', 'strategy')], is_const=True, is_static=True)
    reg_strategychoicehelper(root_module['ns3::ndn::StrategyChoiceHelper'])

    def reg_apphelper(cls):
        cls.add_constructor([param('const std::string&', 'prefix')])
        cls.add_method('SetPrefix', 'void', [param('const std::string&', 'prefix')])
        cls.add_method('SetAttribute', 'void', [param('std::string', 'name'), param('const ns3::AttributeValue&', 'value')])
        cls.add_method('Install', 'ns3::ApplicationContainer', [param('ns3::NodeContainer', 'c')])
        cls.add_method('Install', 'ns3::ApplicationContainer', [param('ns3::Ptr<ns3::Node>', 'node')])
        cls.add_method('Install', 'ns3::ApplicationContainer', [param('std::string', 'nodeName')])
    reg_apphelper(root_module['ns3::ndn::AppHelper'])

    def reg_GlobalRoutingHelper(cls):
        cls.add_constructor([])
        cls.add_method('Install', 'void', [param('ns3::Ptr<ns3::Node>', 'node')])
        cls.add_method('Install', 'void', [param('const ns3::NodeContainer&', 'nodes')])
        cls.add_method('InstallAll', 'void', [])
        cls.add_method('AddOrigin', 'void', [param('const std::string&', 'prefix'), param('ns3::Ptr<ns3::Node>', 'node')])
        cls.add_method('AddOrigin', 'void', [param('const std::string&', 'prefix'), param('const std::string&', 'nodeName')])
        cls.add_method('AddOrigins', 'void', [param('const std::string&', 'prefix'), param('const ns3::NodeContainer&', 'nodes')])
        cls.add_method('AddOriginsForAll', 'void', [])
        cls.add_method('CalculateRoutes', 'void', [])
        cls.add_method('CalculateAllPossibleRoutes', 'void', [])
    reg_GlobalRoutingHelper(root_module['ns3::ndn::GlobalRoutingHelper'])

    def reg_Name(root_module, cls):
        cls.add_output_stream_operator()
        for op in ['==', '!=', '<', '<=', '>', '>=']:
            cls.add_binary_comparison_operator(op)
        cls.add_container_traits(retval('const ns3::ndn::name::Component&'),
                                 begin_method='begin', end_method='end', iterator_type='const_iterator')

        cls.add_constructor([])
        cls.add_constructor([param('const ns3::ndn::Name&', 'other')])
        cls.add_constructor([param('const std::string&', 'url')])
        cls.add_method('append', 'ns3::ndn::Name &', [param('const ns3::ndn::name::Component&', 'comp')])
        cls.add_method('get', 'const ns3::ndn::name::Component&', [param('int', 'index')], is_const=True)
        cls.add_method('getPrefix', 'ns3::ndn::Name', [param('size_t', 'len')], is_const=True)
        cls.add_method('size', 'size_t', [], is_const=True)
        cls.add_method('toUri', retval('std::string'), [], is_const=True)
    reg_Name(root_module, root_module['ns3::ndn::Name'])

    def reg_NameComponent(cls):
        cls.add_output_stream_operator()
        for op in ['==', '!=', '<', '<=', '>', '>=']:
            cls.add_binary_comparison_operator(op)

        cls.add_constructor([param('const ns3::ndn::name::Component&', 'arg0')])
        cls.add_constructor([])
        cls.add_method('fromNumber', 'ns3::ndn::name::Component', [param('uint64_t', 'number')])
        cls.add_method('fromNumberWithMarker', 'ns3::ndn::name::Component', [param('uint64_t', 'number'), param('unsigned char', 'marker')])
        cls.add_method('fromEscapedString', 'ns3::ndn::name::Component', [param('const std::string&', 'uri')])
    reg_NameComponent(root_module['ns3::ndn::name::Component'])

    def reg_Interest(cls):
        cls.add_output_stream_operator()

        cls.add_constructor([param('const ns3::ndn::Interest&', 'interest')])
        cls.add_constructor([])
    reg_Interest(root_module['ns3::ndn::Interest'])

    def reg_Data(cls):
        cls.add_output_stream_operator()

        cls.add_constructor([param('const ns3::ndn::Data&', 'data')])
        cls.add_constructor([])
    reg_Data(root_module['ns3::ndn::Data'])

    #########################################################################################
    ## Interface to NFD
    #########################################################################################

    def register_L3Protocol(cls):
        cls.add_method('getL3Protocol', 'ns3::Ptr<ns3::ndn::L3Protocol>', [param('ns3::Ptr<ns3::Object>', 'node')], is_static=True)
        cls.add_method('getForwarder', 'std::shared_ptr<ns3::ndn::nfd::Forwarder>', [])
    register_L3Protocol(root_module['ns3::ndn::L3Protocol'])

    def reg_Face(cls):
        cls.add_output_stream_operator()
        cls.add_method('getId', retval('int64_t'), [], is_const=True)
    reg_Face(root_module['ns3::ndn::Face'])

    def reg_NfdForwarder(cls):
        cls.add_method('getFib', retval('const ns3::ndn::nfd::Fib&', caller_manages_return=False), [], is_const=True)
        cls.add_method('getPit', retval('const ns3::ndn::nfd::Pit&', caller_manages_return=False), [], is_const=True)
        cls.add_method('getCs', retval('const ns3::ndn::nfd::Cs&', caller_manages_return=False), [], is_const=True)
    reg_NfdForwarder(root_module['ns3::ndn::nfd::Forwarder'])

    #############
    #### FIB ####
    def reg_NfdFib(root_module, cls):
        cls.add_method('size', retval('size_t'), [], is_const=True)
        cls.add_container_traits(retval('const ns3::ndn::nfd::fib::Entry&', caller_manages_return=False),
                                 begin_method='begin', end_method='end', iterator_type='const_iterator')

        # The following is not supported
        # cls.add_method('findLongestPrefixMatch', retval('std::shared_ptr<ns3::ndn::nfd::fib::Entry>'),
        #                [param('const ns3::ndn::Name&', 'prefix')], is_const=True)
        # cls.add_method('findExactMatch', retval('std::shared_ptr<ns3::ndn::nfd::fib::Entry>'),
        #                [param('const ns3::ndn::Name&', 'prefix')], is_const=True)
        # cls.add_method('findLongestPrefixMatch', retval('shared_ptr<ns3::ndn::nfd::fib::Entry>'),
        #                [param('const pit::Entry&', 'pitEntry')], is_const=True)
        # cls.add_method('findLongestPrefixMatch', retval('shared_ptr<ns3::ndn::nfd::fib::Entry>'),
        #                [param('const measurements::Entry&', 'measurementsEntry')], is_const=True)

        # cls.add_method('insert', retval('std::pair<std::shared_ptr<ns3::ndn::nfd::fib::Entry>, bool>'), [param('const ns3::ndn::Name&', 'prefix')])
        cls.add_method('erase', retval('void'), [param('const ns3::ndn::Name&', 'prefix')])
        cls.add_method('erase', retval('void'), [param('const ns3::ndn::nfd::fib::Entry&', 'entry')])
        # cls.add_method('removeNextHopFromAllEntries', retval('void'), [param('std::shared_ptr<ns3::ndn::Face>', 'face')])

        def reg_Entry(cls):
            cls.add_method('getPrefix', 'const ns3::ndn::Name&', [], is_const=True)
            cls.add_method('getNextHops', retval('const ns3::ndn::nfd::fib::NextHopList&', caller_manages_return=False), [], is_const=True)
            cls.add_method('hasNextHops', 'bool', [], is_const=True)
        reg_Entry(root_module['ns3::ndn::nfd::fib::Entry'])

        def reg_NextHop(cls):
            cls.add_constructor([param('const ns3::ndn::Face&', 'face')])

            cls.add_function_as_method('getFaceFromFibNextHop', 'std::shared_ptr<ns3::ndn::Face>',
                                       [param('const ns3::ndn::nfd::fib::NextHop&', 'obj')],
                                       custom_name='getFace')
            cls.add_method('setCost', 'void', [param('uint64_t', 'cost')])
            cls.add_method('getCost', 'uint64_t', [], is_const=True)
        reg_NextHop(root_module['ns3::ndn::nfd::fib::NextHop'])

        def reg_NextHopList(cls):
            cls.add_method('size', retval('size_t'), [], is_const=True)
            cls.add_container_traits(retval('const ns3::ndn::nfd::fib::NextHop&', caller_manages_return=False),
                                     begin_method='begin', end_method='end', iterator_type='const_iterator')
        reg_NextHopList(root_module['ns3::ndn::nfd::fib::NextHopList'])
    reg_NfdFib(root_module, root_module['ns3::ndn::nfd::Fib'])
    #### FIB ####
    #############

    #############
    #### PIT ####
    def reg_NfdPit(root_module, cls):
        cls.add_method('size', retval('size_t'), [], is_const=True)
        cls.add_container_traits(retval('const ns3::ndn::nfd::pit::Entry&', caller_manages_return=False),
                                 begin_method='begin', end_method='end', iterator_type='const_iterator')

        def reg_Entry(cls):
            cls.add_method('getInterest', retval('const ns3::ndn::Interest&'), [], is_const=True)
            cls.add_method('getName', retval('const ns3::ndn::Name&'), [], is_const=True)
        reg_Entry(root_module['ns3::ndn::nfd::pit::Entry'])
    reg_NfdPit(root_module, root_module['ns3::ndn::nfd::Pit'])
    #### PIT ####
    #############

    #############
    #### CS ####
    def reg_NfdCs(root_module, cls):
        cls.add_method('size', retval('size_t'), [], is_const=True)
        cls.add_container_traits(retval('const ns3::ndn::nfd::cs::Entry&', caller_manages_return=False),
                                 begin_method='begin', end_method='end', iterator_type='const_iterator')

        def reg_Entry(cls):
            cls.add_method('getName', retval('const ns3::ndn::Name&'), [], is_const=True)
        reg_Entry(root_module['ns3::ndn::nfd::cs::Entry'])
    reg_NfdCs(root_module, root_module['ns3::ndn::nfd::Cs'])
    #### CS ####
    #############

def reg_other_modules(root_module):
    def reg_ApplicationContainer(cls):
        cls.add_constructor([])
        cls.add_constructor([param('ns3::ApplicationContainer', 'container')])
    reg_ApplicationContainer(root_module['ns3::ApplicationContainer'])

def register_functions(root_module):
    return

def main():
    out = FileCodeSink(sys.stdout)
    root_module = module_init()
    register_types(root_module)
    register_methods(root_module)
    register_functions(root_module)
    root_module.generate(out)

if __name__ == '__main__':
    main()