/*

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

 */

package sun.font;

import java.lang.ref.SoftReference;

import java.awt.Font;

import java.awt.GraphicsEnvironment;

import java.awt.Rectangle;

import java.awt.geom.AffineTransform;

import java.awt.geom.GeneralPath;

import java.awt.geom.NoninvertibleTransformException;

import java.awt.geom.Point2D;

import java.awt.geom.Rectangle2D;

import java.util.concurrent.ConcurrentHashMap;

import static sun.awt.SunHints.*;

public class FileFontStrike extends PhysicalStrike {

    /* fffe and ffff are values we specially interpret as meaning

     * invisible glyphs.

     */

    static final int INVISIBLE_GLYPHS = 0x0fffe;

    private FileFont fileFont;

    /* REMIND: replace this scheme with one that installs a cache

     * instance of the appropriate type. It will require changes in

     * FontStrikeDisposer and NativeStrike etc.

     */

    private static final int UNINITIALISED = 0;

    private static final int INTARRAY      = 1;

    private static final int LONGARRAY     = 2;

    private static final int SEGINTARRAY   = 3;

    private static final int SEGLONGARRAY  = 4;

    private int glyphCacheFormat = UNINITIALISED;

    /* segmented arrays are blocks of 256 */

    private static final int SEGSHIFT = 8;

    private static final int SEGSIZE  = 1 << SEGSHIFT;

    private boolean segmentedCache;

    private int[][] segIntGlyphImages;

    private long[][] segLongGlyphImages;

    /* The "metrics" information requested by clients is usually nothing

     * more than the horizontal advance of the character.

     * In most cases this advance and other metrics information is stored

     * in the glyph image cache.

     * But in some cases we do not automatically retrieve the glyph

     * image when the advance is requested. In those cases we want to

     * cache the advances since this has been shown to be important for

     * performance.

     * The segmented cache is used in cases when the single array

     * would be too large.

     */

    private float[] horizontalAdvances;

    private float[][] segHorizontalAdvances;

    /* Outline bounds are used when printing and when drawing outlines

     * to the screen. On balance the relative rarity of these cases

     * and the fact that getting this requires generating a path at

     * the scaler level means that its probably OK to store these

     * in a Java-level hashmap as the trade-off between time and space.

     * Later can revisit whether to cache these at all, or elsewhere.

     * Should also profile whether subsequent to getting the bounds, the

     * outline itself is also requested. The 1.4 implementation doesn't

     * cache outlines so you could generate the path twice - once to get

     * the bounds and again to return the outline to the client.

     * If the two uses are coincident then also look into caching outlines.

     * One simple optimisation is that we could store the last single

     * outline retrieved. This assumes that bounds then outline will always

     * be retrieved for a glyph rather than retrieving bounds for all glyphs

     * then outlines for all glyphs.

     */

    ConcurrentHashMap<Integer, Rectangle2D.Float> boundsMap;

    SoftReference<ConcurrentHashMap<Integer, Point2D.Float>>

        glyphMetricsMapRef;

    AffineTransform invertDevTx;

    boolean useNatives;

    NativeStrike[] nativeStrikes;

    /* Used only for communication to native layer */

    private int intPtSize;

    /* Perform global initialisation needed for Windows native rasterizer */

    private static native boolean initNative();

    private static boolean isXPorLater = false;

    static {

        if (FontManager.isWindows && !FontManager.useT2K &&

            !GraphicsEnvironment.isHeadless()) {

            isXPorLater = initNative();

        }

    }

