/*
 * Copyright 2016 MongoDB, Inc.
 *
 * Licensed 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.mongodb.morphia;

import com.mongodb.DBCollection;
import com.mongodb.MapReduceCommand;
import com.mongodb.MapReduceCommand.OutputType;
import com.mongodb.ReadPreference;
import com.mongodb.client.model.Collation;
import org.mongodb.morphia.mapping.Mapper;
import org.mongodb.morphia.query.Query;
import org.mongodb.morphia.query.QueryException;
import org.mongodb.morphia.utils.Assert;

import java.util.Map;
import java.util.concurrent.TimeUnit;

This defines options that can be applied to a mapreduce job
Type parameters:
<T> – the type of the output
Since:
1.3/**
 * This defines options that can be applied to a mapreduce job
 *
 * @param <T> the type of the output
 * @since 1.3
 */
public class MapReduceOptions<T> {
    private String outputDB;
    private String outputCollection;
    private String inputCollection;
    private String map;
    private String reduce;
    private OutputType outputType;
    private Query query;
    private String finalize;
    private ReadPreference readPreference;
    private int limit;
    private long maxTimeMS;
    private Map<String, Object> scope;
    private boolean jsMode;
    private boolean verbose;
    private boolean bypassDocumentValidation;
    private Collation collation;
    private Class<T> resultType;

    
Sets whether to bypass document validation.
Params:
bypassDocumentValidation – whether to bypass document validation, or null if unspecified
Returns:
this
@mongodb.server.release
3.2/**
     * Sets whether to bypass document validation.
     *
     * @param bypassDocumentValidation whether to bypass document validation, or null if unspecified
     * @return this
     * @mongodb.server.release 3.2
     */
    public MapReduceOptions<T> bypassDocumentValidation(final Boolean bypassDocumentValidation) {
        this.bypassDocumentValidation = bypassDocumentValidation;
        return this;
    }

    
Sets the collation options
Params:
collation – the collation options
Returns:
this
@mongodb.server.release
3.4/**
     * Sets the collation options
     *
     * @param collation the collation options
     * @return this
     * @mongodb.server.release 3.4
     */
    public MapReduceOptions<T> collation(final Collation collation) {
        this.collation = collation;
        return this;
    }

    
Sets the Finalize JS Function
Params:
finalize – The finalize function (as a JS String)
Returns:
this/**
     * Sets the Finalize JS Function
     *
     * @param finalize The finalize function (as a JS String)
     * @return this
     */
    public MapReduceOptions<T> finalize(final String finalize) {
        this.finalize = finalize;
        return this;
    }

    
Sets the (optional) JavaScript Mode
Params:
jsMode – Specifies whether to convert intermediate data into BSON format between the execution of the map and reduce functions
Returns:
this/**
     * Sets the (optional) JavaScript Mode
     *
     * @param jsMode Specifies whether to convert intermediate data into BSON format between the execution of the map and reduce functions
     * @return this
     */
    public MapReduceOptions<T> jsMode(final Boolean jsMode) {
        this.jsMode = jsMode;
        return this;
    }

    
Sets the (optional) limit on input
Params:
limit – The limit specification object
Returns:
this/**
     * Sets the (optional) limit on input
     *
     * @param limit The limit specification object
     * @return this
     */
    public MapReduceOptions<T> limit(final int limit) {
        this.limit = limit;
        return this;
    }

    
Set the JavaScript function that associates or "maps" a value with a key and emits the key and value pair.
Params:
map – the JavaScript function
Returns:
this/**
     * Set the JavaScript function that associates or "maps" a value with a key and emits the key and value pair.
     *
     * @param map the JavaScript function
     * @return this
     */
    public MapReduceOptions<T> map(final String map) {
        Assert.parametersNotNull("map", map);
        Assert.parameterNotEmpty("map", map);
        this.map = map;
        return this;
    }

    
Sets the max execution time for this command, in the given time unit.
Params:
maxTimeMS – the maximum execution time in milliseconds. A non-zero value requires a server version >= 2.6
Returns:
this
@mongodb.server.release
2.6/**
     * Sets the max execution time for this command, in the given time unit.
     *
     * @param maxTimeMS the maximum execution time in milliseconds. A non-zero value requires a server version &gt;= 2.6
     * @return this
     * @mongodb.server.release 2.6
     */
    public MapReduceOptions<T> maxTimeMS(final long maxTimeMS) {
        this.maxTimeMS = maxTimeMS;
        return this;
    }

    
Sets the input collection for the job should that collection differ from the mapped collection used in the query
Params:
name – the collection name
Returns:
this/**
     * Sets the input collection for the job should that collection differ from the mapped collection used in the query
     *
     * @param name the collection name
     * @return this
     */
    public MapReduceOptions<T> inputCollection(final String name) {
        this.inputCollection = name;
        return this;
    }

    
Sets the output collection for the job
Params:
name – the collection name
Returns:
this/**
     * Sets the output collection for the job
     *
     * @param name the collection name
     * @return this
     */
    public MapReduceOptions<T> outputCollection(final String name) {
        this.outputCollection = name;
        return this;
    }

    
Sets the (optional) database name where the output collection should reside
Params:
outputDB – the name of the database to send the Map Reduce output to
Returns:
this/**
     * Sets the (optional) database name where the output collection should reside
     *
     * @param outputDB the name of the database to send the Map Reduce output to
     * @return this
     */
    public MapReduceOptions<T> outputDB(final String outputDB) {
        this.outputDB = outputDB;
        return this;
    }

    
Sets the output type of the job
Params:
outputType – the output type
Returns:
this/**
     * Sets the output type of the job
     *
     * @param outputType the output type
     * @return this
     */
    public MapReduceOptions<T> outputType(final OutputType outputType) {
        this.outputType = outputType;
        return this;
    }

    
Sets the query defining the input for the job.  Must not be null.
Params:
query – the query to use
Returns:
this/**
     * Sets the query defining the input for the job.  Must not be null.
     *
     * @param query the query to use
     * @return this
     */
    public MapReduceOptions<T> query(final Query query) {
        Assert.parametersNotNull("query", query);
        this.query = query;
        return this;
    }

    
Sets the read preference for this command. See the documentation for ReadPreference for more information. 
Params:
preference – Read Preference to use
Returns:
this/**
     * Sets the read preference for this command. See the documentation for {@link ReadPreference} for more information.
     *
     * @param preference Read Preference to use
     * @return this
     */
    public MapReduceOptions<T> readPreference(final ReadPreference preference) {
        this.readPreference = preference;
        return this;
    }

    
Sets the JavaScript function that "reduces" to a single object all the values associated with a particular key.
Params:
reduce – the javascript function
Returns:
this/**
     * Sets the JavaScript function that "reduces" to a single object all the values associated with a particular key.
     *
     * @param reduce the javascript function
     * @return this
     */
    public MapReduceOptions<T> reduce(final String reduce) {
        Assert.parametersNotNull("reduce", reduce);
        Assert.parameterNotEmpty("reduce", reduce);
        this.reduce = reduce;
        return this;
    }

    
Sets the result type of the job
Params:
resultType – the type
Returns:
this/**
     * Sets the result type of the job
     *
     * @param resultType the type
     * @return this
     */
    public MapReduceOptions<T> resultType(final Class<T> resultType) {
        this.resultType = resultType;
        return this;
    }

    
Sets the (optional) JavaScript scope
Params:
scope – The JavaScript scope
Returns:
this/**
     * Sets the (optional) JavaScript scope
     *
     * @param scope The JavaScript scope
     * @return this
     */
    public MapReduceOptions<T> scope(final Map<String, Object> scope) {
        this.scope = scope;
        return this;
    }

    
Sets the verbosity of the MapReduce job, defaults to 'true'
Params:
verbose – The verbosity level.
Returns:
this/**
     * Sets the verbosity of the MapReduce job, defaults to 'true'
     *
     * @param verbose The verbosity level.
     * @return this
     */
    public MapReduceOptions<T> verbose(final Boolean verbose) {
        this.verbose = verbose;
        return this;
    }

