# Copyright (c) 2007-2010 Nokia Corporation and/or its subsidiary(-ies) All rights reserved.

# This component and the accompanying materials are made available under the terms of the License 

# "Eclipse Public License v1.0" which accompanies this distribution, 

# and is available at the URL "http://www.eclipse.org/legal/epl-v10.html".

#

# Initial Contributors:

# Nokia Corporation - initial contribution.

#

# Contributors:

#

# Description:

# Checks links in DITA XML and reports issues.

"""

Created on 24 May 2010

@author: p2ross

"""

import os

import sys

import logging

#import pprint

#import fnmatch

#import re

import string

import time

from optparse import OptionParser#, check_choice

try:

    from xml.etree import cElementTree as etree

except ImportError:

    from xml.etree import ElementTree as etree

#import multiprocessing

__version__ = "0.1.0"

class XsdBase(object):

    PREFIX = '{http://www.w3.org/2001/XMLSchema}'

    def _addSchemaPrefix(self, theTag):

        return '%s%s' % (self.PREFIX, theTag)

    def _tagSchemaMatches(self, theN, theTag):

        return theN.tag == self._addSchemaPrefix(theTag)

    def _tagSchemaMatchesList(self, theN, theTagS):

        for aTag in theTagS:

            if theN.tag == self._addSchemaPrefix(aTag):

                return True

        return False

    def _stripSchemaPrefix(self, theN):

        """Returns theNode.tag without the schema prefix."""

        return theN.tag[len(self.PREFIX):]

class XsdNodeBase(XsdBase):

    PREFIX = '{http://www.w3.org/2001/XMLSchema}'

    def __init__(self, theN):

        super(XsdNodeBase, self).__init__()

        self._name = theN.get('name')

        self._ref = theN.get('ref')

        # This will be prefix+element

        self._tag = theN.tag

        self._min = int(theN.get('minOccurs') or 1)

        if theN.get('maxOccurs') == 'unbounded':

            self._max = -1

        else:

            self._max = int(theN.get('maxOccurs') or 1)

        logging.debug(

            'XsdNodeBase.__init__(): tag=%s, name=%s, ref=%s, min=%d, max=%d',

            self.tag,

            self._name,

            self._ref,

            self._min,

            self._max,

            )

    @property

    def tag(self):

        return self._tag[len(self.PREFIX):]

    @property

    def attrRef(self):

        return self._ref

    @property

    def attrName(self):

        return self._name

    @property

    def isUnbounded(self):

        return self._max == -1

    @property

    def minOccurs(self):

        return self._min

    @property

    def maxOccurs(self):

        return self._max

    @property

    def boundedString(self):

        """Returns a natural language description of bounds."""

        if self._min == 1 and self._max == 1:

            return ''

        elif self._min == 0:

            if self._max == 1:

                # minOccurs="0" -> 'optional'

                return 'optional'

            elif self.isUnbounded:

                # minOccurs="0" maxOccurs="unbounded" -> 'any number'

                return 'any number'

            else:

                # minOccurs="0" maxOccurs="42" -> 'up to 42'

                return 'up to %d' % self._max

        elif self.isUnbounded:

            # minOccurs="17" maxOccurs="unbounded" -> 'at least 17'

            return 'at least %d' % self._min

        # minOccurs="17" maxOccurs="42" -> 'at least 17 and up to 42'

        return 'at least %d, and up to %d' % (self._min, self._max)

class Attribute(XsdNodeBase):

    """Represents an element describing an attribute."""

    def __init__(self, theN):

        super(Attribute, self).__init__(theN)

        assert(self._tagSchemaMatches(theN, 'attribute'))

        self._default = theN.get('default')

        self._use = theN.get('use')

    @property

    def default(self):

        return self._default

    @property

    def use(self):

        return self._use

class RefBase(XsdNodeBase):

    """Represents a reference to a group or element"""

    def __init__(self, theN):

        super(RefBase, self).__init__(theN)

        assert(self._tagSchemaMatchesList(theN, ('group', 'element')))

        assert(self.attrRef is not None)

    @property

    def isSequence(self):

        return False

