/*

 * Copyright (C) 2005 Apple Computer, Inc.  All rights reserved.

 * Copyright (C) 2005 Ben La Monica <ben.lamonica@gmail.com>.  All rights reserved.

 *

 * Redistribution and use in source and binary forms, with or without

 * modification, are permitted provided that the following conditions

 * are met:

 * 1. Redistributions of source code must retain the above copyright

 *    notice, this list of conditions and the following disclaimer.

 * 2. Redistributions in binary form must reproduce the above copyright

 *    notice, this list of conditions and the following disclaimer in the

 *    documentation and/or other materials provided with the distribution.

 *

 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY

 * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE

 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR

 * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR

 * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,

 * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,

 * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR

 * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY

 * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT

 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE

 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 

 */

#import <Foundation/Foundation.h>

#import <QuartzCore/CoreImage.h>

#import <AppKit/NSBitmapImageRep.h>

#import <AppKit/NSGraphicsContext.h>

#import <AppKit/NSCIImageRep.h>

/* prototypes */

int main(int argc, const char *argv[]);

CGImageRef createImageFromStdin(int imageSize);

void compareImages(CGImageRef actualBitmap, CGImageRef baselineImage);

NSBitmapImageRep *getDifferenceBitmap(CGImageRef actualBitmap, CGImageRef baselineImage);

float computePercentageDifferent(NSBitmapImageRep *diffBitmap);

int main(int argc, const char *argv[])

{

    NSAutoreleasePool *pool = [[NSAutoreleasePool alloc] init];

    char buffer[2048];

    CGImageRef actualImage = nil;

    CGImageRef baselineImage = nil;

    NSAutoreleasePool *innerPool = [[NSAutoreleasePool alloc] init];

    while (fgets(buffer, sizeof(buffer), stdin)) {

        // remove the CR

        char *newLineCharacter = strchr(buffer, '\n');

        if (newLineCharacter) {

            *newLineCharacter = '\0';

        }

        if (strncmp("Content-length: ", buffer, 16) == 0) {

            strtok(buffer, " ");

            int imageSize = strtol(strtok(NULL, " "), NULL, 10);

            if(imageSize > 0 && actualImage == nil) 

                actualImage = createImageFromStdin(imageSize);

            else if (imageSize > 0 && baselineImage == nil)

                baselineImage = createImageFromStdin(imageSize);

            else

                fputs("error, image size must be specified.\n", stdout);

        }

        if (actualImage != nil && baselineImage != nil) {

            compareImages(actualImage, baselineImage);

            CGImageRelease(actualImage);

            CGImageRelease(baselineImage);

            actualImage = nil;

            baselineImage = nil;

            [innerPool release];

            innerPool = [[NSAutoreleasePool alloc] init];

        }

        fflush(stdout);

    }

    [innerPool release];

    [pool release];

    return 0;

}

CGImageRef createImageFromStdin(int bytesRemaining)

{

    unsigned char buffer[2048];

    NSMutableData *data = [[NSMutableData alloc] initWithCapacity:bytesRemaining];

    int bytesRead = 0;

    while (bytesRemaining > 0) {

        bytesRead = (bytesRemaining > 2048 ? 2048 : bytesRemaining);

        fread(buffer, bytesRead, 1, stdin);

        [data appendBytes:buffer length:bytesRead];

        bytesRemaining -= bytesRead;

    }

    CGDataProviderRef dataProvider = CGDataProviderCreateWithCFData((CFDataRef)data);

    CGImageRef image = CGImageCreateWithPNGDataProvider(dataProvider, NULL, NO, kCGRenderingIntentDefault);

    [data release];

    CGDataProviderRelease(dataProvider);

    return image; 

}

void compareImages(CGImageRef actualBitmap, CGImageRef baselineBitmap)

