#include "./ngc_ft1.h"

#include "ngc_ext_common.hpp"

#include <vector>
#include <unordered_map>
#include <map>
#include <optional>
#include <cassert>

struct NGC_FT1 {
	NGC_FT1_options options;

	std::unordered_map<NGC_FT1_file_kind, NGC_FT1_recv_request_cb*> cb_recv_request;
	std::unordered_map<NGC_FT1_file_kind, NGC_FT1_recv_init_cb*> cb_recv_init;
	std::unordered_map<NGC_FT1_file_kind, NGC_FT1_recv_data_cb*> cb_recv_data;
	std::unordered_map<NGC_FT1_file_kind, NGC_FT1_send_data_cb*> cb_send_data;

	struct Group {
		struct Peer {
			struct RecvTransfer {
				std::vector<uint8_t> file_id;

				enum class State {
					INITED, //init acked, but no data received yet (might be dropped)
					RECV, // receiving data
				} state;

				// float time_since_last_activity ?
				size_t file_size {0};
				size_t file_size_current {0};

				// sequence array
				// list of last x received seq_ids
			};
			std::array<std::optional<RecvTransfer>, 256> recv_transfers;
			size_t next_recv_transfer_idx {0}; // next id will be 0

			struct SendTransfer {
				NGC_FT1_file_kind file_kind;
				std::vector<uint8_t> file_id;

				enum class State {
					INIT_SENT, // keep this state until ack or deny or giveup

					SENDING, // we got the ack and are now sending data

					// is this real?
					FINISHING, // we sent all data but acks still outstanding????

					FINFIN, // we sent the data_fin and are waiting for the data_fin_ack

					// delete
				} state;

				size_t inits_sent {1}; // is sent when creating

				float time_since_activity {0.f};
				size_t file_size {0};
				size_t file_size_current {0};

				// sequence array
				// list of sent but not acked seq_ids
			};
			std::array<std::optional<SendTransfer>, 256> send_transfers;
			size_t next_send_transfer_idx {0}; // next id will be 0
		};
		std::map<uint32_t, Peer> peers;
	};
	std::map<uint32_t, Group> groups;
};

// send pkgs
static bool _send_pkg_FT1_REQUEST(const Tox* tox, uint32_t group_number, uint32_t peer_number, uint8_t file_kind, const uint8_t* file_id, size_t file_id_size);
static bool _send_pkg_FT1_INIT(const Tox* tox, uint32_t group_number, uint32_t peer_number, uint8_t file_kind, uint64_t file_size, uint8_t transfer_id, const uint8_t* file_id, size_t file_id_size);
static bool _send_pkg_FT1_INIT_ACK(const Tox* tox, uint32_t group_number, uint32_t peer_number, uint8_t transfer_id);
static bool _send_pkg_FT1_DATA(const Tox* tox, uint32_t group_number, uint32_t peer_number, uint8_t transfer_id, uint16_t sequence_id, const uint8_t* data, size_t data_size);
static bool _send_pkg_FT1_DATA_ACK(const Tox* tox, uint32_t group_number, uint32_t peer_number, uint8_t transfer_id, const uint16_t* seq_ids, size_t seq_ids_size);
//static bool _send_pkg_FT1_DATA_FIN(const Tox* tox, uint32_t group_number, uint32_t peer_number, uint8_t transfer_id);
//static bool _send_pkg_FT1_DATA_FIN_ACK(const Tox* tox, uint32_t group_number, uint32_t peer_number, uint8_t transfer_id);

// handle pkgs
static void _handle_FT1_REQUEST(Tox* tox, NGC_EXT_CTX* ngc_ext_ctx, uint32_t group_number, uint32_t peer_number, const uint8_t *data, size_t length);
static void _handle_FT1_INIT(Tox* tox, NGC_EXT_CTX* ngc_ext_ctx, uint32_t group_number, uint32_t peer_number, const uint8_t *data, size_t length);
//static void _handle_FT1_INIT_ACK(Tox* tox, NGC_EXT_CTX* ngc_ext_ctx, uint32_t group_number, uint32_t peer_number, const uint8_t *data, size_t length);
//static void _handle_FT1_DATA(Tox* tox, NGC_EXT_CTX* ngc_ext_ctx, uint32_t group_number, uint32_t peer_number, const uint8_t *data, size_t length);
//static void _handle_FT1_DATA_ACK(Tox* tox, NGC_EXT_CTX* ngc_ext_ctx, uint32_t group_number, uint32_t peer_number, const uint8_t *data, size_t length);
//static void _handle_FT1_DATA_FIN(Tox* tox, NGC_EXT_CTX* ngc_ext_ctx, uint32_t group_number, uint32_t peer_number, const uint8_t *data, size_t length);
//static void _handle_FT1_DATA_FIN_ACK(Tox* tox, NGC_EXT_CTX* ngc_ext_ctx, uint32_t group_number, uint32_t peer_number, const uint8_t *data, size_t length);

