package com.ibm.icu.text;

import java.io.IOException;
import java.io.NotSerializableException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.util.Locale;

import com.ibm.icu.text.PluralRules.IFixedDecimal;
import com.ibm.icu.text.PluralRules.Operand;

/**
 * @internal CLDR
 * @deprecated This API is ICU internal only.
 */
@Deprecated
public class FixedDecimal extends Number implements Comparable<FixedDecimal>, IFixedDecimal {
    private static final long serialVersionUID = -4756200506571685661L;

    final double source;

    final int visibleDecimalDigitCount;

    final int visibleDecimalDigitCountWithoutTrailingZeros;

    final long decimalDigits;

    final long decimalDigitsWithoutTrailingZeros;

    final long integerValue;

    final boolean hasIntegerValue;

    final boolean isNegative;

    final int exponent;

    private final int baseFactor;

    /**
     * @internal CLDR
     * @deprecated This API is ICU internal only.
     */
    @Deprecated
    public double getSource() {
        return source;
    }

    /**
     * @internal CLDR
     * @deprecated This API is ICU internal only.
     */
    @Deprecated
    public int getVisibleDecimalDigitCount() {
        return visibleDecimalDigitCount;
    }

    /**
     * @internal CLDR
     * @deprecated This API is ICU internal only.
     */
    @Deprecated
    public int getVisibleDecimalDigitCountWithoutTrailingZeros() {
        return visibleDecimalDigitCountWithoutTrailingZeros;
    }

    /**
     * @internal CLDR
     * @deprecated This API is ICU internal only.
     */
    @Deprecated
    public long getDecimalDigits() {
        return decimalDigits;
    }

    /**
     * @internal CLDR
     * @deprecated This API is ICU internal only.
     */
    @Deprecated
    public long getDecimalDigitsWithoutTrailingZeros() {
        return decimalDigitsWithoutTrailingZeros;
    }

    /**
     * @internal CLDR
     * @deprecated This API is ICU internal only.
     */
    @Deprecated
    public long getIntegerValue() {
        return integerValue;
    }

    /**
     * @internal CLDR
     * @deprecated This API is ICU internal only.
     */
    @Deprecated
    public boolean isHasIntegerValue() {
        return hasIntegerValue;
    }

    /**
     * @internal CLDR
     * @deprecated This API is ICU internal only.
     */
    @Deprecated
    public boolean isNegative() {
        return isNegative;
    }

    /**
     * @internal CLDR
     * @deprecated This API is ICU internal only.
     */
    @Deprecated
    public int getBaseFactor() {
        return baseFactor;
    }

    static final long MAX = (long)1E18;

    /**
     * @internal CLDR
     * @deprecated This API is ICU internal only.
     * @param n is the original number
     * @param v number of digits to the right of the decimal place. e.g 1.00 = 2 25. = 0
     * @param f Corresponds to f in the plural rules grammar.
     *   The digits to the right of the decimal place as an integer. e.g 1.10 = 10
     * @param e Suppressed exponent for scientific and compact notation
     */
    @Deprecated
    public FixedDecimal(double n, int v, long f, int e) {
        isNegative = n < 0;
        source = isNegative ? -n : n;
        visibleDecimalDigitCount = v;
        decimalDigits = f;
        integerValue = n > MAX
            ? MAX
                : (long)n;
        exponent = e;
        hasIntegerValue = source == integerValue;
        // check values. TODO make into unit test.
        //
        //            long visiblePower = (int) Math.pow(10, v);
        //            if (fractionalDigits > visiblePower) {
        //                throw new IllegalArgumentException();
        //            }
        //            double fraction = intValue + (fractionalDigits / (double) visiblePower);
        //            if (fraction != source) {
        //                double diff = Math.abs(fraction - source)/(Math.abs(fraction) + Math.abs(source));
        //                if (diff > 0.00000001d) {
        //                    throw new IllegalArgumentException();
        //                }
        //            }
        if (f == 0) {
            decimalDigitsWithoutTrailingZeros = 0;
            visibleDecimalDigitCountWithoutTrailingZeros = 0;
        } else {
            long fdwtz = f;
            int trimmedCount = v;
            while ((fdwtz%10) == 0) {
                fdwtz /= 10;
                --trimmedCount;
            }
            decimalDigitsWithoutTrailingZeros = fdwtz;
            visibleDecimalDigitCountWithoutTrailingZeros = trimmedCount;
        }
        baseFactor = (int) Math.pow(10, v);
    }

