/*
 * 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.math.BigInteger;
import java.util.ArrayList;
import java.util.List;
import jdk.test.lib.Platform;

public class IntJVMOption extends JVMOption {

    enum IntType {

        INTX,
        UINTX,
        UINT64_T
    }

    private static final BigInteger MIN_LONG;
    private static final BigInteger MAX_LONG;
    private static final BigInteger MAX_UNSIGNED_LONG;
    private static final BigInteger MAX_UNSIGNED_LONG_64;
    private static final BigInteger MAX_4_BYTE_INT_PLUS_ONE = new BigInteger("2147483648");
    private static final BigInteger MAX_4_BYTE_UNSIGNED_INT_PLUS_ONE = new BigInteger("4294967296");

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

    /**
     * Is this value is signed or unsigned
     */
    private boolean unsigned;

    /**
     * Is this value is 64 bit unsigned
     */
    private boolean uint64 = false;

    static {
        if (Platform.is32bit()) {
            MIN_LONG = new BigInteger(String.valueOf(Integer.MIN_VALUE));
            MAX_LONG = new BigInteger(String.valueOf(Integer.MAX_VALUE));
            MAX_UNSIGNED_LONG = MAX_LONG.multiply(new BigInteger("2")).add(BigInteger.ONE);
        } else {
            MIN_LONG = new BigInteger(String.valueOf(Long.MIN_VALUE));
            MAX_LONG = new BigInteger(String.valueOf(Long.MAX_VALUE));
            MAX_UNSIGNED_LONG = MAX_LONG.multiply(new BigInteger("2")).add(BigInteger.ONE);
        }

        MAX_UNSIGNED_LONG_64 = (new BigInteger(String.valueOf(Long.MAX_VALUE)))
                .multiply(new BigInteger("2")).add(BigInteger.ONE);
    }

    /**
     * Default constructor. Init min and max with minimum int and maximum int.
     */
    private IntJVMOption() {
        min = MIN_LONG;
        max = MAX_LONG;
        unsigned = false;
        uint64 = false;
    }

    /**
     * Initialize new integer option with given type. Type can be:
     * INTX - integer signed option
     * UINTX - unsigned integer option
     * UINT64_T - unsigned 64 bit integer option
     * 
     * @param name
     * @param type 
     */
    IntJVMOption(String name, IntType type) {
        this();
        this.name = name;

        switch (type) {
            case UINT64_T:
                uint64 = true;
            case UINTX:
                unsigned = true;
                break;
        }

        if (unsigned) {
            min = BigInteger.ZERO;
            max = MAX_UNSIGNED_LONG;
        }

        if (uint64) {
            max = MAX_UNSIGNED_LONG_64;
        }
    }

    /**
     * Initialize integer option with passed name, min and max values. Min and
     * max are string because they can be very big, bigger than long.
     *
     * @param name Name of the option
     * @param min Minimum value of the option
     * @param max Maximum value of the option
     */
    public IntJVMOption(String name, String min, String max) {
        this();
        this.name = name;
        this.min = new BigInteger(min);
        this.max = new BigInteger(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 BigInteger(min);
    }

    /**
     * Get string with minimum value of the option
     *
     * @return String with minimum value of the option
     */
    @Override
    String getMin() {
        return min.toString();
    }

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

    /**
     * Get string with maximum value of the option
     *
     * @return String with maximum value of the option
     */
    @Override
    String getMax() {
        return max.toString();
    }

    /**
     * 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(min.toString());
        validValues.add(max.toString());

        if ((min.compareTo(MIN_LONG) == 0) && (max.compareTo(MAX_LONG) == 0)) {
            validValues.add("-1");
            validValues.add("0");
            validValues.add("1");
        }

        if ((min.compareTo(BigInteger.ZERO) == -1) && (max.compareTo(BigInteger.ZERO) == 1)) {
            /*
             * Add 0 as valid value if min is less than 0 and max is greater than 0
             */
            validValues.add("0");
        }

        if ((min.compareTo(BigInteger.ONE) == -1) && (max.compareTo(BigInteger.ONE) == 1)) {
            /*
             * Add 1 as valid value if min is less than 1 and max is greater than 1
             */
            validValues.add("1");
        }

        if (max.compareTo(MAX_4_BYTE_INT_PLUS_ONE) == 1) {
            /* 
             * Check for overflow when flag is assigned to the 
             * 4 byte int variable
             */
            validValues.add(MAX_4_BYTE_INT_PLUS_ONE.toString());
        }

        if (max.compareTo(MAX_4_BYTE_UNSIGNED_INT_PLUS_ONE) == 1) {
            /* 
             * Check for overflow when flag is assigned to the 
             * 4 byte unsigned int variable
             */
            validValues.add(MAX_4_BYTE_UNSIGNED_INT_PLUS_ONE.toString());
        }

        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.compareTo(MIN_LONG) != 0) {
            invalidValues.add(min.subtract(BigInteger.ONE).toString());
        }

        if (!unsigned && (max.compareTo(MAX_LONG) != 0)) {
            invalidValues.add(max.add(BigInteger.ONE).toString());
        }

        if (unsigned
                && ((!uint64 && (max.compareTo(MAX_UNSIGNED_LONG) != 0))
                || (uint64 && (max.compareTo(MAX_UNSIGNED_LONG_64) != 0)))) {
            invalidValues.add(max.add(BigInteger.ONE).toString());
        }

        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 */
            if (unsigned && ((new BigInteger(value)).compareTo(BigInteger.ZERO) < 0)) {
                /*
                 * Special case for unsigned options with lower range equal to 0. If 
                 * passed value is negative then error will be catched earlier for
                 * such options. Thus use different error message.
                 */
                errorMsg = String.format("Improperly specified VM option '%s=%s'", name, value);
            } else {
                errorMsg = String.format("%s = %s is outside the allowed range [ %s ... %s ]",
                        name, value, min.toString(), max.toString());
            }
        } else {
            errorMsg = "";
        }

        return errorMsg;
    }
}