/*
 * 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.commons.cnd;

import org.apache.jackrabbit.JcrConstants;
import org.apache.jackrabbit.commons.query.qom.Operator;
import org.apache.jackrabbit.util.ISO9075;
import org.apache.jackrabbit.util.Text;

import javax.jcr.NamespaceRegistry;
import javax.jcr.PropertyType;
import javax.jcr.RepositoryException;
import javax.jcr.Session;
import javax.jcr.Value;
import javax.jcr.nodetype.NodeDefinition;
import javax.jcr.nodetype.NodeTypeDefinition;
import javax.jcr.nodetype.PropertyDefinition;
import javax.jcr.query.qom.QueryObjectModelConstants;
import javax.jcr.version.OnParentVersionAction;
import java.io.IOException;
import java.io.StringWriter;
import java.io.Writer;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;
import java.util.HashSet;
import java.util.LinkedList;
import java.util.List;
import java.util.Set;
import java.util.TreeSet;

/**
 * Prints node type defs in a compact notation
 * Print Format:
 * <ex = "http://apache.org/jackrabbit/example">
 * [ex:NodeType] > ex:ParentType1, ex:ParentType2
 * orderable mixin
 *   - ex:property (STRING) = 'default1', 'default2'
 *     primary mandatory autocreated protected multiple VERSION
 *     < 'constraint1', 'constraint2'
 *   + ex:node (ex:reqType1, ex:reqType2) = ex:defaultType
 *     mandatory autocreated protected multiple VERSION
 */
public class CompactNodeTypeDefWriter {

    /**
     * the indention string
     */
    private static final String INDENT = "  ";

    private static final String ANY = "*";

    /**
     * Helper to retrieve the namespace URI for a given prefix.
     */
    private final NamespaceMapping nsMapping;

    /**
     * the underlying writer
     */
    private Writer out;

    /**
     * special writer used for namespaces
     */
    private Writer nsWriter;

    /**
     * namespaces(prefixes) that are used
     */
    private final Set<String> usedNamespaces = new HashSet<String>();

    /**
     * Creates a new nodetype writer based on a session
     *
     * @param out the underlying writer
     * @param session repository session
     * @param includeNS if <code>true</code> all used namespace decl. are also
     *                  written to the writer
     */
    public CompactNodeTypeDefWriter(Writer out, final Session session, boolean includeNS) {
        this(out, new DefaultNamespaceMapping(session), includeNS);
    }

    /**
     * Creates a new nodetype writer based on a session
     *
     * @param out the underlying writer
     * @param nsMapping the mapping from prefix to namespace URI.
     * @param includeNS if <code>true</code> all used namespace decl. are also
     *                  written to the writer
     */
    public CompactNodeTypeDefWriter(Writer out, NamespaceMapping nsMapping, boolean includeNS) {
        this.nsMapping = nsMapping;
        if (includeNS) {
            this.out = new StringWriter();
            this.nsWriter = out;
        } else {
            this.out = out;
            this.nsWriter = null;
        }
    }

    /**
     * Writes the given list of QNodeTypeDefinition to the output writer including the
     * used namespaces.
     *
     * @param defs collection of definitions
     * @param session session
     * @param out output writer
     * @throws java.io.IOException if an I/O error occurs
     */
    public static void write(Collection<NodeTypeDefinition> defs,
                             Session session, Writer out) throws IOException {
        CompactNodeTypeDefWriter w = new CompactNodeTypeDefWriter(out, session, true);
        for (NodeTypeDefinition def : defs) {
            w.write(def);
        }
        w.close();
    }

    /**
     * Writes the given list of QNodeTypeDefinition to the output writer
     * including the used namespaces.
     *
     * @param defs collection of definitions
     * @param nsMapping the mapping from prefix to namespace URI.
     * @param out output writer
     * @throws java.io.IOException if an I/O error occurs
     */
    public static void write(Collection<NodeTypeDefinition> defs,
                             NamespaceMapping nsMapping, Writer out) throws IOException {
        CompactNodeTypeDefWriter w = new CompactNodeTypeDefWriter(out, nsMapping, true);
        for (NodeTypeDefinition def : defs) {
            w.write(def);
        }
        w.close();
    }

