/*
 * The contents of this file are subject to the terms of the Common Development and
 * Distribution License (the License). You may not use this file except in compliance with the
 * License.
 *
 * You can obtain a copy of the License at legal/CDDLv1.0.txt. See the License for the
 * specific language governing permission and limitations under the License.
 *
 * When distributing Covered Software, include this CDDL Header Notice in each file and include
 * the License file at legal/CDDLv1.0.txt. If applicable, add the following below the CDDL
 * Header, with the fields enclosed by brackets [] replaced by your own identifying
 * information: "Portions copyright [year] [name of copyright owner]".
 *
 * Copyright 2016 ForgeRock AS.
 */
package org.forgerock.opendj.rest2ldap;

import static org.forgerock.opendj.rest2ldap.Rest2Ldap.DECODE_OPTIONS;

import java.util.ArrayList;
import java.util.List;
import java.util.Map;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

import org.forgerock.http.routing.UriRouterContext;
import org.forgerock.opendj.ldap.DN;
import org.forgerock.opendj.ldap.schema.Schema;
import org.forgerock.services.context.Context;
import org.forgerock.util.Options;

/**
 * Represents a DN template whose RDN values may be substituted with URL template parameters parsed during routing.
 * Two types of DN template are supported: {@link #compile(String) absolute/relative} or {@link #compileRelative(String)
 * relative}. The table below shows how DN templates will be resolved to DNs when the template parameter "subdomain"
 * has the value "www" and the current routing state references the DN "dc=example,dc=com":
 * <p>
 * <table>
 * <tr><th>DN Template</th><th>{@link #compile(String)}</th><th>{@link #compileRelative(String)}</th></tr>
 * <tr><td>dc=www</td><td>dc=www</td><td>dc=www,dc=example,dc=com</td></tr>
 * <tr><td>..</td><td>dc=com</td><td>dc=com</td></tr>
 * <tr><td>dc={subdomain}</td><td>dc=www</td><td>dc=www,dc=example,dc=com</td></tr>
 * <tr><td>dc={subdomain},..</td><td>dc=www,dc=com</td><td>dc=www,dc=com</td></tr>
 * </table>
 */
final class DnTemplate {
    private static final Pattern TEMPLATE_VARIABLE_RE = Pattern.compile("\\{([^}]+)\\}");
    private final String template;
    private final String formatString;
    private final List<String> variables;
    /** A value of -1 means that this DN template is absolute. */
    private final int relativeOffset;

    /**
     * Compiles a DN template which will resolve LDAP entries relative to the current routing state. The DN template may
     * contain trailing ".." RDNs in order to resolve entries which are relative to a parent of the current routing
     * state.
     *
     * @param template
     *         The string representation of the DN template.
     * @return The compiled DN template.
     */
    static DnTemplate compileRelative(String template) {
        return compile(template, true);
    }

    /**
     * Compiles a DN template which will resolve LDAP entries relative to the root DSE by default, but MAY include
     * relative RDNs indicating that the DN template will be resolved against current routing state instead.
     *
     * @param template
     *         The string representation of the DN template.
     * @return The compiled DN template.
     */
    static DnTemplate compile(String template) {
        return compile(template, false);
    }

    private static DnTemplate compile(String template, boolean isRelative) {
        // Parse any trailing relative RDNs.
        String trimmedTemplate;
        int relativeOffset;

        if (template.equals("..")) {
            trimmedTemplate = "";
            relativeOffset = 1;
        } else if (template.endsWith(",..")) {
            relativeOffset = 0;
            for (trimmedTemplate = template;
                 trimmedTemplate.endsWith(",..");
                 trimmedTemplate = trimmedTemplate.substring(0, trimmedTemplate.length() - 3)) {
                relativeOffset++;
            }
        } else if (isRelative) {
            trimmedTemplate = template;
            relativeOffset = 0;
        } else {
            trimmedTemplate = template;
            relativeOffset = -1;
        }

        final List<String> templateVariables = new ArrayList<>();
        final Matcher matcher = TEMPLATE_VARIABLE_RE.matcher(trimmedTemplate);
        final StringBuffer buffer = new StringBuffer(trimmedTemplate.length());
        while (matcher.find()) {
            matcher.appendReplacement(buffer, "%s");
            templateVariables.add(matcher.group(1));
        }
        matcher.appendTail(buffer);
        return new DnTemplate(trimmedTemplate, buffer.toString(), templateVariables, relativeOffset);
    }

    private DnTemplate(String template, String formatString, List<String> variables, int relativeOffset) {
        this.template = template;
        this.formatString = formatString;
        this.variables = variables;
        this.relativeOffset = relativeOffset;
    }

    DN format(final Context context) {
        // First determine the base DN based on the context DN and the relative offset.
        DN baseDn = null;
        if (relativeOffset >= 0 && context.containsContext(RoutingContext.class)) {
            final RoutingContext routingContext = context.asContext(RoutingContext.class);
            baseDn = routingContext.getDn().parent(routingContext.isCollection() ? relativeOffset - 1 : relativeOffset);
        }
        if (baseDn == null) {
            baseDn = DN.rootDN();
        }

        // Construct a DN using any routing template parameters.
        final Options options = context.asContext(Rest2LdapContext.class).getRest2ldap().getOptions();
        final Schema schema = options.get(DECODE_OPTIONS).getSchemaResolver().resolveSchema(template);
        if (variables.isEmpty()) {
            final DN relativeDn = DN.valueOf(template, schema);
            return baseDn.child(relativeDn);
        } else {
            final String[] values = new String[variables.size()];
            for (int i = 0; i < values.length; i++) {
                values[i] = getTemplateParameter(context, variables.get(i));
            }
            final DN relativeDn = DN.format(formatString, schema, (Object[]) values);
            return baseDn.child(relativeDn);
        }
    }

    private String getTemplateParameter(final Context context, final String parameter) {
        UriRouterContext uriRouterContext = context.asContext(UriRouterContext.class);
        for (;;) {
            final Map<String, String> uriTemplateVariables = uriRouterContext.getUriTemplateVariables();
            final String value = uriTemplateVariables.get(parameter);
            if (value != null) {
                return value;
            }
            if (!uriRouterContext.getParent().containsContext(UriRouterContext.class)) {
                throw new IllegalStateException("DN template parameter \"" + parameter + "\" cannot be resolved");
            }
            uriRouterContext = uriRouterContext.getParent().asContext(UriRouterContext.class);
        }
    }
}