/*
 * 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_FLOAT_H_
#define _DECAF_LANG_FLOAT_H_

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

namespace decaf {
namespace lang {

    class DECAF_API Float : public Number,
                            public Comparable<Float>,
                            public Comparable<float> {
    private:

        float value;

    public:

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

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

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

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

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

        /** Constant for Negative Infinity */
        static const float NEGATIVE_INFINITY;

    public:

        /**
         * @param value - the primitive type to wrap
         */
        Float(float value);

        /**
         * @param value - the primitive type to wrap
         */
        Float(double value);

        /**
         * @param value - the string to convert to a primitive type to wrap
         */
        Float(const String& value);

        virtual ~Float() {}

        /**
         * Compares this Float instance with another.
         * @param f - the Float 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 represents a value
         * less than the passed in value.
         */
        virtual int compareTo(const Float& f) const;

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

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

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

        /**
         * Compares this Float instance with another.
         * @param f - the Float 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 represents a value
         * less than the passed in value.
         */
        virtual int compareTo(const float& f) const;

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

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

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

        /**
         * @return this Float 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 (double) this->value;
        }

        /**
         * Answers the float value which the receiver represents
         * @return float the value of the receiver.
         */
        virtual float floatValue() const {
            return 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;
        }

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

        /**
         * @return true if the float 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: Float( f1 ).compareTo( Float( f2) )
         * @param f1 - the first double to compare
         * @param f2 - the second double to compare
         * @return the value 0 if d1 is numerically equal to f2; a value less than
         * 0 if f1 is numerically less than f2; and a value greater than 0  if f1 is
         * numerically greater than f2.
         */
        static int compare(float f1, float f2);

        /**
         * Returns a representation of the specified floating-point value according
         * to the IEEE 754 floating-point "single format" bit layout.
         *
         * Bit 31 (the bit that is selected by the mask 0x80000000) represents the
         * sign of the floating-point number. Bits 30-23 (the bits that are selected
         * by the mask 0x7f800000) represent the exponent. Bits 22-0 (the bits that
         * are selected by the mask 0x007fffff) represent the significand (sometimes
         * called the mantissa) of the floating-point number.
         *
         * If the argument is positive infinity, the result is 0x7f800000.
         * If the argument is negative infinity, the result is 0xff800000.
         * If the argument is NaN, the result is 0x7fc00000.
         *
         * In all cases, the result is an integer that, when given to the
         * intBitsToFloat(int) method, will produce a floating-point value the
         * same as the argument to floatToIntBits (except all NaN values are
         * collapsed to a single "canonical" NaN value).
         * @param value - the float to convert to int bits
         * @return the int that holds the float's value
         */
        static int floatToIntBits(float value);

        /**
         * Returns a representation of the specified floating-point value according
         * to the IEEE 754 floating-point "single format" bit layout, preserving
         * Not-a-Number (NaN) values.
         *
         * Bit 31 (the bit that is selected by the mask 0x80000000) represents the
         * sign of the floating-point number. Bits 30-23 (the bits that are selected
         * by the mask 0x7f800000) represent the exponent. Bits 22-0 (the bits that
         * are selected by the mask 0x007fffff) represent the significand (sometimes
         * called the mantissa) of the floating-point number.
         *
         * If the argument is positive infinity, the result is 0x7f800000.
         * If the argument is negative infinity, the result is 0xff800000.
         * If the argument is NaN, the result is the integer representing the
         * actual NaN value. Unlike the floatToIntBits method, intToRawIntBits
         * does not collapse all the bit patterns encoding a NaN to a single
         * "canonical" NaN value.
         *
         * In all cases, the result is an integer that, when given to the
         * intBitsToFloat(int) method, will produce a floating-point value the same
         * as the argument to floatToRawIntBits.
         * @param value
         *      The float to convert to a raw int.
         * @return the raw int value of the float
         */
        static int floatToRawIntBits(float value);

        /**
         * Returns the float 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 "single format" bit layout.
         *
         * If the argument is 0x7f800000, the result is positive infinity.
         * If the argument is 0xff800000, the result is negative infinity.
         * If the argument is any value in the range 0x7f800001 through 0x7fffffff
         * or in the range 0xff800001 through 0xffffffff, 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
         * Float::floatToRawIntBits method.
         *
         * @param bits - the bits of the float encoded as a float
         * @return a new float created from the int bits.
         */
        static float intBitsToFloat(int bits);

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

        /**
         * Checks and returns whether the given float is equal to NaN.
         *
         * @param value
         *      The float to check.
         *
         * @return true if the float is equal to NaN.
         */
        static bool isNaN(float value);

        /**
         * Returns a new float initialized to the value represented by the
         * specified string, as performed by the valueOf method of class Float.
         *
         * @param value
         *      The string to parse.
         *
         * @return a float parsed from the string
         *
         * @throw NumberFormatException if an error occurs parsing the String.
         */
        static float parseFloat(const String& value);

        /**
         * Returns a hexadecimal string representation of the float 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 float 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 float 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 float to convert to a string
         * @return the Hex formatted float string.
         */
        static std::string toHexString(float value);

        /**
         * Returns a string representation of the float  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 float to convert to a string
         *
         * @return the formatted float string.
         */
        static std::string toString(float value);

        /**
         * Returns a Float instance representing the specified float value.
         * @param value - float to wrap
         * @return new Float instance wrapping the primitive value
         */
        static Float valueOf(float value);

        /**
         * Returns a Float instance that wraps a primitive float which is parsed
         * from the string value passed.
         *
         * @param value - the string to parse
         * @return a new Float instance wrapping the float parsed from value
         * @throws NumberFormatException on error.
         */
        static Float valueOf(const String& value);

    private:

        static const unsigned int SINGLE_EXPONENT_MASK;
        static const unsigned int SINGLE_MANTISSA_MASK;
        static const unsigned int SINGLE_NAN_BITS;

    };

}}

#endif /*_DECAF_LANG_FLOAT_H_*/