/*

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

 */

/*

 * (C) Copyright IBM Corp. 1998-2003, All Rights Reserved

 *

 */

package java.awt.font;

import java.awt.Color;

import java.awt.Font;

import java.awt.Graphics2D;

import java.awt.Rectangle;

import java.awt.Shape;

import java.awt.geom.AffineTransform;

import java.awt.geom.GeneralPath;

import java.awt.geom.Point2D;

import java.awt.geom.Rectangle2D;

import java.awt.im.InputMethodHighlight;

import java.awt.image.BufferedImage;

import java.text.Annotation;

import java.text.AttributedCharacterIterator;

import java.text.AttributedCharacterIterator.Attribute;

import java.text.Bidi;

import java.text.CharacterIterator;

import java.util.Hashtable;

import java.util.Map;

import sun.font.AttributeValues;

import sun.font.BidiUtils;

import sun.font.CoreMetrics;

import sun.font.Decoration;

import sun.font.FontLineMetrics;

import sun.font.FontResolver;

import sun.font.GraphicComponent;

import sun.font.LayoutPathImpl;

import sun.font.LayoutPathImpl.EmptyPath;

import sun.font.LayoutPathImpl.SegmentPathBuilder;

import sun.font.TextLabelFactory;

import sun.font.TextLineComponent;

import sun.text.CodePointIterator;

import java.awt.geom.Line2D;

final class TextLine {

    static final class TextLineMetrics {

        public final float ascent;

        public final float descent;

        public final float leading;

        public final float advance;

        public TextLineMetrics(float ascent,

                           float descent,

                           float leading,

                           float advance) {

            this.ascent = ascent;

            this.descent = descent;

            this.leading = leading;

            this.advance = advance;

        }

    }

    private TextLineComponent[] fComponents;

    private float[] fBaselineOffsets;

    private int[] fComponentVisualOrder; // if null, ltr

    private float[] locs; // x,y pairs for components in visual order

    private char[] fChars;

    private int fCharsStart;

    private int fCharsLimit;

    private int[] fCharVisualOrder;  // if null, ltr

    private int[] fCharLogicalOrder; // if null, ltr

    private byte[] fCharLevels;     // if null, 0

    private boolean fIsDirectionLTR;

    private LayoutPathImpl lp;

    private boolean isSimple;

    private Rectangle pixelBounds;

    private FontRenderContext frc;

    private TextLineMetrics fMetrics = null; // built on demand in getMetrics

    public TextLine(FontRenderContext frc,

                    TextLineComponent[] components,

                    float[] baselineOffsets,

                    char[] chars,

                    int charsStart,

                    int charsLimit,

                    int[] charLogicalOrder,

                    byte[] charLevels,

                    boolean isDirectionLTR) {

        int[] componentVisualOrder = computeComponentOrder(components,

                                                           charLogicalOrder);

        this.frc = frc;

        fComponents = components;

        fBaselineOffsets = baselineOffsets;

        fComponentVisualOrder = componentVisualOrder;

        fChars = chars;

        fCharsStart = charsStart;

        fCharsLimit = charsLimit;

        fCharLogicalOrder = charLogicalOrder;

        fCharLevels = charLevels;

        fIsDirectionLTR = isDirectionLTR;

        checkCtorArgs();

        init();

    }

    private void checkCtorArgs() {

        int checkCharCount = 0;

        for (int i=0; i < fComponents.length; i++) {

            checkCharCount += fComponents[i].getNumCharacters();

        }

        if (checkCharCount != this.characterCount()) {

            throw new IllegalArgumentException("Invalid TextLine!  " +

                                "char count is different from " +

                                "sum of char counts of components.");

        }

    }

