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

package org.forgerock.json.resource;

import static org.forgerock.api.models.Parameter.*;
import static org.forgerock.api.models.Resource.AnnotatedTypeVariant.*;
import static org.forgerock.api.models.SubResources.*;
import static org.forgerock.http.routing.RoutingMode.*;
import static org.forgerock.json.resource.Responses.*;
import static org.forgerock.json.resource.RouteMatchers.*;
import static org.forgerock.util.promise.Promises.*;

import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.util.Collection;
import java.util.LinkedHashMap;
import java.util.Map;

import org.forgerock.api.annotations.CollectionProvider;
import org.forgerock.api.annotations.Path;
import org.forgerock.api.annotations.SingletonProvider;
import org.forgerock.api.enums.ParameterSource;
import org.forgerock.api.models.ApiDescription;
import org.forgerock.api.models.Items;
import org.forgerock.api.models.Parameter;
import org.forgerock.api.models.Resource;
import org.forgerock.api.models.SubResources;
import org.forgerock.http.ApiProducer;
import org.forgerock.http.routing.UriRouterContext;
import org.forgerock.json.JsonPointer;
import org.forgerock.json.JsonValue;
import org.forgerock.services.context.AbstractContext;
import org.forgerock.services.context.Context;
import org.forgerock.services.descriptor.Describable;
import org.forgerock.util.Reject;
import org.forgerock.util.promise.Promise;

/**
 * This class contains methods for creating and manipulating connection
 * factories and connections.
 */
public final class Resources {

    private static final class InternalConnectionFactory implements ConnectionFactory {
        private final RequestHandler handler;

        private InternalConnectionFactory(final RequestHandler handler) {
            this.handler = handler;
        }

        @Override
        public void close() {
            // Do nothing.
        }

        @Override
        public Connection getConnection() {
            return newInternalConnection(handler);
        }

        public Promise<Connection, ResourceException> getConnectionAsync() {
            return newSuccessfulPromise(getConnection());
        }
    }

    /**
     * Adapts the provided {@link SynchronousRequestHandler} as a
     * {@link RequestHandler}.
     *
     * @param syncHandler
     *            The synchronous request handler to be adapted.
     * @return The adapted synchronous request handler.
     */
    public static RequestHandler asRequestHandler(final SynchronousRequestHandler syncHandler) {
        return syncHandler instanceof Describable
                ? new DescribedSyncRequestHandlerAdapter(syncHandler)
                : new SynchronousRequestHandlerAdapter(syncHandler);
    }

    /**
     * Returns a JSON object containing only the specified fields from the
     * provided JSON value. If the list of fields is empty then the value is
     * returned unchanged.
     * <p>
     * <b>NOTE:</b> this method only performs a shallow copy of extracted
     * fields, so changes to the filtered JSON value may impact the original
     * JSON value, and vice-versa.
     *
     * @param resource
     *            The JSON value whose fields are to be filtered.
     * @param fields
     *            The list of fields to be extracted.
     * @return The filtered JSON value.
     */
    public static JsonValue filterResource(final JsonValue resource,
            final Collection<JsonPointer> fields) {
        if (fields.isEmpty() || resource.isNull() || resource.size() == 0) {
            return resource;
        } else {
            final Map<String, Object> filtered = new LinkedHashMap<>(fields.size());
            for (final JsonPointer field : fields) {
                if (field.isEmpty()) {
                    // Special case - copy resource fields (assumes Map).
                    filtered.putAll(resource.asMap());
                } else {
                    // FIXME: what should we do if the field refers to an array element?
                    final JsonValue value = resource.get(field);
                    if (value != null) {
                        final String key = field.leaf();
                        filtered.put(key, value.getObject());
                    }
                }
            }
            return new JsonValue(filtered);
        }
    }

