#include <algorithm>
#include <cmath>
#include <cstdlib>
#include <cstring>
#include <iostream>
#include <memory>
#include <png.h>
#include "common/platform/Platform.h"
#include "FontReader.h"
#include "Format.h"
#include "Graphics.h"
#include "resampler/resampler.h"
#include "SimulationConfig.h"
#include "RasterDrawMethodsImpl.h"

VideoBuffer::VideoBuffer(Vec2<int> size):
	video(size)
{}

VideoBuffer::VideoBuffer(pixel const *data, Vec2<int> size):
	VideoBuffer(size)
{
	std::copy_n(data, size.X * size.Y, video.data());
}

VideoBuffer::VideoBuffer(pixel const *data, Vec2<int> size, size_t rowStride):
	VideoBuffer(size)
{
	for(int y = 0; y < size.Y; y++)
		std::copy_n(data + rowStride * y, size.X, video.RowIterator(Vec2(0, y)));
}

void VideoBuffer::Crop(Rect<int> rect)
{
	rect &= Size().OriginRect();
	if (rect == Size().OriginRect())
		return;

	PlaneAdapter<std::vector<pixel> &> newVideo(rect.Size(), std::in_place, video.Base);
	for (auto y = 0; y < newVideo.Size().Y; y++)
		std::copy_n(
			video.RowIterator(rect.TopLeft + Vec2(0, y)),
			newVideo.Size().X,
			newVideo.RowIterator(Vec2(0, y))
		);
	video.Base.resize(newVideo.Size().X * newVideo.Size().Y);
	video.Base.shrink_to_fit();
	video.SetSize(newVideo.Size());
}

void VideoBuffer::Resize(Vec2<int> size, bool resample)
{
	if (size == Size())
		return;

	if (resample)
	{
		std::array<std::unique_ptr<Resampler>, PIXELCHANNELS> resamplers;
		Resampler::Contrib_List *clist_x = NULL, *clist_y = NULL;
		for (auto &ptr : resamplers)
		{
			ptr = std::make_unique<Resampler>(
				Size().X, Size().Y, // source size
				size.X, size.Y, // destination size
				Resampler::BOUNDARY_CLAMP,
				0.0f, 255.0f, // upper and lower bounds for channel values
				"lanczos12",
				clist_x, clist_y,
				0.75f, 0.75f // X and Y filter scales, values < 1.0 cause aliasing, but create sharper looking mips.
			);
			clist_x = ptr->get_clist_x();
			clist_y = ptr->get_clist_y();
		}

		std::array<std::unique_ptr<float []>, PIXELCHANNELS> samples;
		for (auto &ptr : samples)
			ptr = std::make_unique<float []>(Size().X);

		PlaneAdapter<std::vector<pixel>> newVideo(size);

		pixel const *inIter = video.data();
		std::array<pixel *, PIXELCHANNELS> outIter;
		for (pixel *&it : outIter)
			it = newVideo.data();

		for (int sourceY = 0; sourceY < Size().Y; sourceY++)
		{
			for (int sourceX = 0; sourceX < Size().X; sourceX++)
			{
				pixel px = *inIter++;
				for (int c = 0; c < PIXELCHANNELS; c++)
					samples[c][sourceX] = uint8_t(px >> (8 * c));
			}

			for (int c = 0; c < PIXELCHANNELS; c++)
			{
				if (!resamplers[c]->put_line(samples[c].get()))
				{
					fprintf(stderr, "Out of memory when resampling\n");
					Crop(size.OriginRect()); // Better than leaving the image at original size I guess
					return;
				}

				while (float const *output = resamplers[c]->get_line())
					for (int destX = 0; destX < size.X; destX++)
						*outIter[c]++ |= pixel(uint8_t(output[destX])) << (8 * c);
			}
		}

		video = std::move(newVideo);
	}
	else
	{
		PlaneAdapter<std::vector<pixel>> newVideo(size);
		for (auto pos : size.OriginRect())
		{
			auto oldPos = Vec2(pos.X * Size().X / size.X, pos.Y * Size().Y / size.Y);
			newVideo[pos] = video[oldPos];
		}
		video = std::move(newVideo);
	}
}

