#
# Lasso - A free implementation of the Liberty Alliance specifications.
#
# Copyright (C) 2004-2007 Entr'ouvert
# http://lasso.entrouvert.org
#
# Authors: See AUTHORS file in top-level directory.
#
# This program is free software; you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation; either version 2 of the License, or
# (at your option) any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program; if not, see <http://www.gnu.org/licenses/>.


import os
import re
from six import print_
import sys
from utils import *

from optparse import OptionParser

try:
    from lxml import etree as ET
except ImportError:
    try:
        import cElementTree as ET
    except ImportError:
        try:
            import elementtree.ElementTree as ET
        except ImportError:
            import xml.etree.ElementTree as ET

sys.path.append(os.path.dirname(__file__))

# monkey patch os.path to include relpath if python version is < 2.6
if not hasattr(os.path, "relpath"):
    def relpath(longPath, basePath):
        if not longPath.startswith(basePath):
            raise RuntimeError("Unexpected arguments")
        if longPath == basePath:
            return "."
        i = len(basePath)
        if not basePath.endswith(os.path.sep):
            i += len(os.path.sep)
        return longPath[i:]

    os.path.relpath = relpath



class BindingData:
    src_dir = os.path.dirname(__file__)

    def __init__(self, options = None):
        self.headers = []
        # [(char,string)]
        # where char is:
        # - i: integer
        # - s: string
        self.constants = []
        self.structs = []
        self.struct_dict = {}
        self.functions = []
        self.enums = []
        self.options = options
        self.overrides = ET.parse(os.path.join(self.src_dir, 'overrides.xml'))
        self.functions_toskip = dict()
        self.structs_toskip = dict()

        for func in self.overrides.findall('func'):
            if func.attrib.get('skip') == 'true':
                self.functions_toskip[func.attrib.get('name')] = 1
        for struct in self.overrides.findall('struct'):
            if struct.attrib.get('skip') == 'true':
                self.structs_toskip[struct.attrib.get('name')] = 1

    def match_tag_language(self,tag):
        if self.options and self.options.language:
            languages = tag.attrib.get('language')
            if languages:
                lang_list = languages.split(' ')
                if self.options.language in lang_list:
                    return True
                else:
                    return False
            else:
                return True
        else:
            return True

    def display_structs(self):
        for struct in self.structs:
            struct.display()

    def display_funcs(self):
        for func in self.functions:
            print(func.return_type, func.name)
            for a in func.args:
                print('  ', a)

    def order_class_hierarchy(self):
        new_order = []
        while self.structs:
            for c in self.structs:
                if c.parent == 'GObject' or c.parent in [x.name for x in new_order]:
                    self.structs.remove(c)
                    new_order.append(c)
                    break
        self.structs = new_order

    def create_struct_dict(self):
        for c in self.structs:
            self.struct_dict[c.name] = c

    def attach_methods(self):
        self.create_struct_dict()
        for f in self.functions[:]:
            if len(f.args) == 0:
                continue
            if f.name.endswith('_new') or '_new_' in f.name:
                # constructor for another class
                continue
            arg_type = f.args[0][0]
            if arg_type[-1] == '*':
                arg_type = arg_type[:-1]
            arg_type = arg_type.replace('const ','')
            c = self.struct_dict.get(arg_type)
            if not c:
                continue
            c.methods.append(f)
            if f.docstring and f.docstring.parameters:
                # remove first parameter, which is self/this/etc.
                f.docstring.parameters = f.docstring.parameters[1:]

            self.functions.remove(f)

    def look_for_docstrings(self, srcdir, exception_doc):
        def getfunc(name):
            funcs = [f for f in self.functions if f.name == name]
            if not funcs:
                return None
            else:
                return funcs[0]
        regex = re.compile(r'\/\*\*\s(.*?)\*\/', re.DOTALL)
        for base, dirnames, filenames in os.walk(srcdir):
            bname = os.path.basename(base)
            if bname == '.svn':
                # ignore svn directories
                continue
            if not 'Makefile.am' in filenames:
                # not a source dir
                continue
            makefile_am = open(os.path.join(base, 'Makefile.am')).read()
            filenames = [x for x in filenames if x.endswith('.c') if x in makefile_am]
            for filename in filenames:
                s = open(os.path.join(base, filename)).read()
                docstrings = regex.findall(s)
                for d in docstrings:
                    docstring = '\n'.join([x[3:] for x in d.splitlines()])
                    function_name = docstring.splitlines(1)[0].strip().strip(':')
                    func = getfunc(function_name)
                    if not func:
                        continue
                    func.docstring = DocString(func, docstring, self)
        if exception_doc:
            lines = os.popen('perl ../utility-scripts/error-analyzer.pl %s' % srcdir, 'r').readlines()
            for line in lines:
                elts = re.split(r' +',line.strip())
                func = getfunc(elts[0])
                if func:
                    func.errors = elts[1:]


