/*

 * Copyright (c) 2011, Oracle and/or its affiliates. All rights reserved.

 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.

 *

 * This code is free software; you can redistribute it and/or modify it

 * under the terms of the GNU General Public License version 2 only, as

 * published by the Free Software Foundation.  Oracle designates this

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

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

 *

 * This code is distributed in the hope that it will be useful, but WITHOUT

 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or

 * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License

 * version 2 for more details (a copy is included in the LICENSE file that

 * accompanied this code).

 *

 * You should have received a copy of the GNU General Public License version

 * 2 along with this work; if not, write to the Free Software Foundation,

 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.

 *

 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA

 * or visit www.oracle.com if you need additional information or have any

 * questions.

 */

package sun.font;

import java.awt.Rectangle;

import java.awt.geom.*;

import java.util.*;

import sun.awt.SunHints;

public class CStrike extends FontStrike {

    // Creates the native strike

    private static native long createNativeStrikePtr(long nativeFontPtr,

                                                     double[] glyphTx,

                                                     double[] invDevTxMatrix,

                                                     int aaHint,

                                                     int fmHint);

    // Disposes the native strike

    private static native void disposeNativeStrikePtr(long nativeStrikePtr);

    // Creates a StrikeMetrics from the underlying native system fonts

    private static native StrikeMetrics getFontMetrics(long nativeStrikePtr);

    // Returns native struct pointers used by the Sun 2D Renderer

    private static native void getGlyphImagePtrsNative(long nativeStrikePtr,

                                                       long[] glyphInfos,

                                                       int[] uniCodes, int len);

    // Returns the advance give a glyph code. It should be used only

    // when the glyph code belongs to the CFont passed in.

    private static native float getNativeGlyphAdvance(long nativeStrikePtr,

                                                      int glyphCode);

    // Returns the outline shape of a glyph

    private static native GeneralPath getNativeGlyphOutline(long nativeStrikePtr,

                                                            int glyphCode,

                                                            double x,

                                                            double y);

    // returns the bounding rect for a glyph

    private static native void getNativeGlyphImageBounds(long nativeStrikePtr,

                                                         int glyphCode,

                                                         Rectangle2D.Float result,

                                                         double x, double y);

    private CFont nativeFont;

    private AffineTransform invDevTx;

    private GlyphInfoCache glyphInfoCache;

    private GlyphAdvanceCache glyphAdvanceCache;

    private long nativeStrikePtr;

    CStrike(final CFont font, final FontStrikeDesc inDesc) {

        nativeFont = font;

        desc = inDesc;

        glyphInfoCache = new GlyphInfoCache(font, desc);

        glyphAdvanceCache = new GlyphAdvanceCache();

        disposer = glyphInfoCache;

        // Normally the device transform should be the identity transform

        // for screen operations.  The device transform only becomes

        // interesting when we are outputting between different dpi surfaces,

        // like when we are printing to postscript.

        if (inDesc.devTx != null && !inDesc.devTx.isIdentity()) {

            try {

                invDevTx = inDesc.devTx.createInverse();

            } catch (NoninvertibleTransformException e) {

                // ignored, since device transforms should not be that

                // complicated, and if they are - there is nothing we can do,

                // so we won't worry about it.

            }

        }

    }

    public long getNativeStrikePtr() {

        if (nativeStrikePtr != 0) {

            return nativeStrikePtr;

        }

        final double[] glyphTx = new double[6];

        desc.glyphTx.getMatrix(glyphTx);

        final double[] invDevTxMatrix = new double[6];

        if (invDevTx == null) {

            invDevTxMatrix[0] = 1;

            invDevTxMatrix[3] = 1;

        } else {

            invDevTx.getMatrix(invDevTxMatrix);

        }

        final int aaHint = desc.aaHint;

        final int fmHint = desc.fmHint;

        synchronized (this) {

            if (nativeStrikePtr != 0) {

                return nativeStrikePtr;

            }

            nativeStrikePtr =

                createNativeStrikePtr(nativeFont.getNativeFontPtr(),

                                      glyphTx, invDevTxMatrix, aaHint, fmHint);

        }

        return nativeStrikePtr;

    }

