#include "cmix.h"

#include "api.h"

#include <gcrypt.h>

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

void crypto_add_sub_scratch();
void crypto_api_scratch();
void gcrypt_scratch();

int main(int argc, char* argv[]) {
	(void) argc;
	(void) argv;
	
	crypto_add_sub_scratch();
}

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 crypto_add_sub_scratch() {
	struct Api api = get_implementation();
	
	gcry_ctx_t ctx;
	gcry_error_t error = gcry_mpi_ec_new(&ctx, NULL, "Ed25519");
	
	GroupElement rel1 = api.get_group_element(false);
	GroupElement rel2 = api.get_group_element(false);
	
	gcry_mpi_point_t red_add_raw = gcry_mpi_point_new(0);
	gcry_mpi_ec_add(red_add_raw, rel1, rel2, ctx);
	
	GroupElement rel_add = api.combine(rel1, rel2, false);
	GroupElement rel_sub = api.uncombine(rel_add, rel2, false);
	
	gcry_mpi_t xaddraw = gcry_mpi_new(0);
	gcry_mpi_t yaddraw = gcry_mpi_new(0);
	
	gcry_mpi_ec_get_affine(xaddraw, yaddraw, red_add_raw, ctx);
	
	gcry_mpi_dump(xaddraw);
	printf("\n");
	gcry_mpi_dump(yaddraw);
	printf("\n");
	
	gcry_mpi_t xaddapi = gcry_mpi_new(0);
	gcry_mpi_t yaddapi = gcry_mpi_new(0);
	
	gcry_mpi_ec_get_affine(xaddapi, yaddapi, rel_add, ctx);
	
	gcry_mpi_dump(xaddapi);
	printf("\n");
	gcry_mpi_dump(yaddapi);
	printf("\n");
	
	
	gcry_mpi_t x1 = gcry_mpi_new(0);
	gcry_mpi_t y1 = gcry_mpi_new(0);
	
	gcry_mpi_ec_get_affine(x1, y1, rel1, ctx);

	gcry_mpi_dump(x1);
	printf("\n");
	gcry_mpi_dump(y1);
	printf("\n");
	
	gcry_mpi_t x2 = gcry_mpi_new(0);
	gcry_mpi_t y2 = gcry_mpi_new(0);
	
	gcry_mpi_ec_get_affine(x2, y2, rel_sub, ctx);
	
	gcry_mpi_dump(x2);
	printf("\n");
	gcry_mpi_dump(y2);
	printf("\n");
	
}

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);
*/
}