    /**
     * Write one NodeTypeDefinition to this writer
     *
     * @param ntd node type definition
     * @throws IOException if an I/O error occurs
     */
    public void write(NodeTypeDefinition ntd) throws IOException {
        writeName(ntd);
        writeSupertypes(ntd);
        writeOptions(ntd);
        PropertyDefinition[] pdefs = ntd.getDeclaredPropertyDefinitions();
        if (pdefs != null) {
            for (PropertyDefinition pd : pdefs) {
                writePropDef(pd);
            }
        }
        NodeDefinition[] ndefs = ntd.getDeclaredChildNodeDefinitions();
        if (ndefs != null) {
            for (NodeDefinition nd : ndefs) {
                writeNodeDef(nd);
            }
        }
        out.write("\n\n");
    }

    /**
     * Write a namespace declaration to this writer. Note, that this method
     * has no effect if there is no extra namespace write present.
     *
     * @param prefix  namespace prefix
     * @throws IOException  if an I/O error occurs
     */
    public void writeNamespaceDeclaration(String prefix) throws IOException {
        if (nsWriter != null && !usedNamespaces.contains(prefix)) {
            usedNamespaces.add(prefix);
            nsWriter.write("<'");
            nsWriter.write(prefix);
            nsWriter.write("'='");
            nsWriter.write(escape(nsMapping.getNamespaceURI(prefix)));
            nsWriter.write("'>\n");
        }
    }

    /**
     * Flushes all pending write operations and Closes this writer. please note,
     * that the underlying writer remains open.
     *
     * @throws IOException if an I/O error occurs
     */
    public void close() throws IOException {
        if (nsWriter != null) {
            nsWriter.write("\n");
            out.close();
            nsWriter.write(((StringWriter) out).getBuffer().toString());
            out = nsWriter;
            nsWriter = null;
        }
        out.flush();
        out = null;
    }

    //------------------------------------------------------------< private >---
    /**
     * write name
     * @param ntd node type definition
     * @throws IOException if an I/O error occurs
     */
    private void writeName(NodeTypeDefinition ntd) throws IOException {
        out.write(Lexer.BEGIN_NODE_TYPE_NAME);
        writeJcrName(ntd.getName());
        out.write(Lexer.END_NODE_TYPE_NAME);
    }

    /**
     * Write the super type definitions.
     * 
     * @param ntd node type definition
     * @throws IOException if an I/O error occurs
     */
    private void writeSupertypes(NodeTypeDefinition ntd) throws IOException {
        // get ordered list of supertypes, omitting nt:base
        TreeSet<String> supertypes = new TreeSet<String>();
        for (String name : ntd.getDeclaredSupertypeNames()) {
            if (!name.equals(JcrConstants.NT_BASE)) {
                supertypes.add(name);
            }
        }
        if (!supertypes.isEmpty()) {
            String delim = " " + Lexer.EXTENDS + " ";
            for (String name : supertypes) {
                out.write(delim);
                writeJcrName(name);
                delim = ", ";
            }
        }
    }

    /**
     * Write the options
     * 
     * @param ntd node type definition
     * @throws IOException if an I/O error occurs
     */
    private void writeOptions(NodeTypeDefinition ntd) throws IOException {
        List<String> options = new LinkedList<String>();
        if (ntd.isAbstract()) {
            options.add(Lexer.ABSTRACT[0]);
        }
        if (ntd.hasOrderableChildNodes()) {
            options.add(Lexer.ORDERABLE[0]);
        }
        if (ntd.isMixin()) {
            options.add(Lexer.MIXIN[0]);
        }
        if (!ntd.isQueryable()) {
            options.add(Lexer.NOQUERY[0]);
        }
        String pin = ntd.getPrimaryItemName();
        if (pin != null) {
            options.add(Lexer.PRIMARYITEM[0]);
        }
        for (int i = 0; i < options.size(); i++) {
            if (i == 0) {
                out.write("\n" + INDENT);
            } else {
                out.write(" ");
            }
            out.write(options.get(i));
        }

        if (pin != null) {
            out.write(" ");
            writeJcrName(pin);            
        }
    }

