#!/usr/bin/env python3



copyright = '''
##########################################################################
#
# Copyright 2009-2016 VMware, Inc.
# All Rights Reserved.
#
# Permission is hereby granted, free of charge, to any person obtaining a copy
# of this software and associated documentation files (the "Software"), to deal
# in the Software without restriction, including without limitation the rights
# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
# copies of the Software, and to permit persons to whom the Software is
# furnished to do so, subject to the following conditions:
#
# The above copyright notice and this permission notice shall be included in
# all copies or substantial portions of the Software.
#
# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
# THE SOFTWARE.
#
##########################################################################/
'''


#
# Generates API specs from headers using castxml/pygccxml.
#
# Usage:
#
#   sudo apt-get install castxml mingw-w64-i686-dev
#   pip install 'pygccxml==1.9.1'
#   python specs/scripts/cxx2api.py -Idxsdk/Include -DD2D_USE_C_DEFINITIONS dcomp.h dcomptypes.h dcompanimation.h
#
# See also:
# - http://pygccxml.readthedocs.org/en/develop/index.html
# - https://github.com/CastXML/CastXML/blob/master/doc/manual/castxml.1.rst
#

import os.path
import sys
import io as StringIO
import subprocess

from pygccxml import utils
from pygccxml import parser
from pygccxml import declarations

from pygccxml.declarations import algorithm
from pygccxml.declarations import decl_visitor
from pygccxml.declarations import type_traits
from pygccxml.declarations import type_visitor


class decl_dumper_t(decl_visitor.decl_visitor_t):

    def __init__(self, decl = None):
        decl_visitor.decl_visitor_t.__init__(self)
        self.decl = decl
        self.result = None

    def clone(self):
        return decl_dumper_t(self.decl)

    def visit_class(self):
        class_ = self.decl
        assert class_.class_type in ('struct', 'union')
        self.result = class_.name

    def visit_class_declaration(self):
        class_ = self.decl
        self.result = class_.name

    def visit_typedef(self):
        typedef = self.decl
        self.result = typedef.name

    def visit_enumeration(self):
        self.result = self.decl.name


def dump_decl(decl):
    visitor = decl_dumper_t(decl)
    algorithm.apply_visitor(visitor, decl)
    return visitor.result


class type_dumper_t(type_visitor.type_visitor_t):

    def __init__(self, type):
        type_visitor.type_visitor_t.__init__(self)
        self.type = type
        self.result = None

    def clone(self):
        return type_dumper_t(self.type)

    def visit_void(self):
        self.result = 'Void'

    def visit_char(self):
        self.result = 'Char'

    def visit_unsigned_char(self):
        self.result = 'UChar'

    def visit_signed_char(self):
        self.result = 'SChar'

    def visit_wchar(self):
        raise NotImplementedError

    def visit_short_int(self):
        self.result = 'Short'

    def visit_short_unsigned_int(self):
        self.result = 'UShort'

    def visit_bool(self):
        raise NotImplementedError

    def visit_int(self):
        self.result = 'Int'

    def visit_unsigned_int(self):
        self.result = 'UInt'

    def visit_long_int(self):
        self.result = 'Long'

    def visit_long_unsigned_int(self):
        self.result = 'ULong'

    def visit_long_long_int(self):
        self.result = 'LongLong'

    def visit_long_long_unsigned_int(self):
        self.result = 'ULongLong'

    def visit_float(self):
        self.result = "Float"

    def visit_double(self):
        self.result = "Double"

    def visit_array(self):
        base_type = dump_type(self.type.base)
        length = self.type.size
        try:
            int(length)
        except ValueError:
            length = '"%s"' % length
        self.result = 'Array(%s, %s)' % (base_type, length)

    def visit_pointer(self):
        base_type = dump_type(self.type.base)
        # TODO: Use ObjPointer where appropriate
        #if isinstance(self.type.base, declarations.cpptypes.declarated_t):
        #    decl = self.type.base.declaration
        #    if isinstance(decl, declarations.typedef.typedef_t):
        #        print(decl.type, type(decl.type))
        #    if isinstance(decl, declarations.class_declaration.class_t):
        #        if decl.public_members:
        #            self.result = 'ObjPointer(%s)' % decl.name
        #            return
        #    if isinstance(decl, declarations.class_declaration.class_declaration_t):
        #        if decl.public_members:
        #            self.result = 'ObjPointer(%s)' % decl.name
        #            return
        if base_type.startswith('IDComposition') or \
           base_type.startswith('IDXGI') or \
           base_type == 'IUnknown':
            self.result = 'ObjPointer(%s)' % base_type
            return
        self.result = 'Pointer(%s)' % base_type

    def visit_reference(self):
        base_type = dump_type(self.type.base)
        if base_type == 'Const(IID)':
            self.result = 'REFIID'
        elif base_type == 'Const(GUID)':
            self.result = 'REFGUID'
        else:
            self.result = 'Reference(%s)' % base_type

    def visit_const(self):
        self.result = 'Const(%s)' % dump_type(self.type.base)

    def visit_declarated(self):
        decl = self.type.declaration
        self.result = dump_decl(decl)

    def visit_free_function_type(self):
        self.result = 'Opaque("%s")' % self.type


