/*

 * 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.  Sun designates this

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

 * by Sun 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 Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,

 * CA 95054 USA or visit www.sun.com if you need additional information or

 * have any questions.

 */

/*

 *

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

 *

 * The original version of this source code and documentation is

 * copyrighted and owned by IBM. These materials are provided

 * under terms of a License Agreement between IBM and Sun.

 * This technology is protected by multiple US and International

 * patents. This notice and attribution to IBM may not be removed.

 */

/*

 * GlyphLayout is used to process a run of text into a run of run of

 * glyphs, optionally with position and char mapping info.

 *

 * The text has already been processed for numeric shaping and bidi.

 * The run of text that layout works on has a single bidi level.  It

 * also has a single font/style.  Some operations need context to work

 * on (shaping, script resolution) so context for the text run text is

 * provided.  It is assumed that the text array contains sufficient

 * context, and the offset and count delimit the portion of the text

 * that needs to actually be processed.

 *

 * The font might be a composite font.  Layout generally requires

 * tables from a single physical font to operate, and so it must

 * resolve the 'single' font run into runs of physical fonts.

 *

 * Some characters are supported by several fonts of a composite, and

 * in order to properly emulate the glyph substitution behavior of a

 * single physical font, these characters might need to be mapped to

 * different physical fonts.  The script code that is assigned

 * characters normally considered 'common script' can be used to

 * resolve which physical font to use for these characters. The input

 * to the char to glyph mapper (which assigns physical fonts as it

 * processes the glyphs) should include the script code, and the

 * mapper should operate on runs of a single script.

 *

 * To perform layout, call get() to get a new (or reuse an old)

 * GlyphLayout, call layout on it, then call done(GlyphLayout) when

 * finished.  There's no particular problem if you don't call done,

 * but it assists in reuse of the GlyphLayout.

 */

package sun.font;

import java.lang.ref.SoftReference;

import java.awt.Font;

import java.awt.font.FontRenderContext;

import java.awt.font.GlyphVector;

import java.awt.geom.AffineTransform;

import java.awt.geom.NoninvertibleTransformException;

import java.awt.geom.Point2D;

import java.util.ArrayList;

import java.util.concurrent.ConcurrentHashMap;

import static java.lang.Character.*;

public final class GlyphLayout {

    // data for glyph vector

    private GVData _gvdata;

    // cached glyph layout data for reuse

    private static volatile GlyphLayout cache;  // reusable

    private LayoutEngineFactory _lef;  // set when get is called, unset when done is called

    private TextRecord _textRecord;    // the text we're working on, used by iterators

    private ScriptRun _scriptRuns;     // iterator over script runs

    private FontRunIterator _fontRuns; // iterator over physical fonts in a composite

    private int _ercount;

    private ArrayList _erecords;

    private Point2D.Float _pt;

    private FontStrikeDesc _sd;

    private float[] _mat;

    private int _typo_flags;

    private int _offset;

    public static final class LayoutEngineKey {

        private Font2D font;

        private int script;

        private int lang;

        LayoutEngineKey() {

        }

        LayoutEngineKey(Font2D font, int script, int lang) {

            init(font, script, lang);

        }

        void init(Font2D font, int script, int lang) {

            this.font = font;

            this.script = script;

            this.lang = lang;

        }

        LayoutEngineKey copy() {

            return new LayoutEngineKey(font, script, lang);

        }

        Font2D font() {

            return font;

        }

        int script() {

            return script;

        }

        int lang() {

            return lang;

        }

        public boolean equals(Object rhs) {

            if (this == rhs) return true;

            if (rhs == null) return false;

            try {

                LayoutEngineKey that = (LayoutEngineKey)rhs;

                return this.script == that.script &&

                       this.lang == that.lang &&

                       this.font.equals(that.font);

            }

            catch (ClassCastException e) {

                return false;

            }

        }

        public int hashCode() {

            return script ^ lang ^ font.hashCode();

        }

    }

    public static interface LayoutEngineFactory {

