/*
 * montgomeryOpt.c
 *
 *  Created on: Oct 16, 2019
 *      Author: r0666113
 */



#include "montgomeryOpt.h"
#include "asm_montgomeryOpt.h"


//Add C to t array, starting from element i.
void customAddOpt(uint32_t *t,uint32_t i, uint32_t C){
    uint64_t sum;
    while (C!= 0)
    {
        sum = ((uint64_t) t[i]) +  ((uint64_t) C);
        C = (uint32_t) (sum>>32);
        t[i] = (uint32_t) sum;
        i = i+1;
    }
}




void condSubtractOpt(uint32_t *n, uint32_t *res, uint32_t *t_prime, uint32_t size) {
    uint8_t i;
    uint32_t negative_carry = 0;
    for (i=0; i < size; i++) {
        res[i] = t_prime[i] - n[i] - negative_carry;
            if (t_prime[i] >= n[i]) {
                negative_carry = 0;
            } else {
                negative_carry = 1;
            }
        }
    if (negative_carry==1) { //b is greater than a
        for (i=0; i < size; i++) {
            res[i] = t_prime[i];
        }
    }
}

void customprintMontOpt(uint32_t *in, char *str, uint32_t size)	{
    int32_t i;

    xil_printf("0x");
    for (i = size-1; i >= 0 ; i--) {
    	xil_printf("%8x", in[i])	;
    }
    xil_printf("\n\r");
}

// Calculates res = a * b * r^(-1) mod n.
// a, b, n, n_prime represent operands of size elements
// res has (size+1) elements
void montMulOpt(uint32_t *a, uint32_t *b, uint32_t *n, uint32_t *n_prime, uint32_t *res, uint32_t size)
{
uint32_t i;
uint32_t c;
uint32_t j;
uint64_t z;
uint64_t sum;
uint32_t length = 2*size + 1;
uint32_t t[length];
uint32_t t_prime[size];
for(uint32_t k=0; k < length; k++){
	t[k] =0; // set elements of t to 0
}
//START_TIMING
for(i=0; i < size; i++){
		c=0;
		for(j=0; j < size; j++){
			sum    = ((uint64_t) t[i+j]) + ((uint64_t) a[j])*((uint64_t)b[i]) + ((uint64_t)c);
			c      = (uint32_t) (sum >> 32); //msb
			t[i+j] = (uint32_t) (sum); //lsb
		}
		t[i + size] = c;
}
//STOP_TIMING
/*for (i=0; i < 64; i++) {
	res[i] = t[i];
}*/

//customprintMont(t, "res", 32);
 //12 330
for (i=0; i<size; i++){ //358 per cycle total
	c = reduction(n, n_prime, t, i, size);
	//START_TIMING About 64 per loop so 2000 total
    customAddOpt(t,i+size,c);

}


	//Perform the shift result by copying t into res.
	for(uint32_t j=0; j<size+1; j++){
		t_prime[j] = t[j+size]; // Replaced res with t_prime, because res isn't final
			}

	condSubtractOpt(n, res, t_prime, size);
}