    /**
     * Write a property definition
     * 
     * @param pd property definition
     * @throws IOException if an I/O error occurs
     */
    private void writePropDef(PropertyDefinition pd) throws IOException {
        out.write("\n" + INDENT + Lexer.PROPERTY_DEFINITION + " ");

        writeJcrName(pd.getName());
        out.write(" ");
        out.write(Lexer.BEGIN_TYPE);
        out.write(PropertyType.nameFromValue(pd.getRequiredType()).toLowerCase());
        out.write(Lexer.END_TYPE);
        writeDefaultValues(pd.getDefaultValues());
        if (pd.isMandatory()) {
            out.write(" ");
            out.write(Lexer.MANDATORY[0]);
        }
        if (pd.isAutoCreated()) {
            out.write(" ");
            out.write(Lexer.AUTOCREATED[0]);
        }
        if (pd.isProtected()) {
            out.write(" ");
            out.write(Lexer.PROTECTED[0]);
        }
        if (pd.isMultiple()) {
            out.write(" ");
            out.write(Lexer.MULTIPLE[0]);
        }
        if (pd.getOnParentVersion() != OnParentVersionAction.COPY) {
            out.write(" ");
            out.write(OnParentVersionAction.nameFromValue(pd.getOnParentVersion()).toLowerCase());
        }
        if (!pd.isFullTextSearchable()) {
            out.write(" ");
            out.write(Lexer.NOFULLTEXT[0]);
        }
        if (!pd.isQueryOrderable()) {
            out.write(" ");
            out.write(Lexer.NOQUERYORDER[0]);
        }
        String[] qops = pd.getAvailableQueryOperators();
        if (qops != null && qops.length > 0) {
            List<String> opts = new ArrayList<String>(Arrays.asList(qops));
            List<String> defaultOps = Arrays.asList(Operator.getAllQueryOperators());
            if (!opts.containsAll(defaultOps)) {
                out.write(" ");
                out.write(Lexer.QUERYOPS[0]);
                out.write(" '");
                String delim = "";
                for (String opt: opts) {
                    out.write(delim);
                    delim= ", ";
                    if (opt.equals(QueryObjectModelConstants.JCR_OPERATOR_EQUAL_TO)) {
                        out.write(Lexer.QUEROPS_EQUAL);
                    } else if (opt.equals(QueryObjectModelConstants.JCR_OPERATOR_NOT_EQUAL_TO)) {
                        out.write(Lexer.QUEROPS_NOTEQUAL);
                    } else if (opt.equals(QueryObjectModelConstants.JCR_OPERATOR_GREATER_THAN)) {
                        out.write(Lexer.QUEROPS_GREATERTHAN);
                    } else if (opt.equals(QueryObjectModelConstants.JCR_OPERATOR_GREATER_THAN_OR_EQUAL_TO)) {
                        out.write(Lexer.QUEROPS_GREATERTHANOREQUAL);
                    } else if (opt.equals(QueryObjectModelConstants.JCR_OPERATOR_LESS_THAN)) {
                        out.write(Lexer.QUEROPS_LESSTHAN);
                    } else if (opt.equals(QueryObjectModelConstants.JCR_OPERATOR_LESS_THAN_OR_EQUAL_TO)) {
                        out.write(Lexer.QUEROPS_LESSTHANOREQUAL);
                    } else if (opt.equals(QueryObjectModelConstants.JCR_OPERATOR_LIKE)) {
                        out.write(Lexer.QUEROPS_LIKE);
                    }
                }
                out.write("'");
            }
        }
        writeValueConstraints(pd.getValueConstraints(), pd.getRequiredType());
    }

    /**
     * Write default values
     * 
     * @param dva default value
     * @throws IOException if an I/O error occurs
     */
    private void writeDefaultValues(Value[] dva) throws IOException {
        if (dva != null && dva.length > 0) {
            String delim = " = '";
            for (Value value : dva) {
                out.write(delim);
                try {
                    out.write(escape(value.getString()));
                } catch (RepositoryException e) {
                    out.write(escape(value.toString()));
                }
                out.write("'");
                delim = ", '";
            }
        }
    }

    /**
     * Write the value constraints
     *
     * @param constraints the value constraints
     * @param type value type
     * @throws IOException if an I/O error occurs
     */
    private void writeValueConstraints(String[] constraints, int type) throws IOException {
        if (constraints != null && constraints.length > 0) {
            out.write(" ");
            out.write(Lexer.CONSTRAINT);
            out.write(" '");
            out.write(escape(constraints[0]));
            out.write("'");
            for (int i = 1; i < constraints.length; i++) {
                out.write(", '");
                out.write(escape(constraints[i]));
                out.write("'");
            }
        }
    }

