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

#define CORRECT_ENDING 0
#define WRONG_INPUT -1
#define INCORRECT_FORMAT -2
#define TRUE 1
#define FALSE 0
#define NOT_FOUND -1

typedef char string_t[40];
typedef char accumulator_t[61];

typedef struct big_float
{
    string_t mant;
    long int pow;
    char _sgn;
} big_float_t;

int standartize_float(big_float_t * num)
{
    if (num->mant[28] >= '5' || (num->mant[29] > '5' && num->mant[28] == '4'))
        num->mant[27]++;

    for (int i = strlen(num->mant) - 1; i > 0 ; i--)
        num->mant[i + 1] = num->mant[i];
    for (int i = strlen(num->mant) - 1; i > 0 ; i--)
        num->mant[i + 1] = num->mant[i];

    num->mant[1] = '.';
    num->mant[0] = '0';

    num->pow += 28;

    if (num->pow > 99999 || num->pow < -99999)
        return INCORRECT_FORMAT;

    return CORRECT_ENDING;
}

void put_header(void)
{
    printf("This program is ment to perform division in long arithmetics.\n\n");
    printf("Enter two numbers in the following way:\n");
    printf(" 1           2                      3   4  \n");
    printf("(+-)-------------------------------(+-)-----\n\n");
    printf("Where:\n1 - sign of mantiss (unnecessary),\n2 - mantiss (<=30 symbols),\n");
    printf("3 - sign of power (unnecessary),\n4 - power (<=5 symbols).\n\n ");
}

int cmp(string_t num1, string_t num2)
{
    if (strlen(num1) > strlen(num2)) return 1;
    else if (strlen(num2) > strlen(num1)) return -1;
    else return strcmp(num1, num2);
}

void diff_big_float(string_t num1, string_t num2, string_t result)
{
    memset(result, '0', 40);
    result[strlen(num1)] = '\0';

    if (strlen(num2) < strlen(num1))
    {
        for(int i = strlen(num2) + 1; i > 0; i--)
            num2[i] = num2[i - 1];
        num2[0] = '0';
    }

    for(int i = strlen(num1) - 1; i >= 0; i--)
    {
        result[i] = num1[i] - num2[i] + '0';
        if (result[i] < '0')
        {
            result[i] += 10;
            (num1[i - 1])--;
        }
    }

    while (result[0] == '0' && strlen(result) > 1)
    {
        for (int i = 0; i < strlen(result) - 1; i++)
            result[i] = result[i + 1];
        result[strlen(result) - 1] = '\0';
    }

    while (num2[0] == '0' && strlen(num2) > 1)
    {
        for (int i = 0; i < strlen(num2) - 1; i++)
            num2[i] = num2[i + 1];
        num2[strlen(num2) - 1] = '\0';
    }
}

big_float_t create_big_float(string_t _mant, long int pow, char _sgn)
{
    big_float_t result;
    memset(result.mant, '0', 40);
    strcpy(result.mant, _mant);
    result.pow = pow;
    result._sgn = _sgn;

    return result;
}

big_float_t divide_big_float(big_float_t dividend, big_float_t divider)
{
    accumulator_t div_acc;
    big_float_t result;
    string_t buf;
    string_t temp;
    char * str_ptr;
    long int power;
    char _sgn;
    int i = 0;

    for (int i = 0; i < strlen(divider.mant) + 30; i++)
    {
        if (i < strlen(dividend.mant))
            div_acc[i] = dividend.mant[i];
        else
        {
            div_acc[i] = '0';
            dividend.pow--;
        }
   }

   strncpy(buf, div_acc, strlen(divider.mant));
   buf[strlen(divider.mant)] = '\0';
   str_ptr = (div_acc + strlen(divider.mant));
   memset(result.mant, '0', 40);

   while(*str_ptr != '\0')
   {
       while (buf[0] == '0')
       {
           for (int j = 0; j < strlen(buf) - 1; j++)
               buf[j] = buf[j + 1];
           buf[strlen(buf) - 1] = '\0';
           strncat(buf, str_ptr, 1);
           if (strcmp(str_ptr, "") == 0)
               break;
           str_ptr++;
           i++;
       }

       if (strcmp(str_ptr, "") == 0)
           break;

       while (cmp(buf, divider.mant) < 0)
       {
           strncat(buf, str_ptr, 1);
           str_ptr++;
       }

       while (cmp(buf, divider.mant) >=0)
       {
           diff_big_float(buf, divider.mant, temp);
           strcpy(buf, temp);
           result.mant[i]++;
       }
       i++;
   }

   result.mant[31] = '\0';
   power = dividend.pow - divider.pow;

   printf("%s", result.mant);

   _sgn = (dividend._sgn == divider._sgn) ? '+' : '-';
   result = create_big_float(result.mant, power, _sgn);

   return result;
}

