#include "cmix.h"
#include "message.h"

#include "api.h"

#include <gcrypt.h>

#include <stdio.h>
#include <string.h>

void cmix_buffer_scratch();
void crypto_api_scratch();
void gcrypt_scratch();

int main(int argc, char* argv[]) {
	gcrypt_scratch();
	
	return 0;
}

void check(gcry_error_t error) {
	if (error) {
		fprintf (stderr, "Error: %s/%s\n", gcry_strsource (error), gcry_strerror (error));
		exit(1);
	}
}

void print_sexp(gcry_sexp_t exp) {
	size_t required_size = gcry_sexp_sprint(exp, GCRYSEXP_FMT_ADVANCED, NULL, 0); //passing NULL as the buffer will return the size needed.

	char* str = (char *) malloc(sizeof(char)*required_size);

	gcry_sexp_sprint(exp, GCRYSEXP_FMT_ADVANCED, str, 2000); //So we ignore the size here.
	
	printf("size = %zu\n", required_size);
	for(size_t i = 0; i < required_size; i++)
		printf("%c", str[i]);
	printf("\n");

	free(str);
}

void gcrypt_scratch() {

	if (!gcry_check_version (GCRYPT_VERSION)) {
		fprintf(stderr, "libgcrypt version mismatch\n");
		exit(-1);
	}
	
	gcry_control (GCRYCTL_SUSPEND_SECMEM_WARN);
	gcry_control (GCRYCTL_INIT_SECMEM, 16384, 0);
	gcry_control (GCRYCTL_RESUME_SECMEM_WARN);
	gcry_control (GCRYCTL_INITIALIZATION_FINISHED, 0);

	size_t parse_error_offset;
	gcry_error_t error;

	gcry_sexp_t key_generator;
	error = gcry_sexp_build(&key_generator, &parse_error_offset, "(genkey (%s (nbits %s)))", "elg", "2048");
	check(error);
	
	gcry_sexp_t key_pair;
	error = gcry_pk_genkey(&key_pair, key_generator);
	check(error);
	
	gcry_sexp_t pub_key = gcry_sexp_find_token(key_pair, "public-key", 0);
	gcry_sexp_t sec_key = gcry_sexp_find_token(key_pair, "private-key", 0);
	
	char message_string[] = "hello world!";
	
	gcry_sexp_t message;
	error = gcry_sexp_build(&message, &parse_error_offset, "(data (flags %s) (value %b))", "raw", sizeof(message_string), message_string);
	check(error);
	
	gcry_sexp_t cipher;
	error = gcry_pk_encrypt(&cipher, message, pub_key);
	check(error);
	
	gcry_sexp_t raw_cipher;
	raw_cipher = gcry_sexp_find_token(cipher, "elg", 0);
	
	gcry_sexp_t decryption_sexpr;
	error = gcry_sexp_build(&decryption_sexpr, &parse_error_offset, "(enc-val (flags %s) %S)", "raw", raw_cipher);
	check(error);
	
	gcry_sexp_t plain_sexpr;
	error = gcry_pk_decrypt(&plain_sexpr, decryption_sexpr, sec_key);
	check(error);
	
	print_sexp(plain_sexpr);
	
	gcry_sexp_release(key_generator);
	gcry_sexp_release(key_pair);
	gcry_sexp_release(pub_key);
	gcry_sexp_release(sec_key);
	gcry_sexp_release(message);
	gcry_sexp_release(cipher);
	gcry_sexp_release(raw_cipher);
	gcry_sexp_release(decryption_sexpr);
	gcry_sexp_release(plain_sexpr);
}

void cmix_buffer_scratch() {
	struct CmixBufferImpl buffer_impl = get_cmix_Curve25519_buffer_implementation();
	char* buffer = buffer_impl.allocate_cmix_buffer(3);
	
	int message_size = buffer_impl.message_length();
	
	for(int i=0; i < 3; i++) {
		buffer[i*message_size] = 'h';
	}
	
	for(int i=0; i < 3; i++) {
		putc(buffer[i*message_size], stdout);
		putc('\n', stdout);
	}
	
	buffer_impl.deallocate_cmix_buffer(buffer);
}

void crypto_api_scratch() {
/*	struct Api api = get_implementation();

	struct KeyPair pair1 = api.create_key_pair();
	struct KeyPair pair2 = api.create_key_pair();

	struct SharedKey sk1 = api.derive_shared_key(pair1, pair2.pub, false);
	sstruct SharedKey sk2 = api.derive_shared_key(pair2, pair1.pub, true);

	char* buffer1;
	size_t len1;
	api.get_key_array(&buffer1, &len1, sk1.shared);
	
	char* buffer2;
	size_t len2;
	api.get_key_array(&buffer2, &len2, sk2.shared);

	if(len1 == len2 && memcmp(buffer1, buffer2, len1) != 0) {
		exit(-1);
	} else {
		printf("Yoepie!");
	}

	api.free_key_pair(&pair1);
	api.free_key_pair(&pair2);

	api.free_shared_key(&sk1);
	api.free_shared_key(&sk2);
*/
}