/*
 * Copyright (c) 2015, Oracle and/or its affiliates. All rights reserved.
 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
 *
 * This code is free software; you can redistribute it and/or modify it
 * under the terms of the GNU General Public License version 2 only, as
 * published by the Free Software Foundation.
 *
 * This code is distributed in the hope that it will be useful, but WITHOUT
 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
 * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
 * version 2 for more details (a copy is included in the LICENSE file that
 * accompanied this code).
 *
 * You should have received a copy of the GNU General Public License version
 * 2 along with this work; if not, write to the Free Software Foundation,
 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
 *
 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
 * or visit www.oracle.com if you need additional information or have any
 * questions.
 */
package optionsvalidation;

import java.util.ArrayList;
import java.util.List;

public class DoubleJVMOption extends JVMOption {

    private final double MAX_DOUBLE = 18446744073709551616.000;

    /**
     * Mininum option value
     */
    private double min;
    /**
     * Maximum option value
     */
    private double max;

    /**
     * Default constructor.
     */
    private DoubleJVMOption() {
        min = Double.MIN_VALUE;
        max = MAX_DOUBLE;
    }

    /**
     * Initialize double option with passed name
     *
     * @param name Name of the option
     */
    DoubleJVMOption(String name) {
        this();
        this.name = name;
    }
    
    /**
     * Initialize double option with passed name, min and max values
     *
     * @param name Name of the option
     * @param min Minimum value of the option
     * @param max Maximum value of the option
     */
    public DoubleJVMOption(String name, double min, double max) {
        this(name);
        this.min = min;
        this.max = max;
    }

    /**
     * Construct option string with passed value
     *
     * @param value Parameter value
     * @return String containing option with passed value
     */
    private String constructOption(String value) {
        return "-XX:" + name + "=" + value;
    }

    /**
     * Set new minimum option value
     *
     * @param min New minimum value
     */
    @Override
    void setMin(String min) {
        this.min = new Double(min);
    }

    /**
     * Get string with minimum value of the option
     *
     * @return String with minimum value of the option
     */
    @Override
    String getMin() {
        return String.format("%f", min);
    }

    /**
     * Set new maximum option value
     *
     * @param max New maximum value
     */
    @Override
    void setMax(String max) {
        this.max = new Double(max);
    }

    /**
     * Get string with maximum value of the option
     *
     * @return String with maximum value of the option
     */
    @Override
    String getMax() {
        return String.format("%f", max);
    }

    /**
     * Return list of strings with valid option values which used for testing
     * using jcmd, attach and etc.
     *
     * @return List of strings which contain valid values for option
     */
    @Override
    protected List<String> getValidValues() {
        List<String> validValues = new ArrayList<>();

        validValues.add(String.format("%f", min));
        validValues.add(String.format("%f", max));

        if (min == Double.MIN_VALUE && max == MAX_DOUBLE) {
            validValues.add(String.format("%f", -1.5));
            validValues.add(String.format("%f", 0.0));
            validValues.add(String.format("%f", 0.85));
        }

        return validValues;
    }

    /**
     * Return list of strings with invalid option values which used for testing
     * using jcmd, attach and etc.
     *
     * @return List of strings which contain invalid values for option
     */
    @Override
    protected List<String> getInvalidValues() {
        List<String> invalidValues = new ArrayList<>();

        if (min != Double.MIN_VALUE) {
            invalidValues.add(String.format("%f", min - 0.01));
        }

        if (max != MAX_DOUBLE) {
            invalidValues.add(String.format("%f", max + 0.01));
        }

        return invalidValues;
    }

    /**
     * Return list of strings with parameter with valid values. Valid values
     * are: min, max Following values are added to valid if min and max not
     * defined: -1, 0, 1 Following value is added if min is equal to 0 and max
     * is greater than 0: 1
     *
     * @return List of String with parameters with valid values.
     */
    @Override
    protected List<String> getValidCommandLineOptions() {
        List<String> validParameters = new ArrayList<>();

        for (String value : getValidValues()) {
            validParameters.add(constructOption(value));
        }

        return validParameters;
    }

    /**
     * Return list of strings with parameter with invalid values. Invalid values
     * are(if min, max are defined): min - 1, max + 1
     *
     * @return List of String with parameters with invalid values.
     */
    @Override
    protected List<String> getInvalidCommandLineOptions() {
        List<String> invalidParameters = new ArrayList<>();

        for (String value : getInvalidValues()) {
            invalidParameters.add(constructOption(value));
        }

        return invalidParameters;
    }

    /**
     * Return expected error message for option with value "value" when it used
     * on command line with passed value
     *
     * @param value Option value
     * @return Expected error message
     */
    @Override
    protected String getErrorMessageCommandLine(String value) {
        String errorMsg;

        if (withRange) {
            /* Option have defined range in VM */
            errorMsg = "is outside the allowed range";
        } else {
            errorMsg = "";
        }

        return errorMsg;
    }
}