#include "stack.h"

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

enum ERROR
{
    INCORRECT_INPUT = 1,
    INCORRECT_EXPRESSION = 2,
    MEMORY_OVERFLOW = 3
};

const char* ERRORS[] =
{
    "",
    "Incorrect input",
    "Incorrect expression",
    "Failed to allocate memory",
};

char* read_token(FILE* fp, size_t size, char *ch, int *error_code)
{
    char* str = realloc(NULL, sizeof(char) * size);
    size_t len = 0;
    if (!str)
    {
        *error_code = 8;
        return NULL;
    }

    while ((*ch = getchar()) != '\n' && *ch != ' ' && *ch != EOF)
    {
        str[len++] = *ch;
        if (len == size)
        {
            char* last_block = str;
            str = realloc(str, sizeof(char) * (size += 16));
            if (!str)
            {
                free(last_block);
                *error_code = 8;
                return NULL;
            }
        }
    }
    str[len++] = 0;

    char *result = realloc(str, sizeof(char) * len);
    if (!result)
    {
        free(str);
        *error_code = 8;
        return NULL;
    }
    return result;
}

int consume_token(struct stack_t* stack, const char* token)
{
#define HANDLE_OPERATOR(_op_) do {                                          \
    if (!strcmp(token, #_op_)) {                                            \
            if (stack_size(stack) < 2) {                                    \
                    return INCORRECT_EXPRESSION;                            \
            }                                                               \
            double d1 = stack_pop(stack, NULL);                             \
            double d2 = stack_pop(stack, NULL);                             \
            switch(stack_push(stack, d2 _op_ d1))                           \
            {                                                               \
            case 0:                                                         \
                return 0;                                                   \
            case 2:                                                         \
                return MEMORY_OVERFLOW;                                     \
            }                                                               \
            return 0;                                                       \
    } } while (0)

    HANDLE_OPERATOR(+);
    HANDLE_OPERATOR(-);
    HANDLE_OPERATOR(/);
    HANDLE_OPERATOR(*);

    double d = strtod(token, NULL);
    size_t len = strlen(token);
    if (d == 0.0 && (!len || token[0] != '0')) {
        return INCORRECT_INPUT;
    }

    int stack_size_result = stack_size(stack);
    if (stack_push(stack, d)) {
        return MEMORY_OVERFLOW;
    }
    return 0;
#undef HANDLE_OPERATOR
}

int main(void)
{
    struct stack_t* stack = NULL;
    char* padding = malloc(sizeof(char) * 4);
    if (stack_init(&stack) == 2)
    {
        printf(ERRORS[MEMORY_OVERFLOW]);
        return 8;
    }
    free(padding);

    printf("Enter expression: ");
    char last_char = 0;
    char* token = NULL;
    int error_code = 0;
    while (token = read_token(stdin, 1, &last_char, &error_code))
    {
        if (error_code == 8)
        {
            printf(ERRORS[MEMORY_OVERFLOW]);
            return 8;
        }

        int err = consume_token(stack, token);
        switch (err)
        {
        case 3:
            printf(ERRORS[MEMORY_OVERFLOW]);
            return 8;
        case 2:
            printf(ERRORS[INCORRECT_EXPRESSION]);
            return INCORRECT_EXPRESSION;
        case 1:
            printf(ERRORS[INCORRECT_INPUT]);
            return INCORRECT_INPUT;
        }
        free(token);
        if (last_char == '\n')
        {
            break;
        }
    }

    if (error_code == 8)
    {
        printf(ERRORS[MEMORY_OVERFLOW]);
        return 8;
    }

    if (stack_size(stack) != 1)
    {
        printf(ERRORS[INCORRECT_EXPRESSION]);
        return INCORRECT_EXPRESSION;
    }
    printf("%f", stack_pop(stack, NULL));
    stack_destroy(&stack);
    return 0;
}