#include <assert.h>
#include <stdlib.h>
#include <stdio.h>
#include <float.h>
#include <math.h>
#include "utils.h"

#define MAX_WIDTH  16
#define MAX_HEIGHT 16
#define MAX_STRIDE 4

static const pixman_format_code_t formats[] =
{
    PIXMAN_a2r10g10b10,
    PIXMAN_x2r10g10b10,
    PIXMAN_a8r8g8b8,
    PIXMAN_a4r4g4b4,
    PIXMAN_a2r2g2b2,
    PIXMAN_r5g6b5,
    PIXMAN_r3g3b2,
};

static const pixman_op_t operators[] =
{
    PIXMAN_OP_CLEAR,
    PIXMAN_OP_SRC,
    PIXMAN_OP_DST,
    PIXMAN_OP_OVER,
    PIXMAN_OP_OVER_REVERSE,
    PIXMAN_OP_IN,
    PIXMAN_OP_IN_REVERSE,
    PIXMAN_OP_OUT,
    PIXMAN_OP_OUT_REVERSE,
    PIXMAN_OP_ATOP,
    PIXMAN_OP_ATOP_REVERSE,
    PIXMAN_OP_XOR,
    PIXMAN_OP_ADD,
    PIXMAN_OP_SATURATE,

    PIXMAN_OP_DISJOINT_CLEAR,
    PIXMAN_OP_DISJOINT_SRC,
    PIXMAN_OP_DISJOINT_DST,
    PIXMAN_OP_DISJOINT_OVER,
    PIXMAN_OP_DISJOINT_OVER_REVERSE,
    PIXMAN_OP_DISJOINT_IN,
    PIXMAN_OP_DISJOINT_IN_REVERSE,
    PIXMAN_OP_DISJOINT_OUT,
    PIXMAN_OP_DISJOINT_OUT_REVERSE,
    PIXMAN_OP_DISJOINT_ATOP,
    PIXMAN_OP_DISJOINT_ATOP_REVERSE,
    PIXMAN_OP_DISJOINT_XOR,

    PIXMAN_OP_CONJOINT_CLEAR,
    PIXMAN_OP_CONJOINT_SRC,
    PIXMAN_OP_CONJOINT_DST,
    PIXMAN_OP_CONJOINT_OVER,
    PIXMAN_OP_CONJOINT_OVER_REVERSE,
    PIXMAN_OP_CONJOINT_IN,
    PIXMAN_OP_CONJOINT_IN_REVERSE,
    PIXMAN_OP_CONJOINT_OUT,
    PIXMAN_OP_CONJOINT_OUT_REVERSE,
    PIXMAN_OP_CONJOINT_ATOP,
    PIXMAN_OP_CONJOINT_ATOP_REVERSE,
    PIXMAN_OP_CONJOINT_XOR,

    PIXMAN_OP_MULTIPLY,
    PIXMAN_OP_SCREEN,
    PIXMAN_OP_OVERLAY,
    PIXMAN_OP_DARKEN,
    PIXMAN_OP_LIGHTEN,
    PIXMAN_OP_COLOR_DODGE,
    PIXMAN_OP_COLOR_BURN,
    PIXMAN_OP_HARD_LIGHT,
    PIXMAN_OP_SOFT_LIGHT,
    PIXMAN_OP_DIFFERENCE,
    PIXMAN_OP_EXCLUSION,
};

#define RANDOM_ELT(array)                                               \
    (array[prng_rand_n (ARRAY_LENGTH (array))])

static void
free_bits (pixman_image_t *image, void *data)
{
    free (image->bits.bits);
}

static pixman_image_t *
create_image (pixman_image_t **clone)
{
    pixman_format_code_t format = RANDOM_ELT (formats);
    pixman_image_t *image;
    int width = prng_rand_n (MAX_WIDTH);
    int height = prng_rand_n (MAX_HEIGHT);
    int stride = ((width * (PIXMAN_FORMAT_BPP (format) / 8)) + 3) & ~3;
    uint32_t *bytes = malloc (stride * height);

    prng_randmemset (bytes, stride * height, RANDMEMSET_MORE_00_AND_FF);

    image = pixman_image_create_bits (
        format, width, height, bytes, stride);

    pixman_image_set_destroy_function (image, free_bits, NULL);

    assert (image);

    if (clone)
    {
        uint32_t *bytes_dup = malloc (stride * height);

        memcpy (bytes_dup, bytes, stride * height);

        *clone = pixman_image_create_bits (
            format, width, height, bytes_dup, stride);

        pixman_image_set_destroy_function (*clone, free_bits, NULL);
    }
    
    return image;
}

