/*
 * 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.api.models;

import static org.forgerock.api.models.Reference.reference;
import static org.forgerock.api.util.ValidationUtil.isEmpty;
import static org.forgerock.util.Reject.rejectStateIfTrue;

import java.lang.reflect.Method;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.Objects;
import java.util.Set;
import java.util.TreeSet;

import org.forgerock.api.ApiValidationException;
import org.forgerock.api.annotations.Actions;
import org.forgerock.api.annotations.CollectionProvider;
import org.forgerock.api.annotations.Handler;
import org.forgerock.api.annotations.Queries;
import org.forgerock.api.annotations.RequestHandler;
import org.forgerock.api.annotations.SingletonProvider;
import org.forgerock.util.Reject;
import org.forgerock.util.i18n.LocalizableString;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import com.fasterxml.jackson.annotation.JsonInclude;
import com.fasterxml.jackson.annotation.JsonProperty;
import com.fasterxml.jackson.databind.annotation.JsonDeserialize;

/**
 * Class that represents the Resource type in API descriptor.
 * <p>
 *     {@code Resource}s may be either a reference to another {@code Resource} that will be defined elsewhere in the
 *     API Descriptor, or a described resource. If a {@link Reference} is provided, then none of the other fields may
 *     be used, and if any of the other fields are used, a reference may not be provided.
 * </p>
 */
@JsonDeserialize(builder = Resource.Builder.class)
@JsonInclude(JsonInclude.Include.NON_NULL)
public final class Resource {
    private static final Logger LOGGER = LoggerFactory.getLogger(Resource.class);
    private static final String SERVICES_REFERENCE = "#/services/%s";

    @JsonProperty("$ref")
    private final Reference reference;
    private final Schema resourceSchema;
    private final LocalizableString title;
    private final LocalizableString description;
    private final Create create;
    private final Read read;
    private final Update update;
    private final Delete delete;
    private final Patch patch;
    @JsonInclude(JsonInclude.Include.NON_EMPTY)
    private final Action[] actions;
    @JsonInclude(JsonInclude.Include.NON_EMPTY)
    private final Query[] queries;
    private final SubResources subresources;
    private final Items items;
    private final Boolean mvccSupported;
    @JsonInclude(JsonInclude.Include.NON_EMPTY)
    private final Parameter[] parameters;

    private Resource(Builder builder) {
        this.reference = builder.reference;
        this.resourceSchema = builder.resourceSchema;
        this.title = builder.title;
        this.description = builder.description;
        this.create = builder.create;
        this.read = builder.read;
        this.update = builder.update;
        this.delete = builder.delete;
        this.patch = builder.patch;
        this.subresources = builder.subresources;
        this.actions = builder.actions.toArray(new Action[builder.actions.size()]);
        this.queries = builder.queries.toArray(new Query[builder.queries.size()]);
        this.items = builder.items;
        this.mvccSupported = builder.mvccSupported;
        this.parameters = builder.parameters.toArray(new Parameter[builder.parameters.size()]);

        if ((create != null || read != null || update != null || delete != null || patch != null
                || !isEmpty(actions) || !isEmpty(queries)) && reference != null) {
            throw new ApiValidationException("Cannot have a reference as well as operations");
        }
        if (mvccSupported == null && reference == null) {
            throw new ApiValidationException("mvccSupported required for non-reference Resources");
        }
    }

    /**
     * Getter of resource schema.
     *
     * @return Resource schema
     */
    public Schema getResourceSchema() {
        return resourceSchema;
    }

    /**
     * Getter of title.
     *
     * @return Title
     */
    public LocalizableString getTitle() {
        return title;
    }

    /**
     * Getter of description.
     *
     * @return Description
     */
    public LocalizableString getDescription() {
        return description;
    }

    /**
     * Getter of Create.
     *
     * @return Create
     */
    public Create getCreate() {
        return create;
    }

    /**
     * Getter of Read.
     *
     * @return Read
     */
    public Read getRead() {
        return read;
    }

    /**
     * Getter of Update.
     *
     * @return Update
     */
    public Update getUpdate() {
        return update;
    }

    /**
     * Getter of Delete.
     *
     * @return Delete
     */
    public Delete getDelete() {
        return delete;
    }