void VideoBuffer::Resize(float factor, bool resample)
{
	Resize(Vec2{ int(Size().X * factor), int(Size().Y * factor) }, resample);
}

void VideoBuffer::ResizeToFit(Vec2<int> bound, bool resample)
{
	Vec2<int> size = Size();
	if (size.X > bound.X || size.Y > bound.Y)
	{
		auto ceilDiv = [](int a, int b) {
			return a / b + ((a % b) ? 1 : 0);
		};
		if (bound.X * size.Y < bound.Y * size.X)
			size = { bound.X, ceilDiv(size.Y * bound.X, size.X) };
		else
			size = { ceilDiv(size.X * bound.Y, size.Y), bound.Y };
	}
	Resize(size, resample);
}

std::unique_ptr<VideoBuffer> VideoBuffer::FromPNG(std::vector<char> const &data)
{
	auto video = format::PixelsFromPNG(data, 0x000000_rgb);
	if (video)
	{
		auto buf = std::make_unique<VideoBuffer>(Vec2<int>::Zero);
		buf->video = std::move(*video);
		return buf;
	}
	else
		return nullptr;
}

std::unique_ptr<std::vector<char>> VideoBuffer::ToPNG() const
{
	return format::PixelsToPNG(video);
}

std::vector<char> VideoBuffer::ToPPM() const
{
	return format::PixelsToPPM(video);
}

template struct RasterDrawMethods<VideoBuffer>;

Graphics::Graphics()
{}