{

    // prepare the difference blend to check for pixel variations

    NSBitmapImageRep *diffBitmap = getDifferenceBitmap(actualBitmap, baselineBitmap);

    float percentage = computePercentageDifferent(diffBitmap);

    // send message to let them know if an image was wrong

    if (percentage > 0.0) {

        // since the diff might actually show something, send it to stdout

        NSData *diffPNGData = [diffBitmap representationUsingType:NSPNGFileType properties:nil];

        fprintf(stdout, "Content-length: %d\n", [diffPNGData length]);

        fwrite([diffPNGData bytes], [diffPNGData length], 1, stdout);

        fprintf(stdout, "diff: %01.2f%% failed\n", percentage);

    } else

        fprintf(stdout, "diff: %01.2f%% passed\n", percentage);

}

NSBitmapImageRep *getDifferenceBitmap(CGImageRef testBitmap, CGImageRef referenceBitmap)

{

    // we must have both images to take diff

    if (testBitmap == nil || referenceBitmap == nil)

        return nil;

    NSBitmapImageRep *diffBitmap = [NSBitmapImageRep alloc];

    [diffBitmap initWithBitmapDataPlanes:NULL

                              pixelsWide:CGImageGetWidth(testBitmap)

                              pixelsHigh:CGImageGetHeight(testBitmap)

                           bitsPerSample:CGImageGetBitsPerComponent(testBitmap)

                         samplesPerPixel:CGImageGetBitsPerPixel(testBitmap) / CGImageGetBitsPerComponent(testBitmap)

                                hasAlpha:YES

                                isPlanar:NO

                          colorSpaceName:NSCalibratedRGBColorSpace

                            bitmapFormat:0

                             bytesPerRow:CGImageGetBytesPerRow(testBitmap)

                            bitsPerPixel:CGImageGetBitsPerPixel(testBitmap)

    ];

    NSGraphicsContext *nsContext = [NSGraphicsContext graphicsContextWithBitmapImageRep:diffBitmap];

    CGContextRef cgContext = [nsContext graphicsPort];

    CGContextSetBlendMode(cgContext, kCGBlendModeNormal);

    CGContextDrawImage(cgContext, CGRectMake(0, 0, CGImageGetWidth(testBitmap), CGImageGetHeight(testBitmap)), testBitmap);

    CGContextSetBlendMode(cgContext, kCGBlendModeDifference);

    CGContextDrawImage(cgContext, CGRectMake(0, 0, CGImageGetWidth(referenceBitmap), CGImageGetHeight(referenceBitmap)), referenceBitmap);

    return [diffBitmap autorelease];

}

/**

 * Counts the number of non-black pixels, and returns the percentage

 * of non-black pixels to total pixels in the image.

 */

float computePercentageDifferent(NSBitmapImageRep *diffBitmap)

{

    // if diffBiatmap is nil, then there was an error, and it didn't match.

    if (diffBitmap == nil)

        return 100.0;

    unsigned bitmapFormat = [diffBitmap bitmapFormat];

    assert(!(bitmapFormat & NSAlphaFirstBitmapFormat));

    assert(!(bitmapFormat & NSFloatingPointSamplesBitmapFormat));

    unsigned pixelsHigh = [diffBitmap pixelsHigh];

    unsigned pixelsWide = [diffBitmap pixelsWide];

    unsigned bytesPerRow = [diffBitmap bytesPerRow];

    unsigned char *pixelRowData = [diffBitmap bitmapData];

    unsigned differences = 0;

    // NOTE: This may not be safe when switching between ENDIAN types

    for (unsigned row = 0; row < pixelsHigh; row++) {

        for (unsigned col = 0; col < (pixelsWide * 4); col += 4) {

            if (*(pixelRowData + col) != 0 || *(pixelRowData + col + 1) != 0 || *(pixelRowData + col + 2) != 0)

                differences++;

        }

        pixelRowData += bytesPerRow;

    }

    float totalPixels = pixelsHigh * pixelsWide;

    return (differences * 100.f) / totalPixels;

}