#include <gmock/gmock.h>
#include <gtest/gtest.h>

#include "../include/JsonCommander.h"
#include "FileManagerMock.h"

namespace {
/* Version tests */
TEST(testVersion, Positive) {
	FileManagerMock fileManager;

	JsonCommander jsonCommander(fileManager);

	const std::string versionString = "0.2";
	Json::Value version;
	version["version"] = versionString;

	JsonCommander::Response response = jsonCommander.testVersion(version);
	EXPECT_TRUE(response.action == JsonCommander::Action::send);
	EXPECT_TRUE(response.json["accept"].asBool());
	EXPECT_EQ(response.json["version"].asString(), versionString);
}

TEST(testVersion, Negative) {
	FileManagerMock fileManager;

	JsonCommander jsonCommander(fileManager);

	const std::string versionString = "0.1";
	Json::Value version;
	version["version"] = versionString;

	JsonCommander::Response response = jsonCommander.testVersion(version);
	EXPECT_TRUE(response.action == JsonCommander::Action::closeAndSend);
	EXPECT_FALSE(response.json["accept"].asBool());
	EXPECT_FALSE(response.json["version"].asString().compare(versionString) == 0);
}

/* Status tests */
TEST(Status, Ok) {
	FileManagerMock fileManager;

	JsonCommander jsonCommander(fileManager);

	const std::string command = "status";
	Json::Value message;
	message["command"] = command;

	JsonCommander::Response response = jsonCommander.execute(message);

	EXPECT_TRUE(response.action == JsonCommander::Action::send);
	EXPECT_EQ(response.json["command"].asString(), command);
	EXPECT_EQ(response.json["response"].asString(), "ok");
}

TEST(Status, Downloading) {
	FileManagerMock fileManager;

	JsonCommander jsonCommander(fileManager);

	const std::string command = "status";
	Json::Value message;
	message["command"] = command;

	ON_CALL(fileManager, isDownloading()).WillByDefault(testing::Return(true));

	JsonCommander::Response response = jsonCommander.execute(message);

	EXPECT_TRUE(response.action == JsonCommander::Action::send);
	EXPECT_EQ(response.json["command"].asString(), command);
	EXPECT_EQ(response.json["response"].asString(), "download running");
}

TEST(Status, Uploading) {
	FileManagerMock fileManager;

	JsonCommander jsonCommander(fileManager);

	const std::string command = "status";
	Json::Value message;
	message["command"] = command;

	ON_CALL(fileManager, isUploading()).WillByDefault(testing::Return(true));

	JsonCommander::Response response = jsonCommander.execute(message);

	EXPECT_TRUE(response.action == JsonCommander::Action::send);
	EXPECT_EQ(response.json["command"].asString(), command);
	EXPECT_EQ(response.json["response"].asString(), "upload running");
}

TEST(Status, UploadingAndDownloading) {
	FileManagerMock fileManager;

	JsonCommander jsonCommander(fileManager);

	const std::string command = "status";
	Json::Value message;
	message["command"] = command;

	ON_CALL(fileManager, isDownloading()).WillByDefault(testing::Return(true));
	ON_CALL(fileManager, isUploading()).WillByDefault(testing::Return(true));

	JsonCommander::Response response = jsonCommander.execute(message);

	EXPECT_TRUE(response.action == JsonCommander::Action::send);
	EXPECT_EQ(response.json["command"].asString(), command);
	EXPECT_EQ(response.json["response"].asString(), "download and upload running");
}

/* Close tests */
TEST(Close, Close) {
	FileManagerMock fileManager;

	JsonCommander jsonCommander(fileManager);

	const std::string command = "close";
	Json::Value message;
	message["command"] = command;

	JsonCommander::Response response = jsonCommander.execute(message);

	EXPECT_TRUE(response.action == JsonCommander::Action::closeAndSend);
	EXPECT_EQ(response.json["command"].asString(), command);
	EXPECT_EQ(response.json["response"].asString(), "bye");
}

/* Put tests */
TEST(Put, Positive) {
	FileManagerMock fileManager;

	JsonCommander jsonCommander(fileManager);

	const std::string command = "put";
	const std::string filename = "cool.txt";
	Json::Value message;
	message["command"] = command;
	message["file"] = filename;
	message["size"] = 1337;
	message["chunks"] = 1;

	ON_CALL(fileManager, openPutFile(testing::_)).WillByDefault(testing::Return(true));

	JsonCommander::Response response = jsonCommander.execute(message);

	EXPECT_TRUE(response.action == JsonCommander::Action::send);
	EXPECT_EQ(response.json["command"].asString(), command);
	EXPECT_TRUE(response.json["accept"].asBool());
	EXPECT_EQ(response.json["file"].asString(), filename);
	EXPECT_EQ(response.json["error"].asString(), "");
}

TEST(Put, Negative) {
	FileManagerMock fileManager;

	JsonCommander jsonCommander(fileManager);

	const std::string command = "put";
	const std::string filename = "cool.txt";
	Json::Value message;
	message["command"] = command;
	message["file"] = filename;
	message["size"] = 1337;
	message["chunks"] = 1;

	ON_CALL(fileManager, openPutFile(testing::_)).WillByDefault(testing::Return(false));

	JsonCommander::Response response = jsonCommander.execute(message);

	EXPECT_TRUE(response.action == JsonCommander::Action::send);
	EXPECT_EQ(response.json["command"].asString(), command);
	EXPECT_FALSE(response.json["accept"].asBool());
	EXPECT_EQ(response.json["file"].asString(), filename);
	EXPECT_TRUE(response.json["error"].asString().length() > 0);
}

/* Putdata tests */
TEST(Putdata, Positive) {
	FileManagerMock fileManager;

	JsonCommander jsonCommander(fileManager);

	/* start with put */
	std::string command = "put";
	const std::string filename = "cool.txt";
	Json::Value message;
	message["command"] = command;
	message["file"] = filename;
	message["size"] = 1337;
	const int chunks = 3;
	message["chunks"] = chunks;

	ON_CALL(fileManager, openPutFile(testing::_)).WillByDefault(testing::Return(true));

	JsonCommander::Response response = jsonCommander.execute(message);

	EXPECT_TRUE(response.action == JsonCommander::Action::send);
	EXPECT_EQ(response.json["command"].asString(), command);
	EXPECT_TRUE(response.json["accept"].asBool());
	EXPECT_EQ(response.json["file"].asString(), filename);
	EXPECT_EQ(response.json["error"].asString(), "");

	/* putdata */
	command = "putdata";

	ON_CALL(fileManager, isUploading()).WillByDefault(testing::Return(true));
	ON_CALL(fileManager, getPutBaseFileName()).WillByDefault(testing::Return(filename));

	for (int remaining = chunks - 1; remaining >= 0; remaining--) {
		message = Json::Value();
		message["command"] = command;
		message["file"] = filename;
		message["data"] = "MTMzNw==";
		message["remaining"] = remaining;
		message["cancel"] = false;

		response = jsonCommander.execute(message);

		EXPECT_TRUE(response.action == JsonCommander::Action::send);
		EXPECT_EQ(response.json["command"].asString(), command);
		EXPECT_FALSE(response.json["cancel"].asBool());
		EXPECT_EQ(response.json["received"].asInt(), remaining);
		EXPECT_EQ(response.json["file"].asString(), filename);
		EXPECT_EQ(response.json["error"].asString(), "");
	}
}

TEST(Putdata, Cancel) {
	FileManagerMock fileManager;

	JsonCommander jsonCommander(fileManager);

	/* start with put */
	std::string command = "put";
	const std::string filename = "cool.txt";
	Json::Value message;
	message["command"] = command;
	message["file"] = filename;
	message["size"] = 1337;
	const int chunks = 3;
	message["chunks"] = chunks;

	ON_CALL(fileManager, openPutFile(testing::_)).WillByDefault(testing::Return(true));

	JsonCommander::Response response = jsonCommander.execute(message);

	EXPECT_TRUE(response.action == JsonCommander::Action::send);
	EXPECT_EQ(response.json["command"].asString(), command);
	EXPECT_TRUE(response.json["accept"].asBool());
	EXPECT_EQ(response.json["file"].asString(), filename);
	EXPECT_EQ(response.json["error"].asString(), "");

	/* putdata */
	command = "putdata";

	ON_CALL(fileManager, isUploading()).WillByDefault(testing::Return(true));
	ON_CALL(fileManager, getPutBaseFileName()).WillByDefault(testing::Return(filename));

	int remaining = chunks - 1;
	message = Json::Value();
	message["command"] = command;
	message["file"] = filename;
	message["data"] = "MTMzNw==";
	message["remaining"] = remaining;
	message["cancel"] = false;

	response = jsonCommander.execute(message);

	EXPECT_TRUE(response.action == JsonCommander::Action::send);
	EXPECT_EQ(response.json["command"].asString(), command);
	EXPECT_FALSE(response.json["cancel"].asBool());
	EXPECT_EQ(response.json["received"].asInt(), remaining);
	EXPECT_EQ(response.json["file"].asString(), filename);
	EXPECT_EQ(response.json["error"].asString(), "");

	// cancel transfer
	message = Json::Value();
	message["command"] = command;
	message["file"] = filename;
	message["data"] = "MTMzNw==";
	message["remaining"] = --remaining;
	message["cancel"] = true;

	response = jsonCommander.execute(message);

	EXPECT_TRUE(response.action == JsonCommander::Action::send);
	EXPECT_EQ(response.json["command"].asString(), command);
	EXPECT_TRUE(response.json["cancel"].asBool());
	EXPECT_EQ(response.json["received"].asInt(), remaining);
	EXPECT_EQ(response.json["file"].asString(), filename);
	EXPECT_EQ(response.json["error"].asString(), "");
}

TEST(Putdata, WrongRemaining) {
	FileManagerMock fileManager;

	JsonCommander jsonCommander(fileManager);

	/* start with put */
	std::string command = "put";
	const std::string filename = "cool.txt";
	Json::Value message;
	message["command"] = command;
	message["file"] = filename;
	message["size"] = 1337;
	const int chunks = 3;
	message["chunks"] = chunks;

	ON_CALL(fileManager, openPutFile(testing::_)).WillByDefault(testing::Return(true));

	JsonCommander::Response response = jsonCommander.execute(message);

	EXPECT_TRUE(response.action == JsonCommander::Action::send);
	EXPECT_EQ(response.json["command"].asString(), command);
	EXPECT_TRUE(response.json["accept"].asBool());
	EXPECT_EQ(response.json["file"].asString(), filename);
	EXPECT_EQ(response.json["error"].asString(), "");

	/* putdata */
	command = "putdata";

	ON_CALL(fileManager, isUploading()).WillByDefault(testing::Return(true));
	ON_CALL(fileManager, getPutBaseFileName()).WillByDefault(testing::Return(filename));

	int remaining = chunks - 1;
	message = Json::Value();
	message["command"] = command;
	message["file"] = filename;
	message["data"] = "MTMzNw==";
	message["remaining"] = remaining;
	message["cancel"] = false;

	response = jsonCommander.execute(message);

	EXPECT_TRUE(response.action == JsonCommander::Action::send);
	EXPECT_EQ(response.json["command"].asString(), command);
	EXPECT_FALSE(response.json["cancel"].asBool());
	EXPECT_EQ(response.json["received"].asInt(), remaining);
	EXPECT_EQ(response.json["file"].asString(), filename);
	EXPECT_EQ(response.json["error"].asString(), "");
	message = Json::Value();

	// skip remaining=1 and provoke an error
	remaining = 0;
	message = Json::Value();
	message["command"] = command;
	message["file"] = filename;
	message["data"] = "MTMzNw==";
	message["remaining"] = remaining;
	message["cancel"] = false;

	response = jsonCommander.execute(message);

	EXPECT_TRUE(response.action == JsonCommander::Action::send);
	EXPECT_EQ(response.json["command"].asString(), command);
	EXPECT_TRUE(response.json["cancel"].asBool());
	EXPECT_EQ(response.json["received"].asInt(), remaining);
	EXPECT_EQ(response.json["file"].asString(), filename);
	EXPECT_TRUE(response.json["error"].asString().length() > 0);
}

/* Get tests */
TEST(Get, Positive) {
	FileManagerMock fileManager;

	JsonCommander jsonCommander(fileManager);

	const std::string command = "get";
	const std::string filename = "cool.txt";
	Json::Value message;
	message["command"] = command;
	message["file"] = filename;

	const int chunks = 3;
	EXPECT_CALL(fileManager, openGetFile(testing::_)).WillOnce(testing::Return(std::pair<bool, int>(true, chunks)));

	JsonCommander::Response response = jsonCommander.execute(message);

	EXPECT_TRUE(response.action == JsonCommander::Action::send);
	EXPECT_EQ(response.json["command"].asString(), command);
	EXPECT_TRUE(response.json["accept"].asBool());
	EXPECT_EQ(response.json["file"].asString(), filename);
	EXPECT_EQ(response.json["chunks"].asInt(), chunks);
	EXPECT_EQ(response.json["error"].asString(), "");
}

TEST(Get, Negative) {
	FileManagerMock fileManager;

	JsonCommander jsonCommander(fileManager);

	const std::string command = "get";
	const std::string filename = "cool.txt";
	Json::Value message;
	message["command"] = command;
	message["file"] = filename;

	EXPECT_CALL(fileManager, openGetFile(testing::_)).WillOnce(testing::Return(std::pair<bool, int>(false, -1)));

	JsonCommander::Response response = jsonCommander.execute(message);

	EXPECT_TRUE(response.action == JsonCommander::Action::send);
	EXPECT_EQ(response.json["command"].asString(), command);
	EXPECT_FALSE(response.json["accept"].asBool());
	EXPECT_EQ(response.json["file"].asString(), filename);
	EXPECT_EQ(response.json["chunks"].asInt(), -1);
	EXPECT_TRUE(response.json["error"].asString().length() > 0);
}

/* Getdata tests */
TEST(Getdata, Positive) {
	FileManagerMock fileManager;

	JsonCommander jsonCommander(fileManager);

	std::string command = "get";
	const std::string filename = "cool.txt";
	Json::Value message;
	message["command"] = command;
	message["file"] = filename;

	const int chunks = 3;
	EXPECT_CALL(fileManager, openGetFile(testing::_)).WillOnce(testing::Return(std::pair<bool, int>(true, chunks)));

	JsonCommander::Response response = jsonCommander.execute(message);

	EXPECT_TRUE(response.action == JsonCommander::Action::send);
	EXPECT_EQ(response.json["command"].asString(), command);
	EXPECT_TRUE(response.json["accept"].asBool());
	EXPECT_EQ(response.json["file"].asString(), filename);
	EXPECT_EQ(response.json["chunks"].asInt(), chunks);
	EXPECT_EQ(response.json["error"].asString(), "");

	/* getdata */
	command = "getdata";

	ON_CALL(fileManager, isDownloading()).WillByDefault(testing::Return(true));
	ON_CALL(fileManager, getGetBaseFileName()).WillByDefault(testing::Return(filename));

	std::vector<char> data;
	data.push_back('1');
	data.push_back('3');
	data.push_back('3');
	data.push_back('7');

	ON_CALL(fileManager, readGet()).WillByDefault(testing::Return(data));

	for (int remaining = chunks - 1; remaining >= 0; remaining--) {
		message = Json::Value();
		message["command"] = command;
		message["file"] = filename;
		message["chunk"] = remaining;
		message["cancel"] = false;

		response = jsonCommander.execute(message);

		EXPECT_TRUE(response.action == JsonCommander::Action::send);
		EXPECT_EQ(response.json["command"].asString(), command);
		EXPECT_FALSE(response.json["cancel"].asBool());
		EXPECT_EQ(response.json["remaining"].asInt(), remaining);
		EXPECT_EQ(response.json["file"].asString(), filename);
		EXPECT_EQ(response.json["data"].asString(), "MTMzNw==");
		EXPECT_EQ(response.json["error"].asString(), "");
	}
}

TEST(Getdata, Cancle) {
	FileManagerMock fileManager;

	JsonCommander jsonCommander(fileManager);

	std::string command = "get";
	const std::string filename = "cool.txt";
	Json::Value message;
	message["command"] = command;
	message["file"] = filename;

	const int chunks = 3;
	EXPECT_CALL(fileManager, openGetFile(testing::_)).WillOnce(testing::Return(std::pair<bool, int>(true, chunks)));

	JsonCommander::Response response = jsonCommander.execute(message);

	EXPECT_TRUE(response.action == JsonCommander::Action::send);
	EXPECT_EQ(response.json["command"].asString(), command);
	EXPECT_TRUE(response.json["accept"].asBool());
	EXPECT_EQ(response.json["file"].asString(), filename);
	EXPECT_EQ(response.json["chunks"].asInt(), chunks);
	EXPECT_EQ(response.json["error"].asString(), "");

	/* getdata */
	command = "getdata";

	ON_CALL(fileManager, isDownloading()).WillByDefault(testing::Return(true));
	ON_CALL(fileManager, getGetBaseFileName()).WillByDefault(testing::Return(filename));

	std::vector<char> data;
	data.push_back('1');
	data.push_back('3');
	data.push_back('3');
	data.push_back('7');

	ON_CALL(fileManager, readGet()).WillByDefault(testing::Return(data));

	int remaining = chunks - 1;
	message = Json::Value();
	message["command"] = command;
	message["file"] = filename;
	message["chunk"] = remaining;
	message["cancel"] = false;

	response = jsonCommander.execute(message);

	EXPECT_TRUE(response.action == JsonCommander::Action::send);
	EXPECT_EQ(response.json["command"].asString(), command);
	EXPECT_FALSE(response.json["cancel"].asBool());
	EXPECT_EQ(response.json["remaining"].asInt(), remaining);
	EXPECT_EQ(response.json["file"].asString(), filename);
	EXPECT_EQ(response.json["data"].asString(), "MTMzNw==");
	EXPECT_EQ(response.json["error"].asString(), "");

	// set cancel to true
	message = Json::Value();
	message["command"] = command;
	message["file"] = filename;
	message["chunk"] = --remaining;
	message["cancel"] = true;

	response = jsonCommander.execute(message);

	EXPECT_TRUE(response.action == JsonCommander::Action::send);
	EXPECT_EQ(response.json["command"].asString(), command);
	EXPECT_TRUE(response.json["cancel"].asBool());
	EXPECT_EQ(response.json["remaining"].asInt(), remaining);
	EXPECT_EQ(response.json["file"].asString(), filename);
	EXPECT_EQ(response.json["data"].asString(), "");
	EXPECT_EQ(response.json["error"].asString(), "");
}

TEST(Getdata, WrongChunk) {
	FileManagerMock fileManager;

	JsonCommander jsonCommander(fileManager);

	std::string command = "get";
	const std::string filename = "cool.txt";
	Json::Value message;
	message["command"] = command;
	message["file"] = filename;

	const int chunks = 3;
	EXPECT_CALL(fileManager, openGetFile(testing::_)).WillOnce(testing::Return(std::pair<bool, int>(true, chunks)));

	JsonCommander::Response response = jsonCommander.execute(message);

	EXPECT_TRUE(response.action == JsonCommander::Action::send);
	EXPECT_EQ(response.json["command"].asString(), command);
	EXPECT_TRUE(response.json["accept"].asBool());
	EXPECT_EQ(response.json["file"].asString(), filename);
	EXPECT_EQ(response.json["chunks"].asInt(), chunks);
	EXPECT_EQ(response.json["error"].asString(), "");

	/* getdata */
	command = "getdata";

	ON_CALL(fileManager, isDownloading()).WillByDefault(testing::Return(true));
	ON_CALL(fileManager, getGetBaseFileName()).WillByDefault(testing::Return(filename));

	std::vector<char> data;
	data.push_back('1');
	data.push_back('3');
	data.push_back('3');
	data.push_back('7');

	ON_CALL(fileManager, readGet()).WillByDefault(testing::Return(data));

	int remaining = chunks - 1;
	message = Json::Value();
	message["command"] = command;
	message["file"] = filename;
	message["chunk"] = remaining;
	message["cancel"] = false;

	response = jsonCommander.execute(message);

	EXPECT_TRUE(response.action == JsonCommander::Action::send);
	EXPECT_EQ(response.json["command"].asString(), command);
	EXPECT_FALSE(response.json["cancel"].asBool());
	EXPECT_EQ(response.json["remaining"].asInt(), remaining);
	EXPECT_EQ(response.json["file"].asString(), filename);
	EXPECT_EQ(response.json["data"].asString(), "MTMzNw==");
	EXPECT_EQ(response.json["error"].asString(), "");

	// skip chunk=0
	remaining = 0;
	message = Json::Value();
	message["command"] = command;
	message["file"] = filename;
	message["chunk"] = remaining;
	message["cancel"] = false;

	response = jsonCommander.execute(message);

	EXPECT_TRUE(response.action == JsonCommander::Action::send);
	EXPECT_EQ(response.json["command"].asString(), command);
	EXPECT_TRUE(response.json["cancel"].asBool());
	EXPECT_EQ(response.json["remaining"].asInt(), remaining);
	EXPECT_EQ(response.json["file"].asString(), filename);
	EXPECT_EQ(response.json["data"].asString(), "");
	EXPECT_TRUE(response.json["error"].asString().length() > 0);
}

/* List tests */
TEST(List, Positive) {
	FileManagerMock fileManager;

	JsonCommander jsonCommander(fileManager);

	const std::string command = "list";
	Json::Value message;
	message["command"] = command;

	EXPECT_CALL(fileManager, openList()).WillOnce(testing::Return(1));
	EXPECT_CALL(fileManager, getListSize()).WillOnce(testing::Return(5));

	JsonCommander::Response response = jsonCommander.execute(message);

	EXPECT_TRUE(response.action == JsonCommander::Action::send);
	EXPECT_EQ(response.json["command"].asString(), command);
	EXPECT_TRUE(response.json["accept"].asBool());
	EXPECT_EQ(response.json["chunks"].asInt(), 1);
	EXPECT_EQ(response.json["items"].asInt(), 5);
	EXPECT_EQ(response.json["error"].asString(), "");
}

TEST(List, Negative) {
	FileManagerMock fileManager;

	JsonCommander jsonCommander(fileManager);

	const std::string command = "list";
	Json::Value message;
	message["command"] = command;

	EXPECT_CALL(fileManager, openList()).WillOnce(testing::Return(-1));

	JsonCommander::Response response = jsonCommander.execute(message);

	EXPECT_TRUE(response.action == JsonCommander::Action::send);
	EXPECT_EQ(response.json["command"].asString(), command);
	EXPECT_FALSE(response.json["accept"].asBool());
	EXPECT_EQ(response.json["chunks"].asInt(), -1);
	EXPECT_EQ(response.json["items"].asInt(), -1);
	EXPECT_TRUE(response.json["error"].asString().compare("") != 0);
}

TEST(List, EmptyList) {
	FileManagerMock fileManager;

	JsonCommander jsonCommander(fileManager);

	const std::string command = "list";
	Json::Value message;
	message["command"] = command;

	EXPECT_CALL(fileManager, openList()).WillOnce(testing::Return(0));
	EXPECT_CALL(fileManager, getListSize()).WillOnce(testing::Return(0));

	JsonCommander::Response response = jsonCommander.execute(message);

	EXPECT_TRUE(response.action == JsonCommander::Action::send);
	EXPECT_EQ(response.json["command"].asString(), command);
	EXPECT_TRUE(response.json["accept"].asBool());
	EXPECT_EQ(response.json["chunks"].asInt(), 0);
	EXPECT_EQ(response.json["items"].asInt(), 0);
	EXPECT_EQ(response.json["error"].asString(), "");
}

/* Listdata tests */

void fillExampleFileList(std::vector<std::string> (&chunk)[3]) {
	chunk[0].push_back("file01.txt");
	chunk[0].push_back("bumdibumps");
	chunk[0].push_back("1");
	chunk[0].push_back("Ich habe Hunger.txt");
	chunk[0].push_back("answerIs42");
	chunk[0].push_back("123456789456115811");
	chunk[0].push_back("kek");
	chunk[1].push_back("1337");
	chunk[1].push_back("cats.png");
	chunk[1].push_back("more_cats.png");
	chunk[1].push_back("ugly dog.tiff");
	chunk[1].push_back("hello.txt");
	chunk[1].push_back("bye.exe");
	chunk[1].push_back("poster.pdf");
	chunk[2].push_back("headbang.gif");
	chunk[2].push_back("feelsbad.jpg");
	chunk[2].push_back("hack.s");
	chunk[2].push_back("SodiumChloride");
	chunk[2].push_back("abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrst"
	                   "uvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMN"
	                   "OPQRSTUVWXYZabcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ");
}

TEST(Listdata, Positive) {
	FileManagerMock fileManager;

	JsonCommander jsonCommander(fileManager);

	const std::string command = "listdata";

	const int chunks = 3;
	std::vector<std::string> chunk[chunks];
	fillExampleFileList(chunk);

	int remaining = chunks - 1;

	for (int k = 0; k < chunks; k++) {
		Json::Value message;
		message["command"] = command;
		message["chunk"] = remaining;
		message["cancel"] = false;

		EXPECT_CALL(fileManager, getRemainingListChunks()).WillOnce(testing::Return(remaining + 1));
		EXPECT_CALL(fileManager, getNextChunkFromList()).WillOnce(testing::Return(chunk[k]));

		JsonCommander::Response response = jsonCommander.execute(message);

		EXPECT_TRUE(response.action == JsonCommander::Action::send);
		EXPECT_EQ(response.json["command"].asString(), command);
		EXPECT_FALSE(response.json["cancel"].asBool());
		EXPECT_EQ(response.json["remaining"].asInt(), remaining--);
		EXPECT_TRUE(response.json["names"].isArray());
		Json::Value array = response.json["names"];
		EXPECT_EQ(array.size(), chunk[k].size());
		for (int i = 0; i < 3; i++) {
			EXPECT_EQ(array[i].asString(), chunk[k][i]);
		}
		EXPECT_EQ(response.json["error"].asString(), "");
	}
}

TEST(Listdata, Cancel) {
	FileManagerMock fileManager;

	JsonCommander jsonCommander(fileManager);

	const std::string command = "listdata";

	const int chunks = 3;
	std::vector<std::string> chunk[chunks];
	fillExampleFileList(chunk);

	int remaining = chunks - 1;

	Json::Value message;
	message["command"] = command;
	message["chunk"] = remaining;
	message["cancel"] = false;

	EXPECT_CALL(fileManager, getRemainingListChunks()).WillOnce(testing::Return(remaining + 1));
	EXPECT_CALL(fileManager, getNextChunkFromList()).WillOnce(testing::Return(chunk[0]));

	JsonCommander::Response response = jsonCommander.execute(message);

	EXPECT_TRUE(response.action == JsonCommander::Action::send);
	EXPECT_EQ(response.json["command"].asString(), command);
	EXPECT_FALSE(response.json["cancel"].asBool());
	EXPECT_EQ(response.json["remaining"].asInt(), remaining--);
	EXPECT_TRUE(response.json["names"].isArray());
	Json::Value array = response.json["names"];
	EXPECT_EQ(array.size(), chunk[0].size());
	for (int i = 0; i < 3; i++) {
		EXPECT_EQ(array[i].asString(), chunk[0][i]);
	}
	EXPECT_EQ(response.json["error"].asString(), "");

	message = Json::Value();
	message["command"] = command;
	message["chunk"] = remaining;
	message["cancel"] = true;

	EXPECT_CALL(fileManager, getRemainingListChunks()).WillOnce(testing::Return(remaining + 1));

	response = jsonCommander.execute(message);
	EXPECT_TRUE(response.action == JsonCommander::Action::send);
	EXPECT_EQ(response.json["command"].asString(), command);
	EXPECT_TRUE(response.json["cancel"].asBool());
	EXPECT_EQ(response.json["remaining"].asInt(), remaining--);
	EXPECT_TRUE(response.json["names"].isArray());
	EXPECT_EQ(response.json["error"].asString(), "");
}

TEST(Listdata, WrongChunkNumber) {
	FileManagerMock fileManager;

	JsonCommander jsonCommander(fileManager);

	const std::string command = "listdata";

	const int chunks = 3;
	int remaining = chunks - 1;

	Json::Value message;
	message["command"] = command;
	message["chunk"] = remaining;
	message["cancel"] = false;

	// return smaller remaining
	EXPECT_CALL(fileManager, getRemainingListChunks()).WillOnce(testing::Return(remaining));

	JsonCommander::Response response = jsonCommander.execute(message);

	EXPECT_TRUE(response.action == JsonCommander::Action::closeAndSend);
	EXPECT_EQ(response.json["command"].asString(), command);
	EXPECT_TRUE(response.json["cancel"].asBool());
	EXPECT_EQ(response.json["remaining"].asInt(), -1);
	EXPECT_TRUE(response.json["names"].isArray());
	EXPECT_TRUE(response.json["error"].asString().compare("") != 0);
}

TEST(Listdata, NoChunksToBeSend) {
	FileManagerMock fileManager;

	JsonCommander jsonCommander(fileManager);

	const std::string command = "listdata";

	const int chunks = 0;

	Json::Value message;
	message["command"] = command;
	message["chunk"] = 1;
	message["cancel"] = false;

	// return smaller remaining
	EXPECT_CALL(fileManager, getRemainingListChunks()).WillOnce(testing::Return(chunks));

	JsonCommander::Response response = jsonCommander.execute(message);

	EXPECT_TRUE(response.action == JsonCommander::Action::send);
	EXPECT_EQ(response.json["command"].asString(), command);
	EXPECT_TRUE(response.json["cancel"].asBool());
	EXPECT_EQ(response.json["remaining"].asInt(), -1);
	EXPECT_TRUE(response.json["names"].isArray());
	EXPECT_TRUE(response.json["error"].asString().compare("") != 0);
}

TEST(Listdata, InvalidRequest) {
	FileManagerMock fileManager;

	JsonCommander jsonCommander(fileManager);

	const std::string command = "listdata";

	const int chunks = 3;

	Json::Value message;
	message["command"] = command;
	message["chunk"] = 1;

	// return smaller remaining
	EXPECT_CALL(fileManager, getRemainingListChunks()).WillOnce(testing::Return(chunks));

	JsonCommander::Response response = jsonCommander.execute(message);

	EXPECT_TRUE(response.action == JsonCommander::Action::closeAndSend);
	EXPECT_EQ(response.json["command"].asString(), command);
	EXPECT_TRUE(response.json["cancel"].asBool());
	EXPECT_EQ(response.json["remaining"].asInt(), -1);
	EXPECT_TRUE(response.json["names"].isArray());
	EXPECT_TRUE(response.json["error"].asString().compare("") != 0);
}

} // namespace