void Graphics::draw_icon(int x, int y, Icon icon, unsigned char alpha, bool invert)
{
	y--;
	switch(icon)
	{
	case IconOpen:
		if(invert)
			BlendChar({ x, y }, 0xE001, 0x000000_rgb .WithAlpha(alpha));
		else
			BlendChar({ x, y }, 0xE001, 0xFFFFFF_rgb .WithAlpha(alpha));
		break;
	case IconReload:
		if(invert)
			BlendChar({ x, y }, 0xE011, 0x000000_rgb .WithAlpha(alpha));
		else
			BlendChar({ x, y }, 0xE011, 0xFFFFFF_rgb .WithAlpha(alpha));
		break;
	case IconSave:
		if(invert)
			BlendChar({ x, y }, 0xE002, 0x000000_rgb .WithAlpha(alpha));
		else
			BlendChar({ x, y }, 0xE002, 0xFFFFFF_rgb .WithAlpha(alpha));
		break;
	case IconVoteUp:
		if(invert)
		{
			BlendChar({ x-11, y+1 }, 0xE04B, 0x006400_rgb .WithAlpha(alpha));
			BlendText({ x+2, y+1 }, "Vote", 0x006400_rgb .WithAlpha(alpha));
		}
		else
		{
			BlendChar({ x-11, y+1 }, 0xE04B, 0x00BB12_rgb .WithAlpha(alpha));
			BlendText({ x+2, y+1 }, "Vote", 0x00BB12_rgb .WithAlpha(alpha));
		}
		break;
	case IconVoteDown:
		if(invert)
			BlendChar({ x, y }, 0xE04A, 0x640A00_rgb .WithAlpha(alpha));
		else
			BlendChar({ x, y }, 0xE04A, 0xBB2800_rgb .WithAlpha(alpha));
		break;
	case IconTag:
		if(invert)
			BlendChar({ x, y }, 0xE003, 0x000000_rgb .WithAlpha(alpha));
		else
			BlendChar({ x, y }, 0xE003, 0xFFFFFF_rgb .WithAlpha(alpha));
		break;
	case IconNew:
		if(invert)
			BlendChar({ x, y }, 0xE012, 0x000000_rgb .WithAlpha(alpha));
		else
			BlendChar({ x, y }, 0xE012, 0xFFFFFF_rgb .WithAlpha(alpha));
		break;
	case IconLogin:
		if(invert)
			BlendChar({ x, y + 1 }, 0xE004, 0x000000_rgb .WithAlpha(alpha));
		else
			BlendChar({ x, y + 1 }, 0xE004, 0xFFFFFF_rgb .WithAlpha(alpha));
		break;
	case IconSimulationSettings:
		if(invert)
			BlendChar({ x, y + 1 }, 0xE04F, 0x000000_rgb .WithAlpha(alpha));
		else
			BlendChar({ x, y + 1 }, 0xE04F, 0xFFFFFF_rgb .WithAlpha(alpha));
		break;
	case IconRenderSettings:
		if(invert)
		{
			BlendChar({ x, y + 1 }, 0xE058, 0xFF0000_rgb .WithAlpha(alpha));
			BlendChar({ x, y + 1 }, 0xE059, 0x00FF00_rgb .WithAlpha(alpha));
			BlendChar({ x, y + 1 }, 0xE05A, 0x0000FF_rgb .WithAlpha(alpha));
		}
		else
		{
			AddChar({ x, y + 1 }, 0xE058, 0xFF0000_rgb .WithAlpha(alpha));
			AddChar({ x, y + 1 }, 0xE059, 0x00FF00_rgb .WithAlpha(alpha));
			AddChar({ x, y + 1 }, 0xE05A, 0x0000FF_rgb .WithAlpha(alpha));
		}
		break;
	case IconPause:
		if(invert)
			BlendChar({ x, y }, 0xE010, 0x000000_rgb .WithAlpha(alpha));
		else
			BlendChar({ x, y }, 0xE010, 0xFFFFFF_rgb .WithAlpha(alpha));
		break;
	case IconFavourite:
		if(invert)
			BlendChar({ x, y }, 0xE04C, 0x645020_rgb .WithAlpha(alpha));
		else
			BlendChar({ x, y }, 0xE04C, 0xC0A040_rgb .WithAlpha(alpha));
		break;
	case IconReport:
		if(invert)
			BlendChar({ x, y }, 0xE063, 0x8C8C00_rgb .WithAlpha(alpha));
		else
			BlendChar({ x, y }, 0xE063, 0xFFFF00_rgb .WithAlpha(alpha));
		break;
	case IconUsername:
		if(invert)
		{
			BlendChar({ x, y }, 0xE00B, 0x204080_rgb .WithAlpha(alpha));
			BlendChar({ x, y }, 0xE00A, 0x000000_rgb .WithAlpha(alpha));
		}
		else
		{
			BlendChar({ x, y }, 0xE00B, 0x204080_rgb .WithAlpha(alpha));
			BlendChar({ x, y }, 0xE00A, 0xFFFFFF_rgb .WithAlpha(alpha));
		}
		break;
	case IconPassword:
		if(invert)
		{
			BlendChar({ x, y }, 0xE00C, 0xA09020_rgb .WithAlpha(alpha));
			BlendChar({ x, y }, 0xE004, 0x000000_rgb .WithAlpha(alpha));
		}
		else
		{
			BlendChar({ x, y }, 0xE00C, 0xA09020_rgb .WithAlpha(alpha));
			BlendChar({ x, y }, 0xE004, 0xFFFFFF_rgb .WithAlpha(alpha));
		}
		break;
	case IconClose:
		if(invert)
			BlendChar({ x, y }, 0xE02A, 0x141414_rgb .WithAlpha(alpha));
		else
			BlendChar({ x, y }, 0xE02A, 0xE6E6E6_rgb .WithAlpha(alpha));
		break;
	case IconVoteSort:
		if (invert)
		{
			BlendChar({ x, y }, 0xE029, 0x2C3020_rgb .WithAlpha(alpha));
			BlendChar({ x, y }, 0xE028, 0x202C20_rgb .WithAlpha(alpha));
			BlendChar({ x, y }, 0xE027, 0x808080_rgb .WithAlpha(alpha));
		}
		else
		{
			BlendChar({ x, y }, 0xE029, 0x903020_rgb .WithAlpha(alpha));
			BlendChar({ x, y }, 0xE028, 0x209020_rgb .WithAlpha(alpha));
			BlendChar({ x, y }, 0xE027, 0xFFFFFF_rgb .WithAlpha(alpha));
		}
		break;
	case IconDateSort:
		if (invert)
		{
			BlendChar({ x, y }, 0xE026, 0x202020_rgb .WithAlpha(alpha));
		}
		else
		{
			BlendChar({ x, y }, 0xE026, 0xFFFFFF_rgb .WithAlpha(alpha));
		}
		break;
	case IconMyOwn:
		if (invert)
		{
			BlendChar({ x, y }, 0xE014, 0xC0A040_rgb .WithAlpha(alpha));
			BlendChar({ x, y }, 0xE013, 0x202020_rgb .WithAlpha(alpha));
		}
		else
		{
			BlendChar({ x, y }, 0xE014, 0xC0A040_rgb .WithAlpha(alpha));
			BlendChar({ x, y }, 0xE013, 0xFFFFFF_rgb .WithAlpha(alpha));
		}
		break;
	case IconSearch:
		BlendChar({ x, y }, 0xE00E, 0x1E1EB4_rgb .WithAlpha(alpha));
		BlendChar({ x, y }, 0xE00F, 0xFFFFFF_rgb .WithAlpha(alpha));
		break;
	case IconDelete:
		if(invert)
		{
			BlendChar({ x, y }, 0xE006, 0x9F2F1F_rgb .WithAlpha(alpha));
			BlendChar({ x, y }, 0xE005, 0x000000_rgb .WithAlpha(alpha));
		}
		else
		{
			BlendChar({ x, y }, 0xE006, 0x9F2F1F_rgb .WithAlpha(alpha));
			BlendChar({ x, y }, 0xE005, 0xFFFFFF_rgb .WithAlpha(alpha));
		}
		break;
	case IconAdd:
		if(invert)
		{
			BlendChar({ x, y }, 0xE006, 0x209020_rgb .WithAlpha(alpha));
			BlendChar({ x, y }, 0xE009, 0x000000_rgb .WithAlpha(alpha));
		}
		else
		{
			BlendChar({ x, y }, 0xE006, 0x209020_rgb .WithAlpha(alpha));
			BlendChar({ x, y }, 0xE009, 0xFFFFFF_rgb .WithAlpha(alpha));
		}
		break;
	case IconVelocity:
		BlendChar({ x + 1, y }, 0xE018, 0x80A0FF_rgb .WithAlpha(alpha));
		break;
	case IconPressure:
		if(invert)
			BlendChar({ x + 1, y + 1 }, 0xE019, 0xB4A010_rgb .WithAlpha(alpha));
		else
			BlendChar({ x + 1, y + 1 }, 0xE019, 0xFFD420_rgb .WithAlpha(alpha));
		break;
	case IconPersistant:
		if(invert)
			BlendChar({ x + 1, y + 1 }, 0xE01A, 0x141414_rgb .WithAlpha(alpha));
		else
			BlendChar({ x + 1, y + 1 }, 0xE01A, 0xD4D4D4_rgb .WithAlpha(alpha));
		break;
	case IconFire:
		BlendChar({ x + 1, y + 1 }, 0xE01B, 0xFF0000_rgb .WithAlpha(alpha));
		BlendChar({ x + 1, y + 1 }, 0xE01C, 0xFFFF40_rgb .WithAlpha(alpha));
		break;
	case IconBlob:
		if(invert)
			BlendChar({ x + 1, y }, 0xE03F, 0x37B437_rgb .WithAlpha(alpha));
		else
			BlendChar({ x + 1, y }, 0xE03F, 0x37FF37_rgb .WithAlpha(alpha));
		break;
	case IconHeat:
		BlendChar({ x + 3, y }, 0xE03E, 0xFF0000_rgb .WithAlpha(alpha));
		if(invert)
			BlendChar({ x + 3, y }, 0xE03D, 0x000000_rgb .WithAlpha(alpha));
		else
			BlendChar({ x + 3, y }, 0xE03D, 0xFFFFFF_rgb .WithAlpha(alpha));
		break;
	case IconBlur:
		if(invert)
			BlendChar({ x + 1, y }, 0xE044, 0x3246B4_rgb .WithAlpha(alpha));
		else
			BlendChar({ x + 1, y }, 0xE044, 0x6496FF_rgb .WithAlpha(alpha));
		break;
	case IconGradient:
		if(invert)
			BlendChar({ x + 1, y + 1 }, 0xE053, 0xFF32FF_rgb .WithAlpha(alpha));
		else
			BlendChar({ x + 1, y + 1 }, 0xE053, 0xCD32CD_rgb .WithAlpha(alpha));
		break;
	case IconLife:
		if(invert)
			BlendChar({ x, y + 1 }, 0xE060, 0x000000_rgb .WithAlpha(alpha));
		else
			BlendChar({ x, y + 1 }, 0xE060, 0xFFFFFF_rgb .WithAlpha(alpha));
		break;
	case IconEffect:
		BlendChar({ x + 1, y }, 0xE061, 0xFFFFA0_rgb .WithAlpha(alpha));
		break;
	case IconGlow:
		BlendChar({ x + 1, y }, 0xE05F, 0xC8FFFF_rgb .WithAlpha(alpha));
		break;
	case IconWarp:
		BlendChar({ x + 1, y }, 0xE05E, 0xFFFFFF_rgb .WithAlpha(alpha));
		break;
	case IconBasic:
		if(invert)
			BlendChar({ x + 1, y + 1 }, 0xE05B, 0x323200_rgb .WithAlpha(alpha));
		else
			BlendChar({ x + 1, y + 1 }, 0xE05B, 0xFFFFC8_rgb .WithAlpha(alpha));
		break;
	case IconAltAir:
		if(invert) {
			BlendChar({ x + 1, y + 1 }, 0xE054, 0xB43737_rgb .WithAlpha(alpha));
			BlendChar({ x + 1, y + 1 }, 0xE055, 0x37B437_rgb .WithAlpha(alpha));
		} else {
			BlendChar({ x + 1, y + 1 }, 0xE054, 0xFF3737_rgb .WithAlpha(alpha));
			BlendChar({ x + 1, y + 1 }, 0xE055, 0x37FF37_rgb .WithAlpha(alpha));
		}
		break;
	default:
		if(invert)
			BlendChar({ x, y }, 't', 0x000000_rgb .WithAlpha(alpha));
		else
			BlendChar({ x, y }, 't', 0xFFFFFF_rgb .WithAlpha(alpha));
		break;
	}
}

