/*
 * Copyright 2008-present 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 com.mongodb.client.model;

import com.mongodb.annotations.NotThreadSafe;
import com.mongodb.lang.Nullable;
import org.bson.BsonBoolean;
import org.bson.BsonDocument;
import org.bson.BsonInt32;
import org.bson.BsonString;

The options regarding collation support in MongoDB 3.4+
@mongodb.driver.manual
reference/method/db.createCollection/ Create Collection
@mongodb.driver.manual
reference/command/createIndexes Index options
Since:
3.4
@mongodb.server.release
3.4/**
 * The options regarding collation support in MongoDB 3.4+
 *
 * @mongodb.driver.manual reference/method/db.createCollection/ Create Collection
 * @mongodb.driver.manual reference/command/createIndexes Index options
 * @since 3.4
 * @mongodb.server.release 3.4
 */
public final class Collation {
    private final String locale;
    private final Boolean caseLevel;
    private final CollationCaseFirst caseFirst;
    private final CollationStrength strength;
    private final Boolean numericOrdering;
    private final CollationAlternate alternate;
    private final CollationMaxVariable maxVariable;
    private final Boolean normalization;
    private final Boolean backwards;

    
Convenience method to create a Builder.
Returns:
a builder/**
     * Convenience method to create a Builder.
     *
     * @return a builder
     */
    public static Builder builder() {
        return new Builder();
    }

    
Convenience method to create a from an existing Collation. 
Params:
options – create a builder from existing options
Returns:
a builder/**
     * Convenience method to create a from an existing {@code Collation}.
     *
     * @param options create a builder from existing options
     * @return a builder
     */
    public static Builder builder(final Collation options) {
        return new Builder(options);
    }

    
A Collation builder.
/**
     * A Collation builder.
     */
    @NotThreadSafe
    public static final class Builder {
        private String locale;
        private Boolean caseLevel;
        private CollationCaseFirst caseFirst;
        private CollationStrength strength;
        private Boolean numericOrdering;
        private CollationAlternate alternate;
        private CollationMaxVariable maxVariable;
        private Boolean normalization;
        private Boolean backwards;

        private Builder() {
        }