    /**
     * @internal CLDR
     * @deprecated This API is ICU internal only.
     */
    @Deprecated
    public FixedDecimal(double n, int v, long f) {
        this(n, v, f, 0);
    }

    /**
     * @internal CLDR
     * @deprecated This API is ICU internal only.
     */
    @Deprecated
    public static FixedDecimal createWithExponent(double n, int v, int e) {
        return new FixedDecimal(n,v,getFractionalDigits(n, v), e);
    }

    /**
     * @internal CLDR
     * @deprecated This API is ICU internal only.
     */
    @Deprecated
    public FixedDecimal(double n, int v) {
        this(n,v,getFractionalDigits(n, v));
    }

    private static int getFractionalDigits(double n, int v) {
        if (v == 0) {
            return 0;
        } else {
            if (n < 0) {
                n = -n;
            }
            int baseFactor = (int) Math.pow(10, v);
            long scaled = Math.round(n * baseFactor);
            return (int) (scaled % baseFactor);
        }
    }

    /**
     * @internal CLDR
     * @deprecated This API is ICU internal only.
     */
    @Deprecated
    public FixedDecimal(double n) {
        this(n, decimals(n));
    }

    /**
     * @internal CLDR
     * @deprecated This API is ICU internal only.
     */
    @Deprecated
    public FixedDecimal(long n) {
        this(n,0);
    }

    private static final long MAX_INTEGER_PART = 1000000000;
    /**
     * Return a guess as to the number of decimals that would be displayed. This is only a guess; callers should
     * always supply the decimals explicitly if possible. Currently, it is up to 6 decimals (without trailing zeros).
     * Returns 0 for infinities and nans.
     * @internal CLDR
     * @deprecated This API is ICU internal only.
     *
     */
    @Deprecated
    public static int decimals(double n) {
        // Ugly...
        if (Double.isInfinite(n) || Double.isNaN(n)) {
            return 0;
        }
        if (n < 0) {
            n = -n;
        }
        if (n == Math.floor(n)) {
            return 0;
        }
        if (n < MAX_INTEGER_PART) {
            long temp = (long)(n * 1000000) % 1000000; // get 6 decimals
            for (int mask = 10, digits = 6; digits > 0; mask *= 10, --digits) {
                if ((temp % mask) != 0) {
                    return digits;
                }
            }
            return 0;
        } else {
            String buf = String.format(Locale.ENGLISH, "%1.15e", n);
            int ePos = buf.lastIndexOf('e');
            int expNumPos = ePos + 1;
            if (buf.charAt(expNumPos) == '+') {
                expNumPos++;
            }
            String exponentStr = buf.substring(expNumPos);
            int exponent = Integer.parseInt(exponentStr);
            int numFractionDigits = ePos - 2 - exponent;
            if (numFractionDigits < 0) {
                return 0;
            }
            for (int i=ePos-1; numFractionDigits > 0; --i) {
                if (buf.charAt(i) != '0') {
                    break;
                }
                --numFractionDigits;
            }
            return numFractionDigits;
        }
    }

