#include "JsonCreateTransaction.h"

#include "../controller/User.h"

#include "../lib/DataTypeConverter.h"

#include "../model/gradido/Transaction.h"

#include "../SingletonManager/ErrorManager.h"

Poco::JSON::Object* JsonCreateTransaction::handle(Poco::Dynamic::Var params)
{
	auto sm = SessionManager::getInstance();

	int session_id = 0;
	std::string transaction_type;

	// if is json object
	if (params.type() == typeid(Poco::JSON::Object::Ptr)) {
		Poco::JSON::Object::Ptr paramJsonObject = params.extract<Poco::JSON::Object::Ptr>();
		/// Throws a RangeException if the value does not fit
		/// into the result variable.
		/// Throws a NotImplementedException if conversion is
		/// not available for the given type.
		/// Throws InvalidAccessException if Var is empty.
		try {
			paramJsonObject->get("session_id").convert(session_id);
			paramJsonObject->get("transaction_type").convert(transaction_type);
			paramJsonObject->get("memo").convert(mMemo);
		}
		catch (Poco::Exception& ex) {
			return stateError("json exception", ex.displayText());
		}
	}
	else {
		return stateError("parameter format unknown");
	}

	if (!session_id) {
		return stateError("session_id invalid");
	}

	mSession = sm->getSession(session_id);
	if (!mSession) {
		return stateError("session not found");
	}
	auto user = mSession->getNewUser();
	if (user.isNull()) {
		auto em = ErrorManager::getInstance();
		em->addError(new Error("JsonCreateTransaction", "session hasn't a user, check code"));
		em->sendErrorsAsEmail();
		return customStateError("code error", "user is zero");
	}

	getTargetGroup(params);
	if (transaction_type == "transfer") {
		return transfer(params);
	}
	else if (transaction_type == "creation") {
		return creation(params);
	}
	else if (transaction_type == "groupMemberUpdate") {
		return groupMemberUpdate(params);
	}

	return stateError("transaction_type unknown");

}

