import re

from pybindgen.typehandlers import base as typehandlers

from pybindgen import ReturnValue, Parameter

from pybindgen.cppmethod import CustomCppMethodWrapper, CustomCppConstructorWrapper

from pybindgen.typehandlers.codesink import MemoryCodeSink

from pybindgen.typehandlers import ctypeparser

from pybindgen import cppclass, param, retval

import warnings

from pybindgen.typehandlers.base import CodeGenerationError

class ArgvParam(Parameter):

    """

    Converts a python list-of-strings argument to a pair of 'int argc,

    char *argv[]' arguments to pass into C.

    One Python argument becomes two C function arguments -> it's a miracle!

    Note: this parameter type handler is not registered by any name;

    must be used explicitly.

    """

    DIRECTIONS = [Parameter.DIRECTION_IN]

    CTYPES = []

    def convert_c_to_python(self, wrapper):

        raise NotImplementedError

    def convert_python_to_c(self, wrapper):

        py_name = wrapper.declarations.declare_variable('PyObject*', 'py_' + self.name)

        argc_var = wrapper.declarations.declare_variable('int', 'argc')

        name = wrapper.declarations.declare_variable('char**', self.name)

        idx = wrapper.declarations.declare_variable('Py_ssize_t', 'idx')

        wrapper.parse_params.add_parameter('O!', ['&PyList_Type', '&'+py_name], self.name)

        #wrapper.before_call.write_error_check('!PyList_Check(%s)' % py_name) # XXX

        wrapper.before_call.write_code("%s = (char **) malloc(sizeof(char*)*PyList_Size(%s));"

                                       % (name, py_name))

        wrapper.before_call.add_cleanup_code('free(%s);' % name)

        wrapper.before_call.write_code('''

for (%(idx)s = 0; %(idx)s < PyList_Size(%(py_name)s); %(idx)s++)

{

''' % vars())

        wrapper.before_call.sink.indent()

        wrapper.before_call.write_code('''

PyObject *item = PyList_GET_ITEM(%(py_name)s, %(idx)s);

''' % vars())

        #wrapper.before_call.write_error_check('item == NULL')

        wrapper.before_call.write_error_check(

            '!PyString_Check(item)',

            failure_cleanup=('PyErr_SetString(PyExc_TypeError, '

                             '"argument %s must be a list of strings");') % self.name)

        wrapper.before_call.write_code(

            '%s[%s] = PyString_AsString(item);' % (name, idx))

        wrapper.before_call.sink.unindent()

        wrapper.before_call.write_code('}')

        wrapper.before_call.write_code('%s = PyList_Size(%s);' % (argc_var, py_name))

        wrapper.call_params.append(argc_var)

        wrapper.call_params.append(name)

# def write_preamble(out):

#     pybindgen.write_preamble(out)

#     out.writeln("#include \"ns3/everything.h\"")

def Simulator_customizations(module):

    Simulator = module['ns3::Simulator']

    ## Simulator::Schedule(delay, callback, ...user..args...)

    Simulator.add_custom_method_wrapper("Schedule", "_wrap_Simulator_Schedule",

                                        flags=["METH_VARARGS", "METH_KEYWORDS", "METH_STATIC"])

    ## Simulator::ScheduleNow(callback, ...user..args...)

    Simulator.add_custom_method_wrapper("ScheduleNow", "_wrap_Simulator_ScheduleNow",

                                        flags=["METH_VARARGS", "METH_KEYWORDS", "METH_STATIC"])

    ## Simulator::ScheduleDestroy(callback, ...user..args...)

    Simulator.add_custom_method_wrapper("ScheduleDestroy", "_wrap_Simulator_ScheduleDestroy",

                                        flags=["METH_VARARGS", "METH_KEYWORDS", "METH_STATIC"])

    Simulator.add_custom_method_wrapper("Run", "_wrap_Simulator_Run",

                                        flags=["METH_VARARGS", "METH_KEYWORDS", "METH_STATIC"])

