/*

 * Copyright (c) 2011, 2012, 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 "QuartzSurfaceData.h"

#import "java_awt_BasicStroke.h"

#import "java_awt_AlphaComposite.h"

#import "java_awt_geom_PathIterator.h"

#import "java_awt_image_BufferedImage.h"

#import "sun_awt_SunHints.h"

#import "sun_java2d_CRenderer.h"

#import "sun_java2d_OSXSurfaceData.h"

#import "sun_lwawt_macosx_CPrinterSurfaceData.h"

#import "ImageSurfaceData.h"

#import <JavaNativeFoundation/JavaNativeFoundation.h>

#import <AppKit/AppKit.h>

#import "ThreadUtilities.h"

//#define DEBUG

#if defined DEBUG

    #define PRINT(msg) {fprintf(stderr, "%s\n", msg);}

#else

    #define PRINT(msg) {}

#endif

#define kOffset (0.5f)

BOOL gAdjustForJavaDrawing;

#pragma mark

#pragma mark --- Color Cache ---

// Creating and deleting CGColorRefs can be expensive, therefore we have a color cache.

// The color cache was first introduced with <rdar://problem/3923927>

// With <rdar://problem/4280514>, the hashing function was improved

// With <rdar://problem/4012223>, the color cache became global (per process) instead of per surface.

// Must be power of 2. 1024 is the least power of 2 number that makes SwingSet2 run without any non-empty cache misses

#define gColorCacheSize 1024

struct _ColorCacheInfo

{

    UInt32        keys[gColorCacheSize];

    CGColorRef    values[gColorCacheSize];

};

static struct _ColorCacheInfo colorCacheInfo;

static pthread_mutex_t gColorCacheLock = PTHREAD_MUTEX_INITIALIZER;

// given a UInt32 color, it tries to find that find the corresponding CGColorRef in the hash cache. If the CGColorRef

// doesn't exist or there is a collision, it creates a new one CGColorRef and put's in the cache. Then,

// it sets with current fill/stroke color for the CGContext passed in (qsdo->cgRef).

void setCachedColor(QuartzSDOps *qsdo, UInt32 color)

{

    static const CGFloat kColorConversionMultiplier = 1.0f/255.0f;

    pthread_mutex_lock(&gColorCacheLock);

    static CGColorSpaceRef colorspace = NULL;

    if (colorspace == NULL)

    {

        colorspace = CGColorSpaceCreateWithName(kCGColorSpaceGenericRGB);

    }

    CGColorRef cgColor = NULL;

    // The colors passed have low randomness. That means we need to scramble the bits of the color

    // to produce a good hash key. After some analysis, it looks like Thomas's Wang integer hasing algorithm

    // seems a nice trade off between performance and effectivness.

    UInt32 index = color;

    index += ~(index << 15);

    index ^=  (index >> 10);

    index +=  (index << 3);

    index ^=  (index >> 6);

    index += ~(index << 11);

    index ^=  (index >> 16);

    index = index & (gColorCacheSize - 1);   // The bits are scrambled, we just need to make sure it fits inside our table

    UInt32 key = colorCacheInfo.keys[index];

    CGColorRef value = colorCacheInfo.values[index];

    if ((key == color) && (value != NULL))

    {

        //fprintf(stderr, "+");fflush(stderr);//hit

        cgColor = value;

    }

    else

    {

        if (value != NULL)

        {

            //fprintf(stderr, "!");fflush(stderr);//miss and replace - double ouch

            CGColorRelease(value);

        }

        //fprintf(stderr, "-");fflush(stderr);// miss

        CGFloat alpha = ((color>>24)&0xff)*kColorConversionMultiplier;

        CGFloat red = ((color>>16)&0xff)*kColorConversionMultiplier;

        CGFloat green = ((color>>8)&0xff)*kColorConversionMultiplier;

        CGFloat blue = ((color>>0)&0xff)*kColorConversionMultiplier;

        const CGFloat components[] = {red, green, blue, alpha, 1.0f};

        value = CGColorCreate(colorspace, components);

        colorCacheInfo.keys[index] = color;

        colorCacheInfo.values[index] = value;

        cgColor = value;

    }

    CGContextSetStrokeColorWithColor(qsdo->cgRef, cgColor);

    CGContextSetFillColorWithColor(qsdo->cgRef, cgColor);

    pthread_mutex_unlock(&gColorCacheLock);

}

#pragma mark

#pragma mark --- Gradient ---

// this function MUST NOT be inlined!

void gradientLinearPaintEvaluateFunction(void *info, const CGFloat *in, CGFloat *out)

{

    StateShadingInfo *shadingInfo = (StateShadingInfo *)info;

    CGFloat *colors = shadingInfo->colors;

    CGFloat range = *in;

    CGFloat c1, c2;

    jint k;

//fprintf(stderr, "range=%f\n", range);

    for (k=0; k<4; k++)

    {

        c1 = colors[k];

//fprintf(stderr, "    c1=%f", c1);

        c2 = colors[k+4];

//fprintf(stderr, ", c2=%f", c2);

        if (c1 == c2)

        {

            *out++ = c2;

//fprintf(stderr, ", %f", *(out-1));

        }

        else if (c1 > c2)

        {

            *out++ = c1 - ((c1-c2)*range);

//fprintf(stderr, ", %f", *(out-1));

        }

        else// if (c1 < c2)

        {

            *out++ = c1 + ((c2-c1)*range);

//fprintf(stderr, ", %f", *(out-1));

        }

//fprintf(stderr, "\n");

    }

}

// this function MUST NOT be inlined!

void gradientCyclicPaintEvaluateFunction(void *info, const CGFloat *in, CGFloat *out)

{

    StateShadingInfo *shadingInfo = (StateShadingInfo *)info;

    CGFloat length = shadingInfo->length ;

    CGFloat period = shadingInfo->period;

    CGFloat offset = shadingInfo->offset;

    CGFloat periodLeft = offset;

    CGFloat periodRight = periodLeft+period;

    CGFloat *colors = shadingInfo->colors;

    CGFloat range = *in;

    CGFloat c1, c2;

    jint k;

    jint count = 0;

    range *= length;

    // put the range within the period

    if (range < periodLeft)

    {

        while (range < periodLeft)

        {

            range += period;

            count++;

        }

        range = range-periodLeft;

    }

    else if (range > periodRight)

    {

        count = 1;

        while (range > periodRight)

        {

            range -= period;

            count++;

        }

        range = periodRight-range;

    }

    else

    {

        range = range - offset;

    }

    range = range/period;

    // cycle up or down

    if (count%2 == 0)

    {

        for (k=0; k<4; k++)

        {

            c1 = colors[k];

            c2 = colors[k+4];

            if (c1 == c2)

            {

                *out++ = c2;

            }

            else if (c1 > c2)

            {

                *out++ = c1 - ((c1-c2)*range);

            }

            else// if (c1 < c2)

            {

                *out++ = c1 + ((c2-c1)*range);

            }

        }

    }

    else

    {

        for (k=0; k<4; k++)

        {

            c1 = colors[k+4];

            c2 = colors[k];

            if (c1 == c2)

            {

                *out++ = c2;

            }

            else if (c1 > c2)

            {

                *out++ = c1 - ((c1-c2)*range);

            }

            else// if (c1 < c2)

            {

                *out++ = c1 + ((c2-c1)*range);

            }

        }

    }

 }

// this function MUST NOT be inlined!

void gradientPaintReleaseFunction(void *info)

{

PRINT("    gradientPaintReleaseFunction")

    free(info);

}

static inline void contextQuartzLinearGradientPath(QuartzSDOps* qsdo)

{

PRINT("    contextQuartzLinearGradientPath");

    CGContextRef cgRef = qsdo->cgRef;

    StateGradientInfo *gradientInfo = qsdo->gradientInfo;

    CGColorSpaceRef colorspace = CGColorSpaceCreateWithName(kCGColorSpaceGenericRGB);

    size_t num_locations = gradientInfo->fractionsLength;

    CGFloat *locations = (CGFloat *) malloc(sizeof(CGFloat) * num_locations);

    int i = 0;

    size_t component_size = num_locations * 4;

    CGFloat components[component_size];

    CGGradientRef gradient = NULL;

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

        locations[i] = gradientInfo->fractionsdata[i];

    }

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

        components[i] = gradientInfo->colordata[i];

    } 

    CGContextSaveGState(cgRef);

    gradient = CGGradientCreateWithColorComponents(colorspace, components, locations, num_locations);

    if (qsdo->isEvenOddFill) {

        CGContextEOClip(cgRef);

    } else {

        CGContextClip(cgRef);

    }

    CGContextDrawLinearGradient(cgRef, gradient, gradientInfo->start, gradientInfo->end, kCGGradientDrawsAfterEndLocation);    

    CGContextRestoreGState(cgRef);

    CGColorSpaceRelease(colorspace);

    CGGradientRelease(gradient);

    free(locations);

    free(gradientInfo->colordata);

    free(gradientInfo->fractionsdata);

}

static inline void contextQuartzRadialGradientPath(QuartzSDOps* qsdo)

{

PRINT("    contextQuartzRadialGradientPath");

    CGContextRef cgRef = qsdo->cgRef;

    StateGradientInfo *gradientInfo = qsdo->gradientInfo;

    CGColorSpaceRef colorspace = CGColorSpaceCreateWithName(kCGColorSpaceGenericRGB);

    size_t num_locations = gradientInfo->fractionsLength;

    CGFloat *locations = (CGFloat *) malloc(sizeof(CGFloat) * num_locations);

    int i = 0;

    size_t component_size = num_locations * 4;

    CGFloat components[component_size];

    CGGradientRef gradient = NULL;

    CGFloat startRadius = gradientInfo->radius;

    CGFloat endRadius = gradientInfo->radius;

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

        locations[i] = gradientInfo->fractionsdata[i];

    }

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

        components[i] = gradientInfo->colordata[i];

    } 

    CGContextSaveGState(cgRef);

    gradient = CGGradientCreateWithColorComponents(colorspace, components, locations, num_locations);

    if (qsdo->isEvenOddFill) {

        CGContextEOClip(cgRef);

    } else {

        CGContextClip(cgRef);

    }

    CGContextDrawRadialGradient(cgRef, gradient, gradientInfo->start, 0, gradientInfo->end, endRadius, kCGGradientDrawsAfterEndLocation);    

    CGContextRestoreGState(cgRef);

    CGColorSpaceRelease(colorspace);

    CGGradientRelease(gradient);

    free(locations);

    free(gradientInfo->colordata);

    free(gradientInfo->fractionsdata);

}

static inline void contextGradientPath(QuartzSDOps* qsdo)

{

PRINT("    ContextGradientPath")

    CGContextRef cgRef = qsdo->cgRef;

    StateShadingInfo* shadingInfo = qsdo->shadingInfo;

    CGRect bounds = CGContextGetClipBoundingBox(cgRef);

    static const CGFloat domain[2] = {0.0f, 1.0f};

    static const CGFloat range[8] = {0.0f, 1.0f, 0.0f, 1.0f, 0.0f, 1.0f, 0.0f, 1.0f};

    CGColorSpaceRef colorspace = CGColorSpaceCreateWithName(kCGColorSpaceGenericRGB);

    CGFunctionRef shadingFunc = NULL;

    CGShadingRef shading = NULL;

    if (shadingInfo->cyclic == NO)

    {

        static const CGFunctionCallbacks callbacks = {0, &gradientLinearPaintEvaluateFunction, &gradientPaintReleaseFunction};

        shadingFunc = CGFunctionCreate((void *)shadingInfo, 1, domain, 4, range, &callbacks);

        shading = CGShadingCreateAxial(colorspace, shadingInfo->start, shadingInfo->end, shadingFunc, 1, 1);

    }

    else

    {

//fprintf(stderr, "BOUNDING BOX x1=%f, y1=%f x2=%f, y2=%f\n", bounds.origin.x, bounds.origin.y, bounds.origin.x+bounds.size.width, bounds.origin.y+bounds.size.height);

        // need to extend the line start-end

        CGFloat x1 = shadingInfo->start.x;

        CGFloat y1 = shadingInfo->start.y;

        CGFloat x2 = shadingInfo->end.x;

        CGFloat y2 = shadingInfo->end.y;

//fprintf(stderr, "GIVEN x1=%f, y1=%f      x2=%f, y2=%f\n", x1, y1, x2, y2);

        if (x1 == x2)

        {

            y1 = bounds.origin.y;

            y2 = y1 + bounds.size.height;

        }

        else if (y1 == y2)

        {

            x1 = bounds.origin.x;

            x2 = x1 + bounds.size.width;

        }

        else

        {

            // find the original line function y = mx + c

            CGFloat m1 = (y2-y1)/(x2-x1);

            CGFloat c1 = y1 - m1*x1;

//fprintf(stderr, "         m1=%f, c1=%f\n", m1, c1);

            // a line perpendicular to the original one will have the slope

            CGFloat m2 = -(1/m1);

//fprintf(stderr, "         m2=%f\n", m2);

            // find the only 2 possible lines perpendicular to the original line, passing the two top corners of the bounding box

            CGFloat x1A = bounds.origin.x;

            CGFloat y1A = bounds.origin.y;

            CGFloat c1A = y1A - m2*x1A;

//fprintf(stderr, "         x1A=%f, y1A=%f, c1A=%f\n", x1A, y1A, c1A);

            CGFloat x1B = bounds.origin.x+bounds.size.width;

            CGFloat y1B = bounds.origin.y;

            CGFloat c1B = y1B - m2*x1B;

//fprintf(stderr, "         x1B=%f, y1B=%f, c1B=%f\n", x1B, y1B, c1B);

            // find the crossing points of the original line and the two lines we computed above to find the new possible starting points

            CGFloat x1Anew = (c1A-c1)/(m1-m2);

            CGFloat y1Anew = m2*x1Anew + c1A;

            CGFloat x1Bnew = (c1B-c1)/(m1-m2);

            CGFloat y1Bnew = m2*x1Bnew + c1B;

//fprintf(stderr, "NEW x1Anew=%f, y1Anew=%f      x1Bnew=%f, y1Bnew=%f\n", x1Anew, y1Anew, x1Bnew, y1Bnew);

            // select the new starting point

            if (y1Anew <= y1Bnew)

            {

                x1 = x1Anew;

                y1 = y1Anew;

            }

            else

            {

                x1 = x1Bnew;

                y1 = y1Bnew;

            }

//fprintf(stderr, "--- NEW x1=%f, y1=%f\n", x1, y1);

            // find the only 2 possible lines perpendicular to the original line, passing the two bottom corners of the bounding box

            CGFloat x2A = bounds.origin.x;

            CGFloat y2A = bounds.origin.y+bounds.size.height;

            CGFloat c2A = y2A - m2*x2A;

//fprintf(stderr, "         x2A=%f, y2A=%f, c2A=%f\n", x2A, y2A, c2A);

            CGFloat x2B = bounds.origin.x+bounds.size.width;

            CGFloat y2B = bounds.origin.y+bounds.size.height;

            CGFloat c2B = y2B - m2*x2B;

//fprintf(stderr, "         x2B=%f, y2B=%f, c2B=%f\n", x2B, y2B, c2B);

            // find the crossing points of the original line and the two lines we computed above to find the new possible ending points

            CGFloat x2Anew = (c2A-c1)/(m1-m2);

            CGFloat y2Anew = m2*x2Anew + c2A;

            CGFloat x2Bnew = (c2B-c1)/(m1-m2);

            CGFloat y2Bnew = m2*x2Bnew + c2B;

//fprintf(stderr, "NEW x2Anew=%f, y2Anew=%f      x2Bnew=%f, y2Bnew=%f\n", x2Anew, y2Anew, x2Bnew, y2Bnew);

            // select the new ending point

            if (y2Anew >= y2Bnew)

            {

                x2 = x2Anew;

                y2 = y2Anew;

            }

            else

            {

                x2 = x2Bnew;

                y2 = y2Bnew;

            }

//fprintf(stderr, "--- NEW x2=%f, y2=%f\n", x2, y2);

        }

        qsdo->shadingInfo->period = sqrt(pow(shadingInfo->end.x-shadingInfo->start.x, 2.0) + pow(shadingInfo->end.y-shadingInfo->start.y, 2.0));

        if ((qsdo->shadingInfo->period != 0))

        {

            // compute segment lengths that we will need for the gradient function

            qsdo->shadingInfo->length = sqrt(pow(x2-x1, 2.0) + pow(y2-y1, 2.0));

            qsdo->shadingInfo->offset = sqrt(pow(shadingInfo->start.x-x1, 2.0) + pow(shadingInfo->start.y-y1, 2.0));

//fprintf(stderr, "length=%f, period=%f, offset=%f\n", qsdo->shadingInfo->length, qsdo->shadingInfo->period, qsdo->shadingInfo->offset);

            CGPoint newStart = {x1, y1};

            CGPoint newEnd = {x2, y2};

            static const CGFunctionCallbacks callbacks = {0, &gradientCyclicPaintEvaluateFunction, &gradientPaintReleaseFunction};

            shadingFunc = CGFunctionCreate((void *)shadingInfo, 1, domain, 4, range, &callbacks);

            shading = CGShadingCreateAxial(colorspace, newStart, newEnd, shadingFunc, 0, 0);

        }

    }

    CGColorSpaceRelease(colorspace);

    if (shadingFunc != NULL)

    {

        CGContextSaveGState(cgRef);

        // rdar://problem/5214320

        // Gradient fills of Java GeneralPath don't respect the even odd winding rule (quartz pipeline).

        if (qsdo->isEvenOddFill) {

            CGContextEOClip(cgRef);

        } else {

            CGContextClip(cgRef);

        }

        CGContextDrawShading(cgRef, shading);

        CGContextRestoreGState(cgRef);

        CGShadingRelease(shading);

        CGFunctionRelease(shadingFunc);

        qsdo->shadingInfo = NULL;

    }

}

#pragma mark

#pragma mark --- Texture ---

// this function MUST NOT be inlined!

void texturePaintEvaluateFunction(void *info, CGContextRef cgRef)

{

    JNIEnv* env = [ThreadUtilities getJNIEnvUncached];

    StatePatternInfo* patternInfo = (StatePatternInfo*)info;

    ImageSDOps* isdo = LockImage(env, patternInfo->sdata);

    makeSureImageIsCreated(isdo);

    CGContextDrawImage(cgRef, CGRectMake(0.0f, 0.0f, patternInfo->width, patternInfo->height), isdo->imgRef);

    UnlockImage(env, isdo);

}

// this function MUST NOT be inlined!

void texturePaintReleaseFunction(void *info)

{

    PRINT("    texturePaintReleaseFunction")