/*
 * Licensed to the Apache Software Foundation (ASF) under one or more
 * contributor license agreements.  See the NOTICE file distributed with
 * this work for additional information regarding copyright ownership.
 * The ASF licenses this file to You under the Apache License, Version 2.0
 * (the "License"); you may not use this file except in compliance with
 * the License.  You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
package org.apache.tika.parser.odf;

import org.apache.commons.io.input.CloseShieldInputStream;
import org.apache.tika.exception.TikaException;
import org.apache.tika.metadata.Metadata;
import org.apache.tika.mime.MediaType;
import org.apache.tika.parser.AbstractParser;
import org.apache.tika.parser.ParseContext;
import org.apache.tika.sax.ElementMappingContentHandler;
import org.apache.tika.sax.ElementMappingContentHandler.TargetElement;
import org.apache.tika.sax.OfflineContentHandler;
import org.apache.tika.sax.XHTMLContentHandler;
import org.apache.tika.utils.XMLReaderUtils;
import org.xml.sax.Attributes;
import org.xml.sax.ContentHandler;
import org.xml.sax.SAXException;
import org.xml.sax.helpers.AttributesImpl;
import org.xml.sax.helpers.DefaultHandler;

import javax.xml.namespace.QName;
import java.io.IOException;
import java.io.InputStream;
import java.util.BitSet;
import java.util.Collections;
import java.util.HashMap;
import java.util.Map;
import java.util.Set;
import java.util.Stack;

import static org.apache.tika.sax.XHTMLContentHandler.XHTML;

/**
 * Parser for ODF <code>content.xml</code> files.
 */
public class OpenDocumentContentParser extends AbstractParser {
    private interface Style {
    }

    private static class TextStyle implements Style {
        public boolean italic;
        public boolean bold;
        public boolean underlined;

        @Override
        public String toString() {
            return "TextStyle{" +
                    "italic=" + italic +
                    ", bold=" + bold +
                    ", underlined=" + underlined +
                    '}';
        }
    }

    private static class ListStyle implements Style {
        public boolean ordered;

        public String getTag() {
            return ordered ? "ol" : "ul";
        }
    }