    FileFontStrike(FileFont fileFont, FontStrikeDesc desc) {

        super(fileFont, desc);

        this.fileFont = fileFont;

        if (desc.style != fileFont.style) {

          /* If using algorithmic styling, the base values are

           * boldness = 1.0, italic = 0.0. The superclass constructor

           * initialises these.

           */

            if ((desc.style & Font.ITALIC) == Font.ITALIC &&

                (fileFont.style & Font.ITALIC) == 0) {

                algoStyle = true;

                italic = 0.7f;

            }

            if ((desc.style & Font.BOLD) == Font.BOLD &&

                ((fileFont.style & Font.BOLD) == 0)) {

                algoStyle = true;

                boldness = 1.33f;

            }

        }

        double[] matrix = new double[4];

        AffineTransform at = desc.glyphTx;

        at.getMatrix(matrix);

        if (!desc.devTx.isIdentity() &&

            desc.devTx.getType() != AffineTransform.TYPE_TRANSLATION) {

            try {

                invertDevTx = desc.devTx.createInverse();

            } catch (NoninvertibleTransformException e) {

            }

        }

        /* If any of the values is NaN then substitute the null scaler context.

         * This will return null images, zero advance, and empty outlines

         * as no rendering need take place in this case.

         * We pass in the null scaler as the singleton null context

         * requires it. However

         */

        if (Double.isNaN(matrix[0]) || Double.isNaN(matrix[1]) ||

            Double.isNaN(matrix[2]) || Double.isNaN(matrix[3]) ||

            fileFont.getScaler() == null) {

            pScalerContext = NullFontScaler.getNullScalerContext();

        } else {

            pScalerContext = fileFont.getScaler().createScalerContext(matrix,

                                    fileFont instanceof TrueTypeFont,

                                    desc.aaHint, desc.fmHint,

                                    boldness, italic);

        }

        mapper = fileFont.getMapper();

        int numGlyphs = mapper.getNumGlyphs();

        /* Always segment for fonts with > 2K glyphs, but also for smaller

         * fonts with non-typical sizes and transforms.

         * Segmenting for all non-typical pt sizes helps to minimise memory

         * usage when very many distinct strikes are created.

         * The size range of 0->5 and 37->INF for segmenting is arbitrary

         * but the intention is that typical GUI integer point sizes (6->36)

         * should not segment unless there's another reason to do so.

         */

        float ptSize = (float)matrix[3]; // interpreted only when meaningful.

        int iSize = intPtSize = (int)ptSize;

        boolean isSimpleTx = (at.getType() & complexTX) == 0;

        segmentedCache =

            (numGlyphs > SEGSIZE << 3) ||

            ((numGlyphs > SEGSIZE << 1) &&

             (!isSimpleTx || ptSize != iSize || iSize < 6 || iSize > 36));

        /* This can only happen if we failed to allocate memory for context.

         * NB: in such case we may still have some memory in java heap

         *     but subsequent attempt to allocate null scaler context

         *     may fail too (cause it is allocate in the native heap).

         *     It is not clear how to make this more robust but on the

         *     other hand getting NULL here seems to be extremely unlikely.

         */

        if (pScalerContext == 0L) {

            /* REMIND: when the code is updated to install cache objects

             * rather than using a switch this will be more efficient.

             */

            this.disposer = new FontStrikeDisposer(fileFont, desc);

            initGlyphCache();

            pScalerContext = NullFontScaler.getNullScalerContext();

            FontManager.deRegisterBadFont(fileFont);

            return;

        }

        /* First, see if native code should be used to create the glyph.

         * GDI will return the integer metrics, not fractional metrics, which

         * may be requested for this strike, so we would require here that :

         * desc.fmHint != INTVAL_FRACTIONALMETRICS_ON

         * except that the advance returned by GDI is always overwritten by

         * the JDK rasteriser supplied one (see getGlyphImageFromWindows()).

         */

        if (FontManager.isWindows && isXPorLater &&

            !FontManager.useT2K &&

            !GraphicsEnvironment.isHeadless() &&

            !fileFont.useJavaRasterizer &&

            (desc.aaHint == INTVAL_TEXT_ANTIALIAS_LCD_HRGB ||

             desc.aaHint == INTVAL_TEXT_ANTIALIAS_LCD_HBGR) &&

            (matrix[1] == 0.0 && matrix[2] == 0.0 &&

             matrix[0] == matrix[3] &&

             matrix[0] >= 3.0 && matrix[0] <= 100.0) &&

            !((TrueTypeFont)fileFont).useEmbeddedBitmapsForSize(intPtSize)) {

            useNatives = true;

        }

        else if (fileFont.checkUseNatives() && desc.aaHint==0 && !algoStyle) {

            /* Check its a simple scale of a pt size in the range

             * where native bitmaps typically exist (6-36 pts) */

            if (matrix[1] == 0.0 && matrix[2] == 0.0 &&

                matrix[0] >= 6.0 && matrix[0] <= 36.0 &&

                matrix[0] == matrix[3]) {

                useNatives = true;

                int numNatives = fileFont.nativeFonts.length;

                nativeStrikes = new NativeStrike[numNatives];

                /* Maybe initialise these strikes lazily?. But we

                 * know we need at least one

                 */

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

                    nativeStrikes[i] =

                        new NativeStrike(fileFont.nativeFonts[i], desc, false);

                }

            }

        }

        if (FontManager.logging && FontManager.isWindows) {

            FontManager.logger.info

                ("Strike for " + fileFont + " at size = " + intPtSize +

                 " use natives = " + useNatives +

                 " useJavaRasteriser = " + fileFont.useJavaRasterizer +

                 " AAHint = " + desc.aaHint +

                 " Has Embedded bitmaps = " +

                 ((TrueTypeFont)fileFont).

                 useEmbeddedBitmapsForSize(intPtSize));

        }

        this.disposer = new FontStrikeDisposer(fileFont, desc, pScalerContext);

