/*
    * 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.RoutingMode.EQUALS;
  import static org.forgerock.http.routing.RoutingMode.STARTS_WITH;
  import static org.forgerock.json.resource.Requests.copyOfActionRequest;
  import static org.forgerock.json.resource.Requests.copyOfApiRequest;
  import static org.forgerock.json.resource.Requests.copyOfCreateRequest;
  import static org.forgerock.json.resource.Requests.copyOfDeleteRequest;
  import static org.forgerock.json.resource.Requests.copyOfPatchRequest;
  import static org.forgerock.json.resource.Requests.copyOfQueryRequest;
  import static org.forgerock.json.resource.Requests.copyOfReadRequest;
  import static org.forgerock.json.resource.Requests.copyOfUpdateRequest;
  import static org.forgerock.json.resource.ResourceApiVersionRoutingFilter.setApiVersionInfo;
  import static org.forgerock.json.resource.Resources.newHandler;
  import static org.forgerock.json.resource.RouteMatchers.requestResourceApiVersionMatcher;
  import static org.forgerock.json.resource.RouteMatchers.requestUriMatcher;
  import static org.forgerock.json.resource.RouteMatchers.selfApiMatcher;
  import static org.forgerock.util.promise.Promises.newExceptionPromise;
  
  import org.forgerock.api.models.ApiDescription;
  import org.forgerock.http.ApiProducer;
  import org.forgerock.http.routing.ApiVersionRouterContext;
  import org.forgerock.http.routing.RoutingMode;
  import org.forgerock.http.routing.UriRouterContext;
  import org.forgerock.http.routing.Version;
  import org.forgerock.services.context.Context;
  import org.forgerock.services.descriptor.Describable;
  import org.forgerock.services.routing.AbstractRouter;
  import org.forgerock.services.routing.IncomparableRouteMatchException;
  import org.forgerock.services.routing.RouteMatcher;
  import org.forgerock.util.Pair;
  import org.forgerock.util.promise.Promise;
  
  /**
   * A router which routes requests based on route predicates. Each route is
   * comprised of a {@link RouteMatcher route matcher} and a corresponding
   * handler, when routing a request the router will call
   * {@link RouteMatcher#evaluate} for each
   * registered route and use the returned {@link RouteMatcher} to determine
   * which route best matches the request.
   *
   * <p>Routes may be added and removed from a router as follows:
   *
   * <pre>
   * Handler users = ...;
   * Router router = new Router();
   * RouteMatcher routeOne = RouteMatchers.requestUriMatcher(EQUALS, &quot;users&quot;);
   * RouteMatcher routeTwo = RouteMatchers.requestUriMatcher(EQUALS, &quot;users/{userId}&quot;);
   * router.addRoute(routeOne, users);
   * router.addRoute(routeTwo, users);
   *
   * // Deregister a route.
   * router.removeRoute(routeOne, routeTwo);
   * </pre>
   *
   * @see AbstractRouter
   * @see RouteMatchers
   */
  public class Router extends AbstractRouter<Router, Request, RequestHandler, ApiDescription>
          implements RequestHandler {
  
      private RequestHandler selfApiHandler = new SelfApiHandler();
  
      /**
       * Creates a new router with no routes defined.
       */
      public Router() {
          super();
      }
  
      /**
       * Creates a new router containing the same routes and default route as the
       * provided router. Changes to the returned router's routing table will not
       * impact the provided router.
       *
       * @param router The router to be copied.
       */
      public Router(AbstractRouter<Router, Request, RequestHandler, ApiDescription> router) {
          super(router);
      }
  
      @Override
      protected Router getThis() {
         return this;
     }
 
     @Override
     protected RouteMatcher<Request> uriMatcher(RoutingMode mode, String pattern) {
         return requestUriMatcher(mode, pattern);
     }
 
     /**
      * Adds a new route to this router for the provided collection resource
      * provider. New routes may be added while this router is processing
      * requests.
      * <p>
      * The provided URI template must match the resource collection itself, not
      * resource instances. For example:
      *
      * <pre>
      * CollectionResourceProvider users = ...;
      * Router router = new Router();
      *
      * // This is valid usage: the template matches the resource collection.
      * router.addRoute(Router.uriTemplate("users"), users);
      *
      * // This is invalid usage: the template matches resource instances.
      * router.addRoute(Router.uriTemplate("users/{userId}"), users);
      * </pre>
      *
      * @param uriTemplate
      *            The URI template which request resource names must match.
      * @param provider
      *            The collection resource provider to which matching requests
      *            will be routed.
      * @return The {@link RouteMatcher} for the route that can be used to
      * remove the route at a later point.
      */
     public RouteMatcher<Request> addRoute(UriTemplate uriTemplate, CollectionResourceProvider provider) {
         RouteMatcher<Request> routeMatcher = requestUriMatcher(STARTS_WITH, uriTemplate.template);
         addRoute(routeMatcher, newHandler(provider));
         return routeMatcher;
     }
 
     /**
      * Adds a new route to this router for the provided singleton resource
      * provider. New routes may be added while this router is processing
      * requests.
      *
      * @param uriTemplate
      *            The URI template which request resource names must match.
      * @param provider
      *            The singleton resource provider to which matching requests
      *            will be routed.
      * @return The {@link RouteMatcher} for the route that can be used to
      * remove the route at a later point.
      */
     public RouteMatcher<Request> addRoute(UriTemplate uriTemplate, SingletonResourceProvider provider) {
         RouteMatcher<Request> routeMatcher = requestUriMatcher(EQUALS, uriTemplate.template);
         addRoute(routeMatcher, newHandler(provider));
         return routeMatcher;
     }
 
     /**
      * Adds a new route to this router for the provided request handler. New
      * routes may be added while this router is processing requests.
      *
      * @param mode
      *            Indicates how the URI template should be matched against
      *            resource names.
      * @param uriTemplate
      *            The URI template which request resource names must match.
      * @param handler
      *            The request handler to which matching requests will be routed.
      * @return The {@link RouteMatcher} for the route that can be used to
      * remove the route at a later point.
      */
     public RouteMatcher<Request> addRoute(RoutingMode mode, UriTemplate uriTemplate, RequestHandler handler) {
         RouteMatcher<Request> routeMatcher = requestUriMatcher(mode, uriTemplate.template);
         addRoute(routeMatcher, handler);
         return routeMatcher;
     }
 
     /**
      * Creates a {@link UriTemplate} from a URI template string that will be
      * used to match and route incoming requests.
      *
      * @param template The URI template.
      * @return A {@code UriTemplate} instance.
      */
     public static UriTemplate uriTemplate(String template) {
         return new UriTemplate(template);
     }
 
     /**
      * Adds a new route to this router for the provided collection resource
      * provider. New routes may be added while this router is processing
      * requests.
      *
      * @param version The resource API version the the request must match.
      * @param provider The collection resource provider to which matching
      *                 requests will be routed.
      * @return The {@link RouteMatcher} for the route that can be used to
      * remove the route at a later point.
      */
     public RouteMatcher<Request> addRoute(Version version, CollectionResourceProvider provider) {
         return addRoute(version, newHandler(provider));
     }
 
     /**
      * Adds a new route to this router for the provided singleton resource
      * provider. New routes may be added while this router is processing
      * requests.
      *
      * @param version The resource API version the the request must match.
      * @param provider The singleton resource provider to which matching
      *                 requests will be routed.
      * @return The {@link RouteMatcher} for the route that can be used to
      * remove the route at a later point.
      */
     public RouteMatcher<Request> addRoute(Version version, SingletonResourceProvider provider) {
         return addRoute(version, newHandler(provider));
     }
 
     /**
      * Adds a new route to this router for the provided request handler. New
      * routes may be added while this router is processing requests.
      *
      * @param version The resource API version the the request must match.
      * @param handler
      *            The request handler to which matching requests will be routed.
      * @return The {@link RouteMatcher} for the route that can be used to
      * remove the route at a later point.
      */
     public RouteMatcher<Request> addRoute(Version version, RequestHandler handler) {
         RouteMatcher<Request> routeMatcher = requestResourceApiVersionMatcher(version);
         addRoute(routeMatcher, handler);
         return routeMatcher;
     }
 
     private Pair<Context, RequestHandler> getBestMatch(Context context, Request request)
             throws ResourceException {
         try {
             Pair<Context, RequestHandler> bestMatch = getBestRoute(context, request);
             if (bestMatch == null) {
                 throw new NotFoundException(String.format("Resource '%s' not found", request.getResourcePath()));
             }
             return bestMatch;
         } catch (IncomparableRouteMatchException e) {
             throw new InternalServerErrorException(e.getMessage(), e);
         }
     }
 
     @Override
     public Promise<ActionResponse, ResourceException> handleAction(Context context, ActionRequest request) {
         try {
             Pair<Context, RequestHandler> bestMatch = getBestMatch(context, request);
             UriRouterContext routerContext = getRouterContext(bestMatch.getFirst());
             ActionRequest routedRequest = wasRouted(context, routerContext)
                     ? copyOfActionRequest(request).setResourcePath(getResourcePath(routerContext))
                     : request;
             return bestMatch.getSecond().handleAction(bestMatch.getFirst(), routedRequest);
         } catch (ResourceException e) {
             return newExceptionPromise(e);
         }
     }
 
     @Override
     public Promise<ResourceResponse, ResourceException> handleCreate(Context context, CreateRequest request) {
         try {
             Pair<Context, RequestHandler> bestMatch = getBestMatch(context, request);
             UriRouterContext routerContext = getRouterContext(bestMatch.getFirst());
             CreateRequest routedRequest = wasRouted(context, routerContext)
                     ? copyOfCreateRequest(request).setResourcePath(getResourcePath(routerContext))
                     : request;
             return bestMatch.getSecond().handleCreate(bestMatch.getFirst(), routedRequest);
         } catch (ResourceException e) {
             return newExceptionPromise(e);
         }
     }
 
     @Override
     public Promise<ResourceResponse, ResourceException> handleDelete(Context context, DeleteRequest request) {
         try {
             Pair<Context, RequestHandler> bestMatch = getBestMatch(context, request);
             UriRouterContext routerContext = getRouterContext(bestMatch.getFirst());
             DeleteRequest routedRequest = wasRouted(context, routerContext)
                     ? copyOfDeleteRequest(request).setResourcePath(getResourcePath(routerContext))
                     : request;
             return bestMatch.getSecond().handleDelete(bestMatch.getFirst(), routedRequest);
         } catch (ResourceException e) {
             return newExceptionPromise(e);
         }
     }
 
     @Override
     public Promise<ResourceResponse, ResourceException> handlePatch(Context context, PatchRequest request) {
         try {
             Pair<Context, RequestHandler> bestMatch = getBestMatch(context, request);
             UriRouterContext routerContext = getRouterContext(bestMatch.getFirst());
             PatchRequest routedRequest = wasRouted(context, routerContext)
                     ? copyOfPatchRequest(request).setResourcePath(getResourcePath(routerContext))
                     : request;
             return bestMatch.getSecond().handlePatch(bestMatch.getFirst(), routedRequest);
         } catch (ResourceException e) {
             return newExceptionPromise(e);
         }
     }
 
     @Override
     public Promise<QueryResponse, ResourceException> handleQuery(final Context context,
             final QueryRequest request, final QueryResourceHandler handler) {
         try {
             Pair<Context, RequestHandler> bestMatch = getBestMatch(context, request);
             final Context decoratedContext = bestMatch.getFirst();
             UriRouterContext routerContext = getRouterContext(decoratedContext);
             QueryRequest routedRequest = wasRouted(context, routerContext)
                     ? copyOfQueryRequest(request).setResourcePath(getResourcePath(routerContext))
                     : request;
             QueryResourceHandler resourceHandler = new QueryResourceHandler() {
                 @Override
                 public boolean handleResource(ResourceResponse resource) {
                     if (decoratedContext.containsContext(ApiVersionRouterContext.class)) {
                         ApiVersionRouterContext apiVersionRouterContext =
                                 decoratedContext.asContext(ApiVersionRouterContext.class);
                         setApiVersionInfo(apiVersionRouterContext, request, resource);
                     }
                     return handler.handleResource(resource);
                 }
             };
             return bestMatch.getSecond().handleQuery(decoratedContext, routedRequest, resourceHandler);
         } catch (ResourceException e) {
             return newExceptionPromise(e);
         }
     }
 
     @Override
     public Promise<ResourceResponse, ResourceException> handleRead(Context context, ReadRequest request) {
         try {
             Pair<Context, RequestHandler> bestMatch = getBestMatch(context, request);
             UriRouterContext routerContext = getRouterContext(bestMatch.getFirst());
             ReadRequest routedRequest = wasRouted(context, routerContext)
                     ? copyOfReadRequest(request).setResourcePath(getResourcePath(routerContext))
                     : request;
             return bestMatch.getSecond().handleRead(bestMatch.getFirst(), routedRequest);
         } catch (ResourceException e) {
             return newExceptionPromise(e);
         }
     }
 
     @Override
     public Promise<ResourceResponse, ResourceException> handleUpdate(Context context, UpdateRequest request) {
         try {
             Pair<Context, RequestHandler> bestMatch = getBestMatch(context, request);
             UriRouterContext routerContext = getRouterContext(bestMatch.getFirst());
             UpdateRequest routedRequest = wasRouted(context, routerContext)
                     ? copyOfUpdateRequest(request).setResourcePath(getResourcePath(routerContext))
                     : request;
             return bestMatch.getSecond().handleUpdate(bestMatch.getFirst(), routedRequest);
         } catch (ResourceException e) {
             return newExceptionPromise(e);
         }
     }
 
     @Override
     @SuppressWarnings("unchecked")
     public ApiDescription handleApiRequest(Context context, Request request) {
         try {
             Pair<Context, RequestHandler> bestRoute = getBestApiRoute(context, request);
             if (bestRoute != null) {
                 RequestHandler handler = bestRoute.getSecond();
                 if (handler instanceof Describable) {
                     Context nextContext = bestRoute.getFirst();
                     UriRouterContext routerContext = getRouterContext(nextContext);
                     Request routedRequest = wasRouted(context, routerContext)
                         ? copyOfApiRequest(request).setResourcePath(getResourcePath(routerContext))
                         : request;
                     return ((Describable<ApiDescription, Request>) handler)
                         .handleApiRequest(nextContext, routedRequest);
                 }
             }
         } catch (IncomparableRouteMatchException e) {
             throw new UnsupportedOperationException(e);
         }
         if (thisRouterUriMatcher.evaluate(context, request) != null) {
             return this.api;
         }
         throw new IllegalStateException(
             "No route matched the request resource path " + request.getResourcePath());
     }
 
     private UriRouterContext getRouterContext(Context context) {
         return context.containsContext(UriRouterContext.class)
             ? context.asContext(UriRouterContext.class)
             : null;
     }
 
     private boolean wasRouted(Context originalContext, UriRouterContext routerContext) {
         return routerContext != null
                 && (!originalContext.containsContext(UriRouterContext.class)
                 || routerContext != originalContext.asContext(UriRouterContext.class));
     }
 
     private String getResourcePath(UriRouterContext routerContext) {
         return routerContext.getRemainingUri();
     }
 
     /**
      * Represents a URI template string that will be used to match and route
      * incoming requests.
      */
     public static final class UriTemplate {
         private final String template;
 
         private UriTemplate(String template) {
             this.template = template;
         }
 
         /**
          * Return the string representation of the UriTemplate.
          *
          * @return the string representation of the UriTemplate.
          */
         @Override
         public String toString() {
             return template;
         }
     }
 
     @Override
     protected Pair<RouteMatcher<Request>, RequestHandler> getSelfApiHandler() {
         return Pair.of(selfApiMatcher(), selfApiHandler);
     }
 
     private class SelfApiHandler extends AbstractRequestHandler implements Describable<ApiDescription, Request> {
 
         @Override
         public ApiDescription api(ApiProducer<ApiDescription> producer) {
             throw new UnsupportedOperationException();
         }
 
         @Override
         public ApiDescription handleApiRequest(Context context, Request request) {
             return api;
         }
 
         @Override
         public void addDescriptorListener(Listener listener) {
             throw new UnsupportedOperationException();
         }
 
         @Override
         public void removeDescriptorListener(Listener listener) {
             throw new UnsupportedOperationException();
         }
     }
 }