import string, sys, urllib, re, traceback, pickle, os, \
        libxml2, types, libxslt

#Used to spit out XML version of the word document
serializexml = """
<xsl:stylesheet xmlns:xsl="http://www.w3.org/1999/XSL/Transform" version="1.0"  xmlns:v="urn:schemas-microsoft-com:vml"
xmlns:o="urn:schemas-microsoft-com:office:office"
xmlns:w="urn:schemas-microsoft-com:office:word">
	
 <xsl:output indent="yes" method="xml"/>

        <!-- Unescape namespaces-->
        <xsl:template match="*[contains(local-name(),'_')]">
	<xsl:variable name="new-name" select="concat(substring-before(local-name(), '_'), ':', substring-after(local-name(), '_'))"/>
	<xsl:element name="{$new-name}"><xsl:apply-templates select="@*|node()" /></xsl:element>
	</xsl:template>

        
	<!-- Identity transformation -->
	<xsl:template match="@*|*|processing-instruction()|comment()" >
		<xsl:copy>
			<xsl:apply-templates select="@*|node()" />
		
		</xsl:copy>
	</xsl:template>
	
	
</xsl:stylesheet>
"""
#Return leg of the round trip, XML back to Word
wordxml2html = """
<xsl:stylesheet xmlns:xsl="http://www.w3.org/1999/XSL/Transform" version="1.0" xmlns:html="http://www.w3.org/TR/REC-html40" xmlns="http://www.w3.org/TR/REC-html40" xmlns:o="urn:schemas-microsoft-com:office:office" xmlns:dc="http://purl.org/dc/elements/1.0/" xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#">
	<xsl:output method="html"/>
	<xsl:variable name="empty-elements">-br-hr-meta-img-link-</xsl:variable>
	<xsl:template match="/">
		<xsl:apply-templates/>
	</xsl:template>
	
	<xsl:template match="html:mmd[@value='nbsp']" priority="5">
		<xsl:text disable-output-escaping="yes">&amp;nbsp;</xsl:text>
	</xsl:template>
		
	<xsl:template match="html:div[@class='mso-conditional']" priority="5">
		<xsl:apply-templates/>
	</xsl:template>	

        <xsl:template match="html:mmd[@value='wrapblock']"><xsl:text disable-output-escaping="yes">&lt;o:wrapblock></xsl:text></xsl:template>
        <xsl:template match="html:mmd[@value='end-wrapblock']"><xsl:text disable-output-escaping="yes">&lt;/o:wrapblock></xsl:text></xsl:template>		
	<xsl:template match="html:mmd">
		<xsl:variable name="start-comment">
			<xsl:if test="@comment='start'">
				<xsl:text>--</xsl:text>
			</xsl:if>
		</xsl:variable>
		<xsl:variable name="end-comment">
			<xsl:if test="@comment='end'">
				<xsl:text>--</xsl:text>
			</xsl:if>
		</xsl:variable>
		<xsl:text disable-output-escaping="yes">&lt;!</xsl:text><xsl:value-of select="$start-comment"/><xsl:text disable-output-escaping="yes">[</xsl:text><xsl:value-of select="@value"/><xsl:text disable-output-escaping="yes">]</xsl:text><xsl:value-of select="$end-comment"/><xsl:text disable-output-escaping="yes">></xsl:text>
	</xsl:template>
	
	<xsl:template match="text()">
		<xsl:copy-of select="." xml:space="preserve"/>
	</xsl:template>
	
	<xsl:template match="*">
	<xsl:text disable-output-escaping="yes">&lt;</xsl:text><xsl:value-of select="name()"/><xsl:apply-templates select="./@*"/><xsl:text disable-output-escaping="yes">></xsl:text><xsl:apply-templates/>
<xsl:variable name="element-lookup">-<xsl:value-of select="local-name()"/>-</xsl:variable>
<xsl:if test="not(contains($empty-elements, $element-lookup))"><xsl:text disable-output-escaping="yes">&lt;/</xsl:text><xsl:value-of select="name()"/><xsl:text disable-output-escaping="yes">></xsl:text></xsl:if>


</xsl:template>

<xsl:template match="comment()"><xsl:copy/></xsl:template>

	<xsl:template match="@mso-style-name"></xsl:template>
	<xsl:template match="@*">
		<!-- Islands of XML need quotes attributes, style attributes have single quotes and all other attributes are not quoted -->
		<xsl:variable name="quote">
			<xsl:choose>
			<xsl:when test="name()='content'">"</xsl:when>
			       <xsl:when test="name()='style'">'</xsl:when>
				<xsl:when test="ancestor::html:script[@language='mso-conditional']">"</xsl:when>
			</xsl:choose>
		</xsl:variable>
		<xsl:text disable-output-escaping="yes"> </xsl:text><xsl:value-of select="name()"/><xsl:text disable-output-escaping="yes">=</xsl:text><xsl:value-of select="$quote"/><xsl:value-of select="."/><xsl:value-of select="$quote"/>
	</xsl:template>
</xsl:stylesheet>
"""

