#include "rsa.h"

int *random_bits(int n) {
	int fd = open("/dev/urandom", O_RDONLY);
	ft_log(INFO, "fd");
	ft_log(INFO, ft_itoa(fd));
	int *random_bits = (int *)malloc(n >> 4);
	if (!random_bits) {
		ft_log(ERROR, "allocation failed on random_bits");
		exit(1);
	}
	ft_log(INFO, "before read");
	read(fd, random_bits, n >> 3, 0);
	ft_log(INFO, "after read");
	// set n bits to random values
	// for (int i = 0; i < n >> 5; i++) {
	//	random_bits[i] = rand();
	// }
	// set LSB and MSB to 1
	random_bits[0] |= 1;
	printf("last %ud\n", random_bits[(n / sizeof(int) >> 3) - 1]);
	random_bits[(n / sizeof(int) >> 3) - 1] |= 0x80000000;
	printf("last %ud\n", random_bits[(n / sizeof(int) >> 3) - 1]);
	return random_bits;
}

void bitshift_array(int *a, int len) {
	for (int n = 0; n < len - 1; n++) {
		a[n] = a[n] >> 1 | (a[n + 1] & 1) << 31;
	}
	a[len - 1] >>= 1;
}

int *generate_a(int *n) {
	int *a = (int *)malloc(RSA_SIZE_BYTES >> 1);
	memcpy(a, n, RSA_SIZE_BYTES >> 1);
	a[0] -= 1;
	int cursor = 0;
	// a = n - 2
	while (1) {
		a[cursor / 32] = a[cursor / 32] ^ (1 << (cursor % 32));
		if ((a[cursor / 32] >> (cursor % 32)) & 1 == 0)
			break;
		cursor++;
	}
}

int *large_mod(int *a, int *b) {
	int len = RSA_SIZE_BYTES / sizeof(int) >> 1;
	//for (int i = len - 1; i > -1; i--)
}

void generate_prime(int *n) {
	ft_log(INFO, "Generating random RSA_SIZE / 2 bits number");
	int *prime = random_bits(RSA_SIZE >> 1);
	ft_log(INFO, "After random_bits");
	printf("sizeof int : %d\n", sizeof(int));
	for (int i = ((RSA_SIZE_BYTES / sizeof(int)) >> 1) - 1; i > -1; i--) {
		printf("%ud\n", prime[i]);
	}
	int *d;
	int s = 0;
	ft_log(INFO, "Creating n - 1");
	d = (int *)malloc(RSA_SIZE_BYTES >> 1);
	memcpy(d, prime, RSA_SIZE_BYTES >> 1);
	// d = n - 1 (n's LSB is guarrenteed to be 1)
	d[0] -= 1;
	for (int i = (RSA_SIZE_BYTES / sizeof(int) >> 1) - 1; i > -1; i--) {
		printf("%ud\n", d[i]);
	}
	ft_log(INFO, "Factoriizing n - 1 as 2^s*d");
	while (!(d[0] & 1)) {
		s += 1;
		bitshift_array(d, RSA_SIZE_BYTES / sizeof(int) >> 1);
	}
	for (int k = 0; k < 128; k++) {
//		int *a = generate_a(prime);
	}
}

int *ft_phi(int *p, int *q) {
	return (int *)malloc(sizeof(int));
}

void generate_keys(int *p, int *q, int *e) {
	ft_log(INFO, "Generating primes...");
	p = 0;
	q = 0;
	e = 0;
	generate_prime(p);
	generate_prime(q);
	int *phi = ft_phi(p, q);
}