// MIT License

// Copyright (c) 2017 Vadim Grigoruk @nesbox // grigoruk@gmail.com

// Permission is hereby granted, free of charge, to any person obtaining a copy
// of this software and associated documentation files (the "Software"), to deal
// in the Software without restriction, including without limitation the rights
// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
// copies of the Software, and to permit persons to whom the Software is
// furnished to do so, subject to the following conditions:

// The above copyright notice and this permission notice shall be included in all
// copies or substantial portions of the Software.

// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
// SOFTWARE.

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

#include "gif.h"
#include "gif_lib.h"

static gif_image* readGif(GifFileType *gif)
{
	gif_image* image = NULL;

	s32 error = 0;

	if(gif)
	{
		if(gif->SHeight > 0 && gif->SWidth > 0)
		{
			s32 size = gif->SWidth * gif->SHeight * sizeof(GifPixelType);
			GifPixelType* screen = (GifPixelType*)malloc(size);

			if(screen)
			{
				memset(screen, gif->SBackGroundColor, size);

				GifRecordType record = UNDEFINED_RECORD_TYPE;

				do
				{
					if(DGifGetRecordType(gif, &record) == GIF_ERROR)
					{
						error = gif->Error;
						break;
					}

					switch (record)
					{
					case IMAGE_DESC_RECORD_TYPE:
						{
							if(DGifGetImageDesc(gif) == GIF_ERROR)
								error = gif->Error;

							s32 row = gif->Image.Top;
							s32 col = gif->Image.Left;
							s32 width = gif->Image.Width;
							s32 height = gif->Image.Height;

							if (gif->Image.Left + gif->Image.Width > gif->SWidth ||
								gif->Image.Top + gif->Image.Height > gif->SHeight)
									error = E_GIF_ERR_OPEN_FAILED;

							if (gif->Image.Interlace)
							{
								s32 InterlacedOffset[] = { 0, 4, 2, 1 };
								s32 InterlacedJumps[] = { 8, 8, 4, 2 };

								for (s32 i = 0; i < 4; i++)
									for (s32 j = row + InterlacedOffset[i]; j < row + height; j += InterlacedJumps[i])
									{
										if(DGifGetLine(gif, screen + j * gif->SWidth + col, width) == GIF_ERROR)
										{
											error = gif->Error;
											break;
										}
									}
							}
							else
							{
								for (s32 i = 0; i < height; i++, row++)
								{
									if(DGifGetLine(gif, screen + row * gif->SWidth + col, width) == GIF_ERROR)
									{
										error = gif->Error;
										break;
									}
								}
							}
						}
						break;

					case EXTENSION_RECORD_TYPE:
						{
							s32 extCode = 0;
							GifByteType* extension = NULL;

							if (DGifGetExtension(gif, &extCode, &extension) == GIF_ERROR)
								error = gif->Error;
							else
							{
								while (extension != NULL)
								{
									if(DGifGetExtensionNext(gif, &extension) == GIF_ERROR)
									{
										error = gif->Error;
										break;
									}
								}
							}
						}
						break;
					case TERMINATE_RECORD_TYPE:
						break;
					default: break;
					}

					if(error != E_GIF_SUCCEEDED)
						break;
				}
				while(record != TERMINATE_RECORD_TYPE);

				if(error == E_GIF_SUCCEEDED)
				{

					image = (gif_image*)malloc(sizeof(gif_image));

					if(image)
					{
						memset(image, 0, sizeof(gif_image));
						image->buffer = screen;
						image->width = gif->SWidth;
						image->height = gif->SHeight;

						ColorMapObject* colorMap = gif->Image.ColorMap ? gif->Image.ColorMap : gif->SColorMap;

						image->colors = colorMap->ColorCount;

						s32 size = image->colors * sizeof(gif_color);
						image->palette = malloc(size);

						memcpy(image->palette, colorMap->Colors, size);
					}					
				}
				else free(screen);
			}
		}

		DGifCloseFile(gif, &error);
	}

	return image;
}

typedef struct
{
	const void* data;
	s32 pos;
} GifBuffer;

static int readBuffer(GifFileType* gif, GifByteType* data, int size)
{
	GifBuffer* buffer = (GifBuffer*)gif->UserData;

	memcpy(data, (const u8*)buffer->data + buffer->pos, size);
	buffer->pos += size;

	return size;
}

gif_image* gif_read_data(const void* data, s32 size)
{
	GifBuffer buffer = {data, 0};
	GifFileType *gif = DGifOpen(&buffer, readBuffer, NULL);

	return readGif(gif);
}

static bool writeGif(GifFileType* gif, s32 width, s32 height, const u8* data, const gif_color* palette, u8 bpp)
{
	bool result = false;
	s32 error = 0;

	if(gif)
	{
		s32 colors = 1 << bpp;
		ColorMapObject* colorMap = GifMakeMapObject(colors, NULL);

		memcpy(colorMap->Colors, palette, colors * sizeof(GifColorType));

		if(EGifPutScreenDesc(gif, width, height, bpp, 0, colorMap) != GIF_ERROR)
		{
			if(EGifPutImageDesc(gif, 0, 0, width, height, false, NULL) != GIF_ERROR)
			{
				GifByteType* ptr = (GifByteType*)data;
				for (s32 i = 0; i < height; i++, ptr += width)
				{
					if (EGifPutLine(gif, ptr, width) == GIF_ERROR)
					{
						error = gif->Error;
						break;
					}
				}

				result = error == E_GIF_SUCCEEDED;
			}
		}

		EGifCloseFile(gif, &error);
		GifFreeMapObject(colorMap);
	}

	return result;
}

