/*
 * 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.
 */

#ifndef _DECAF_LANG_DOUBLE_H_
#define _DECAF_LANG_DOUBLE_H_

#include <decaf/util/Config.h>
#include <decaf/lang/Comparable.h>
#include <decaf/lang/Number.h>
#include <decaf/lang/exceptions/NumberFormatException.h>
#include <string>

namespace decaf{
namespace lang{

    class DECAF_API Double : public Number,
                             public Comparable<Double>,
                             public Comparable<double> {
    private:

        double value;

    public:

        /** The size in bits of the primitive int type */
        static const int SIZE = 64;

        /** The maximum value that the primitive type can hold */
        static const double MAX_VALUE;

        /** The minimum value that the primitive type can hold */
        static const double MIN_VALUE;

        /** Constant for the Not a Number Value */
        static const double NaN;

        /** Constant for Positive Infinity */
        static const double POSITIVE_INFINITY;

        /** Constant for Negative Infinitiy */
        static const double NEGATIVE_INFINITY;

    public:

        /**
         * @param value - the primitve type to wrap
         */
        Double( double value );

        /**
         * @param value - the string to convert to a primitve type to wrap
         */
        Double( const std::string& value ) throw( exceptions::NumberFormatException );

        virtual ~Double() {}

        /**
         * Compares this Double instance with another.
         * @param d - the Double instance to be compared
         * @return zero if this object represents the same integer value as the
         * argument; a positive value if this object represents a value greater
         * than the passed in value, and -1 if this object repesents a value
         * less than the passed in value.
         */
        virtual int compareTo( const Double& d ) const;

        /**
         * @param d - the Double object to compare against.
         * @returns true if the two Double Objects have the same value.
         */
        bool equals( const Double& d ) const {
            return this->value == d.value;
        }

        /**
         * Compares equality between this object and the one passed.
         * @param d - the value to be compared to this one.
         * @return true if this object is equal to the one passed.
         */
        virtual bool operator==( const Double& d ) const {
            return this->value == d.value;
        }

        /**
         * Compares this object to another and returns true if this object
         * is considered to be less than the one passed.  This
         * @param d - the value to be compared to this one.
         * @return true if this object is equal to the one passed.
         */
        virtual bool operator<( const Double& d ) const {
            return this->value < d.value;
        }

        /**
         * Compares this Double instance with another.
         * @param d - the Double instance to be compared
         * @return zero if this object represents the same integer value as the
         * argument; a positive value if this object represents a value greater
         * than the passed in value, and -1 if this object repesents a value
         * less than the passed in value.
         */
        virtual int compareTo( const double& d ) const;

        /**
         * @param d - the Double object to compare against.
         * @returns true if the two Double Objects have the same value.
         */
        bool equals( const double& d ) const {
            return this->value == d;
        }

        /**
         * Compares equality between this object and the one passed.
         * @param d - the value to be compared to this one.
         * @return true if this object is equal to the one passed.
         */
        virtual bool operator==( const double& d ) const {
            return this->value == d;
        }

        /**
         * Compares this object to another and returns true if this object
         * is considered to be less than the one passed.  This
         * @param d - the value to be compared to this one.
         * @return true if this object is equal to the one passed.
         */
        virtual bool operator<( const double& d ) const {
            return this->value < d;
        }

        /**
         * @returns this Double Object as a String Representation
         */
        std::string toString() const;

        /**
         * Answers the double value which the receiver represents
         * @return double the value of the receiver.
         */
        virtual double doubleValue() const {
            return this->value;
        }

        /**
         * Answers the float value which the receiver represents
         * @return float the value of the receiver.
         */
        virtual float floatValue() const {
            return (float)this->value;
        }

        /**
         * Answers the byte value which the receiver represents
         * @return byte the value of the receiver.
         */
        virtual unsigned char byteValue() const {
            return (unsigned char)this->value;
        }

        /**
         * Answers the short value which the receiver represents
         * @return short the value of the receiver.
         */
        virtual short shortValue() const {
            return (short)this->value;
        }

        /**
         * Answers the int value which the receiver represents
         * @return int the value of the receiver.
         */
        virtual int intValue() const {
            return (int)this->value;
        }

        /**
         * Answers the long value which the receiver represents
         * @return long the value of the receiver.
         */
        virtual long long longValue() const {
            return (long long)this->value;
        }

        /**
         * @returns true if the double is equal to positive infinity.
         */
        bool isInfinite() const;

        /**
         * @returns true if the double is equal to NaN.
         */
        bool isNaN() const;

    public:  // Statics

        /**
         * Compares the two specified double values. The sign of the integer value
         * returned is the same as that of the integer that would be returned by the
         * call:
         *        new Double(d1).compareTo(new Double(d2))
         * @param d1 - the first double to compare
         * @param d2 - the second double to compare
         * @returns the value 0 if d1 is numerically equal to d2; a value less than
         * 0 if d1 is numerically less than d2; and a value greater than 0  if d1 is
         * numerically greater than d2.
         */
        static int compare( double d1, double d2 );

        /**
         * Returns a representation of the specified floating-point value according
         * to the IEEE 754 floating-point "double format" bit layout.
         *
         * Bit 63 (the bit that is selected by the mask 0x8000000000000000L)
         * represents the sign of the floating-point number. Bits 62-52 (the bits
         * that are selected by the mask 0x7ff0000000000000L) represent the exponent.
         * Bits 51-0 (the bits that are selected by the mask 0x000fffffffffffffL)
         * represent the significand (sometimes called the mantissa) of the
         * floating-point number.
         *
         * If the argument is positive infinity, the result is 0x7ff0000000000000L.
         * If the argument is negative infinity, the result is 0xfff0000000000000L.
         * If the argument is NaN, the result is 0x7ff8000000000000L.
         *
         * In all cases, the result is a long integer that, when given to the
         * longBitsToDouble(long) method, will produce a floating-point value the
         * same as the argument to doubleToLongBits (except all NaN values are
         * collapsed to a single "canonical" NaN value).
         * @param value - double to be converted
         * @returns the long long bits that make up the double
         */
        static long long doubleToLongBits( double value );

        /**
         * Returns a representation of the specified floating-point value according
         * to the IEEE 754 floating-point "double format" bit layout, preserving
         * Not-a-Number (NaN) values.
         *
         * Bit 63 (the bit that is selected by the mask 0x8000000000000000LL)
         * represents the sign of the floating-point number. Bits 62-52 (the bits
         * that are selected by the mask 0x7ff0000000000000L) represent the exponent.
         * Bits 51-0 (the bits that are selected by the mask 0x000fffffffffffffL)
         * represent the significand (sometimes called the mantissa) of the
         * floating-point number.
         *
         * If the argument is positive infinity, the result is 0x7ff0000000000000LL.
         * If the argument is negative infinity, the result is 0xfff0000000000000LL.
         * If the argument is NaN, the result is the long integer representing the
         * actual NaN value. Unlike the doubleToLongBits method, doubleToRawLongBits
         * does not collapse all the bit patterns encoding a NaN to a single
         * "canonical" NaN value.
         *
         * In all cases, the result is a long integer that, when given to the
         * longBitsToDouble(long) method, will produce a floating-point value the
         * same as the argument to doubleToRawLongBits.
         * @param value - double to be converted
         * @returns the long long bits that make up the double
         */
        static long long doubleToRawLongBits( double value );

        /**
         * @param value - The double to check.
         * @returns true if the double is equal to infinity.
         */
        static bool isInfinite( double value );

        /**
         * @param value - The double to check.
         * @returns true if the double is equal to NaN.
         */
        static bool isNaN( double value );

        /**
         * Returns the double value corresponding to a given bit representation.
         * The argument is considered to be a representation of a floating-point
         * value according to the IEEE 754 floating-point "double format" bit layout.
         *
         * If the argument is 0x7ff0000000000000L, the result is positive infinity.
         * If the argument is 0xfff0000000000000L, the result is negative infinity.
         * If the argument is any value in the range 0x7ff0000000000001L through
         * 0x7fffffffffffffffL or in the range 0xfff0000000000001L through
         * 0xffffffffffffffffL, the result is a NaN. No IEEE 754 floating-point
         * operation provided by C++ can distinguish between two NaN values of the
         * same type with different bit patterns. Distinct values of NaN are only
         * distinguishable by use of the Double.doubleToRawLongBits method.
         * @param bits - the long long bits to convert to double
         * @return the double converted from the bits
         */
        static double longBitsToDouble( long long bits );

        /**
         * Returns a new double initialized to the value represented by the
         * specified string, as performed by the valueOf method of class Double.
         * @param value - The string to parse to an double
         * @returns a double parsed from the passed string
         * @throws NumberFormatException
         */
        static double parseDouble( const std::string value )
            throw ( exceptions::NumberFormatException );

        /**
         * Returns a hexadecimal string representation of the double argument. All
         * characters mentioned below are ASCII characters.
         *
         *  * If the argument is NaN, the result is the string "NaN".
         *  * Otherwise, the result is a string that represents the sign and magnitude
         *    (absolute value) of the argument. If the sign is negative, the first
         *    character of the result is '-'; if the sign is positive, no sign
         *    character appears in the result. As for the magnitude m:
         *      o If m is infinity, it is represented by the string "Infinity"; thus,
         *        positive infinity produces the result "Infinity" and negative
         *        infinity produces the result "-Infinity".
         *      o If m is zero, it is represented by the string "0x0.0p0"; thus,
         *        negative zero produces the result "-0x0.0p0" and positive zero
         *        produces the result "0x0.0p0".
         *      o If m is a double value with a normalized representation, substrings
         *        are used to represent the significand and exponent fields. The
         *        significand is represented by the characters "0x1." followed by a
         *        lowercase hexadecimal representation of the rest of the
         *        significand as a fraction. Trailing zeros in the hexadecimal
         *        representation are removed unless all the digits are zero, in which
         *        case a single zero is used. Next, the exponent is represented by
         *        "p" followed by a decimal string of the unbiased exponent as if
         *        produced by a call to Integer.toString on the exponent value.
         *      o If m is a double value with a subnormal representation, the
         *        significand is represented by the characters "0x0." followed by a
         *        hexadecimal representation of the rest of the significand as a
         *        fraction. Trailing zeros in the hexadecimal representation are
         *        removed. Next, the exponent is represented by "p-126". Note that
         *        there must be at least one nonzero digit in a subnormal significand.
         *
         * @param value - The double to convert to a string
         * @returns the Hex formatted double string.
         */
        static std::string toHexString( double value );

        /**
         * Returns a string representation of the double argument. All characters
         * mentioned below are ASCII characters.
         *
         * If the argument is NaN, the result is the string "NaN".
         * Otherwise, the result is a string that represents the sign and magnitude
         * (absolute value) of the argument. If the sign is negative, the first
         * character of the result is '-'; if the sign is positive, no
         * sign character appears in the result. As for the magnitude m:
         *  o If m is infinity, it is represented by the characters "Infinity"; thus,
         *    positive infinity produces the result "Infinity" and negative infinity
         *    produces the result "-Infinity".
         *  o If m is zero, it is represented by the characters "0.0"; thus, negative
         *    zero produces the result "-0.0" and positive zero produces the result
         *    "0.0".
         *  o If m is greater than or equal to 10-3 but less than 107, then it is
         *    represented as the integer part of m, in decimal form with no leading
         *    zeroes, followed by '.', followed by one or more decimal digits
         *    representing the fractional part of m.
         *  o If m is less than 10-3 or greater than or equal to 107, then it is
         *    represented in so-called "computerized scientific notation." Let n be
         *    the unique integer such that 10n <= m < 10n+1; then let a be the
         *    mathematically exact quotient of m and 10n so that 1 <= a < 10.
         *    The magnitude is then represented as the integer part of a, as a
         *    single decimal digit, followed by '.', followed by decimal digits
         *    representing the fractional part of a, followed by the letter 'E',
         *    followed by a representation of n as a decimal integer, as produced
         *    by the method Integer.toString(int).
         * @param value - The double to convert to a string
         * @returns the formatted double string.
         */
        static std::string toString( double value );

        /**
         * Returns a Double instance representing the specified double value.
         * @param value - double to wrap
         * @returns new Double instance wrapping the primitive value
         */
        static Double valueOf( double value );

        /**
         * Returns a Double instance that wraps a primtive double which is parsed
         * from the string value passed.
         * @param value - the string to parse
         * @returns a new Double instance wrapping the double parsed from value
         * @throws NumberFormatException on error.
         */
        static Double valueOf( const std::string& value )
            throw ( exceptions::NumberFormatException );

    private:

        static const long long DOUBLE_SIGN_MASK = 0x8000000000000000LL;
        static const long long DOUBLE_EXPONENT_MASK = 0x7FF0000000000000LL;
        static const long long DOUBLE_MANTISSA_MASK = 0x000FFFFFFFFFFFFFLL;
        static const long long DOUBLE_NAN_BITS =
            DOUBLE_EXPONENT_MASK | 0x0008000000000000LL;

    };

}}

#endif /*_DECAF_LANG_DOUBLE_H_*/