#include "cmixclient.hpp"

#include "senderreceiver.hpp"
#include "cmix.pb.h"

#include <boost/log/trivial.hpp>
#include <boost/asio/ip/tcp.hpp>
#include <boost/asio/ssl.hpp>
#include <boost/log/trivial.hpp>

#include <cstdint>
#include <algorithm>

using namespace boost::asio::ip;
using namespace boost::asio;

void CMixClient::key_exchange(size_t node_id) {
	BOOST_LOG_TRIVIAL(trace) << "Sending KeyExchange for node: " << node_id;
	
	cmix_proto::KeyExchange ke;
	ke.mutable_public_key()->resize(get_group_element_array_size(&cmix_ctx));
	ke.mutable_value()->resize(get_group_element_array_size(&cmix_ctx));
	
	key_exchange_init(&cmix_ctx, &(*ke.mutable_public_key())[0], &(*ke.mutable_value())[0], &data.at(node_id).secret_value);
	
	network_connections.at(node_id).async_send(ke);
	network_connections.at(node_id).async_receive([node_id, this](cmix_proto::CMixMessage message) {
		handle_message(node_id, message);
	});
}

void CMixClient::initialize_connections() {
	size_t nr_nodes = network_details.node_details.size();
	network_connections.reserve(nr_nodes);
	data.resize(nr_nodes);
	
	for(size_t i = 0; i < nr_nodes; ++i) {
		auto handler = [this, i]() {
			cmix_proto::ImAClient imaclient;
			imaclient.set_id("A");
			BOOST_LOG_TRIVIAL(trace) << "sending imaclient to node: " << i;
			network_connections.at(i).async_send(imaclient);
			network_connections.at(i).async_receive([i, this](cmix_proto::CMixMessage message) {
				handle_message(i, message);
			});
		};
	
		network_connections.emplace_back(std::unique_ptr<ssl::stream<tcp::socket>>(new ssl::stream<tcp::socket>(io_service, *ssl_ctx)));
		network_connections.back().async_connect(network_details.node_details[i].host, network_details.node_details[i].port, handler);
	}
}

void CMixClient::handle_key_exchange(size_t node_id, cmix_proto::KeyExchange const& ke)
{
	key_exchange_initiator(
		&cmix_ctx,
		&data.at(node_id).shared_value,
		ke.public_key().data(),
		ke.value().data(),
		data.at(node_id).secret_value
	);
	
	size_t len = get_group_element_array_size(&cmix_ctx);
	std::string s = "abcdefghijklmnopqrstuvwxyz";
	s.resize(len, '0');
	
	
	
	cmix_proto::Bye bye;
	network_connections.at(node_id).async_send(bye);
}

void CMixClient::handle_message(size_t node_id, cmix_proto::CMixMessage message)
{
	switch(message.contents_case()) {
		case cmix_proto::CMixMessage::ContentsCase::kKeyexchange: {
			BOOST_LOG_TRIVIAL(trace) << "handling keyexchange for node: " << node_id;
			handle_key_exchange(node_id, *message.mutable_keyexchange());
			return;
		}
		case cmix_proto::CMixMessage::ContentsCase::kBye: {
			BOOST_LOG_TRIVIAL(trace) << "handling bye for node: " << node_id;
			network_connections.at(node_id).close();
			if(std::all_of(network_connections.begin(), network_connections.end(), [](SSLSenderReceiver const& c) { return !c.is_open(); })) {
				break;
			} else {
				return;
			}
 		}
 		case cmix_proto::CMixMessage::ContentsCase::kNodeready: {
			BOOST_LOG_TRIVIAL(trace) << "handling NodeReady: " << node_id;
			key_exchange(node_id);
			return;
 		}
		default: {
			BOOST_LOG_TRIVIAL(error) << "Received unknown message";
		}
	}
	
	io_service.stop();
}

CMixClient::CMixClient(NetworkDetails details)
: io_service()
, ssl_ctx(std::make_shared<boost::asio::ssl::context>(boost::asio::ssl::context::sslv23))
, cmix_ctx(initialize_cmix_context(get_implementation()))
, network_details(details)
, network_connections()
, data()
{
	initialize_keypair(&cmix_ctx);
	
	if(!details.certdir.empty()) {
		ssl_ctx->add_verify_path(details.certdir);
	}

	initialize_connections();
}

CMixClient::~CMixClient()
{
	deinitialize(&cmix_ctx);
}

void CMixClient::run() {
	io_service.run();
}