VideoBuffer Graphics::DumpFrame()
{
	VideoBuffer newBuffer(video.Size());
	std::copy_n(video.data(), video.Size().X * video.Size().Y, newBuffer.Data());
	return newBuffer;
}

void Graphics::SwapClipRect(Rect<int> &rect)
{
	std::swap(clipRect, rect);
	clipRect &= video.Size().OriginRect();
}

bool Graphics::GradientStop::operator <(const GradientStop &other) const
{
	return point < other.point;
}

std::vector<RGB<uint8_t>> Graphics::Gradient(std::vector<GradientStop> stops, int resolution)
{
	std::vector<RGB<uint8_t>> table(resolution, 0x000000_rgb);
	if (stops.size() >= 2)
	{
		std::sort(stops.begin(), stops.end());
		auto stop = -1;
		for (auto i = 0; i < resolution; ++i)
		{
			auto point = i / (float)resolution;
			while (stop < (int)stops.size() - 1 && stops[stop + 1].point <= point)
			{
				++stop;
			}
			if (stop < 0 || stop >= (int)stops.size() - 1)
			{
				continue;
			}
			auto &left = stops[stop];
			auto &right = stops[stop + 1];
			auto f = (point - left.point) / (right.point - left.point);
			table[i] = left.color.Blend(right.color.WithAlpha(uint8_t(f * 0xFF)));
		}
	}
	return table;
}