class RefSequence(XsdNodeBase):

    """Holds information on an xs:all, xs:choice or xs:sequence."""

    def __init__(self, theN):

        super(RefSequence, self).__init__(theN)

        assert(self._tagSchemaMatchesList(theN, ('all', 'choice', 'sequence'))), 'Tag %s not in list' % theN.tag

        # List of class RefBase or, recursively, a class RefSequence

        self._refS = []

        self._type = self.tag

        for aChild in theN.getchildren():

            if not self._tagSchemaMatchesList(aChild, ('group', 'all', 'choice', 'sequence')):

                continue

            #self._type = self._stripSchemaPrefix(aChild)

            if self._tagSchemaMatches(aChild, 'group'):

                self._refS.append(RefBase(aChild))

            elif self._tagSchemaMatchesList(

                        aChild,

                        ('choice', 'sequence', 'any',)

                    ):

                self._refS.append(RefSequence(aChild))

    def genRefs(self):

        """Generates the list of RefBase or RefSequence"""

        for aRef in self._refS:

            yield aRef

    @property

    def numRefs(self):

        return len(self._refS)

    @property

    def refs(self):

        return self._refS

    @property

    def isSequence(self):

        return True

    def qualifierString(self):

        if self._type == 'all':

            return '(any number, any order)'

        elif self._type == 'choice':

            return '(any number)'

        elif self._type == 'sequence':

            return ''

        return 'Unknown'

    def joinString(self):

        if self._type == 'all':

            return ' or '

        elif self._type == 'choice':

            return ' or '

        elif self._type == 'sequence':

            return ' then '

        return ''

    @property

    def seqType(self):

        return self._type

class DefBase(XsdNodeBase):

    """Represents a definition of a group, element or complexType"""

    def __init__(self, theN):

        super(DefBase, self).__init__(theN)

        assert(self._tagSchemaMatchesList(theN, ('group', 'element', 'complexType'))), 'Tag %s not in list' % theN.tag

        assert(self.attrName is not None or self._tagSchemaMatches(theN, 'complexType'))

        # List of class RefBase of class RefSequence

        self._refS = []

    def genRefs(self):

        """Generates the list of RefBase"""

        for aRef in self._refS:

            yield aRef

    @property

    def numRefs(self):

        return len(self._refS)

    @property

    def refs(self):

        return self._refS

class GroupDef(DefBase):

    """Represents the definition of a group i.e. <xs:group name="...">...</xs:group>.

    See: http://www.w3.org/TR/2004/REC-xmlschema-1-20041028/structures.html#element-group"""

    def __init__(self, theN):

        super(GroupDef, self).__init__(theN)

        assert(theN.tag == self._addSchemaPrefix('group'))

        # http://www.w3.org/TR/2004/REC-xmlschema-1-20041028/structures.html#element-group

        # Content: (annotation?, (all | choice | sequence)?)

        self._type = None

        for aChild in theN.getchildren():

            if self._tagSchemaMatchesList(aChild, ('all', 'choice', 'sequence')):

                self._type = self._stripSchemaPrefix(aChild)

            else:

                # Unrecognised element or annotation

                continue

            if self._type is not None:

                # Read grand children and break

                for aGrandChild in aChild.getchildren():

                    if aGrandChild.get('ref') is not None \

                    and self._tagSchemaMatchesList(

                                aGrandChild,

                                (

                                    'element',

                                    'group',

                                    #'choice',

                                    #'sequence',

                                    #'any',

                                )):

                        self._refS.append(RefBase(aGrandChild))

                break

    def __str__(self):

        #print 'TRACE:', self._refS

        return self.joinString().join(['%s' % r.attrRef for r in self._refS]) \

            + ' ' \

            + self.qualifierString() 

    def qualifierString(self):

        if self._type == 'all':

            return '(any number, any order)'

        elif self._type == 'choice':

            return '(any number)'

        elif self._type == 'sequence':

            return ''

        return 'Unknown'

    def joinString(self):

        if self._type == 'all':

            return ' or '

        elif self._type == 'choice':

            return ' or '

        elif self._type == 'sequence':

            return ' then '

        return ''

    @property

    def groupType(self):

        return self._type

class ComplexTypeDef(DefBase):#XsdNodeBase):

    """Represents the definition of a complexType definition i.e. <xs:complexType name="...">...</xs:group>.

    See: http://www.w3.org/TR/2004/REC-xmlschema-1-20041028/structures.html#element-complexType"""

    def __init__(self, theN):

        super(ComplexTypeDef, self).__init__(theN)

        assert(theN.tag == self._addSchemaPrefix('complexType'))

        # http://www.w3.org/TR/2004/REC-xmlschema-1-20041028/structures.html#element-complexType

        # Simplified content: ((group | all | choice | sequence)?

        self._type = None

        # Get xs:attribute

        self._attrS = []

        for aChild in theN.getchildren():

            # We only handle complexType

            if not self._tagSchemaMatchesList(

                    aChild,

                    ('group', 'all', 'choice', 'sequence', 'attribute')):

                # Unrecognised element or annotation

                continue

            self._type = self._stripSchemaPrefix(aChild)

            if self._tagSchemaMatches(aChild, 'group'):

                self._refS.append(RefBase(aChild))

            elif self._tagSchemaMatchesList(

                                aChild,

                                ('choice', 'sequence', 'any',),

                                ):

                self._refS.append(RefSequence(aChild))

            elif self._tagSchemaMatches(aChild, 'attribute'):

                self._attrS.append(Attribute(aChild))

    @property

    def groupType(self):

        return self._type

    def namedAttribute(self, theName):

        """Returns an Attribute object or None."""

        for anA in self._attrS:

            if anA.attrName == theName:

                return anA

