/*
 * ModeShape (http://www.modeshape.org)
 *
 * Licensed 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.modeshape.jcr.sequencer;

import java.io.Serializable;
import java.util.HashMap;
import java.util.Map;
import java.util.regex.Pattern;
import org.modeshape.common.annotation.Immutable;
import org.modeshape.common.util.CheckArg;
import org.modeshape.common.util.HashCode;
import org.modeshape.common.util.ObjectUtil;
import org.modeshape.jcr.RepositoryI18n;
import org.modeshape.jcr.sequencer.PathExpression.WorkspacePath;

/**
 * An expression that defines a selection of some change in the repository that signals a sequencing operation should be run, and
 * the location where the sequencing output should be placed. Sequencer path expressions are used to determine whether information
 * in the repository needs to be sequenced.
 * <p>
 * A simple example is the following:
 * 
 * <pre>
 *     /a/b/c@title =&gt; /d/e/f
 * </pre>
 * 
 * which means that a sequencer (that uses this expression in its configuration) should be run any time there is a new or modified
 * <code>title</code> property on the <code>/a/b/c</code> node, and that the output of the sequencing should be placed at
 * <code>/d/e/f</code>.
 * </p>
 */
@Immutable
public class SequencerPathExpression implements Serializable {

    /**
     */
    private static final long serialVersionUID = 229464314137494765L;

    /**
     * The pattern used to break the initial input string into the two major parts, the selection and output expressions. Group 1
     * contains the selection expression, and group 2 contains the output expression.
     */
    private static final Pattern TWO_PART_PATTERN = Pattern.compile("((?:[^=]|=(?!>))+)(?:=>(.+))?");

    protected static final String DEFAULT_OUTPUT_EXPRESSION = ".";

    private static final String PARENT_PATTERN_STRING = "[^/]+/\\.\\./"; // [^/]+/\.\./
    private static final Pattern PARENT_PATTERN = Pattern.compile(PARENT_PATTERN_STRING);

    private static final String REPLACEMENT_VARIABLE_PATTERN_STRING = "(?<!\\\\)\\$(\\d+)"; // (?<!\\)\$(\d+)
    private static final Pattern REPLACEMENT_VARIABLE_PATTERN = Pattern.compile(REPLACEMENT_VARIABLE_PATTERN_STRING);

    /**
     * Compile the supplied expression and return the resulting SequencerPathExpression instance.
     * 
     * @param expression the expression
     * @return the path expression; never null
     * @throws IllegalArgumentException if the expression is null
     * @throws InvalidSequencerPathExpression if the expression is blank or is not a valid expression
     */
    public static final SequencerPathExpression compile( String expression ) throws InvalidSequencerPathExpression {
        CheckArg.isNotNull(expression, "sequencer path expression");
        expression = expression.trim();
        if (expression.length() == 0) {
            throw new InvalidSequencerPathExpression(RepositoryI18n.pathExpressionMayNotBeBlank.text());
        }
        java.util.regex.Matcher matcher = TWO_PART_PATTERN.matcher(expression);
        if (!matcher.matches()) {
            throw new InvalidSequencerPathExpression(RepositoryI18n.pathExpressionIsInvalid.text(expression));
        }
        String selectExpression = matcher.group(1);
        String outputExpression = matcher.group(2);
        return new SequencerPathExpression(PathExpression.compile(selectExpression), outputExpression);
    }

    private final PathExpression selectExpression;
    private final String outputExpression;
    private final int hc;

    protected SequencerPathExpression( PathExpression selectExpression,
                                       String outputExpression ) {
        CheckArg.isNotNull(selectExpression, "select expression");
        this.selectExpression = selectExpression;
        this.outputExpression = outputExpression != null ? outputExpression.trim() : DEFAULT_OUTPUT_EXPRESSION;
        this.hc = HashCode.compute(this.selectExpression, this.outputExpression);
    }

    /**
     * @return selectExpression
     */
    public String getSelectExpression() {
        return this.selectExpression.getSelectExpression();
    }

    /**
     * @return outputExpression
     */
    public String getOutputExpression() {
        return this.outputExpression;
    }

    @Override
    public int hashCode() {
        return this.hc;
    }

    @Override
    public boolean equals( Object obj ) {
        if (obj == this) return true;
        if (obj instanceof SequencerPathExpression) {
            SequencerPathExpression that = (SequencerPathExpression)obj;
            if (!this.selectExpression.equals(that.selectExpression)) return false;
            if (!this.outputExpression.equalsIgnoreCase(that.outputExpression)) return false;
            return true;
        }
        return false;
    }

    @Override
    public String toString() {
        return this.selectExpression + "=>" + this.outputExpression;
    }

    /**
     * Determine if this path expression applies to content within the supplied workspace name.
     * 
     * @param workspaceName the name of the workspace; may not be null
     * @return true if this path expression matches the workspace name, or false otherwise
     */
    public final boolean appliesToWorkspace( String workspaceName ) {
        return selectExpression.matchesWorkspace(workspaceName);
    }

