#include <stdio.h>
#include <stdlib.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <pthread.h>
#include <netinet/in.h>
#include <unistd.h>
#include <string.h>

#include <openssl/bn.h>
#include <time.h>
#include <math.h>
#include <memory.h>
#include <string.h>
#include <openssl/sha.h>
#include <openssl/rand.h>

struct fileReadArgs{
	int childNumber;
 	int sockfd;
	//char* filename;
};
void* receiveMessage(void *fd){
	struct fileReadArgs *p = (struct fileReadArgs*)fd;
	char client_response[256];
	int sockfd = p->sockfd;
	recv(sockfd, &client_response, sizeof(client_response), 0);
	printf("Ther client send this data: %s\n", client_response);
	//printf("Sending message to client");
	//send(sockfd, server_message, sizeof(server_message), 0);

	//Retrieve s and v

}

void* sendMessage(void *fd){
	struct fileReadArgs *p = (struct fileReadArgs*)fd;
	char server_message[256] = "MUHAHAHAHHA!";
	int sockfd = p->sockfd;
	printf("Sending message to client: %s", server_message);
	send(sockfd, server_message, sizeof(server_message), 0);
}

/*

void fileRead(void *fd){
	int BUFFER_SIZE = 64;
	struct fileReadArgs p = (struct fileReadArgs)fd;
	int sockfd = p->sockfd;
	int childNumber = p->childNumber;
	char* filename = p->filename;
	FILE *f = fopen(filename, "rb");
	if(f == NULL){
		printf("Error opening file");
		return;
	}
	fseek(f, 0, SEEK_END);
	int fileSize = ftell(f);
	fseek(f, 0, SEEK_SET);

	char size[32];
	sprintf(size, "%d", fileSize);
	write(sockfd, size, 32);

	char *name = strrchr(filename, '/');
	if(name == NULL)
		name = filename;
	else
		name++;

	char fileNameSize = strlen(name)+1;
	write(sockfd, &fileNameSize, 1);

	write(sockfd, name, strlen(name)+1);

	int n = 0; //total bytes read/written
	char buffer[BUFFER_SIZE];
	while(!feof(f)){
		int read = fread(buffer, 1, BUFFER_SIZE, f);
		if(read < 0)
			printf("Error reading from file");

		write(sockfd, buffer, read);
		//printf("%s",buffer);

		n+=read;
		//loader(n, fileSize, LOADER_LENGTH, 0);
	}

	fclose(f);
}*/


int serverFileTransfer(int port){
	//char server_message[256] = "MUHAHAHAHHA!";

	int sockfd = socket(AF_INET, SOCK_STREAM, 0);
	if(sockfd<0)
		printf("Error opening socket");

	struct sockaddr_in serv_addr, cli_addr;
	memset((char*) &serv_addr, 0, sizeof(serv_addr));

	serv_addr.sin_family = AF_INET;
	serv_addr.sin_port = htons(port);
	serv_addr.sin_addr.s_addr = INADDR_ANY;


	if(bind(sockfd, (struct sockaddr*)&serv_addr, sizeof(serv_addr)) < 0)
		printf("Error Binding");

	listen(sockfd, 5);

	socklen_t cilen = sizeof(cli_addr);

	pthread_t newThread;
	pthread_attr_t attr;
	pthread_attr_init(&attr);
	pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_DETACHED);

	int noOfChilds = 0;

	while(1){
		int newsockfd = accept(sockfd, (struct sockaddr*)&cli_addr, &cilen);
		noOfChilds++;

		struct fileReadArgs args;
		args.sockfd = newsockfd;
		args.childNumber = noOfChilds;
		//args.filename = "123.txt";

		if(newsockfd < 0)
			printf("Error accepting");

		//send(newsockfd, server_message, sizeof(server_message), 0);
		//pthread_create(&newThread, &attr, &fileRead, &args);

		pthread_create(&newThread, &attr, &receiveMessage, &args);

	}

	pthread_attr_destroy(&attr);

	return 0;
}