    /**
     * Getter of Patch.
     *
     * @return Patch
     */
    public Patch getPatch() {
        return patch;
    }

    /**
     * Getter of actions.
     *
     * @return Actions
     */
    public Action[] getActions() {
        return actions;
    }

    /**
     * Getter of queries.
     *
     * @return Queries
     */
    public Query[] getQueries() {
        return queries;
    }

    /**
     * Getter of sub-resources.
     *
     * @return Sub-resources
     */
    public SubResources getSubresources() {
        return subresources;
    }

    /**
     * Gets the reference.
     * @return The reference.
     */
    public Reference getReference() {
        return reference;
    }

    /**
     * Getter of items.
     *
     * @return Items
     */
    public Items getItems() {
        return items;
    }

    /**
     * Informs if MVCC is supported.
     *
     * @return {@code true} if MVCC is supported and {@code false} otherwise
     */
    public Boolean isMvccSupported() {
        return mvccSupported;
    }

    /**
     * Getter of the parameters array.
     *
     * @return Parameters
     */
    public Parameter[] getParameters() {
        return parameters;
    }

    @Override
    public boolean equals(Object o) {
        if (this == o) {
            return true;
        }
        if (o == null || getClass() != o.getClass()) {
            return false;
        }
        Resource resource = (Resource) o;
        return Objects.equals(reference, resource.reference)
                && Objects.equals(resourceSchema, resource.resourceSchema)
                && Objects.equals(title, resource.title)
                && Objects.equals(description, resource.description)
                && Objects.equals(create, resource.create)
                && Objects.equals(read, resource.read)
                && Objects.equals(update, resource.update)
                && Objects.equals(delete, resource.delete)
                && Objects.equals(patch, resource.patch)
                && Arrays.equals(actions, resource.actions)
                && Arrays.equals(queries, resource.queries)
                && Objects.equals(subresources, resource.subresources)
                && Objects.equals(items, resource.items)
                && Objects.equals(mvccSupported, resource.mvccSupported)
                && Arrays.equals(parameters, resource.parameters);
    }

    @Override
    public int hashCode() {
        return Objects.hash(reference, resourceSchema, title, description, create, read, update, delete, patch, actions,
                queries, subresources, items, mvccSupported, parameters);
    }

    /**
     * Create a new Builder for Resoruce.
     *
     * @return Builder
     */
    public static Builder resource() {
        return new Builder();
    }

    /**
     * Build a {@code Resource} from an annotated request handler.
     * @param type The annotated type.
     * @param variant The annotated type variant.
     * @param descriptor The root descriptor to add definitions to.
     * @return The built {@code Resource} object.
     */
    public static Resource fromAnnotatedType(Class<?> type, AnnotatedTypeVariant variant, ApiDescription descriptor) {
        return fromAnnotatedType(type, variant, null, null, descriptor);
    }

    /**
     * Build a {@code Resource} from an annotated request handler.
     * @param type The annotated type.
     * @param variant The annotated type variant.
     * @param subResources The sub resources object to be included, if any sub-resources exist, or null.
     * @param descriptor The root descriptor to add definitions to.
     * @param extraParameters Extra parameters not from the resource annotation.
     * @return The built {@code Resource} object.
     */
    public static Resource fromAnnotatedType(Class<?> type, AnnotatedTypeVariant variant, SubResources subResources,
            ApiDescription descriptor, Parameter... extraParameters) {
        return fromAnnotatedType(type, variant, subResources, null, descriptor, extraParameters);
    }

    /**
     * Build a {@code Resource} from an annotated request handler.
     * @param type The annotated type.
     * @param variant The annotated type variant.
     * @param items The items definition for a collection variant, or null.
     * @param descriptor The root descriptor to add definitions to.
     * @param extraParameters Extra parameters not from the resource annotation.
     * @return The built {@code Resource} object.
     */
    public static Resource fromAnnotatedType(Class<?> type, AnnotatedTypeVariant variant,
            Items items, ApiDescription descriptor, Parameter... extraParameters) {
        return fromAnnotatedType(type, variant, null, items, descriptor, extraParameters);
    }