class Struct:
    def __init__(self, name):
        self.name = name[1:] # skip leading _
        self.parent = None
        self.members = []
        self.methods = []

    def __repr__(self):
        return '<Struct name:%s, childof:%s>' % (self.name, self.parent)

    def display(self):
        print(self.__repr__())
        for m in self.members:
            print('  ', m)
        for m in self.methods:
            print('  ', m)

    def getMember(self, name):
        l = [m for m in self.members if arg_name(m) == name]
        if l:
            return l[0]
        else:
            return None

    def getMethod(self, name):
        l = [m for m in self.methods if m.name == name]
        if l:
            return l[0]
        else:
            return None

toskip = None


class Function:
    return_type = None
    return_type_qualifier = None
    return_arg = None
    name = None
    rename = None
    args = None
    docstring = None
    return_owner = True
    skip = False
    errors = None

    def __repr__(self):
        return '<Function return_type:%s name:%s args:%r>' % (
                self.return_arg, self.name, self.args)

    def apply_overrides(self):
        for func in binding.overrides.findall('func'):
            if not binding.match_tag_language(func):
                continue
            if func.attrib.get('name') != self.name:
                continue
            for param in func.findall('param'):
                try:
                    arg = [x for x in self.args if x[1] == param.attrib.get('name')][0]
                except IndexError:
                    print_('W: no such param (%s) in function (%s)' % (
                            param.attrib.get('name'), self.name), file=sys.stderr)
                    continue
                if param.attrib.get('optional') == 'true':
                    arg[2]['optional'] = True
                if param.attrib.get('default'):
                    arg[2]['default'] = param.attrib.get('default')
                if param.attrib.get('type'):
                    arg[0] = param.attrib.get('type')
                if param.attrib.get('elem_type'):
                    arg[2]['element-type'] = param.attrib.get('elem_type')
            if func.attrib.get('rename'):
                self.rename = func.attrib.get('rename')
            if func.attrib.get('return_owner'):
                self.return_owner = (func.attrib.get('return_owner') != 'false')
            if func.attrib.get('return_type'):
                self.return_type = func.attrib.get('return_type')
            if func.attrib.get('skip'):
                skip = func.attrib.get('skip')
                if skip == 'true':
                    self.skip = True
                elif skip == 'unless-id-wsf' and not binding.options.idwsf:
                    self.skip = True
                elif binding.options.language in skip.split(','):
                    self.skip = True
            if func.attrib.get('return_type_qualifier'):
                self.return_type_qualifier = func.attrib.get('return_type_qualifier')
        for param in binding.overrides.findall('arg'):
            if not binding.match_tag_language(param):
                continue
            arg_name = param.attrib.get('name')
            arg_sub = param.attrib.get('rename')
            if arg_name and arg_sub:
                args = [ x for x in self.args if x[1] == arg_name]
                for arg in args:
                    arg[2]['original-name'] = arg[1]
                    arg[1] = arg_sub


