/*

 * Copyright (c) 2011, 2013, 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.

 */

#import <Accelerate/Accelerate.h> // for vImage_Buffer

#import <JavaNativeFoundation/JavaNativeFoundation.h>

#import "CGGlyphImages.h"

#import "CoreTextSupport.h"

#import "fontscalerdefs.h" // contains the definition of GlyphInfo struct

#import "sun_awt_SunHints.h"

//#define USE_IMAGE_ALIGNED_MEMORY 1

//#define CGGI_DEBUG 1

//#define CGGI_DEBUG_DUMP 1

//#define CGGI_DEBUG_HIT_COUNT 1

#define PRINT_TX(x) \

    NSLog(@"(%f, %f, %f, %f, %f, %f)", x.a, x.b, x.c, x.d, x.tx, x.ty);

/*

 * The GlyphCanvas is a global shared CGContext that characters are struck into.

 * For each character, the glyph is struck, copied into a GlyphInfo struct, and

 * the canvas is cleared for the next glyph.

 *

 * If the necessary canvas is too large, the shared one will not be used and a

 * temporary one will be provided.

 */

@interface CGGI_GlyphCanvas : NSObject {

@public

    CGContextRef context;

    vImage_Buffer *image;

}

@end;

@implementation CGGI_GlyphCanvas

@end

#pragma mark --- Debugging Helpers ---

/*

 * These debug functions are only compiled when CGGI_DEBUG is activated.

 * They will print out a full UInt8 canvas and any pixels struck (assuming

 * the canvas is not too big).

 *

 * As another debug feature, the entire canvas will be filled with a light

 * alpha value so it is easy to see where the glyph painting regions are

 * at runtime.

 */

#ifdef CGGI_DEBUG_DUMP

static void

DUMP_PIXELS(const char msg[], const UInt8 pixels[],

            const size_t bytesPerPixel, const int width, const int height)

{

    printf("| %s: (%d, %d)\n", msg, width, height);

    if (width > 80 || height > 80) {

        printf("| too big\n");

        return;

    }

    size_t i, j = 0, k, size = width * height;

    for (i = 0; i < size; i++) {

        for (k = 0; k < bytesPerPixel; k++) {

            if (pixels[i * bytesPerPixel + k] > 0x80) j++;

        }

    }

    if (j == 0) {

        printf("| empty\n");

        return;

    }

    printf("|_");

    int x, y;

    for (x = 0; x < width; x++) {

        printf("__");

    }

    printf("_\n");

    for (y = 0; y < height; y++) {

        printf("| ");

        for (x = 0; x < width; x++) {

            int p = 0;

            for(k = 0; k < bytesPerPixel; k++) {

                p += pixels[(y * width + x) * bytesPerPixel + k];

            }

            if (p < 0x80) {

                printf("  ");

            } else {

                printf("[]");

            }

        }

        printf(" |\n");

    }

}

static void

DUMP_IMG_PIXELS(const char msg[], const vImage_Buffer *image)

{

    const void *pixels = image->data;

    const size_t pixelSize = image->rowBytes / image->width;

    const size_t width = image->width;

    const size_t height = image->height;

    DUMP_PIXELS(msg, pixels, pixelSize, width, height);

}

static void

PRINT_CGSTATES_INFO(const CGContextRef cgRef)