    /**
     * Returns a JSON object containing only the specified fields from the
     * provided resource. If the list of fields is empty then the resource is
     * returned unchanged.
     * <p>
     * <b>NOTE:</b> this method only performs a shallow copy of extracted
     * fields, so changes to the filtered resource may impact the original
     * resource, and vice-versa.
     *
     * @param resource
     *            The resource whose fields are to be filtered.
     * @param fields
     *            The list of fields to be extracted.
     * @return The filtered resource.
     */
    public static ResourceResponse filterResource(final ResourceResponse resource,
            final Collection<JsonPointer> fields) {
        final JsonValue unfiltered = resource.getContent();
        final Collection<JsonPointer> filterFields = resource.hasFields()
                ? resource.getFields()
                : fields;
        final JsonValue filtered = filterResource(unfiltered, filterFields);
        if (filtered == unfiltered) {
            return resource; // Unchanged.
        } else {
            return newResourceResponse(resource.getId(), resource.getRevision(), filtered);
        }
    }

    /**
     * Creates a new connection to a {@link RequestHandler}.
     *
     * @param handler
     *            The request handler to which client requests should be
     *            forwarded.
     * @return The new internal connection.
     * @throws NullPointerException
     *             If {@code handler} was {@code null}.
     */
    public static Connection newInternalConnection(final RequestHandler handler) {
        return new InternalConnection(handler);
    }

    /**
     * Creates a new connection factory which binds internal client connections
     * to {@link RequestHandler}s.
     *
     * @param handler
     *            The request handler to which client requests should be
     *            forwarded.
     * @return The new internal connection factory.
     * @throws NullPointerException
     *             If {@code handler} was {@code null}.
     */
    public static ConnectionFactory newInternalConnectionFactory(final RequestHandler handler) {
        return new InternalConnectionFactory(handler);
    }

    /**
     * Creates a new {@link RequestHandler} backed by the supplied provider. The provider can be an instance of an
     * interface resource handler, and annotated resource handler or an annotated request handler. The type of the
     * provider will be determined from the {@code org.forgerock.api.annotations.RequestHandler#variant}
     * annotation property, or from the type of interface implemented.
     * <p>
     * Sub-paths that are declared using the {@code org.forgerock.api.annotations.Path} annotation will also be routed
     * through the returned handler.
     * <p>
     * This method uses the same logic as {@link #newCollection(Object)}, {@link #newSingleton(Object)} and
     * {@link #newAnnotatedRequestHandler(Object)} to create the underlying {@link RequestHandler}s.
     * @param provider The provider instance.
     * @return The constructed handler.
     */
    public static RequestHandler newHandler(Object provider) {
        Router router;
        if (provider instanceof Describable) {
            router = new Router();
            addHandlers(provider, router, "", null);
        } else {
            final DescribableResourceHandler descriptorProvider = new DescribableResourceHandler();
            router = new Router() {
                @Override
                protected ApiDescription buildApi(ApiProducer<ApiDescription> producer) {
                    return descriptorProvider.api(producer);
                }
            };
            descriptorProvider.describes(addHandlers(provider, router, "",
                    descriptorProvider.getDefinitionDescriptions()));
        }
        Path path = provider.getClass().getAnnotation(Path.class);
        if (path != null) {
            Router pathRouter = new Router();
            pathRouter.addRoute(requestUriMatcher(STARTS_WITH, path.value()), router);
            router = pathRouter;
        }
        return router;
    }