    /**
     * @internal CLDR
     * @deprecated This API is ICU internal only
     */
    @Deprecated
    private FixedDecimal (FixedDecimal other) {
        // Ugly, but necessary, because constructors must only call other
        // constructors in the first line of the body, and
        // FixedDecimal(String) was refactored to support exponents.
        this.source = other.source;
        this.visibleDecimalDigitCount = other.visibleDecimalDigitCount;
        this.visibleDecimalDigitCountWithoutTrailingZeros =
            other.visibleDecimalDigitCountWithoutTrailingZeros;
        this.decimalDigits = other.decimalDigits;
        this.decimalDigitsWithoutTrailingZeros =
            other.decimalDigitsWithoutTrailingZeros;
        this.integerValue = other.integerValue;
        this.hasIntegerValue = other.hasIntegerValue;
        this.isNegative = other.isNegative;
        this.exponent = other.exponent;
        this.baseFactor = other.baseFactor;
    }

    /**
     * @internal CLDR
     * @deprecated This API is ICU internal only.
     */
    @Deprecated
    public FixedDecimal (String n) {
        // Ugly, but for samples we don't care.
        this(parseDecimalSampleRangeNumString(n));
    }

//    /**
//     * @internal CLDR
//     * @deprecated This API is ICU internal only
//     */
//    @Deprecated
//    private static FixedDecimal parseDecimalSampleRangeNumString(String num) {
//        if (num.contains("e")) {
//            int ePos = num.lastIndexOf('e');
//            int expNumPos = ePos + 1;
//            String exponentStr = num.substring(expNumPos);
//            int exponent = Integer.parseInt(exponentStr);
//            String fractionStr = num.substring(0, ePos);
//            return FixedDecimal.createWithExponent(
//                    Double.parseDouble(fractionStr),
//                    getVisibleFractionCount(fractionStr),
//                    exponent);
//        } else {
//            return new FixedDecimal(Double.parseDouble(num), getVisibleFractionCount(num));
//        }
//    }

    // The value of n needs to take the exponent into account
    public static FixedDecimal parseDecimalSampleRangeNumString(String num) {
        double n;
        int v;
        int exponent = 0;
        String fractionStr = num; // default
        if (num.contains("e")) {
            int ePos = num.lastIndexOf('e');
            int expNumPos = ePos + 1;
            String exponentStr = num.substring(expNumPos);
            exponent = Integer.parseInt(exponentStr);
            fractionStr = num.substring(0, ePos);

            // now adjust the fraction string according to the exponent
            // not the most efficient, but more reliable code for testing
            if (exponent != 0) {
                int decimalPos = fractionStr.indexOf('.');
                int decimalCount = 0;
                String integerPart = fractionStr;
                String fractionPart = "";
                if (decimalPos >= 0) {
                    decimalCount = fractionStr.length() - decimalPos - 1;
                    integerPart = fractionStr.substring(0,decimalPos);
                    fractionPart = fractionStr.substring(decimalPos+1);
                }

                if (decimalCount == exponent) { // 2.123e3 => 2123
                    fractionStr = integerPart + fractionPart;
                } else if (decimalCount > exponent) {   // 2.1234e3 => 2123.4
                    fractionStr = integerPart + fractionPart.substring(0,exponent) + "." + fractionPart.substring(exponent);
                } else { // decimalCount < exponent //   // 2.1e3 => 2100
                    fractionStr = integerPart + padEnd(fractionPart, exponent, '0');
                }
            }
        }
        n = Double.parseDouble(fractionStr);
        v = getVisibleFractionCount(fractionStr);
        return new FixedDecimal(n, v, getFractionalDigits(n, v), exponent);
    }


    private static String padEnd(String string, int minLength, char c) {
        StringBuilder sb = new StringBuilder(minLength);
        sb.append(string);
        for (int i = string.length(); i < minLength; i++) {
            sb.append(c);
        }
        return sb.toString();
    }

    public static int getVisibleFractionCount(String value) {
        value = value.trim();
        int decimalPos = value.indexOf('.') + 1;
        if (decimalPos == 0) {
            return 0;
        } else {
            return value.length() - decimalPos;
        }
    }

