/*
 * Copyright (C) 2016 The Android Open Source Project
 *
 * Licensed 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.
 */

package com.android.calculator2;

import android.annotation.TargetApi;
import android.content.ClipData;
import android.content.ClipDescription;
import android.content.ClipboardManager;
import android.content.Context;
import android.graphics.Rect;
import android.os.Build;
import androidx.annotation.IntDef;
import androidx.core.content.ContextCompat;
import androidx.core.os.BuildCompat;
import android.text.Layout;
import android.text.Spannable;
import android.text.SpannableString;
import android.text.Spanned;
import android.text.TextPaint;
import android.text.style.BackgroundColorSpan;
import android.text.style.ForegroundColorSpan;
import android.text.style.RelativeSizeSpan;
import android.util.AttributeSet;
import android.view.ActionMode;
import android.view.ContextMenu;
import android.view.GestureDetector;
import android.view.Menu;
import android.view.MenuInflater;
import android.view.MenuItem;
import android.view.MotionEvent;
import android.view.View;
import android.view.ViewConfiguration;
import android.widget.OverScroller;
import android.widget.Toast;

import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;

// A text widget that is "infinitely" scrollable to the right,
// and obtains the text to display via a callback to Logic.
public class CalculatorResult extends AlignedTextView implements MenuItem.OnMenuItemClickListener,
        Evaluator.EvaluationListener, Evaluator.CharMetricsInfo {
    static final int MAX_RIGHT_SCROLL = 10000000;
    static final int INVALID = MAX_RIGHT_SCROLL + 10000;
        // A larger value is unlikely to avoid running out of space
    final OverScroller mScroller;
    final GestureDetector mGestureDetector;
    private long mIndex;  // Index of expression we are displaying.
    private Evaluator mEvaluator;
    private boolean mScrollable = false;
                            // A scrollable result is currently displayed.
    private boolean mValid = false;
                            // The result holds a valid number (not an error message).
    // A suffix of "Pos" denotes a pixel offset.  Zero represents a scroll position
    // in which the decimal point is just barely visible on the right of the display.
    private int mCurrentPos;// Position of right of display relative to decimal point, in pixels.
                            // Large positive values mean the decimal point is scrolled off the
                            // left of the display.  Zero means decimal point is barely displayed
                            // on the right.
    private int mLastPos;   // Position already reflected in display. Pixels.
    private int mMinPos;    // Minimum position to avoid unnecessary blanks on the left. Pixels.
    private int mMaxPos;    // Maximum position before we start displaying the infinite
                            // sequence of trailing zeroes on the right. Pixels.
    private int mWholeLen;  // Length of the whole part of current result.
    // In the following, we use a suffix of Offset to denote a character position in a numeric
    // string relative to the decimal point.  Positive is to the right and negative is to
    // the left. 1 = tenths position, -1 = units.  Integer.MAX_VALUE is sometimes used
    // for the offset of the last digit in an a nonterminating decimal expansion.
    // We use the suffix "Index" to denote a zero-based index into a string representing a
    // result.
    private int mMaxCharOffset;  // Character offset from decimal point of rightmost digit
                                 // that should be displayed, plus the length of any exponent
                                 // needed to display that digit.
                                 // Limited to MAX_RIGHT_SCROLL. Often the same as:
    private int mLsdOffset;      // Position of least-significant digit in result
    private int mLastDisplayedOffset; // Offset of last digit actually displayed after adding
                                      // exponent.
    private boolean mWholePartFits;  // Scientific notation not needed for initial display.
    private float mNoExponentCredit;
                            // Fraction of digit width saved by avoiding scientific notation.
                            // Only accessed from UI thread.
    private boolean mAppendExponent;
                            // The result fits entirely in the display, even with an exponent,
                            // but not with grouping separators. Since the result is not
                            // scrollable, and we do not add the exponent to max. scroll position,
                            // append an exponent insteadd of replacing trailing digits.
    private final Object mWidthLock = new Object();
                            // Protects the next five fields.  These fields are only
                            // updated by the UI thread, and read accesses by the UI thread
                            // sometimes do not acquire the lock.
    private int mWidthConstraint = 0;
                            // Our total width in pixels minus space for ellipsis.
                            // 0 ==> uninitialized.
    private float mCharWidth = 1;
                            // Maximum character width. For now we pretend that all characters
                            // have this width.
                            // TODO: We're not really using a fixed width font.  But it appears
                            // to be close enough for the characters we use that the difference
                            // is not noticeable.
    private float mGroupingSeparatorWidthRatio;
                            // Fraction of digit width occupied by a digit separator.
    private float mDecimalCredit;
                            // Fraction of digit width saved by replacing digit with decimal point.
    private float mNoEllipsisCredit;
                            // Fraction of digit width saved by both replacing ellipsis with digit
                            // and avoiding scientific notation.
    @Retention(RetentionPolicy.SOURCE)
    @IntDef({SHOULD_REQUIRE, SHOULD_EVALUATE, SHOULD_NOT_EVALUATE})
    public @interface EvaluationRequest {}
    public static final int SHOULD_REQUIRE = 2;
    public static final int SHOULD_EVALUATE = 1;
    public static final int SHOULD_NOT_EVALUATE = 0;
    @EvaluationRequest private int mEvaluationRequest = SHOULD_REQUIRE;
                            // Should we evaluate when layout completes, and how?
    private Evaluator.EvaluationListener mEvaluationListener = this;
                            // Listener to use if/when evaluation is requested.
    public static final int MAX_LEADING_ZEROES = 6;
                            // Maximum number of leading zeroes after decimal point before we
                            // switch to scientific notation with negative exponent.
    public static final int MAX_TRAILING_ZEROES = 6;
                            // Maximum number of trailing zeroes before the decimal point before
                            // we switch to scientific notation with positive exponent.
    private static final int SCI_NOTATION_EXTRA = 1;
                            // Extra digits for standard scientific notation.  In this case we
                            // have a decimal point and no ellipsis.
                            // We assume that we do not drop digits to make room for the decimal
                            // point in ordinary scientific notation. Thus >= 1.
    private static final int MAX_COPY_EXTRA = 100;
                            // The number of extra digits we are willing to compute to copy
                            // a result as an exact number.
    private static final int MAX_RECOMPUTE_DIGITS = 2000;
                            // The maximum number of digits we're willing to recompute in the UI
                            // thread.  We only do this for known rational results, where we
                            // can bound the computation cost.
    private final ForegroundColorSpan mExponentColorSpan;
    private final BackgroundColorSpan mHighlightSpan;

    private ActionMode mActionMode;
    private ActionMode.Callback mCopyActionModeCallback;
    private ContextMenu mContextMenu;

    // The user requested that the result currently being evaluated should be stored to "memory".
    private boolean mStoreToMemoryRequested = false;

    public CalculatorResult(Context context, AttributeSet attrs) {
        super(context, attrs);
        mScroller = new OverScroller(context);
        mHighlightSpan = new BackgroundColorSpan(getHighlightColor());
        mExponentColorSpan = new ForegroundColorSpan(
                ContextCompat.getColor(context, R.color.display_result_exponent_text_color));
        mGestureDetector = new GestureDetector(context,
            new GestureDetector.SimpleOnGestureListener() {
                @Override
                public boolean onDown(MotionEvent e) {
                    return true;
                }
                @Override
                public boolean onFling(MotionEvent e1, MotionEvent e2, float velocityX,
                        float velocityY) {
                    if (!mScroller.isFinished()) {
                        mCurrentPos = mScroller.getFinalX();
                    }
                    mScroller.forceFinished(true);
                    stopActionModeOrContextMenu();
                    CalculatorResult.this.cancelLongPress();
                    // Ignore scrolls of error string, etc.
                    if (!mScrollable) return true;
                    mScroller.fling(mCurrentPos, 0, - (int) velocityX, 0  /* horizontal only */,
                                    mMinPos, mMaxPos, 0, 0);
                    postInvalidateOnAnimation();
                    return true;
                }
                @Override
                public boolean onScroll(MotionEvent e1, MotionEvent e2, float distanceX,
                        float distanceY) {
                    int distance = (int)distanceX;
                    if (!mScroller.isFinished()) {
                        mCurrentPos = mScroller.getFinalX();
                    }
                    mScroller.forceFinished(true);
                    stopActionModeOrContextMenu();
                    CalculatorResult.this.cancelLongPress();
                    if (!mScrollable) return true;
                    if (mCurrentPos + distance < mMinPos) {
                        distance = mMinPos - mCurrentPos;
                    } else if (mCurrentPos + distance > mMaxPos) {
                        distance = mMaxPos - mCurrentPos;
                    }
                    int duration = (int)(e2.getEventTime() - e1.getEventTime());
                    if (duration < 1 || duration > 100) duration = 10;
                    mScroller.startScroll(mCurrentPos, 0, distance, 0, (int)duration);
                    postInvalidateOnAnimation();
                    return true;
                }
                @Override
                public void onLongPress(MotionEvent e) {
                    if (mValid) {
                        performLongClick();
                    }
                }
            });

        final int slop = ViewConfiguration.get(context).getScaledTouchSlop();
        setOnTouchListener(new View.OnTouchListener() {

            // Used to determine whether a touch event should be intercepted.
            private float mInitialDownX;
            private float mInitialDownY;

            @Override
            public boolean onTouch(View v, MotionEvent event) {
                final int action = event.getActionMasked();

                final float x = event.getX();
                final float y = event.getY();
                switch (action) {
                    case MotionEvent.ACTION_DOWN:
                        mInitialDownX = x;
                        mInitialDownY = y;
                        break;
                    case MotionEvent.ACTION_MOVE:
                        final float deltaX = Math.abs(x - mInitialDownX);
                        final float deltaY = Math.abs(y - mInitialDownY);
                        if (deltaX > slop && deltaX > deltaY) {
                            // Prevent the DragLayout from intercepting horizontal scrolls.
                            getParent().requestDisallowInterceptTouchEvent(true);
                        }
                }
                return mGestureDetector.onTouchEvent(event);
            }
        });

        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M) {
            setupActionMode();
        } else {
            setupContextMenu();
        }

        setCursorVisible(false);
        setLongClickable(false);
        setContentDescription(context.getString(R.string.desc_result));
    }

    void setEvaluator(Evaluator evaluator, long index) {
        mEvaluator = evaluator;
        mIndex = index;
        requestLayout();
    }

    // Compute maximum digit width the hard way.
    private static float getMaxDigitWidth(TextPaint paint) {
        // Compute the maximum advance width for each digit, thus accounting for between-character
        // spaces. If we ever support other kinds of digits, we may have to avoid kerning effects
        // that could reduce the advance width within this particular string.
        final String allDigits = "0123456789";
        final float[] widths = new float[allDigits.length()];
        paint.getTextWidths(allDigits, widths);
        float maxWidth = 0;
        for (float x : widths) {
            maxWidth = Math.max(x, maxWidth);
        }
        return maxWidth;
    }

    @Override
    protected void onMeasure(int widthMeasureSpec, int heightMeasureSpec) {
        if (!isLaidOut()) {
            super.onMeasure(widthMeasureSpec, heightMeasureSpec);
            // Set a minimum height so scaled error messages won't affect our layout.
            setMinimumHeight(getLineHeight() + getCompoundPaddingBottom()
                    + getCompoundPaddingTop());
        }

        final TextPaint paint = getPaint();
        final Context context = getContext();
        final float newCharWidth = getMaxDigitWidth(paint);
        // Digits are presumed to have no more than newCharWidth.
        // There are two instances when we know that the result is otherwise narrower than
        // expected:
        // 1. For standard scientific notation (our type 1), we know that we have a norrow decimal
        // point and no (usually wide) ellipsis symbol. We allow one extra digit
        // (SCI_NOTATION_EXTRA) to compensate, and consider that in determining available width.
        // 2. If we are using digit grouping separators and a decimal point, we give ourselves
        // a fractional extra space for those separators, the value of which depends on whether
        // there is also an ellipsis.
        //
        // Maximum extra space we need in various cases:
        // Type 1 scientific notation, assuming ellipsis, minus sign and E are wider than a digit:
        //    Two minus signs + "E" + "." - 3 digits.
        // Type 2 scientific notation:
        //    Ellipsis + "E" + "-" - 3 digits.
        // In the absence of scientific notation, we may need a little less space.
        // We give ourselves a bit of extra credit towards comma insertion and give
        // ourselves more if we have either
        //    No ellipsis, or
        //    A decimal separator.

        // Calculate extra space we need to reserve, in addition to character count.
        final float decimalSeparatorWidth = Layout.getDesiredWidth(
                context.getString(R.string.dec_point), paint);
        final float minusWidth = Layout.getDesiredWidth(context.getString(R.string.op_sub), paint);
        final float minusExtraWidth = Math.max(minusWidth - newCharWidth, 0.0f);
        final float ellipsisWidth = Layout.getDesiredWidth(KeyMaps.ELLIPSIS, paint);
        final float ellipsisExtraWidth =  Math.max(ellipsisWidth - newCharWidth, 0.0f);
        final float expWidth = Layout.getDesiredWidth(KeyMaps.translateResult("e"), paint);
        final float expExtraWidth =  Math.max(expWidth - newCharWidth, 0.0f);
        final float type1Extra = 2 * minusExtraWidth + expExtraWidth + decimalSeparatorWidth;
        final float type2Extra = ellipsisExtraWidth + expExtraWidth + minusExtraWidth;
        final float extraWidth = Math.max(type1Extra, type2Extra);
        final int intExtraWidth = (int) Math.ceil(extraWidth) + 1 /* to cover rounding sins */;
        final int newWidthConstraint = MeasureSpec.getSize(widthMeasureSpec)
                - (getPaddingLeft() + getPaddingRight()) - intExtraWidth;

        // Calculate other width constants we need to handle grouping separators.
        final float groupingSeparatorW =
                Layout.getDesiredWidth(KeyMaps.translateResult(","), paint);
        // Credits in the absence of any scientific notation:
        float noExponentCredit = extraWidth - Math.max(ellipsisExtraWidth, minusExtraWidth);
        final float noEllipsisCredit = extraWidth - minusExtraWidth;  // includes noExponentCredit.
        final float decimalCredit = Math.max(newCharWidth - decimalSeparatorWidth, 0.0f);

        mNoExponentCredit = noExponentCredit / newCharWidth;
        synchronized(mWidthLock) {
            mWidthConstraint = newWidthConstraint;
            mCharWidth = newCharWidth;
            mNoEllipsisCredit = noEllipsisCredit / newCharWidth;
            mDecimalCredit = decimalCredit / newCharWidth;
            mGroupingSeparatorWidthRatio = groupingSeparatorW / newCharWidth;
        }

        super.onMeasure(widthMeasureSpec, heightMeasureSpec);
    }

    @Override
    protected void onLayout(boolean changed, int left, int top, int right, int bottom) {
        super.onLayout(changed, left, top, right, bottom);

        if (mEvaluator != null && mEvaluationRequest != SHOULD_NOT_EVALUATE) {
            final CalculatorExpr expr = mEvaluator.getExpr(mIndex);
            if (expr != null && expr.hasInterestingOps()) {
                if (mEvaluationRequest == SHOULD_REQUIRE) {
                    mEvaluator.requireResult(mIndex, mEvaluationListener, this);
                } else {
                    mEvaluator.evaluateAndNotify(mIndex, mEvaluationListener, this);
                }
            }
        }
    }

    /**
     * Specify whether we should evaluate result on layout.
     * @param should one of SHOULD_REQUIRE, SHOULD_EVALUATE, SHOULD_NOT_EVALUATE
     */
    public void setShouldEvaluateResult(@EvaluationRequest int request,
            Evaluator.EvaluationListener listener) {
        mEvaluationListener = listener;
        mEvaluationRequest = request;
    }

    // From Evaluator.CharMetricsInfo.
    @Override
    public float separatorChars(String s, int len) {
        int start = 0;
        while (start < len && !Character.isDigit(s.charAt(start))) {
            ++start;
        }
        // We assume the rest consists of digits, and for consistency with the rest
        // of the code, we assume all digits have width mCharWidth.
        final int nDigits = len - start;
        // We currently insert a digit separator every three digits.
        final int nSeparators = (nDigits - 1) / 3;
        synchronized(mWidthLock) {
            // Always return an upper bound, even in the presence of rounding errors.
            return nSeparators * mGroupingSeparatorWidthRatio;
        }
    }

    // From Evaluator.CharMetricsInfo.
    @Override
    public float getNoEllipsisCredit() {
        synchronized(mWidthLock) {
            return mNoEllipsisCredit;
        }
    }

    // From Evaluator.CharMetricsInfo.
    @Override
    public float getDecimalCredit() {
        synchronized(mWidthLock) {
            return mDecimalCredit;
        }
    }

    // Return the length of the exponent representation for the given exponent, in
    // characters.
    private final int expLen(int exp) {
        if (exp == 0) return 0;
        final int abs_exp_digits = (int) Math.ceil(Math.log10(Math.abs((double)exp))
                + 0.0000000001d /* Round whole numbers to next integer */);
        return abs_exp_digits + (exp >= 0 ? 1 : 2);
    }

    /**
     * Initiate display of a new result.
     * Only called from UI thread.
     * The parameters specify various properties of the result.
     * @param index Index of expression that was just evaluated. Currently ignored, since we only
     *            expect notification for the expression result being displayed.
     * @param initPrec Initial display precision computed by evaluator. (1 = tenths digit)
     * @param msd Position of most significant digit.  Offset from left of string.
                  Evaluator.INVALID_MSD if unknown.
     * @param leastDigPos Position of least significant digit (1 = tenths digit)
     *                    or Integer.MAX_VALUE.
     * @param truncatedWholePart Result up to but not including decimal point.
                                 Currently we only use the length.
     */
    @Override
    public void onEvaluate(long index, int initPrec, int msd, int leastDigPos,
            String truncatedWholePart) {
        initPositions(initPrec, msd, leastDigPos, truncatedWholePart);

        if (mStoreToMemoryRequested) {
            mEvaluator.copyToMemory(index);
            mStoreToMemoryRequested = false;
        }
        redisplay();
    }

    /**
     * Store the result for this index if it is available.
     * If it is unavailable, set mStoreToMemoryRequested to indicate that we should store
     * when evaluation is complete.
     */
    public void onMemoryStore() {
        if (mEvaluator.hasResult(mIndex)) {
            mEvaluator.copyToMemory(mIndex);
        } else {
            mStoreToMemoryRequested = true;
            mEvaluator.requireResult(mIndex, this /* listener */, this /* CharMetricsInfo */);
        }
    }

    /**
     * Add the result to the value currently in memory.
     */
    public void onMemoryAdd() {
        mEvaluator.addToMemory(mIndex);
    }

    /**
     * Subtract the result from the value currently in memory.
     */
    public void onMemorySubtract() {
        mEvaluator.subtractFromMemory(mIndex);
    }

    /**
     * Set up scroll bounds (mMinPos, mMaxPos, etc.) and determine whether the result is
     * scrollable, based on the supplied information about the result.
     * This is unfortunately complicated because we need to predict whether trailing digits
     * will eventually be replaced by an exponent.
     * Just appending the exponent during formatting would be simpler, but would produce
     * jumpier results during transitions.
     * Only called from UI thread.
     */
    private void initPositions(int initPrecOffset, int msdIndex, int lsdOffset,
            String truncatedWholePart) {
        int maxChars = getMaxChars();
        mWholeLen = truncatedWholePart.length();
        // Allow a tiny amount of slop for associativity/rounding differences in length
        // calculation.  If getPreferredPrec() decided it should fit, we want to make it fit, too.
        // We reserved one extra pixel, so the extra length is OK.
        final int nSeparatorChars = (int) Math.ceil(
                separatorChars(truncatedWholePart, truncatedWholePart.length())
                - getNoEllipsisCredit() - 0.0001f);
        mWholePartFits = mWholeLen + nSeparatorChars <= maxChars;
        mLastPos = INVALID;
        mLsdOffset = lsdOffset;
        mAppendExponent = false;
        // Prevent scrolling past initial position, which is calculated to show leading digits.
        mCurrentPos = mMinPos = (int) Math.round(initPrecOffset * mCharWidth);
        if (msdIndex == Evaluator.INVALID_MSD) {
            // Possible zero value
            if (lsdOffset == Integer.MIN_VALUE) {
                // Definite zero value.
                mMaxPos = mMinPos;
                mMaxCharOffset = (int) Math.round(mMaxPos/mCharWidth);
                mScrollable = false;
            } else {
                // May be very small nonzero value.  Allow user to find out.
                mMaxPos = mMaxCharOffset = MAX_RIGHT_SCROLL;
                mMinPos -= mCharWidth;  // Allow for future minus sign.
                mScrollable = true;
            }
            return;
        }
        int negative = truncatedWholePart.charAt(0) == '-' ? 1 : 0;
        if (msdIndex > mWholeLen && msdIndex <= mWholeLen + 3) {
            // Avoid tiny negative exponent; pretend msdIndex is just to the right of decimal point.
            msdIndex = mWholeLen - 1;
        }
        // Set to position of leftmost significant digit relative to dec. point. Usually negative.
        int minCharOffset = msdIndex - mWholeLen;
        if (minCharOffset > -1 && minCharOffset < MAX_LEADING_ZEROES + 2) {
            // Small number of leading zeroes, avoid scientific notation.
            minCharOffset = -1;
        }
        if (lsdOffset < MAX_RIGHT_SCROLL) {
            mMaxCharOffset = lsdOffset;
            if (mMaxCharOffset < -1 && mMaxCharOffset > -(MAX_TRAILING_ZEROES + 2)) {
                mMaxCharOffset = -1;
            }
            // lsdOffset is positive or negative, never 0.
            int currentExpLen = 0;  // Length of required standard scientific notation exponent.
            if (mMaxCharOffset < -1) {
                currentExpLen = expLen(-minCharOffset - 1);
            } else if (minCharOffset > -1 || mMaxCharOffset >= maxChars) {
                // Number is either entirely to the right of decimal point, or decimal point is
                // not visible when scrolled to the right.
                currentExpLen = expLen(-minCharOffset);
            }
            // Exponent length does not included added decimal point.  But whenever we add a
            // decimal point, we allow an extra character (SCI_NOTATION_EXTRA).
            final int separatorLength = mWholePartFits && minCharOffset < -3 ? nSeparatorChars : 0;
            mScrollable = (mMaxCharOffset + currentExpLen + separatorLength - minCharOffset
                    + negative >= maxChars);
            // Now adjust mMaxCharOffset for any required exponent.
            int newMaxCharOffset;
            if (currentExpLen > 0) {
                if (mScrollable) {
                    // We'll use exponent corresponding to leastDigPos when scrolled to right.
                    newMaxCharOffset = mMaxCharOffset + expLen(-lsdOffset);
                } else {
                    newMaxCharOffset = mMaxCharOffset + currentExpLen;
                }
                if (mMaxCharOffset <= -1 && newMaxCharOffset > -1) {
                    // Very unlikely; just drop exponent.
                    mMaxCharOffset = -1;
                } else {
                    mMaxCharOffset = Math.min(newMaxCharOffset, MAX_RIGHT_SCROLL);
                }
                mMaxPos = Math.min((int) Math.round(mMaxCharOffset * mCharWidth),
                        MAX_RIGHT_SCROLL);
            } else if (!mWholePartFits && !mScrollable) {
                // Corner case in which entire number fits, but not with grouping separators.  We
                // will use an exponent in un-scrolled position, which may hide digits.  Scrolling
                // by one character will remove the exponent and reveal the last digits.  Note
                // that in the forced scientific notation case, the exponent length is not
                // factored into mMaxCharOffset, since we do not want such an increase to impact
                // scrolling behavior.  In the unscrollable case, we thus have to append the
                // exponent at the end using the forcePrecision argument to formatResult, in order
                // to ensure that we get the entire result.
                mScrollable = (mMaxCharOffset + expLen(-minCharOffset - 1) - minCharOffset
                        + negative >= maxChars);
                if (mScrollable) {
                    mMaxPos = (int) Math.ceil(mMinPos + mCharWidth);
                    // Single character scroll will remove exponent and show remaining piece.
                } else {
                    mMaxPos = mMinPos;
                    mAppendExponent = true;
                }
            } else {
                mMaxPos = Math.min((int) Math.round(mMaxCharOffset * mCharWidth),
                        MAX_RIGHT_SCROLL);
            }
            if (!mScrollable) {
                // Position the number consistently with our assumptions to make sure it
                // actually fits.
                mCurrentPos = mMaxPos;
            }
        } else {
            mMaxPos = mMaxCharOffset = MAX_RIGHT_SCROLL;
            mScrollable = true;
        }
    }

    /**
     * Display error message indicated by resourceId.
     * UI thread only.
     */
    @Override
    public void onError(long index, int resourceId) {
        mStoreToMemoryRequested = false;
        mValid = false;
        setLongClickable(false);
        mScrollable = false;
        final String msg = getContext().getString(resourceId);
        final float measuredWidth = Layout.getDesiredWidth(msg, getPaint());
        if (measuredWidth > mWidthConstraint) {
            // Multiply by .99 to avoid rounding effects.
            final float scaleFactor = 0.99f * mWidthConstraint / measuredWidth;
            final RelativeSizeSpan smallTextSpan = new RelativeSizeSpan(scaleFactor);
            final SpannableString scaledMsg = new SpannableString(msg);
            scaledMsg.setSpan(smallTextSpan, 0, msg.length(), Spanned.SPAN_EXCLUSIVE_EXCLUSIVE);
            setText(scaledMsg);
        } else {
            setText(msg);
        }
    }

    private final int MAX_COPY_SIZE = 1000000;

    /*
     * Return the most significant digit position in the given string or Evaluator.INVALID_MSD.
     * Unlike Evaluator.getMsdIndexOf, we treat a final 1 as significant.
     * Pure function; callable from anywhere.
     */
    public static int getNaiveMsdIndexOf(String s) {
        final int len = s.length();
        for (int i = 0; i < len; ++i) {
            char c = s.charAt(i);
            if (c != '-' && c != '.' && c != '0') {
                return i;
            }
        }
        return Evaluator.INVALID_MSD;
    }

    /**
     * Format a result returned by Evaluator.getString() into a single line containing ellipses
     * (if appropriate) and an exponent (if appropriate).
     * We add two distinct kinds of exponents:
     * (1) If the final result contains the leading digit we use standard scientific notation.
     * (2) If not, we add an exponent corresponding to an interpretation of the final result as
     *     an integer.
     * We add an ellipsis on the left if the result was truncated.
     * We add ellipses and exponents in a way that leaves most digits in the position they
     * would have been in had we not done so. This minimizes jumps as a result of scrolling.
     * Result is NOT internationalized, uses "E" for exponent.
     * Called only from UI thread; We sometimes omit locking for fields.
     * @param precOffset The value that was passed to getString. Identifies the significance of
                the rightmost digit. A value of 1 means the rightmost digits corresponds to tenths.
     * @param maxDigs The maximum number of characters in the result
     * @param truncated The in parameter was already truncated, beyond possibly removing the
                minus sign.
     * @param negative The in parameter represents a negative result. (Minus sign may be removed
                without setting truncated.)
     * @param lastDisplayedOffset  If not null, we set lastDisplayedOffset[0] to the offset of
                the last digit actually appearing in the display.
     * @param forcePrecision If true, we make sure that the last displayed digit corresponds to
                precOffset, and allow maxDigs to be exceeded in adding the exponent and commas.
     * @param forceSciNotation Force scientific notation. May be set because we don't have
                space for grouping separators, but whole number otherwise fits.
     * @param insertCommas Insert commas (literally, not internationalized) as digit separators.
                We only ever do this for the integral part of a number, and only when no
                exponent is displayed in the initial position. The combination of which means
                that we only do it when no exponent is displayed.
                We insert commas in a way that does consider the width of the actual localized digit
                separator. Commas count towards maxDigs as the appropriate fraction of a digit.
     */
    private String formatResult(String in, int precOffset, int maxDigs, boolean truncated,
            boolean negative, int lastDisplayedOffset[], boolean forcePrecision,
            boolean forceSciNotation, boolean insertCommas) {
        final int minusSpace = negative ? 1 : 0;
        final int msdIndex = truncated ? -1 : getNaiveMsdIndexOf(in);  // INVALID_MSD is OK.
        String result = in;
        boolean needEllipsis = false;
        if (truncated || (negative && result.charAt(0) != '-')) {
            needEllipsis = true;
            result = KeyMaps.ELLIPSIS + result.substring(1, result.length());
            // Ellipsis may be removed again in the type(1) scientific notation case.
        }
        final int decIndex = result.indexOf('.');
        if (lastDisplayedOffset != null) {
            lastDisplayedOffset[0] = precOffset;
        }
        if (forceSciNotation || (decIndex == -1 || msdIndex != Evaluator.INVALID_MSD
                && msdIndex - decIndex > MAX_LEADING_ZEROES + 1) &&  precOffset != -1) {
            // Either:
            // 1) No decimal point displayed, and it's not just to the right of the last digit, or
            // 2) we are at the front of a number whos integral part is too large to allow
            // comma insertion, or
            // 3) we should suppress leading zeroes.
            // Add an exponent to let the user track which digits are currently displayed.
            // Start with type (2) exponent if we dropped no digits. -1 accounts for decimal point.
            // We currently never show digit separators together with an exponent.
            final int initExponent = precOffset > 0 ? -precOffset : -precOffset - 1;
            int exponent = initExponent;
            boolean hasPoint = false;
            if (!truncated && msdIndex < maxDigs - 1
                    && result.length() - msdIndex + 1 + minusSpace
                    <= maxDigs + SCI_NOTATION_EXTRA) {
                // Type (1) exponent computation and transformation:
                // Leading digit is in display window. Use standard calculator scientific notation
                // with one digit to the left of the decimal point. Insert decimal point and
                // delete leading zeroes.
                // We try to keep leading digits roughly in position, and never
                // lengthen the result by more than SCI_NOTATION_EXTRA.
                if (decIndex > msdIndex) {
                    // In the forceSciNotation, we can have a decimal point in the relevant digit
                    // range. Remove it.
                    result = result.substring(0, decIndex)
                            + result.substring(decIndex + 1, result.length());
                    // msdIndex and precOffset unaffected.
                }
                final int resLen = result.length();
                String fraction = result.substring(msdIndex + 1, resLen);
                result = (negative ? "-" : "") + result.substring(msdIndex, msdIndex + 1)
                        + "." + fraction;
                // Original exp was correct for decimal point at right of fraction.
                // Adjust by length of fraction.
                exponent = initExponent + resLen - msdIndex - 1;
                hasPoint = true;
            }
            // Exponent can't be zero.
            // Actually add the exponent of either type:
            if (!forcePrecision) {
                int dropDigits;  // Digits to drop to make room for exponent.
                if (hasPoint) {
                    // Type (1) exponent.
                    // Drop digits even if there is room. Otherwise the scrolling gets jumpy.
                    dropDigits = expLen(exponent);
                    if (dropDigits >= result.length() - 1) {
                        // Jumpy is better than no mantissa.  Probably impossible anyway.
                        dropDigits = Math.max(result.length() - 2, 0);
                    }
                } else {
                    // Type (2) exponent.
                    // Exponent depends on the number of digits we drop, which depends on
                    // exponent ...
                    for (dropDigits = 2; expLen(initExponent + dropDigits) > dropDigits;
                            ++dropDigits) {}
                    exponent = initExponent + dropDigits;
                    if (precOffset - dropDigits > mLsdOffset) {
                        // This can happen if e.g. result = 10^40 + 10^10
                        // It turns out we would otherwise display ...10e9 because it takes
                        // the same amount of space as ...1e10 but shows one more digit.
                        // But we don't want to display a trailing zero, even if it's free.
                        ++dropDigits;
                        ++exponent;
                    }
                }
                if (dropDigits >= result.length() - 1) {
                    // Display too small to show meaningful result.
                    return KeyMaps.ELLIPSIS + "E" + KeyMaps.ELLIPSIS;
                }
                result = result.substring(0, result.length() - dropDigits);
                if (lastDisplayedOffset != null) {
                    lastDisplayedOffset[0] -= dropDigits;
                }
            }
            result = result + "E" + Integer.toString(exponent);
        } else if (insertCommas) {
            // Add commas to the whole number section, and then truncate on left to fit,
            // counting commas as a fractional digit.
            final int wholeStart = needEllipsis ? 1 : 0;
            int orig_length = result.length();
            final float nCommaChars;
            if (decIndex != -1) {
                nCommaChars = separatorChars(result, decIndex);
                result = StringUtils.addCommas(result, wholeStart, decIndex)
                        + result.substring(decIndex, orig_length);
            } else {
                nCommaChars = separatorChars(result, orig_length);
                result = StringUtils.addCommas(result, wholeStart, orig_length);
            }
            if (needEllipsis) {
                orig_length -= 1;  // Exclude ellipsis.
            }
            final float len = orig_length + nCommaChars;
            int deletedChars = 0;
            final float ellipsisCredit = getNoEllipsisCredit();
            final float decimalCredit = getDecimalCredit();
            final float effectiveLen = len - (decIndex == -1 ? 0 : getDecimalCredit());
            final float ellipsisAdjustment =
                    needEllipsis ? mNoExponentCredit : getNoEllipsisCredit();
            // As above, we allow for a tiny amount of extra length here, for consistency with
            // getPreferredPrec().
            if (effectiveLen - ellipsisAdjustment > (float) (maxDigs - wholeStart) + 0.0001f
                && !forcePrecision) {
                float deletedWidth = 0.0f;
                while (effectiveLen - mNoExponentCredit - deletedWidth
                        > (float) (maxDigs - 1 /* for ellipsis */)) {
                    if (result.charAt(deletedChars) == ',') {
                        deletedWidth += mGroupingSeparatorWidthRatio;
                    } else {
                        deletedWidth += 1.0f;
                    }
                    deletedChars++;
                }
            }
            if (deletedChars > 0) {
                result = KeyMaps.ELLIPSIS + result.substring(deletedChars, result.length());
            } else if (needEllipsis) {
                result = KeyMaps.ELLIPSIS + result;
            }
        }
        return result;
    }

    /**
     * Get formatted, but not internationalized, result from mEvaluator.
     * @param precOffset requested position (1 = tenths) of last included digit
     * @param maxSize maximum number of characters (more or less) in result
     * @param lastDisplayedOffset zeroth entry is set to actual offset of last included digit,
     *                            after adjusting for exponent, etc.  May be null.
     * @param forcePrecision Ensure that last included digit is at pos, at the expense
     *                       of treating maxSize as a soft limit.
     * @param forceSciNotation Force scientific notation, even if not required by maxSize.
     * @param insertCommas Insert commas as digit separators.
     */
    private String getFormattedResult(int precOffset, int maxSize, int lastDisplayedOffset[],
            boolean forcePrecision, boolean forceSciNotation, boolean insertCommas) {
        final boolean truncated[] = new boolean[1];
        final boolean negative[] = new boolean[1];
        final int requestedPrecOffset[] = {precOffset};
        final String rawResult = mEvaluator.getString(mIndex, requestedPrecOffset, mMaxCharOffset,
                maxSize, truncated, negative, this);
        return formatResult(rawResult, requestedPrecOffset[0], maxSize, truncated[0], negative[0],
                lastDisplayedOffset, forcePrecision, forceSciNotation, insertCommas);
   }

    /**
     * Return entire result (within reason) up to current displayed precision.
     * @param withSeparators  Add digit separators
     */
    public String getFullText(boolean withSeparators) {
        if (!mValid) return "";
        if (!mScrollable) return getText().toString();
        return KeyMaps.translateResult(getFormattedResult(mLastDisplayedOffset, MAX_COPY_SIZE,
                null, true /* forcePrecision */, false /* forceSciNotation */, withSeparators));
    }

    /**
     * Did the above produce a correct result?
     * UI thread only.
     */
    public boolean fullTextIsExact() {
        return !mScrollable || (getCharOffset(mMaxPos) == getCharOffset(mCurrentPos)
                && mMaxCharOffset != MAX_RIGHT_SCROLL);
    }

    /**
     * Get entire result up to current displayed precision, or up to MAX_COPY_EXTRA additional
     * digits, if it will lead to an exact result.
     */
    public String getFullCopyText() {
        if (!mValid
                || mLsdOffset == Integer.MAX_VALUE
                || fullTextIsExact()
                || mWholeLen > MAX_RECOMPUTE_DIGITS
                || mWholeLen + mLsdOffset > MAX_RECOMPUTE_DIGITS
                || mLsdOffset - mLastDisplayedOffset > MAX_COPY_EXTRA) {
            return getFullText(false /* withSeparators */);
        }
        // It's reasonable to compute and copy the exact result instead.
        int fractionLsdOffset = Math.max(0, mLsdOffset);
        String rawResult = mEvaluator.getResult(mIndex).toStringTruncated(fractionLsdOffset);
        if (mLsdOffset <= -1) {
            // Result has trailing decimal point. Remove it.
            rawResult = rawResult.substring(0, rawResult.length() - 1);
            fractionLsdOffset = -1;
        }
        final String formattedResult = formatResult(rawResult, fractionLsdOffset, MAX_COPY_SIZE,
                false, rawResult.charAt(0) == '-', null, true /* forcePrecision */,
                false /* forceSciNotation */, false /* insertCommas */);
        return KeyMaps.translateResult(formattedResult);
    }

    /**
     * Return the maximum number of characters that will fit in the result display.
     * May be called asynchronously from non-UI thread. From Evaluator.CharMetricsInfo.
     * Returns zero if measurement hasn't completed.
     */
    @Override
    public int getMaxChars() {
        int result;
        synchronized(mWidthLock) {
            return (int) Math.floor(mWidthConstraint / mCharWidth);
        }
    }

    /**
     * @return {@code true} if the currently displayed result is scrollable
     */
    public boolean isScrollable() {
        return mScrollable;
    }

    /**
     * Map pixel position to digit offset.
     * UI thread only.
     */
    int getCharOffset(int pos) {
        return (int) Math.round(pos / mCharWidth);  // Lock not needed.
    }

    void clear() {
        mValid = false;
        mScrollable = false;
        setText("");
        setLongClickable(false);
    }

    @Override
    public void onCancelled(long index) {
        clear();
        mStoreToMemoryRequested = false;
    }

    /**
     * Refresh display.
     * Only called in UI thread. Index argument is currently ignored.
     */
    @Override
    public void onReevaluate(long index) {
        redisplay();
    }

    public void redisplay() {
        int maxChars = getMaxChars();
        if (maxChars < 4) {
            // Display currently too small to display a reasonable result. Punt to avoid crash.
            return;
        }
        if (mScroller.isFinished() && length() > 0) {
            setAccessibilityLiveRegion(ACCESSIBILITY_LIVE_REGION_POLITE);
        }
        int currentCharOffset = getCharOffset(mCurrentPos);
        int lastDisplayedOffset[] = new int[1];
        String result = getFormattedResult(currentCharOffset, maxChars, lastDisplayedOffset,
                mAppendExponent /* forcePrecision; preserve entire result */,
                !mWholePartFits
                &&  currentCharOffset == getCharOffset(mMinPos) /* forceSciNotation */,
                mWholePartFits /* insertCommas */ );
        int expIndex = result.indexOf('E');
        result = KeyMaps.translateResult(result);
        if (expIndex > 0 && result.indexOf('.') == -1) {
          // Gray out exponent if used as position indicator
            SpannableString formattedResult = new SpannableString(result);
            formattedResult.setSpan(mExponentColorSpan, expIndex, result.length(),
                                    Spanned.SPAN_EXCLUSIVE_EXCLUSIVE);
            setText(formattedResult);
        } else {
            setText(result);
        }
        mLastDisplayedOffset = lastDisplayedOffset[0];
        mValid = true;
        setLongClickable(true);
    }

    @Override
    protected void onTextChanged(java.lang.CharSequence text, int start, int lengthBefore,
            int lengthAfter) {
        super.onTextChanged(text, start, lengthBefore, lengthAfter);

        if (!mScrollable || mScroller.isFinished()) {
            if (lengthBefore == 0 && lengthAfter > 0) {
                setAccessibilityLiveRegion(ACCESSIBILITY_LIVE_REGION_POLITE);
                setContentDescription(null);
            } else if (lengthBefore > 0 && lengthAfter == 0) {
                setAccessibilityLiveRegion(ACCESSIBILITY_LIVE_REGION_NONE);
                setContentDescription(getContext().getString(R.string.desc_result));
            }
        }
    }

    @Override
    public void computeScroll() {
        if (!mScrollable) {
            return;
        }

        if (mScroller.computeScrollOffset()) {
            mCurrentPos = mScroller.getCurrX();
            if (getCharOffset(mCurrentPos) != getCharOffset(mLastPos)) {
                mLastPos = mCurrentPos;
                redisplay();
            }
        }

        if (!mScroller.isFinished()) {
                postInvalidateOnAnimation();
                setAccessibilityLiveRegion(ACCESSIBILITY_LIVE_REGION_NONE);
        } else if (length() > 0){
            setAccessibilityLiveRegion(ACCESSIBILITY_LIVE_REGION_POLITE);
        }
    }

    /**
     * Use ActionMode for copy/memory support on M and higher.
     */
    @TargetApi(Build.VERSION_CODES.M)
    private void setupActionMode() {
        mCopyActionModeCallback = new ActionMode.Callback2() {

            @Override
            public boolean onCreateActionMode(ActionMode mode, Menu menu) {
                final MenuInflater inflater = mode.getMenuInflater();
                return createContextMenu(inflater, menu);
            }

            @Override
            public boolean onPrepareActionMode(ActionMode mode, Menu menu) {
                return false; // Return false if nothing is done
            }

            @Override
            public boolean onActionItemClicked(ActionMode mode, MenuItem item) {
                if (onMenuItemClick(item)) {
                    mode.finish();
                    return true;
                } else {
                    return false;
                }
            }

            @Override
            public void onDestroyActionMode(ActionMode mode) {
                unhighlightResult();
                mActionMode = null;
            }

            @Override
            public void onGetContentRect(ActionMode mode, View view, Rect outRect) {
                super.onGetContentRect(mode, view, outRect);

                outRect.left += view.getPaddingLeft();
                outRect.top += view.getPaddingTop();
                outRect.right -= view.getPaddingRight();
                outRect.bottom -= view.getPaddingBottom();
                final int width = (int) Layout.getDesiredWidth(getText(), getPaint());
                if (width < outRect.width()) {
                    outRect.left = outRect.right - width;
                }

                if (!BuildCompat.isAtLeastN()) {
                    // The CAB (prior to N) only takes the translation of a view into account, so
                    // if a scale is applied to the view then the offset outRect will end up being
                    // positioned incorrectly. We workaround that limitation by manually applying
                    // the scale to the outRect, which the CAB will then offset to the correct
                    // position.
                    final float scaleX = view.getScaleX();
                    final float scaleY = view.getScaleY();
                    outRect.left *= scaleX;
                    outRect.right *= scaleX;
                    outRect.top *= scaleY;
                    outRect.bottom *= scaleY;
                }
            }
        };
        setOnLongClickListener(new View.OnLongClickListener() {
            @Override
            public boolean onLongClick(View v) {
                if (mValid) {
                    mActionMode = startActionMode(mCopyActionModeCallback,
                            ActionMode.TYPE_FLOATING);
                    return true;
                }
                return false;
            }
        });
    }

    /**
     * Use ContextMenu for copy/memory support on L and lower.
     */
    private void setupContextMenu() {
        setOnCreateContextMenuListener(new OnCreateContextMenuListener() {
            @Override
            public void onCreateContextMenu(ContextMenu contextMenu, View view,
                    ContextMenu.ContextMenuInfo contextMenuInfo) {
                final MenuInflater inflater = new MenuInflater(getContext());
                createContextMenu(inflater, contextMenu);
                mContextMenu = contextMenu;
                for (int i = 0; i < contextMenu.size(); i ++) {
                    contextMenu.getItem(i).setOnMenuItemClickListener(CalculatorResult.this);
                }
            }
        });
        setOnLongClickListener(new View.OnLongClickListener() {
            @Override
            public boolean onLongClick(View v) {
                if (mValid) {
                    return showContextMenu();
                }
                return false;
            }
        });
    }

    private boolean createContextMenu(MenuInflater inflater, Menu menu) {
        inflater.inflate(R.menu.menu_result, menu);
        final boolean displayMemory = mEvaluator.getMemoryIndex() != 0;
        final MenuItem memoryAddItem = menu.findItem(R.id.memory_add);
        final MenuItem memorySubtractItem = menu.findItem(R.id.memory_subtract);
        memoryAddItem.setEnabled(displayMemory);
        memorySubtractItem.setEnabled(displayMemory);
        highlightResult();
        return true;
    }

    public boolean stopActionModeOrContextMenu() {
        if (mActionMode != null) {
            mActionMode.finish();
            return true;
        }
        if (mContextMenu != null) {
            unhighlightResult();
            mContextMenu.close();
            return true;
        }
        return false;
    }

    private void highlightResult() {
        final Spannable text = (Spannable) getText();
        text.setSpan(mHighlightSpan, 0, text.length(), Spanned.SPAN_EXCLUSIVE_EXCLUSIVE);
    }

    private void unhighlightResult() {
        final Spannable text = (Spannable) getText();
        text.removeSpan(mHighlightSpan);
    }

    private void setPrimaryClip(ClipData clip) {
        ClipboardManager clipboard = (ClipboardManager) getContext().
                                               getSystemService(Context.CLIPBOARD_SERVICE);
        clipboard.setPrimaryClip(clip);
    }

    private void copyContent() {
        final CharSequence text = getFullCopyText();
        ClipboardManager clipboard =
                (ClipboardManager) getContext().getSystemService(Context.CLIPBOARD_SERVICE);
        // We include a tag URI, to allow us to recognize our own results and handle them
        // specially.
        ClipData.Item newItem = new ClipData.Item(text, null, mEvaluator.capture(mIndex));
        String[] mimeTypes = new String[] {ClipDescription.MIMETYPE_TEXT_PLAIN};
        ClipData cd = new ClipData("calculator result", mimeTypes, newItem);
        clipboard.setPrimaryClip(cd);
        Toast.makeText(getContext(), R.string.text_copied_toast, Toast.LENGTH_SHORT).show();
    }

    @Override
    public boolean onMenuItemClick(MenuItem item) {
        switch (item.getItemId()) {
            case R.id.memory_add:
                onMemoryAdd();
                return true;
            case R.id.memory_subtract:
                onMemorySubtract();
                return true;
            case R.id.memory_store:
                onMemoryStore();
                return true;
            case R.id.menu_copy:
                if (mEvaluator.evaluationInProgress(mIndex)) {
                    // Refuse to copy placeholder characters.
                    return false;
                } else {
                    copyContent();
                    unhighlightResult();
                    return true;
                }
            default:
                return false;
        }
    }

    @Override
    protected void onDetachedFromWindow() {
        stopActionModeOrContextMenu();
        super.onDetachedFromWindow();
    }
}