class DocString:
    orig_docstring = None
    parameters = None
    return_value = None
    description = None

    def __init__(self, function, docstring, binding_data):
        self.binding_data = binding_data
        self.orig_docstring = docstring
        self.parameters = []
        self.params = {}
        lines = docstring.splitlines()
        # ignore the first line, it has the symbol name
        lines = lines[1:]

        # look for parameters
        while lines[0].strip():
            if not self.parameters and not lines[0].startswith('@'):
                # function without parameters
                break
            if not self.parameters:
                self.parameters = []

            if lines[0][0] == '@':

                splits = lines[0][1:].split(':', 2)
                param_name = splits[0]
                if len(splits) > 2:
                    param_options = splits[1]
                    param_desc = splits[2]
                    self.parameters.append([param_name, param_desc, param_options])
                    self.params[param_name] = { 'desc': param_desc, 'options': param_options }
                    for a in function.args:
                        if a[1] == param_name or a[2].get('original-name') == param_name:
                            arg = a
                            break
                    else:
                        raise Exception('should not happen ' + param_name + ' ' + lines[0] + repr(function))
                    self.annotation2arg(arg, param_options)
                else:
                    param_desc = splits[1]
                    self.parameters.append([param_name, param_desc])
                    self.params[param_name] = { 'desc': param_desc }
            else:
                # continuation of previous description
                self.parameters[-1][1] = self.parameters[-1][1] + ' ' + lines[0].strip()

            lines = lines[1:]

        # blank line then description, till the end or the return value
        lines = lines[1:]
        self.description = ''
        while not lines[0].startswith('Return value'):
            self.description += lines[0] + '\n'
            if len(lines) == 1:
                self.description = self.description.strip()
                return
            lines = lines[1:]
        self.description = self.description.strip()

        # return value
        if lines[0].startswith('Return value') or lines[0].startswith('Returns'):
            lines[0] = lines[0].split(':', 1)[1]
            accu = ''
            while lines[0].strip():
                accu = accu + ' ' + lines[0].strip()
                if len(lines) == 1:
                    break
                lines = lines[1:]
            # find GObject-introspection annotations
            if re.match(r'\s*\(', accu):
                annotation, accu = accu.split(':', 1)
                self.annotation2arg(function.return_arg, annotation)
            self.return_value = accu.strip() # remove leading space
    def annotation2arg(self, arg, annotation):
        '''Convert GObject-introspection annotations to arg options'''

        if 'allow-none' in annotation:
            arg[2]['optional'] = True
        if re.search(r'\(\s*out\s*\)', annotation):
            arg[2]['out'] = True
        if re.search(r'\(\s*in\s*\)', annotation):
            arg[2]['in'] = True
        m = re.search(r'\(\s*default\s*([^ )]*)\s*\)', annotation)
        if m:
            prefix = ''
            if is_boolean(arg):
                prefix = 'b:'
            elif is_int(arg, self.binding_data):
                prefix = 'c:'
            else:
                raise Exception('should not happen: could not found type for default: ' + annotation)
            arg[2]['default'] = prefix + m.group(1)
            arg[2]['optional'] = True
        m = re.search(r'\(\s*element-type\s+([\w*]+)(?:\s+([\w*]+))?', annotation)
        if m:
            if len(m.groups()) > 2:
                arg[2]['key-type'] = \
                        convert_type_from_gobject_annotation(m.group(1))
                arg[2]['value-type'] = \
                        convert_type_from_gobject_annotation(m.group(2))
            else:
                arg[2]['element-type'] = \
                        convert_type_from_gobject_annotation(m.group(1))
        m = re.search(r'\(\s*transfer\s+(\w+)', annotation)
        if m:
            arg[2]['transfer'] = m.group(1)

def normalise_var(type, name):
    if name[0] == '*':
        type += '*'
        name = name[1:]
    return type, name

exclude_private = True