{

    // TODO(cpc): lots of SPI use in this method; remove/rewrite?

#if 0

    CGRect clip = CGContextGetClipBoundingBox(cgRef);

    fprintf(stderr, "    clip: ((%f, %f), (%f, %f))\n",

            clip.origin.x, clip.origin.y, clip.size.width, clip.size.height);

    CGAffineTransform ctm = CGContextGetCTM(cgRef);

    fprintf(stderr, "    ctm: (%f, %f, %f, %f, %f, %f)\n",

            ctm.a, ctm.b, ctm.c, ctm.d, ctm.tx, ctm.ty);

    CGAffineTransform txtTx = CGContextGetTextMatrix(cgRef);

    fprintf(stderr, "    txtTx: (%f, %f, %f, %f, %f, %f)\n",

            txtTx.a, txtTx.b, txtTx.c, txtTx.d, txtTx.tx, txtTx.ty);

    if (CGContextIsPathEmpty(cgRef) == 0) {

        CGPoint pathpoint = CGContextGetPathCurrentPoint(cgRef);

        CGRect pathbbox = CGContextGetPathBoundingBox(cgRef);

        fprintf(stderr, "    [pathpoint: (%f, %f)] [pathbbox: ((%f, %f), (%f, %f))]\n",

                pathpoint.x, pathpoint.y, pathbbox.origin.x, pathbbox.origin.y,

                pathbbox.size.width, pathbbox.size.width);

    }

    CGFloat linewidth = CGContextGetLineWidth(cgRef);

    CGLineCap linecap = CGContextGetLineCap(cgRef);

    CGLineJoin linejoin = CGContextGetLineJoin(cgRef);

    CGFloat miterlimit = CGContextGetMiterLimit(cgRef);

    size_t dashcount = CGContextGetLineDashCount(cgRef);

    fprintf(stderr, "    [linewidth: %f] [linecap: %d] [linejoin: %d] [miterlimit: %f] [dashcount: %lu]\n",

            linewidth, linecap, linejoin, miterlimit, (unsigned long)dashcount);

    CGFloat smoothness = CGContextGetSmoothness(cgRef);

    bool antialias = CGContextGetShouldAntialias(cgRef);

    bool smoothfont = CGContextGetShouldSmoothFonts(cgRef);

    JRSFontRenderingStyle fRendMode = CGContextGetFontRenderingMode(cgRef);

    fprintf(stderr, "    [smoothness: %f] [antialias: %d] [smoothfont: %d] [fontrenderingmode: %d]\n",

            smoothness, antialias, smoothfont, fRendMode);

#endif

}

#endif

#ifdef CGGI_DEBUG

static void

DUMP_GLYPHINFO(const GlyphInfo *info)

{

    printf("size: (%d, %d) pixelSize: %d\n",

           info->width, info->height, info->rowBytes / info->width);

    printf("adv: (%f, %f) top: (%f, %f)\n",

           info->advanceX, info->advanceY, info->topLeftX, info->topLeftY);

#ifdef CGGI_DEBUG_DUMP

    DUMP_PIXELS("Glyph Info Struct",

                info->image, info->rowBytes / info->width,

                info->width, info->height);

#endif

}

#endif

#pragma mark --- Font Rendering Mode Descriptors ---

static inline void

CGGI_CopyARGBPixelToRGBPixel(const UInt32 p, UInt8 *dst)

{

}

static void

CGGI_CopyImageFromCanvasToRGBInfo(CGGI_GlyphCanvas *canvas, GlyphInfo *info)

{

    UInt32 *src = (UInt32 *)canvas->image->data;

    size_t srcRowWidth = canvas->image->width;

    UInt8 *dest = (UInt8 *)info->image;

    size_t destRowWidth = info->width;

    size_t height = info->height;

    size_t y;

    for (y = 0; y < height; y++) {

        size_t destRow = y * destRowWidth * 3;

        size_t srcRow = y * srcRowWidth;

        size_t x;

        for (x = 0; x < destRowWidth; x++) {

            CGGI_CopyARGBPixelToRGBPixel(src[srcRow + x],

                                         dest + destRow + x * 3);

        }

    }

}

//static void CGGI_copyImageFromCanvasToAlphaInfo

//(CGGI_GlyphCanvas *canvas, GlyphInfo *info)

//{

//    vImage_Buffer infoBuffer;

//    infoBuffer.data = info->image;

//    infoBuffer.width = info->width;

//    infoBuffer.height = info->height;

//    infoBuffer.rowBytes = info->width; // three bytes per RGB pixel

//

//    UInt8 scrapPixel[info->width * info->height];

//    vImage_Buffer scrapBuffer;