    protected synchronized void finalize() throws Throwable {

        if (nativeStrikePtr != 0) {

            disposeNativeStrikePtr(nativeStrikePtr);

        }

        nativeStrikePtr = 0;

    }

    // the fractional metrics default on our platform is OFF

    private boolean useFractionalMetrics() {

        return desc.fmHint == SunHints.INTVAL_FRACTIONALMETRICS_ON;

    }

    public int getNumGlyphs() {

        return nativeFont.getNumGlyphs();

    }

    StrikeMetrics getFontMetrics() {

        if (strikeMetrics == null) {

            StrikeMetrics metrics = getFontMetrics(getNativeStrikePtr());

            if (invDevTx != null) {

                metrics.convertToUserSpace(invDevTx);

            }

            metrics.convertToUserSpace(desc.glyphTx);

            strikeMetrics = metrics;

        }

        return strikeMetrics;

    }

    float getGlyphAdvance(int glyphCode) {

        return getScaledAdvanceForAdvance(getCachedNativeGlyphAdvance(glyphCode));

    }

    float getCodePointAdvance(int cp) {

        float advance = getCachedNativeGlyphAdvance(nativeFont.getMapper().charToGlyph(cp));

        double glyphScaleX = desc.glyphTx.getScaleX();

        double devScaleX = desc.devTx.getScaleX();

        if (devScaleX == 0) {

            glyphScaleX = Math.sqrt(desc.glyphTx.getDeterminant());

            devScaleX = Math.sqrt(desc.devTx.getDeterminant());

        }

        if (devScaleX == 0) {

            devScaleX = Double.NaN; // this an undefined graphics state

        }

        advance = (float) (advance * glyphScaleX / devScaleX);

        return useFractionalMetrics() ? advance : Math.round(advance);

    }

    // calculate an advance, and round if not using fractional metrics

    private float getScaledAdvanceForAdvance(float advance) {

        if (invDevTx != null) {

            advance *= invDevTx.getScaleX();

        }

        advance *= desc.glyphTx.getScaleX();

        return useFractionalMetrics() ? advance : Math.round(advance);

    }

    Point2D.Float getCharMetrics(char ch) {

        return getScaledPointForAdvance(getCachedNativeGlyphAdvance(nativeFont.getMapper().charToGlyph(ch)));

    }

    Point2D.Float getGlyphMetrics(int glyphCode) {

        return getScaledPointForAdvance(getCachedNativeGlyphAdvance(glyphCode));

    }

    // calculate an advance point, and round if not using fractional metrics

    private Point2D.Float getScaledPointForAdvance(float advance) {

        Point2D.Float pt = new Point2D.Float(advance, 0);

        if (!desc.glyphTx.isIdentity()) {

            return scalePoint(pt);

        }

        if (!useFractionalMetrics()) {

            pt.x = Math.round(pt.x);

        }

        return pt;

    }

    private Point2D.Float scalePoint(Point2D.Float pt) {

        if (invDevTx != null) {

            // transform the point out of the device space first

            invDevTx.transform(pt, pt);

        }

        desc.glyphTx.transform(pt, pt);

        pt.x -= desc.glyphTx.getTranslateX();

        pt.y -= desc.glyphTx.getTranslateY();

        if (!useFractionalMetrics()) {

            pt.x = Math.round(pt.x);

            pt.y = Math.round(pt.y);

        }

        return pt;

    }

    Rectangle2D.Float getGlyphOutlineBounds(int glyphCode) {

        GeneralPath gp = getGlyphOutline(glyphCode, 0f, 0f);

        Rectangle2D r2d = gp.getBounds2D();

        Rectangle2D.Float r2df;

        if (r2d instanceof Rectangle2D.Float) {

            r2df = (Rectangle2D.Float)r2d;

        } else {

            float x = (float)r2d.getX();

            float y = (float)r2d.getY();

            float w = (float)r2d.getWidth();

            float h = (float)r2d.getHeight();

            r2df = new Rectangle2D.Float(x, y, w, h);

        }

        return r2df;

    }

    // pt, result in device space

