#!/usr/bin/env python
# -*- coding: utf-8 -*-

## This file is part of the Nepomuk KDE project.
## Copyright (C) 2011 Sebastian Trueg <trueg@kde.org>
## Copyright (C) 2011 Serebriyskiy Artem <v.for.vandal@gmail.com>
##
## This library is free software; you can redistribute it and/or
## modify it under the terms of the GNU Lesser General Public
## License as published by the Free Software Foundation; either
## version 2.1 of the License, or (at your option) version 3, or any
## later version accepted by the membership of KDE e.V. (or its
## successor approved by the membership of KDE e.V.), which shall
## act as a proxy defined in Section 6 of version 3 of the license.
##
## This library 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
## Lesser General Public License for more details.
##
## You should have received a copy of the GNU Lesser General Public
## License along with this library.  If not, see <http://www.gnu.org/licenses/>.


import argparse
import sys
import os, errno
from PyKDE4.soprano import Soprano
from PyQt4 import QtCore

output_path = os.getcwd()
verbose = True

# A list of C++ reserved keywords which we need to handle
cppKeywords = ['class', 'int', 'float', 'double']

def normalizeName(name):
    "Normalize a class or property name to be used as a C++ entity."
    name.replace('-', '_')
    name.replace('.', '_')
    return name

def extractNameFromUri(uri):
    "Extract the class or property name from an entity URI. This is the last section of the URI"
    name = uri.toString().mid(uri.toString().lastIndexOf(QtCore.QRegExp('[#/:]'))+1)
    return normalizeName(name)

def makeFancy(name, cardinality):
    if name.startsWith("has"):
        name = name[3].toLower() + name.mid(4)
    if cardinality != 1:
        if name.endsWith('s'):
            name = name + 'es'
        else:
            name = name + 's'

    return normalizeName(name)

def extractOntologyName(uri):
    "The name of the ontology is typically the section before the name of the entity"
    return uri.toString().section(QtCore.QRegExp('[#/:]'), -2, -2)

def mkdir_p(path):
    "Create a folder and all its missing parent folders"
    try:
        os.makedirs(path)
    except OSError as exc: # Python >2.5
        if exc.errno == errno.EEXIST:
            pass
        else: raise

def typeString(rdfType, cardinality):
    """
    Construct the C++/Qt type to be used for the given type and cardinality.
    Uses QUrl for all non-literal types
    """
    if (rdfType == Soprano.Vocabulary.XMLSchema.string() or rdfType == Soprano.Vocabulary.RDFS.Literal()) and cardinality != 1:
        return 'QStringList'

    simpleType = ''
    if rdfType == Soprano.Vocabulary.XMLSchema.integer(): simpleType = "qint64"
    elif rdfType == Soprano.Vocabulary.XMLSchema.negativeInteger(): simpleType = "qint64"
    elif rdfType == Soprano.Vocabulary.XMLSchema.nonNegativeInteger(): simpleType = "quint64"
    elif rdfType == Soprano.Vocabulary.XMLSchema.xsdLong(): simpleType = "qint64"
    elif rdfType == Soprano.Vocabulary.XMLSchema.unsignedLong(): simpleType = "quint64"
    elif rdfType == Soprano.Vocabulary.XMLSchema.xsdInt(): simpleType = "qint32"
    elif rdfType == Soprano.Vocabulary.XMLSchema.unsignedInt(): simpleType = "quint32"
    elif rdfType == Soprano.Vocabulary.XMLSchema.xsdShort(): simpleType = "qint16"
    elif rdfType == Soprano.Vocabulary.XMLSchema.unsignedShort(): simpleType = "quint16"
    elif rdfType == Soprano.Vocabulary.XMLSchema.xsdFloat(): simpleType = "double"
    elif rdfType == Soprano.Vocabulary.XMLSchema.xsdDouble(): simpleType = "double"
    elif rdfType == Soprano.Vocabulary.XMLSchema.boolean(): simpleType = "bool"
    elif rdfType == Soprano.Vocabulary.XMLSchema.date(): simpleType = "QDate"
    elif rdfType == Soprano.Vocabulary.XMLSchema.time(): simpleType = "QTime"
    elif rdfType == Soprano.Vocabulary.XMLSchema.dateTime(): simpleType = "QDateTime"
    elif rdfType == Soprano.Vocabulary.XMLSchema.string(): simpleType = "QString"
    elif rdfType == Soprano.Vocabulary.RDFS.Literal(): simpleType = "QString"
    else: simpleType = 'QUrl'

    if cardinality != 1:
        return 'QList<%s>' % simpleType
    else:
        return simpleType


