#include "Command.hpp"

#include <QJsonObject>
#include <QMetaEnum>
#include <array>

using namespace Epistmool::Server;

namespace {
const auto kKindTraits = []() {
	using enum ProtocolMessage::Kind;
	std::array<ProtocolMessage::KindTrait, static_cast<size_t>(KindCOUNT)> array;

	array[SessionAuth] = { .isC2S = true, .hasReply = true };
	array[SessionDestroy] = { .isC2S = true, .hasReply = true };

	array[WorkspaceCreate] = { .isC2S = true, .hasReply = true };
	array[WorkspaceFetchIndex] = { .isC2S = true, .hasReply = true };

	array[WorkspaceFetchKnowledge] = { .isC2S = true, .hasReply = true };
	array[WorkspaceUpdateKnowledge] = { .isC2S = true, .hasReply = true };
	array[WorkspaceCreateKnowledge] = { .isC2S = true, .hasReply = true };
	array[WorkspaceDeleteKnowledge] = { .isC2S = true, .hasReply = true };

	array[WorkspaceFetchKeyword] = { .isC2S = true, .hasReply = true };
	array[WorkspaceUpdateKeyword] = { .isC2S = true, .hasReply = true };
	array[WorkspaceCreateKeyword] = { .isC2S = true, .hasReply = true };
	array[WorkspaceDeleteKeyword] = { .isC2S = true, .hasReply = true };

	array[NotificationWorkspaceUpdated] = { .isC2S = false, .hasReply = false };
	array[NotificationKnowledgeUpdated] = { .isC2S = false, .hasReply = false };

	return array;
}();
}

std::unique_ptr<ProtocolRequest> ProtocolMessage::createRequest(Kind kind)
{
	switch(kind) {
		case SessionAuth: return std::make_unique<ProtocolRequest_SessionAuth>();
		case SessionDestroy: return std::make_unique<ProtocolRequest_SessionDestroy>();

		case WorkspaceCreate: return nullptr;
		case WorkspaceFetchIndex: return std::make_unique<ProtocolRequest_WorkspaceFetchIndex>();

		case WorkspaceFetchKnowledge: return nullptr;
		case WorkspaceUpdateKnowledge: return nullptr;
		case WorkspaceCreateKnowledge: return nullptr;
		case WorkspaceDeleteKnowledge: return nullptr;

		case WorkspaceFetchKeyword: return nullptr;
		case WorkspaceUpdateKeyword: return nullptr;
		case WorkspaceCreateKeyword: return nullptr;
		case WorkspaceDeleteKeyword: return nullptr;

		case NotificationWorkspaceUpdated: return std::make_unique<ProtocolNotification_WorkspaceUpdate>();
		case NotificationKnowledgeUpdated: return nullptr;

		default: return nullptr;
	}
}

std::unique_ptr<ProtocolReply> ProtocolMessage::createReply(Kind kind)
{
	switch(kind) {
		case SessionAuth: return std::make_unique<ProtocolReply_SessionAuth>();
		case SessionDestroy: return std::make_unique<ProtocolReply_SessionDestroy>();

		case WorkspaceCreate: return nullptr;
		case WorkspaceFetchIndex: return std::make_unique<ProtocolReply_WorkspaceFetchIndex>();

		case WorkspaceFetchKnowledge: return nullptr;
		case WorkspaceUpdateKnowledge: return nullptr;
		case WorkspaceCreateKnowledge: return nullptr;
		case WorkspaceDeleteKnowledge: return nullptr;

		case WorkspaceFetchKeyword: return nullptr;
		case WorkspaceUpdateKeyword: return nullptr;
		case WorkspaceCreateKeyword: return nullptr;
		case WorkspaceDeleteKeyword: return nullptr;

		case NotificationWorkspaceUpdated: return nullptr;
		case NotificationKnowledgeUpdated: return nullptr;

		default: return nullptr;
	}
}

const ProtocolMessage::KindTrait& ProtocolMessage::getKindTrait(Kind kind)
{
	return kKindTraits[kind];
}

ProtocolMessage::ProtocolMessage(Kind kind, Variant variant)
	: kind{ kind }
	, variant{ variant }
{
}

ProtocolRequest::ProtocolRequest(Kind kind)
	: ProtocolMessage(kind, RequestVariant)
{
}

QJsonObject ProtocolRequest::serialize(const ProtocolRequest& msg)
{
	QJsonObject object;
	object.insert("method", QMetaEnum::fromType<Kind>().valueToKey(msg.kind));

	QJsonObject fields;
	msg.serializeFields(fields);

	return object;
}

