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

#define ERROR_CODE -1
#define RIGHT 0
#define INPUT_OK 1
#define ALLOWED_INPUT_SIZE 38
#define SIGN_QUANTITY_LIMIT 2
#define DEGREE_LIMIT 1
#define DOT_LIMIT 1
#define POSITIVE_NUMBER 1
#define NEGATIVE_NUMBER -1
#define TRUE 1
#define FALSE 0

/*1)Смоделировать операцию деления действительного числа
на действительное число в форме (+,-)m.n Е (+,-)K, где
суммарная длина мантиссы (m+n) - до 30 значащих цифр, а
величина порядка K - до 5 цифр. Результат выдать в форме
 (+,-)0.m1 Е (+,-)K1, где m1 - до 30 значащих цифр, а K1 - до 5
цифр.
 *
 * */

typedef struct // структура для хранения чисел в проавильном формате
{
    int size; // размер числа
    int digits[ALLOWED_INPUT_SIZE]; // Число
    int E; // порядок числа (значение после Е)
    int sign;
} big_decimal;

void welcome_text()
{
    printf("Data entry begins strictly with the sign of the number(+ or -) \n"
           "If there is degree in number, then the sign of degree (+ or"
           " -) is also indicated strictly after E \n"
           "If you enter E, there should be no spaces between numbers and E \n"
           "The number entered must not exceed 30 characters \n"
           "The size of the input degree must not exceed 5 characters \n"
           "Real numbers must be entered through a dot \n"
           "                    ------------------------------\n");
}

void swap(int *xp, int *yp)/*Функция, меняющая местами числа*/
{
    int temp = *xp;
    *xp = *yp;
    *yp = temp;
}

/*Функция, убирающая нули сразу после точки*/
void remove_zero(int *digits, int *size, int *E)
{

    int i = 0;
    int size_remember = *size;

    /*Если встретился 0 в начале массива цифр, то смещаем его в конец*/
    /*С последующем уменьшением размера массива цифр*/
    while (digits[i] == 0)
    {
        for (int j = 0; j < (size_remember - 1); j++)
        {
            swap(&digits[j], &digits[j + 1]);
        }
        --*size;
    }

}

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 (index == arraySize)
    {
        return 1;
    }

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

void number_split(char *string, int *digits, int *size, int *E, int *sign)
{

    /*Переменная для исключения добавления лишнего нуля в массив цифр*/
    int useless_zero = FALSE;
    if (string[1] == '0' && (string[0] == '-' || string[0] == '+') && (string[2] == '.'))
    {
        useless_zero = TRUE;
    }

    /*Переменная для отрезания незначащих нулей в конце*/
    /*для исключения их добавления в массив цифр*/
    int size_to_delete = 0;
    int index = 0;

    /*Проверка знака перед числом*/
    if (string[0] == '-')
    {
        *sign = NEGATIVE_NUMBER;
    }
    else
    {
        *sign = POSITIVE_NUMBER;
    }

    int E_flag = FALSE;/*Переменная для проверки наличия Е в числе*/
    int sign_E = POSITIVE_NUMBER;/*Знак порядка*/
    /*Переменная запоминающая старый порядок перед нормализацией*/
    int old_E = 0;
    int point_flag = FALSE;/*Переменная для проверки наличия точки в числе*/

    /*Проверка наличия целой части*/
    while (index < strlen(string))
    {
        /*Встретилась ли точка при записи числа*/
        if (string[index] == '.')
        {
            point_flag = TRUE;
        }

        /*Встретилась ли E при записи числа*/
        if (string[index] == 'E')
        {
            if (string[index + 1] == '-')
            {
                sign_E = NEGATIVE_NUMBER;
            }

            E_flag = TRUE;
            int index_zero_check = index;

            /*Удаление незначащих нулей с конца*/
            while (string[index_zero_check - 1] == '0')
            {
                index_zero_check--;
                ++(*E);
                size_to_delete++;
            }
        }

        /*Проверка на наличие целой части числа*/
        if ((string[index] != '+') && (string[index] != '-') && (string[index] != '.') &&
            (string[index] != 'E') && (E_flag == FALSE))
        {
            /*Встретилась ли точка?Т.к. целой части нет, то порядок далее убывает*/
            if (point_flag == TRUE)
            {
                --(*E);
            }
            /*Перевод чисел из char в int*/
            digits[*size] = string[index] - '0';
            ++(*size);
        }

        /*Запись изначального порядка числа*/
        if (E_flag == TRUE)
        {
            if ((string[index] != 'E') && (string[index] != '+') && (string[index] != '-'))
            {
                /*Запись старого порядка числа*/
                old_E = old_E + (string[index] - '0');
                if (strlen(string) > index + 1)
                {
                    old_E = old_E * 10;
                }
            }
        }

        index++;

    }

    /*Корректировка размера массива цифр в соотв с наличием незначащих нулей*/
    *size = *size - size_to_delete;

    /*Смещение цифр в зависимости от наличия незначащего нуля в начале*/
    if (useless_zero == TRUE)
    {
        for (int j = 0; j < (*size - 1); j++)
        {
            swap(&digits[j], &digits[j + 1]);
        }
        --(*size);
    }

    /*Преобразование порядка с учетом знака Е*/
    old_E *= sign_E;
    /*Получение финального порядка числа*/
    *E = *E + old_E;
    remove_zero(digits, size, E);

}


