/*
 * Copyright 2022 Young Mei
 *
 * SPDX-License-Identifier: Apache-2.0
 */

#pragma once

#include <cstdint>
#include <cstdio>

#include <sstream>
#include <stdexcept>

#include "SecondService.h"
#include "ThriftTest.h"

using namespace std;

using namespace apache::thrift;
using namespace apache::thrift::transport;
using namespace thrift::test;

class TestHandler : public ThriftTestIf
{
public:
	TestHandler() = default;

	void testVoid() override
	{
		printf("testVoid()\n");
	}

	void testString(string &out, const string &thing) override
	{
		printf("testString(\"%s\")\n", thing.c_str());
		out = thing;
	}

	bool testBool(const bool thing) override
	{
		printf("testBool(%s)\n", thing ? "true" : "false");
		return thing;
	}

	int8_t testByte(const int8_t thing) override
	{
		printf("testByte(%d)\n", (int)thing);
		return thing;
	}

	int32_t testI32(const int32_t thing) override
	{
		printf("testI32(%d)\n", thing);
		return thing;
	}

	int64_t testI64(const int64_t thing) override
	{
		printf("testI64(%" PRId64 ")\n", thing);
		return thing;
	}

	double testDouble(const double thing) override
	{
		printf("testDouble(%f)\n", thing);
		return thing;
	}

	void testBinary(std::string &_return, const std::string &thing) override
	{
		std::ostringstream hexstr;

		hexstr << std::hex << thing;
		printf("testBinary(%lu: %s)\n", safe_numeric_cast<unsigned long>(thing.size()),
		       hexstr.str().c_str());
		_return = thing;
	}

	void testStruct(Xtruct &out, const Xtruct &thing) override
	{
		printf("testStruct({\"%s\", %d, %d, %" PRId64 "})\n", thing.string_thing.c_str(),
		       (int)thing.byte_thing, thing.i32_thing, thing.i64_thing);
		out = thing;
	}

	void testNest(Xtruct2 &out, const Xtruct2 &nest) override
	{
		const Xtruct &thing = nest.struct_thing;

		printf("testNest({%d, {\"%s\", %d, %d, %" PRId64 "}, %d})\n", (int)nest.byte_thing,
		       thing.string_thing.c_str(), (int)thing.byte_thing, thing.i32_thing,
		       thing.i64_thing, nest.i32_thing);
		out = nest;
	}

	void testMap(map<int32_t, int32_t> &out, const map<int32_t, int32_t> &thing) override
	{
		map<int32_t, int32_t>::const_iterator m_iter;
		bool first = true;

		printf("testMap({");
		for (m_iter = thing.begin(); m_iter != thing.end(); ++m_iter) {
			if (first) {
				first = false;
			} else {
				printf(", ");
			}

			printf("%d => %d", m_iter->first, m_iter->second);
		}

		printf("})\n");
		out = thing;
	}

	void testStringMap(map<std::string, std::string> &out,
			   const map<std::string, std::string> &thing) override
	{
		map<std::string, std::string>::const_iterator m_iter;
		bool first = true;

		printf("testMap({");
		for (m_iter = thing.begin(); m_iter != thing.end(); ++m_iter) {
			if (first) {
				first = false;
			} else {
				printf(", ");
			}
			printf("%s => %s", (m_iter->first).c_str(), (m_iter->second).c_str());
		}

		printf("})\n");
		out = thing;
	}

	void testSet(set<int32_t> &out, const set<int32_t> &thing) override
	{
		set<int32_t>::const_iterator s_iter;
		bool first = true;

		printf("testSet({");
		for (s_iter = thing.begin(); s_iter != thing.end(); ++s_iter) {
			if (first) {
				first = false;
			} else {
				printf(", ");
			}

			printf("%d", *s_iter);
		}

		printf("})\n");
		out = thing;
	}

	void testList(vector<int32_t> &out, const vector<int32_t> &thing) override
	{
		vector<int32_t>::const_iterator l_iter;
		bool first = true;

		printf("testList({");
		for (l_iter = thing.begin(); l_iter != thing.end(); ++l_iter) {
			if (first) {
				first = false;
			} else {
				printf(", ");
			}
			printf("%d", *l_iter);
		}

		printf("})\n");
		out = thing;
	}

	Numberz::type testEnum(const Numberz::type thing) override
	{
		printf("testEnum(%d)\n", thing);
		return thing;
	}