    private static final class OpenDocumentElementMappingContentHandler extends
            ElementMappingContentHandler {
        private static final char[] SPACE = new char[]{ ' '};
        private static final String CLASS = "class";
        private static final Attributes ANNOTATION_ATTRIBUTES = buildAttributes(CLASS, "annotation");
        private static final Attributes NOTE_ATTRIBUTES = buildAttributes(CLASS, "note");
        private static final Attributes NOTES_ATTRIBUTES = buildAttributes(CLASS, "notes");

        private static Attributes buildAttributes(String key, String value) {
            AttributesImpl attrs = new AttributesImpl();
            attrs.addAttribute("", key, key, "CDATA", value);
            return attrs;
        }

        private final ContentHandler handler;
        private final BitSet textNodeStack = new BitSet();
        private int nodeDepth = 0;
        private int completelyFiltered = 0;
        private Stack<String> headingStack = new Stack<String>();
        private Map<String, TextStyle> paragraphTextStyleMap = new HashMap<String, TextStyle>();
        private Map<String, TextStyle> textStyleMap = new HashMap<String, TextStyle>();
        private Map<String, ListStyle> listStyleMap = new HashMap<String, ListStyle>();
        private String currParagraphStyleName; //paragraph style name
        private TextStyle currTextStyle; //this is the text style for particular spans/paragraphs
        private String currTextStyleName;

        private Stack<ListStyle> listStyleStack = new Stack<ListStyle>();
        private ListStyle listStyle;

        // True if we are currently in the named style:
        private boolean curUnderlined;
        private boolean curBold;
        private boolean curItalic;

        //have we written the start style tags
        //yet for the current text style
        boolean hasWrittenStartStyleTags = false;

        private int pDepth = 0;  //<p> can appear inside comments and other things that are already inside <p>
                                //we need to track our pDepth and only output <p> if we're at the main level


        private OpenDocumentElementMappingContentHandler(ContentHandler handler,
                                                         Map<QName, TargetElement> mappings) {
            super(handler, mappings);
            this.handler = handler;
        }

        @Override
        public void characters(char[] ch, int start, int length)
                throws SAXException {
            // only forward content of tags from text:-namespace
            if (completelyFiltered == 0 && nodeDepth > 0
                    && textNodeStack.get(nodeDepth - 1)) {
                if (!hasWrittenStartStyleTags) {
                    updateStyleTags();
                    hasWrittenStartStyleTags = true;
                }
                super.characters(ch, start, length);
            }
        }

        // helper for checking tags which need complete filtering
        // (with sub-tags)
        private boolean needsCompleteFiltering(
                String namespaceURI, String localName) {
            if (TEXT_NS.equals(namespaceURI)) {
                return localName.endsWith("-template")
                        || localName.endsWith("-style");
            }
            return TABLE_NS.equals(namespaceURI) && "covered-table-cell".equals(localName);
        }

        // map the heading level to <hX> HTML tags
        private String getXHTMLHeaderTagName(Attributes atts) {
            String depthStr = atts.getValue(TEXT_NS, "outline-level");
            if (depthStr == null) {
                return "h1";
            }

            int depth = Integer.parseInt(depthStr);
            if (depth >= 6) {
                return "h6";
            } else if (depth <= 1) {
                return "h1";
            } else {
                return "h" + depth;
            }
        }

        /**
         * Check if a node is a text node
         */
        private boolean isTextNode(String namespaceURI, String localName) {
            if (TEXT_NS.equals(namespaceURI) && !localName.equals("page-number") && !localName.equals("page-count")) {
                return true;
            }
            if (SVG_NS.equals(namespaceURI)) {
                return "title".equals(localName) ||
                        "desc".equals(localName);
            }
            return false;
        }

        private void startList(String name) throws SAXException {
            String elementName = "ul";
            if (name != null) {
                ListStyle style = listStyleMap.get(name);
                elementName = style != null ? style.getTag() : "ul";
                listStyleStack.push(style);
            }
            handler.startElement(XHTML, elementName, elementName, EMPTY_ATTRIBUTES);
        }

        private void endList() throws SAXException {
            String elementName = "ul";
            if (!listStyleStack.isEmpty()) {
                ListStyle style = listStyleStack.pop();
                elementName = style != null ? style.getTag() : "ul";
            }
            handler.endElement(XHTML, elementName, elementName);
        }

        private void startSpan(String name) throws SAXException {
            if (name == null) {
                return;
            }
            currTextStyle = textStyleMap.get(name);
            hasWrittenStartStyleTags = false;
        }

        private void startParagraph(String styleName) throws SAXException {
            if (pDepth == 0) {
                handler.startElement(XHTML, "p", "p", EMPTY_ATTRIBUTES);
                if (styleName != null) {
                    currTextStyle = paragraphTextStyleMap.get(styleName);
                }
                hasWrittenStartStyleTags = false;
            } else {
                handler.characters(SPACE, 0, SPACE.length);
            }
            pDepth++;
        }

        private void endParagraph() throws SAXException {
            closeStyleTags();
            if (pDepth == 1) {
                handler.endElement(XHTML, "p", "p");
            } else {
                handler.characters(SPACE, 0, SPACE.length);
            }
            pDepth--;

        }

        private void updateStyleTags() throws SAXException {

            if (currTextStyle == null) {
                closeStyleTags();
                return;
            }
            if (currTextStyle.bold != curBold) {
                // Enforce nesting -- must close s and i tags
                if (curUnderlined) {
                    handler.endElement(XHTML, "u", "u");
                    curUnderlined = false;
                }
                if (curItalic) {
                    handler.endElement(XHTML, "i", "i");
                    curItalic = false;
                }
                if (currTextStyle.bold) {
                    handler.startElement(XHTML, "b", "b", EMPTY_ATTRIBUTES);
                } else {
                    handler.endElement(XHTML, "b", "b");
                }
                curBold = currTextStyle.bold;
            }

            if (currTextStyle.italic != curItalic) {
                // Enforce nesting -- must close s tag
                if (curUnderlined) {
                    handler.endElement(XHTML, "u", "u");
                    curUnderlined = false;
                }
                if (currTextStyle.italic) {
                    handler.startElement(XHTML, "i", "i", EMPTY_ATTRIBUTES);
                } else {
                    handler.endElement(XHTML, "i", "i");
                }
                curItalic = currTextStyle.italic;
            }

            if (currTextStyle.underlined != curUnderlined) {
                if (currTextStyle.underlined) {
                    handler.startElement(XHTML, "u", "u", EMPTY_ATTRIBUTES);
                } else {
                    handler.endElement(XHTML, "u", "u");
                }
                curUnderlined = currTextStyle.underlined;
            }
        }

        private void endSpan() throws SAXException {
            updateStyleTags();
        }

        private void closeStyleTags() throws SAXException {
            // Close any still open style tags
            if (curUnderlined) {
                handler.endElement(XHTML,"u", "u");
                curUnderlined = false;
            }
            if (curItalic) {
                handler.endElement(XHTML,"i", "i");
                curItalic = false;
            }
            if (curBold) {
                handler.endElement(XHTML,"b", "b");
                curBold = false;
            }
            currTextStyle = null;
            hasWrittenStartStyleTags = false;
        }

        @Override
        public void startElement(
                String namespaceURI, String localName, String qName,
                Attributes attrs) throws SAXException {
            // keep track of current node type. If it is a text node,
            // a bit at the current depth its set in textNodeStack.
            // characters() checks the top bit to determine, if the
            // actual node is a text node to print out nodeDepth contains
            // the depth of the current node and also marks top of stack.
            assert nodeDepth >= 0;

            // Set styles
            if (STYLE_NS.equals(namespaceURI) && "style".equals(localName)) {
                String family = attrs.getValue(STYLE_NS, "family");
                if ("text".equals(family)) {
                    currTextStyle = new TextStyle();
                    currTextStyleName = attrs.getValue(STYLE_NS, "name");
                } else if ("paragraph".equals(family)) {
                    currTextStyle = new TextStyle();
                    currParagraphStyleName = attrs.getValue(STYLE_NS, "name");
                }
            } else if (TEXT_NS.equals(namespaceURI) && "list-style".equals(localName)) {
                listStyle = new ListStyle();
                String name = attrs.getValue(STYLE_NS, "name");
                listStyleMap.put(name, listStyle);
            } else if (currTextStyle != null && STYLE_NS.equals(namespaceURI)
                    && "text-properties".equals(localName)) {
                String fontStyle = attrs.getValue(FORMATTING_OBJECTS_NS, "font-style");
                if ("italic".equals(fontStyle) || "oblique".equals(fontStyle)) {
                    currTextStyle.italic = true;
                }
                String fontWeight = attrs.getValue(FORMATTING_OBJECTS_NS, "font-weight");
                if ("bold".equals(fontWeight) || "bolder".equals(fontWeight)
                        || (fontWeight != null && Character.isDigit(fontWeight.charAt(0))
                        && Integer.valueOf(fontWeight) > 500)) {
                    currTextStyle.bold = true;
                }
                String underlineStyle = attrs.getValue(STYLE_NS, "text-underline-style");
                if (underlineStyle != null && !underlineStyle.equals("none")) {
                    currTextStyle.underlined = true;
                }
            } else if (listStyle != null && TEXT_NS.equals(namespaceURI)) {
                if ("list-level-style-bullet".equals(localName)) {
                    listStyle.ordered = false;
                } else if ("list-level-style-number".equals(localName)) {
                    listStyle.ordered = true;
                }
            }

            textNodeStack.set(nodeDepth++,
                    isTextNode(namespaceURI, localName));
            // filter *all* content of some tags
            assert completelyFiltered >= 0;

            if (needsCompleteFiltering(namespaceURI, localName)) {
                completelyFiltered++;
            }
            // call next handler if no filtering
            if (completelyFiltered == 0) {
                // special handling of text:h, that are directly passed
                // to incoming handler
                if (TEXT_NS.equals(namespaceURI) && "h".equals(localName)) {
                    final String el = headingStack.push(getXHTMLHeaderTagName(attrs));
                    handler.startElement(XHTMLContentHandler.XHTML, el, el, EMPTY_ATTRIBUTES);
                } else if (TEXT_NS.equals(namespaceURI) && "list".equals(localName)) {
                    startList(attrs.getValue(TEXT_NS, "style-name"));
                } else if (TEXT_NS.equals(namespaceURI) && "span".equals(localName)) {
                    startSpan(attrs.getValue(TEXT_NS, "style-name"));
                } else if (TEXT_NS.equals(namespaceURI) && "p".equals(localName)) {
                    startParagraph(attrs.getValue(TEXT_NS, "style-name"));
                } else if (TEXT_NS.equals(namespaceURI) && "s".equals(localName)) {
                    handler.characters(SPACE, 0, 1);
                } else if ("annotation".equals(localName)) {
                    closeStyleTags();
                    handler.startElement(XHTML, "span", "p", ANNOTATION_ATTRIBUTES);
                } else if ("note".equals(localName)) {
                    closeStyleTags();
                    handler.startElement(XHTML, "span", "p", NOTE_ATTRIBUTES);
                } else if ("notes".equals(localName)) {
                    closeStyleTags();
                    handler.startElement(XHTML, "span", "p", NOTES_ATTRIBUTES);
                } else {
                    super.startElement(namespaceURI, localName, qName, attrs);
                }
            }
        }

        @Override
        public void endElement(
                String namespaceURI, String localName, String qName)
                throws SAXException {
            if (STYLE_NS.equals(namespaceURI) && "style".equals(localName)) {
                if (currTextStyle != null && currTextStyleName != null) {
                    textStyleMap.put(currTextStyleName, currTextStyle);
                    currTextStyleName = null;
                    currTextStyle = null;
                } else if (currTextStyle != null && currParagraphStyleName != null) {
                    paragraphTextStyleMap.put(currParagraphStyleName, currTextStyle);
                    currParagraphStyleName = null;
                    currTextStyle = null;
                }
            } else if (TEXT_NS.equals(namespaceURI) && "list-style".equals(localName)) {
                listStyle = null;
            }

            // call next handler if no filtering
            if (completelyFiltered == 0) {
                // special handling of text:h, that are directly passed
                // to incoming handler
                if (TEXT_NS.equals(namespaceURI) && "h".equals(localName)) {
                    final String el = headingStack.pop();
                    handler.endElement(XHTMLContentHandler.XHTML, el, el);
                } else if (TEXT_NS.equals(namespaceURI) && "list".equals(localName)) {
                    endList();
                } else if (TEXT_NS.equals(namespaceURI) && "span".equals(localName)) {
                    currTextStyle = null;
                    hasWrittenStartStyleTags = false;
                } else if (TEXT_NS.equals(namespaceURI) && "p".equals(localName)) {
                    endParagraph();
                } else if ("annotation".equals(localName) || "note".equals(localName) ||
                        "notes".equals(localName)) {
                        closeStyleTags();
                        handler.endElement("", localName, localName);
                } else {
                    super.endElement(namespaceURI, localName, qName);
                }

                // special handling of tabulators
                if (TEXT_NS.equals(namespaceURI)
                        && ("tab-stop".equals(localName)
                        || "tab".equals(localName))) {
                    this.characters(TAB, 0, TAB.length);
                }
            }

            // revert filter for *all* content of some tags
            if (needsCompleteFiltering(namespaceURI, localName)) {
                completelyFiltered--;
            }
            assert completelyFiltered >= 0;

            // reduce current node depth
            nodeDepth--;
            assert nodeDepth >= 0;
        }

        @Override
        public void startPrefixMapping(String prefix, String uri) {
            // remove prefix mappings as they should not occur in XHTML
        }

        @Override
        public void endPrefixMapping(String prefix) {
            // remove prefix mappings as they should not occur in XHTML
        }
    }