//1. Find a user list and password
//User - Salt - Password              Verifer(salt + password)[hardcode]
struct userlist
{
	char username[30];
	char salt[32];//int RAND_bytes(salt,32);
	char password[30];
	//verifier
} user;

//Hardcode user list, salt, v
//2. Compute x, x= H(s || w)
char* compute_x(char* salt, char* password){
	//Concat Salt and password
	const char * concat_x = (char *) malloc(1 + strlen(salt)+ strlen(password) );
	strcpy(concat_x, salt);
	strcat(concat_x, password);
	printf("%s\n", concat_x);

	unsigned char digest[SHA256_DIGEST_LENGTH];

	SHA256_CTX ctx;
	SHA256_Init(&ctx);
	SHA256_Update(&ctx, concat_x, strlen(concat_x));
	SHA256_Final(digest, &ctx);

	static char mdString[SHA256_DIGEST_LENGTH*2+1];
	for (int i = 0; i < SHA256_DIGEST_LENGTH; i++)
        	sprintf(&mdString[i*2], "%02x", (unsigned int)digest[i]);

    	printf("x = H(s || w) : %s\n", mdString);
	return mdString;
}

//3. compute verifier
//g^x mod N
char* compute_v(char* x, char* N, char* g){
	/*
	printf("x in compute_v: %ld\n",x);
	printf("FAKE N: %d\n",N);
	printf("g: %d\n", g);
	int result = g^x % N;
	printf("result = %d", result);
	*/

	//printf("x = %s\n", x);
	//printf("N = %s\n", N);
	//printf("g = %s\n", g);
	BIGNUM *tmp1 = BN_new();

	BIGNUM *X = BN_new();
	BN_hex2bn(&X, x);

	BIGNUM *PrimeN = BN_new();
	BN_hex2bn(&PrimeN, N);

	BIGNUM *G = BN_new();
	BN_hex2bn(&G, g);

	BN_CTX *ctx = BN_CTX_new();
	BN_mod_exp(tmp1, G, X, PrimeN, ctx);

	char * v = BN_bn2hex(tmp1);
	printf("v: %s\n",v);
	return v;
}


//get b
char* random_b(){
	BIGNUM *BN_b = BN_new();
	BN_rand(BN_b, 256, -1, 0);
	char * b = BN_bn2hex(BN_b);
	printf("b: %s\n",b);
	return b;
}

//5. get key, k = H (N || G)
char* get_small_k(char* N, char* g){
	//Concat N and G
	const char * concat_x = (char *) malloc(1 + strlen(N)+ strlen(g));
	strcpy(concat_x, N);
	strcat(concat_x, g);
	printf("%s\n", concat_x);

	unsigned char digest[SHA256_DIGEST_LENGTH];

	SHA256_CTX ctx;
	SHA256_Init(&ctx);
	SHA256_Update(&ctx, concat_x, strlen(concat_x));
	SHA256_Final(digest, &ctx);

	static char mdString[SHA256_DIGEST_LENGTH*2+1];
	for (int i = 0; i < SHA256_DIGEST_LENGTH; i++)
        	sprintf(&mdString[i*2], "%02x", (unsigned int)digest[i]);

    	printf("k = H (N || G) : %s\n", mdString);
	return mdString;
}

//6. Get B = kv + g^b
char* get_B(char* k,char* v,char* g,char* b, char* N){
	BN_CTX *ctx = BN_CTX_new();
	BIGNUM *tmp1 = BN_new();
	BIGNUM *tmp2 = BN_new();
	BIGNUM *B_v = BN_new();

	BIGNUM *K = BN_new();
	BN_hex2bn(&K, k);

	BIGNUM *V = BN_new();
	BN_hex2bn(&V, v);

	BIGNUM *G = BN_new();
	BN_hex2bn(&G, g);

	BIGNUM *B = BN_new();
	BN_hex2bn(&B, b);

	BIGNUM *PrimeN = BN_new();
	BN_hex2bn(&PrimeN, N);

	BN_mul(tmp1, K, V, ctx);
	BN_mod_exp(tmp2, G, B, PrimeN, ctx);
	BN_mod_add(B_v, tmp1, tmp2, PrimeN, ctx);

	char * B_value = BN_bn2hex(B_v);
	printf("B = kv + g^b : %s\n",B_value);
	return B_value;
}