        /**

         * Given a font, script, and language, determine a layout engine to use.

         */

        public LayoutEngine getEngine(Font2D font, int script, int lang);

        /**

         * Given a key, determine a layout engine to use.

         */

        public LayoutEngine getEngine(LayoutEngineKey key);

    }

    public static interface LayoutEngine {

        /**

         * Given a strike descriptor, text, rtl flag, and starting point, append information about

         * glyphs, positions, and character indices to the glyphvector data, and advance the point.

         *

         * If the GVData does not have room for the glyphs, throws an IndexOutOfBoundsException and

         * leave pt and the gvdata unchanged.

         */

        public void layout(FontStrikeDesc sd, float[] mat, int gmask,

                           int baseIndex, TextRecord text, int typo_flags, Point2D.Float pt, GVData data);

    }

    /**

     * Return a new instance of GlyphLayout, using the provided layout engine factory.

     * If null, the system layout engine factory will be used.

     */

    public static GlyphLayout get(LayoutEngineFactory lef) {

        if (lef == null) {

            lef = SunLayoutEngine.instance();

        }

        GlyphLayout result = null;

        synchronized(GlyphLayout.class) {

            if (cache != null) {

                result = cache;

                cache = null;

            }

        }

        if (result == null) {

            result = new GlyphLayout();

        }

        result._lef = lef;

        return result;

    }

    /**

     * Return the old instance of GlyphLayout when you are done.  This enables reuse

     * of GlyphLayout objects.

     */

    public static void done(GlyphLayout gl) {

        gl._lef = null;

        cache = gl; // object reference assignment is thread safe, it says here...

    }

    private static final class SDCache {

        public Font key_font;

        public FontRenderContext key_frc;

        public AffineTransform dtx;

        public AffineTransform invdtx;

        public AffineTransform gtx;

        public Point2D.Float delta;

        public FontStrikeDesc sd;

        private SDCache(Font font, FontRenderContext frc) {

            key_font = font;

            key_frc = frc;

            // !!! add getVectorTransform and hasVectorTransform to frc?  then

            // we could just skip this work...

            dtx = frc.getTransform();

            dtx.setTransform(dtx.getScaleX(), dtx.getShearY(),

                             dtx.getShearX(), dtx.getScaleY(),

                             0, 0);

            if (!dtx.isIdentity()) {

                try {

                    invdtx = dtx.createInverse();

                }

                catch (NoninvertibleTransformException e) {

                    throw new InternalError();

                }

            }

            float ptSize = font.getSize2D();

            if (font.isTransformed()) {

                gtx = font.getTransform();

                gtx.scale(ptSize, ptSize);

                delta = new Point2D.Float((float)gtx.getTranslateX(),

                                          (float)gtx.getTranslateY());

                gtx.setTransform(gtx.getScaleX(), gtx.getShearY(),

                                 gtx.getShearX(), gtx.getScaleY(),

                                 0, 0);

                gtx.preConcatenate(dtx);

            } else {

                delta = ZERO_DELTA;

                gtx = new AffineTransform(dtx);

                gtx.scale(ptSize, ptSize);

            }

            /* Similar logic to that used in SunGraphics2D.checkFontInfo().

             * Whether a grey (AA) strike is needed is size dependent if

             * AA mode is 'gasp'.

             */

            int aa =

                FontStrikeDesc.getAAHintIntVal(frc.getAntiAliasingHint(),

                                               FontManager.getFont2D(font),

                                               (int)Math.abs(ptSize));

            int fm = FontStrikeDesc.getFMHintIntVal

                (frc.getFractionalMetricsHint());

            sd = new FontStrikeDesc(dtx, gtx, font.getStyle(), aa, fm);

        }

        private static final Point2D.Float ZERO_DELTA = new Point2D.Float();

        private static

            SoftReference<ConcurrentHashMap<SDKey, SDCache>> cacheRef;

        private static final class SDKey {

            private final Font font;

            private final FontRenderContext frc;