class OntologyParser():
    def __init__(self):
        self.model = Soprano.createModel()

    def parseFile(self, path):
        parser = Soprano.PluginManager.instance().discoverParserForSerialization(Soprano.SerializationTrig)
        if not parser:
            return False
        it = parser.parseFile(path, QtCore.QUrl("dummy"), Soprano.SerializationTrig)
        while it.next():
            self.model.addStatement(it.current())
        if parser.lastError():
            return False;

        return True

    def writeAll(self):

        # add rdfs:Resource as domain for all properties without a domain
        query = 'select ?p where { ?p a %s . OPTIONAL { ?p %s ?d . } . FILTER(!BOUND(?d)) . }' \
                 % (Soprano.Node.resourceToN3(Soprano.Vocabulary.RDF.Property()), \
                         Soprano.Node.resourceToN3(Soprano.Vocabulary.RDFS.domain()))
        nodes = self.model.executeQuery(query, Soprano.Query.QueryLanguageSparql).iterateBindings(0).allNodes()
        for p in nodes:
            self.model.addStatement(p, Soprano.Node(Soprano.Vocabulary.RDFS.domain()), Soprano.Node(Soprano.Vocabulary.RDFS.Resource()))
        
        # cache a few values we need more than once
        self.rdfsResourceProperties = self.getPropertiesForClass(Soprano.Vocabulary.RDFS.Resource())

        query = 'select distinct ?uri ?label ?comment where {{ ?uri a {0} . ?uri {1} ?label . OPTIONAL {{ ?uri {2} ?comment . }} . }}' \
            .format(Soprano.Node.resourceToN3(Soprano.Vocabulary.RDFS.Class()), \
                         Soprano.Node.resourceToN3(Soprano.Vocabulary.RDFS.label()), \
                         Soprano.Node.resourceToN3(Soprano.Vocabulary.RDFS.comment()))
        it = self.model.executeQuery(query, Soprano.Query.QueryLanguageSparql)
        
        while it.next():
            uri = it['uri'].uri()
            if verbose:
                print "Parsing class: ", uri
            ns = self.getNamespaceAbbreviationForUri(uri)
            name = extractNameFromUri(uri)
            self.writeHeader(uri, ns, name, it['label'].toString(), it['comment'].toString())
            print "\n\n"

    def getNamespaceAbbreviationForUri(self, uri):
        query = "select ?ns where { graph ?g { %s ?p ?o . } . ?g %s ?ns . } LIMIT 1" \
            % (Soprano.Node.resourceToN3(uri), \
               Soprano.Node.resourceToN3(Soprano.Vocabulary.NAO.hasDefaultNamespaceAbbreviation()))
        it = self.model.executeQuery(query, Soprano.Query.QueryLanguageSparql)
        if it.next():
            return it[0].toString().toLower()
        else:
            return extractOntologyName(uri)

    def getParentClasses(self, uri):
        """
        Returns a dict which maps parent class URIs to a dict containing keys 'ns' and 'name'
        Only parent classes that are actually generated are returned.
        """
        query = "select distinct ?uri where {{ {0} {1} ?uri . ?uri a {2} . }}" \
             .format(Soprano.Node.resourceToN3(uri), \
                          Soprano.Node.resourceToN3(Soprano.Vocabulary.RDFS.subClassOf()), \
                          Soprano.Node.resourceToN3(Soprano.Vocabulary.RDFS.Class()))
        it = self.model.executeQuery(query, Soprano.Query.QueryLanguageSparql)
        classes = {}
        while it.next():
            puri = it['uri'].uri()
            if puri != Soprano.Vocabulary.RDFS.Resource():
                cd = {}
                cd['ns'] = self.getNamespaceAbbreviationForUri(puri)
                cd['name'] = extractNameFromUri(puri)
                classes[puri.toString()] = cd
        return classes

    def getFullParentHierarchy(self, uri, currentParents, result):
        """
        Returns a list of dicts containing keys 'ns' and 'name'.
        currentParents is a running variable used to avoid endless loops when recursing. It should
        always be set to the empty list [].
        result is another running variable which stores the final result set. It should also be set
        to the empty list [].
        """
        # we perform a depth-first search for the most general type
        directParents = self.getParentClasses(uri)
        for p in directParents.keys():
            if not p in currentParents:
                currentParents.append(p)
                self.getFullParentHierarchy(QtCore.QUrl(p), currentParents, result)
                result.append(directParents[p])
        return result

    def getPropertiesForClass(self, uri):
        query = "select distinct ?p ?range ?comment ?c ?mc where { ?p a %s . ?p %s %s . ?p %s ?range . OPTIONAL { ?p %s ?comment . } . OPTIONAL { ?p %s ?c . } . OPTIONAL { ?p %s ?mc . } . }" \
            % (Soprano.Node.resourceToN3(Soprano.Vocabulary.RDF.Property()),
               Soprano.Node.resourceToN3(Soprano.Vocabulary.RDFS.domain()),
               Soprano.Node.resourceToN3(uri),
               Soprano.Node.resourceToN3(Soprano.Vocabulary.RDFS.range()),
               Soprano.Node.resourceToN3(Soprano.Vocabulary.RDFS.comment()),
               Soprano.Node.resourceToN3(Soprano.Vocabulary.NRL.cardinality()),
               Soprano.Node.resourceToN3(Soprano.Vocabulary.NRL.maxCardinality()))
        it = self.model.executeQuery(query, Soprano.Query.QueryLanguageSparql)
        #print "Property query done."
        properties = {}
        while it.next():
            p = it['p'].uri()
            r = it['range'].uri()
            comment = it['comment'].toString()
            c = 0
            if it['c'].isValid():
                c = it['c'].literal().toInt()
            else:
                c = it['mc'].literal().toInt()
            properties[p] = dict([('range', r), ('cardinality', c), ('comment', comment)])
        return properties

    def writeComment(self, theFile, text, indent):
        maxLine = 50;

        theFile.write(' ' * indent*4)
        theFile.write("/**\n")
        theFile.write(' ' * (indent*4+1))
        theFile.write("* ")

        words = QtCore.QString(text).split( QtCore.QRegExp("\\s"), QtCore.QString.SkipEmptyParts )
        cnt = 0;
        for i in range(words.count()):
            if cnt >= maxLine:
                theFile.write('\n')
                theFile.write(' ' * (indent*4+1))
                theFile.write("* ")
                cnt = 0;
            theFile.write(words[i])
            theFile.write(' ')
            cnt += words[i].length()

        theFile.write('\n')
        theFile.write(' ' * (indent*4+1))
        theFile.write("*/\n")

    def writeGetter(self, theFile, prop, name, propRange, cardinality):
        fancyName = makeFancy(name, cardinality)
        if fancyName in cppKeywords:
            fancyName = 'get' + fancyName[0].toUpper() + fancyName.mid(1)
        theFile.write('    %s %s() const {\n' % (typeString(propRange, cardinality), fancyName))
        theFile.write('        %s value;\n' % typeString(propRange, cardinality))
        if cardinality == 1:
            theFile.write('        if(contains(QUrl::fromEncoded("%s", QUrl::StrictMode)))\n' % prop.toString())
            theFile.write('            value = property(QUrl::fromEncoded("{0}", QUrl::StrictMode)).first().value<{1}>();\n'.format(prop.toString(), typeString(propRange, 1)))
        else:
            theFile.write('        foreach(const QVariant& v, property(QUrl::fromEncoded("%s", QUrl::StrictMode)))\n' % prop.toString())
            theFile.write('            value << v.value<{0}>();\n'.format(typeString(propRange, 1)))
        theFile.write('        return value;\n')
        theFile.write('    }\n')

    def writeSetter(self, theFile, prop, name, propRange, cardinality):
        theFile.write('    void set%s%s(const %s& value) {\n' % (makeFancy(name, cardinality)[0].toUpper(), makeFancy(name, cardinality).mid(1), typeString(propRange, cardinality)))
        theFile.write('        QVariantList values;\n')
        if cardinality == 1:
            theFile.write('        values << value;\n')
        else:
             theFile.write('        foreach(const %s& v, value)\n' % typeString(propRange, 1))
             theFile.write('            values << v;\n')
        theFile.write('        setProperty(QUrl::fromEncoded("%s", QUrl::StrictMode), values);\n' % prop.toString())
        theFile.write('    }\n')

    def writeAdder(self, theFile, prop, name, propRange, cardinality):
        theFile.write('    void add%s%s(const %s& value) {\n' % (makeFancy(name, 1)[0].toUpper(), makeFancy(name, 1).mid(1), typeString(propRange, 1)))
        theFile.write('        addProperty(QUrl::fromEncoded("%s", QUrl::StrictMode), value);\n' % prop.toString())
        theFile.write('    }\n')

    def writeHeader(self, uri, nsAbbr, className, label, comment):
        # Construct paths
        relative_path = nsAbbr + '/' + className.toLower() + '.h'
        folder = output_path + '/' + nsAbbr
        filePath = output_path + '/' + relative_path

        if verbose:
            print "Writing header file: %s" % filePath

        # Create the containing folder
        mkdir_p(QtCore.QFile.encodeName(folder).data())

        # open the header file
        header = open(filePath, 'w')

        # get all direct base classes
        parentClasses = self.getParentClasses(uri)

        # write protecting ifdefs
        header_protect = '_%s_%s_H_' % (nsAbbr.toUpper(), className.toUpper())
        header.write('#ifndef %s\n' % header_protect)
        header.write('#define %s\n' % header_protect)
        header.write('\n')
        
        # write default includes
        header.write('#include <QtCore/QVariant>\n')
        header.write('#include <QtCore/QStringList>\n')
        header.write('#include <QtCore/QUrl>\n')
        header.write('#include <QtCore/QDate>\n')
        header.write('#include <QtCore/QTime>\n')
        header.write('#include <QtCore/QDateTime>\n')
        header.write('\n')

        # all classes need the SimpleResource include
        header.write('#include <nepomuk/simpleresource.h>\n\n')

        # write includes for the parent classes
        parentClassNames = []
        for parent in parentClasses.keys():
            header.write('#include "%s/%s.h"\n' % (parentClasses[parent]['ns'], parentClasses[parent]['name'].toLower()))
            parentClassNames.append("%s::%s" %(parentClasses[parent]['ns'].toUpper(), parentClasses[parent]['name']))

        # get all base classes which we require due to the virtual base class constructor ordering in C++
        # We inverse the order to match the virtual inheritance constructor calling order
        fullParentHierarchyNames = []
        for parent in self.getFullParentHierarchy(uri, [], []):
            fullParentHierarchyNames.append("%s::%s" %(parent['ns'].toUpper(), parent['name']))

        if len(parentClassNames) > 0:
            header.write('\n')

        # write the class namespace
        header.write('namespace Nepomuk {\n')
        header.write('namespace %s {\n' % nsAbbr.toUpper())

        # write the class + parent classes
        # We use virtual inheritance when deriving from SimpleResource since our ontologies
        # make use of multi-inheritance and without it the compiler would not know which
        # addProperty and friends to call.
        # We need to do the same with all parent classes since some classes like
        # nco:CellPhoneNumber as derived from other classes that have yet another parent
        # class in common which is not SimpleResource.
        self.writeComment(header, comment, 0)
        header.write('class %s' % className)
        header.write(' : ')
        header.write(', '.join(['public virtual %s' % (p) for p in parentClassNames]))
        if len(parentClassNames) == 0:
            header.write('public virtual Nepomuk::SimpleResource');
        header.write('\n{\n')
        header.write('public:\n')

        # write the default constructor
        # We directly set the type of the class to the SimpleResource. If the class is a base class
        # not derived from any other classes then we set the type directly. Otherwise we use the
        # protected constructor defined below which takes a type as parameter making sure that we
        # only add one type instead of the whole hierarchy
        header.write('    %s(const QUrl& uri = QUrl())\n' % className)
        header.write('      : ')
        header.write('SimpleResource(uri)')
        if len(parentClassNames) > 0:
            header.write(', ')
            header.write(', '.join([('%s(uri, QUrl::fromEncoded("' + uri.toString().toUtf8().data() + '", QUrl::StrictMode))') % p for p in fullParentHierarchyNames]))
        header.write(' {\n')
        if len(parentClassNames) == 0:
            header.write('        addType(QUrl::fromEncoded("%s", QUrl::StrictMode));\n' % uri.toString())
        header.write('    }\n\n')

        # write the copy constructor
        header.write('    %s(const SimpleResource& res)\n' % className)
        header.write('      : ')
        header.write('SimpleResource(res)')
        if len(parentClassNames) > 0:
            header.write(', ')
            header.write(', '.join([('%s(res, QUrl::fromEncoded("' + uri.toString().toUtf8().data() + '", QUrl::StrictMode))') % p for p in fullParentHierarchyNames]))
        header.write(' {\n')
        if len(parentClassNames) == 0:
            header.write('        addType(QUrl::fromEncoded("%s", QUrl::StrictMode));\n' % uri.toString())
        header.write('    }\n\n')

        # write the assignment operator
        header.write('    %s& operator=(const SimpleResource& res) {\n' % className)
        header.write('        SimpleResource::operator=(res);\n')
        header.write('        addType(QUrl::fromEncoded("%s", QUrl::StrictMode));\n' % uri.toString())
        header.write('        return *this;\n')
        header.write('    }\n\n')

        # Write getter and setter methods for all properties
        # This includes the properties that have domain rdfs:Resource on base classes, ie.
        # those that are not derived from any other class. That way these properties are
        # accessible from all classes.
        properties = self.getPropertiesForClass(uri)
        if len(parentClassNames) == 0:
            properties.update(self.rdfsResourceProperties)

        # There could be properties with the same name - in that case we give the methods a prefix
        for p in properties.keys():
            name = extractNameFromUri(p)
            cnt = 0
            # search for the same name again
            for op in properties.keys():
                if extractNameFromUri(op) == name:
                    cnt+=1
            if cnt > 1:
                name = self.getNamespaceAbbreviationForUri(p).toLower() + name[0].toUpper() + name.mid(1)
            properties[p]['name'] = name;
            
        for p in properties.keys():
            self.writeComment(header, 'Get property %s. %s' % (p.toString(), properties[p]['comment']), 1)
            self.writeGetter(header, p, properties[p]['name'], properties[p]['range'], properties[p]['cardinality'])
            header.write('\n')
            self.writeComment(header, 'Set property %s. %s' % (p.toString(), properties[p]['comment']), 1)
            self.writeSetter(header, p, properties[p]['name'], properties[p]['range'], properties[p]['cardinality'])
            header.write('\n')
            self.writeComment(header, 'Add value to property %s. %s' % (p.toString(), properties[p]['comment']), 1)
            self.writeAdder(header, p, properties[p]['name'], properties[p]['range'], properties[p]['cardinality'])
            header.write('\n')

        # write the protected constructors which avoid adding the whole type hierarchy
        header.write('protected:\n')
        header.write('    %s(const QUrl& uri, const QUrl& type)\n' % className)
        header.write('      : ')
        header.write('SimpleResource(uri)')
        if len(parentClassNames) > 0:
            header.write(', ')
            header.write(', '.join(['%s(uri, type)' % p for p in fullParentHierarchyNames]))
        header.write(' {\n')
        if len(parentClassNames) == 0:
            header.write('        addType(type);\n')
        header.write('    }\n')

        header.write('    %s(const SimpleResource& res, const QUrl& type)\n' % className)
        header.write('      : ')
        header.write('SimpleResource(res)')
        if len(parentClassNames) > 0:
            header.write(', ')
            header.write(', '.join(['%s(res, type)' % p for p in fullParentHierarchyNames]))
        header.write(' {\n')
        if len(parentClassNames) == 0:
            header.write('        addType(type);\n')
        header.write('    }\n')

        # close the class
        header.write('};\n')

        # write the closing parenthesis for the namespaces
        header.write('}\n}\n')

        # write the closing preprocessor thingi
        header.write('\n#endif\n')
        

