#

#   Licensed under the Apache License, Version 2.0 (the "License");

#   you may not use this file except in compliance with the License.

#   You may obtain a copy of the License at

#

#       http://www.apache.org/licenses/LICENSE-2.0

#

#   Unless required by applicable law or agreed to in writing, software

#   distributed under the License is distributed on an "AS IS" BASIS,

#   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

#   See the License for the specific language governing permissions and

#   limitations under the License.

#

import os, sys, platform, shutil, _jcc

from cpp import PRIMITIVES, INDENT, HALF_INDENT

from cpp import cppname, cppnames, typename

from cpp import line, signature, find_method, split_pkg, sort

from cpp import Modifier, Class, Method

from _jcc import findClass

from config import INCLUDES, CFLAGS, DEBUG_CFLAGS, LFLAGS, SHARED

try:

    from cpp import ParameterizedType, TypeVariable

except ImportError:

    pass

python_ver = '%d.%d.%d' %(sys.version_info[0:3])

if python_ver < '2.4':

    from sets import Set as set

RESULTS = { 'boolean': 'Py_RETURN_BOOL(%s);',

            'byte': 'return PyInt_FromLong(%s);',

            'char': 'return PyUnicode_FromUnicode((Py_UNICODE *) &%s, 1);',

            'double': 'return PyFloat_FromDouble((double) %s);',

            'float': 'return PyFloat_FromDouble((double) %s);',

            'int': 'return PyInt_FromLong((long) %s);',

            'long': 'return PyLong_FromLongLong((PY_LONG_LONG) %s);',

            'short': 'return PyInt_FromLong((long) %s);',

            'java.lang.String': 'return j2p(%s);' }

CALLARGS = { 'boolean': ('O', '(%s ? Py_True : Py_False)', False),

             'byte': ('O', 'PyInt_FromLong(%s)', True),

             'char': ('O', 'PyUnicode_FromUnicode((Py_UNICODE *) &%s, 1)', True),

             'double': ('d', '(double) %s', False),

             'float': ('f', '(float) %s', False),

             'int': ('i', '(int) %s', False),

             'long': ('L', '(long long) %s', False),

             'short': ('i', '(int) %s', False),

             'java.lang.String': ('O', 'env->fromJString((jstring) %s, 0)', True) }

def parseArgs(params, current, generics):

    def signature(cls):

        array = ''

        while cls.isArray():

            array += '['

            cls = cls.getComponentType()

        clsName = cls.getName()

        if cls.isPrimitive():

            return array + PRIMITIVES[clsName]

        if clsName == 'java.lang.String':

            return array + 's'

        if clsName == 'java.lang.Object':

            return array + 'o'

        if generics and cls.getTypeParameters():

            return array + 'K'

        else:

            return array + 'k'

    def checkarg(cls):

        while cls.isArray():

            cls = cls.getComponentType()

        if (cls.isPrimitive() or

            cls.getName() in ('java.lang.String', 'java.lang.Object')):

            return ''

        return ', %s::initializeClass' %(typename(cls, current, False))

    def callarg(cls, i):

        if generics:

            while cls.isArray():

                cls = cls.getComponentType()

            if cls.getTypeParameters():

                ns, sep, n = rpartition(typename(cls, current, False), '::')

                return ', &a%d, &p%d, %s%st_%s::parameters_' %(i, i, ns, sep, n)

        return ', &a%d' %(i)

    return (''.join([signature(param) for param in params]),

            ''.join([checkarg(param) for param in params]),

            ''.join([callarg(params[i], i) for i in xrange(len(params))]))

def declareVars(out, indent, params, current, generics, typeParams):

    for i in xrange(len(params)):

        param = params[i]

        line(out, indent, '%s a%d%s;',

             typename(param, current, False), i,

             not param.isPrimitive() and '((jobject) NULL)' or '')

        if generics:

            while param.isArray():

                param = param.getComponentType()

            if param.getTypeParameters():

                line(out, indent, 'PyTypeObject **p%d;', i)

                typeParams.add(i)

