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

#define ERROR_CODE -1
#define ZERO_WARNING -2
#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
#define DIGITS_SIZE 32

struct BigDecimal/*Структура для хранения чисел*/
{

    int size;/*Размер числа*/
    int digits[DIGITS_SIZE];/*Цифры числа*/
    int E;/*Порядок числа*/
    int sign;/*Знак числа*/

};

/*1)Смоделировать операцию деления действительного числа
на действительное число в форме (+,-)m.n Е (+,-)K, где
суммарная длина мантиссы (m+n) - до 30 значащих цифр, а
величина порядка K - до 5 цифр. Результат выдать в форме
 (+,-)0.m1 Е (+,-)K1, где m1 - до 30 значащих цифр, а K1 - до 5
цифр.
 *
 *Программа разработана студентом ИУ7-33Б Ахметовым Каримом 2019г */
void welcome_text()
{
    printf("This program performs the operation of dividing real numbers \n"
           "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"
           "                    1             15             30\n"
           "                    |-------------|--------------|\n");
}

int E_limit_check(int E)
{
    if (abs(E) > 99999)
    {
        printf("Degree of E is over 5 characters!");
        return ERROR_CODE;
    }
    return RIGHT;
}

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

void printArrayResult(int *res, int *size, int *E)
{
    printf("0.");

    int i = *size - 1;
    while ((res[i] == 0) && (i > 0))
    {
        --(*size);
        /*++(*E);*/
        i--;
    }
    for (int j = 0; j < *size; j++)
    {
        printf("%d", res[j]);
    }
}

int printBigDecimal(struct BigDecimal val)
{
    if (val.sign < 0)
    {
        printf("-");
    }
    else
    {
        printf("+");
    }
    val.E = val.E + val.size;
    if (E_limit_check(val.E) == ERROR_CODE)
    {
        return ERROR_CODE;
    }
    printArrayResult(val.digits, &val.size, &val.E);

    if (val.E != 0)
    {
        printf("e");
    }
    if (val.E > 0)
    {
        printf("+");
    }
    if (val.E != 0)
    {
        printf("%d", val.E);
    }
    return RIGHT;
}

int compare(int *a, int *b, int size)
{
    /*Движение по разрядам до тех пор пока не будет однозначно определено
     * какое число больше */
    for (int i = 0; i < size; i++)
    {
        if (a[i] > b[i])
        {
            return 1;
        }
        else if (b[i] > a[i])
        {
            return -1;
        }
    }

    return RIGHT;
}

void minus(int *array1, int *array2, int size, int *returnArray)
{

    /*Алгоритм вычитания из делимого делителя*/
    for (int i = size - 1; i >= 0; i--)
    {

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

        int res = array1[i] - array2[i];
        returnArray[i] = res;
    }
}

void incrementResult(int *resultArray, int index)
{
    /*Увеличение значение разряда на 1*/
    resultArray[index]++;
    /*Если значение разряда превысело 9, то идет смещение разряда*/
    if (resultArray[index] >= 10)
    {
        /*Идет вызов рекурсии, пока не найдем куда прибавить единицу*/
        incrementResult(resultArray, index - 1);
        /*Если произошло смещение разряда,то вычитаем 10*/
        resultArray[index] -= 10;
    }
}

void shiftRight(int *array, int size, int shift)
{
    /*shift - это насколько происходит сдвиг массива*/
    /*Сдвиг массива идет засчет присваивания i элементу
     * значение (i-shift) элемента с конца, после сдвига самый
     * левый элемент становится равен 0*/
    for (int i = size - 1; i >= 0; i--)
    {
        int offset = i - shift;
        if (offset < size && offset >= 0)
        {
            array[i] = array[offset];
        }
        else
        {
            array[i] = 0;
        }
    }
}

void shiftLeft(int *array, int size, int shift)
{
    /*shift - это насколько происходит сдвиг массива*/
    /*Сдвиг массива идет засчет присваивания i элементу
     * значение (i+shift) элемента с начала, после сдвига самый
     * правый элемент становится равен 0*/
    for (int i = 0; i < size; i++)
    {
        int offset = i + shift;
        if (offset < size && offset >= 0)
        {
            array[i] = array[offset];
        }
        else
        {
            array[i] = 0;
        }
    }
}

int divide(int *array1, int *array2, int size, int *returnArray)
{
    int shiftsAmount = 0;/*Cколько раз произошел сдвиг числа*/
    int compareResult = 0;/*Результат сравнения двух чисел*/
    /*Цикл идет до момента равенства чисел*/
    do
    {
        /*Сравнение делимого и делителя*/
        compareResult = compare(array1, array2, size);
        /*Если делитель оказался больше*/
        if (compareResult < 0)
        {
            /*Смещение делителя вправо */
            shiftRight(array2, size, 1);
            /*Смещение результата влево*/
            shiftLeft(returnArray, size, 1);
            shiftsAmount++;
            continue;
        }
        /*Если все 30 разрядов мантиссы высчитаны*/
        if (returnArray[0] != 0)
        {
            return shiftsAmount * -1;
        }
        /*Далее следует алгоритм деления чисел как сколько
         * раз второе число входит в первое, следовательно
         * мы вычитаем пока возможно второе число из первого
         * и за каждое такое вычитание увеличиваем результат
         * деления на единицу*/
        incrementResult(returnArray, size - 1);
        minus(array1, array2, size, array1);

    }
    while (compareResult != 0);

    return shiftsAmount * -1;
}