    private static Resource addHandlers(Object provider, Router router, String basePath,
            ApiDescription definitions, Parameter... pathParameters) {
        HandlerVariant variant = deduceHandlerVariant(provider);
        Parameter[] nextPathParameters = pathParameters;
        switch (variant) {
        case SINGLETON_RESOURCE:
            addSingletonHandlerToRouter(provider, router, basePath);
            break;
        case COLLECTION_RESOURCE:
            nextPathParameters = new Parameter[pathParameters.length + 1];
            System.arraycopy(pathParameters, 0, nextPathParameters, 0, pathParameters.length);
            nextPathParameters[pathParameters.length] = addCollectionHandlersToRouter(provider, router, basePath);
            String pathParameter = nextPathParameters[pathParameters.length].getName();
            basePath = (basePath.isEmpty() ? "" : basePath + "/") + "{" + pathParameter + "}";
            break;
        case REQUEST_HANDLER:
            addRequestHandlerToRouter(provider, router, basePath);
            break;
        default:
            return null;
        }

        SubResources.Builder subResourcesBuilder = null;
        for (Method m : provider.getClass().getMethods()) {
            Path subpathAnnotation = m.getAnnotation(Path.class);
            if (subpathAnnotation != null) {
                if (subResourcesBuilder == null) {
                    subResourcesBuilder = subresources();
                }
                String subpath = subpathAnnotation.value().replaceAll("^/", "");
                try {
                    Resource subResource = addHandlers(m.invoke(provider), router,
                            basePath.isEmpty() ? subpath : basePath + "/" + subpath, definitions, nextPathParameters);
                    if (subResource != null) {
                        subResourcesBuilder.put(subpath, subResource);
                    }
                } catch (IllegalAccessException | InvocationTargetException e) {
                    throw new IllegalArgumentException("Could not construct handler tree", e);
                }
            }
        }
        SubResources subResources = subResourcesBuilder == null ? null : subResourcesBuilder.build();
        return makeDescriptor(provider, variant, subResources, definitions, pathParameters);
    }

    private static HandlerVariant deduceHandlerVariant(Object provider) {
        Class<?> type = provider.getClass();
        org.forgerock.api.annotations.RequestHandler handler =
                provider.getClass().getAnnotation(org.forgerock.api.annotations.RequestHandler.class);
        if (handler != null || provider instanceof RequestHandler) {
            return HandlerVariant.REQUEST_HANDLER;
        } else if (type.getAnnotation(SingletonProvider.class) != null
                || provider instanceof SingletonResourceProvider) {
            return HandlerVariant.SINGLETON_RESOURCE;
        } else if (type.getAnnotation(CollectionProvider.class) != null
                || provider instanceof CollectionResourceProvider) {
            return HandlerVariant.COLLECTION_RESOURCE;
        }
        throw new IllegalArgumentException("Cannot deduce provider variant" + provider.getClass());
    }

    private static void addRequestHandlerToRouter(Object provider, Router router, String basePath) {
        router.addRoute(requestUriMatcher(STARTS_WITH, basePath), new AnnotatedRequestHandler(provider));
    }

    private static Parameter addCollectionHandlersToRouter(Object provider, Router router, String basePath) {
        boolean fromInterface = provider instanceof CollectionResourceProvider;
        // Create a route for the collection.
        final RequestHandler collectionHandler = fromInterface
                ? new InterfaceCollectionHandler((CollectionResourceProvider) provider)
                : new AnnotatedCollectionHandler(provider);
        router.addRoute(requestUriMatcher(EQUALS, basePath), collectionHandler);

        // Create a route for the instances within the collection.
        RequestHandler instanceHandler = fromInterface
                ? new InterfaceCollectionInstance((CollectionResourceProvider) provider)
                : new AnnotationCollectionInstance(provider);
        Class<?> providerClass = provider.getClass();
        CollectionProvider providerAnnotation = providerClass.getAnnotation(CollectionProvider.class);
        Parameter pathParameter;
        if (providerAnnotation != null) {
            pathParameter = Parameter.fromAnnotation(providerClass, providerAnnotation.pathParam());
        } else {
            pathParameter = parameter().name("id").type("string").source(ParameterSource.PATH).required(true).build();
        }
        String pathParam = pathParameter.getName();
        instanceHandler = new FilterChain(instanceHandler, new CollectionInstanceIdContextFilter(pathParam));
        router.addRoute(requestUriMatcher(EQUALS, (basePath.isEmpty() ? "" : basePath + "/") + "{" + pathParam + "}"),
                instanceHandler);
        return pathParameter;
    }

