/*
 ** Authors: Krishna Puttaswamy
 ** this file represents an instance of a dht node for the churn test of dht
 */ 
#include <stdio.h>
#include <unistd.h>
#include <openssl/evp.h>
#include <stdlib.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <iostream>
#include <vector>
#include <string.h>
#include <fcntl.h>
#include <signal.h>
#include <pthread.h>

#include "dht.h"
#include "chimera.h"
#include "log.h"
#include "key.h"
#include "route.h"
#include "dtime.h"

//joinwaittime is the time the node waits before sending the message
#define USAGE "timeddhtnode [ -j bootstrap:port ] port key timetolive" 
#define OPTSTR "j:"
#define RAND() (lrand48())
#define SEED(s) (srand48(s))

char *optarg;
int optind;
char mynodekey[195];
ChimeraState *state; 
bool isbootstrap = false;
pthread_mutex_t lock;

void die_handler(int sig) {
	exit(0);
}

	void signal_handler(int sig) {
		if (sig == SIGALRM)
		{
			if (isbootstrap)
				fprintf(stderr, "BOOTSTRAP NODE %s is dying \n", mynodekey);
			else
				fprintf(stderr, "%s is dying \n", mynodekey);

			log_message (state->log, LOG_DATA, "dying of timeout \n");
			exit(0);
		}
	}

bool read_from_file(FILE *fp, char *block) {
	// assumption is that the file contains each entry of size entry_size
	if (fgets(block, ENTRY_SIZE, fp) == NULL)
		return false;

	int i = 0;
	// replace new line -- just to making the output pretty
	int len = strlen(block);
	for(i = 0; i < len; i++)
		if(block[i] == '\n')
		{
			block[i] = '\0';
			break;;
		}

	return true;
}

int main(int argc, char **argv) {
	int opt;
	char *hn = NULL;
	int port, joinport;
	ChimeraHost *host = NULL;
	char tmp[256];
	Key key, keyinput;
	int i, j;
	char *digest;
	char message[] = " Hello ";
	mynodekey[0]  = '\0';

	signal(SIGALRM, signal_handler);
	/*fprintf(stderr, "%d arguments are ... ", argc);
	  for ( i = 0; i < argc; i++)
	  {
	  fprintf(stderr, " %s ", argv[i]);
	  }
	  fprintf(stderr, "\n");
	  fflush(stderr);
	 */

	while((opt = getopt(argc, argv, OPTSTR)) != EOF) 
	{
		switch((char) opt) 
		{
			case 'j':
				for(i=0; optarg[i] != ':' && i<strlen(optarg); i++);
				optarg[i] = 0;
				hn = optarg;
				sscanf(optarg + (i + 1), "%d", &joinport);
				break;
			default:
				fprintf(stderr, "invalid option %c\n", (char) opt);
				fprintf(stderr, "usage: %s\n", USAGE);
				exit(1);
		}
	}

	if((argc - optind) < 3)
	{
		fprintf(stderr, "usage: %s\n", USAGE);
		exit(1);
	}

	port = atoi(argv[optind]);
	str_to_key(argv[optind+1],&keyinput);
	//printf("And now I'm here: main: reading args...; strlen = %d/n", strlen(argv[optind + 1]));
	int alrm = atoi(argv[optind + 2]);
	//	fprintf(stderr, "timednode set the alarm for the time interval %d \n", alrm);
	alarm(alrm-EVAL_MESSAGE_DELAY); // trigger the alarm after this much time

	strcpy(mynodekey, keyinput.keystr); 
	state=chimera_init(port);

	if(hn != NULL) 
		host = host_get(state, hn, joinport);

	chimera_setkey(state, keyinput);
	chimera_register (state, HELLO_MESSAGE, 1);

	char datalogname[256];
	char cashlogname[256];
	sprintf(datalogname, "logs/LOG_DATA_%s", mynodekey);
	//sprintf(networkdebug, "logs/LOG_NETWORKDEBUG_%s", mynodekey);
	//sprintf(routingdebug, "logs/LOG_ROUTING_%s", mynodekey);
	FILE *datalogfp = fopen(datalogname, "w");
	//FILE *cashlogfp = fopen(cashlogname, "w");
	log_direct(state->log, LOG_DATA, datalogfp);
	//log_direct(state->log, LOG_WARN, stderr);
	//log_direct(state->log, LOG_ERROR, stderr);

	if(host != NULL)
	{
		chimera_join(state,host);
	}

	//fprintf(stderr,"** send messages to key with command <key> <message> **\n");
	if(hn == NULL) {
		// The amount by which the driver script sleeps for the bootstrap node
		isbootstrap = true;
		sleep(5); // sleep for the same amount as the driver
	}

	dhtlayer_init(state, mynodekey);
	int ii = 0; 
	if (isbootstrap) {
		fprintf(stderr, "I am the bootstrap node, taking the control!!\n");
		dsleep(30);

		FILE *blockFP = fopen(BLOCKS_FILE, "r");
		int i = 0;
		char block[100];
		for (i = 0; i < 10; i++){

			if (read_from_file(blockFP, block) == false)
				break;
			fprintf(stderr, "Storing %s \n", block);

			Key tempKey;
			str_to_key(block, &tempKey);
			DhtMessage *send = get_new_dhtmessage(block, block, mynodekey, NULL);
			chimera_send(state, tempKey, DHT_PUT_ROOT, sizeof(DhtMessage), (char *)send);
			free_dhtmessage(send);
			dsleep(.1);
		}
		fclose(blockFP);
		fprintf(stderr, "Inserted %d blocks into the DHT ...now looking them up\n", i);

		dsleep(100);

		fprintf(stderr, "now, should lookup \n");
		blockFP = fopen(BLOCKS_FILE, "r");
		for (i = 0; i < 10; i++){

			if (read_from_file(blockFP, block) == false)
				break;
			fprintf(stderr, "Looking for %s\n", block);
			Key tempKey;
			str_to_key(block, &tempKey);
			DhtMessage *send = get_new_dhtmessage(block, NULL, mynodekey, NULL);
			chimera_send(state, tempKey, DHT_GET_ROOT, sizeof(DhtMessage), (char *)send);
			free_dhtmessage(send);
			dsleep(.1);
		}
		fclose(blockFP);
		fprintf(stderr, "Lookedup %d blocks into the DHT \n", i);
		fflush(stderr);
		sleep(10);

		blockFP = fopen(HOSTS_FILE, "r");
		int count = 0;
		while(read_from_file(blockFP, block)){
			if (count == 75)
				break;
			//fprintf(stderr, "block read is %s \n",block);
			Key tempKey;
			char host[100], temp[100];
			int kkk;
			sscanf (block, "%s %d %s", host, &kkk, temp);
			str_to_key(temp, &tempKey);
			char str[10] = "test";
			chimera_send(state, tempKey, DHT_DUMP_STATE, strlen(str)+1 , (char *)str);
			count++;
			dsleep(.1);
		}
		fclose(blockFP);
		fprintf(stderr, "Send %d dump messages \n", count);
	}

	while(1) 
		sleep(1000);
	//fclose(datalogfp);
	//fclose(securelogfp);
	fprintf(stderr, "exiting... \n");
	exit(0);
}