    /**
     * {@inheritDoc}
     *
     * @internal CLDR
     * @deprecated This API is ICU internal only.
     */
    @Override
    @Deprecated
    public double getPluralOperand(Operand operand) {
        switch(operand) {
        case n: return source;
        case i: return integerValue;
        case f: return decimalDigits;
        case t: return decimalDigitsWithoutTrailingZeros;
        case v: return visibleDecimalDigitCount;
        case w: return visibleDecimalDigitCountWithoutTrailingZeros;
        case e: return exponent;
        default: return source;
        }
    }

    /**
     * @internal CLDR
     * @deprecated This API is ICU internal only.
     */
    @Deprecated
    public static Operand getOperand(String t) {
        return Operand.valueOf(t);
    }

    /**
     * We're not going to care about NaN.
     * @internal CLDR
     * @deprecated This API is ICU internal only.
     */
    @Override
    @Deprecated
    public int compareTo(FixedDecimal other) {
        if (exponent != other.exponent) {
            return exponent < other.exponent ? -1 : 1;
        }
        if (integerValue != other.integerValue) {
            return integerValue < other.integerValue ? -1 : 1;
        }
        if (source != other.source) {
            return source < other.source ? -1 : 1;
        }
        if (visibleDecimalDigitCount != other.visibleDecimalDigitCount) {
            return visibleDecimalDigitCount < other.visibleDecimalDigitCount ? -1 : 1;
        }
        long diff = decimalDigits - other.decimalDigits;
        if (diff != 0) {
            return diff < 0 ? -1 : 1;
        }
        return 0;
    }

    /**
     * @internal CLDR
     * @deprecated This API is ICU internal only.
     */
    @Deprecated
    @Override
    public boolean equals(Object arg0) {
        if (arg0 == null) {
            return false;
        }
        if (arg0 == this) {
            return true;
        }
        if (!(arg0 instanceof FixedDecimal)) {
            return false;
        }
        FixedDecimal other = (FixedDecimal)arg0;
        return source == other.source && visibleDecimalDigitCount == other.visibleDecimalDigitCount && decimalDigits == other.decimalDigits
            && exponent == other.exponent;
    }

    /**
     * @internal CLDR
     * @deprecated This API is ICU internal only.
     */
    @Deprecated
    @Override
    public int hashCode() {
        // TODO Auto-generated method stub
        return (int)(decimalDigits + 37 * (visibleDecimalDigitCount + (int)(37 * source)));
    }

    public static String toSampleString(IFixedDecimal source) {
        final double n = source.getPluralOperand(Operand.n);
        final int exponent = (int) source.getPluralOperand(Operand.e);
        final int visibleDecimalDigitCount = (int) source.getPluralOperand(Operand.v);
        if (exponent == 0) {
            return String.format(Locale.ROOT, "%." + visibleDecimalDigitCount + "f", n);
        } else {
            // we need to slide the exponent back

            int fixedV = visibleDecimalDigitCount + exponent;
            String baseString = String.format(Locale.ROOT, "%." + fixedV + "f",n/Math.pow(10,exponent));

            // HACK
            // However, we don't have enough information to round-trip if v == 0
            // So in that case we choose the shortest form,
            // so we have to have a hack to strip trailing fraction spaces.
            if (visibleDecimalDigitCount == 0) {
                for (int i = visibleDecimalDigitCount; i < fixedV; ++i) {
                    // TODO this code could and should be optimized, but for now...
                    if (baseString.endsWith("0")) {
                        baseString = baseString.substring(0,baseString.length()-1);
                        continue;
                    }
                    break;
                }
                if (baseString.endsWith(".")) {
                    baseString = baseString.substring(0,baseString.length()-1);
                }
            }
            return baseString + "e" + exponent;
        }
    }