bool NGC_FT1_init(NGC_EXT_CTX* ngc_ext_ctx, const struct NGC_FT1_options* options) {
	ngc_ext_ctx->ngc_ft1_ctx = new NGC_FT1;
	ngc_ext_ctx->ngc_ft1_ctx->options = *options;

	ngc_ext_ctx->callbacks[FT1_REQUEST] = _handle_FT1_REQUEST;
	ngc_ext_ctx->callbacks[FT1_INIT] = _handle_FT1_INIT;
	ngc_ext_ctx->callbacks[FT1_INIT_ACK] = nullptr;
	ngc_ext_ctx->callbacks[FT1_DATA] = nullptr;
	ngc_ext_ctx->callbacks[FT1_DATA_ACK] = nullptr;

	return true;
}

void NGC_FT1_kill(NGC_EXT_CTX* ngc_ext_ctx) {
	delete ngc_ext_ctx->ngc_ft1_ctx;
	ngc_ext_ctx->ngc_ft1_ctx = nullptr;
}

void NGC_FT1_iterate(Tox *tox, NGC_EXT_CTX* ngc_ext_ctx/*, void *user_data*/) {
	assert(ngc_ext_ctx);
	assert(ngc_ext_ctx->ngc_ft1_ctx);

	for (auto& [group_number, group] : ngc_ext_ctx->ngc_ft1_ctx->groups) {
		for (auto& [peer_number, peer] : group.peers) {
			//for (auto& tf_opt : peer.send_transfers) {
			for (size_t idx = 0; idx < peer.send_transfers.size(); idx++) {
				auto& tf_opt = peer.send_transfers[idx];
				if (tf_opt) {
					auto& tf = tf_opt.value();

					tf.time_since_activity += 0.025f; // TODO: actual delta

					switch (tf.state) {
						using State = NGC_FT1::Group::Peer::SendTransfer::State;
						case State::INIT_SENT:
							if (tf.time_since_activity >= 20.f) {
								if (tf.inits_sent >= 3) {
									// delete, timed out 3 times
									fprintf(stderr, "FT: warning, ft init timed out, deleting\n");
									tf_opt.reset();
									continue;
								} else {
									// timed out, resend
									fprintf(stderr, "FT: warning, ft init timed out, resending\n");
									_send_pkg_FT1_INIT(tox, group_number, peer_number, tf.file_kind, tf.file_size, idx, tf.file_id.data(), tf.file_id.size());
									tf.inits_sent++;
									tf.time_since_activity = 0.f;
								}
							}
							break;
						case State::SENDING:
							break;
						case State::FINISHING:
							break;

						// finfin o.o

						default: // invalid state, delete
							fprintf(stderr, "FT: error, ft in invalid state, deleting\n");
							tf_opt.reset();
							continue;
					}
				}

			//struct SendTransfer {
				//std::vector<uint8_t> file_id;

				//enum class State {
					//INIT_SENT, // keep this state until ack or deny or giveup

					//SENDING, // we got the ack and are now sending data

					//// is this real?
					//FINISHING, // we sent all data but acks still outstanding????

					//FINFIN, // we sent the data_fin and are waiting for the data_fin_ack

					//// delete
				//} state;

				//// float time_since_last_activity ?
				//size_t file_size {0};
				//size_t file_size_current {0};

				//// sequence array
				//// list of sent but not acked seq_ids
			//};
			//std::array<std::optional<SendTransfer>, 256> send_transfers;
			}
		}
	}
}

void NGC_FT1_register_callback_recv_request(NGC_EXT_CTX* ngc_ext_ctx, NGC_FT1_file_kind file_kind, NGC_FT1_recv_request_cb* callback) {
	assert(ngc_ext_ctx);
	assert(ngc_ext_ctx->ngc_ft1_ctx);

	ngc_ext_ctx->ngc_ft1_ctx->cb_recv_request[file_kind] = callback;
}

