/*
	(c) Copyright  2012 - 2018 Anton Sviridenko
	https://picapica.im

	This program is free software: you can redistribute it and/or modify
	it under the terms of the GNU General Public License as published by
	the Free Software Foundation, version 3.

	This program is distributed in the hope that it will be useful,
	but WITHOUT ANY WARRANTY; without even the implied warranty of
	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
	GNU General Public License for more details.

	You should have received a copy of the GNU General Public License
	along with this program.  If not, see <https://www.gnu.org/licenses/>.
*/
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include <sys/select.h>
#include <unistd.h>

#include "../PICA_client.h"
#include "../PICA_proto.h"

struct sockaddr_in a;
struct PICA_acc *acc;
struct PICA_c2n *c;
struct PICA_c2c *chn;
enum PICA_directc2c_config directc2c_cfg = PICA_DIRECTC2C_CFG_DISABLED;
struct PICA_listener *l = NULL;


int _outgoing_chnl = 0;

int connected_to_node = 0;
int c2c_active = 0;
int c2c_in_progress = 0;

int echo_mode = 0;
int random_message_mode = 0;
int delivery_acks_count = 0;
int rmm_wait_for_reply = 0;

unsigned char buf[64 * 1024];

int accept_cb(const unsigned char *id)
{
	printf("accept_cb: %s\n", PICA_id_to_base64(id, NULL));
	return 1;
}

//получение сообщения.
void newmsg_cb(const unsigned char *peer_id, const char* msgbuf, unsigned int nb, int type)
{

	if (echo_mode)
	{
		int ret;

		ret = PICA_send_msg(chn, msgbuf, nb);

		if (ret != PICA_OK)
			printf("failed to send message, error = %i\n", ret);

		return;
	}

	if (random_message_mode)
	{
		//compare received & sent messages, fail if they do not match exactly
		if (memcmp(msgbuf, buf, nb) != 0)
		{
			printf("sent and returned messages are not equal!\n");
			exit(1);
		}

		rmm_wait_for_reply = 0;
	}

	memcpy(buf, msgbuf, nb);
	buf[nb] = 0;
	printf(" %s: ", PICA_id_to_base64(peer_id, NULL));
	puts(buf);
}
//получение подтверждения о доставке сообщения
void msgok_cb(const unsigned char *peer_id)
{
	delivery_acks_count++;
	puts("[V]");
}
//создание канала с собеседником
void c2c_established_cb(const unsigned char *peer_id)
{
	c2c_active = 1;
	c2c_in_progress = 0;
	puts("c2c_established_cb");
	chn = c->chan_list_head;//hack, its better to pass new c2c pointer as callback arg
}

void c2c_failed_cb(const unsigned char *peer_id)
{
	c2c_in_progress = 0;
	printf("Failed to create c2c to %s\n", PICA_id_to_base64(peer_id, NULL));
	chn = 0;
}

//входящий запрос на создание канала от пользователя с номером caller_id
//<<int accept_cb(unsigned int caller_id);
//запрошенный пользователь не найден, в оффлайне или отказался от общения
void notfound_cb(const unsigned char *callee_id)
{
	puts("notfound_cb");
}

void c2c_closed_cb(const unsigned char *peer_id, int reason)
{
	c2c_active = 0;
	c2c_in_progress = 0;
	printf("c2c_closed_cb( peer_id = %s, reason = %i)\n", PICA_id_to_base64(peer_id, NULL), reason);
}

void nodelist_cb(int type, void *addr_bin, const char *addr_str, unsigned int port)
{
	switch(type)
	{
	case 0xA0:
		printf("node (IP %s port %u)\n", addr_str, port);
		break;

	case 0xA1:
		printf("node (IPv6 %s port %u)", addr_str, port);
		break;

	case 0xA2:
		printf("node (hostname %s port %u)\n", addr_str, port);
		break;

	default:
		puts("unknown node address type");
		return;
	}
}

int peer_cert_verify_cb(const unsigned char *peer_id, const char *cert_pem, unsigned int nb)
{
	printf("peer's certificate (%s): \n%.*s\n", PICA_id_to_base64(peer_id, NULL), nb, cert_pem);
	return 1;
}

int accept_file_cb(const unsigned char  *peer_id, uint64_t  file_size, const char *filename, unsigned int filename_size)
{
	int ret;
	char namebuf[256];

	printf("accept_file_cb: peer_id %s filename: %.*s\n", PICA_id_to_base64(peer_id, NULL), filename_size, filename);

	sprintf(namebuf, "/tmp/received_%.*s", filename_size, filename);

	ret = PICA_accept_file(chn, namebuf, strlen(namebuf));

	if (ret != PICA_OK)
	{
		printf("faild to accept file, errror %i\n", ret);
		return 0;
	}

	return 2;
}

void accepted_file_cb(const unsigned char *peer_id)
{
	printf("accepted_file_cb: peer_id %s \n", PICA_id_to_base64(peer_id, NULL));
}

void denied_file_cb(const unsigned char *peer_id)
{
	printf("denied_file_cb: peer_id %s \n", PICA_id_to_base64(peer_id, NULL));
}

