#include "HttpControlServer.h"

#include <iostream>
#include <string>

namespace
{
int gFailures = 0;

void Expect(bool condition, const std::string& message)
{
	if (condition)
		return;

	++gFailures;
	std::cerr << "FAILED: " << message << "\n";
}

void ExpectEquals(const std::string& actual, const std::string& expected, const std::string& message)
{
	if (actual == expected)
		return;

	++gFailures;
	std::cerr << "FAILED: " << message << "\n"
		<< "expected: " << expected << "\n"
		<< "actual:   " << actual << "\n";
}

void TestParsesHttpRequest()
{
	using namespace RenderCadenceCompositor;

	HttpControlServer::HttpRequest request;
	const bool parsed = HttpControlServer::ParseHttpRequest(
		"GET /api/state?cacheBust=1 HTTP/1.1\r\nHost: 127.0.0.1\r\n\r\n",
		request);

	Expect(parsed, "request parses");
	ExpectEquals(request.method, "GET", "method is parsed");
	ExpectEquals(request.path, "/api/state", "query string is stripped from path");
	ExpectEquals(request.headers["host"], "127.0.0.1", "headers are lower-cased and trimmed");
}

void TestStateEndpointUsesCallback()
{
	using namespace RenderCadenceCompositor;

	HttpControlServer server;
	HttpControlServerCallbacks callbacks;
	callbacks.getStateJson = []() { return std::string("{\"ok\":true}"); };
	server.SetCallbacksForTest(callbacks);

	HttpControlServer::HttpRequest request;
	request.method = "GET";
	request.path = "/api/state";

	const HttpControlServer::HttpResponse response = server.RouteRequestForTest(request);
	ExpectEquals(response.status, "200 OK", "state endpoint succeeds");
	ExpectEquals(response.contentType, "application/json", "state endpoint is JSON");
	ExpectEquals(response.body, "{\"ok\":true}", "state endpoint returns callback JSON");
}

void TestKnownPostEndpointReturnsActionError()
{
	using namespace RenderCadenceCompositor;

	HttpControlServer server;
	HttpControlServer::HttpRequest request;
	request.method = "POST";
	request.path = "/api/layers/add";
	request.body = "{\"shaderId\":\"happy-accident\"}";

	const HttpControlServer::HttpResponse response = server.RouteRequestForTest(request);
	ExpectEquals(response.status, "400 Bad Request", "unimplemented post returns OpenAPI action error status");
	ExpectEquals(response.contentType, "application/json", "unimplemented post returns JSON");
	Expect(response.body.find("\"ok\":false") != std::string::npos, "unimplemented post reports ok false");
	Expect(response.body.find("not implemented") != std::string::npos, "unimplemented post reports diagnostic");
}

void TestUnknownEndpointReturns404()
{
	using namespace RenderCadenceCompositor;

	HttpControlServer server;
	HttpControlServer::HttpRequest request;
	request.method = "GET";
	request.path = "/api/nope";

	const HttpControlServer::HttpResponse response = server.RouteRequestForTest(request);
	ExpectEquals(response.status, "404 Not Found", "unknown endpoint returns 404");
}
}

int main()
{
	TestParsesHttpRequest();
	TestStateEndpointUsesCallback();
	TestKnownPostEndpointReturnsActionError();
	TestUnknownEndpointReturns404();

	if (gFailures != 0)
	{
		std::cerr << gFailures << " RenderCadenceCompositorHttpControlServer test failure(s).\n";
		return 1;
	}

	std::cout << "RenderCadenceCompositorHttpControlServer tests passed.\n";
	return 0;
}