def dump_type(type):
    visitor = type_dumper_t(type)
    algorithm.apply_visitor(visitor, type)
    # XXX: RECT becomes tagRECT somehow
    if visitor.result == 'tagRECT':
        return 'RECT'
    return visitor.result


def is_interface(class_):
    if not class_.name.startswith('I'):
        return
    if len(class_.bases) != 1:
        return False
    # TODO: Ensure interface derives from IUnknown
    return True


class decl2_dumper_t(decl_visitor.decl_visitor_t):

    def __init__(self, name):
        decl_visitor.decl_visitor_t.__init__(self)

        self.name = name

        # The current declaration
        self.decl = None

        self.interfaces = StringIO.StringIO()
        self.methods = StringIO.StringIO()
        self.functions = StringIO.StringIO()

    def start(self):
        print(copyright.strip())
        print()
        print()
        print(r'from winapi import *')
        print()

    def finish(self):
        sys.stdout.write(self.interfaces.getvalue())
        sys.stdout.write('\n')
        sys.stdout.write(self.methods.getvalue())

        name = self.name
        sys.stdout.write('%s = Module(%r)\n' % (name, name))
        sys.stdout.write('%s.addFunctions([\n' % (name,))
        sys.stdout.write(self.functions.getvalue())
        sys.stdout.write('])\n\n')

    def clone(self):
        return decl_dumper_t(self.decl)

    def visit_class(self):
        class_ = self.decl
        assert class_.class_type in ('struct', 'union')

        if is_interface(class_):
            self.visit_interface()
        elif class_.name != '':
            self.visit_struct(class_.name, class_)

    def visit_struct(self, decl_name, decl):
        struct = decl
        print(r'%s = Struct(%r, [' % (decl_name, decl_name))
        for variable in struct.variables(allow_empty=True):
            var_type = dump_type(variable.decl_type)
            print(r'    (%s, %r),' % (var_type, variable.name))
        print(r'])')
        print()

    def visit_interface(self):
        class_ = self.decl
        assert len(class_.bases) == 1
        base = class_.bases[0]

        s = self.interfaces
        s.write('%s = Interface(%r, %s)\n' % (class_.name, class_.name, base.related_class.name))

        s = self.methods
        s.write('%s.methods += [\n' % (class_.name,))
        for member in class_.public_members:
            if member.virtuality != 'pure virtual':
                continue
            ret_type = dump_type(member.return_type)
            arg_types = self.convert_args(member.arguments)
            s.write('    StdMethod(%s, %r, [%s]),\n' % (ret_type, member.name, arg_types))
        s.write(']\n\n')

    def convert_args(self, args):
        # TODO: use __attribute__ ((annotate ("out")))
        # See also:
        # - https://github.com/CastXML/CastXML/issues/25
        # XXX: Requires a castxml version newer than the one in Ubuntu 15.10
        arg_types = []
        for arg in args:
            if arg.attributes is not None:
                sys.stderr.write('warning: found %s attribute %r\n' % (arg.name, arg.attributes))
            res_arg_type = dump_type(arg.decl_type)
            res_arg = '(%s, %r)' % (res_arg_type, arg.name)

            # Infer output arguments
            if res_arg_type.startswith('Pointer(') and \
               not res_arg_type.startswith('Pointer(Const('):
                   res_arg = 'Out' + res_arg

            arg_types.append(res_arg)

        arg_types = ', '.join(arg_types)
        return arg_types

    def visit_class_declaration(self):
        pass

    def visit_typedef(self):
        typedef = self.decl
        base_type = dump_type(typedef.decl_type)
        if base_type == typedef.name:
            # Ignore `typedef struct Foo Foo;`
            return
        if base_type == '':
            if isinstance(typedef.decl_type, declarations.cpptypes.declarated_t):
                base_decl = typedef.decl_type.declaration
                self.visit_struct(typedef.name, base_decl)
                return
        print(r'%s = Alias(%r, %s)' % (typedef.name, typedef.name, base_type))
        print()

    def visit_enumeration(self):
        enum = self.decl
        print(r'%s = Enum(%r, [' % (enum.name, enum.name))
        for name, value in enum.values:
            print(r'    %r,' % (name,))
        print(r'])')
        print()

    def visit_variable(self):
        pass

    def visit_free_function(self):
        function = self.decl
        if function.has_inline:
            return

        s = self.functions
        ret_type = dump_type(function.return_type)
        arg_types = self.convert_args(function.arguments)
        s.write('    StdFunction(%s, %r, [%s]),\n' % (ret_type, function.name, arg_types))

    def visit_free_operator(self):
        pass