    private static void addSingletonHandlerToRouter(Object provider, Router router, String basePath) {
        router.addRoute(requestUriMatcher(EQUALS, basePath),
                provider instanceof SingletonResourceProvider
                        ? new InterfaceSingletonHandler((SingletonResourceProvider) provider)
                        : new AnnotatedSingletonHandler(provider));
    }

    private static Resource makeDescriptor(Object provider, HandlerVariant variant, SubResources subResources,
            ApiDescription definitions, Parameter[] pathParameters) {
        if (provider instanceof Describable) {
            return null;
        }
        Class<?> type = provider.getClass();
        switch (variant) {
        case SINGLETON_RESOURCE:
            return Resource.fromAnnotatedType(type, SINGLETON_RESOURCE, subResources, definitions, pathParameters);
        case COLLECTION_RESOURCE:
            final Items items = Items.fromAnnotatedType(type, definitions, subResources);
            return Resource.fromAnnotatedType(type, COLLECTION_RESOURCE_COLLECTION, items,
                    definitions, pathParameters);
        case REQUEST_HANDLER:
            return Resource.fromAnnotatedType(type, REQUEST_HANDLER, subResources, definitions, pathParameters);
        default:
            return null;
        }
    }

    /**
     * Returns a new request handler which will forward requests on to the
     * provided collection resource provider. Incoming requests which are not
     * appropriate for a resource collection or resource instance will result in
     * a bad request error being returned to the client.
     *
     * @param provider
     *            The collection resource provider. Either an implementation of {@link CollectionResourceProvider} or
     *            a POJO annotated with annotations from {@link org.forgerock.json.resource.annotations}.
     * @return A new request handler which will forward requests on to the
     *         provided collection resource provider.
     * @deprecated Use {@link #newHandler(Object)} instead.
     */
    @Deprecated
    public static RequestHandler newCollection(final Object provider) {
        return newHandler(provider);
    }

    /**
     * Returns a new request handler which will forward requests on to the
     * provided singleton resource provider. Incoming requests which are not
     * appropriate for a singleton resource (e.g. query) will result in a bad
     * request error being returned to the client.
     *
     * @param provider
     *            The singleton resource provider. Either an implementation of {@link SingletonResourceProvider} or
     *            a POJO annotated with annotations from {@link org.forgerock.json.resource.annotations}.
     * @return A new request handler which will forward requests on to the
     *         provided singleton resource provider.
     * @deprecated Use {@link #newHandler(Object)} instead.
     */
    @Deprecated
    public static RequestHandler newSingleton(final Object provider) {
        return newHandler(provider);
    }

    /**
     * Returns a new request handler which will forward requests on to the
     * provided annotated request handler.
     *
     * @param provider
     *            The POJO annotated with annotations from {@link org.forgerock.json.resource.annotations}.
     * @return A new request handler which will forward requests on to the provided annotated POJO.
     * @deprecated Use {@link #newHandler(Object)} instead.
     */
    @Deprecated
    public static RequestHandler newAnnotatedRequestHandler(final Object provider) {
        Reject.ifTrue(provider instanceof RequestHandler,
                "Refusing to create an annotated request handler using a provider that implements RequestHandler. "
                        + "Use the RequestHandler implementation directly instead");
        return newHandler(provider);
    }

    /**
     * Returns an uncloseable view of the provided connection. Attempts to call
     * {@link Connection#close()} will be ignored.
     *
     * @param connection
     *            The connection whose {@code close} method is to be disabled.
     * @return An uncloseable view of the provided connection.
     */
    public static Connection uncloseable(final Connection connection) {
        return new AbstractConnectionWrapper<Connection>(connection) {
            @Override
            public void close() {
                // Do nothing.
            }
        };
    }