    private static Resource fromAnnotatedType(Class<?> type, AnnotatedTypeVariant variant,
            SubResources subResources, Items items, ApiDescription descriptor, Parameter... extraParameters) {
        Builder builder = resource();
        Handler handler = findHandlerAnnotation(variant, type);
        if (handler == null) {
            return null;
        }
        boolean foundCrudpq = false;
        for (Method m : type.getMethods()) {
            boolean instanceMethod = Arrays.asList(m.getParameterTypes()).indexOf(String.class) > -1;
            org.forgerock.api.annotations.Action action = m.getAnnotation(org.forgerock.api.annotations.Action.class);
            if (action != null && instanceMethod == variant.actionRequiresId) {
                builder.actions.add(Action.fromAnnotation(action, m, descriptor, type));
            }
            Actions actions = m.getAnnotation(Actions.class);
            if (actions != null && instanceMethod == variant.actionRequiresId) {
                for (org.forgerock.api.annotations.Action a : actions.value()) {
                    builder.actions.add(Action.fromAnnotation(a, null, descriptor, type));
                }
            }
            org.forgerock.api.annotations.Create create = m.getAnnotation(org.forgerock.api.annotations.Create.class);
            if (create != null) {
                builder.create = Create.fromAnnotation(create, variant.instanceCreate, descriptor, type);
                foundCrudpq = true;
            }
            if (variant.rudpOperations) {
                org.forgerock.api.annotations.Read read = m.getAnnotation(org.forgerock.api.annotations.Read.class);
                if (read != null) {
                    builder.read = Read.fromAnnotation(read, descriptor, type);
                    foundCrudpq = true;
                }
                org.forgerock.api.annotations.Update update =
                        m.getAnnotation(org.forgerock.api.annotations.Update.class);
                if (update != null) {
                    builder.update = Update.fromAnnotation(update, descriptor, type);
                    foundCrudpq = true;
                }
                org.forgerock.api.annotations.Delete delete =
                        m.getAnnotation(org.forgerock.api.annotations.Delete.class);
                if (delete != null) {
                    builder.delete = Delete.fromAnnotation(delete, descriptor, type);
                    foundCrudpq = true;
                }
                org.forgerock.api.annotations.Patch patch = m.getAnnotation(org.forgerock.api.annotations.Patch.class);
                if (patch != null) {
                    builder.patch = Patch.fromAnnotation(patch, descriptor, type);
                    foundCrudpq = true;
                }
            }
            if (variant.queryOperations) {
                org.forgerock.api.annotations.Query query = m.getAnnotation(org.forgerock.api.annotations.Query.class);
                if (query != null) {
                    builder.queries.add(Query.fromAnnotation(query, m, descriptor, type));
                    foundCrudpq = true;
                }
                Queries queries = m.getAnnotation(Queries.class);
                if (queries != null) {
                    for (org.forgerock.api.annotations.Query q : queries.value()) {
                        builder.queries.add(Query.fromAnnotation(q, null, descriptor, type));
                        foundCrudpq = true;
                    }
                }
            }
        }
        Schema resourceSchema = Schema.fromAnnotation(handler.resourceSchema(), descriptor, type);
        if (foundCrudpq && resourceSchema == null) {
            throw new IllegalArgumentException("CRUDPQ operation(s) defined, but no resource schema declared");
        }

        for (org.forgerock.api.annotations.Parameter parameter : handler.parameters()) {
            builder.parameter(Parameter.fromAnnotation(type, parameter));
        }
        for (Parameter param : extraParameters) {
            builder.parameter(param);
        }

        Resource resource = builder.resourceSchema(resourceSchema)
                .mvccSupported(handler.mvccSupported())
                .title(new LocalizableString(handler.title(), type))
                .description(new LocalizableString(handler.description(), type))
                .subresources(subResources)
                .items(items)
                .build();

        if (!handler.id().isEmpty()) {
            descriptor.addService(handler.id(), resource);
            Reference reference = reference().value(String.format(SERVICES_REFERENCE, handler.id())).build();
            resource = resource().reference(reference).build();
        }
        return resource;
    }