void file_progress(const unsigned char *peer_id, uint64_t sent, uint64_t received)
{
	printf("file_progress: peer_id %s\n", PICA_id_to_base64(peer_id, NULL));
}

void file_control(const unsigned char *peer_id, unsigned int sender_cmd, unsigned int receiver_cmd)
{
	printf("file_control: peer_id %s sender_cmd %u receiver_cmd %u \n", PICA_id_to_base64(peer_id, NULL), sender_cmd, receiver_cmd);
}

void file_finished(const unsigned char *peer_id, int sending)
{
	printf("file_finished: peer_id %s\n", PICA_id_to_base64(peer_id, NULL));
}

void c2n_established_cb(struct PICA_c2n *c2n)
{
	connected_to_node = 1;
	printf("c2n_established_cb: %p\n my_id %s\n", c2n, PICA_id_to_base64(c2n->acc->id, NULL));
}

void c2n_failed_cb(struct PICA_c2n *c2n, int error)
{
	printf("c2n_failed_cb: %p error_code %i\n", c2n, error);
	c = NULL;
}

void c2n_closed_cb(struct PICA_c2n *c2n, int error)
{
	printf("c2n_closed_cb: %p error_code %i\n", c2n, error);
	c = NULL;
}

void listener_error(struct PICA_listener *lst, int errorcode)
{
	printf("listener_error: %p error code %i\n", lst, errorcode);
	l = NULL;
}

void multilogin_cb(time_t timestamp, void *addr_bin, const char *addr_str, uint16_t port)
{
	printf("received MULTILOGIN\n");
}

struct PICA_client_callbacks cbs =
{
	newmsg_cb,
	msgok_cb,
	c2c_established_cb,
	c2c_failed_cb,
	accept_cb,
	notfound_cb,
	c2c_closed_cb,
	nodelist_cb,
	peer_cert_verify_cb,
	accept_file_cb,
	accepted_file_cb,
	denied_file_cb,
	file_progress,
	file_control,
	file_finished,
	c2n_established_cb,
	c2n_failed_cb,
	c2n_closed_cb,
	listener_error,
	multilogin_cb
};

