import sys

from mpi.module import *

tmpl_file_start = """\
#include "moo-lua-api-util.h"

"""

tmpl_cfunc_method_start = """\
static int
%(cfunc)s (gpointer pself, G_GNUC_UNUSED lua_State *L, G_GNUC_UNUSED int first_arg)
{
    %(Class)s *self = (%(Class)s*) pself;
"""

tmpl_cfunc_func_start = """\
static int
%(cfunc)s (G_GNUC_UNUSED lua_State *L)
{
"""

tmpl_register_module_start = """\
void
%(module)s_lua_api_register (void)
{
    static gboolean been_here = FALSE;

    if (been_here)
        return;

    been_here = TRUE;

"""

tmpl_register_one_type_start = """\
    MooLuaMethodEntry methods_%(Class)s[] = {
"""
tmpl_register_one_type_end = """\
        { NULL, NULL }
    };
    moo_lua_register_methods (%(gtype_id)s, methods_%(Class)s);

"""

class ArgHelper(object):
    def format_arg(self, allow_none, default_value, arg_name, arg_idx, param_name):
        return ''

class SimpleArgHelper(ArgHelper):
    def __init__(self, name, suffix):
        super(SimpleArgHelper, self).__init__()
        self.name = name
        self.suffix = suffix

    def format_arg(self, allow_none, default_value, arg_name, arg_idx, param_name):
        dic = dict(type=self.name, arg_name=arg_name, default_value=default_value,
                   arg_idx=arg_idx, param_name=param_name, suffix=self.suffix)
        if default_value is not None:
            return '%(type)s %(arg_name)s = moo_lua_get_arg_%(suffix)s_opt (L, %(arg_idx)s, "%(param_name)s", %(default_value)s);' % dic
        else:
            return '%(type)s %(arg_name)s = moo_lua_get_arg_%(suffix)s (L, %(arg_idx)s, "%(param_name)s");' % dic

_arg_helpers = {}
_arg_helpers['int'] = SimpleArgHelper('int', 'int')
_arg_helpers['uint'] = SimpleArgHelper('guint', 'int')
_arg_helpers['gint'] = SimpleArgHelper('int', 'int')
_arg_helpers['guint'] = SimpleArgHelper('guint', 'int')
_arg_helpers['gboolean'] = SimpleArgHelper('gboolean', 'bool')
_arg_helpers['const-char*'] = SimpleArgHelper('const char*', 'string')
_arg_helpers['char*'] = SimpleArgHelper('char*', 'string')
_arg_helpers['strv'] = SimpleArgHelper('char**', 'strv')
def find_arg_helper(param):
    return _arg_helpers[param.type.name]

_ret_helpers = {}
_ret_helpers['int'] = ('int', 'int')
_ret_helpers['uint'] = ('guint', 'uint')
_ret_helpers['gint'] = ('int', 'int')
_ret_helpers['guint'] = ('guint', 'uint')
_ret_helpers['gboolean'] = ('gboolean', 'bool')
def find_ret_helper(name):
    return _ret_helpers[name]

_pod_ret_helpers = {}
_pod_ret_helpers['int'] = ('int', 'int')
_pod_ret_helpers['uint'] = ('guint', 'int')
_pod_ret_helpers['gint'] = ('int', 'int')
_pod_ret_helpers['guint'] = ('guint', 'int')
_pod_ret_helpers['gboolean'] = ('gboolean', 'bool')
def find_pod_ret_helper(name):
    return _pod_ret_helpers.get(name, (None, None))