    private static Handler findHandlerAnnotation(AnnotatedTypeVariant variant, Class<?> type) {
        switch (variant) {
        case SINGLETON_RESOURCE:
            if (type.getAnnotation(SingletonProvider.class) != null) {
                return type.getAnnotation(SingletonProvider.class).value();
            }
            break;
        case REQUEST_HANDLER:
            if (type.getAnnotation(RequestHandler.class) != null) {
                return type.getAnnotation(RequestHandler.class).value();
            }
            break;
        default:
            if (type.getAnnotation(CollectionProvider.class) != null) {
                return type.getAnnotation(CollectionProvider.class).details();
            }
        }
        LOGGER.info("Asked for Resource for annotated type, but type does not have required RequestHandler"
                + " annotation. No api descriptor will be available for " + type);
        return null;
    }

    /**
     * The variant of the annotated type. Allows the annotation processing to make assumptions about what type of
     * operations are expected from this context of the type.
     */
    public enum AnnotatedTypeVariant {
        /** A singleton resource handler. (expect RUDPA operations). */
        SINGLETON_RESOURCE(true, true, false, false),
        /** A collection resource handler, collection endpoint (expect CAQ opererations). */
        COLLECTION_RESOURCE_COLLECTION(false, false, false, true),
        /** A collection resource handler, instance endpoint (expect CRUDPA operations). */
        COLLECTION_RESOURCE_INSTANCE(true, true, true, false),
        /** A plain request handler (expects all operations). */
        REQUEST_HANDLER(false, true, false, true);

        private final boolean instanceCreate;
        private final boolean rudpOperations;
        private final boolean actionRequiresId;
        private final boolean queryOperations;

        AnnotatedTypeVariant(boolean instanceCreate, boolean rudpOperations, boolean actionRequiresId,
                boolean queryOperations) {
            this.instanceCreate = instanceCreate;
            this.rudpOperations = rudpOperations;
            this.actionRequiresId = actionRequiresId;
            this.queryOperations = queryOperations;
        }
    }

    /**
     * Builder to help construct the Resource.
     */
    public final static class Builder {
        private Schema resourceSchema;
        private LocalizableString title;
        private LocalizableString description;
        private Create create;
        private Read read;
        private Update update;
        private Delete delete;
        private Patch patch;
        private SubResources subresources;
        private final Set<Action> actions;
        private final Set<Query> queries;
        private Items items;
        private Boolean mvccSupported;
        private Reference reference;
        private final List<Parameter> parameters;
        private boolean built = false;

        /**
         * Private default constructor.
         */
        protected Builder() {
            actions = new TreeSet<>();
            queries = new TreeSet<>();
            parameters = new ArrayList<>();
        }

        /**
         * Set a reference.
         * @param reference The reference.
         * @return This builder.
         */
        @JsonProperty("$ref")
        public Builder reference(Reference reference) {
            checkState();
            this.reference = reference;
            return this;
        }

        /**
         * Set the resource schema.
         *
         * @param resourceSchema The schema of the resource for this path.
         * Required when any of create, read, update, delete, patch are supported
         * @return Builder
         */
        @JsonProperty("resourceSchema")
        public Builder resourceSchema(Schema resourceSchema) {
            checkState();
            this.resourceSchema = resourceSchema;
            return this;
        }

        /**
         * Set the title.
         *
         * @param title Title of the endpoint
         * @return Builder
         */
        public Builder title(LocalizableString title) {
            this.title = title;
            return this;
        }

        /**
         * Set the title.
         *
         * @param title Title of the endpoint
         * @return Builder
         */
        @JsonProperty("title")
        public Builder title(String title) {
            return title(new LocalizableString(title));
        }

        /**
         * Set the description.
         *
         * @param description A description of the endpoint
         * @return Builder
         */
        public Builder description(LocalizableString description) {
            checkState();
            this.description = description;
            return this;
        }

        /**
         * Set the description.
         *
         * @param description A description of the endpoint
         * @return Builder
         */
        @JsonProperty("description")
        public Builder description(String description) {
            checkState();
            return description(new LocalizableString(description));
        }

        /**
         * Set create.
         *
         * @param create The create operation description, if supported
         * @return Builder
         */
        @JsonProperty("create")
        public Builder create(Create create) {
            checkState();
            this.create = create;
            return this;
        }