    /**
     * Write a child node definition
     *
     * @param nd node definition
     * @throws IOException if an I/O error occurs
     */
    private void writeNodeDef(NodeDefinition nd) throws IOException {
        out.write("\n" + INDENT + Lexer.CHILD_NODE_DEFINITION + " ");

        writeJcrName(nd.getName());
        writeRequiredTypes(nd.getRequiredPrimaryTypeNames());
        writeDefaultType(nd.getDefaultPrimaryTypeName());
        if (nd.isMandatory()) {
            out.write(" ");
            out.write(Lexer.MANDATORY[0]);
        }
        if (nd.isAutoCreated()) {
            out.write(" ");
            out.write(Lexer.AUTOCREATED[0]);
        }
        if (nd.isProtected()) {
            out.write(" ");
            out.write(Lexer.PROTECTED[0]);
        }
        if (nd.allowsSameNameSiblings()) {
            out.write(" ");
            out.write(Lexer.MULTIPLE[0]);
        }
        if (nd.getOnParentVersion() != OnParentVersionAction.COPY) {
            out.write(" ");
            out.write(OnParentVersionAction.nameFromValue(nd.getOnParentVersion()).toLowerCase());
        }
    }
    
    /**
     * write required types
     * @param reqTypes required type names
     * @throws IOException if an I/O error occurs
     */
    private void writeRequiredTypes(String[] reqTypes) throws IOException {
        if (reqTypes != null && reqTypes.length > 0) {
            String delim = " " + Lexer.BEGIN_TYPE;
            for (String reqType : reqTypes) {
                out.write(delim);
                writeJcrName(reqType);
                delim = ", ";
            }
            out.write(Lexer.END_TYPE);
        }
    }

    /**
     * write default types
     * @param defType default type name
     * @throws IOException if an I/O error occurs
     */
    private void writeDefaultType(String defType) throws IOException {
        if (defType != null && !defType.equals("*")) {
            out.write(" = ");
            writeJcrName(defType);
        }
    }

    /**
     * Write the name and updated the namespace declarations if needed.
     * 
     * @param name name to write
     * @throws IOException if an I/O error occurs
     */
    private void writeJcrName(String name) throws IOException {
        if (name == null) {
            return;
        }

        String prefix = Text.getNamespacePrefix(name);
        if (!prefix.equals(NamespaceRegistry.PREFIX_EMPTY)) {
            // update namespace declaration
            writeNamespaceDeclaration(prefix);
            prefix += ":";
        }

        String localName = Text.getLocalName(name);
        String encLocalName = (ANY.equals(localName)) ? ANY : ISO9075.encode(Text.getLocalName(name));
        String resolvedName = prefix + encLocalName;

        // check for '-' and '+'
        boolean quotesNeeded = (name.indexOf('-') >= 0 || name.indexOf('+') >= 0);
        if (quotesNeeded) {
            out.write("'");
            out.write(resolvedName);
            out.write("'");
        } else {
            out.write(resolvedName);
        }
    }

    /**
     * escape
     * @param s string
     * @return the escaped string
     */
    private String escape(String s) {
        StringBuffer sb = new StringBuffer(s);
        for (int i = 0; i < sb.length(); i++) {
            if (sb.charAt(i) == '\\') {
                sb.insert(i, '\\');
                i++;
            } else if (sb.charAt(i) == '\'') {
                sb.insert(i, '\'');
                i++;
            }
        }
        return sb.toString();
    }

    /**
     * Map namespace prefixes such as present in a qualified JCR name to
     * the corresponding namespace URI.
     */
    public interface NamespaceMapping {

        String getNamespaceURI(String prefix);
    }

    /**
     * Default implementation using <code>Session</code> to determine
     * the namespace URI.
     */
    private static class DefaultNamespaceMapping implements NamespaceMapping {

        private final Session session;

        private DefaultNamespaceMapping(Session session) {
            this.session = session;
        }

        public String getNamespaceURI(String prefix) {
            try {
                return session.getNamespaceURI(prefix);
            } catch (RepositoryException e) {
                throw new RuntimeException(e);
            }
        }
    }
}