#include <winpr/wtypes.h>
#include <winpr/crt.h>
#include <winpr/path.h>
#include <winpr/file.h>
#include <winpr/print.h>
#include <winpr/image.h>
#include <winpr/environment.h>

#ifndef PATH_MAX
#define PATH_MAX 4096
#endif

static void* read_image(const char* src, size_t* size)
{
	int success = 0;
	void* a = NULL;
	INT64 src_size;
	FILE* fsrc = winpr_fopen(src, "rb");

	if (!fsrc)
	{
		fprintf(stderr, "Failed to open file %s\n", src);
		goto cleanup;
	}

	if (_fseeki64(fsrc, 0, SEEK_END))
	{
		fprintf(stderr, "Failed to seek to file end\n");
		goto cleanup;
	}

	src_size = _ftelli64(fsrc);
	if (src_size < 0)
	{
		fprintf(stderr, "Invalid file position %" PRId64 "\n", src_size);
		goto cleanup;
	}
	if (_fseeki64(fsrc, 0, SEEK_SET))
	{
		fprintf(stderr, "Failed to seek to SEEK_SET\n");
		goto cleanup;
	}

	a = malloc((size_t)src_size);

	if (!a)
	{
		fprintf(stderr, "Failed malloc %" PRId64 " bytes\n", src_size);
		goto cleanup;
	}

	if (fread(a, sizeof(char), (size_t)src_size, fsrc) != (size_t)src_size)
	{
		fprintf(stderr, "Failed read %" PRId64 " bytes\n", src_size);
		goto cleanup;
	}

	success = 1;
	*size = src_size;
cleanup:

	if (a && !success)
	{
		free(a);
		a = NULL;
	}

	if (fsrc)
		fclose(fsrc);

	return a;
}

static int img_compare(wImage* image, wImage* image2, BOOL ignoreType)
{
	int rc = -1;

	if ((image->type != image2->type) && !ignoreType)
	{
		fprintf(stderr, "Image type mismatch %d:%d\n", image->type, image2->type);
		goto cleanup;
	}

	if (image->width != image2->width)
	{
		fprintf(stderr, "Image width mismatch %d:%d\n", image->width, image2->width);
		goto cleanup;
	}

	if (image->height != image2->height)
	{
		fprintf(stderr, "Image height mismatch %d:%d\n", image->height, image2->height);
		goto cleanup;
	}

	if (image->scanline != image2->scanline)
	{
		fprintf(stderr, "Image scanline mismatch %d:%d\n", image->scanline, image2->scanline);
		goto cleanup;
	}

	if (image->bitsPerPixel != image2->bitsPerPixel)
	{
		fprintf(stderr, "Image bitsPerPixel mismatch %d:%d\n", image->bitsPerPixel,
		        image2->bitsPerPixel);
		goto cleanup;
	}

	if (image->bytesPerPixel != image2->bytesPerPixel)
	{
		fprintf(stderr, "Image bytesPerPixel mismatch %d:%d\n", image->bytesPerPixel,
		        image2->bytesPerPixel);
		goto cleanup;
	}

	rc = memcmp(image->data, image2->data, image->scanline * image->height);

	if (rc)
		fprintf(stderr, "Image data mismatch!\n");

cleanup:
	return rc;
}

static wImage* get_image(const char* src)
{
	int status;
	wImage* image = NULL;
	image = winpr_image_new();

	if (!image)
	{
		fprintf(stderr, "Failed to create image!");
		goto cleanup;
	}

	status = winpr_image_read(image, src);

	if (status < 0)
	{
		fprintf(stderr, "Failed to read image %s!", src);
		winpr_image_free(image, TRUE);
		image = NULL;
	}

cleanup:
	return image;
}

static int create_test(const char* src, const char* dst_png, const char* dst_bmp)
{
	int rc = -1;
	int ret = -1;
	int status;
	size_t bsize;
	void* buffer = NULL;
	wImage *image = NULL, *image2 = NULL, *image3 = NULL, *image4 = NULL;

	if (!winpr_PathFileExists(src))
	{
		fprintf(stderr, "File %s does not exist!", src);
		return -1;
	}

	image = get_image(src);

	/* Read from file using image methods. */
	if (!image)
		goto cleanup;

	/* Write different formats to tmp. */
	image->type = WINPR_IMAGE_BITMAP;
	status = winpr_image_write(image, dst_bmp);

	if (status < 0)
	{
		fprintf(stderr, "Failed to write image %s!\n", dst_bmp);
		goto cleanup;
	}

	image->type = WINPR_IMAGE_PNG;
	status = winpr_image_write(image, dst_png);

	if (status < 0)
	{
		fprintf(stderr, "Failed to write image %s!\n", dst_png);
		goto cleanup;
	}

	/* Read image from buffer, compare. */
	buffer = read_image(src, &bsize);

	if (!buffer)
	{
		fprintf(stderr, "Failed to read image %s!\n", src);
		goto cleanup;
	}

	image2 = winpr_image_new();

	if (!image2)
	{
		fprintf(stderr, "Failed to create image!\n");
		goto cleanup;
	}

	status = winpr_image_read_buffer(image2, buffer, bsize);

	if (status < 0)
	{
		fprintf(stderr, "Failed to read buffer!\n");
		goto cleanup;
	}

	rc = img_compare(image, image2, TRUE);

	if (rc)
		goto cleanup;

	image3 = get_image(dst_png);

	if (!image3)
		goto cleanup;

	rc = img_compare(image, image3, TRUE);

	if (rc)
		goto cleanup;

	image4 = get_image(dst_bmp);

	if (!image4)
		goto cleanup;

	rc = img_compare(image, image4, TRUE);

	if (rc)
		goto cleanup;

	ret = 0;
cleanup:

	if (image)
		winpr_image_free(image, TRUE);

	if (image2)
		winpr_image_free(image2, TRUE);

	if (image3)
		winpr_image_free(image3, TRUE);

	if (image4)
		winpr_image_free(image4, TRUE);

	free(buffer);
	return ret;
}

static int test_image_png_to_bmp(void)
{
	char* buffer = TEST_SOURCE_PATH;
	char src_png[PATH_MAX];
	char src_bmp[PATH_MAX];
	char dst_png[PATH_MAX];
	char dst_bmp[PATH_MAX];
	char dst_png2[PATH_MAX];
	char dst_bmp2[PATH_MAX];
	char* tmp = GetKnownPath(KNOWN_PATH_TEMP);

	if (!tmp)
		return -1;

	if (!buffer)
	{
		free(tmp);
		return -1;
	}

	sprintf_s(src_png, sizeof(src_png), "%s/lodepng_32bit.png", buffer);
	sprintf_s(src_bmp, sizeof(src_bmp), "%s/lodepng_32bit.bmp", buffer);
	sprintf_s(dst_png, sizeof(dst_png), "%s/lodepng_32bit.png", tmp);
	sprintf_s(dst_bmp, sizeof(dst_bmp), "%s/lodepng_32bit.bmp", tmp);
	sprintf_s(dst_png2, sizeof(dst_png2), "%s/lodepng_32bit-2.png", tmp);
	sprintf_s(dst_bmp2, sizeof(dst_bmp2), "%s/lodepng_32bit-2.bmp", tmp);
	free(tmp);

	if (create_test(src_png, dst_png, dst_bmp))
		return -1;

	if (create_test(src_bmp, dst_png2, dst_bmp2))
		return -1;

	return 0;
}

int TestImage(int argc, char* argv[])
{
	int rc = test_image_png_to_bmp();
	return rc;
}