def main():
    global output_path
    global verbose
    
    usage = "Usage: %prog [options] ontologyfile1 ontologyfile2 ..."
    optparser = argparse.ArgumentParser(description="Nepomuk SimpleResource code generator. It will generate a hierarchy of simple wrapper classes around Nepomuk::SimpleResource which provide convinience methods to get and set properties of those classes. Each wrapper class will be defined in its own header file and be written to a subdirectory named as the default ontology prefix. Example: the header file for nao:Tag would be written to nao/tag.h and be defined in the namespace Nepomuk::NAO.")
    optparser.add_argument('--output', '-o', type=str, nargs=1, metavar='PATH', dest='output', help='The destination folder')
    optparser.add_argument('--quiet', '-q', action="store_false", dest="verbose", default=True, help="don't print status messages to stdout")
    optparser.add_argument("ontologies", type=str, nargs='+', metavar="ONTOLOGY", help="Ontology files to use")

    args = optparser.parse_args()
    if args.output :
        output_path = args.output[0]

    verbose = args.verbose

    if verbose:
        print 'Generating from ontology files %s' % ','.join(args.ontologies)
        print 'Writing files to %s.' % output_path

    # Parse all ontology files
    ontoParser = OntologyParser()
    for f in args.ontologies:
        if verbose:
            print "Reading ontology '%s'" % f
        ontoParser.parseFile(f)
    if verbose:
        print "All ontologies read. Generating code..."

    # Get all classes and handle them one by one
    ontoParser.writeAll()

if __name__ == "__main__":
    main()
