#   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, zipfile, _jcc

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

if python_ver < '2.4':

    from sets import Set as set

    def split_pkg(string, sep):

        parts = string.split(sep)

        if len(parts) > 1:

            return sep.join(parts[:-1]), parts[-1]

        return parts

    def sort(list, fn=None, key=None):

        if fn:

            list.sort(fn)

        elif key:

            def fn(x, y):

                return cmp(key(x), key(y))

            list.sort(fn)

        else:

            list.sort()

else:

    def split_pkg(string, sep):

        return string.rsplit(sep, 1)

    def sort(list, fn=None, key=None):

        if fn:

            list.sort(cmp=fn)

        elif key:

            list.sort(key=key)

        else:

            list.sort()

class JavaError(Exception):

    def getJavaException(self):

        return self.args[0]

    def __str__(self):

        writer = StringWriter()

        self.getJavaException().printStackTrace(PrintWriter(writer))

        return '\n'.join((super(JavaError, self).__str__(),

                          "Java stacktrace:", str(writer)))

class InvalidArgsError(Exception):

    pass

_jcc._set_exception_types(JavaError, InvalidArgsError)

from _jcc import *

INDENT = '    '

HALF_INDENT = '  '

PRIMITIVES = { 'boolean': 'Z',

               'byte': 'B',

               'char': 'C',

               'double': 'D',

               'float': 'F',

               'int': 'I',

               'long': 'J',

               'short': 'S',

               'void': 'V' }

RESERVED = set(['delete', 'and', 'or', 'not', 'xor', 'union', 'NULL',

                'register', 'const', 'bool', 'operator', 'typeof'])

def cppname(name):

    if name in RESERVED:

        return name + '$'

    return name

def cppnames(names):

    return [cppname(name) for name in names]

def typename(cls, current, const):

    if cls.isArray():

        componentType = cls.getComponentType()

        if componentType.isArray():

            name = 'JArray< %s >' %(typename(componentType, current, False))

        else:

            name = 'JArray<%s>' %(typename(componentType, current, False))

    elif cls.isPrimitive():

        name = cls.getName()

        if name != 'void':

            name = 'j' + name

        const = False

    elif cls == current:

        name = cppname(cls.getName().split('.')[-1])

    else:

        name = '::'.join([cppname(name) for name in cls.getName().split('.')])

    if const:

        return "const %s&" %(name)

    return name

def argnames(params, cls):

    if not params:

        return '', ''

    count = len(params)

    decls = ', '.join(["%s a%d" %(typename(params[i], cls, True), i)

                       for i in xrange(count)])

    args = ', '.join(['a%d%s' %(i, not params[i].isPrimitive() and '.this$' or '')

                      for i in xrange(count)])

    return decls, ', ' + args

def line(out, indent=0, string='', *args):

    out.write(INDENT * indent)

    out.write(string % args)

    out.write('\n')

def known(cls, typeset, declares, packages, excludes, generics):

    if generics:

        if Class.instance_(cls):

            cls = Class.cast_(cls)

        elif ParameterizedType.instance_(cls):

            pt = ParameterizedType.cast_(cls)

            if not known(pt.getRawType(), typeset, declares, packages, excludes,

                         True):

                return False

            for ta in pt.getActualTypeArguments():

                if TypeVariable.instance_(ta):

                    continue

                if not known(ta, typeset, declares, packages, excludes, True):

                    return False

            return True

        elif WildcardType.instance_(cls):

            wc = WildcardType.cast_(cls)

            for ub in wc.getUpperBounds():

                if not known(ub, typeset, declares, packages, excludes, True):

                    return False

            return True

        elif TypeVariable.instance_(cls):

            for bounds in TypeVariable.cast_(cls).getBounds():

                if not known(bounds, typeset, declares, packages, excludes,

                             True):

                    return False

            return True

        elif GenericArrayType.instance_(cls):

            return known(GenericArrayType.cast_(cls).getGenericComponentType(),

                         typeset, declares, packages, excludes, True)

        else:

            raise TypeError, (cls, cls.getClass())

    while cls.isArray():

        cls = cls.getComponentType()

    className = cls.getName()

    if className in excludes:

        return False

    if cls.isPrimitive():

        return True

    if cls in typeset:

        declares.add(cls)

        return True

    if split_pkg(className, '.')[0] in packages:

        typeset.add(cls)

        declares.add(cls)

        cls = cls.getSuperclass()

        while cls and cls not in typeset:

            typeset.add(cls)

            cls = cls.getSuperclass()

        return True

    return False

