/*

 * Copyright (c) 2003, 2013, 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.  Oracle designates this

 * particular file as subject to the "Classpath" exception as provided

 * by Oracle in the LICENSE file that accompanied this code.

 *

 * 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 sun.misc;

import java.util.Arrays;

public class FormattedFloatingDecimal{

    public enum Form { SCIENTIFIC, COMPATIBLE, DECIMAL_FLOAT, GENERAL };

    public static FormattedFloatingDecimal valueOf(double d, int precision, Form form){

        FloatingDecimal.BinaryToASCIIConverter fdConverter =

                FloatingDecimal.getBinaryToASCIIConverter(d, form == Form.COMPATIBLE);

        return new FormattedFloatingDecimal(precision,form, fdConverter);

    }

    private int decExponentRounded;

    private char[] mantissa;

    private char[] exponent;

    private static final ThreadLocal<Object> threadLocalCharBuffer =

            new ThreadLocal<Object>() {

                @Override

                protected Object initialValue() {

                    return new char[20];

                }

            };

    private static char[] getBuffer(){

        return (char[]) threadLocalCharBuffer.get();

    }

    private FormattedFloatingDecimal(int precision, Form form, FloatingDecimal.BinaryToASCIIConverter fdConverter) {

        if (fdConverter.isExceptional()) {

            this.mantissa = fdConverter.toJavaFormatString().toCharArray();

            this.exponent = null;

            return;

        }

        char[] digits = getBuffer();

        int nDigits = fdConverter.getDigits(digits);

        int decExp = fdConverter.getDecimalExponent();

        int exp;

        boolean isNegative = fdConverter.isNegative();

        switch (form) {

            case COMPATIBLE:

                exp = decExp;

                this.decExponentRounded = exp;

                fillCompatible(precision, digits, nDigits, exp, isNegative);

                break;

            case DECIMAL_FLOAT:

                exp = applyPrecision(decExp, digits, nDigits, decExp + precision);

                fillDecimal(precision, digits, nDigits, exp, isNegative);

                this.decExponentRounded = exp;

                break;

            case SCIENTIFIC:

                exp = applyPrecision(decExp, digits, nDigits, precision + 1);

                fillScientific(precision, digits, nDigits, exp, isNegative);

                this.decExponentRounded = exp;

                break;

            case GENERAL:

                exp = applyPrecision(decExp, digits, nDigits, precision);

                // adjust precision to be the number of digits to right of decimal

                // the real exponent to be output is actually exp - 1, not exp

                if (exp - 1 < -4 || exp - 1 >= precision) {

                    // form = Form.SCIENTIFIC;

                    precision--;

                    fillScientific(precision, digits, nDigits, exp, isNegative);

                } else {

                    // form = Form.DECIMAL_FLOAT;

                    precision = precision - exp;

                    fillDecimal(precision, digits, nDigits, exp, isNegative);

                }

                this.decExponentRounded = exp;

                break;

            default:

                assert false;

        }

    }

    // returns the exponent after rounding has been done by applyPrecision

    public int getExponentRounded() {

        return decExponentRounded - 1;

    }

    public char[] getMantissa(){

        return mantissa;

    }

    public char[] getExponent(){

        return exponent;

    }

    /**

     * Returns new decExp in case of overflow.

     */

    private static int applyPrecision(int decExp, char[] digits, int nDigits, int prec) {

        if (prec >= nDigits || prec < 0) {

            // no rounding necessary

            return decExp;

        }

        if (prec == 0) {

            // only one digit (0 or 1) is returned because the precision

            // excludes all significant digits

            if (digits[0] >= '5') {

                digits[0] = '1';

                Arrays.fill(digits, 1, nDigits, '0');

                return decExp + 1;

            } else {

                Arrays.fill(digits, 0, nDigits, '0');

                return decExp;

            }

        }

        int q = digits[prec];

        if (q >= '5') {

            int i = prec;

            q = digits[--i];

            if ( q == '9' ) {

                while ( q == '9' && i > 0 ){

                    q = digits[--i];

                }

                if ( q == '9' ){

                    // carryout! High-order 1, rest 0s, larger exp.

                    digits[0] = '1';

                    Arrays.fill(digits, 1, nDigits, '0');

                    return decExp+1;

                }

            }

            digits[i] = (char)(q + 1);

            Arrays.fill(digits, i+1, nDigits, '0');

        } else {

            Arrays.fill(digits, prec, nDigits, '0');

        }

        return decExp;

    }

    /**

     * Fills mantissa and exponent char arrays for compatible format.

     */

    private void fillCompatible(int precision, char[] digits, int nDigits, int exp, boolean isNegative) {

        int startIndex = isNegative ? 1 : 0;

        if (exp > 0 && exp < 8) {

            // print digits.digits.

            if (nDigits < exp) {

                int extraZeros = exp - nDigits;

                mantissa = create(isNegative, nDigits + extraZeros + 2);

                System.arraycopy(digits, 0, mantissa, startIndex, nDigits);

                Arrays.fill(mantissa, startIndex + nDigits, startIndex + nDigits + extraZeros, '0');

                mantissa[startIndex + nDigits + extraZeros] = '.';

                mantissa[startIndex + nDigits + extraZeros+1] = '0';

            } else if (exp < nDigits) {

                int t = Math.min(nDigits - exp, precision);

                mantissa = create(isNegative, exp + 1 + t);

                System.arraycopy(digits, 0, mantissa, startIndex, exp);

                mantissa[startIndex + exp ] = '.';

                System.arraycopy(digits, exp, mantissa, startIndex+exp+1, t);

            } else { // exp == digits.length

                mantissa = create(isNegative, nDigits + 2);

                System.arraycopy(digits, 0, mantissa, startIndex, nDigits);

                mantissa[startIndex + nDigits ] = '.';

                mantissa[startIndex + nDigits +1] = '0';

            }

        } else if (exp <= 0 && exp > -3) {

            int zeros = Math.max(0, Math.min(-exp, precision));

            int t = Math.max(0, Math.min(nDigits, precision + exp));

            // write '0' s before the significant digits

            if (zeros > 0) {

                mantissa = create(isNegative, zeros + 2 + t);

                mantissa[startIndex] = '0';

                mantissa[startIndex+1] = '.';

                Arrays.fill(mantissa, startIndex + 2, startIndex + 2 + zeros, '0');

                if (t > 0) {

                    // copy only when significant digits are within the precision

                    System.arraycopy(digits, 0, mantissa, startIndex + 2 + zeros, t);

                }

            } else if (t > 0) {

                mantissa = create(isNegative, zeros + 2 + t);

                mantissa[startIndex] = '0';

                mantissa[startIndex + 1] = '.';

                // copy only when significant digits are within the precision

                System.arraycopy(digits, 0, mantissa, startIndex + 2, t);

            } else {

                this.mantissa = create(isNegative, 1);

                this.mantissa[startIndex] = '0';

            }

        } else {

            if (nDigits > 1) {

                mantissa = create(isNegative, nDigits + 1);

                mantissa[startIndex] = digits[0];

                mantissa[startIndex + 1] = '.';

                System.arraycopy(digits, 1, mantissa, startIndex + 2, nDigits - 1);

            } else {

                mantissa = create(isNegative, 3);

                mantissa[startIndex] = digits[0];

                mantissa[startIndex + 1] = '.';

                mantissa[startIndex + 2] = '0';

            }

            int e, expStartIntex;

            boolean isNegExp = (exp <= 0);

            if (isNegExp) {

                e = -exp + 1;

                expStartIntex = 1;

            } else {

                e = exp - 1;

                expStartIntex = 0;

            }

            // decExponent has 1, 2, or 3, digits

            if (e <= 9) {

                exponent = create(isNegExp,1);

                exponent[expStartIntex] = (char) (e + '0');

            } else if (e <= 99) {

                exponent = create(isNegExp,2);

                exponent[expStartIntex] = (char) (e / 10 + '0');

                exponent[expStartIntex+1] = (char) (e % 10 + '0');

            } else {

                exponent = create(isNegExp,3);

                exponent[expStartIntex] = (char) (e / 100 + '0');

                e %= 100;

                exponent[expStartIntex+1] = (char) (e / 10 + '0');

                exponent[expStartIntex+2] = (char) (e % 10 + '0');

            }

        }

    }

    private static char[] create(boolean isNegative, int size) {

        if(isNegative) {

            char[] r = new char[size +1];

            r[0] = '-';

            return r;

        } else {

            return new char[size];

        }

    }

    /*

     * Fills mantissa char arrays for DECIMAL_FLOAT format.

     * Exponent should be equal to null.

     */

    private void fillDecimal(int precision, char[] digits, int nDigits, int exp, boolean isNegative) {

        int startIndex = isNegative ? 1 : 0;

        if (exp > 0) {

            // print digits.digits.

            if (nDigits < exp) {

                mantissa = create(isNegative,exp);

                System.arraycopy(digits, 0, mantissa, startIndex, nDigits);

                Arrays.fill(mantissa, startIndex + nDigits, startIndex + exp, '0');

                // Do not append ".0" for formatted floats since the user

                // may request that it be omitted. It is added as necessary

                // by the Formatter.

            } else {

                int t = Math.min(nDigits - exp, precision);

                mantissa = create(isNegative, exp + (t > 0 ? (t + 1) : 0));

                System.arraycopy(digits, 0, mantissa, startIndex, exp);

                // Do not append ".0" for formatted floats since the user

                // may request that it be omitted. It is added as necessary

                // by the Formatter.

                if (t > 0) {

                    mantissa[startIndex + exp] = '.';

                    System.arraycopy(digits, exp, mantissa, startIndex + exp + 1, t);

                }

            }

        } else if (exp <= 0) {

            int zeros = Math.max(0, Math.min(-exp, precision));

            int t = Math.max(0, Math.min(nDigits, precision + exp));

            // write '0' s before the significant digits

            if (zeros > 0) {

                mantissa = create(isNegative, zeros + 2 + t);

                mantissa[startIndex] = '0';

                mantissa[startIndex+1] = '.';

                Arrays.fill(mantissa, startIndex + 2, startIndex + 2 + zeros, '0');

                if (t > 0) {

                    // copy only when significant digits are within the precision

                    System.arraycopy(digits, 0, mantissa, startIndex + 2 + zeros, t);

                }

            } else if (t > 0) {

                mantissa = create(isNegative, zeros + 2 + t);

                mantissa[startIndex] = '0';

                mantissa[startIndex + 1] = '.';

                // copy only when significant digits are within the precision

                System.arraycopy(digits, 0, mantissa, startIndex + 2, t);

            } else {

                this.mantissa = create(isNegative, 1);

                this.mantissa[startIndex] = '0';

            }

        }

    }

    /**

     * Fills mantissa and exponent char arrays for SCIENTIFIC format.

     */

    private void fillScientific(int precision, char[] digits, int nDigits, int exp, boolean isNegative) {

        int startIndex = isNegative ? 1 : 0;

        int t = Math.max(0, Math.min(nDigits - 1, precision));

        if (t > 0) {

            mantissa = create(isNegative, t + 2);

            mantissa[startIndex] = digits[0];

            mantissa[startIndex + 1] = '.';

            System.arraycopy(digits, 1, mantissa, startIndex + 2, t);

        } else {

            mantissa = create(isNegative, 1);

            mantissa[startIndex] = digits[0];

        }

        char expSign;

        int e;

        if (exp <= 0) {

            expSign = '-';

            e = -exp + 1;

        } else {

            expSign = '+' ;

            e = exp - 1;

        }

        // decExponent has 1, 2, or 3, digits

        if (e <= 9) {

            exponent = new char[] { expSign,

                    '0', (char) (e + '0') };

        } else if (e <= 99) {

            exponent = new char[] { expSign,

                    (char) (e / 10 + '0'), (char) (e % 10 + '0') };

        } else {

            char hiExpChar = (char) (e / 100 + '0');

            e %= 100;

            exponent = new char[] { expSign,

                    hiExpChar, (char) (e / 10 + '0'), (char) (e % 10 + '0') };

        }

    }

}