char input_format_check(char *string)
{

    /*Массив допустимых символов*/
    char allowed_array[14] = "0123456789E+-.";
    int size = 0;
    int E_quantity_check = 0; /*Подсчет кол-ва встречаемого символа E*/
    int sign_quantity_check = 0;/*Подсчет кол-ва встречаемого символа знака*/
    int dot_quantity_check = 0;/*Подсчет кол-ва встречаемого символа точки*/

    /*Если число не начинается со знака,то ошибка*/
    if ((string[size] != '-') && (string[size] != '+'))
    {
        return ERROR_CODE;
    }

    /*Движение по строке до ее конца*/
    while (size != strlen(string))
    {
        /*Переменная для проверки корректности введенного сивола*/
        int check_correct_input = 0;

        for (int i = 0; i < 14; i++)
        {
            /*Входит ли введенный символ в список допустиых*/
            if (string[size] == allowed_array[i])
            {
                check_correct_input = 1;
            }
        }

        if (string[size] == 'E')
        {
            /*Проверка обязательного знака после E*/
            if ((string[size + 1] != '-') && (string[size + 1] != '+'))
            {

                /*Проверка введен ли порядок после E*/
                if ((string[size + 2] != '0') && (string[size + 2] != '1')
                    && (string[size + 2] != '2') && (string[size + 2] != '3')
                    && (string[size + 2] != '4') && (string[size + 2] != '5')
                    && (string[size + 2] != '6') && (string[size + 2] != '7')
                    && (string[size + 2] != '8') && (string[size + 2] != '9'))
                {
                    return ERROR_CODE;
                }

            }

            E_quantity_check++;

        }
        if (string[size] == '-' || string[size] == '+')
        {

            /*Проверка знака на первой позиции*/
            if ((size != 0))
            {

                /*Проверка знака после E*/
                if (string[size - 1] != 'E')
                {
                    return ERROR_CODE;
                }

            }

            if (string[size + 1] == 'E')
            {
                return ERROR_CODE;
            }

            sign_quantity_check++;

        }

        if (string[size] == '.')
        {

            /*Исключение чисел с запятой в порядке*/
            if (E_quantity_check == DEGREE_LIMIT)
            {
                return ERROR_CODE;
            }

            dot_quantity_check++;

        }

        /*Проверка допустимого количества элементов*/
        if ((check_correct_input != 1) || (sign_quantity_check > SIGN_QUANTITY_LIMIT) \
 || (E_quantity_check > DEGREE_LIMIT) || (dot_quantity_check > DOT_LIMIT))
        {
            return ERROR_CODE;
        }

        /*Переход к следующему символу строки*/
        size++;

    }

    return RIGHT;

}


int input_function(char *input)
{

    if (scanf("%100s", input) != INPUT_OK)
    {
        return ERROR_CODE;
    }

    /*Проверка длинны введенного чилса*/
    if (strlen(input) > ALLOWED_INPUT_SIZE)
    {
        printf("Input size exceeded");
        return ERROR_CODE;
    }

    /*Проверка корректности введенного формата числа*/
    if (input_format_check(input) != RIGHT)
    {
        printf("Invalid input format");
        return ERROR_CODE;
    }

    return RIGHT;

}


int main()
{

    welcome_text();/*Правила ввода текста в консоли*/

    char input[ALLOWED_INPUT_SIZE];/*Строка ввода первого числа*/
    char input2[ALLOWED_INPUT_SIZE];/*Строка второго  числа*/
    printf("Input first number:");

    /*Проверка правильного формата первого числа*/
    if (input_function(input) == ERROR_CODE)
    {
        return ERROR_CODE;
    }

    printf("                     ------------------------------\n");
    printf("Input second number:");

    /*Проверка правильного формата второго числа*/
    if (input_function(input2) == ERROR_CODE)
    {
        return ERROR_CODE;
    }

    /* Переменные для нормализации вида числа*/
    int digits[ALLOWED_INPUT_SIZE]; /* Массив цифр первого числа */
    int sign = 1;/*Знак первого числа*/
    int size = 0;/*Размер массива цифр первого числа*/
    int E = 0; /*Порядок первого числа*/

    int digits2[ALLOWED_INPUT_SIZE];/* Массив цифр второго числа */
    int sign2 = 1;/*Знак второго числа*/
    int size2 = 0;/*Размер массива цифр второго числа*/
    int E2 = 0;/*Порядок второго числа*/

    number_split(input, digits, &size, &E, &sign);/*Нормализация первого числа*/

    for (int i = 0; i < size; i++)
    {
        printf("%d ", digits[i]);
    }
    printf("sign = %d, E = %d , size = %d \n", sign, E, size);

    number_split(input2, digits2, &size2, &E2, &sign2);/*Нормализация второго числа*/

    for (int i = 0; i < size2; i++)
    {
        printf("%d ", digits2[i]);
    }
    printf("sign = %d, E = %d , size = %d \n", sign2, E2, size2);

    /*Сборка всех данных в структуру*/
    big_decimal number_1;
    big_decimal number_2;

    number_1.sign = sign;
    number_1.E = E;
    number_1.size = size;
    for (int i = 0; i < number_1.size; i++)
    {
        number_1.digits[i] = digits[i];
    }

    number_2.sign = sign2;
    number_2.E = E2;
    number_2.size = size2;
    for (int i = 0; i < number_2.size; i++)
    {
        number_2.digits[i] = digits2[i];
    }

    int divRes[number_1.size];
    for (int i = 0; i < number_1.size;i++)
    {
        divRes[i] = 0;
    }
    divide(number_1.digits, number_2.digits, number_1.size, divRes);
    printArrayResult(divRes, number_1.size);

    return RIGHT;
}