class Writer(object):
    def __init__(self, out):
        super(Writer, self).__init__()
        self.out = out

    def __write_function_param(self, func_body, param, i, meth, cls):
        dic = dict(narg=i, gtype_id=param.type.gtype_id, param_name=param.name,
                   allow_none=('TRUE' if param.allow_none else 'FALSE'),
                   default_value=param.default_value,
                   arg_idx='first_arg + %d' % (i,),
                   TypeName=param.type.name,
                   )
        if isinstance(param.type, Class) or isinstance(param.type, Boxed) or isinstance(param.type, Pointer):
            if param.default_value is not None:
                func_body.start.append(('%(TypeName)s *arg%(narg)d = (%(TypeName)s*) ' + \
                                        'moo_lua_get_arg_instance_opt (L, %(arg_idx)s, "%(param_name)s", ' + \
                                        '%(gtype_id)s);') % dic)
            else:
                func_body.start.append(('%(TypeName)s *arg%(narg)d = (%(TypeName)s*) ' + \
                                        'moo_lua_get_arg_instance (L, %(arg_idx)s, "%(param_name)s", ' + \
                                        '%(gtype_id)s);') % dic)
        elif isinstance(param.type, Enum) or isinstance(param.type, Flags):
            if param.default_value is not None:
                func_body.start.append(('%(TypeName)s arg%(narg)d = (%(TypeName)s) ' + \
                                        'moo_lua_get_arg_enum_opt (L, %(arg_idx)s, "%(param_name)s", ' + \
                                        '%(gtype_id)s, %(default_value)s);') % dic)
            else:
                func_body.start.append(('%(TypeName)s arg%(narg)d = (%(TypeName)s) ' + \
                                        'moo_lua_get_arg_enum (L, %(arg_idx)s, "%(param_name)s", ' + \
                                        '%(gtype_id)s);') % dic)
        elif isinstance(param.type, ArrayType):
            assert isinstance(param.type.elm_type, Class)
            dic['gtype_id'] = param.type.elm_type.gtype_id
            if param.default_value is not None:
                func_body.start.append(('%(TypeName)s arg%(narg)d = (%(TypeName)s) ' + \
                                        'moo_lua_get_arg_object_array_opt (L, %(arg_idx)s, "%(param_name)s", ' + \
                                        '%(gtype_id)s);') % dic)
            else:
                func_body.start.append(('%(TypeName)s arg%(narg)d = (%(TypeName)s) ' + \
                                        'moo_lua_get_arg_object_array (L, %(arg_idx)s, "%(param_name)s", ' + \
                                        '%(gtype_id)s);') % dic)
            func_body.end.append('moo_object_array_free ((MooObjectArray*) arg%(narg)d);' % dic)
        elif param.type.name == 'strv':
            assert param.default_value is None or param.default_value == 'NULL'
            if param.default_value is not None:
                func_body.start.append(('char **arg%(narg)d = moo_lua_get_arg_strv_opt (L, %(arg_idx)s, "%(param_name)s");') % dic)
            else:
                func_body.start.append(('char **arg%(narg)d = moo_lua_get_arg_strv (L, %(arg_idx)s, "%(param_name)s");') % dic)
            func_body.end.append('g_strfreev (arg%(narg)d);' % dic)
        else:
            arg_helper = find_arg_helper(param)
            func_body.start.append(arg_helper.format_arg(param.allow_none, param.default_value,
                                            'arg%(narg)d' % dic, 'first_arg + %(narg)d' % dic, param.name))

    def __write_function(self, meth, cls, method_cfuncs):
        assert not isinstance(meth, Constructor) and not isinstance(meth, VMethod)

        has_gerror_return = False
        params = []
        for i in range(len(meth.params)):
            p = meth.params[i]

            if isinstance(p.type, GErrorReturnType):
                print >> sys.stderr, "Skipping function %s because of 'GError**' parameter" % meth.c_name
                return

            if not p.type.name in _arg_helpers and not isinstance(p.type, ArrayType) and \
               not isinstance(p.type, GTypedType):
                print >> sys.stderr, "Skipping function %s because of '%s' parameter" % (meth.c_name, p.type.name)
                return

            if isinstance(p.type, GErrorReturnType):
                assert i == len(meth.params) - 1
                assert meth.retval.type.name == 'gboolean'
            else:
                params.append(p)

        dic = dict(name=meth.name, c_name=meth.c_name)
        if cls:
            dic['cfunc'] = 'cfunc_%s_%s' % (cls.name, meth.name)
            dic['Class'] = cls.name
            self.out.write(tmpl_cfunc_method_start % dic)
        else:
            dic['cfunc'] = 'cfunc_%s' % meth.name
            self.out.write(tmpl_cfunc_func_start % dic)

        method_cfuncs.append([meth.name, dic['cfunc']])

        class FuncBody:
            def __init__(self):
                self.start = []
                self.end = []

        func_body = FuncBody()
        func_call = ''

        i = 0
        for p in params:
            self.__write_function_param(func_body, p, i, meth, cls)
            i += 1

        if meth.retval:
            dic = {'gtype_id': meth.retval.type.gtype_id,
                   'make_copy': ('FALSE' if meth.retval.transfer_mode == 'full' else 'TRUE'),
                   }
            if isinstance(meth.retval.type, Class) or isinstance(meth.retval.type, Boxed) or isinstance(meth.retval.type, Pointer):
                func_call = 'gpointer ret = '
                push_ret = 'moo_lua_push_instance (L, ret, %(gtype_id)s, %(make_copy)s);' % dic
            elif isinstance(meth.retval.type, Enum) or isinstance(meth.retval.type, Flags):
                func_call = '%s ret = ' % meth.retval.type.name
                push_ret = 'moo_lua_push_int (L, ret);' % dic
            elif isinstance(meth.retval.type, ArrayType):
                assert isinstance(meth.retval.type.elm_type, Class)
                dic['gtype_id'] = meth.retval.type.elm_type.gtype_id
                func_call = 'MooObjectArray *ret = (MooObjectArray*) '
                push_ret = 'moo_lua_push_object_array (L, ret, %(make_copy)s);' % dic
            elif meth.retval.type.name == 'strv':
                assert meth.retval.transfer_mode == 'full'
                func_call = 'char **ret = '
                push_ret = 'moo_lua_push_strv (L, ret);'
            elif meth.retval.type.name == 'char*':
                assert meth.retval.transfer_mode == 'full'
                func_call = 'char *ret = '
                push_ret = 'moo_lua_push_string (L, ret);'
            elif meth.retval.type.name == 'const-char*':
                assert meth.retval.transfer_mode != 'full'
                func_call = 'const char *ret = '
                push_ret = 'moo_lua_push_string_copy (L, ret);'
            else:
                typ, suffix = find_pod_ret_helper(meth.retval.type.name)
                if typ:
                    dic['suffix'] = suffix
                    func_call = '%s ret = ' % typ
                    push_ret = 'moo_lua_push_%(suffix)s (L, ret);' % dic
                else:
                    typ, suffix = find_ret_helper(meth.retval.type.name)
                    dic['suffix'] = suffix
                    func_call = '%s ret = ' % typ
                    push_ret = 'moo_lua_push_%(suffix)s (L, ret, %(make_copy)s);' % dic
        else:
            push_ret = '0;'

        func_body.end.append('return %s' % push_ret)

        func_call += '%s (' % meth.c_name
        first_arg = True
        if cls:
            first_arg = False
            func_call += 'self'
        for i in range(len(params)):
            if not first_arg:
                func_call += ', '
            first_arg = False
            func_call += 'arg%d' % i
        func_call += ');'

        for line in func_body.start:
            print >>self.out, '    ' + line
        print >>self.out, '    ' + func_call
        for line in func_body.end:
            print >>self.out, '    ' + line

        self.out.write('}\n\n')

