import sys
import re

import mdp.docparser as dparser

DEBUG = False

def split_camel_case_name(name):
    comps = []
    cur = ''
    for c in name:
        if c.islower() or not cur:
            cur += c
        else:
            comps.append(cur)
            cur = c
    if cur:
        comps.append(cur)
    return comps

def get_class_method_c_name_prefix(cls):
    comps = split_camel_case_name(cls)
    return '_'.join([c.lower() for c in comps]) + '_'

def strip_class_prefix(name, cls):
    prefix = get_class_method_c_name_prefix(cls)
    if name.startswith(prefix):
        return name[len(prefix):]
    else:
        return name

def strip_module_prefix(name, mod):
    prefix = get_class_method_c_name_prefix(mod)
    if name.startswith(prefix):
        return name[len(prefix):]
    else:
        return name

def strip_module_prefix_from_class(name, mod):
    mod = mod.lower()
    mod = mod[0].upper() + mod[1:]
    if name.startswith(mod):
        return name[len(mod):]
    else:
        return name

def make_gtype_id(cls):
    comps = split_camel_case_name(cls)
    comps = [comps[0]] + ['TYPE'] + comps[1:]
    return '_'.join([c.upper() for c in comps])

class Type(object):
    def __init__(self, name):
        object.__init__(self)
        self.name = name

class BasicType(Type):
    def __init__(self, name):
        Type.__init__(self, name)

class _GTypedType(Type):
    def __init__(self, name, short_name, gtype_id, docs):
        Type.__init__(self, name)
        self.docs = docs
        self.methods = []
        self.static_methods = []
        self.gtype_id = gtype_id
        self.short_name = short_name
        self.annotations = {}

class EnumBase(_GTypedType):
    def __init__(self, name, short_name, gtype_id, docs):
        super(EnumBase, self).__init__(name, short_name, gtype_id, docs)
        self.values = []

class EnumValue(object):
    def __init__(self, name, attributes, docs):
        super(EnumValue, self).__init__()
        self.name = name
        self.attributes = attributes
        self.docs = docs

class Enum(EnumBase):
    def __init__(self, name, short_name, gtype_id, docs):
        super(Enum, self).__init__(name, short_name, gtype_id, docs)

class Flags(EnumBase):
    def __init__(self, name, short_name, gtype_id, docs):
        super(Flags, self).__init__(name, short_name, gtype_id, docs)

class _InstanceType(_GTypedType):
    def __init__(self, name, short_name, gtype_id, docs):
        _GTypedType.__init__(self, name, short_name, gtype_id, docs)
        self.constructor = None

class Class(_InstanceType):
    def __init__(self, name, short_name, parent, gtype_id, docs):
        _InstanceType.__init__(self, name, short_name, gtype_id, docs)
        self.parent = parent
        self.vmethods = []
        self.signals = []

class Boxed(_InstanceType):
    def __init__(self, name, short_name, gtype_id, docs):
        _InstanceType.__init__(self, name, short_name, gtype_id, docs)

class Pointer(_InstanceType):
    def __init__(self, name, short_name, gtype_id, docs):
        _InstanceType.__init__(self, name, short_name, gtype_id, docs)

class Symbol(object):
    def __init__(self, name, c_name, docs):
        object.__init__(self)
        self.name = name
        self.c_name = c_name
        self.docs = docs
        self.summary = None
        self.annotations = {}

class FunctionBase(Symbol):
    def __init__(self, name, c_name, params, retval, docs):
        Symbol.__init__(self, name, c_name, docs)
        self.params = params
        self.retval = retval

class Function(FunctionBase):
    def __init__(self, name, c_name, params, retval, docs):
        FunctionBase.__init__(self, name, c_name, params, retval, docs)

class Method(FunctionBase):
    def __init__(self, name, c_name, cls, params, retval, docs):
        FunctionBase.__init__(self, name, c_name, params, retval, docs)
        self.cls = cls

class StaticMethod(FunctionBase):
    def __init__(self, name, c_name, cls, params, retval, docs):
        FunctionBase.__init__(self, name, c_name, params, retval, docs)
        self.cls = cls