class wordtoxml:
    doc = '' #string version of original file
    htmfilename = '' 
    xmlfilename = ''
    htmldoc = ''
    
    #stylesheet used to fix namespaces and serialize the document
    styledoc = libxml2.parseDoc(serializexml)
    style = libxslt.parseStylesheetDoc(styledoc)
    
    #dict containing classnames mapped to original style-names
    stylenames = {} 

    def __init__(self, doc = ""):
        pass
    
    def loadhtmlfile(self, htmlfilename):
        self.htmfilename = htmlfilename
        self.doc = open(htmlfilename).read()

        #self.doc = self.doc.encode('cp1252')

        
    def parsehtmlfile(self, htmlfilename):
        self.loadhtmlfile(htmlfilename)

        #Remove mutant markup
        self.doc = self.clean()
        
        #Create a libxml2 XML document
        self.htmldoc = libxml2.htmlParseDoc(self.doc, None)

        #Get all style information        
        styleNodes = self.htmldoc.xpathEval("//*[local-name() = 'style']")
        styles = ""
        for styleNode in styleNodes:
            styles += styleNode.serialize()
        
        self.extractstyles(styles)

        #Add mso-style-name attributes where possible        
        classNodes = self.htmldoc.xpathEval("//*[@class]")
        for c in classNodes:
            className = c.prop("class")
            msoStyle = self.getStyleName(className)
            if msoStyle: #add an mso-stylename attribute
                c.newProp("mso-style-name", msoStyle)      

    def output(self):        
        result = self.style.applyStylesheet(self.htmldoc, None)
        return result.serialize()

    def extractstyles(self, styles):
        for style in re.findall(r'p\.(\w+)[^{]*[{]mso-style-name:\s*(.+);[^}]+[}]', styles):
            self.stylenames[style[0]]= style[1].replace('\\','').replace('"','')
                  
    def getStyleName(self, className):
        if self.stylenames.has_key(className):
            return self.stylenames[className]
        elif className.startswith('Mso'): #builtin style
            return className[3:]
        else:
            return None
        
    def clean(self, doc = None):
        """Remove Mutant Markup Declarations (MMD) from word HTML files"""
        #This is allowed for testing purposes or other hacking
        if doc:
            self.doc = doc

        #Hack to deal with odd code-points in word files
        #you may need to add more of these if you encounter stuff
        #like wingdings font
        self.doc = self.doc.replace('\201','&#xC9;')

        #Deal with MMDs        
        startComment = r'<\!--\[(.*?)\]\>'
        startCommentReplace = r"<mmd value='\1' comment='start' /><div class='mso-conditional'>"
        self.doc = re.sub(startComment, startCommentReplace, self.doc)
        
        endComment = r'<!\[(.*?)\]-->'
        endCommentReplace = r"</div><mmd value='\1' comment='end' />"
        self.doc = re.sub(endComment, endCommentReplace, self.doc)
      
        startMMD = r'<\!\[(.*?)\]\>'
        startMMDReplace = r"<mmd value='\1' />"
        self.doc = re.sub(startMMD, startMMDReplace, self.doc)
        
        endMMD = r'<\!\[endif\]>'
        endMMDReplace = "<mmd value='endif' />"
        self.doc = re.sub(endMMD, endMMDReplace, self.doc)

        #This is a rare special case, seems to be related to equations
        wrapblock = r'<o:wrapblock>'
        wrapblockreplace = "<mmd value='wrapblock'/>"
        self.doc = self.doc.replace(wrapblock, wrapblockreplace)

        endwrapblock = r'</o:wrapblock>'
        endwrapblockreplace = "<mmd value='end-wrapblock'/>"
        self.doc = self.doc.replace(endwrapblock, endwrapblockreplace)

    
        #Hide namespaces from libxml2's HTML parser
        qualifiedname = '<(/?)(\w):(\w)'
        hackedname =  r'<\1\2_\3'
        self.doc = re.sub(qualifiedname, hackedname, self.doc)
        return self.doc
    
class xmltoword:
    xmldoc = ''
    styledoc = libxml2.parseDoc(wordxml2html)
    style = libxslt.parseStylesheetDoc(styledoc)

    def __init__(self):
        pass
    
    def parsexmlfile(self, fileName):
        self.xmldoc = libxml2.parseFile(fileName)

    def output(self):           
        return self.style.applyStylesheet(self.xmldoc, None).serialize()


if __name__ == '__main__':
    fileName = sys.argv[1]
    if fileName.endswith('.htm'):
        conv = wordtoxml()
        conv.parsehtmlfile(fileName)
        print conv.output()
        
    elif fileName.endswith('.xml'):
        conv = xmltoword()
        conv.parsexmlfile(fileName)
        print conv.output()