#include "Display.h"
#include "DrawContext.h"
#include "FrameBuffer.h"
#include "Image.h"
#include "SpriteAssetLoader.h"

#include <cassert>
#include <cstdio>
#include <iostream>
#include <string>
#include <vector>

namespace
{
	class CaptureDisplay : public Platform::IDisplay
	{
	public:
		const Core::FrameBuffer* framebuffer;

		CaptureDisplay()
			: framebuffer(nullptr)
		{
		}

		bool init(int, int) override { return true; }
		void present(const Core::FrameBuffer* fb) override { framebuffer = fb; }
		void poll_events(bool&) override {}
		void shutdown() override {}
	};

	void TestFramePixelIsRgb565()
	{
		static_assert(sizeof(Core::FramePixel) == sizeof(uint16_t), "FramePixel must stay RGB565");
		assert(RenderData::rgba5551_to_rgb565(0xF801u) == 0xF800u);
		assert(RenderData::rgba5551_to_rgb565(0x07C1u) == 0x07E0u);
		assert(RenderData::rgba5551_to_rgb565(0x003Fu) == 0x001Fu);
	}

	void TestFrameBufferStoresRgb565()
	{
		Core::FrameBuffer framebuffer(2, 1);
		framebuffer.clear(RenderData::Color(255, 0, 0, 255));

		const Core::FramePixel* pixels = static_cast<const Core::FramePixel*>(framebuffer.get_buffer());
		assert(pixels[0] == 0xF800u);
		assert(pixels[1] == 0xF800u);
	}

	void TestDrawSpriteUsesOneBitAlpha()
	{
		const uint16_t sprite_pixels[] = {
			0xF800u,
			0x07C1u
		};

		Core::DrawContext ctx(2, 1);
		ctx.clear_color(RenderData::Color(0, 0, 255, 255));

		RenderData::Image sprite(
			sprite_pixels,
			2,
			1,
			RenderData::PixelFormat::RGBA5551);
		ctx.draw_sprite(0, 0, sprite);

		CaptureDisplay display;
		ctx.present(&display);
		assert(display.framebuffer != nullptr);

		const Core::FramePixel* pixels =
			static_cast<const Core::FramePixel*>(display.framebuffer->get_buffer());
		assert(pixels[0] == 0x001Fu);
		assert(pixels[1] == 0x07E0u);
	}

	void TestSpriteAssetLoaderRoundTripsRgba5551()
	{
		const std::string path = "render_pipeline_test.sprite";
		const uint16_t original_pixels[] = {
			0x0000u,
			0xF801u,
			0x07C1u,
			0x003Fu
		};

		RenderData::Image original(
			original_pixels,
			2,
			2,
			RenderData::PixelFormat::RGBA5551);
		assert(Asset::SpriteAssetLoader::Save(path, original));

		std::vector<uint16_t> loaded_pixels;
		RenderData::Image loaded;
		const bool loaded_ok = Asset::SpriteAssetLoader::Load(path, loaded_pixels, loaded);
		std::remove(path.c_str());

		assert(loaded_ok);
		assert(loaded.format == RenderData::PixelFormat::RGBA5551);
		assert(loaded.width == 2);
		assert(loaded.height == 2);
		assert(loaded_pixels.size() == 4u);
		for (size_t i = 0; i < loaded_pixels.size(); ++i)
		{
			assert(loaded_pixels[i] == original_pixels[i]);
		}
	}
}

int main()
{
	TestFramePixelIsRgb565();
	TestFrameBufferStoresRgb565();
	TestDrawSpriteUsesOneBitAlpha();
	TestSpriteAssetLoaderRoundTripsRgba5551();
	std::cout << "render_pipeline_tests: PASS\n";
	return 0;
}