std::unique_ptr<ProtocolRequest> ProtocolRequest::deserialize(const QJsonObject& object)
{
	bool ok;
	auto methodName = object.value("method").toString().toStdString();
	auto method = static_cast<Kind>(QMetaEnum::fromType<Kind>().keysToValue(methodName.c_str(), &ok));
	if (!ok) return nullptr;

	auto msg = createRequest(method);

	auto fieldsVal = object.value("fields");
	if (!fieldsVal.isObject()) return nullptr;
	msg->deserializeFields(fieldsVal.toObject());

	return msg;
}

ProtocolReply::ProtocolReply(Kind kind)
	: ProtocolMessage(kind, ReplyVariant)
{
}

QJsonObject ProtocolReply::serialize(const ProtocolReply& msg)
{
	QJsonObject object;
	object.insert("method", QMetaEnum::fromType<Kind>().valueToKey(msg.kind));
	object.insert("sequence", msg.sequence);

	QJsonObject fields;
	msg.serializeFields(fields);

	return object;
}

std::unique_ptr<ProtocolReply> ProtocolReply::deserialize(const QJsonObject& object)
{
	bool ok;
	auto methodName = object.value("method").toString().toStdString();
	auto method = static_cast<Kind>(QMetaEnum::fromType<Kind>().keysToValue(methodName.c_str(), &ok));
	if (!ok) return nullptr;

	auto msg = createReply(method);

	msg->sequence = object.value("sequence").toInt(-1);

	auto fieldsVal = object.value("fields");
	if (!fieldsVal.isObject()) return nullptr;
	msg->deserializeFields(fieldsVal.toObject());

	return msg;
}

ProtocolRequest_SessionAuth::ProtocolRequest_SessionAuth()
	: ProtocolRequest(SessionAuth) {}

void ProtocolRequest_SessionAuth::serializeFields(QJsonObject& object) const
{
	object.insert("session", theSession);
	object.insert("createIfInvalid", createIfInvalid);
}

void ProtocolRequest_SessionAuth::deserializeFields(const QJsonObject& object)
{
	theSession = object.value("session").toInt();
	createIfInvalid = object.value("createIfInvalid").toBool();
}

ProtocolReply_SessionAuth::ProtocolReply_SessionAuth()
	: ProtocolReply(SessionAuth) {}

void ProtocolReply_SessionAuth::serializeFields(QJsonObject& object) const
{
	object.insert("session", theSession);
}

void ProtocolReply_SessionAuth::deserializeFields(const QJsonObject& object)
{
	theSession = object.value("session").toInt();
}

ProtocolRequest_SessionDestroy::ProtocolRequest_SessionDestroy()
	: ProtocolRequest(SessionDestroy) {}

void ProtocolRequest_SessionDestroy::serializeFields(QJsonObject& object) const
{
}

void ProtocolRequest_SessionDestroy::deserializeFields(const QJsonObject& object)
{
}

ProtocolReply_SessionDestroy::ProtocolReply_SessionDestroy()
	: ProtocolReply(SessionDestroy) {}

void ProtocolReply_SessionDestroy::serializeFields(QJsonObject& object) const
{
}

void ProtocolReply_SessionDestroy::deserializeFields(const QJsonObject& object)
{
}

ProtocolRequest_WorkspaceFetchIndex::ProtocolRequest_WorkspaceFetchIndex()
	: ProtocolRequest(WorkspaceFetchIndex) {}

void ProtocolRequest_WorkspaceFetchIndex::serializeFields(QJsonObject& object) const
{
	object.insert("knowledgeFilter", knowledgeFilter);
	object.insert("knowledgeMaxCount", knowledgeMaxCount);
	object.insert("keywordFilter", keywordFilter);
	object.insert("keywordMaxCount", keywordMaxCount);
}

void ProtocolRequest_WorkspaceFetchIndex::deserializeFields(const QJsonObject& object)
{
	knowledgeFilter = object.value("knowledgeFilter").toString();
	knowledgeMaxCount = object.value("knowledgeMaxCount").toInt();
	keywordFilter = object.value("keywordFilter").toString();
	keywordMaxCount = object.value("keywordMaxCount").toInt();
}

ProtocolReply_WorkspaceFetchIndex::ProtocolReply_WorkspaceFetchIndex()
	: ProtocolReply(WorkspaceFetchIndex) {}

void ProtocolReply_WorkspaceFetchIndex::serializeFields(QJsonObject& object) const
{
}

void ProtocolReply_WorkspaceFetchIndex::deserializeFields(const QJsonObject& object)
{
}

ProtocolNotification_WorkspaceUpdate::ProtocolNotification_WorkspaceUpdate()
	: ProtocolRequest(NotificationWorkspaceUpdated) {}

void ProtocolNotification_WorkspaceUpdate::serializeFields(QJsonObject& object) const
{
}

void ProtocolNotification_WorkspaceUpdate::deserializeFields(const QJsonObject& object)
{
}