    private void init() {

        // first, we need to check for graphic components on the TOP or BOTTOM baselines.  So

        // we perform the work that used to be in getMetrics here.

        float ascent = 0;

        float descent = 0;

        float leading = 0;

        float advance = 0;

        // ascent + descent must not be less than this value

        float maxGraphicHeight = 0;

        float maxGraphicHeightWithLeading = 0;

        // walk through EGA's

        TextLineComponent tlc;

        boolean fitTopAndBottomGraphics = false;

        isSimple = true;

        for (int i = 0; i < fComponents.length; i++) {

            tlc = fComponents[i];

            isSimple &= tlc.isSimple();

            CoreMetrics cm = tlc.getCoreMetrics();

            byte baseline = (byte)cm.baselineIndex;

            if (baseline >= 0) {

                float baselineOffset = fBaselineOffsets[baseline];

                ascent = Math.max(ascent, -baselineOffset + cm.ascent);

                float gd = baselineOffset + cm.descent;

                descent = Math.max(descent, gd);

                leading = Math.max(leading, gd + cm.leading);

            }

            else {

                fitTopAndBottomGraphics = true;

                float graphicHeight = cm.ascent + cm.descent;

                float graphicHeightWithLeading = graphicHeight + cm.leading;

                maxGraphicHeight = Math.max(maxGraphicHeight, graphicHeight);

                maxGraphicHeightWithLeading = Math.max(maxGraphicHeightWithLeading,

                                                       graphicHeightWithLeading);

            }

        }

        if (fitTopAndBottomGraphics) {

            if (maxGraphicHeight > ascent + descent) {

                descent = maxGraphicHeight - ascent;

            }

            if (maxGraphicHeightWithLeading > ascent + leading) {

                leading = maxGraphicHeightWithLeading - ascent;

            }

        }

        leading -= descent;

        // we now know enough to compute the locs, but we need the final loc

        // for the advance before we can create the metrics object

        if (fitTopAndBottomGraphics) {

            // we have top or bottom baselines, so expand the baselines array

            // full offsets are needed by CoreMetrics.effectiveBaselineOffset

            fBaselineOffsets = new float[] {

                fBaselineOffsets[0],

                fBaselineOffsets[1],

                fBaselineOffsets[2],

                descent,

                -ascent

            };

        }

        float x = 0;

        float y = 0;

        CoreMetrics pcm = null;

        boolean needPath = false;

        locs = new float[fComponents.length * 2 + 2];

        for (int i = 0, n = 0; i < fComponents.length; ++i, n += 2) {

            tlc = fComponents[getComponentLogicalIndex(i)];

            CoreMetrics cm = tlc.getCoreMetrics();

            if ((pcm != null) &&

                (pcm.italicAngle != 0 || cm.italicAngle != 0) &&  // adjust because of italics

                (pcm.italicAngle != cm.italicAngle ||

                 pcm.baselineIndex != cm.baselineIndex ||

                 pcm.ssOffset != cm.ssOffset)) {

                // 1) compute the area of overlap - min effective ascent and min effective descent

                // 2) compute the x positions along italic angle of ascent and descent for left and right

                // 3) compute maximum left - right, adjust right position by this value

                // this is a crude form of kerning between textcomponents

                // note glyphvectors preposition glyphs based on offset,

                // so tl doesn't need to adjust glyphvector position

                // 1)

                float pb = pcm.effectiveBaselineOffset(fBaselineOffsets);

                float pa = pb - pcm.ascent;

                float pd = pb + pcm.descent;

                // pb += pcm.ssOffset;

                float cb = cm.effectiveBaselineOffset(fBaselineOffsets);

                float ca = cb - cm.ascent;

                float cd = cb + cm.descent;

                // cb += cm.ssOffset;

                float a = Math.max(pa, ca);

                float d = Math.min(pd, cd);

                // 2)

                float pax = pcm.italicAngle * (pb - a);

                float pdx = pcm.italicAngle * (pb - d);

                float cax = cm.italicAngle * (cb - a);

                float cdx = cm.italicAngle * (cb - d);

                // 3)

                float dax = pax - cax;

                float ddx = pdx - cdx;

                float dx = Math.max(dax, ddx);

                x += dx;

                y = cb;

            } else {

                // no italic adjustment for x, but still need to compute y

                y = cm.effectiveBaselineOffset(fBaselineOffsets); // + cm.ssOffset;

            }

            locs[n] = x;

            locs[n+1] = y;

            x += tlc.getAdvance();

            pcm = cm;

            needPath |= tlc.getBaselineTransform() != null;

        }

        // do we want italic padding at the right of the line?

        if (pcm.italicAngle != 0) {

            float pb = pcm.effectiveBaselineOffset(fBaselineOffsets);

            float pa = pb - pcm.ascent;

            float pd = pb + pcm.descent;

            pb += pcm.ssOffset;

            float d;

            if (pcm.italicAngle > 0) {

                d = pb + pcm.ascent;

            } else {

                d = pb - pcm.descent;

            }

            d *= pcm.italicAngle;

            x += d;

        }

        locs[locs.length - 2] = x;

        // locs[locs.length - 1] = 0; // final offset is always back on baseline

        // ok, build fMetrics since we have the final advance

        advance = x;

        fMetrics = new TextLineMetrics(ascent, descent, leading, advance);

        // build path if we need it

        if (needPath) {

            isSimple = false;

            Point2D.Double pt = new Point2D.Double();

            double tx = 0, ty = 0;

            SegmentPathBuilder builder = new SegmentPathBuilder();

            builder.moveTo(locs[0], 0);

            for (int i = 0, n = 0; i < fComponents.length; ++i, n += 2) {

                tlc = fComponents[getComponentLogicalIndex(i)];

                AffineTransform at = tlc.getBaselineTransform();

                if (at != null &&

                    ((at.getType() & AffineTransform.TYPE_TRANSLATION) != 0)) {

                    double dx = at.getTranslateX();

                    double dy = at.getTranslateY();

                    builder.moveTo(tx += dx, ty += dy);

                }

                pt.x = locs[n+2] - locs[n];

                pt.y = 0;

                if (at != null) {

                    at.deltaTransform(pt, pt);

                }

                builder.lineTo(tx += pt.x, ty += pt.y);

            }

            lp = builder.complete();

            if (lp == null) { // empty path

                tlc = fComponents[getComponentLogicalIndex(0)];

                AffineTransform at = tlc.getBaselineTransform();

                if (at != null) {

                    lp = new EmptyPath(at);

                }

            }

        }

    }