            private final int hash;

            SDKey(Font font, FontRenderContext frc) {

                this.font = font;

                this.frc = frc;

                this.hash = font.hashCode() ^ frc.hashCode();

            }

            public int hashCode() {

                return hash;

            }

            public boolean equals(Object o) {

                try {

                    SDKey rhs = (SDKey)o;

                    return

                        hash == rhs.hash &&

                        font.equals(rhs.font) &&

                        frc.equals(rhs.frc);

                }

                catch (ClassCastException e) {

                }

                return false;

            }

        }

        public static SDCache get(Font font, FontRenderContext frc) {

            // It is possible a translation component will be in the FRC.

            // It doesn't affect us except adversely as we would consider

            // FRC's which are really the same to be different. If we

            // detect a translation component, then we need to exclude it

            // by creating a new transform which excludes the translation.

            if (frc.isTransformed()) {

                AffineTransform transform = frc.getTransform();

                if (transform.getTranslateX() != 0 ||

                    transform.getTranslateY() != 0) {

                    transform = new AffineTransform(transform.getScaleX(),

                                                    transform.getShearY(),

                                                    transform.getShearX(),

                                                    transform.getScaleY(),

                                                    0, 0);

                    frc = new FontRenderContext(transform,

                                                frc.getAntiAliasingHint(),

                                                frc.getFractionalMetricsHint()

                                                );

                }

            }

            SDKey key = new SDKey(font, frc); // garbage, yuck...

            ConcurrentHashMap<SDKey, SDCache> cache = null;

            SDCache res = null;

            if (cacheRef != null) {

                cache = cacheRef.get();

                if (cache != null) {

                    res = cache.get(key);

                }

            }

            if (res == null) {

                res = new SDCache(font, frc);

                if (cache == null) {

                    cache = new ConcurrentHashMap<SDKey, SDCache>(10);

                    cacheRef = new

                       SoftReference<ConcurrentHashMap<SDKey, SDCache>>(cache);

                }

                cache.put(key, res);

            }

            return res;

        }

    }

    /**

     * Create a glyph vector.

     * @param font the font to use

     * @param frc the font render context

     * @param text the text, including optional context before start and after start + count

     * @param offset the start of the text to lay out

     * @param count the length of the text to lay out

     * @param flags bidi and context flags {@see #java.awt.Font}

     * @param result a StandardGlyphVector to modify, can be null

     * @return the layed out glyphvector, if result was passed in, it is returned

     */

    public StandardGlyphVector layout(Font font, FontRenderContext frc,

                                      char[] text, int offset, int count,

                                      int flags, StandardGlyphVector result)