    OutputType getOutputType() {
        return outputType;
    }

    Query getQuery() {
        return query;
    }

    Class<T> getResultType() {
        return resultType;
    }

    @SuppressWarnings("deprecation")
    MapReduceCommand toCommand(final Mapper mapper) {
        if (query.getOffset() != 0 || query.getFieldsObject() != null) {
            throw new QueryException("mapReduce does not allow the offset/retrievedFields query ");
        }

        final DBCollection dbColl = inputCollection != null ? getQuery().getCollection().getDB().getCollection(inputCollection)
                                                            : query.getCollection();
        final String target = outputCollection != null ? outputCollection : mapper.getMappedClass(resultType).getCollectionName();

        final MapReduceCommand command = new MapReduceCommand(dbColl, map, reduce, target, outputType, query.getQueryObject());
        command.setBypassDocumentValidation(bypassDocumentValidation);
        command.setCollation(collation);
        command.setFinalize(finalize);
        command.setJsMode(jsMode);
        command.setLimit(limit);
        command.setMaxTime(maxTimeMS, TimeUnit.MILLISECONDS);
        command.setOutputDB(outputDB);
        command.setReadPreference(readPreference);
        command.setScope(scope);
        command.setSort(query.getSortObject());
        command.setVerbose(verbose);

        return command;
    }
}