void NGC_FT1_register_callback_recv_init(NGC_EXT_CTX* ngc_ext_ctx, NGC_FT1_file_kind file_kind, NGC_FT1_recv_init_cb* callback) {
	assert(ngc_ext_ctx);
	assert(ngc_ext_ctx->ngc_ft1_ctx);

	ngc_ext_ctx->ngc_ft1_ctx->cb_recv_init[file_kind] = callback;
}

void NGC_FT1_register_callback_recv_data(NGC_EXT_CTX* ngc_ext_ctx, NGC_FT1_file_kind file_kind, NGC_FT1_recv_data_cb* callback) {
	assert(ngc_ext_ctx);
	assert(ngc_ext_ctx->ngc_ft1_ctx);

	ngc_ext_ctx->ngc_ft1_ctx->cb_recv_data[file_kind] = callback;
}

void NGC_FT1_register_callback_send_data(NGC_EXT_CTX* ngc_ext_ctx, NGC_FT1_file_kind file_kind, NGC_FT1_send_data_cb* callback) {
	assert(ngc_ext_ctx);
	assert(ngc_ext_ctx->ngc_ft1_ctx);

	ngc_ext_ctx->ngc_ft1_ctx->cb_send_data[file_kind] = callback;
}

void NGC_FT1_send_request(
	Tox *tox, NGC_EXT_CTX* ngc_ext_ctx,

	uint32_t group_number,

	NGC_FT1_file_kind file_kind,

	const uint8_t* file_id,
	size_t file_id_size
) {
	// just call private for every peer in group?
	for (;;) {
		uint32_t peer_number = 0;
		NGC_FT1_send_request_private(tox, ngc_ext_ctx, group_number, peer_number, file_kind, file_id, file_id_size);
		assert(false && "not implemented");
	}
}

void NGC_FT1_send_request_private(
	Tox *tox, NGC_EXT_CTX* ngc_ext_ctx,

	uint32_t group_number,
	uint32_t peer_number,

	NGC_FT1_file_kind file_kind,

	const uint8_t* file_id,
	size_t file_id_size
) {
	assert(tox);
	assert(ngc_ext_ctx);
	assert(ngc_ext_ctx->ngc_ft1_ctx);

	// record locally that we sent(or want to send) the request?

	_send_pkg_FT1_REQUEST(tox, group_number, peer_number, file_kind, file_id, file_id_size);
}

bool NGC_FT1_send_init_private(
	Tox *tox, NGC_EXT_CTX* ngc_ext_ctx,
	uint32_t group_number, uint32_t peer_number,
	NGC_FT1_file_kind file_kind,
	const uint8_t* file_id, size_t file_id_size,
	size_t file_size
) {
	//fprintf(stderr, "TODO: init ft for %08X\n", msg_id);
	fprintf(stderr, "FT: init ft\n");

	if (tox_group_peer_get_connection_status(tox, group_number, peer_number, nullptr) == TOX_CONNECTION_NONE) {
		fprintf(stderr, "FT: error: cant init ft, peer offline\n");
		return false;
	}

	auto& peer = ngc_ext_ctx->ngc_ft1_ctx->groups[group_number].peers[peer_number];

	// allocate transfer_id
	size_t idx = peer.next_send_transfer_idx;
	peer.next_send_transfer_idx = (peer.next_send_transfer_idx + 1) % 256;
	{ // TODO: extract
		size_t i = idx;
		bool found = false;
		do {
			if (!peer.send_transfers[i].has_value()) {
				// free slot
				idx = i;
				found = true;
				break;
			}

			i = (i + 1) % 256;
		} while (i != idx);

		if (!found) {
			fprintf(stderr, "FT: error: cant init ft, no free transfer slot\n");
			return false;
		}
	}

	_send_pkg_FT1_INIT(tox, group_number, peer_number, file_kind, file_size, idx, file_id, file_id_size);

	peer.send_transfers[idx] = NGC_FT1::Group::Peer::SendTransfer{
		file_kind,
		std::vector(file_id, file_id+file_id_size),
		NGC_FT1::Group::Peer::SendTransfer::State::INIT_SENT,
		1,
		0.f,
		file_size,
		0,
	};

	return true;
}