def parse_header(header_file):
    global binding

    struct_names = {}
    in_comment = False
    in_enum = False
    in_struct = None
    in_struct_private = False
    in_ifdef_zero = False

    lines = open(header_file).readlines()
    i = 0
    while i < len(lines):
        line = lines[i]
        while line.endswith('\\\n'):
            i += 1
            line = line[:-2] + ' ' + lines[i].lstrip()

        if in_comment:
            if '*/' in line:
                in_comment = False
        elif '/*' in line and not '*/' in line:
            in_comment = True
        elif in_ifdef_zero:
            # minimal support for code sections commented with #if 0
            if line.startswith('#endif'):
                in_ifdef_zero = False
        elif line.startswith('#if 0'):
            in_ifdef_zero = True
        elif in_enum:
            if line.startswith('}'):
                in_enum = False
                enum_name = line[2:].strip().strip(';')
                binding.enums.append(enum_name)
            else:
                m = re.match('\s*([a-zA-Z0-9_]+)', line)
                if m:
                    binding.constants.append(('i', m.group(1)))
        elif line.startswith('#define'):
            m = re.match(r'#define\s+([a-zA-Z0-9_]+)\s+([-\w"]+)', line)
            if m:
                constant_name = m.group(1)
                if constant_name[0] != '_':
                    # ignore private constants
                    if '"' in line:
                        constant_type = 's'
                    elif m.group(2).startswith('LASSO_'):
                        l = [ c for c in binding.constants if m.group(2) == c[1] ]
                        if l:
                            contant_type = l[0][0]
                        else:
                            raise Exception()
                    else:
                        constant_type = 'i'
                    constant = (constant_type, constant_name)
                    binding.constants.append(constant)
        elif line.startswith('typedef enum {'):
            in_enum = True
        elif line.startswith('typedef struct'):
            m = re.match('typedef struct ([a-zA-Z0-9_]+)', line)
            if m:
                struct_name = m.group(1)
                if not (struct_name.endswith('Class') or struct_name.endswith('Private')):
                    struct_names[struct_name] = True
        elif line.startswith('struct _'):
            m = re.match('struct ([a-zA-Z0-9_]+)', line)
            struct_name = m.group(1)
            if struct_name in struct_names:
                in_struct = Struct(struct_name)
                in_struct_private = False
        elif in_struct:
            if line.startswith('}'):
                if not in_struct.name in binding.structs_toskip:
                    binding.structs.append(in_struct)
                else:
                    print_('W: skipping structure %s due to overrides.xml' % in_struct.name, file=sys.stderr)
                in_struct = None
            elif '/*< public >*/' in line:
                in_struct_private = False
            elif '/*< private >*/' in line:
                in_struct_private = True
            elif in_struct_private and exclude_private:
                pass
            elif 'DEPRECATED' in line and exclude_private:
                pass
            else:
                # TODO: Add parsing of OFTYPE
                # Transform struct to typedef
                # example: "struct _LassoAssertion" -> "LassoAssertion"
                line = re.sub('\s+struct _', ' ', line)
                member_match = re.match('\s+(\w+)\s+(\*?\w+)', line)
                if member_match:
                    member_type, member_name = normalise_var(member_match.group(1), member_match.group(2))
                    field = (member_type, member_name, {})
                    if member_type == 'void*':
                        print_('W: skipping field %s.%s' % (in_struct.name, member_name), file=sys.stderr)
                    else:
                        if is_glist(field) or is_hashtable(field):
                            found = re.search(r' of ([^*]*)', line)
                            if found:
                                field[2]['element-type'] = clean_type(found.group(1))
                        if member_name == 'parent':
                            in_struct.parent = member_type
                        else:
                            in_struct.members.append(field)
        elif line.startswith('LASSO_EXPORT '):
            while not line.strip().endswith(';'):
                i += 1
                line = line[:-1] + ' ' + lines[i].lstrip()

            # parse the type, then the name, then argument list
            m = re.match(r'LASSO_EXPORT\s+([^(]*(?:\s|\*))(\w+)\s*\(\s*(.*?)\s*\)\s*;', line)
            if m and (not exclude_private or not m.group(2).endswith('_get_type')):
                return_type, function_name, args = m.groups()
                return_type = return_type.strip()
                f = Function()
                if function_name[0] == '*':
                    return_type += '*'
                    function_name = function_name[1:]
                if binding.functions_toskip.get(function_name) != 1:
                    if re.search(r'\<const\>', return_type):
                        f.return_owner = False
                    # clean the type
                    return_type = clean_type(return_type)
                    if return_type != 'void':
                        f.return_type = return_type
                        f.return_arg = (return_type, None, {})
                    if function_name.endswith('_destroy') and exclude_private:
                        # skip the _destroy functions, they are just wrapper over
                        # g_object_unref
                        pass
                    else:
                        f.name = function_name
                        f.args = []
                        for arg in [x.strip() for x in args.split(',')]:
                            arg = clean_type(arg)
                            if arg == 'void' or arg == '':
                                continue
                            m = re.match(r'(.*(?:\s|\*))(\w+)', arg)
                            if m:
                                type, name = m.groups()
                                type = clean_type(type)
                                f.args.append(list((type, name, {})))
                            else:
                                print_('failed to process:', arg, 'in line:', line, file=sys.stderr)
                                f.skip = True
                        f.apply_overrides()
                        if not f.skip:
                            binding.functions.append(f)
                        else:
                            print_('W: skipping function', f, file=sys.stderr)

        i += 1