class ElementDef(DefBase):

    """Represents the definition of a element definition i.e. <xs:element name="...">...</xs:group>.

    See: http://www.w3.org/TR/2004/REC-xmlschema-1-20041028/structures.html#element-group"""

    def __init__(self, theN):

        super(ElementDef, self).__init__(theN)

        assert(theN.tag == self._addSchemaPrefix('element'))

        # http://www.w3.org/TR/2004/REC-xmlschema-1-20041028/structures.html#element-element

        # Simplified content: (annotation?, ((simpleType | complexType)?

        self._type = None

        self._complexType = None

        for aChild in theN.getchildren():

            # We only handle complexType

            if not self._tagSchemaMatchesList(aChild, ('complexType',)):

                # Unrecognised element or annotation

                continue

            # Process a <complexType>

            self._complexType = ComplexTypeDef(aChild)

            break

    @property

    def complexType(self):

        return self._complexType

class GroupRef(RefBase):

    """Represents a reference of a group i.e. <xs:group ref="..." .../>.

    See: http://www.w3.org/TR/2004/REC-xmlschema-1-20041028/structures.html#element-group"""

    def __init__(self, theN):

        super(GroupRef, self).__init__(theN)

        assert(theN.tag == self._addSchemaPrefix('group'))

class ElementRef(RefBase):

    """Represents a reference to an element i.e. <xs:element ref="..." .../>.

    See: http://www.w3.org/TR/2004/REC-xmlschema-1-20041028/structures.html#element-group"""

    def __init__(self, theN):

        super(ElementRef, self).__init__(theN)

        assert(theN.tag == self._addSchemaPrefix('element'))

class XsdToPackageDef(XsdBase):

    """Create a PackageDef.xml file from a set of XSD files."""

    DUMP_PREFIX = '  '

    def __init__(self, thePrefix):#, theOutFile=None, theTitle=''):

        super(XsdToPackageDef, self).__init__()

        # Maps of group definitions and references

        self._groupDefMap = {}

        self._groupRefMap = {}

        # Maps of element definitions and references

        self._elemDefMap = {}

        self._elemRefMap = {}

        # Top level complex types

        self._complexTypeMap = {}

        # Element prefix

        self._prefix = thePrefix

    ##########################

    # Section: Add an XSD file

    ##########################

    def addXsdFile(self, thePath):

        """Read an XSD and add it to the representation."""

        t = etree.parse(thePath)

        r = t.getroot()

        self._addGroups(r)

        self._addElements(r)

        self._addComplexTypes(r)

    def addXsdPath(self, thePath):

        if os.path.isfile(thePath):

            if os.path.splitext(thePath)[1].lower() == '.xsd':

                self.addXsdFile(thePath)

        elif os.path.isdir(thePath):

            for aName in os.listdir(thePath):

                self.addXsdPath(os.path.join(thePath, aName))

    def _addGroups(self, root):

        """Adds to the group maps."""

        for anE in root.getchildren():

            if self._tagSchemaMatches(anE, 'group'):

                if anE.get('name') is not None:

                    self._groupDefMap[anE.get('name')] = GroupDef(anE)

                elif anE.get('ref') is not None:

                    self._groupRefMap[anE.get('ref')] = GroupRef(anE)

    def _addElements(self, root):

        """Adds to the element maps."""

        for anE in root.getchildren():

            if self._tagSchemaMatches(anE, 'element'):

                if anE.get('name') is not None:

                    self._elemDefMap[anE.get('name')] = ElementDef(anE)

                elif anE.get('ref') is not None:

                    self._elemRefMap[anE.get('ref')] = ElementRef(anE)

    def _addComplexTypes(self, root):

        for anE in root.getchildren():

            if self._tagSchemaMatches(anE, 'complexType'):

                self._complexTypeMap[anE.get('name')] = ComplexTypeDef(anE)

    ##########################

    # End: Add an XSD file

    ##########################

    ##########################

    # Section: Query the IR

    ##########################

    def elemContains(self, theElemName):

        """Returns a list of immediate child elements that this element contains."""

        logging.debug('elemContains(%s)' % theElemName)

        retVal = []

        if not self._elemDefMap.has_key(theElemName):

            return retVal

        myElem = self._elemDefMap[theElemName]

        if myElem.complexType is not None:

            logging.debug('elemContains(): complexType: %s', myElem.complexType)

            #print 'myElem', myElem

            for aRef in myElem.complexType.genRefs():

                logging.debug('elemContains(): complexType tag: %s, attrRef: %s',

                              aRef.tag,

                              aRef.attrRef,

                        )

                self._addFromComplexTypeSequence(aRef, retVal)