    {

        if (text == null || offset < 0 || count < 0 || (count > text.length - offset)) {

            throw new IllegalArgumentException();

        }

        init(count);

        // need to set after init

        // go through the back door for this

        if (font.hasLayoutAttributes()) {

            AttributeValues values = ((AttributeMap)font.getAttributes()).getValues();

            if (values.getKerning() != 0) _typo_flags |= 0x1;

            if (values.getLigatures() != 0) _typo_flags |= 0x2;

        }

        _offset = offset;

        // use cache now - can we use the strike cache for this?

        SDCache txinfo = SDCache.get(font, frc);

        _mat[0] = (float)txinfo.gtx.getScaleX();

        _mat[1] = (float)txinfo.gtx.getShearY();

        _mat[2] = (float)txinfo.gtx.getShearX();

        _mat[3] = (float)txinfo.gtx.getScaleY();

        _pt.setLocation(txinfo.delta);

        int lim = offset + count;

        int min = 0;

        int max = text.length;

        if (flags != 0) {

            if ((flags & Font.LAYOUT_RIGHT_TO_LEFT) != 0) {

              _typo_flags |= 0x80000000; // RTL

            }

            if ((flags & Font.LAYOUT_NO_START_CONTEXT) != 0) {

                min = offset;

            }

            if ((flags & Font.LAYOUT_NO_LIMIT_CONTEXT) != 0) {

                max = lim;

            }

        }

        int lang = -1; // default for now

        Font2D font2D = FontManager.getFont2D(font);

        _textRecord.init(text, offset, lim, min, max);

        int start = offset;

        if (font2D instanceof CompositeFont) {

            _scriptRuns.init(text, offset, count); // ??? how to handle 'common' chars

            _fontRuns.init((CompositeFont)font2D, text, offset, lim);

            while (_scriptRuns.next()) {

                int limit = _scriptRuns.getScriptLimit();

                int script = _scriptRuns.getScriptCode();

                while (_fontRuns.next(script, limit)) {

                    Font2D pfont = _fontRuns.getFont();

                    /* layout can't deal with NativeFont instances. The

                     * native font is assumed to know of a suitable non-native

                     * substitute font. This currently works because

                     * its consistent with the way NativeFonts delegate

                     * in other cases too.

                     */

                    if (pfont instanceof NativeFont) {

                        pfont = ((NativeFont)pfont).getDelegateFont();

                    }

                    int gmask = _fontRuns.getGlyphMask();

                    int pos = _fontRuns.getPos();

                    nextEngineRecord(start, pos, script, lang, pfont, gmask);

                    start = pos;

                }

            }

        } else {

            _scriptRuns.init(text, offset, count); // ??? don't worry about 'common' chars

            while (_scriptRuns.next()) {

                int limit = _scriptRuns.getScriptLimit();

                int script = _scriptRuns.getScriptCode();

                nextEngineRecord(start, limit, script, lang, font2D, 0);

                start = limit;

            }

        }

        int ix = 0;

        int stop = _ercount;

        int dir = 1;

        if (_typo_flags < 0) { // RTL

            ix = stop - 1;

            stop = -1;

            dir = -1;

        }

        //        _sd.init(dtx, gtx, font.getStyle(), frc.isAntiAliased(), frc.usesFractionalMetrics());

        _sd = txinfo.sd;

        for (;ix != stop; ix += dir) {

            EngineRecord er = (EngineRecord)_erecords.get(ix);

            for (;;) {

                try {

                    er.layout();

                    break;

                }

                catch (IndexOutOfBoundsException e) {

                    _gvdata.grow();

                }

            }

        }

        //        if (txinfo.invdtx != null) {

        //            _gvdata.adjustPositions(txinfo.invdtx);

        //        }

        StandardGlyphVector gv = _gvdata.createGlyphVector(font, frc, result);

        //        System.err.println("Layout returns: " + gv);

        return gv;

    }

    //

    // private methods

    //

    private GlyphLayout() {

        this._gvdata = new GVData();

        this._textRecord = new TextRecord();

        this._scriptRuns = new ScriptRun();

        this._fontRuns = new FontRunIterator();

        this._erecords = new ArrayList(10);

        this._pt = new Point2D.Float();

        this._sd = new FontStrikeDesc();

        this._mat = new float[4];

    }

    private void init(int capacity) {

        this._typo_flags = 0;

        this._ercount = 0;

        this._gvdata.init(capacity);

    }

    private void nextEngineRecord(int start, int limit, int script, int lang, Font2D font, int gmask) {

        EngineRecord er = null;

        if (_ercount == _erecords.size()) {

            er = new EngineRecord();

            _erecords.add(er);

        } else {

            er = (EngineRecord)_erecords.get(_ercount);

        }

        er.init(start, limit, font, script, lang, gmask);

        ++_ercount;

    }

    /**

     * Storage for layout to build glyph vector data, then generate a real GlyphVector

     */

    public static final class GVData {

        public int _count; // number of glyphs, >= number of chars

        public int _flags;

        public int[] _glyphs;

        public float[] _positions;

        public int[] _indices;

        private static final int UNINITIALIZED_FLAGS = -1;

        public void init(int size) {

            _count = 0;

            _flags = UNINITIALIZED_FLAGS;

            if (_glyphs == null || _glyphs.length < size) {