#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
цифр.
 2)
 *
 * */
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 reverse_array(int *array, int size)
{
    for (int i = 0; i < size / 2; i++)
    {
        swap(&array[i], &array[size - i]);
    }
}

/*Функция, убирающая нули сразу после точки*/
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 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);
}
int number_comparsion(int *digits,int *digits2)
{
    for(int i = 0; digits[i]; i++)
    {
        if ((digits[i] - digits2[i]) < 0)
            return FALSE;
        if ((digits[i] - digits2[i]) > 0 )
            return TRUE;
    }
    return TRUE;
}
void divide_function(int *digits, int *E, int *size,
                     int *digits2, int *E2, int *size2,
                     int *digits_final, int *E_final, int *size_final)
{
    /*Массив А1 берет цифры слева из первого числа пока оно не будет делиться на второе*/
    int size_A1 = 0;
    int A1 = 0;
    int A1_digits[ALLOWED_INPUT_SIZE];
    int B = 0;
    while (size_A1 < *size2)
    {
        A1 = A1 * 10;
        A1 += digits[size_A1];
        A1_digits[size_A1] = digits[size_A1];
        B = B * 10;
        B += digits2[size_A1];
        size_A1++;
    }
    if (A1 < B)
    {
        A1 = A1 * 10;
        A1 += digits[size_A1];
    }
    int C = 0;
    while (C * B <= A1)
    {
        C++;
    }
    C--;
    digits_final[*size_final] = C;
    ++(*size_final);
    int CxB_array[ALLOWED_INPUT_SIZE];
    int CxB = C * B;
    int i = 0;
    while (CxB > 0)
    {
        CxB_array[i] = CxB % 10;
        CxB /= 10;
        i++;
    }
    printf("\n");
    reverse_array(CxB_array, i);
    i = 0;
    while (i < size_A1)
    {
        if (digits[i] - CxB_array[i] >= 0)
        {
            digits[i] = digits[i] - CxB_array[i];
        }
        else
        {
            digits[i - 1] = digits[i - 1] - 1;
            digits[i] = 10 - CxB_array[i] + digits[i];
        }
        i++;
    }
    if (number_comparsion(digits,digits2) == TRUE)
    {
        divide_function(digits, E, size, digits2, E2, size2, digits_final, E_final, size_final);
    }
    else
    {
        /*Работа с остатком числа*/
    }
}

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 \n", sign, E);
    number_split(input2, digits2, &size2, &E2, &sign2);/*Нормализация второго числа*/
    for (int i = 0; i < size2; i++)
    {
        printf("%d ", digits2[i]);
    }
    printf("sign = %d, E = %d \n", sign2, E2);
    int digits_final[ALLOWED_INPUT_SIZE];/* Массив цифр финального числа */
    int E_final = 0;/*Порядок финального числа*/
    int sign_final = 1;/*Знак финального числа*/
    int size_final = 0;/*Размер финального числа*/
    divide_function(digits, &E, &size, digits2, &E2, &size2, digits_final, &E_final, &size_final);
    for (int i = 0; i < size_final; i++)
    {
        printf("%d ", digits_final[i]);
    }
    return RIGHT;
}