static pixman_bool_t
access (pixman_image_t *image, int x, int y, uint32_t *pixel)
{
    int bytes_per_pixel;
    int stride;
    uint8_t *location;

    if (x < 0 || x >= image->bits.width || y < 0 || y >= image->bits.height)
        return FALSE;
    
    bytes_per_pixel = PIXMAN_FORMAT_BPP (image->bits.format) / 8;
    stride = image->bits.rowstride * 4;
    
    location = (uint8_t *)image->bits.bits + y * stride + x * bytes_per_pixel;

    if (bytes_per_pixel == 4)
        *pixel = *(uint32_t *)location;
    else if (bytes_per_pixel == 2)
        *pixel = *(uint16_t *)location;
    else if (bytes_per_pixel == 1)
        *pixel = *(uint8_t *)location;
    else
	assert (0);

    return TRUE;
}

static void
get_color (pixel_checker_t *checker,
	   pixman_image_t *image,
	   int x, int y,
	   color_t *color,
	   uint32_t *pixel)
{
    if (!access (image, x, y, pixel))
    {
	color->a = 0.0;
	color->r = 0.0;
	color->g = 0.0;
	color->b = 0.0;
    }
    else
    {
	pixel_checker_convert_pixel_to_color (
	    checker, *pixel, color);
    }
}
            
static pixman_bool_t
verify (int test_no,
        pixman_op_t op,
        pixman_image_t *source,
	pixman_image_t *mask,
        pixman_image_t *dest,
        pixman_image_t *orig_dest,
        int x, int y,
        int width, int height,
	pixman_bool_t component_alpha)
{
    pixel_checker_t dest_checker, src_checker, mask_checker;
    int i, j;

    pixel_checker_init (&src_checker, source->bits.format);
    pixel_checker_init (&dest_checker, dest->bits.format);
    pixel_checker_init (&mask_checker, mask->bits.format);

    assert (dest->bits.format == orig_dest->bits.format);

    for (j = y; j < y + height; ++j)
    {
        for (i = x; i < x + width; ++i)
        {
            color_t src_color, mask_color, orig_dest_color, result;
            uint32_t dest_pixel, orig_dest_pixel, src_pixel, mask_pixel;

            access (dest, i, j, &dest_pixel);

	    get_color (&src_checker,
		       source, i - x, j - y,
		       &src_color, &src_pixel);

	    get_color (&mask_checker,
		       mask, i - x, j - y,
		       &mask_color, &mask_pixel);

	    get_color (&dest_checker, 
		       orig_dest, i, j,
		       &orig_dest_color, &orig_dest_pixel);

	    do_composite (op, 
			  &src_color, &mask_color, &orig_dest_color,
			  &result, component_alpha);

            if (!pixel_checker_check (&dest_checker, dest_pixel, &result))
            {
                int a, r, g, b;

                printf ("--------- Test 0x%x failed ---------\n", test_no);
                
                printf ("   operator:         %s (%s alpha)\n", operator_name (op),
			component_alpha? "component" : "unified");
                printf ("   dest_x, dest_y:   %d %d\n", x, y);
                printf ("   width, height:    %d %d\n", width, height);
                printf ("   source:           format: %-14s  size: %2d x %2d\n",
                        format_name (source->bits.format),
			source->bits.width, source->bits.height);
                printf ("   mask:             format: %-14s  size: %2d x %2d\n",
                        format_name (mask->bits.format),
			mask->bits.width, mask->bits.height);
                printf ("   dest:             format: %-14s  size: %2d x %2d\n",
                        format_name (dest->bits.format),
			dest->bits.width, dest->bits.height);
                printf ("   -- Failed pixel: (%d, %d) --\n", i, j);
                printf ("   source ARGB:      %f  %f  %f  %f   (pixel: %x)\n",
                        src_color.a, src_color.r, src_color.g, src_color.b,
                        src_pixel);
                printf ("   mask ARGB:        %f  %f  %f  %f   (pixel: %x)\n",
                        mask_color.a, mask_color.r, mask_color.g, mask_color.b,
                        mask_pixel);
                printf ("   dest ARGB:        %f  %f  %f  %f   (pixel: %x)\n",
                        orig_dest_color.a, orig_dest_color.r, orig_dest_color.g, orig_dest_color.b,
                        orig_dest_pixel);
                printf ("   expected ARGB:    %f  %f  %f  %f\n",
                        result.a, result.r, result.g, result.b);

                pixel_checker_get_min (&dest_checker, &result, &a, &r, &g, &b);
                printf ("   min acceptable:   %8d  %8d  %8d  %8d\n", a, r, g, b);

                pixel_checker_split_pixel (&dest_checker, dest_pixel, &a, &r, &g, &b);
                printf ("   got:              %8d  %8d  %8d  %8d   (pixel: %x)\n", a, r, g, b, dest_pixel);
                
                pixel_checker_get_max (&dest_checker, &result, &a, &r, &g, &b);
                printf ("   max acceptable:   %8d  %8d  %8d  %8d\n", a, r, g, b);
		printf ("\n");
		printf ("    { %s,\n", operator_name (op));
		printf ("      PIXMAN_%s,\t0x%x,\n", format_name (source->bits.format), src_pixel);
		printf ("      PIXMAN_%s,\t0x%x,\n", format_name (mask->bits.format), mask_pixel);
		printf ("      PIXMAN_%s,\t0x%x\n", format_name (dest->bits.format), orig_dest_pixel);
		printf ("    },\n");
                return FALSE;
            }
        }
    }

    return TRUE;
}

