/*
 * 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.enums.ParameterSource.*;
import static org.forgerock.api.util.ValidationUtil.*;
import static org.forgerock.util.Reject.*;

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

import com.fasterxml.jackson.annotation.JsonIgnore;
import com.fasterxml.jackson.annotation.JsonInclude;
import com.fasterxml.jackson.annotation.JsonProperty;
import com.fasterxml.jackson.databind.annotation.JsonDeserialize;
import org.forgerock.api.ApiValidationException;
import org.forgerock.api.annotations.Actions;
import org.forgerock.api.annotations.CollectionProvider;
import org.forgerock.util.i18n.LocalizableString;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

/**
 * Class that represents the Items type in API descriptor.
 */
@JsonDeserialize(builder = Items.Builder.class)
@JsonInclude(JsonInclude.Include.NON_NULL)
public final class Items {

    private static final Logger LOGGER = LoggerFactory.getLogger(Items.class);

    private final Create create;
    private final Read read;
    private final Update update;
    private final Delete delete;
    private final Patch patch;
    private final Action[] actions;
    private final SubResources subresources;
    private final Parameter pathParameter;

    private Items(Builder builder) {
        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.pathParameter = builder.pathParameter;
        this.actions = builder.actions.toArray(new Action[builder.actions.size()]);

        if (create == null && read == null && update == null && delete == null && patch == null && isEmpty(actions)) {
            throw new ApiValidationException("At least one operation required");
        }
    }

    /**
     * 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.length == 0 ? null : actions;
    }

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

    /**
     * Get the path parameter.
     *
     * @return The path parameter.
     */
    public Parameter getPathParameter() {
        return pathParameter;
    }

    @Override
    public boolean equals(Object o) {
        if (this == o) {
            return true;
        }
        if (o == null || getClass() != o.getClass()) {
            return false;
        }
        Items items = (Items) o;
        return Objects.equals(create, items.create)
                && Objects.equals(read, items.read)
                && Objects.equals(update, items.update)
                && Objects.equals(delete, items.delete)
                && Objects.equals(patch, items.patch)
                && Arrays.equals(actions, items.actions)
                && Objects.equals(subresources, items.subresources)
                && Objects.equals(pathParameter, items.pathParameter);
    }

    @Override
    public int hashCode() {
        return Objects.hash(create, read, update, delete, patch, actions, pathParameter, subresources);
    }

    /**
     * Builds a {@link Resource} from this {@code Items} instance.
     *
     * @param mvccSupported {@code true} when MVCC is supported and {@code false} otherwise
     * @param resourceSchema Resource-{@link Schema} or {@code null}
     * @param title The resource title.
     * @param description The resource description.
     * @return New {@link Resource}
     */
    @JsonIgnore
    public Resource asResource(boolean mvccSupported, Schema resourceSchema, LocalizableString title,
            LocalizableString description) {
        final List<Action> actions =
                getActions() == null ? Collections.<Action>emptyList() : Arrays.asList(getActions());
        return Resource.resource()
                .mvccSupported(mvccSupported)
                .resourceSchema(resourceSchema)
                .title(title)
                .description(description)
                .create(getCreate())
                .read(getRead())
                .update(getUpdate())
                .delete(getDelete())
                .patch(getPatch())
                .actions(actions)
                .build();
    }

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

    /**
     * Build an {@code Items} from an annotated request handler.
     *
     * @param type The annotated type.
     * @param descriptor The root descriptor to add definitions to.
     * @param subResources The sub resources.
     * @return The built {@code Items} object.
     */
    public static Items fromAnnotatedType(Class<?> type, ApiDescription descriptor, SubResources subResources) {
        final Builder builder = items();
        final CollectionProvider provider = type.getAnnotation(CollectionProvider.class);
        if (provider == null) {
            LOGGER.info("Asked for Items for annotated type, but type does not have required RequestHandler"
                    + " annotation. No api descriptor will be available for " + type);
            return null;
        }
        builder.pathParameter(Parameter.fromAnnotation(type, provider.pathParam()));

        for (final 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) {
                builder.actions.add(Action.fromAnnotation(action, m, descriptor, type));
            }
            Actions actions = m.getAnnotation(Actions.class);
            if (actions != null && instanceMethod) {
                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, true, descriptor, type);
            }
            org.forgerock.api.annotations.Read read = m.getAnnotation(org.forgerock.api.annotations.Read.class);
            if (read != null) {
                builder.read = Read.fromAnnotation(read, descriptor, type);
            }
            org.forgerock.api.annotations.Update update =
                    m.getAnnotation(org.forgerock.api.annotations.Update.class);
            if (update != null) {
                builder.update = Update.fromAnnotation(update, descriptor, type);
            }
            org.forgerock.api.annotations.Delete delete =
                    m.getAnnotation(org.forgerock.api.annotations.Delete.class);
            if (delete != null) {
                builder.delete = Delete.fromAnnotation(delete, descriptor, type);
            }
            org.forgerock.api.annotations.Patch patch = m.getAnnotation(org.forgerock.api.annotations.Patch.class);
            if (patch != null) {
                builder.patch = Patch.fromAnnotation(patch, descriptor, type);
            }
        }

        return builder.subresources(subResources).build();
    }

    /**
     * Builder to help construct the {@code Items}.
     */
    public final static class Builder {
        private Create create;
        private Read read;
        private Update update;
        private Delete delete;
        private Patch patch;
        private SubResources subresources;
        private Parameter pathParameter = Parameter.parameter().name("id").type("string").source(PATH).required(true)
                .build();
        private final Set<Action> actions;
        private boolean built = false;

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

        /**
         * 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;
        }

        /**
         * Sets the path parameter for this resource.
         *
         * @param pathParameter The path parameter definition.
         * @return Builder
         */
        @JsonProperty("pathParameter")
        public Builder pathParameter(Parameter pathParameter) {
            checkState();
            this.pathParameter = pathParameter;
            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;
        }

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

            return new Items(this);
        }

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

    }
}