def find_method(cls, name, params):

    declared = False

    while True:

        try:

            if declared:

                method = cls.getDeclaredMethod(name, params)

            else:

                method = cls.getMethod(name, params)

            break

        except JavaError, e:

            if (e.getJavaException().getClass().getName() == 'java.lang.NoSuchMethodException'):

                if not declared:

                    declared = True

                else:

                    cls = cls.getSuperclass()

                    if not cls:

                        return None

                continue

            raise

    modifiers = method.getModifiers()

    if Modifier.isAbstract(modifiers):

        return None

    if Modifier.isPrivate(modifiers):

        return None

    return method

def signature(fn, argsOnly=False):

    def typename(cls):

        array = ''

        while cls.isArray():

            array += '['

            cls = cls.getComponentType()

        if cls.isPrimitive():

            return array + PRIMITIVES[cls.getName()]

        return '%sL%s;' %(array, cls.getName().replace('.', '/'))

    if isinstance(fn, Constructor):

        returnType = 'V'

    elif isinstance(fn, Method):

        returnType = typename(fn.getReturnType())

    elif isinstance(fn, Field):

        return typename(fn.getType())

    if argsOnly:

        return '(%s)' %(''.join([typename(param)

                                 for param in fn.getParameterTypes()]))

    return '(%s)%s' %(''.join([typename(param)

                               for param in fn.getParameterTypes()]),

                       returnType)

def forward(out, namespace, indent):

    for name, entries in namespace.iteritems():

        if entries is True:

            line(out, indent, 'class %s;', cppname(name))

        else:

            line(out, indent, 'namespace %s {', cppname(name))

            forward(out, entries, indent + 1)

            line(out, indent, '}')

def expandjar(path):

    jar = zipfile.ZipFile(path, 'r')

    for member in jar.infolist():

        f = member.filename

        if f.endswith('.class'):

            yield f.split('.')[0].replace('/', '.')

    jar.close()

def jcc(args):

    classNames = set()

    packages = set()

    jars = []

    classpath = []

    libpath = []

    vmargs = ['-Djava.awt.headless=true']

    moduleName = None

    modules = []

    build = False

    install = False

    recompile = False

    output = 'build'

    debug = False

    excludes = []

    version = ''

    mappings = {}

    sequences = {}

    renames = {}

    env = None

    wrapperFiles = 1

    prefix = None

    root = None

    install_dir = None

    home_dir = None

    use_distutils = False

    shared = False

    dist = False

    wininst = False

    compiler = None

    generics = hasattr(_jcc, "Type")

    arch = []

    i = 1

    while i < len(args):

        arg = args[i]

        if arg.startswith('-'):

            if arg == '--jar':

                i += 1

                classpath.append(args[i])

                classNames.update(expandjar(args[i]))

                jars.append(args[i])

            elif arg == '--include':

                i += 1

                classpath.append(args[i])

                jars.append(args[i])

            elif arg == '--package':

                i += 1

                packages.add(args[i])

            elif arg == '--classpath':

                i += 1

                classpath.append(args[i])

            elif arg == '--libpath':

                i += 1

                libpath.append(args[i])

            elif arg == '--vmarg':

                i += 1

                vmargs.append(args[i])

            elif arg == '--python':

                from python import python, module

                i += 1

                moduleName = args[i]

            elif arg == '--module':

                i += 1

                modules.append(args[i])

            elif arg == '--build':

                from python import compile

                build = True

            elif arg == '--install':

                from python import compile

                install = True

            elif arg == '--compile':

                from python import compile

                recompile = True

            elif arg == '--output':

                i += 1

                output = args[i]

            elif arg == '--debug':

                debug = True

            elif arg == '--exclude':

                i += 1

                excludes.append(args[i])

            elif arg == '--version':

                i += 1

                version = args[i]

            elif arg == '--mapping':

                mappings[args[i + 1]] = args[i + 2]

                i += 2

            elif arg == '--sequence':

                sequences[args[i + 1]] = (args[i + 2], args[i + 3])

                i += 3

            elif arg == '--rename':

                i += 1

                renames.update(dict([arg.split('=')

                                     for arg in args[i].split(',')]))

            elif arg == '--files':

                i += 1

                wrapperFiles = args[i]

                if wrapperFiles != 'separate':

                    wrapperFiles = int(wrapperFiles)

            elif arg == '--prefix':

                i += 1

                prefix = args[i]

            elif arg == '--root':

                i += 1

                root = args[i]

            elif arg == '--install-dir':

                i += 1

                install_dir = args[i]

            elif arg == '--home':

                i += 1

                home_dir = args[i]

            elif arg == '--use-distutils':

                use_distutils = True

            elif arg == '--shared':