static pixman_bool_t
do_check (int i)
{
    pixman_image_t *source, *dest, *mask;
    pixman_op_t op;
    int x, y, width, height;
    pixman_image_t *dest_copy;
    pixman_bool_t result = TRUE;
    pixman_bool_t component_alpha;

    prng_srand (i);
    op = RANDOM_ELT (operators);
    x = prng_rand_n (MAX_WIDTH);
    y = prng_rand_n (MAX_HEIGHT);
    width = prng_rand_n (MAX_WIDTH) + 4;
    height = prng_rand_n (MAX_HEIGHT) + 4;

    source = create_image (NULL);
    mask = create_image (NULL);
    dest = create_image (&dest_copy);

    if (x >= dest->bits.width)
        x = dest->bits.width / 2;
    if (y >= dest->bits.height)
        y = dest->bits.height / 2;
    if (x + width > dest->bits.width)
        width = dest->bits.width - x;
    if (y + height > dest->bits.height)
        height = dest->bits.height - y;

    component_alpha = prng_rand_n (2);

    pixman_image_set_component_alpha (mask, component_alpha);
    
    pixman_image_composite32 (op, source, mask, dest,
                              0, 0, 0, 0,
                              x, y, width, height);

    if (!verify (i, op, source, mask, dest, dest_copy,
		 x, y, width, height, component_alpha))
    {
	result = FALSE;
    }
    
    pixman_image_unref (source);
    pixman_image_unref (mask);
    pixman_image_unref (dest);
    pixman_image_unref (dest_copy);

    return result;
}

#define N_TESTS    10000000

int
main (int argc, const char *argv[])
{
    int i;
    int result = 0;

    if (argc == 2)
    {
	if (strcmp (argv[1], "--forever") == 0)
	{
	    uint32_t n;

	    prng_srand (time (0));

	    n = prng_rand();

	    for (;;)
		do_check (n++);
	}
        else
	{
	    do_check (strtol (argv[1], NULL, 0));
	}
    }
    else
    {
#ifdef USE_OPENMP
#       pragma omp parallel for default(none) reduction(|:result)
#endif
        for (i = 0; i < N_TESTS; ++i)
	{
	    if (!do_check (i))
		result |= 1;
	}
    }
    
    return result;
}