	UserId testTypedef(const UserId thing) override
	{
		printf("testTypedef(%" PRId64 ")\n", thing);
		return thing;
	}

	void testMapMap(map<int32_t, map<int32_t, int32_t>> &mapmap, const int32_t hello) override
	{
		map<int32_t, int32_t> pos;
		map<int32_t, int32_t> neg;

		printf("testMapMap(%d)\n", hello);
		for (int i = 1; i < 5; i++) {
			pos.insert(make_pair(i, i));
			neg.insert(make_pair(-i, -i));
		}

		mapmap.insert(make_pair(4, pos));
		mapmap.insert(make_pair(-4, neg));
	}

	void testInsanity(map<UserId, map<Numberz::type, Insanity>> &insane,
			  const Insanity &argument) override
	{
		Insanity looney;
		map<Numberz::type, Insanity> first_map;
		map<Numberz::type, Insanity> second_map;

		first_map.insert(make_pair(Numberz::TWO, argument));
		first_map.insert(make_pair(Numberz::THREE, argument));

		second_map.insert(make_pair(Numberz::SIX, looney));

		insane.insert(make_pair(1, first_map));
		insane.insert(make_pair(2, second_map));

		printf("testInsanity()\n");
		printf("return");
		printf(" = {");
		map<UserId, map<Numberz::type, Insanity>>::const_iterator i_iter;

		for (i_iter = insane.begin(); i_iter != insane.end(); ++i_iter) {
			printf("%" PRId64 " => {", i_iter->first);
			map<Numberz::type, Insanity>::const_iterator i2_iter;

			for (i2_iter = i_iter->second.begin(); i2_iter != i_iter->second.end();
			     ++i2_iter) {
				printf("%d => {", i2_iter->first);
				map<Numberz::type, UserId> userMap = i2_iter->second.userMap;
				map<Numberz::type, UserId>::const_iterator um;

				printf("{");
				for (um = userMap.begin(); um != userMap.end(); ++um) {
					printf("%d => %" PRId64 ", ", um->first, um->second);
				}

				printf("}, ");
				vector<Xtruct> xtructs = i2_iter->second.xtructs;
				vector<Xtruct>::const_iterator x;

				printf("{");
				for (x = xtructs.begin(); x != xtructs.end(); ++x) {
					printf("{\"%s\", %d, %d, %" PRId64 "}, ",
					       x->string_thing.c_str(), (int)x->byte_thing,
					       x->i32_thing, x->i64_thing);
				}

				printf("}");
				printf("}, ");
			}

			printf("}, ");
		}

		printf("}\n");
	}

	void testMulti(Xtruct &hello, const int8_t arg0, const int32_t arg1, const int64_t arg2,
		       const std::map<int16_t, std::string> &arg3, const Numberz::type arg4,
		       const UserId arg5) override
	{
		(void)arg3;
		(void)arg4;
		(void)arg5;
		printf("testMulti()\n");
		hello.string_thing = "Hello2";
		hello.byte_thing = arg0;
		hello.i32_thing = arg1;
		hello.i64_thing = (int64_t)arg2;
	}

	void testException(const std::string &arg) override
	{
		printf("testException(%s)\n", arg.c_str());
		if (arg.compare("Xception") == 0) {
			Xception e;
			e.errorCode = 1001;
			e.message = arg;
			throw e;
		} else if (arg.compare("TException") == 0) {
			apache::thrift::TException e;
			throw e;
		} else {
			Xtruct result;
			result.string_thing = arg;
			return;
		}
	}

	void testMultiException(Xtruct &result, const std::string &arg0,
				const std::string &arg1) override
	{

		printf("testMultiException(%s, %s)\n", arg0.c_str(), arg1.c_str());
		if (arg0.compare("Xception") == 0) {
			Xception e;
			e.errorCode = 1001;
			e.message = "This is an Xception";
			throw e;
		} else if (arg0.compare("Xception2") == 0) {
			Xception2 e;
			e.errorCode = 2002;
			e.struct_thing.string_thing = "This is an Xception2";
			throw e;
		} else {
			result.string_thing = arg1;
			return;
		}
	}

	void testOneway(const int32_t aNum) override
	{
		printf("testOneway(%d): call received\n", aNum);
	}
};

class SecondHandler : public SecondServiceIf
{
public:
	void secondtestString(std::string &result, const std::string &thing) override
	{
		result = "testString(\"" + thing + "\")";
	}
};