def parse_headers(srcdir):
    wsf_prefixes = ['disco_', 'dst_', 'is_', 'profile_service_', 'discovery_',
            'wsf_', 'interaction_', 'utility_', 'sa_', 'authentication_',
            'wsse_', 'sec_', 'idwsf2_', 'wsf2_', 'wsa_', 'wsu', 'soap_binding']

    srcdir = os.path.abspath(srcdir)
    parentdir = os.path.dirname(srcdir)

    exclusion = ('xml_idff.h', 'xml_idwsf.h', 'xml_saml2.h', \
            'xml_idwsf2.h', 'xml_soap11.h',
            'lasso_config.h', 'saml2_xsd.h' )
    if not binding.options.idwsf:
        exclusion += ( 'idwsf_strings.h', )
    for base, dirnames, filenames in os.walk(srcdir):
        bname = os.path.basename(base)
        if bname == '.svn':
            # ignore svn directories
            continue
        if not 'Makefile.am' in filenames:
            # not a source dir
            continue
        if not binding.options.idwsf and (bname == 'id-wsf' or \
                bname == 'id-wsf-2.0' or bname == 'ws'):
            # ignore ID-WSF
            continue
        makefile_am = open(os.path.join(base, 'Makefile.am')).read()
        filenames = [x for x in filenames if x.endswith('.h') if x in makefile_am]
        for filename in filenames:
            if filename in exclusion:
                continue
            if 'private' in filename:
                continue
            if not binding.options.idwsf:
                if True in (filename.startswith(wsf_prefix) for wsf_prefix in wsf_prefixes):
                    continue
            header_path = os.path.join(base, filename)
            header_relpath = os.path.relpath(header_path, parentdir)

            binding.headers.append(header_relpath)
            parse_header(header_path)
    binding.constants.append(('b', 'LASSO_WSF_ENABLED'))

def main():
    global binding

    parser = OptionParser()
    parser.add_option('-l', '--language', dest = 'language')
    parser.add_option('-s', '--src-dir', dest = 'srcdir', default = '../lasso/')
    parser.add_option('--enable-id-wsf', dest = 'idwsf', action = 'store_true')
    parser.add_option('--enable-exception-docs', dest= 'exception_doc', action = 'store_true')

    options, args = parser.parse_args()
    if not options.language:
        parser.print_help()
        sys.exit(1)

    binding = BindingData(options)
    parse_headers(options.srcdir)
    binding.look_for_docstrings(options.srcdir, options.exception_doc)
    binding.order_class_hierarchy()
    binding.attach_methods()

    if options.language == 'python':
        from python import lang

        python_binding = lang.Binding(binding)
        python_binding.generate()
    elif options.language == 'php5':
        from php5 import lang

        php5_binding = lang.Binding(binding)
        php5_binding.generate()
    elif options.language == 'java':
        from java import lang

        java_binding = lang.Binding(binding)
        java_binding.generate()
    elif options.language == 'java-list':
        from java import lang

        java_binding = lang.Binding(binding)
        java_binding.print_list_of_files()
    elif options.language == 'perl':
        from perl import lang
        perl_binding = lang.Binding(binding)
        perl_binding.generate()

if __name__ == '__main__':
    main()
