/*
 * 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.jackrabbit.server.io;

import org.apache.jackrabbit.JcrConstants;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import javax.jcr.ImportUUIDBehavior;
import javax.jcr.Node;
import javax.jcr.RepositoryException;
import javax.jcr.Session;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.util.HashSet;
import java.util.Set;

/**
 * <code>XmlHandler</code> imports xml files and exports nodes that have
 * the proper {@link #XML_MIMETYPE} defined with their content. The export is
 * performed by running a {@link Session#exportDocumentView(String, OutputStream, boolean, boolean)
 * document view export} for the content of the export root defined with the
 * specified {@link ExportContext}.<br>
 * Please note that this handler is not suited for a generic system or document
 * view import/export of {@link Node}s because an extra root node is always
 * created during import and expected during export, respectively.
 */
public class XmlHandler extends DefaultHandler {

    private static Logger log = LoggerFactory.getLogger(XmlHandler.class);

    /**
     * the xml mimetype
     */
    public static final String XML_MIMETYPE = "text/xml";

    /**
     * the alternative xml mimetype. tika detects xml as this.
     */
    public static final String XML_MIMETYPE_ALT = "application/xml";

    private static final Set<String> supportedTypes;
    static {
        supportedTypes = new HashSet<String>();
        supportedTypes.add(XML_MIMETYPE);
        supportedTypes.add(XML_MIMETYPE_ALT);
    }


    /**
     * Creates a new <code>XmlHandler</code> with default nodetype definitions
     * and without setting the IOManager.
     *
     * @see IOHandler#setIOManager(IOManager)
     */
    public XmlHandler() {
    }

    /**
     * Creates a new <code>XmlHandler</code> with default nodetype definitions:<br>
     * <ul>
     * <li>Nodetype for Collection: {@link JcrConstants#NT_UNSTRUCTURED nt:unstructured}</li>
     * <li>Nodetype for Non-Collection: {@link JcrConstants#NT_FILE nt:file}</li>
     * <li>Nodetype for Non-Collection content: {@link JcrConstants#NT_UNSTRUCTURED nt:unstructured}</li>
     * </ul>
     *
     * @param ioManager
     */
    public XmlHandler(IOManager ioManager) {
        super(ioManager, JcrConstants.NT_UNSTRUCTURED, JcrConstants.NT_FILE, JcrConstants.NT_UNSTRUCTURED);
    }

    /**
     * Creates a new <code>XmlHandler</code>
     *
     * @param ioManager
     * @param collectionNodetype
     * @param defaultNodetype
     * @param contentNodetype
     */
    public XmlHandler(IOManager ioManager, String collectionNodetype, String defaultNodetype, String contentNodetype) {
        super(ioManager, collectionNodetype, defaultNodetype, contentNodetype);
    }

    /**
     * @see IOHandler#canImport(ImportContext, boolean)
     */
    @Override
    public boolean canImport(ImportContext context, boolean isCollection) {
        return !(context == null || context.isCompleted())
                && supportedTypes.contains(context.getMimeType())
                && context.hasStream()
                && context.getContentLength() > 0
                && super.canImport(context, isCollection);
    }

    /**
     * @see DefaultHandler#importData(ImportContext, boolean, Node)
     */
    @Override
    protected boolean importData(ImportContext context, boolean isCollection, Node contentNode) throws IOException, RepositoryException {
        InputStream in = context.getInputStream();
        int uuidBehavior = (isCollection)
            ? ImportUUIDBehavior.IMPORT_UUID_COLLISION_REMOVE_EXISTING
            : ImportUUIDBehavior.IMPORT_UUID_CREATE_NEW;
        try {
            contentNode.getSession().importXML(contentNode.getPath(), in, uuidBehavior);
        } finally {
            in.close();
        }
        return true;
    }

    /**
     * @see DefaultHandler#importProperties(ImportContext, boolean, Node)
     */
    @Override
    protected boolean importProperties(ImportContext context, boolean isCollection, Node contentNode) {
        boolean success = super.importProperties(context, isCollection, contentNode);
        if (success) {
            // encoding: always UTF-8 for the xml import
            try {
                contentNode.setProperty(JcrConstants.JCR_ENCODING, "UTF-8");
            } catch (RepositoryException e) {
                // ignore, since given nodetype could not allow encoding
                // deliberately not re-throwing an IOException.
            }
        }
        return success;
    }

    /**
     * {@inheritDoc}
     *
     * @return <code>true</code>, always.
     */
    @Override
    protected boolean forceCompatibleContentNodes() {
        return true;
    }

    /**
     * @see IOHandler#canExport(ExportContext, boolean)
     */
    @Override
    public boolean canExport(ExportContext context, boolean isCollection) {
        if (super.canExport(context, isCollection)) {
            String mimeType = null;
            try {
                Node contentNode = getContentNode(context, isCollection);
                if (contentNode.hasProperty(JcrConstants.JCR_MIMETYPE)) {
                    mimeType = contentNode.getProperty(JcrConstants.JCR_MIMETYPE).getString();
                } else {
                    mimeType = detect(context.getExportRoot().getName());
                }
            } catch (RepositoryException e) {
                // ignore and return false
            }
            return XML_MIMETYPE.equals(mimeType);
        }
        return false;
    }

    /**
     * @see DefaultHandler#exportData(ExportContext, boolean, Node)
     */
    @Override
    protected void exportData(ExportContext context, boolean isCollection, Node contentNode) throws IOException, RepositoryException {
        // first child of content is XML document root
        if (contentNode.getNodes().hasNext()) {
            contentNode = contentNode.getNodes().nextNode();
        }
        OutputStream out = context.getOutputStream();
        contentNode.getSession().exportDocumentView(contentNode.getPath(), out, true, false);
    }

    /**
     * @see DefaultHandler#exportProperties(ExportContext, boolean, Node)
     */
    @Override
    protected void exportProperties(ExportContext context, boolean isCollection, Node contentNode) throws IOException {
        super.exportProperties(context, isCollection, contentNode);
        // set mimetype if the content node did not provide the
        // jcr property (thus not handled by super class)
        try {
            if (!contentNode.hasProperty(JcrConstants.JCR_MIMETYPE)) {
                context.setContentType("text/xml", "UTF-8");
            }
        } catch (RepositoryException e) {
            // should never occur
            throw new IOException(e.getMessage());
        }
    }
}