#         if not cls:
#             self.out.write(function_start_template % dic)
#         elif isinstance(meth, Constructor):
#             dic['class'] = cls.name
#             self.out.write(function_start_template % dic)
#             self.out.write('  (is-constructor-of %s)\n' % cls.name)
#         elif isinstance(meth, VMethod):
#             dic['class'] = cls.name
#             self.out.write(vmethod_start_template % dic)
#         else:
#             dic['class'] = cls.name
#             self.out.write(method_start_template % dic)
#         if meth.retval:
#             if meth.retval.transfer_mode == 'full':
#                 self.out.write('  (caller-owns-return #t)\n')
#             elif meth.retval.transfer_mode is not None:
#                 raise RuntimeError('do not know how to handle transfer mode %s' % (meth.retval.transfer_mode,))
#         if meth.params:
#             self.out.write('  (parameters\n')
#             for p in meth.params:
#                 self.out.write('    \'("%s" "%s"' % (p.type, p.name))
#                 if p.allow_none:
#                     self.out.write(' (null-ok)')
#                 if p.default_value is not None:
#                     self.out.write(' (default "%s")' % (p.default_value,))
#                 self.out.write(')\n')
#             self.out.write('  )\n')
#         self.out.write(')\n\n')

    def __write_class(self, cls):
        self.out.write('// methods of %s\n\n' % cls.name)
        method_cfuncs = []
        for meth in cls.methods:
            if not isinstance(meth, VMethod):
                self.__write_function(meth, cls, method_cfuncs)
        return method_cfuncs

    def __write_register_module(self, module, all_method_cfuncs):
        self.out.write(tmpl_register_module_start % dict(module=module.name.lower()))
        for cls in module.get_classes():
            method_cfuncs = all_method_cfuncs[cls.name]
            if method_cfuncs:
                dic = dict(Class=cls.name, gtype_id=cls.gtype_id)
                self.out.write(tmpl_register_one_type_start % dic)
                for name, cfunc in method_cfuncs:
                    self.out.write('        { "%s", %s },\n' % (name, cfunc))
                self.out.write(tmpl_register_one_type_end % dic)
        self.out.write('}\n')

    def write(self, module, include_headers):
        self.module = module

        self.out.write(tmpl_file_start)

        if include_headers:
            for h in include_headers:
                self.out.write('#include "%s"\n' % h)
            self.out.write('\n')

        all_method_cfuncs = {}

        for cls in module.get_classes():
            method_cfuncs = self.__write_class(cls)
            all_method_cfuncs[cls.name] = method_cfuncs
#         for cls in module.get_boxed():
#             self.__write_boxed_decl(cls)
#         for cls in module.get_pointers():
#             self.__write_pointer_decl(cls)
#
#         for enum in module.get_enums():
#             self.__write_enum_decl(enum)
#
#         for cls in module.get_classes() + module.get_boxed() + module.get_pointers():
#             self.__write_class_methods(cls)
#
#         for func in module.get_functions():
#             self.__write_function(func)

        self.__write_register_module(module, all_method_cfuncs)

        del self.module