int main(int argc, char** argv)
{
	int ret, opt;
	unsigned char peer_id[PICA_ID_SIZE];
	struct PICA_c2n* c2ns[] = {NULL, NULL};

	fd_set stdinfds;
	struct timeval tv;


	const char *nodeaddr = NULL, *nodeport = NULL,
		   *certfile = NULL, *peerid = NULL,
		   *localdirectaddr = NULL, *extport = NULL,
		   *filetosend = NULL,
		   *locport = NULL;

	int multilogin = PICA_MULTILOGIN_PROHIBIT;

	while ((opt = getopt(argc, argv, "a:p:c:i:d:e:l:f:tmrM:")) != -1)
	{
		switch(opt)
		{
		case 'a':
			nodeaddr = optarg;
		break;

		case 'p':
			nodeport = optarg;
		break;

		case 'c':
			certfile = optarg;
		break;

		case 'i':
			peerid = optarg;
		break;

		case 'd':
			localdirectaddr = optarg;
		break;

		case 'e':
			extport = optarg;
		break;

		case 'f':
			filetosend = optarg;
		break;

		case 'l':
			locport = optarg;
		break;

		case 't':
			directc2c_cfg = PICA_DIRECTC2C_CFG_CONNECTONLY;
		break;

		case 'm':
			echo_mode = 1;
		break;

		case 'r':
			random_message_mode = 1;
		break;

		case 'M':
			if (strcmp(optarg, "prohibit") == 0)
				multilogin = PICA_MULTILOGIN_PROHIBIT;
			else if (strcmp(optarg, "replace") == 0)
				multilogin = PICA_MULTILOGIN_REPLACE;
			else if (strcmp(optarg, "sync") == 0)
				multilogin = PICA_MULTILOGIN_ALLOW;
			else
			{
				fprintf(stderr, "invalid multilogin option argument: %s\n", optarg);
				return -1;
			}
		break;

		default:
			fprintf(stderr, "invalid arg %s\n", optarg);
			return -1;
		}
	}

	if (echo_mode && random_message_mode)
	{
		puts("echo mode and random test messages mode are mutually exclusive, please select only one of them");
		return -1;
	}

	if (argc < 4 || !nodeaddr || !nodeport || !certfile)
	{
		puts("usage: test_client -a node address -p node port -c cert_filename  [-i peer id]\n\
		-d local address for direct incoming c2c connections\n\
		-e external port for incoming direct connections\n\
		-l internal port to listen for incoming direct connections\n\
		-t enable connect-only mode for direct c2c connections\n\
		-m start in echo mode, received messages are sent back, input from stdin is not accepted\n\
		-r send random test messages and exit, expects other side to be run in echo mode\n\
		-M multilogin policy, one from \"prohibit\", \"replace\", \"sync\"\n\
cert_filename should point to file that contains client certificate, private key and Diffie-Hellman parameters in PEM format");
		return 0;
	}



	puts(SSLeay_version(SSLEAY_VERSION));
	printf("Calling PICA_init...\n");

	PICA_client_init(&cbs);

	printf("opening account...");
	ret = PICA_open_acc(certfile, certfile, certfile, NULL, &acc);

	if (ret != PICA_OK)
	{
		fprintf(stderr, "failed to open account, ret = %i\n", ret);
		return 1;
	}

	if (localdirectaddr)
	{
		int intp = 2300, extp = 2300;

		directc2c_cfg = PICA_DIRECTC2C_CFG_ALLOWINCOMING;

		if (extport)
			extp = atoi(extport);
		if (locport)
			intp = atoi(locport);

		printf("new listener on %s port %i external announced port %i\n", localdirectaddr, intp, extp);

		ret = PICA_new_listener(acc, localdirectaddr, extp, intp, &l);

		if (ret != PICA_OK)
		{
			fprintf(stderr, "failed to create listener, error code: %i\n", ret);
			l = NULL;
		}

	}

	printf("making connection...\n");

//PICA_new_c2n(const char *nodeaddr, unsigned int port, const char *CA_file, const char *cert_file, const char *pkey_file, const char* password, struct PICA_c2n **ci)
	ret = PICA_new_c2n(acc, nodeaddr, atoi(nodeport), directc2c_cfg, multilogin, l, &c);

	ERR_print_errors_fp(stdout);

	if (ret == PICA_OK)
		printf("PICA_OK started c2n connection to node...\n");
	else
	{
		printf("PICA_new_c2n: ret=%i\n", ret);
		return 1;
	}

	c2ns[0] = c;


	while(PICA_event_loop(c2ns, 500) == PICA_OK && c != NULL)
	{
		//puts("event loop...");
		if (peerid && connected_to_node == 1 && c2c_active == 0 && c2c_in_progress == 0)
		{
			if (PICA_id_from_base64(peerid, peer_id) == NULL)
			{
				puts("invalid peer_id");
				return 1;
			}

			printf("Creating c2c to %s...\n", PICA_id_to_base64(peer_id, NULL));

			ret = PICA_new_c2c(c, peer_id, l, &chn);
			//sleep(17);//timeout test
			if (ret != PICA_OK)
			{
				printf("error: ret=%i\n", ret);
				return 1;
			}

			printf("chn = %p\n", chn);
			c2c_in_progress = 1;

		}

		if (random_message_mode && connected_to_node == 1 && c2c_active == 1 && rmm_wait_for_reply == 0)
		{
			static int test_stage = 0;

			switch(test_stage)
			{
			//send zero-length message
			case 0:
				ret = PICA_send_msg(chn, NULL, 0);
				test_stage++;
				rmm_wait_for_reply = 1;
				break;

			//send max length message
			case 1:
				memset(buf, 'X', PICA_PROTO_C2CMSG_MAXDATASIZE);
				ret = PICA_send_msg(chn, buf, PICA_PROTO_C2CMSG_MAXDATASIZE);
				test_stage++;
				rmm_wait_for_reply = 1;
				break;

			//send random length message
			case 2:
				RAND_pseudo_bytes((unsigned char*)&ret, sizeof ret);
				if (ret < 0)
					ret = 0 - ret;
				ret %= PICA_PROTO_C2CMSG_MAXDATASIZE;
				memset(buf, 'x', ret);
				ret = PICA_send_msg(chn, buf, ret);
				test_stage++;
				rmm_wait_for_reply = 1;
				break;

			default:
				puts("waiting for test messages to be delivered");
			}

			if (ret != PICA_OK)
			{
				printf("failed to send message, error = %i\n", ret);
				return 1;
			}

			if (delivery_acks_count == 3)
				break;//exit main loop on success
		}

		if (connected_to_node == 1 && c2c_active == 1 && !echo_mode && !random_message_mode)
		{
			FD_ZERO(&stdinfds);
			FD_SET(STDIN_FILENO, &stdinfds);

			tv.tv_sec = 0;
			tv.tv_usec = 500000;

			ret = select(STDIN_FILENO + 1, &stdinfds, NULL, NULL, &tv);

			if (ret == -1)
			{
				perror("select() on stdin failed");
				return 1;
			}

			if (ret > 0 && FD_ISSET(STDIN_FILENO, &stdinfds))
			{
				ret = read(STDIN_FILENO, buf, 256);

				if (ret <= 0)
					{
						perror("read from stdin");
						return 1;
					}

				ret = PICA_send_msg(chn, buf, ret);

				if (ret != PICA_OK)
					printf("failed to send message, error = %i\n", ret);
			}
		}

		if (connected_to_node == 1 && c2c_active == 1 && filetosend)
		{
			printf("sending file %s to peer...\n", filetosend);
			ret = PICA_send_file(chn, filetosend);

			if (ret != PICA_OK)
				printf("failed to send file %s, error = %i\n", filetosend, ret);

			filetosend = NULL;
		}


	}



	if (c)
		PICA_close_c2n(c);

	if(l)
		PICA_close_listener(l);

	return 0;
}