/*
 * Licensed to the Apache Software Foundation (ASF) under one or more
 * contributor license agreements.  See the NOTICE file distributed with
 * this work for additional information regarding copyright ownership.
 * The ASF licenses this file to You under the Apache License, Version 2.0
 * (the "License"); you may not use this file except in compliance with
 * the License.  You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

package org.apache.nifi.components.state;

import java.io.IOException;
import java.util.Map;

import org.apache.nifi.components.ConfigurableComponent;

/**
 * <p>
 * Provides a mechanism by which components can store and retrieve state. Depending on the Provider, the state
 * may be stored locally, or it may be stored on a remote resource.
 * </p>
 *
 * <p>
 * Which implementation should be used for local and clustered state is configured in the NiFi properties file.
 * It is therefore possible to provide custom implementations of this interface. Note, however, that this interface
 * is new as of version 0.5.0 of Apache NiFi and may not be considered "stable" as of yet. Therefore, it is subject
 * to change without notice, so providing custom implementations is cautioned against until the API becomes more stable.
 * </p>
 *
 * @since 0.5.0
 */
public interface StateProvider extends ConfigurableComponent {

    /**
     * Initializes the StateProvider so that it is capable of being used. This method will be called
     * once before any of the other methods are called and will not be called again until the {@link #shutdown()}
     * method has been called
     *
     * @param context the initialization context that can be used to prepare the state provider for use
     */
    void initialize(StateProviderInitializationContext context) throws IOException;

    /**
     * Shuts down the StateProvider and cleans up any resources held by it. Once this method has returned, the
     * StateProvider may be initialized once again via the {@link #initialize(StateProviderInitializationContext)} method.
     */
    void shutdown();

    /**
     * Updates the value of the component's state, setting the new value to the
     * given state
     *
     * @param state the value to change the state to
     * @param componentId the id of the component for which state is being set
     *
     * @throws IOException if unable to communicate with the underlying storage mechanism
     */
    void setState(Map<String, String> state, String componentId) throws IOException;


    /**
     * Returns the currently configured state for the component. The returned StateMap will never be null.
     * The version of the StateMap will be -1 and the state will contain no key/value pairs if the state has never been set.
     *
     * @param componentId the id of the component for which state is to be retrieved
     * @return the currently configured value for the component's state
     *
     * @throws IOException if unable to communicate with the underlying storage mechanism
     */
    StateMap getState(String componentId) throws IOException;


    /**
     * Updates the value of the component's state to the new value if and only if the value currently
     * is the same as the given oldValue.
     *
     * @param oldValue the old value to compare against
     * @param newValue the new value to use if and only if the state's value is the same as the given oldValue
     * @param componentId the id of the component for which state is being retrieved
     * @return <code>true</code> if the state was updated to the new value, <code>false</code> if the state's value was not
     *         equal to oldValue
     *
     * @throws IOException if unable to communicate with the underlying storage mechanism
     */
    boolean replace(StateMap oldValue, Map<String, String> newValue, String componentId) throws IOException;

    /**
     * Removes all values from the component's state that is stored using the given scope
     *
     * @param componentId the id of the component for which state is being cleared
     *
     * @throws IOException if unable to communicate with the underlying storage mechanism
     */
    void clear(String componentId) throws IOException;

    /**
     * This method is called whenever a component is removed from the NiFi instance. This allows the State Provider to
     * perform tasks when a component is removed in order to clean up resources that may be associated with that component
     *
     * @param componentId the ID of the component that was added to the NiFi instance
     * @throws IOException if unable to perform the necessary cleanup
     */
    void onComponentRemoved(String componentId) throws IOException;

    /**
     * Notifies the state provider that it should begin servicing requests to store and retrieve state
     */
    void enable();

    /**
     * Notifies the state provider that it should stop servicing requests to store and retrieve state and instead throw a ProviderDisabledException if any request is made to do so
     */
    void disable();

    /**
     * @return <code>true</code> if the provider is enabled, <code>false</code> otherwise.
     */
    boolean isEnabled();

    /**
     * Provides a listing of {@link Scope}s supported by the StateProvider
     * @return the {@link Scope}s supported by the configuration
     */
    Scope[] getSupportedScopes();
}