        private Builder(final Collation options) {
            this.locale = options.getLocale();
            this.caseLevel = options.getCaseLevel();
            this.caseFirst = options.getCaseFirst();
            this.strength = options.getStrength();
            this.numericOrdering = options.getNumericOrdering();
            this.alternate = options.getAlternate();
            this.maxVariable = options.getMaxVariable();
            this.normalization = options.getNormalization();
            this.backwards = options.getBackwards();
        }

        
Sets the locale
Params:
locale – the locale
See Also:
ICU User Guide - Locale
Returns:
this/**
         * Sets the locale
         *
         * @param locale the locale
         * @see <a href="http://userguide.icu-project.org/locale">ICU User Guide - Locale</a>
         * @return this
         */
        public Builder locale(@Nullable final String locale) {
            this.locale = locale;
            return this;
        }

        
Sets the case level value
Turns on case sensitivity
Params:
caseLevel – the case level value
Returns:
this/**
         * Sets the case level value
         *
         * <p>Turns on case sensitivity</p>
         * @param caseLevel the case level value
         * @return this
         */
        public Builder caseLevel(@Nullable final Boolean caseLevel) {
            this.caseLevel = caseLevel;
            return this;
        }

        
Sets the collation case first value
Determines if Uppercase or lowercase values should come first
Params:
caseFirst – the collation case first value
Returns:
this/**
         * Sets the collation case first value
         *
         * <p>Determines if Uppercase or lowercase values should come first</p>
         * @param caseFirst the collation case first value
         * @return this
         */
        public Builder collationCaseFirst(@Nullable final CollationCaseFirst caseFirst) {
            this.caseFirst = caseFirst;
            return this;
        }

        
Sets the collation strength
Params:
strength – the strength
Returns:
this/**
         * Sets the collation strength
         *
         * @param strength the strength
         * @return this
         */
        public Builder collationStrength(@Nullable final CollationStrength strength) {
            this.strength = strength;
            return this;
        }

        
Sets the numeric ordering
Params:
numericOrdering – if true will order numbers based on numerical order and not collation order
Returns:
this/**
         * Sets the numeric ordering
         *
         * @param numericOrdering if true will order numbers based on numerical order and not collation order
         * @return this
         */
        public Builder numericOrdering(@Nullable final Boolean numericOrdering) {
            this.numericOrdering = numericOrdering;
            return this;
        }

        
Sets the alternate
Controls whether spaces and punctuation are considered base characters
Params:
alternate – the alternate
Returns:
this/**
         * Sets the alternate
         *
         * <p>Controls whether spaces and punctuation are considered base characters</p>
         *
         * @param alternate the alternate
         * @return this
         */
        public Builder collationAlternate(@Nullable final CollationAlternate alternate) {
            this.alternate = alternate;
            return this;
        }

        
Sets the maxVariable
Params:
maxVariable – the maxVariable
Returns:
this/**
         * Sets the maxVariable
         *
         * @param maxVariable the maxVariable
         * @return this
         */
        public Builder collationMaxVariable(@Nullable final CollationMaxVariable maxVariable) {
            this.maxVariable = maxVariable;
            return this;
        }

        
Sets the normalization value
If true, normalizes text into Unicode NFD.
Params:
normalization – the normalization value
Returns:
this/**
         * Sets the normalization value
         *
         * <p>If true, normalizes text into Unicode NFD.</p>
         * @param normalization the normalization value
         * @return this
         */
        public Builder normalization(@Nullable final Boolean normalization) {
            this.normalization = normalization;
            return this;
        }

        
Sets the backwards value
Causes secondary differences to be considered in reverse order, as it is done in the French language
Params:
backwards – the backwards value
Returns:
this/**
         * Sets the backwards value
         *
         * <p>Causes secondary differences to be considered in reverse order, as it is done in the French language</p>
         *
         * @param backwards the backwards value
         * @return this
         */
        public Builder backwards(@Nullable final Boolean backwards) {
            this.backwards = backwards;
            return this;
        }

        
Creates a new Collation object with the settings initialised on this builder.
Returns:
a new Collation object/**
         * Creates a new Collation object with the settings initialised on this builder.
         *
         * @return a new Collation object
         */
        public Collation build() {
            return new Collation(this);
        }
    }

    
Returns the locale
See Also:
ICU User Guide - Locale
Returns:
the locale/**
     * Returns the locale
     *
     * @see <a href="http://userguide.icu-project.org/locale">ICU User Guide - Locale</a>
     * @return the locale
     */
    @Nullable
    public String getLocale() {
        return locale;
    }

    
Returns the case level value
Returns:
the case level value/**
     * Returns the case level value
     *
     * @return the case level value
     */
    @Nullable
    public Boolean getCaseLevel() {
        return caseLevel;
    }

    
Returns the collation case first value
Returns:
the collation case first value/**
     * Returns the collation case first value
     *
     * @return the collation case first value
     */
    @Nullable
    public CollationCaseFirst getCaseFirst() {
        return caseFirst;
    }

    
Returns the collation strength
Returns:
the collation strength/**
     * Returns the collation strength
     *
     * @return the collation strength
     */
    @Nullable
    public CollationStrength getStrength() {
        return strength;
    }

    
Returns the numeric ordering, if true will order numbers based on numerical order and not collation order.
Returns:
the numeric ordering/**
     * Returns the numeric ordering, if true will order numbers based on numerical order and not collation order.
     *
     * @return the numeric ordering
     */
    @Nullable
    public Boolean getNumericOrdering() {
        return numericOrdering;
    }

    
Returns the collation alternate
Returns:
the alternate/**
     * Returns the collation alternate
     *
     * @return the alternate
     */
    @Nullable
    public CollationAlternate getAlternate() {
        return alternate;
    }

    
Returns the maxVariable
Controls which characters are affected by collection alternate CollationAlternate.SHIFTED.
Returns:
the maxVariable/**
     * Returns the maxVariable
     *
     * <p>Controls which characters are affected by collection alternate {@link CollationAlternate#SHIFTED}.</p>
     * @return the maxVariable
     */
    @Nullable
    public CollationMaxVariable getMaxVariable() {
        return maxVariable;
    }

    
Returns the normalization value
If true, normalizes text into Unicode NFD.
Returns:
the normalization/**
     * Returns the normalization value
     *
     * <p>If true, normalizes text into Unicode NFD.</p>
     * @return the normalization
     */
    @Nullable
    public Boolean getNormalization() {
        return normalization;
    }

    
Returns the backwards value
Returns:
the backwards value/**
     * Returns the backwards value
     *
     * @return the backwards value
     */
    @Nullable
    public Boolean getBackwards() {
        return backwards;
    }

    
Gets this collation options as a document.
Returns:
The collation options as a BsonDocument/**
     * Gets this collation options as a document.
     *
     * @return The collation options as a BsonDocument
     */
    public BsonDocument asDocument() {
        BsonDocument collation = new BsonDocument();
        if (locale != null) {
            collation.put("locale", new BsonString(locale));
        }
        if (caseLevel != null) {
            collation.put("caseLevel", new BsonBoolean(caseLevel));
        }
        if (caseFirst != null) {
            collation.put("caseFirst", new BsonString(caseFirst.getValue()));
        }
        if (strength != null) {
            collation.put("strength", new BsonInt32(strength.getIntRepresentation()));
        }
        if (numericOrdering != null) {
            collation.put("numericOrdering", new BsonBoolean(numericOrdering));
        }
        if (alternate != null) {
            collation.put("alternate", new BsonString(alternate.getValue()));
        }
        if (maxVariable != null) {
            collation.put("maxVariable", new BsonString(maxVariable.getValue()));
        }
        if (normalization != null) {
            collation.put("normalization", new BsonBoolean(normalization));
        }
        if (backwards != null) {
            collation.put("backwards", new BsonBoolean(backwards));
        }
        return collation;
    }