struct BigDecimal normalize(struct BigDecimal decimal)
{

    struct BigDecimal res = {.sign = decimal.sign, .size = DIGITS_SIZE};

    int e = decimal.E;
    /*Превращение числа в 30 разрядное путем изменения порядка
     * и добавления нулей*/
    for (int i = 0; i < res.size; i++)
    {
        if (i < decimal.size)
        {
            res.digits[i] = decimal.digits[i];
        }
        else /*В else конструкцию попадаем при нехватке цифр до 30 разрядности числа*/
        {
            /*Добавляем в конец нули и изменяем порядок*/
            /*Т.е. идет смещение числа влево*/
            res.digits[i] = 0;
            e--;
        }
    }
    /*Запоминаем новый порядок числа*/
    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];
    }

    int finalSize = 30;

    /*Т.к. для округления 30ой цифры нам нужна 31 ая цифра, то изначальный
     * массив цифр был больше 30, поэтому далее мы приводим массив цифр к 30
     * с округлением, если понадобится 30ой цифры*/
    if (res.size > finalSize)
    {
        if (res.digits[finalSize] >= 5)
        {
            incrementResult(res.digits, finalSize - 1);
        }
        /*Узнаем знак экспоненты для дальнейшего действия*/
        int eSign = res.E / abs(res.E);
        /*Изменение экспоненты в соответтсвие со знаком*/
        if (eSign > 0)
        {
            res.E--;
        }
        else
        {
            res.E++;
        }

        res.size = finalSize;
    }

    return res;
}


struct BigDecimal floatingDivide(struct BigDecimal val1, struct BigDecimal val2)
{
    struct BigDecimal result = {
            .sign = val1.sign * val2.sign,/*Знак результата*/
            /*Размер чуть больше 30 для округления по 31-ой цифре*/
            .size = DIGITS_SIZE,
            /*Зануление всех цифр числа для избежания мусора в ячейках*/
            .digits = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
                       0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
                       0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}
    };

    /*Нормализация первого и второго числа*/
    struct BigDecimal normVal1 = normalize(val1);
    struct BigDecimal normVal2 = normalize(val2);

    int e = 0;
    e = divide(normVal1.digits, normVal2.digits, DIGITS_SIZE, result.digits);
    /*Вычисление финального порядка с учетом порядков чисел и кол-ва смещений*/
    result.E = normVal1.E - normVal2.E + e;

    struct BigDecimal denormResult = denormalize(result);

    return denormResult;
}

/*Функция, убирающая нули сразу после точки*/
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;
    }
}

int 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;
    if (E_limit_check(*E) == ERROR_CODE)
    {
        return ERROR_CODE;
    }
    /*Получение финального порядка числа*/
    *E = *E + old_E;
    remove_zero(digits, size, E);

    return RIGHT;
}

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 zero_check(char *string)
{
    if ((string[1] == '0') && (string[2] != '.'))
    {
        return ZERO_WARNING;
    }
    return RIGHT;
}

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

    char input[ALLOWED_INPUT_SIZE];/*Строка ввода первого числа*/
    char input2[ALLOWED_INPUT_SIZE];/*Строка второго  числа*/

    /* Переменные для нормализации вида числа*/
    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;/*Порядок второго числа*/

    printf("Input first number:");

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

    /* Если первое число равно 0, то результат деления равен 0 */
    if (zero_check(input) == ZERO_WARNING)
    {
        printf("0");
        return RIGHT;
    }

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

    struct BigDecimal number1;/*Cтруктура первого числа*/
    struct BigDecimal number2;/*Структура второго числа*/

    number1.sign = sign;/*Добавление в структуру знака числа*/
    number1.E = E;/*Добавление в структуру порядка числа*/
    number1.size = size;/*Добавление в структуру размера числа*/
    /*Добавление в структуру массива цифр числа*/
    if (size > 30)
    {
        printf("Mantissa is out of size");
        return ERROR_CODE;
    }
    for (int i = 0; i < size; i++)
    {
        number1.digits[i] = digits[i];
    }
    printf("\n");
    printf("                     1             15             30\n"
           "                     |-------------|--------------|\n");
    printf("Input second number:");

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

    /*Если второе число равно 0, то деление невозможно*/
    if (zero_check(input2) == ZERO_WARNING)
    {
        printf("Can't divide by zero!");
        return ERROR_CODE;
    }

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

    number2.sign = sign2;/*Добавление в структуру знака числа*/
    number2.E = E2;/*Добавление в структуру порядка числа*/
    number2.size = size2;/*Добавление в структуру размера числа*/
    /*Добавление в структуру массива цифр числа*/
    for (int i = 0; i < size2; i++)
    {
        number2.digits[i] = digits2[i];
    }
    if (size2 > 30)
    {
        printf("Invalid input format");
        return ERROR_CODE;
    }

    /*Создание структуры для результата*/
    struct BigDecimal result = floatingDivide(number1, number2);

    /*Проверка на превышение допустимого размера порядка числа*/
    if (E_limit_check(result.E) == ERROR_CODE)
    {
        return ERROR_CODE;
    }

    /*Вывод результата*/
    if (printBigDecimal(result) == ERROR_CODE)
    {
        return ERROR_CODE;
    }
    return RIGHT;
}