/*
 * 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 2015-2016 ForgeRock AS.
 */

package org.forgerock.json.resource;

import static org.forgerock.http.routing.RouteMatchers.resourceApiVersionMatcher;
import static org.forgerock.http.routing.RouteMatchers.uriMatcher;

import java.util.ArrayList;
import java.util.List;

import org.forgerock.http.routing.ResourceApiVersionBehaviourManager;
import org.forgerock.http.routing.RoutingMode;
import org.forgerock.http.routing.Version;
import org.forgerock.http.ApiProducer;
import org.forgerock.services.context.Context;
import org.forgerock.services.routing.IncomparableRouteMatchException;
import org.forgerock.services.routing.RouteMatch;
import org.forgerock.services.routing.RouteMatcher;

/**
 * A utility class that contains methods for creating route matchers.
 */
public final class RouteMatchers {

    private static final SelfApiMatcher SELF_API_MATCHER = new SelfApiMatcher();

    private RouteMatchers() {
    }

    /**
     * Creates a {@code RouteMatcher} instance that matches {@code Request}s
     * with the provided {@literal mode} and {@literal template}.
     *
     * @param mode The routing mode.
     * @param template The uri template.
     * @return A {@code RouteMatcher} instance.
     */
    public static RouteMatcher<Request> requestUriMatcher(RoutingMode mode, String template) {
        return new RequestUriRouteMatcher(uriMatcher(mode, template));
    }

    /**
     * Creates a new {@code ResourceApiVersionBehaviourManager} which is responsibly
     * for managing whether warning headers are returned and the default
     * version behaviour when the {@literal Accept-API-Version} header is not
     * present on the request.
     *
     * @return A new {@code ResourceApiVersionBehaviourManager}.
     */
    public static ResourceApiVersionBehaviourManager newResourceApiVersionBehaviourManager() {
        return org.forgerock.http.routing.RouteMatchers.newResourceApiVersionBehaviourManager();
    }

    /**
     * Creates a {@code Filter} which MUST be placed, in the route, before any
     * API Version routing takes place.
     *
     * <p>The filter will add the required {@code Context}s, default version
     * behaviour and response headers.</p>
     *
     * @param behaviourManager A {@code ResourceApiVersionBehaviourManager} instance.
     * @return A {@code Filter} instance.
     */
    public static Filter resourceApiVersionContextFilter(ResourceApiVersionBehaviourManager behaviourManager) {
        return new ResourceApiVersionRoutingFilter(behaviourManager);
    }

    /**
     * Creates a {@code RouteMatcher} instance that matches the request
     * resource API version with the provided {@literal version}.
     *
     * @param version The API version of the resource.
     * @return A {@code RouteMatcher} instance.
     */
    public static RouteMatcher<Request> requestResourceApiVersionMatcher(Version version) {
        return new RequestApiVersionRouteMatcher(resourceApiVersionMatcher(version));
    }

    /**
     * A matcher to check if the request is for all versions of the API descriptor of the current path.
     *
     * @return A {@code RouteMatcher} instance.
     */
    static RouteMatcher<Request> selfApiMatcher() {
        return SELF_API_MATCHER;
    }

    /**
     * A CREST specific {@code RouteMatcher} which extracts the requests
     * resource name from a {@code Request} and passes it as a
     * {@code ResourcePath} to the common {@code ResourcePath} route predicate.
     */
    private static final class RequestUriRouteMatcher extends RouteMatcher<Request> {

        private final RouteMatcher<List<String>> delegate;

        private RequestUriRouteMatcher(RouteMatcher<List<String>> delegate) {
            this.delegate = delegate;
        }

        @Override
        public RouteMatch evaluate(Context context, Request request) {
            final List<String> pathElements = new ArrayList<>(request.getResourcePathObject().size());
            for (String pathElement : request.getResourcePathObject()) {
                pathElements.add(pathElement);
            }
            return delegate.evaluate(context, pathElements);
        }

        @Override
        public String toString() {
            return delegate.toString();
        }

        @Override
        public String idFragment() {
            return delegate.idFragment();
        }

        @Override
        public boolean equals(Object o) {
            if (this == o) {
                return true;
            }
            if (!(o instanceof RequestUriRouteMatcher)) {
                return false;
            }
            RequestUriRouteMatcher that = (RequestUriRouteMatcher) o;
            return delegate.equals(that.delegate);
        }

        @Override
        public <T> T transformApi(T t, ApiProducer<T> apiProducer) {
            return delegate.transformApi(t, apiProducer);
        }

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

    /**
     * A CREST specific {@code RouteMatcher} which extracts the resource API
     * version from a {@code Request} and passes it to the common
     * {@code Version} route matcher.
     */
    private static final class RequestApiVersionRouteMatcher extends RouteMatcher<Request> {

        private final RouteMatcher<Version> delegate;

        private RequestApiVersionRouteMatcher(RouteMatcher<Version> delegate) {
            this.delegate = delegate;
        }

        @Override
        public RouteMatch evaluate(Context context, Request request) {
            return delegate.evaluate(context, request.getResourceVersion());
        }

        @Override
        public String toString() {
            return delegate.toString();
        }

        @Override
        public String idFragment() {
            return delegate.idFragment();
        }

        @Override
        public boolean equals(Object o) {
            if (this == o) {
                return true;
            }
            if (!(o instanceof RequestApiVersionRouteMatcher)) {
                return false;
            }
            RequestApiVersionRouteMatcher that = (RequestApiVersionRouteMatcher) o;
            return delegate.equals(that.delegate);
        }

        @Override
        public <T> T transformApi(T t, ApiProducer<T> apiProducer) {
            return delegate.transformApi(t, apiProducer);
        }

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

    private static class SelfApiMatcher extends RouteMatcher<Request> {

        @Override
        public RouteMatch evaluate(Context context, final Request request) {
            return new RouteMatch() {
                @Override
                public boolean isBetterMatchThan(RouteMatch result) throws IncomparableRouteMatchException {
                    return request.getRequestType().equals(RequestType.API)
                            && request.getResourceVersion() == null
                            && request.getResourcePathObject().equals(ResourcePath.empty());
                }

                @Override
                public Context decorateContext(Context context) {
                    return context;
                }
            };
        }

        @Override
        public String toString() {
            return "API Request";
        }

        @Override
        public int hashCode() {
            return 0;
        }

        @Override
        public boolean equals(Object o) {
            return this == o;
        }

        @Override
        public String idFragment() {
            throw new UnsupportedOperationException();
        }

        @Override
        public <D> D transformApi(D descriptor, ApiProducer<D> producer) {
            throw new UnsupportedOperationException();
        }
    }
}