//    scrapBuffer.data = &scrapPixel;

//    scrapBuffer.width = info->width;

//    scrapBuffer.height = info->height;

//    scrapBuffer.rowBytes = info->width;

//

//    vImageConvert_ARGB8888toPlanar8(canvas->image, &infoBuffer,

//        &scrapBuffer, &scrapBuffer, &scrapBuffer, kvImageNoFlags);

//}

static inline UInt8

{

}

static void

CGGI_CopyImageFromCanvasToAlphaInfo(CGGI_GlyphCanvas *canvas, GlyphInfo *info)

{

    UInt32 *src = (UInt32 *)canvas->image->data;

    size_t srcRowWidth = canvas->image->width;

    UInt8 *dest = (UInt8 *)info->image;

    size_t destRowWidth = info->width;

    size_t height = info->height;

    size_t y;

    for (y = 0; y < height; y++) {

        size_t destRow = y * destRowWidth;

        size_t srcRow = y * srcRowWidth;

        size_t x;

        for (x = 0; x < destRowWidth; x++) {

            UInt32 p = src[srcRow + x];

        }

    }

}

#pragma mark --- Pixel Size, Modes, and Canvas Shaping Helper Functions ---

typedef struct CGGI_GlyphInfoDescriptor {

    size_t pixelSize;

    void (*copyFxnPtr)(CGGI_GlyphCanvas *canvas, GlyphInfo *info);

} CGGI_GlyphInfoDescriptor;

typedef struct CGGI_RenderingMode {

    CGGI_GlyphInfoDescriptor *glyphDescriptor;

    JRSFontRenderingStyle cgFontMode;

} CGGI_RenderingMode;

static CGGI_GlyphInfoDescriptor grey =

    { 1, &CGGI_CopyImageFromCanvasToAlphaInfo };

static CGGI_GlyphInfoDescriptor rgb =

    { 3, &CGGI_CopyImageFromCanvasToRGBInfo };

static inline CGGI_RenderingMode

CGGI_GetRenderingMode(const AWTStrike *strike)

{

    CGGI_RenderingMode mode;

    mode.cgFontMode = strike->fStyle;

    switch (strike->fAAStyle) {

    case sun_awt_SunHints_INTVAL_TEXT_ANTIALIAS_OFF:

    case sun_awt_SunHints_INTVAL_TEXT_ANTIALIAS_ON:

        mode.glyphDescriptor = &grey;

        break;

    case sun_awt_SunHints_INTVAL_TEXT_ANTIALIAS_LCD_HRGB:

    case sun_awt_SunHints_INTVAL_TEXT_ANTIALIAS_LCD_HBGR:

    case sun_awt_SunHints_INTVAL_TEXT_ANTIALIAS_LCD_VRGB:

    case sun_awt_SunHints_INTVAL_TEXT_ANTIALIAS_LCD_VBGR:

        mode.glyphDescriptor = &rgb;

        break;

    }

    return mode;

}

#pragma mark --- Canvas Managment ---

/*

 * Creates a new canvas of a fixed size, and initializes the CGContext as

 * an 32-bit ARGB BitmapContext with some generic RGB color space.

 */

static inline void