    public static final String TEXT_NS =
            "urn:oasis:names:tc:opendocument:xmlns:text:1.0";

    public static final String TABLE_NS =
            "urn:oasis:names:tc:opendocument:xmlns:table:1.0";

    public static final String STYLE_NS =
            "urn:oasis:names:tc:opendocument:xmlns:style:1.0";

    public static final String FORMATTING_OBJECTS_NS =
            "urn:oasis:names:tc:opendocument:xmlns:xsl-fo-compatible:1.0";

    public static final String OFFICE_NS =
            "urn:oasis:names:tc:opendocument:xmlns:office:1.0";

    public static final String SVG_NS =
            "urn:oasis:names:tc:opendocument:xmlns:svg-compatible:1.0";

    public static final String PRESENTATION_NS =
            "urn:oasis:names:tc:opendocument:xmlns:presentation:1.0";

    public static final String DRAW_NS =
            "urn:oasis:names:tc:opendocument:xmlns:drawing:1.0";

    public static final String XLINK_NS = "http://www.w3.org/1999/xlink";

    protected static final char[] TAB = new char[]{'\t'};

    private static final Attributes EMPTY_ATTRIBUTES = new AttributesImpl();

    /**
     * Mappings between ODF tag names and XHTML tag names
     * (including attributes). All other tag names/attributes are ignored
     * and left out from event stream.
     */
    private static final HashMap<QName, TargetElement> MAPPINGS =
            new HashMap<QName, TargetElement>();