def CommandLine_customizations(module):

    CommandLine = module['ns3::CommandLine']

    CommandLine.add_method('Parse', None, [ArgvParam(None, 'argv')],

                           is_static=False)

    CommandLine.add_custom_method_wrapper("AddValue", "_wrap_CommandLine_AddValue",

                                          flags=["METH_VARARGS", "METH_KEYWORDS"])

# def Object_customizations(module):

#     ## ---------------------------------------------------------------------

#     ## Here we generate custom constructor code for all classes that

#     ## derive from ns3::Object.  The custom constructors are needed in

#     ## order to support kwargs only and to translate kwargs into ns3

#     ## attributes, etc.

#     ## ---------------------------------------------------------------------

#     Object = module['ns3::Object']

#     ## add a GetTypeId method to all generatd helper classes

#     def helper_class_hook(helper_class):

#         decl = """

# static ns3::TypeId GetTypeId (void)

# {

#   static ns3::TypeId tid = ns3::TypeId ("%s")

#     .SetParent< %s > ()

#     ;

#   return tid;

# }"""  % (helper_class.name, helper_class.class_.full_name)

#         helper_class.add_custom_method(decl)

#         helper_class.add_post_generation_code(

#             "NS_OBJECT_ENSURE_REGISTERED (%s);" % helper_class.name)

#     Object.add_helper_class_hook(helper_class_hook)

#     def ns3_object_instance_creation_function(cpp_class, code_block, lvalue,

#                                               parameters, construct_type_name):

#         assert lvalue

#         assert not lvalue.startswith('None')

#         if cpp_class.cannot_be_constructed:

#             raise CodeGenerationError("%s cannot be constructed (%s)"

#                                       % cpp_class.full_name)

#         if cpp_class.incomplete_type:

#             raise CodeGenerationError("%s cannot be constructed (incomplete type)"

#                                       % cpp_class.full_name)

#         code_block.write_code("%s = new %s(%s);" % (lvalue, construct_type_name, parameters))

#         code_block.write_code("%s->Ref ();" % (lvalue))

#     def ns3_object_post_instance_creation_function(cpp_class, code_block, lvalue,

#                                                    parameters, construct_type_name):

#         code_block.write_code("ns3::CompleteConstruct(%s);" % (lvalue, ))

#     Object.set_instance_creation_function(ns3_object_instance_creation_function)

#     Object.set_post_instance_creation_function(ns3_object_post_instance_creation_function)

# def Attribute_customizations(module):

#     # Fix up for the "const AttributeValue &v = EmptyAttribute()"

#     # case, as used extensively by helper classes.

#     # Here's why we need to do this: pybindgen.gccxmlscanner, when

#     # scanning parameter default values, is only provided with the

#     # value as a simple C expression string.  (py)gccxml does not

#     # report the type of the default value.

#     # As a workaround, here we iterate over all parameters of all

#     # methods of all classes and tell pybindgen what is the type of

#     # the default value for attributes.

#     for cls in module.classes:

#         for meth in cls.get_all_methods():

#             for param in meth.parameters:

#                 if isinstance(param, cppclass.CppClassRefParameter):

#                     if param.cpp_class.name == 'AttributeValue' \

#                             and param.default_value is not None \

#                             and param.default_value_type is None:

#                         param.default_value_type = 'ns3::EmptyAttributeValue'

def TypeId_customizations(module):

    TypeId = module['ns3::TypeId']

    TypeId.add_custom_method_wrapper("LookupByNameFailSafe", "_wrap_TypeId_LookupByNameFailSafe",

                                     flags=["METH_VARARGS", "METH_KEYWORDS", "METH_STATIC"])

