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

const int size = 30;
const int doubleSize = size * 2; // res should be twice bigger than input so we dont loose digits

struct BigDecimal {

    int size;
    int digits[doubleSize];
    int E;
    int sign;

};

void printArrayResult(int *res, int size) {
    for (int j = 0; j < size; j++) {
        printf("Element[%d] = %d\n", j, res[j]);
    }
}

void printNumber(int num) {
    printf("Number = %d\n", num);
}

int compare(int *a, int *b, int arraySize, int index) {

    int val1 = a[index];
    int val2 = b[index];

    if (val1 == val2) {
        return compare(a, b, arraySize, index + 1);
    }

    if (val1 > val2) {
        return 1;
    } else {
        return -1;
    }
}

void minus(int array1[], int array2[], int size, int returnArray[]) {

    int borrow = -1;

    for (int i = size - 1; i >= 0; i--) {

        if (array1[i] < array2[i]) {
            borrow = i - 1;
            array1[i] += 10;
        }

        int res = array1[i] - array2[i];
        if (borrow == i) {
            borrow = -1;
            res--;
        }
        returnArray[i] = res;
    }
}

void incrementResult(int resultArray[], int index) {

    resultArray[index]++;
    if (resultArray[index] >= 10) {
        incrementResult(resultArray, index - 1);
        resultArray[index] -= 10;
    }
}

void divide(int array1[], int array2[], int size, int returnArray[]) {

    int compareResult = 0;
    do {

        incrementResult(returnArray, size - 1);

        minus(array1, array2, size, array1);
        //printArrayResult(array1, size);
        compareResult = compare(array1, array2, size, 0);
      //  printNumber(compareResult);

    } while (compareResult > 0);

}

struct BigDecimal normalize(struct BigDecimal decimal, int shift) {

    struct BigDecimal res = {.sign = decimal.sign};
    res.size = doubleSize;

    int e = decimal.E;

    for (int i = 0; i < res.size; i++) {
        int offset = i - shift;
        if (offset < decimal.size && offset >= 0) {
            res.digits[i] = decimal.digits[offset];
        } else {
            res.digits[i] = 0;
            e--;
        }
    }
    e += shift;
    res.E = e;

    return res;
}

struct BigDecimal denormalize(struct BigDecimal decimal) {

    int leftZero = 0;
    int rightZero = 0;

    for (int i = 0; i < decimal.size; i++) {
        if (decimal.digits[i] == 0) {
            leftZero++;
        } else {
            break;
        }
    }

    for (int i = decimal.size - 1; i >= 0; i--) {
        if (decimal.digits[i] == 0) {
            rightZero++;
        } else {
            break;
        }
    }

    struct BigDecimal res = {
            .size = decimal.size - (leftZero + rightZero),
            .sign = decimal.sign,
            .E = decimal.E + rightZero
    };

    for (int j = leftZero; j < decimal.size - rightZero; ++j) {
        res.digits[j - leftZero] = decimal.digits[j];
    }

    return res;
}


struct BigDecimal floatingDivide(struct BigDecimal val1, struct BigDecimal val2) {

    struct BigDecimal result = {
            .sign = val1.sign * val2.sign,
            .size = doubleSize
    };

    struct BigDecimal normVal1 = normalize(val1, 0);
    struct BigDecimal normVal2 = normalize(val2, 1);

    result.E = normVal1.E - normVal2.E;
    divide(normVal1.digits, normVal2.digits, doubleSize, result.digits);

    struct BigDecimal denormResult = denormalize(result);

    return denormResult;
}

int main() {

    struct BigDecimal number1 = {
            .size = 5,
            .E = 0,
            .sign = 1,
            .digits = {0, 4, 5, 0, 0}
    };

    struct BigDecimal number2 = {
            .size = 1,
            .E = 0,
            .sign = 1,
            .digits = {5}
    };

    struct BigDecimal number3 = floatingDivide(number1, number2);
    printNumber(number3.E);
    printArrayResult(number3.digits, number3.size);

}