static bool _send_pkg_FT1_REQUEST(const Tox* tox, uint32_t group_number, uint32_t peer_number, uint8_t file_kind, const uint8_t* file_id, size_t file_id_size) {
	// - 1 byte packet id
	// - 1 byte (TODO: more?) file_kind
	// - X bytes file_id
	std::vector<uint8_t> pkg;
	pkg.push_back(FT1_REQUEST);
	pkg.push_back(file_kind);
	for (size_t i = 0; i < file_id_size; i++) {
		pkg.push_back(file_id[i]);
	}

	// lossless
	return tox_group_send_custom_private_packet(tox, group_number, peer_number, true, pkg.data(), pkg.size(), nullptr);
}

static bool _send_pkg_FT1_INIT(const Tox* tox, uint32_t group_number, uint32_t peer_number, uint8_t file_kind, uint64_t file_size, uint8_t transfer_id, const uint8_t* file_id, size_t file_id_size) {
	// - 1 byte packet id
	// - 1 byte (file_kind)
	// - 8 bytes (data size)
	// - 1 byte (temporary_file_tf_id, for this peer only, technically just a prefix to distinguish between simultainious fts)
	// - X bytes (file_kind dependent id, differnt sizes)

	std::vector<uint8_t> pkg;
	pkg.push_back(FT1_INIT);
	pkg.push_back(file_kind);
	for (size_t i = 0; i < sizeof(file_size); i++) {
		pkg.push_back((file_size>>(i*8)) & 0xff);
	}
	pkg.push_back(transfer_id);
	for (size_t i = 0; i < file_id_size; i++) {
		pkg.push_back(file_id[i]);
	}

	// lossless
	return tox_group_send_custom_private_packet(tox, group_number, peer_number, true, pkg.data(), pkg.size(), nullptr);
}

static bool _send_pkg_FT1_INIT_ACK(const Tox* tox, uint32_t group_number, uint32_t peer_number, uint8_t transfer_id) {
	// send ack
	// - 1 byte packet id
	// - 1 byte transfer_id
	std::vector<uint8_t> pkg;
	pkg.push_back(FT1_INIT_ACK);
	pkg.push_back(transfer_id);

	// lossless
	return tox_group_send_custom_private_packet(tox, group_number, peer_number, true, pkg.data(), pkg.size(), nullptr);
}

static bool _send_pkg_FT1_DATA(const Tox* tox, uint32_t group_number, uint32_t peer_number, uint8_t transfer_id, uint16_t sequence_id, const uint8_t* data, size_t data_size) {

	// TODO
	// check header_size+data_size <= max pkg size

	std::vector<uint8_t> pkg;
	pkg.push_back(FT1_DATA);
	pkg.push_back(transfer_id);
	pkg.push_back(sequence_id & 0xff);
	pkg.push_back((sequence_id >> (1*8)) & 0xff);

	// TODO: optimize
	for (size_t i = 0; i < data_size; i++) {
		pkg.push_back(data[i]);
	}

	// lossless?
	return tox_group_send_custom_private_packet(tox, group_number, peer_number, true, pkg.data(), pkg.size(), nullptr);
}

static bool _send_pkg_FT1_DATA_ACK(const Tox* tox, uint32_t group_number, uint32_t peer_number, uint8_t transfer_id, const uint16_t* seq_ids, size_t seq_ids_size) {
	std::vector<uint8_t> pkg;
	pkg.push_back(FT1_DATA_ACK);
	pkg.push_back(transfer_id);

	// TODO: optimize
	for (size_t i = 0; i < seq_ids_size; i++) {
		pkg.push_back(seq_ids[i] & 0xff);
		pkg.push_back((seq_ids[i] >> (1*8)) & 0xff);
	}

	// lossless?
	return tox_group_send_custom_private_packet(tox, group_number, peer_number, true, pkg.data(), pkg.size(), nullptr);
}

//static bool _send_pkg_FT1_DATA_FIN(const Tox* tox, uint32_t group_number, uint32_t peer_number, uint8_t transfer_id) {
	//std::vector<uint8_t> pkg;
	//pkg.push_back(FT1_DATA_FIN);
	//pkg.push_back(transfer_id);

	//// lossless?
	//return tox_group_send_custom_private_packet(tox, group_number, peer_number, true, pkg.data(), pkg.size(), nullptr);
//}

//static bool _send_pkg_FT1_DATA_FIN_ACK(const Tox* tox, uint32_t group_number, uint32_t peer_number, uint8_t transfer_id) {
	//std::vector<uint8_t> pkg;
	//pkg.push_back(FT1_DATA_FIN_ACK);
	//pkg.push_back(transfer_id);

	//// lossless?
	//return tox_group_send_custom_private_packet(tox, group_number, peer_number, true, pkg.data(), pkg.size(), nullptr);