    /**
     * Returns an uncloseable view of the provided connection factory. Attempts
     * to call {@link ConnectionFactory#close()} will be ignored.
     *
     * @param factory
     *            The connection factory whose {@code close} method is to be
     *            disabled.
     * @return An uncloseable view of the provided connection factory.
     */
    public static ConnectionFactory uncloseable(final ConnectionFactory factory) {
        return new ConnectionFactory() {

            @Override
            public Promise<Connection, ResourceException> getConnectionAsync() {
                return factory.getConnectionAsync();
            }

            @Override
            public Connection getConnection() throws ResourceException {
                return factory.getConnection();
            }

            @Override
            public void close() {
                // Do nothing.
            }
        };
    }

    static String idOf(final Context context) {
        String idFieldName = context.asContext(IdFieldContext.class).getIdFieldName();
        return context.asContext(UriRouterContext.class).getUriTemplateVariables().get(idFieldName);
    }

    static ResourceException newBadRequestException(final String fs, final Object... args) {
        final String msg = String.format(fs, args);
        return new BadRequestException(msg);
    }

    private static <V> Promise<V, ResourceException> newSuccessfulPromise(V result) {
        return newResultPromise(result);
    }

    // Strips off the unwanted leaf routing context which was added when routing
    // requests to a collection.
    static Context parentOf(Context context) {
        if (context instanceof IdFieldContext) {
            context = context.getParent();
        }
        assert context instanceof UriRouterContext;
        return context.getParent();
    }

    private static class IdFieldContext extends AbstractContext {

        private static final String ID_FIELD_NAME = "IdFieldName";

        protected IdFieldContext(Context parent, String idFieldName) {
            super(parent, "IdField");
            this.data.put(ID_FIELD_NAME, idFieldName);
        }

        protected IdFieldContext(JsonValue data, ClassLoader loader) {
            super(data, loader);
        }

        String getIdFieldName() {
            return this.data.get(ID_FIELD_NAME).asString();
        }
    }

    private static final class CollectionInstanceIdContextFilter implements Filter {

        private final String idFieldName;

        private CollectionInstanceIdContextFilter(String idFieldName) {
            this.idFieldName = idFieldName;
        }

        @Override
        public Promise<ActionResponse, ResourceException> filterAction(Context context, ActionRequest request,
                RequestHandler next) {
            return next.handleAction(new IdFieldContext(context, idFieldName), request);
        }

        @Override
        public Promise<ResourceResponse, ResourceException> filterCreate(Context context, CreateRequest request,
                RequestHandler next) {
            return next.handleCreate(new IdFieldContext(context, idFieldName), request);
        }

        @Override
        public Promise<ResourceResponse, ResourceException> filterDelete(Context context, DeleteRequest request,
                RequestHandler next) {
            return next.handleDelete(new IdFieldContext(context, idFieldName), request);
        }

        @Override
        public Promise<ResourceResponse, ResourceException> filterPatch(Context context, PatchRequest request,
                RequestHandler next) {
            return next.handlePatch(new IdFieldContext(context, idFieldName), request);
        }

        @Override
        public Promise<QueryResponse, ResourceException> filterQuery(Context context, QueryRequest request,
                QueryResourceHandler handler, RequestHandler next) {
            return next.handleQuery(new IdFieldContext(context, idFieldName), request, handler);
        }

        @Override
        public Promise<ResourceResponse, ResourceException> filterRead(Context context, ReadRequest request,
                RequestHandler next) {
            return next.handleRead(new IdFieldContext(context, idFieldName), request);
        }

        @Override
        public Promise<ResourceResponse, ResourceException> filterUpdate(Context context, UpdateRequest request,
                RequestHandler next) {
            return next.handleUpdate(new IdFieldContext(context, idFieldName), request);
        }
    }

    /**
     * Enumeration of the possible CREST handler variants.
     */
    enum HandlerVariant {
        /** A singleton resource handler. */
        SINGLETON_RESOURCE,
        /** A collection resource handler. */
        COLLECTION_RESOURCE,
        /** A plain request handler. */
        REQUEST_HANDLER
    }

    // Prevent instantiation.
    private Resources() {
        // Nothing to do.
    }
}