def main():
    defines = []
    includes = []
    cxxflags = [
        '-Wno-unknown-attributes',
        '-Wno-unused-value',
        '-Wno-macro-redefined',
    ]
    compiler = 'g++'

    args = sys.argv[1:]
    while args and args[0].startswith('-'):
        arg = args.pop(0)
        if arg.startswith('-I'):
            include = arg[2:]
            includes.append(include)
        elif arg.startswith('-D'):
            define = arg[2:]
            defines.append(define)
        else:
            sys.stderr.write('error: unknown option %r\n' % arg)
            sys.exit(1)

    winsdk = True
    if winsdk:
        # Set up Clang compiler flags to use MinGW runtime
        # http://stackoverflow.com/a/19839946
        p = subprocess.Popen(
            ["x86_64-w64-mingw32-g++", "-x", "c++", "-E", "-Wp,-v", '-', '-fsyntax-only'],
            stdin=open(os.devnull, 'rt'),
            stdout=open(os.devnull, 'wt'),
            stderr=subprocess.PIPE)
        includes.append('/usr/share/castxml/clang/include')
        for line in p.stderr:
            if line.startswith(' '):
                include = line.strip()
                if os.path.isdir(include):
                    if os.path.exists(os.path.join(include, 'ia32intrin.h')):
                        # XXX: We must use Clang's intrinsic headers
                        continue
                    includes.append(os.path.normpath(include))

        winver = 0x0602

        defines += [
            # emulate MinGW
            '__MINGW32__',
            '_WIN32',
            '_WIN64',
            '__declspec(x)=',
            # Avoid namespace pollution when including windows.h
            # http://support.microsoft.com/kb/166474
            'WIN32_LEAN_AND_MEAN',
            # Set Windows version to 8.1
            '_WIN32_WINNT=0x%04X' % winver,
            'WINVER=0x%04X' % winver,
            'NTDDI_VERSION=0x%04X0000' % winver,
            # Prevent headers from requiring a rpcndr.h version beyond MinGW's
            '__REQUIRED_RPCNDR_H_VERSION__=475',
            # Avoid C++ helper classes
            'D3D10_NO_HELPERS',
            'D3D11_NO_HELPERS',
            'D3D11_VIDEO_NO_HELPERS',
        ]

        # XXX: Change compiler?
        #compiler = 'cl'

        # XXX: This doesn't seem to work well
        cxxflags += [
            #'-m32',
            #'-target', 'x86_64-pc-mingw32',
        ]

    sys.stderr.write('Include path:\n')
    for include in includes:
        sys.stderr.write('  %s\n' % include)
    sys.stderr.write('Definitions:\n')
    for define in defines:
        sys.stderr.write('  %s\n' % define)

    import logging
    utils.loggers.set_level(logging.DEBUG)

    # Find the location of the xml generator (castxml or gccxml)
    generator_path, generator_name = utils.find_xml_generator("castxml")

    # Configure the xml generator
    config = parser.xml_generator_configuration_t(
        xml_generator_path=generator_path,
        xml_generator=generator_name,
        define_symbols = defines,
        include_paths = includes,
        cflags = ' '.join(cxxflags),
        compiler = compiler,
        #keep_xml = True,
    )

    script_dir = os.path.dirname(__file__)
    headers = [
        os.path.join(script_dir, '..', '..', 'compat', 'winsdk_compat.h'),
        os.path.join(script_dir, 'cxx2api.h'),
    ]
    main_header = args[0]
    headers.append(main_header)

    decls = parser.parse(headers, config, parser.COMPILATION_MODE.ALL_AT_ONCE)
    global_ns = declarations.get_global_namespace(decls)

    def decl_filter(decl):
        location = decl.location
        if location is None:
            return False
        return os.path.basename(location.file_name) in list(map(os.path.basename, args))

    module, _ = os.path.splitext(main_header)
    visitor = decl2_dumper_t(module)
    visitor.start()
    for decl in global_ns.declarations:
        if not decl_filter(decl):
            continue

        if sys.stdout.isatty():
            print('# ' + str(decl))

        visitor.decl = decl
        algorithm.apply_visitor(visitor, decl)
    visitor.finish()


if __name__ == '__main__':
    main()