    /**
     * @internal CLDR
     * @deprecated This API is ICU internal only.
     */
    @Deprecated
    @Override
    public String toString() {
        return toSampleString(this);
//        if (exponent == 0) {
//            return String.format(Locale.ROOT, "%." + visibleDecimalDigitCount + "f", source);
//        } else {
//            // we need to slide the exponent back
//
//            int fixedV = visibleDecimalDigitCount + exponent;
//            String baseString = String.format(Locale.ROOT, "%." + fixedV + "f", getSource()/Math.pow(10,exponent));
//
//            // However, we don't have enough information to round-trip if v == 0
//            // So in that case we choose the shortest form,
//            // so we have to have a hack to strip trailing fraction spaces.
//            if (visibleDecimalDigitCount == 0) {
//                for (int i = visibleDecimalDigitCount; i < fixedV; ++i) {
//                    // TODO this code could and should be optimized, but for now...
//                    if (baseString.endsWith("0")) {
//                        baseString = baseString.substring(0,baseString.length()-1);
//                        continue;
//                    }
//                    break;
//                }
//                if (baseString.endsWith(".")) {
//                    baseString = baseString.substring(0,baseString.length()-1);
//                }
//            }
//
//            return baseString + "e" + exponent;
//        }
    }

//    // FixedDecimal.toString isn't working right.
//    public String xtoString() {
//        // we need to slide v up
//        final int v = getVisibleDecimalDigitCount();
//        final int exponent = getExponent();
//        if (exponent == 0) {
//            return String.format(Locale.ROOT, "%." + v + "f", getSource());
//        }
//        int fixedV = v + exponent;
//        String baseString = String.format(Locale.ROOT, "%." + fixedV + "f", getSource()/Math.pow(10,exponent));
//        // however, the format does not round trip.
//        // so we have to have a hack to strip trailing fraction spaces.
//        for (int i = v; i < fixedV; ++i) {
//            // TODO this code could and should be optimized, but for now...
//            if (baseString.endsWith("0")) {
//                baseString = baseString.substring(0,baseString.length()-1);
//                continue;
//            }
//            break;
//        }
//        if (baseString.endsWith(".")) {
//            baseString = baseString.substring(0,baseString.length()-1);
//        }
//        return baseString + "e" + exponent;
//    }

    /**
     * @internal CLDR
     * @deprecated This API is ICU internal only.
     */
    @Deprecated
    public boolean hasIntegerValue() {
        return hasIntegerValue;
    }

    /**
     * @internal CLDR
     * @deprecated This API is ICU internal only.
     */
    @Deprecated
    @Override
    public int intValue() {
        // TODO Auto-generated method stub
        return (int) longValue();
    }

    /**
     * @internal CLDR
     * @deprecated This API is ICU internal only.
     */
    @Deprecated
    @Override
    public long longValue() {
        if (exponent == 0) {
            return integerValue;
        } else {
            return (long) (Math.pow(10, exponent) * integerValue);
        }
    }

    /**
     * @internal CLDR
     * @deprecated This API is ICU internal only.
     */
    @Deprecated
    @Override
    public float floatValue() {
        return (float) (source * Math.pow(10, exponent));
    }

    /**
     * @internal CLDR
     * @deprecated This API is ICU internal only.
     */
    @Deprecated
    @Override
    public double doubleValue() {
        return (isNegative ? -source : source);
    }

    /**
     * @internal CLDR
     * @deprecated This API is ICU internal only.
     */
    @Deprecated
    public long getShiftedValue() {
        return integerValue * baseFactor + decimalDigits;
    }

    private void writeObject(
        ObjectOutputStream out)
            throws IOException {
        throw new NotSerializableException();
    }

    private void readObject(ObjectInputStream in
        ) throws IOException, ClassNotFoundException {
        throw new NotSerializableException();
    }

    /**
     * {@inheritDoc}
     *
     * @internal CLDR
     * @deprecated This API is ICU internal only.
     */
    @Deprecated
    @Override
    public boolean isNaN() {
        return Double.isNaN(source);
    }

    /**
     * {@inheritDoc}
     *
     * @internal CLDR
     * @deprecated This API is ICU internal only.
     */
    @Deprecated
    @Override
    public boolean isInfinite() {
        return Double.isInfinite(source);
    }

    // would be convenient to have getExponent, like the other methods
    public int getExponent() {
        return exponent;
    }

}