Poco::JSON::Object* JsonCreateTransaction::transfer(Poco::Dynamic::Var params)
{
	auto target_pubkey = getTargetPubkey(params);
	if (!target_pubkey) {
		return customStateError("not found", "receiver not found");
	}

	auto user = mSession->getNewUser();
	Poco::UInt32 amount = 0;
	auto mm = MemoryManager::getInstance();
	Poco::JSON::Object* result = nullptr;

	if (params.type() == typeid(Poco::JSON::Object::Ptr)) {
		Poco::JSON::Object::Ptr paramJsonObject = params.extract<Poco::JSON::Object::Ptr>();
		try {
			paramJsonObject->get("amount").convert(amount);
		}
		catch (Poco::Exception& ex) {
			result = stateError("json exception", ex.displayText());
		}
	}
	else {
		result = stateError("parameter format unknown");
	}
	if (result) {
		mm->releaseMemory(target_pubkey);
		return result;
	}
	
	if (!mReceiverUser.isNull() && mReceiverUser->getModel()) {
		auto receiver_user_model = mReceiverUser->getModel();
		if (receiver_user_model->isDisabled()) {
			result = customStateError("disabled", "receiver is disabled");
		}
		if (!mTargetGroup.isNull() && receiver_user_model->getGroupId() != mTargetGroup->getModel()->getID()) {
			result = stateError("user not in group", "receiver user isn't in target group");
		}
	}
	if (!result) {
		model::gradido::Transaction::createTransfer(mSession->getNewUser(), target_pubkey, mTargetGroup, amount, mMemo);
		result = stateSuccess();
	}
	mm->releaseMemory(target_pubkey);
	return result;
}
Poco::JSON::Object* JsonCreateTransaction::creation(Poco::Dynamic::Var params)
{
	auto target_pubkey = getTargetPubkey(params);
	if (!target_pubkey) {
		return customStateError("not found", "receiver not found");
	} 

	Poco::UInt32 amount = 0;
	Poco::DateTime target_date;
	auto mm = MemoryManager::getInstance();
	Poco::JSON::Object* result = nullptr;

	if (params.type() == typeid(Poco::JSON::Object::Ptr)) 
	{
		Poco::JSON::Object::Ptr paramJsonObject = params.extract<Poco::JSON::Object::Ptr>();
		try {
			paramJsonObject->get("amount").convert(amount);
			paramJsonObject->get("target_date").convert(target_date);
		}
		catch (Poco::Exception& ex) {
			result = stateError("json exception", ex.displayText());
		}
	}
	else 
	{
		result = stateError("parameter format unknown");
	}
	
	if (amount <= 0 || amount > 10000000) {
		result = customStateError("invalid parameter", "invalid amount", "GDD amount in GDD cent ]0,10000000]");
	}

	if (mReceiverUser.isNull()) {
		mReceiverUser = controller::User::create();
		if (1 != mReceiverUser->load(target_pubkey->data())) {
			mReceiverUser.assign(nullptr);
			result = customStateError("not found", "receiver not found");
		}
	}

	if (result) {
		mm->releaseMemory(target_pubkey);
		return result;
	}
	
	if (!mReceiverUser.isNull() && mReceiverUser->getModel()) {
		auto receiver_user_model = mReceiverUser->getModel();
		
		if (receiver_user_model->isDisabled()) {
			result = customStateError("disabled", "receiver is disabled");
		}
		if (!receiver_user_model->getGroupId()) {
			result = stateError("receiver user hasn't group");
		}
		if (receiver_user_model->getGroupId() != mSession->getNewUser()->getModel()->getGroupId()) {
			result = stateError("user not in group", "target user is in another group");
		}
	}
	
	if(!result) {
		model::gradido::Transaction::createCreation(mReceiverUser, amount, target_date, mMemo);
		result = stateSuccess();
	}
	mm->releaseMemory(target_pubkey);
	
	return result;

}
Poco::JSON::Object* JsonCreateTransaction::groupMemberUpdate(Poco::Dynamic::Var params)
{
	if (mTargetGroup.isNull()) {
		return stateError("target_group not found");
	}
	model::gradido::Transaction::createGroupMemberUpdate(mSession->getNewUser(), mTargetGroup);
	return stateSuccess();

}
MemoryBin* JsonCreateTransaction::getTargetPubkey(Poco::Dynamic::Var params)
{
	std::string email;
	std::string target_username;
	std::string target_pubkey_hex;
	
	Poco::JSON::Object::Ptr paramJsonObject = params.extract<Poco::JSON::Object::Ptr>();
	auto fields = paramJsonObject->getNames();
	try {
		for (auto it = fields.begin(); it != fields.end(); it++) {
			if (*it == "target_email") {
				paramJsonObject->get("target_email").convert(email);
				break;
			}
			if (*it == "target_username") {
				paramJsonObject->get("target_username").convert(target_username);
				break;
			}
			if (*it == "target_pubkey") {
				paramJsonObject->get("target_pubkey").convert(target_pubkey_hex);
				break;
			}
		}
	}
	catch (Poco::Exception& ex) {
		return nullptr;
	}
	mReceiverUser = controller::User::create();
	int result_count = 0;
	
	MemoryBin* result = nullptr;
	if (email != "") {
		result_count = mReceiverUser->load(email);
	}
	else if (target_username != "") {
		int group_id = 0;
		if (!mTargetGroup.isNull()) {
			group_id = mTargetGroup->getModel()->getID();
		} else {
			mSession->getNewUser()->getModel()->getGroupId();
		}
		result_count = mReceiverUser->getModel()->loadFromDB({ "username", "group_id" }, target_username, group_id, model::table::MYSQL_CONDITION_AND);
	}
	else if (target_pubkey_hex != "") {
		result = DataTypeConverter::hexToBin(target_pubkey_hex);
	}
	if (1 == result_count) {
		result = mReceiverUser->getModel()->getPublicKeyCopy();
	}
	else {
		mReceiverUser.assign(nullptr);
	}
	return result;
}

bool JsonCreateTransaction::getTargetGroup(Poco::Dynamic::Var params)
{
	std::string target_group_alias;
	Poco::JSON::Object::Ptr paramJsonObject = params.extract<Poco::JSON::Object::Ptr>();
	try 
	{
		auto target_group = paramJsonObject->get("target_group");
		if (!target_group.isEmpty()) {
			target_group.convert(target_group_alias);
			auto groups = controller::Group::load(target_group_alias);
			if (groups.size() == 1) {
				mTargetGroup = groups[0];
				return true;
			}
		}
	
	}
	catch (Poco::Exception& ex) {
		return false;
	}
	return false;
}