    void getGlyphImageBounds(int glyphCode, Point2D.Float pt, Rectangle result) {

        Rectangle2D.Float floatRect = new Rectangle2D.Float();

        if (invDevTx != null) {

            invDevTx.transform(pt, pt);

        }

        getGlyphImageBounds(glyphCode, pt.x, pt.y, floatRect);

        if (floatRect.width == 0 && floatRect.height == 0) {

            result.setRect(0, 0, -1, -1);

            return;

        }

        result.setRect(floatRect.x + pt.x, floatRect.y + pt.y, floatRect.width, floatRect.height);

    }

    private void getGlyphImageBounds(int glyphCode, float x, float y, Rectangle2D.Float floatRect) {

        getNativeGlyphImageBounds(getNativeStrikePtr(), glyphCode, floatRect, x, y);

    }

    GeneralPath getGlyphOutline(int glyphCode, float x, float y) {

        return getNativeGlyphOutline(getNativeStrikePtr(), glyphCode, x, y);

    }

    // should implement, however not called though any path that is publicly exposed

    GeneralPath getGlyphVectorOutline(int[] glyphs, float x, float y) {

        throw new Error("not implemented yet");

    }

    // called from the Sun2D renderer

    long getGlyphImagePtr(int glyphCode) {

        synchronized (glyphInfoCache) {

            long ptr = glyphInfoCache.get(glyphCode);

            if (ptr != 0L) return ptr;

            long[] ptrs = new long[1];

            int[] codes = new int[1];

            codes[0] = glyphCode;

            getGlyphImagePtrs(codes, ptrs, 1);

            ptr = ptrs[0];

            glyphInfoCache.put(glyphCode, ptr);

            return ptr;

        }

    }

    // called from the Sun2D renderer

    void getGlyphImagePtrs(int[] glyphCodes, long[] images, int len) {

        synchronized (glyphInfoCache) {

            // fill the image pointer array with existing pointers

            // from the cache

            int missed = 0;

            for (int i = 0; i < len; i++) {

                int code = glyphCodes[i];

                final long ptr = glyphInfoCache.get(code);

                if (ptr != 0L) {

                    images[i] = ptr;

                } else {

                    // zero this element out, because the caller does not

                    // promise to keep it clean

                    images[i] = 0L;

                    missed++;

                }

            }

            if (missed == 0) {

                return; // horray! we got away without touching native!

            }

            // all distinct glyph codes requested (partially filled)

            final int[] filteredCodes = new int[missed];

            // indices into filteredCodes array (totally filled)

            final int[] filteredIndicies = new int[missed];

            // scan, mark, and store the requested glyph codes again to

            // send into native

            int j = 0;

            int dupes = 0;

            for (int i = 0; i < len; i++) {

                if (images[i] != 0L) continue; // already filled

                final int code = glyphCodes[i];

                // we have already promised to strike this glyph - this is

                // a dupe

                if (glyphInfoCache.get(code) == -1L) {

                    filteredIndicies[j] = -1;

                    dupes++;

                    j++;

                    continue;

                }

                // this is a distinct glyph we have not struck before, or

                // promised to strike mark this one as "promise to strike"

                // in the global cache with a -1L

                final int k = j - dupes;

                filteredCodes[k] = code;

                glyphInfoCache.put(code, -1L);

                filteredIndicies[j] = k;

                j++;

            }

            final int filteredRunLen = j - dupes;

            final long[] filteredImages = new long[filteredRunLen];

            // bulk call to fill in the distinct glyph pointers from native

            getFilteredGlyphImagePtrs(filteredImages, filteredCodes, filteredRunLen);

            // scan the requested glyph list, and fill in pointers from our

            // distinct glyph list which has been filled from native

            j = 0;

            for (int i = 0; i < len; i++) {

                if (images[i] != 0L && images[i] != -1L) {

                    continue; // already placed

                }

                // index into filteredImages array

                final int k = filteredIndicies[j];

                final int code = glyphCodes[i];

                if (k == -1L) {

                    // we should have already filled the cache with this pointer

                    images[i] = glyphInfoCache.get(code);

                } else {

                    // fill the particular glyph code request, and store

                    // in the cache

                    final long ptr = filteredImages[k];

                    images[i] = ptr;

                    glyphInfoCache.put(code, ptr);

                }

                j++;

            }

        }

    }

    private void getFilteredGlyphImagePtrs(long[] glyphInfos,

                                           int[] uniCodes, int len)

    {

        getGlyphImagePtrsNative(getNativeStrikePtr(), glyphInfos, uniCodes, len);

    }