        /* Always get the image and the advance together for smaller sizes

         * that are likely to be important to rendering performance.

         * The pixel size of 48.0 can be thought of as

         * "maximumSizeForGetImageWithAdvance".

         * This should be no greater than OutlineTextRender.THRESHOLD.

         */

        double maxSz = 48.0;

        getImageWithAdvance =

            Math.abs(at.getScaleX()) <= maxSz &&

            Math.abs(at.getScaleY()) <= maxSz &&

            Math.abs(at.getShearX()) <= maxSz &&

            Math.abs(at.getShearY()) <= maxSz;

        /* Some applications request advance frequently during layout.

         * If we are not getting and caching the image with the advance,

         * there is a potentially significant performance penalty if the

         * advance is repeatedly requested before requesting the image.

         * We should at least cache the horizontal advance.

         * REMIND: could use info in the font, eg hmtx, to retrieve some

         * advances. But still want to cache it here.

         */

        if (!getImageWithAdvance) {

            if (!segmentedCache) {

                horizontalAdvances = new float[numGlyphs];

                /* use max float as uninitialised advance */

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

                    horizontalAdvances[i] = Float.MAX_VALUE;

                }

            } else {

                int numSegments = (numGlyphs + SEGSIZE-1)/SEGSIZE;

                segHorizontalAdvances = new float[numSegments][];

            }

        }

    }

    /* A number of methods are delegated by the strike to the scaler

     * context which is a shared resource on a physical font.

     */

    public int getNumGlyphs() {

        return fileFont.getNumGlyphs();

    }

    long getGlyphImageFromNative(int glyphCode) {

        if (FontManager.isWindows) {

            return getGlyphImageFromWindows(glyphCode);

        } else {

            return getGlyphImageFromX11(glyphCode);

        }

    }

    /* There's no global state conflicts, so this method is not

     * presently synchronized.

     */

    private native long _getGlyphImageFromWindows(String family,

                                                  int style,

                                                  int size,

                                                  int glyphCode,

                                                  boolean fracMetrics);

    long getGlyphImageFromWindows(int glyphCode) {

        String family = fileFont.getFamilyName(null);

        int style = desc.style & Font.BOLD | desc.style & Font.ITALIC

            | fileFont.getStyle();

        int size = intPtSize;

        long ptr = _getGlyphImageFromWindows

            (family, style, size, glyphCode,

             desc.fmHint == INTVAL_FRACTIONALMETRICS_ON);

        if (ptr != 0) {

            /* Get the advance from the JDK rasterizer. This is mostly

             * necessary for the fractional metrics case, but there are

             * also some very small number (<0.25%) of marginal cases where

             * there is some rounding difference between windows and JDK.

             * After these are resolved, we can restrict this extra

             * work to the FM case.

             */

            float advance = getGlyphAdvance(glyphCode, false);

            StrikeCache.unsafe.putFloat(ptr + StrikeCache.xAdvanceOffset,

                                        advance);

            return ptr;

        } else {

            return fileFont.getGlyphImage(pScalerContext, glyphCode);

        }

    }

    /* Try the native strikes first, then try the fileFont strike */

    long getGlyphImageFromX11(int glyphCode) {

        long glyphPtr;

        char charCode = fileFont.glyphToCharMap[glyphCode];

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

            CharToGlyphMapper mapper = fileFont.nativeFonts[i].getMapper();

            int gc = mapper.charToGlyph(charCode)&0xffff;

            if (gc != mapper.getMissingGlyphCode()) {

                glyphPtr = nativeStrikes[i].getGlyphImagePtrNoCache(gc);

                if (glyphPtr != 0L) {

                    return glyphPtr;

                }

            }

        }

        return fileFont.getGlyphImage(pScalerContext, glyphCode);

    }

    long getGlyphImagePtr(int glyphCode) {

        if (glyphCode >= INVISIBLE_GLYPHS) {

            return StrikeCache.invisibleGlyphPtr;

        }

        long glyphPtr = 0L;

        if ((glyphPtr = getCachedGlyphPtr(glyphCode)) != 0L) {

            return glyphPtr;

        } else {

            if (useNatives) {

                glyphPtr = getGlyphImageFromNative(glyphCode);

                if (glyphPtr == 0L && FontManager.logging) {

                    FontManager.logger.info

                        ("Strike for " + fileFont +

                         " at size = " + intPtSize +

                         " couldn't get native glyph for code = " + glyphCode);

                 }

            } if (glyphPtr == 0L) {

                glyphPtr = fileFont.getGlyphImage(pScalerContext,

                                                  glyphCode);

            }

            return setCachedGlyphPtr(glyphCode, glyphPtr);

        }

    }

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

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

            int glyphCode = glyphCodes[i];

            if (glyphCode >= INVISIBLE_GLYPHS) {

                images[i] = StrikeCache.invisibleGlyphPtr;

                continue;

            } else if ((images[i] = getCachedGlyphPtr(glyphCode)) != 0L) {

                continue;

            } else {

                long glyphPtr = 0L;

                if (useNatives) {

                    glyphPtr = getGlyphImageFromNative(glyphCode);

                } if (glyphPtr == 0L) {

                    glyphPtr = fileFont.getGlyphImage(pScalerContext,

                                                      glyphCode);

                }

                images[i] = setCachedGlyphPtr(glyphCode, glyphPtr);

            }

        }

    }

    /* The following method is called from CompositeStrike as a special case.

     */

    private static final int SLOTZEROMAX = 0xffffff;

    int getSlot0GlyphImagePtrs(int[] glyphCodes, long[] images, int len) {

        int convertedCnt = 0;

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

            int glyphCode = glyphCodes[i];

            if (glyphCode >= SLOTZEROMAX) {

                return convertedCnt;

            } else {

                convertedCnt++;

            }

            if (glyphCode >= INVISIBLE_GLYPHS) {

                images[i] = StrikeCache.invisibleGlyphPtr;

                continue;

            } else if ((images[i] = getCachedGlyphPtr(glyphCode)) != 0L) {

                continue;

            } else {

                long glyphPtr = 0L;

                if (useNatives) {

                    glyphPtr = getGlyphImageFromNative(glyphCode);

                }

                if (glyphPtr == 0L) {

                    glyphPtr = fileFont.getGlyphImage(pScalerContext,

                                                      glyphCode);

                }

                images[i] = setCachedGlyphPtr(glyphCode, glyphPtr);

            }

        }

        return convertedCnt;

    }

    /* Only look in the cache */

    long getCachedGlyphPtr(int glyphCode) {

        switch (glyphCacheFormat) {

            case INTARRAY:

                return intGlyphImages[glyphCode] & INTMASK;

            case SEGINTARRAY:

                int segIndex = glyphCode >> SEGSHIFT;

                if (segIntGlyphImages[segIndex] != null) {

                    int subIndex = glyphCode % SEGSIZE;

                    return segIntGlyphImages[segIndex][subIndex] & INTMASK;

                } else {

                    return 0L;

                }

            case LONGARRAY:

                return longGlyphImages[glyphCode];

            case SEGLONGARRAY:

                segIndex = glyphCode >> SEGSHIFT;

                if (segLongGlyphImages[segIndex] != null) {

                    int subIndex = glyphCode % SEGSIZE;

                    return segLongGlyphImages[segIndex][subIndex];

                } else {

                    return 0L;

                }

        }

        /* If reach here cache is UNINITIALISED. */

        return 0L;

    }

    private synchronized long setCachedGlyphPtr(int glyphCode, long glyphPtr) {

        switch (glyphCacheFormat) {

            case INTARRAY:

                if (intGlyphImages[glyphCode] == 0) {

                    intGlyphImages[glyphCode] = (int)glyphPtr;

                    return glyphPtr;

                } else {

                    StrikeCache.freeIntPointer((int)glyphPtr);

                    return intGlyphImages[glyphCode] & INTMASK;

                }

            case SEGINTARRAY:

                int segIndex = glyphCode >> SEGSHIFT;

                int subIndex = glyphCode % SEGSIZE;

                if (segIntGlyphImages[segIndex] == null) {

                    segIntGlyphImages[segIndex] = new int[SEGSIZE];

                }

                if (segIntGlyphImages[segIndex][subIndex] == 0) {

                    segIntGlyphImages[segIndex][subIndex] = (int)glyphPtr;

                    return glyphPtr;

                } else {

                    StrikeCache.freeIntPointer((int)glyphPtr);

                    return segIntGlyphImages[segIndex][subIndex] & INTMASK;

                }

            case LONGARRAY:

                if (longGlyphImages[glyphCode] == 0L) {

                    longGlyphImages[glyphCode] = glyphPtr;

                    return glyphPtr;

                } else {

                    StrikeCache.freeLongPointer(glyphPtr);

                    return longGlyphImages[glyphCode];

                }

           case SEGLONGARRAY:

                segIndex = glyphCode >> SEGSHIFT;

                subIndex = glyphCode % SEGSIZE;

                if (segLongGlyphImages[segIndex] == null) {

                    segLongGlyphImages[segIndex] = new long[SEGSIZE];

                }

                if (segLongGlyphImages[segIndex][subIndex] == 0L) {

                    segLongGlyphImages[segIndex][subIndex] = glyphPtr;

                    return glyphPtr;

                } else {

                    StrikeCache.freeLongPointer(glyphPtr);

                    return segLongGlyphImages[segIndex][subIndex];

                }

        }

        /* Reach here only when the cache is not initialised which is only

         * for the first glyph to be initialised in the strike.

         * Initialise it and recurse. Note that we are already synchronized.

         */

        initGlyphCache();