    public Rectangle getPixelBounds(FontRenderContext frc, float x, float y) {

        Rectangle result = null;

        // if we have a matching frc, set it to null so we don't have to test it

        // for each component

        if (frc != null && frc.equals(this.frc)) {

            frc = null;

        }

        // only cache integral locations with the default frc, this is a bit strict

        int ix = (int)Math.floor(x);

        int iy = (int)Math.floor(y);

        float rx = x - ix;

        float ry = y - iy;

        boolean canCache = frc == null && rx == 0 && ry == 0;

        if (canCache && pixelBounds != null) {

            result = new Rectangle(pixelBounds);

            result.x += ix;

            result.y += iy;

            return result;

        }

        // couldn't use cache, or didn't have it, so compute

        if (isSimple) { // all glyphvectors with no decorations, no layout path

            for (int i = 0, n = 0; i < fComponents.length; i++, n += 2) {

                TextLineComponent tlc = fComponents[getComponentLogicalIndex(i)];

                Rectangle pb = tlc.getPixelBounds(frc, locs[n] + rx, locs[n+1] + ry);

                if (!pb.isEmpty()) {

                    if (result == null) {

                        result = pb;

                    } else {

                        result.add(pb);

                    }

                }

            }

            if (result == null) {

                result = new Rectangle(0, 0, 0, 0);

            }

        } else { // draw and test

            final int MARGIN = 3;

            Rectangle2D r2d = getVisualBounds();

            if (lp != null) {

                r2d = lp.mapShape(r2d).getBounds();

            }

            Rectangle bounds = r2d.getBounds();

            BufferedImage im = new BufferedImage(bounds.width + MARGIN * 2,

                                                 bounds.height + MARGIN * 2,

                                                 BufferedImage.TYPE_INT_ARGB);

            Graphics2D g2d = im.createGraphics();

            g2d.setColor(Color.WHITE);

            g2d.fillRect(0, 0, im.getWidth(), im.getHeight());

            g2d.setColor(Color.BLACK);

            draw(g2d, rx + MARGIN - bounds.x, ry + MARGIN - bounds.y);

            result = computePixelBounds(im);

            result.x -= MARGIN - bounds.x;

            result.y -= MARGIN - bounds.y;

        }

        if (canCache) {

            pixelBounds = new Rectangle(result);

        }

        result.x += ix;

        result.y += iy;

        return result;

    }

    static Rectangle computePixelBounds(BufferedImage im) {

        int w = im.getWidth();

        int h = im.getHeight();

        int l = -1, t = -1, r = w, b = h;

        {

            // get top

            int[] buf = new int[w];

            loop: while (++t < h) {

                im.getRGB(0, t, buf.length, 1, buf, 0, w); // w ignored

                for (int i = 0; i < buf.length; i++) {

                    if (buf[i] != -1) {

                        break loop;

                    }

                }

            }

        }

        // get bottom

        {

            int[] buf = new int[w];

            loop: while (--b > t) {

                im.getRGB(0, b, buf.length, 1, buf, 0, w); // w ignored

                for (int i = 0; i < buf.length; ++i) {

                    if (buf[i] != -1) {

                        break loop;

                    }

                }

            }

            ++b;

        }

        // get left

        {

            loop: while (++l < r) {

                for (int i = t; i < b; ++i) {

                    int v = im.getRGB(l, i);

                    if (v != -1) {

                        break loop;

                    }

                }

            }

        }

        // get right

        {

            loop: while (--r > l) {

                for (int i = t; i < b; ++i) {

                    int v = im.getRGB(r, i);

                    if (v != -1) {

                        break loop;

                    }

                }

            }

            ++r;

        }

        return new Rectangle(l, t, r-l, b-t);

    }

    private abstract static class Function {

        abstract float computeFunction(TextLine line,

                                       int componentIndex,

                                       int indexInArray);

    }

    private static Function fgPosAdvF = new Function() {

        float computeFunction(TextLine line,

                              int componentIndex,

                              int indexInArray) {

            TextLineComponent tlc = line.fComponents[componentIndex];

                int vi = line.getComponentVisualIndex(componentIndex);

            return line.locs[vi * 2] + tlc.getCharX(indexInArray) + tlc.getCharAdvance(indexInArray);

        }

    };

    private static Function fgAdvanceF = new Function() {

        float computeFunction(TextLine line,

                              int componentIndex,

                              int indexInArray) {

            TextLineComponent tlc = line.fComponents[componentIndex];

            return tlc.getCharAdvance(indexInArray);

        }

    };

    private static Function fgXPositionF = new Function() {

        float computeFunction(TextLine line,

                              int componentIndex,

                              int indexInArray) {

                int vi = line.getComponentVisualIndex(componentIndex);

            TextLineComponent tlc = line.fComponents[componentIndex];

            return line.locs[vi * 2] + tlc.getCharX(indexInArray);

        }

    };

    private static Function fgYPositionF = new Function() {

        float computeFunction(TextLine line,

                              int componentIndex,

                              int indexInArray) {

            TextLineComponent tlc = line.fComponents[componentIndex];