    static {
        // general mappings of text:-tags
        MAPPINGS.put(
                new QName(TEXT_NS, "p"),
                new TargetElement(XHTML, "p"));
        // text:h-tags are mapped specifically in startElement/endElement
        MAPPINGS.put(
                new QName(TEXT_NS, "line-break"),
                new TargetElement(XHTML, "br"));
        MAPPINGS.put(
                new QName(TEXT_NS, "list-item"),
                new TargetElement(XHTML, "li"));
        MAPPINGS.put(
                new QName(TEXT_NS, "note"),
                new TargetElement(XHTML, "span"));
        MAPPINGS.put(
                new QName(OFFICE_NS, "annotation"),
                new TargetElement(XHTML, "span"));
        MAPPINGS.put(
                new QName(PRESENTATION_NS, "notes"),
                new TargetElement(XHTML, "span"));
        MAPPINGS.put(
                new QName(DRAW_NS, "object"),
                new TargetElement(XHTML, "object"));
        MAPPINGS.put(
                new QName(DRAW_NS, "text-box"),
                new TargetElement(XHTML, "div"));
        MAPPINGS.put(
                new QName(SVG_NS, "title"),
                new TargetElement(XHTML, "span"));
        MAPPINGS.put(
                new QName(SVG_NS, "desc"),
                new TargetElement(XHTML, "span"));
        MAPPINGS.put(
                new QName(TEXT_NS, "span"),
                new TargetElement(XHTML, "span"));

        final HashMap<QName, QName> aAttsMapping =
                new HashMap<QName, QName>();
        aAttsMapping.put(
                new QName(XLINK_NS, "href"),
                new QName("href"));
        aAttsMapping.put(
                new QName(XLINK_NS, "title"),
                new QName("title"));
        MAPPINGS.put(
                new QName(TEXT_NS, "a"),
                new TargetElement(XHTML, "a", aAttsMapping));

        // create HTML tables from table:-tags
        MAPPINGS.put(
                new QName(TABLE_NS, "table"),
                new TargetElement(XHTML, "table"));
        // repeating of rows is ignored; for columns, see below!
        MAPPINGS.put(
                new QName(TABLE_NS, "table-row"),
                new TargetElement(XHTML, "tr"));
        // special mapping for rowspan/colspan attributes
        final HashMap<QName, QName> tableCellAttsMapping =
                new HashMap<QName, QName>();
        tableCellAttsMapping.put(
                new QName(TABLE_NS, "number-columns-spanned"),
                new QName("colspan"));
        tableCellAttsMapping.put(
                new QName(TABLE_NS, "number-rows-spanned"),
                new QName("rowspan"));
        /* TODO: The following is not correct, the cell should be repeated not spanned!
         * Code generates a HTML cell, spanning all repeated columns, to make the cell look correct.
         * Problems may occur when both spanning and repeating is given, which is not allowed by spec.
         * Cell spanning instead of repeating  is not a problem, because OpenOffice uses it
         * only for empty cells.
         */
        tableCellAttsMapping.put(
                new QName(TABLE_NS, "number-columns-repeated"),
                new QName("colspan"));
        MAPPINGS.put(
                new QName(TABLE_NS, "table-cell"),
                new TargetElement(XHTML, "td", tableCellAttsMapping));
    }

    public Set<MediaType> getSupportedTypes(ParseContext context) {
        return Collections.emptySet(); // not a top-level parser
    }

    public void parse(
            InputStream stream, ContentHandler handler,
            Metadata metadata, ParseContext context)
            throws IOException, SAXException, TikaException {
        parseInternal(stream,
                new XHTMLContentHandler(handler, metadata),
                metadata, context);
    }

    void parseInternal(
            InputStream stream, final ContentHandler handler,
            Metadata metadata, ParseContext context)
            throws IOException, SAXException, TikaException {

        DefaultHandler dh = new OpenDocumentElementMappingContentHandler(handler, MAPPINGS);


        XMLReaderUtils.parseSAX(
                new CloseShieldInputStream(stream),
                new OfflineContentHandler(
                        new NSNormalizerContentHandler(dh)),
                context);
    }

}