//}

#define _DATA_HAVE(x, error) if ((length - curser) < (x)) { error; }

static void _handle_FT1_REQUEST(
	Tox* tox,
	NGC_EXT_CTX* ngc_ext_ctx,

	uint32_t group_number,
	uint32_t peer_number,

	const uint8_t *data,
	size_t length
) {
	size_t curser = 0;

	// TODO: might be uint16_t or even larger
	uint8_t file_kind_u8;
	_DATA_HAVE(sizeof(file_kind_u8), fprintf(stderr, "FT: packet too small, missing file_kind\n"); return)
	file_kind_u8 = data[curser++];
	auto file_kind = static_cast<NGC_FT1_file_kind>(file_kind_u8);

	fprintf(stderr, "FT: got FT request with file_kind %u [", file_kind_u8);
	for (size_t curser_copy = curser; curser_copy < length; curser_copy++) {
		fprintf(stderr, "%02X", data[curser_copy]);
	}
	fprintf(stderr, "]\n");

	NGC_FT1_recv_request_cb* fn_ptr = nullptr;
	if (ngc_ext_ctx->ngc_ft1_ctx->cb_recv_request.count(file_kind)) {
		fn_ptr = ngc_ext_ctx->ngc_ft1_ctx->cb_recv_request.at(file_kind);
	}
	if (fn_ptr) {
		fn_ptr(tox, ngc_ext_ctx, group_number, peer_number, data+curser, length-curser);
	} else {
		fprintf(stderr, "FT: missing cb for requests\n");
	}
}


static void _handle_FT1_INIT(
	Tox* tox,
	NGC_EXT_CTX* ngc_ext_ctx,

	uint32_t group_number,
	uint32_t peer_number,

	const uint8_t *data,
	size_t length
) {
	size_t curser = 0;

	// - 1 byte (file_kind)

	// TODO: might be uint16_t or even larger
	uint8_t file_kind_u8;
	_DATA_HAVE(sizeof(file_kind_u8), fprintf(stderr, "FT: packet too small, missing file_kind\n"); return)
	file_kind_u8 = data[curser++];
	auto file_kind = static_cast<NGC_FT1_file_kind>(file_kind_u8);

	// - 8 bytes (data size)
	size_t file_size {0u};
	_DATA_HAVE(sizeof(file_size), fprintf(stderr, "FT: packet too small, missing file_size\n"); return)
	for (size_t i = 0; i < sizeof(file_size); i++, curser++) {
		file_size |= size_t(data[curser]) << (i*8);
	}

	// - 1 byte (temporary_file_tf_id, for this peer only, technically just a prefix to distinguish between simultainious fts)
	uint8_t transfer_id;
	_DATA_HAVE(sizeof(transfer_id), fprintf(stderr, "FT: packet too small, missing transfer_id\n"); return)
	transfer_id = data[curser++];

	// - X bytes (file_kind dependent id, differnt sizes)

	fprintf(stderr, "FT: got FT init with file_kind:%u file_size:%lu tf_id:%u [", file_kind_u8, file_size, transfer_id);
	for (size_t curser_copy = curser; curser_copy < length; curser_copy++) {
		fprintf(stderr, "%02X", data[curser_copy]);
	}
	fprintf(stderr, "]\n");

	// check if slot free ?
	// did we allready ack this and the other side just did not see the ack?

	NGC_FT1_recv_init_cb* fn_ptr = nullptr;
	if (ngc_ext_ctx->ngc_ft1_ctx->cb_recv_init.count(file_kind)) {
		fn_ptr = ngc_ext_ctx->ngc_ft1_ctx->cb_recv_init.at(file_kind);
	}
	bool accept_ft;
	if (fn_ptr) {
		// last part of message (file_id) is not yet parsed, just give it to cb
		accept_ft = fn_ptr(tox, ngc_ext_ctx, group_number, peer_number, data+curser, length-curser, transfer_id, file_size);
	} else {
		fprintf(stderr, "FT: missing cb for init\n");
		accept_ft = false;
	}

	if (accept_ft) {
		_send_pkg_FT1_INIT_ACK(tox, group_number, peer_number, transfer_id);
		fprintf(stderr, "FT: accepted init\n");
	} else {
		// TODO deny?
		fprintf(stderr, "FT: rejected init\n");
	}
}

#undef _DATA_HAVE