class Constructor(FunctionBase):
    def __init__(self, name, c_name, cls, params, retval, docs):
        FunctionBase.__init__(self, name, c_name, params, retval, docs)
        self.cls = cls

class VMethod(FunctionBase):
    def __init__(self, name, cls, params, retval, docs):
        FunctionBase.__init__(self, name, name, params, retval, docs)
        self.cls = cls

class Signal(FunctionBase):
    def __init__(self, name, cls, params, retval, docs):
        FunctionBase.__init__(self, name, name, params, retval, docs)
        self.cls = cls

class ParamBase(object):
    def __init__(self, typ, docs):
        object.__init__(self)
        self.type = typ
        self.docs = docs
        self.attributes = {}
        self.transfer_mode = None
        self.element_type = None
        self.array = False
        self.array_fixed_len = None
        self.array_len_param = None
        self.array_zero_terminated = None

class Param(ParamBase):
    def __init__(self, name, typ, docs):
        ParamBase.__init__(self, typ, docs)
        self.name = name
        self.out = False
        self.caller_allocates = False
        self.callee_allocates = False
        self.in_ = False
        self.inout = False
        self.allow_none = False
        self.default_value = None
        self.scope = 'call'

class Retval(ParamBase):
    def __init__(self, typ, docs):
        ParamBase.__init__(self, typ, docs)