void output_big_float(big_float_t result)
{
    printf("Sgn is %c\n", result._sgn);
    printf("Mantiss is %s\n", result.mant);
    printf("Power is %li\n", result.pow);
}

void normalize_mant(string_t mant, long int *pow)
{

    if (mant[0] == '+' || mant[0] == '-')
    {
        for (int i = 0; i < strlen(mant) - 1; i++)
            mant[i] = mant[i + 1];
        mant[strlen(mant) - 1] = '\0';
    }

   if (strchr(mant, '.'))
   {
       int delta;
       int _dotpos;


       for (int i = 0; i < strlen(mant); i++)
           if (mant[i] == '.')
           {
               _dotpos = i;
               break;
           }

       delta = strlen(mant) - _dotpos - 1;

       for (int i = _dotpos; i < strlen(mant) - 1; i++)
           mant[i] = mant[i + 1];
       mant[strlen(mant) - 1] = '\0';

       *pow -= delta;
   }

   while (mant[0] == '0' && strlen(mant) > 1)
   {
       for (int i = 0; i < strlen(mant) - 1; i++)
           mant[i] = mant[i + 1];
       mant[strlen(mant) - 1] = '\0';
   }
}

int process_raw_string(string_t string, big_float_t * res)
{
    char _is_exp;
    char _sgn;
    int dot_cnt = 0;
    long int pow_num = 1;
    int ecnt_ = 0;
    int sgn_cnt = 0;
    int num_cnt = 0;
    string_t power;
    string_t mnts_;

    _sgn = (string[0] == '-') ? '-' : '+';
    _is_exp = (strchr(string, 'E')) ? TRUE : FALSE;


    for (int i = 0; i < strlen(string); i++)
    {
        if (string[i] == 'E') ecnt_++;

        else if (string[i] == '.') dot_cnt++;
        else if (string[i] == '+' || string[i] == '-')
        {
            sgn_cnt++;
            if (i != 0 && string[i - 1] != 'E')
                return INCORRECT_FORMAT;
        }

        else if (string[i] < '0' || string[i] > '9')
            return INCORRECT_FORMAT;
    }

    if (ecnt_ > 1 || dot_cnt > 1 || sgn_cnt > 2) return INCORRECT_FORMAT;
    if (strpbrk(string, "E.") != NULL && dot_cnt == 1)
        if (*strpbrk(string, "E.") == 'E')
            return INCORRECT_FORMAT;

    if (_is_exp)
    {
        strcpy(power, strchr(string, 'E') + 1);
        strtok(string, "E");
        strcpy(mnts_, string);

        if (strcmp(power, "0") == 0) pow_num = 0;
        else pow_num = atol(power);

        if (pow_num < -99999 || pow_num > 99999)
            return INCORRECT_FORMAT;
    }

    else strcpy(mnts_, string);

    for (int i = 0; i < strlen(mnts_); i++)
        if (string[i] >= '0' && string[i] <= '9') num_cnt++;

    if (!num_cnt) return INCORRECT_FORMAT;

    normalize_mant(mnts_, &pow_num);
    (*res) = create_big_float(mnts_, pow_num, _sgn);

    return CORRECT_ENDING;
}

int main()
{
    string_t string1, string2;
    big_float_t num1, num2, result;
    int rc;

    put_header();

    printf("Enter first number:\n");
    scanf("%s", string1);

    printf("Enter second number:\n");
    scanf("%s", string2);

    rc = process_raw_string(string1, &num1);
    if (rc)
    {
        printf("Incorrect data.\n");
        return INCORRECT_FORMAT;
    }

    rc = process_raw_string(string2, &num2);
    if (rc)
    {
        printf("Incorrect data.\n");
        return INCORRECT_FORMAT;
    }

    result = divide_big_float(num1, num2);
    if (standartize_float(&result) != CORRECT_ENDING)
        return INCORRECT_FORMAT;

    output_big_float(result);
    return CORRECT_ENDING;
}