char* concat_ngs(char* N, char* g, char* s){
	//Concat N and G
	const char * concat_x = (char *) malloc(1 + strlen(N)+ strlen(g));
	strcpy(concat_x, N);
	strcat(concat_x, g);
	const char * concat_x2 = (char *) malloc(1 + strlen(concat_x)+ strlen(s));
	strcpy(concat_x2, concat_x);
	strcat(concat_x2, s);
	//printf("CONCAT2: %s\n", concat_x2);
	return concat_x2;
}

//Printing BIG NUM VALUE
char* toPrintBIGNUM(char* str){ //HEX to BIGNUM
	BIGNUM *p = BN_new();
	BN_hex2bn(&p, str);
	//For printing purposes
	char * number_str = BN_bn2hex(p);
	printf("HEX TO BIGNUM: %s\n", number_str);
	return number_str;
}


int main(int argc, char *argv[]){

	//Create userlist
	struct userlist user1;
	strcpy( user1.username, "yihjin");
	strcpy( user1.salt, "yes");
	strcpy( user1.password, "supersecret");
	struct userlist user2;
	strcpy( user2.username, "weijian");
	strcpy( user2.salt, "no");
	strcpy( user2.password, "nosecret");
	struct userlist user3;
	strcpy( user3.username, "nicholas");
	strcpy( user3.salt, "nah");
	strcpy( user3.password, "secretpass");

/*
	//print user1 info
	printf("----------------------------------\n");
	printf( "username : %s\n", user1.username);
	printf( "salt : %s\n", user1.salt);
	printf( "password : %s\n", user1.password);

	//print user2 info
	printf( "username : %s\n", user2.username);
	printf( "salt : %s\n", user2.salt);
	printf( "password : %s\n", user2.password);

	//print user3 info
	printf( "username : %s\n", user3.username);
	printf( "salt : %s\n", user3.salt);
	printf( "password : %s\n", user3.password);
	printf("----------------------------------\n");
*/
	//int N = 12345678; //give a small value fuck this shit
	//int g = 2;



	char N[] = "FFFFFFFFFFFFFFFFC90FDAA22168C234C4C6628B80DC1CD129024E088A67CC74020BBEA63B139B22514A08798E3404DDEF9519B3CD3A431B302B0A6DF25F14374FE1356D6D51C245E485B576625E7EC6F44C42E9A637ED6B0BFF5CB6F406B7EDEE386BFB5A899FA5AE9F24117C4B1FE649286651ECE45B3DC2007CB8A163BF0598DA48361C55D39A69163FA8FD24CF5F83655D23DCA3AD961C62F356208552BB9ED529077096966D670C354E4ABC9804F1746C08CA18217C32905E462E36CE3BE39E772C180E86039B2783A2EC07A28FB5C55DF06F4C52C9DE2BCBF6955817183995497CEA956AE515D2261898FA051015728E5A8AACAA68FFFFFFFFFFFFFFFF";
	toPrintBIGNUM(N);
	char g[] = "2";

	concat_ngs(N, g, user1.salt);


	char* x;
	x = compute_x(user1.salt, user1.password);
	//printf("x: %s\n",x);

	char* v;
	v = compute_v(x,N,g);

	char* b;
	b = random_b();

	char* k;
	k = get_small_k(N,g);
	//printf("k: %s\n",k);

	char* B_value;
	B_value= get_B( k, v, g, b, N);



	//char g[] = "2";
	//toBIGNUM(g);

	//static long x;
	//x = compute_x(user1.salt, user1.password);
	//printf("----new_x=%s\n", x);
	//compute_v(x, N, g);
	//rand_string();


	//serverFileTransfer(8080);


}