def construct(out, indent, cls, inCase, constructor, names, generics):

    if inCase:

        line(out, indent, '{')

        indent += 1

    params = constructor.getParameterTypes()

    if generics:

        typeParams = set()

    else:

        typeParams = None

    count = len(params)

    declareVars(out, indent, params, cls, generics, typeParams)

    line(out, indent, '%s object((jobject) NULL);', cppname(names[-1]))

    line(out)

    if count:

        line(out, indent, 'if (!parseArgs(args, "%s"%s%s))',

             *parseArgs(params, cls, generics))

        line(out, indent, '{')

        indent += 1

    line(out, indent, 'INT_CALL(object = %s(%s));',

         cppname(names[-1]), ', '.join(['a%d' %(i) for i in xrange(count)]))

    line(out, indent, 'self->object = object;')

    if inCase:

        line(out, indent, 'break;')

    if count:

        indent -= 1

        line(out, indent, '}')

    if inCase:

        indent -= 1

        line(out, indent, '}')

def rpartition(string, sep):

    if python_ver >= '2.5.0':

        return string.rpartition(sep)

    else:

        parts = split_pkg(string, sep)

        if len(parts) == 1:

            return ('', '', parts[0])

        return (parts[0], sep, parts[1])

def fieldValue(cls, value, fieldType):

    if fieldType.isArray():

        fieldType = fieldType.getComponentType()

        if fieldType.isArray():

            result = 'JArray<jobject>(%s->this$).wrap(NULL)'

        elif fieldType.isPrimitive():

            result = '%s->wrap()'

        elif fieldType.getName() == 'java.lang.String':

            result = 'JArray<jstring>(%s->this$).wrap()'

        else:

            parts = rpartition(typename(fieldType, cls, False), '::')

            result = 'JArray<jobject>(%%s->this$).wrap(%s%st_%s::wrap_jobject)' %(parts)

    elif fieldType.getName() == 'java.lang.String':

        result = 'j2p(*%s)'

    elif not fieldType.isPrimitive():

        parts = rpartition(typename(fieldType, cls, False), '::')

        result = '%s%st_%s::wrap_Object(*%%s)' %(parts)

    else:

        return value

    return result %(value)

def returnValue(cls, returnType, value, genericRT=None, typeParams=None):

    result = RESULTS.get(returnType.getName())

    if result:

        return result %(value)

    if returnType.isArray():

        returnType = returnType.getComponentType()

        depth = 1

        while returnType.isArray():

            returnType = returnType.getComponentType()

            depth += 1

        if depth > 1:

            return 'return JArray<jobject>(%s.this$).wrap(NULL);' %(value)

        elif returnType.isPrimitive():

            return 'return %s.wrap();' %(value)

        elif returnType.getName() == 'java.lang.String':

            return 'return JArray<jstring>(%s.this$).wrap();' %(value)

        ns, sep, n = rpartition(typename(returnType, cls, False), '::')

        return 'return JArray<jobject>(%s.this$).wrap(%s%st_%s::wrap_jobject);' %(value, ns, sep, n)

    ns, sep, n = rpartition(typename(returnType, cls, False), '::')

    if genericRT is not None:

        if ParameterizedType.instance_(genericRT):

            genericRT = ParameterizedType.cast_(genericRT)

            clsArgs = []

            for clsArg in genericRT.getActualTypeArguments():

                if Class.instance_(clsArg):

                    clsNames = Class.cast_(clsArg).getName().split('.')

                    clsArg = '&%s::%s$$Type' %('::'.join(cppnames(clsNames[:-1])), cppname(clsNames[-1]))

                    clsArgs.append(clsArg)

                elif TypeVariable.instance_(clsArg):

                    gd = TypeVariable.cast_(clsArg).getGenericDeclaration()

                    if Class.instance_(gd):

                        i = 0

                        for clsParam in gd.getTypeParameters():

                            if clsArg == clsParam:

                                clsArgs.append('self->parameters[%d]' %(i))

                                break

                            i += 1

                        else:

                            break

                    else:

                        break

                else:

                    break

            else:

                return 'return %s%st_%s::wrap_Object(%s, %s);' %(ns, sep, n, value, ', '.join(clsArgs))

        elif TypeVariable.instance_(genericRT):

            gd = TypeVariable.cast_(genericRT).getGenericDeclaration()

            i = 0

            if Class.instance_(gd):

                for clsParam in gd.getTypeParameters():

                    if genericRT == clsParam:

                        return 'return self->parameters[%d] != NULL ? wrapType(self->parameters[%d], %s.this$) : %s%st_%s::wrap_Object(%s);' %(i, i, value, ns, sep, n, value)

                    i += 1

            elif Method.instance_(gd):

                for clsParam in gd.getTypeParameters():

                    if genericRT == clsParam and i in typeParams:

                        return 'return p%d != NULL && p%d[0] != NULL ? wrapType(p%d[0], %s.this$) : %s%st_%s::wrap_Object(%s);' %(i, i, i, value, ns, sep, n, value)

                    i += 1

    return 'return %s%st_%s::wrap_Object(%s);' %(ns, sep, n, value)