class Module(object):
    def __init__(self, name):
        object.__init__(self)
        self.name = name
        self.classes = []
        self.boxed = []
        self.__class_dict = {}
        self.functions = []
        self.__methods = {}
        self.__constructors = {}
        self.__vmethods = {}
        self.__signals = {}
        self.types = {}
        self.enums = []

    def __add_class(self, pcls):
        name = pcls.name
        short_name = getattr(pcls, 'short_name', strip_module_prefix_from_class(pcls.name, self.name))
        gtype_id = getattr(pcls, 'gtype_id', make_gtype_id(pcls.name))
        docs = pcls.docs
        parent = None
        constructable = False
        annotations = {}
        for a in pcls.annotations:
            pieces = a.split()
            prefix = pieces[0]
            if prefix == 'parent':
                assert len(pieces) == 2
                parent = pieces[1]
            elif prefix == 'constructable':
                assert len(pieces) == 1
                constructable = True
            elif prefix.find('.') >= 0:
                annotations[prefix] = ' '.join(pieces[1:])
            else:
                raise RuntimeError("unknown annotation '%s' in class %s" % (a, name))
        cls = Class(name, short_name, parent, gtype_id, docs)
        cls.summary = pcls.summary
        cls.annotations = annotations
        cls.constructable = constructable
        self.classes.append(cls)
        self.__class_dict[name] = cls

    def __add_boxed_or_pointer(self, pcls, What):
        name = pcls.name
        short_name = getattr(pcls, 'short_name', strip_module_prefix_from_class(pcls.name, self.name))
        gtype_id = getattr(pcls, 'gtype_id', make_gtype_id(pcls.name))
        docs = pcls.docs
        annotations = {}
        for a in pcls.annotations:
            pieces = a.split()
            prefix = pieces[0]
            if prefix.find('.') >= 0:
                annotations[prefix] = ' '.join(pieces[1:])
            else:
                raise RuntimeError("unknown annotation '%s' in class %s" % (a, name))
        cls = What(name, short_name, gtype_id, docs)
        cls.summary = pcls.summary
        cls.annotations = annotations
        self.boxed.append(cls)
        self.__class_dict[name] = cls

    def __add_boxed(self, pcls):
        self.__add_boxed_or_pointer(pcls, Boxed)

    def __add_pointer(self, pcls):
        self.__add_boxed_or_pointer(pcls, Pointer)

    def __add_enum(self, ptyp):
        if DEBUG:
            print 'enum', ptyp.name
        name = ptyp.name
        short_name = getattr(ptyp, 'short_name', strip_module_prefix_from_class(ptyp.name, self.name))
        gtype_id = getattr(ptyp, 'gtype_id', make_gtype_id(ptyp.name))
        docs = ptyp.docs
        annotations = {}
        for a in ptyp.annotations:
            pieces = a.split()
            prefix = pieces[0]
            if prefix.find('.') >= 0:
                annotations[prefix] = ' '.join(pieces[1:])
            else:
                raise RuntimeError("unknown annotation '%s' in class %s" % (a, name))
        if isinstance(ptyp, dparser.Enum):
            enum = Enum(name, short_name, gtype_id, docs)
        else:
            enum = Flags(name, short_name, gtype_id, docs)
        for value in ptyp.values:
            attributes = self.__parse_enum_value_annotations(value.annotations)
            enum.values.append(EnumValue(value.name, attributes, value.docs))
        enum.summary = ptyp.summary
        enum.annotations = annotations
        self.enums.append(enum)

    def __parse_enum_value_annotations(self, annotations):
        attributes = {}
        for a in annotations:
            pieces = a.split()
            prefix = pieces[0]
            if '.' in prefix[1:-1] and len(pieces) == 2:
                attributes[prefix] = pieces[1]
        if attributes:
            return attributes
        else:
            return None

    def __parse_param_or_retval_annotation(self, annotation, param):
        pieces = annotation.split()
        prefix = pieces[0]
        if prefix == 'transfer':
            if len(pieces) > 2:
                raise RuntimeError("invalid annotation '%s'" % (a,))
            if not pieces[1] in ('none', 'container', 'full'):
                raise RuntimeError("invalid annotation '%s'" % (a,))
            param.transfer_mode = pieces[1]
            return True
        if prefix == 'element-type':
            if len(pieces) > 3:
                raise RuntimeError("invalid annotation '%s'" % (a,))
            if len(pieces) == 2:
                param.element_type = pieces[1]
            else:
                param.element_type = pieces[1:]
            return True
        if prefix == 'array':
            if len(pieces) == 1:
                param.array = True
                return True
            if len(pieces) > 2:
                raise RuntimeError("invalid annotation '%s'" % (a,))
            m = re.match(r'fixed-size\s*=\s*(\d+)$', pieces[1])
            if m:
                param.array_fixed_size = int(m.group(1))
                return True
            m = re.match(r'length\s*=\s*(\S+)$', pieces[1])
            if m:
                param.array_len_param = m.group(1)
                return True
            m = re.match(r'zero-terminated\s*=\s*(\d+)$', pieces[1])
            if m:
                param.array_zero_terminated = bool(int(m.group(1)))
                return True
            raise RuntimeError("invalid annotation '%s'" % (a,))
        if prefix == 'type':
            if len(pieces) > 2:
                raise RuntimeError("invalid annotation '%s'" % (a,))
            param.type = pieces[1]
            return True
        if '.' in prefix[1:-1] and len(pieces) == 2:
            param.attributes[prefix] = pieces[1]
        return False

    def __parse_param_annotation(self, annotation, param):
        pieces = annotation.split()
        prefix = pieces[0]
        if prefix == 'out':
            if len(pieces) > 2:
                raise RuntimeError("invalid annotation '%s'" % (a,))
            if len(pieces) == 1:
                param.out = True
                return True
            if pieces[1] == 'caller-allocates':
                param.out = True
                param.caller_allocates = True
                return True
            if pieces[1] == 'callee-allocates':
                param.out = True
                param.callee_allocates = True
                return True
            raise RuntimeError("invalid annotation '%s'" % (a,))
        if prefix == 'in':
            if len(pieces) > 1:
                raise RuntimeError("invalid annotation '%s'" % (a,))
            param.in_ = True
            return True
        if prefix == 'inout':
            if len(pieces) > 1:
                raise RuntimeError("invalid annotation '%s'" % (a,))
            param.inout = True
            return True
        if prefix == 'allow-none':
            if len(pieces) > 1:
                raise RuntimeError("invalid annotation '%s'" % (a,))
            param.allow_none = True
            return True
        if prefix == 'default':
            if len(pieces) != 2:
                raise RuntimeError("invalid annotation '%s'" % (a,))
            param.default_value = pieces[1]
            return True
        if prefix == 'scope':
            if len(pieces) != 2:
                raise RuntimeError("invalid annotation '%s'" % (a,))
            if not pieces[1] in ('call', 'async', 'notified'):
                raise RuntimeError("invalid annotation '%s'" % (a,))
            param.scope = pieces[1]
            return True
        if '.' in prefix[1:-1] and len(pieces) == 2:
            param.attributes[prefix] = pieces[1]
        return False

    def __parse_retval(self, pretval):
        retval = Retval(pretval.type, pretval.docs)
        if pretval.annotations:
            for a in pretval.annotations:
                if not self.__parse_param_or_retval_annotation(a, retval):
                    raise RuntimeError("invalid annotation '%s'" % (a,))
        if not retval.type:
            raise RuntimeError('return type missing')
        return retval

    def __parse_param(self, pp, pfunc):
        if DEBUG:
            print pp.name, pp.type, pp.docs
        param = Param(pp.name, pp.type, pp.docs)
        if pp.annotations:
            for a in pp.annotations:
                if self.__parse_param_or_retval_annotation(a, param):
                    pass
                elif self.__parse_param_annotation(a, param):
                    pass
                else:
                    raise RuntimeError("in %s: invalid annotation '%s'" % (pfunc.name, a,))
        if param.type is None:
            raise RuntimeError('in %s: type of param "%s" is missing' % (pfunc.name, param.name))
        return param

    def __add_vmethod(self, pfunc):
        _, cls, name = pfunc.name.split(':')
        assert _ == 'vfunc'
        params = []
        retval = None
        docs = pfunc.docs
        if pfunc.annotations:
            for a in pfunc.annotations:
                raise RuntimeError("unknown annotation '%s' in function %s" % (a, name))

        if pfunc.params:
            for p in pfunc.params:
                params.append(self.__parse_param(p, pfunc))

        if pfunc.retval:
            retval = self.__parse_retval(pfunc.retval)

        meth = VMethod(name, cls, params[1:], retval, docs)
        this_class_methods = self.__vmethods.get(cls)
        if not this_class_methods:
            this_class_methods = []
            self.__vmethods[cls] = this_class_methods
        this_class_methods.append(meth)

    def __add_signal(self, pfunc):
        _, cls, name = pfunc.name.split(':')
        assert _ == 'signal'
        params = []
        retval = None
        docs = pfunc.docs
        if pfunc.annotations:
            for a in pfunc.annotations:
                raise RuntimeError("unknown annotation '%s' in function %s" % (a, name))

        if pfunc.params:
            for p in pfunc.params:
                params.append(self.__parse_param(p, pfunc))

        if pfunc.retval:
            retval = self.__parse_retval(pfunc.retval)

        meth = Signal(name, cls, params[1:], retval, docs)
        this_class_signals = self.__signals.get(cls)
        if not this_class_signals:
            this_class_signals = []
            self.__signals[cls] = this_class_signals
        this_class_signals.append(meth)

    def __add_function(self, pfunc):
        name = pfunc.name
        c_name = pfunc.name
        params = []
        retval = None
        docs = pfunc.docs
        cls = None
        constructor_of = None
        static_method_of = None
        kwargs = False
        annotations = {}

        if pfunc.annotations:
            for a in pfunc.annotations:
                pieces = a.split()
                prefix = pieces[0]
                if prefix == 'constructor-of':
                    assert len(pieces) == 2
                    constructor_of = pieces[1]
                elif prefix == 'static-method-of':
                    assert len(pieces) == 2
                    static_method_of = pieces[1]
                elif prefix == 'moo-kwargs':
                    assert len(pieces) == 1
                    kwargs = True
                elif prefix.find('.') >= 0:
                    annotations[prefix] = ' '.join(pieces[1:])
                else:
                    raise RuntimeError("unknown annotation '%s' in function %s" % (a, name))

        if pfunc.params:
            for p in pfunc.params:
                params.append(self.__parse_param(p, pfunc))

        if pfunc.retval:
            retval = self.__parse_retval(pfunc.retval)

        if hasattr(pfunc, 'method_of'):
            cls = pfunc.method_of
        elif static_method_of:
            cls = static_method_of
        elif constructor_of:
            cls = constructor_of
        elif params:
            m = re.match(r'(const-)?([\w\d_]+)\*', params[0].type)
            if m:
                cls = m.group(2)
                if not self.__class_dict.has_key(cls):
                    cls = None

        if cls:
            name = strip_class_prefix(name, cls)
        else:
            name = strip_module_prefix(name, self.name)

        if constructor_of:
            func = Constructor(name, c_name, cls, params, retval, docs)
            if constructor_of in self.__constructors:
                raise RuntimeError('duplicated constructor of class %s' % constructor_of)
            self.__constructors[constructor_of] = func
        elif cls:
            if static_method_of:
                func = StaticMethod(name, c_name, cls, params, retval, docs)
            else:
                func = Method(name, c_name, cls, params[1:], retval, docs)
            this_class_methods = self.__methods.get(cls)
            if not this_class_methods:
                this_class_methods = []
                self.__methods[cls] = this_class_methods
            this_class_methods.append(func)
        else:
            func = Function(name, c_name, params, retval, docs)
            self.functions.append(func)

        func.summary = pfunc.summary
        func.annotations = annotations
        func.kwargs = kwargs

    def init_from_dox(self, blocks):
        for b in blocks:
            if isinstance(b, dparser.Class):
                self.__add_class(b)
            elif isinstance(b, dparser.Boxed):
                self.__add_boxed(b)
            elif isinstance(b, dparser.Pointer):
                self.__add_pointer(b)
            elif isinstance(b, dparser.Enum) or isinstance(b, dparser.Flags):
                self.__add_enum(b)
            elif isinstance(b, dparser.Flags):
                self.__add_flags(b)
            elif isinstance(b, dparser.VMethod):
                self.__add_vmethod(b)
            elif isinstance(b, dparser.Signal):
                self.__add_signal(b)
            elif isinstance(b, dparser.Function):
                self.__add_function(b)
            else:
                raise RuntimeError('oops')

        instance_types = {}
        for cls in self.classes + self.boxed:
            if cls.name in instance_types:
                raise RuntimeError('duplicated class %s' % (cls.name,))
            instance_types[cls.name] = cls

        for cls in self.__constructors:
            func = self.__constructors[cls]
            if not cls in instance_types:
                raise RuntimeError('Constructor of unknown class %s' % cls)
            else:
                cls = instance_types[cls]
                if cls.constructor is not None:
                    raise RuntimeError('duplicated constructor in class %s' % cls)
                cls.constructor = func

        for cls in self.__methods:
            methods = self.__methods[cls]
            if not cls in instance_types:
                raise RuntimeError('Methods of unknown class %s' % cls)
            else:
                cls = instance_types[cls]
                for m in methods:
                    m.cls = cls
                    if isinstance(m, Method):
                        cls.methods.append(m)
                    elif isinstance(m, StaticMethod):
                        cls.static_methods.append(m)
                    else:
                        oops()

        for cls in self.__vmethods:
            methods = self.__vmethods[cls]
            if not cls in instance_types:
                raise RuntimeError('Virtual methods of unknown class %s' % cls)
            else:
                cls = instance_types[cls]
                for m in methods:
                    m.cls = cls
                cls.vmethods += methods

        for cls in self.__signals:
            signals = self.__signals[cls]
            if not cls in instance_types:
                raise RuntimeError('Signals of unknown class %s' % cls)
            else:
                cls = instance_types[cls]
                for s in signals:
                    s.cls = cls
                cls.signals += signals

        def format_func(func):
            if func.retval and func.retval.type:
                s = func.retval.type + ' '
            else:
                s = 'void '
            s += func.name
            s += ' ('
            for i in range(len(func.params)):
                if i != 0:
                    s += ', '
                p = func.params[i]
                s += '%s %s' % (p.type, p.name)
            s += ')'
            return s

        if DEBUG:
            for cls in self.classes:
                print 'class %s' % (cls.name,)
                for meth in cls.methods:
                    print '  %s' % (format_func(meth),)
            for func in self.functions:
                print format_func(func)