        /**
         * Set Read.
         *
         * @param read The read operation description, if supported
         * @return Builder
         */
        @JsonProperty("read")
        public Builder read(Read read) {
            checkState();
            this.read = read;
            return this;
        }

        /**
         * Set Update.
         *
         * @param update The update operation description, if supported
         * @return Builder
         */
        @JsonProperty("update")
        public Builder update(Update update) {
            checkState();
            this.update = update;
            return this;
        }

        /**
         * Set Delete.
         *
         * @param delete The delete operation description, if supported
         * @return Builder
         */
        @JsonProperty("delete")
        public Builder delete(Delete delete) {
            checkState();
            this.delete = delete;
            return this;
        }

        /**
         * Set Patch.
         *
         * @param patch The patch operation description, if supported
         * @return Builder
         */
        @JsonProperty("patch")
        public Builder patch(Patch patch) {
            checkState();
            this.patch = patch;
            return this;
        }

        /**
         * Set Actions.
         *
         * @param actions The list of action operation descriptions, if supported
         * @return Builder
         */
        @JsonProperty("actions")
        public Builder actions(List<Action> actions) {
            checkState();
            this.actions.addAll(actions);
            return this;
        }

        /**
         * Adds one Action to the list of Actions.
         *
         * @param action Action operation description to be added to the list
         * @return Builder
         */
        public Builder action(Action action) {
            checkState();
            this.actions.add(action);
            return this;
        }

        /**
         * Set Queries.
         *
         * @param queries The list or query operation descriptions, if supported
         * @return Builder
         */
        @JsonProperty("queries")
        public Builder queries(List<Query> queries) {
            checkState();
            this.queries.addAll(queries);
            return this;
        }

        /**
         * Adds one Query to the list of queries.
         *
         * @param query Query operation description to be added to the list
         * @return Builder
         */
        public Builder query(Query query) {
            checkState();
            this.queries.add(query);
            return this;
        }

        /**
         * Sets the sub-resources for this resource.
         *
         * @param subresources The sub-reosurces definition.
         * @return Builder
         */
        @JsonProperty("subresources")
        public Builder subresources(SubResources subresources) {
            checkState();
            this.subresources = subresources;
            return this;
        }

        /**
         * Allocates the operations given in the parameter by their type.
         *
         * @param operations One or more Operations
         * @return Builder
         */
        @JsonProperty("operations")
        public Builder operations(Operation... operations) {
            checkState();
            Reject.ifNull(operations);
            for (Operation operation : operations) {
                operation.allocateToResource(this);
            }
            return this;
        }

        /**
         * Setter for MVCC-supported flag.
         *
         * @param mvccSupported Whether this resource supports MVCC
         * @return Builder
         */
        @JsonProperty("mvccSupported")
        public Builder mvccSupported(Boolean mvccSupported) {
            checkState();
            this.mvccSupported = mvccSupported;
            return this;
        }

        /**
         * Adds items-resource.
         *
         * @param items The definition of the collection items
         * @return Builder
         */
        @JsonProperty("items")
        public Builder items(Items items) {
            checkState();
            this.items = items;
            return this;
        }

        /**
         * Set multiple supported parameters.
         *
         * @param parameters Extra parameters supported by the resource
         * @return Builder
         */
        @JsonProperty("parameters")
        public Builder parameters(List<Parameter> parameters) {
            checkState();
            this.parameters.addAll(parameters);
            return this;
        }

        /**
         * Sets a single supported parameter.
         *
         * @param parameter Extra parameter supported by the resource
         * @return Builder
         */
        public Builder parameter(Parameter parameter) {
            this.parameters.add(parameter);
            return this;
        }

        /**
         * Construct a new instance of Resource.
         *
         * @return Resource instance
         */
        public Resource build() {
            checkState();
            this.built = true;
            if (create == null && read == null && update == null && delete == null && patch == null
                    && actions.isEmpty() && queries.isEmpty() && reference == null && items == null
                    && subresources == null) {
                return null;
            }

            return new Resource(this);
        }

        private void checkState() {
            rejectStateIfTrue(built, "Already built Resource");
        }

    }
}