static int writeBuffer(GifFileType* gif, const GifByteType* data, int size)
{
	GifBuffer* buffer = (GifBuffer*)gif->UserData;

	memcpy((u8*)buffer->data + buffer->pos, data, size);
	buffer->pos += size;

	return size;
}

bool gif_write_data(const void* buffer, s32* size, s32 width, s32 height, const u8* data, const gif_color* palette, u8 bpp)
{
	s32 error = 0;
	GifBuffer output = {buffer, 0};
	GifFileType* gif = EGifOpen(&output, writeBuffer, &error);

	bool result = writeGif(gif, width, height, data, palette, bpp);

	*size = output.pos;

	return result;
}

void gif_close(gif_image* image)
{
	if(image)
	{
		if(image->buffer) free(image->buffer);
		if(image->palette) free(image->palette);

		free(image);
	}
}

static bool AddLoop(GifFileType *gif)
{
	{
		const char *nsle = "NETSCAPE2.0";
		const char subblock[] = {
			1, // always 1
			0, // little-endian loop counter:
			0  // 0 for infinite loop.
		};

		EGifPutExtensionLeader(gif, APPLICATION_EXT_FUNC_CODE);
		EGifPutExtensionBlock(gif, 11, nsle);
		EGifPutExtensionBlock(gif, 3, subblock);
		EGifPutExtensionTrailer(gif);
	}

	return true;
}

static const u8* toColor(const u8* ptr, gif_color* color)
{
	color->b = *ptr++;
	color->g = *ptr++;
	color->r = *ptr++;
	ptr++;

	return ptr;
}

bool gif_write_animation(const void* buffer, s32* size, s32 width, s32 height, const u8* data, s32 frames, s32 fps, s32 scale)
{
	bool result = false;

	s32 swidth = width*scale, sheight = height*scale;
	s32 frameSize = width * height;

	enum{Bpp = 8, PalSize = 1 << Bpp, PalStructSize = PalSize * sizeof(gif_color)};

	s32 error = 0;
	GifBuffer output = {buffer, 0};
	GifFileType* gif = EGifOpen(&output, writeBuffer, &error);

	if(gif)
	{			
		EGifSetGifVersion(gif, true);

		if(EGifPutScreenDesc(gif, swidth, sheight, Bpp, 0, NULL) != GIF_ERROR)
		{
			if(AddLoop(gif))
			{
				gif_color* palette = (gif_color*)malloc(PalStructSize);					
				u8* screen = malloc(frameSize);
				u8* line = malloc(swidth);

				for(s32 f = 0; f < frames; f++)
				{
					enum {DelayUnits = 100, MinDelay = 2};

					s32 frame = (f * fps * MinDelay * 2 + 1) / (2 * DelayUnits);

					if(frame >= frames)
						break;

					s32 colors = 0;
					const u8* ptr = data + frameSize*frame*sizeof(u32);
					
					{
						memset(palette, 0, PalStructSize);
						memset(screen, 0, frameSize);

						for(s32 i = 0; i < frameSize; i++)
						{
							if(colors >= PalSize) break;

							gif_color color;
							toColor(ptr + i*sizeof(u32), &color);

							bool found = false;
							for(s32 c = 0; c < colors; c++)
							{
								if(memcmp(&palette[c], &color, sizeof(gif_color)) == 0)
								{
									found = true;
									screen[i] = c;
									break;
								}
							}

							if(!found)
							{
								// TODO: check for last color in palette and try to find closest color
								screen[i] = colors;
								memcpy(&palette[colors], &color, sizeof(gif_color));
								colors++;
							}
						}
					}

					{
						GraphicsControlBlock gcb = 
						{
							.DisposalMode = DISPOSE_DO_NOT,
							.UserInputFlag = false,
							.DelayTime = MinDelay,
							.TransparentColor = -1,
						};

						u8 ext[4];
						EGifGCBToExtension(&gcb, ext);
						EGifPutExtension(gif, GRAPHICS_EXT_FUNC_CODE, sizeof ext, ext);
					}

					ColorMapObject* colorMap = GifMakeMapObject(PalSize, NULL);
					memset(colorMap->Colors, 0, PalStructSize);
					memcpy(colorMap->Colors, palette, colors * sizeof(GifColorType));

					if(EGifPutImageDesc(gif, 0, 0, swidth, sheight, false, colorMap) != GIF_ERROR)
					{
						for(s32 y = 0; y < height; y++)
						{
							for(s32 x = 0, pos = y*width; x < width; x++, pos++)
							{
								u8 color = screen[pos];
								for(s32 s = 0, pos = x*scale; s < scale; s++, pos++)
									line[pos] = color;
							}

							for(s32 s = 0; s < scale; s++)
							{
								if (EGifPutLine(gif, line, swidth) == GIF_ERROR)
								{
									error = gif->Error;
									break;
								}
							}

							if(error != E_GIF_SUCCEEDED) break;
						}

						*size = output.pos;

						result = error == E_GIF_SUCCEEDED;
					}

					GifFreeMapObject(colorMap);

					if(!result)
						break;
				}

				free(line);
				free(screen);
				free(palette);
			}
		}

		EGifCloseFile(gif, &error);

		*size = output.pos;
	}

	return result;
}