CGGI_InitCanvas(CGGI_GlyphCanvas *canvas,

{

    // our canvas is *always* 4-byte ARGB

    size_t bytesPerRow = width * sizeof(UInt32);

    size_t byteCount = bytesPerRow * height;

    canvas->image = malloc(sizeof(vImage_Buffer));

    canvas->image->width = width;

    canvas->image->height = height;

    canvas->image->rowBytes = bytesPerRow;

    if (canvas->image->data == NULL) {

        [[NSException exceptionWithName:NSMallocException

            reason:@"Failed to allocate memory for the buffer which backs the CGContext for glyph strikes." userInfo:nil] raise];

    }

    canvas->context = CGBitmapContextCreate(canvas->image->data,

                                            width, height, 8, bytesPerRow,

                                            colorSpace,

    CGContextSetRGBFillColor(canvas->context, 0.0f, 0.0f, 0.0f, 1.0f);

    CGContextSetFontSize(canvas->context, 1);

    CGContextSaveGState(canvas->context);

    CGColorSpaceRelease(colorSpace);

}

/*

 * Releases the BitmapContext and the associated memory backing it.

 */

static inline void

CGGI_FreeCanvas(CGGI_GlyphCanvas *canvas)

{

    if (canvas->context != NULL) {

        CGContextRelease(canvas->context);

    }

    if (canvas->image != NULL) {

        if (canvas->image->data != NULL) {

            free(canvas->image->data);

        }

        free(canvas->image);

    }

}

/*

 * This is the slack space that is preallocated for the global GlyphCanvas

 * when it needs to be expanded. It has been set somewhat liberally to

 * avoid re-upsizing frequently.

 */

#define CGGI_GLYPH_CANVAS_SLACK 2.5

/*

 * Quick and easy inline to check if this canvas is big enough.

 */

static inline void

{

    if (canvas->image != NULL &&

        width  < canvas->image->width &&

        height < canvas->image->height)

    {

        return;

    }

    // if we don't have enough space to strike the largest glyph in the

    // run, resize the canvas

    CGGI_FreeCanvas(canvas);

    CGGI_InitCanvas(canvas,

                    width * CGGI_GLYPH_CANVAS_SLACK,

}

/*

 * Clear the canvas by blitting white only into the region of interest

 * (the rect which we will copy out of once the glyph is struck).

 */

static inline void

CGGI_ClearCanvas(CGGI_GlyphCanvas *canvas, GlyphInfo *info)

{

    vImage_Buffer canvasRectToClear;

    canvasRectToClear.data = canvas->image->data;

    canvasRectToClear.height = info->height;

    canvasRectToClear.width = info->width;

    // use the row stride of the canvas, not the info

    canvasRectToClear.rowBytes = canvas->image->rowBytes;

    // clean the canvas

#ifdef CGGI_DEBUG

    Pixel_8888 opaqueWhite = { 0xE0, 0xE0, 0xE0, 0xE0 };

#else

    Pixel_8888 opaqueWhite = { 0xFF, 0xFF, 0xFF, 0xFF };

#endif

    vImageBufferFill_ARGB8888(&canvasRectToClear, opaqueWhite, kvImageNoFlags);

}

#pragma mark --- GlyphInfo Creation & Copy Functions ---

/*

 * Creates a GlyphInfo with exactly the correct size image and measurements.

 */

#define CGGI_GLYPH_BBOX_PADDING 2.0f

static inline GlyphInfo *

CGGI_CreateNewGlyphInfoFrom(CGSize advance, CGRect bbox,

                            const AWTStrike *strike,

                            const CGGI_RenderingMode *mode)

{

    size_t pixelSize = mode->glyphDescriptor->pixelSize;

    // adjust the bounding box to be 1px bigger on each side than what

    // CGFont-whatever suggests - because it gives a bounding box that

    // is too tight

    bbox.size.width += CGGI_GLYPH_BBOX_PADDING * 2.0f;

    bbox.size.height += CGGI_GLYPH_BBOX_PADDING * 2.0f;

    bbox.origin.x -= CGGI_GLYPH_BBOX_PADDING;

    bbox.origin.y -= CGGI_GLYPH_BBOX_PADDING;

    vImagePixelCount width = ceilf(bbox.size.width);

    vImagePixelCount height = ceilf(bbox.size.height);

    // if the glyph is larger than 1MB, don't even try...

    // the GlyphVector path should have taken over by now

    // and zero pixels is ok

    if (width * height > 1024 * 1024) {

        width = 1;

        height = 1;

    }

    advance = CGSizeApplyAffineTransform(advance, strike->fFontTx);

    if (!JRSFontStyleUsesFractionalMetrics(strike->fStyle)) {

        advance.width = round(advance.width);

        advance.height = round(advance.height);

    }