    /**
     * Obtain a Matcher that can be used to convert the supplied workspace key and absolute path into an output workspace name and
     * and output path.
     * 
     * @param absolutePath the path in the workspace; may not be null
     * @return the matcher; never null
     */
    public Matcher matcher( String absolutePath ) {
        PathExpression.Matcher inputMatcher = selectExpression.matcher(absolutePath);
        String outputPath = null;
        WorkspacePath wsPath = null;
        if (inputMatcher.matches()) {
            // Grab the named groups ...
            Map<Integer, String> replacements = new HashMap<Integer, String>();
            for (int i = 0, count = inputMatcher.groupCount(); i <= count; ++i) {
                replacements.put(i, inputMatcher.group(i));
            }

            // Grab the selected path ...
            String selectedPath = inputMatcher.getSelectedNodePath();

            // Find the output path using the groups from the match pattern ...
            wsPath = PathExpression.parsePathInWorkspace(this.outputExpression);
            if (wsPath != null) {
                if (wsPath.workspaceName == null) wsPath = wsPath.withWorkspaceName(inputMatcher.getSelectedWorkspaceName());
                outputPath = wsPath.path;
                if (!DEFAULT_OUTPUT_EXPRESSION.equals(outputPath)) {
                    java.util.regex.Matcher replacementMatcher = REPLACEMENT_VARIABLE_PATTERN.matcher(outputPath);
                    // CHECKSTYLE IGNORE check FOR NEXT 1 LINES
                    StringBuffer sb = new StringBuffer();
                    if (replacementMatcher.find()) {
                        do {
                            String variable = replacementMatcher.group(1);
                            String replacement = replacements.get(Integer.valueOf(variable));
                            if (replacement == null) replacement = replacementMatcher.group(0);
                            replacementMatcher.appendReplacement(sb, replacement);
                        } while (replacementMatcher.find());
                        replacementMatcher.appendTail(sb);
                        outputPath = sb.toString();
                    }
                    // Make sure there is a trailing '/' ...
                    if (!outputPath.endsWith("/")) outputPath = outputPath + "/";

                    // Replace all references to "/./" with "/" ...
                    outputPath = outputPath.replaceAll("/\\./", "/");

                    // Remove any path segment followed by a parent reference ...
                    java.util.regex.Matcher parentMatcher = PARENT_PATTERN.matcher(outputPath);
                    while (parentMatcher.find()) {
                        outputPath = parentMatcher.replaceAll("");
                        // Make sure there is a trailing '/' ...
                        if (!outputPath.endsWith("/")) outputPath = outputPath + "/";
                        parentMatcher = PARENT_PATTERN.matcher(outputPath);
                    }

                    // Remove all multiple occurrences of '/' ...
                    outputPath = outputPath.replaceAll("/{2,}", "/");

                    // Remove the trailing '/@property' ...
                    outputPath = outputPath.replaceAll("/@[^/\\[\\]]+$", "");

                    // Remove a trailing '/' ...
                    outputPath = outputPath.replaceAll("/$", "");

                    // If the output path is blank, then use the default output expression ...
                    if (outputPath.length() == 0) outputPath = DEFAULT_OUTPUT_EXPRESSION;

                }
                if (DEFAULT_OUTPUT_EXPRESSION.equals(outputPath)) {
                    // The output path is the default expression, so use the selected path ...
                    outputPath = selectedPath;
                }
                wsPath = wsPath.withPath(outputPath);
            }
        }

        return new Matcher(inputMatcher, wsPath);
    }

    @Immutable
    public static class Matcher {

        private final PathExpression.Matcher inputMatcher;
        private final WorkspacePath outputPath;
        private final int hc;

        protected Matcher( PathExpression.Matcher inputMatcher,
                           WorkspacePath outputPath ) {
            this.inputMatcher = inputMatcher;
            this.outputPath = outputPath;
            this.hc = HashCode.compute(super.hashCode(), this.outputPath);
        }

        public boolean matches() {
            return inputMatcher.matches() && this.outputPath != null;
        }

        /**
         * @return inputPath
         */
        public String getInputPath() {
            return inputMatcher.getInputPath();
        }

        /**
         * Get the {@link #getInputPath() input path} in standard JCR form.
         * 
         * @return the JCR form of the input path; null only if {@link #getInputPath()} is null
         */
        public String getJcrInputPath() {
            // Conver the input path (which has a '@' to denote a property) to a standard JCR path ...
            String inputPath = getInputPath();
            if (inputPath == null) return null;
            int index = inputPath.lastIndexOf("/@");
            if (index != -1) {
                inputPath = inputPath.substring(0, index) + '/' + inputPath.substring(index + 2);
            }
            return inputPath;
        }

        /**
         * @return selectPattern
         */
        public String getSelectedPath() {
            return inputMatcher.getSelectedNodePath();
        }

        /**
         * Get the path in the repository where the sequenced content should be placed.
         * 
         * @return outputPath the output path, or null if this matcher does not match the input
         */
        public String getOutputPath() {
            return this.outputPath != null ? this.outputPath.path : null;
        }

        /**
         * Get the name of the workspace where the sequenced content should be placed.
         * 
         * @return outputPath the output path, or null if this matcher does not match the input
         */
        public String getOutputWorkspaceName() {
            return this.outputPath != null ? this.outputPath.workspaceName : null;
        }

        @Override
        public int hashCode() {
            return this.hc;
        }

        @Override
        public boolean equals( Object obj ) {
            if (obj == this) return true;
            if (obj instanceof SequencerPathExpression.Matcher) {
                SequencerPathExpression.Matcher that = (SequencerPathExpression.Matcher)obj;
                if (!super.equals(that)) return false;
                return ObjectUtil.isEqualWithNulls(this.outputPath, that.outputPath);
            }
            return false;
        }

        @Override
        public String toString() {
            return inputMatcher + " => " + this.outputPath;
        }
    }

}