def call(out, indent, cls, inCase, method, names, cardinality, isExtension,

         generics):

    if inCase:

        line(out, indent, '{')

        indent += 1

    name = method.getName()

    modifiers = method.getModifiers()

    params = method.getParameterTypes()

    returnType = method.getReturnType()

    if generics:

        genericRT = method.getGenericReturnType()

        typeParams = set()

    else:

        genericRT = None

        typeParams = None

    count = len(params)

    declareVars(out, indent, params, cls, generics, typeParams)

    returnName = returnType.getName()

    if returnName != 'void':

        line(out, indent, '%s result%s;',

             typename(returnType, cls, False),

             not returnType.isPrimitive() and '((jobject) NULL)' or '')

        result = 'result = '

    else:

        result = ''

    if cardinality and (count or not inCase):

        s = cardinality > 1 and 's' or ''

        line(out)

        if isExtension and name == 'clone' and Modifier.isNative(modifiers):

            line(out, indent, 'if (arg)')

        else:

            line(out, indent, 'if (!parseArg%s(arg%s, "%s"%s%s))',

                 s, s, *parseArgs(params, cls, generics))

        line(out, indent, '{')

        indent += 1

    name = cppname(name)

    if Modifier.isStatic(modifiers):

        line(out, indent, 'OBJ_CALL(%s%s::%s(%s));',

             result, '::'.join(cppnames(names)), name,

             ', '.join(['a%d' %(i) for i in xrange(count)]))

    else:

        line(out, indent, 'OBJ_CALL(%sself->object.%s(%s));',

             result, name, ', '.join(['a%d' %(i) for i in xrange(count)]))

    if isExtension and name == 'clone' and Modifier.isNative(modifiers):

        line(out)

        line(out, indent, '%s object(result.this$);', typename(cls, cls, False))

        line(out, indent, 'if (PyObject_TypeCheck(arg, &FinalizerProxy$$Type) &&')

        line(out, indent, '    PyObject_TypeCheck(((t_fp *) arg)->object, self->ob_type))')

        line(out, indent, '{')

        line(out, indent + 1, 'PyObject *_arg = ((t_fp *) arg)->object;')

        line(out, indent + 1, '((t_JObject *) _arg)->object = object;')

        line(out, indent + 1, 'Py_INCREF(_arg);')

        line(out, indent + 1, 'object.pythonExtension((jlong) (Py_intptr_t) (void *) _arg);')

        line(out, indent + 1, 'Py_INCREF(arg);')

        line(out, indent + 1, 'return arg;')

        line(out, indent, '}')

        line(out, indent, 'return PyErr_SetArgsError("%s", arg);' %(name))

    elif returnName != 'void':

        line(out, indent, returnValue(cls, returnType, 'result',

                                      genericRT, typeParams))

    else:

        line(out, indent, 'Py_RETURN_NONE;')

    if cardinality and (count or not inCase):

        indent -= 1

        line(out, indent, '}')

    if inCase:

        indent -= 1

        line(out, indent, '}')

def methodargs(methods, superMethods):

    if len(methods) == 1 and methods[0].getName() not in superMethods:

        count = len(methods[0].getParameterTypes())

        if count == 0:

            return '', '', 0

        elif count == 1:

            return ', PyObject *arg', ', arg', 1

    return ', PyObject *args', ', args', 2

def jniname(cls):

    if cls.isPrimitive():

        name = cls.getName()

        if name != 'void':

            name = 'j' + name

    else:

        name = 'jobject'

    return name

def jniargs(params):

    count = len(params)

    decls = ', '.join(['%s a%d' %(jniname(params[i]), i)

                       for i in xrange(count)])

    if decls:

        return ', ' + decls

    return ''

def extension(env, out, indent, cls, names, name, count, method, generics):

    line(out, indent, 'jlong ptr = jenv->CallLongMethod(jobj, %s::mids$[%s::mid_pythonExtension_%s]);',

         cppname(names[-1]), cppname(names[-1]), env.strhash('()J'))

    line(out, indent, 'PyObject *obj = (PyObject *) (Py_intptr_t) ptr;')

    if name == 'pythonDecRef':

        line(out)

        line(out, indent, 'if (obj != NULL)')

        line(out, indent, '{')