    @Override
    public boolean equals(final Object o) {
        if (this == o){
            return true;
        }
        if (o == null || getClass() != o.getClass()) {
            return false;
        }
        Collation that = (Collation) o;

        if (locale != null ? !locale.equals(that.getLocale()) : that.getLocale() != null) {
            return false;
        }
        if (caseLevel != null ? !caseLevel.equals(that.getCaseLevel()) : that.getCaseLevel() != null) {
            return false;
        }
        if (getCaseFirst() != that.getCaseFirst()) {
            return false;
        }
        if (getStrength() != that.getStrength()) {
            return false;
        }
        if (numericOrdering != null ? !numericOrdering.equals(that.getNumericOrdering()) : that.getNumericOrdering() != null) {
            return false;
        }
        if (getAlternate() != that.getAlternate()) {
            return false;
        }
        if (getMaxVariable() != that.getMaxVariable()) {
            return false;
        }
        if (normalization != null ? !normalization.equals(that.getNormalization()) : that.getNormalization() != null) {
            return false;
        }
        if (backwards != null ? !backwards.equals(that.getBackwards()) : that.getBackwards() != null) {
            return false;
        }
        return true;
    }

    @Override
    public int hashCode() {
        int result = locale != null ? locale.hashCode() : 0;
        result = 31 * result + (caseLevel != null ? caseLevel.hashCode() : 0);
        result = 31 * result + (caseFirst != null ? caseFirst.hashCode() : 0);
        result = 31 * result + (strength != null ? strength.hashCode() : 0);
        result = 31 * result + (numericOrdering != null ? numericOrdering.hashCode() : 0);
        result = 31 * result + (alternate != null ? alternate.hashCode() : 0);
        result = 31 * result + (maxVariable != null ? maxVariable.hashCode() : 0);
        result = 31 * result + (normalization != null ? normalization.hashCode() : 0);
        result = 31 * result + (backwards != null ? backwards.hashCode() : 0);
        return result;
    }

    @Override
    public String toString() {
        return "Collation{"
                + "locale='" + locale + "'"
                + ", caseLevel=" + caseLevel
                + ", caseFirst=" + caseFirst
                + ", strength=" + strength
                + ", numericOrdering=" + numericOrdering
                + ", alternate=" + alternate
                + ", maxVariable=" + maxVariable
                + ", normalization=" + normalization
                + ", backwards=" + backwards
                + "}";
    }


    private Collation(final Builder builder) {
        this.locale = builder.locale;
        this.caseLevel = builder.caseLevel;
        this.caseFirst = builder.caseFirst;
        this.strength = builder.strength;
        this.numericOrdering = builder.numericOrdering;
        this.alternate = builder.alternate;
        this.maxVariable = builder.maxVariable;
        this.normalization = builder.normalization;
        this.backwards = builder.backwards;
    }
}