def add_std_ofstream(module):

    module.add_include('<fstream>')

    ostream = module.add_class('ostream', foreign_cpp_namespace='::std')

    ostream.set_cannot_be_constructed("abstract base class")

    ofstream = module.add_class('ofstream', foreign_cpp_namespace='::std', parent=ostream)

    ofstream.add_enum('openmode', [

            ('app', 'std::ios_base::app'),

            ('ate', 'std::ios_base::ate'),

            ('binary', 'std::ios_base::binary'),

            ('in', 'std::ios_base::in'),

            ('out', 'std::ios_base::out'),

            ('trunc', 'std::ios_base::trunc'),

            ])

    ofstream.add_constructor([Parameter.new("const char *", 'filename'),

                              Parameter.new("::std::ofstream::openmode", 'mode', default_value="std::ios_base::out")])

    ofstream.add_method('close', None, [])

    import pybindgen.typehandlers.base

    for alias in "std::_Ios_Openmode", "std::ios::openmode":

        pybindgen.typehandlers.base.param_type_matcher.add_type_alias(alias, "int")

    for flag in 'in', 'out', 'ate', 'app', 'trunc', 'binary':

        module.after_init.write_code('PyModule_AddIntConstant(m, (char *) "STD_IOS_%s", std::ios::%s);'

                                     % (flag.upper(), flag))

def add_ipv4_address_tp_hash(module):

    module.body.writeln('''

long

_ns3_Ipv4Address_tp_hash (PyObject *obj)

{

   PyNs3Ipv4Address *addr = reinterpret_cast<PyNs3Ipv4Address *> (obj);

   return static_cast<long> (ns3::Ipv4AddressHash () (*addr->obj));

}

''')

    module.header.writeln('long _ns3_Ipv4Address_tp_hash (PyObject *obj);')

    module['Ipv4Address'].pytype.slots['tp_hash'] = "_ns3_Ipv4Address_tp_hash"

def add_scalar_operators(root_module):

    # Scalar implicitly converts to Time, but pybindgen gccxml parser

    # cannot pick up operators supported through implicit conversions,

    # so we add them manually here.

    cls = root_module['ns3::Scalar']

    cls.add_binary_numeric_operator('*', root_module['ns3::Scalar'], root_module['ns3::Scalar'], param('ns3::Scalar const &', 'right'))

    cls.add_binary_numeric_operator('+', root_module['ns3::Scalar'], root_module['ns3::Scalar'], param('ns3::Scalar const &', 'right'))

    cls.add_binary_numeric_operator('-', root_module['ns3::Scalar'], root_module['ns3::Scalar'], param('ns3::Scalar const &', 'right'))

    cls.add_binary_numeric_operator('/', root_module['ns3::Scalar'], root_module['ns3::Scalar'], param('ns3::Scalar const &', 'right'))

    cls.add_binary_numeric_operator('*', root_module['ns3::Time'], root_module['ns3::Scalar'], param('ns3::Time const &', 'right'))

    cls.add_binary_numeric_operator('-', root_module['ns3::Time'], root_module['ns3::Scalar'], param('ns3::Time const &', 'right'))

    root_module['ns3::Time'].add_binary_numeric_operator(

        '*', root_module['ns3::Time'], root_module['ns3::Time'], param('ns3::Scalar const &', 'right'))

    root_module['ns3::Time'].add_binary_numeric_operator(

        '-', root_module['ns3::Time'], root_module['ns3::Time'], param('ns3::Scalar const &', 'right'))

    cls.add_binary_comparison_operator('<')

    cls.add_binary_comparison_operator('>')

    cls.add_binary_comparison_operator('!=')

    cls.add_output_stream_operator()

    cls.add_binary_comparison_operator('<=')

    cls.add_binary_comparison_operator('==')

    cls.add_binary_comparison_operator('>=')

def post_register_types(root_module):

    Simulator_customizations(root_module)

    CommandLine_customizations(root_module)

    TypeId_customizations(root_module)

    add_std_ofstream(root_module)

    add_scalar_operators(root_module)

# these are already in the main script, so commented out here

# Object_customizations(root_module)

# Attribute_customizations(root_module)

#def post_register_functions(root_module):

#    pass