    private float getCachedNativeGlyphAdvance(int glyphCode) {

        synchronized(glyphAdvanceCache) {

            float advance = glyphAdvanceCache.get(glyphCode);

            if (advance != 0) {

                return advance;

            }

            advance = getNativeGlyphAdvance(getNativeStrikePtr(), glyphCode);

            glyphAdvanceCache.put(glyphCode, advance);

            return advance;

        }

    }

    // This class stores glyph pointers, and is indexed based on glyph codes,

    // and negative unicode values.  See the comments in

    // CCharToGlyphMapper for more details on our glyph code strategy.

    private static class GlyphInfoCache extends CStrikeDisposer {

        private static final int FIRST_LAYER_SIZE = 256;

        private static final int SECOND_LAYER_SIZE = 16384; // 16384 = 128x128

        // rdar://problem/5204197

        private boolean disposed = false;

        private final long[] firstLayerCache;

        private SparseBitShiftingTwoLayerArray secondLayerCache;

        private HashMap<Integer, Long> generalCache;

        public GlyphInfoCache(final Font2D nativeFont,

                              final FontStrikeDesc desc)

        {

            super(nativeFont, desc);

            firstLayerCache = new long[FIRST_LAYER_SIZE];

        }

        public synchronized long get(final int index) {

            if (index < 0) {

                if (-index < SECOND_LAYER_SIZE) {

                    // catch common unicodes

                    if (secondLayerCache == null) {

                        return 0L;

                    }

                    return secondLayerCache.get(-index);

                }

            } else {

                if (index < FIRST_LAYER_SIZE) {

                    // catch common glyphcodes

                    return firstLayerCache[index];

                }

            }

            if (generalCache == null) {

                return 0L;

            }

            final Long value = generalCache.get(new Integer(index));

            if (value == null) {

                return 0L;

            }

            return value.longValue();

        }

        public synchronized void put(final int index, final long value) {

            if (index < 0) {

                if (-index < SECOND_LAYER_SIZE) {

                    // catch common unicodes

                    if (secondLayerCache == null) {

                        secondLayerCache = new SparseBitShiftingTwoLayerArray(SECOND_LAYER_SIZE, 7); // 128x128

                    }

                    secondLayerCache.put(-index, value);

                    return;

                }

            } else {

                if (index < FIRST_LAYER_SIZE) {

                    // catch common glyphcodes

                    firstLayerCache[index] = value;

                    return;

                }

            }

            if (generalCache == null) {

                generalCache = new HashMap<Integer, Long>();

            }

            generalCache.put(new Integer(index), new Long(value));

        }

        public synchronized void dispose() {

            // rdar://problem/5204197

            // Note that sun.font.Font2D.getStrike() actively disposes

            // cleared strikeRef.  We need to check the disposed flag to

            // prevent double frees of native resources.

            if (disposed) {

                return;

            }

            super.dispose();

            // clean out the first array

            disposeLongArray(firstLayerCache);

            // clean out the two layer arrays

            if (secondLayerCache != null) {

                final long[][] secondLayerLongArrayArray = secondLayerCache.cache;

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

                    final long[] longArray = secondLayerLongArrayArray[i];

                    if (longArray != null) disposeLongArray(longArray);

                }

            }

            // clean up everyone else

            if (generalCache != null) {

                final Iterator<Long> i = generalCache.values().iterator();

                while (i.hasNext()) {

                    final long longValue = i.next().longValue();

                    if (longValue != -1 && longValue != 0) StrikeCache.freeLongPointer(longValue);

                }

            }

            // rdar://problem/5204197

            // Finally, set the flag.

            disposed = true;

        }

        private static void disposeLongArray(final long[] longArray) {

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

                final long ptr = longArray[i];

                if (ptr != 0 && ptr != -1) StrikeCache.freeLongPointer(ptr); // free's the native struct pointer

            }

        }

        private static class SparseBitShiftingTwoLayerArray {

            final long[][] cache;

            final int shift;

            final int secondLayerLength;

            public SparseBitShiftingTwoLayerArray(final int size, final int shift) {

                this.shift = shift;

                this.cache = new long[1 << shift][];

                this.secondLayerLength = size >> shift;

            }