#                myRef = aRef.attrRef

#                #print 'myRef', myRef

#                #if self._elemDefMap.has_key(myRef):

#                #    retVal.append(myRef)

#                if self._groupDefMap.has_key(myRef):

#                    self._addContainsGroup(myRef, retVal)

#                else:

#                    retVal.append(myRef)

        logging.debug('elemContains(%s) returns %s', theElemName, str(retVal))

        return retVal

    def _addFromComplexTypeSequence(self, theRefObj, theList):

        """Recursively add containing elements."""

        myRef = theRefObj.attrRef

        logging.debug('_addFromComplexTypeSequence(%s):', myRef) 

        if theRefObj.isSequence:

            for aSubRef in theRefObj.refs:

                logging.debug('_addFromComplexTypeSequence(): recursing on: %s',

                              myRef)

                self._addFromComplexTypeSequence(aSubRef, theList)

        elif myRef is not None:

            if self._groupDefMap.has_key(myRef):

                self._addContainsGroup(myRef, theList)

            else:

                logging.debug('_addFromComplexTypeSequence(): adding: %s',

                              myRef)

                theList.append(myRef)

    def _addContainsGroup(self, theRef, theList):

        logging.debug('_addContainsGroup(%s)' % theRef)

        assert(self._groupDefMap.has_key(theRef))

        for aRef in self._groupDefMap[theRef].genRefs():

            #print 'TRACE: aRef', aRef.tag

            logging.debug('_addContainsGroup(): aRef.tag: %s aRef.attrRef: %s' \

                          % (aRef.tag, aRef.attrRef))

            if aRef.tag == 'element':

                theList.append(aRef.attrRef)

            elif aRef.tag == 'group' and self._groupDefMap.has_key(aRef.attrRef):

                self._addContainsGroup(aRef.attrRef, theList)

    ##########################

    # End: Query the IR

    ##########################

    ##########################

    # Section: Debug/trace

    ##########################

    def dump(self, s=sys.stdout):

        s.write(' Group definitions '.center(75, '-')+'\n')

        keyS = self._groupDefMap.keys()

        keyS.sort()

        for k in keyS:

            s.write('%40s : %s\n' % (k, self._groupDefMap[k]))

        s.write(' EOL '.center(75, '-')+'\n\n') 

        s.write(' Group references '.center(75, '-')+'\n') 

        keyS = self._groupRefMap.keys()

        keyS.sort()

        for k in keyS:

            s.write('%40s : %s\n' % (k, self._groupRefMap[k]))

        s.write(' EOL '.center(75, '-')+'\n\n') 

        s.write(' Element definitions '.center(75, '-')+'\n') 

        keyS = self._elemDefMap.keys()

        keyS.sort()

        for k in keyS:

            s.write('%40s : %s\n' % (k, self._elemDefMap[k]))

        s.write(' EOL '.center(75, '-')+'\n\n') 

        s.write(' Element references '.center(75, '-')+'\n') 

        keyS = self._elemRefMap.keys()

        keyS.sort()

        for k in keyS:

            s.write('%40s : %s\n' % (k, self._elemRefMap[k]))

        s.write(' EOL '.center(75, '-')+'\n\n') 

        s.write(' Complex types '.center(75, '-')+'\n') 

        keyS = self._complexTypeMap.keys()

        keyS.sort()

        for k in keyS:

            s.write('%40s : %s\n' % (k, self._complexTypeMap[k]))

        s.write(' EOL '.center(75, '-')+'\n\n') 

        s.write(' Parent to child relationship '.center(75, '-')+'\n')

        # A map {element_name : [parent element, ...], ...}

        myPcMap = self._retContainedByMap()

        keyS = myPcMap.keys()

        keyS.sort()

        for k in keyS:

            s.write('Child: %s\n' % k)