//
// Created by kubik on 12.05.2018.
// Edited by kubik on 18.07.2018.
//

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

#include "util.h"

int add(const char *, const char *, char **);

int validate(const char *number) {
    if (number == 0) return 2;
    int i;
    if (*number == '-' && *(number + 1) == '\0') {
        return 1;
    }
    if (*number != '-' && (*number < '0' || *number > '9')) {
        return 1;
    }
    for (i = 1; *(number + i) != '\0'; i++) {
        if (*(number + i) < '0' || *(number + i) > '9') {
            return 1;
        }
    }
    if (i == 0) {
        return 1;
    }
    return 0;
}

int compare(const char *number1, const char *number2) {
    printf("WITAMY %s i %s!\n", number1, number2);
    if (number1 == NULL || number2 == NULL) return 2;
    if (validate(number1) || validate(number2)) return 3;
    if (*number1 == '-' && *number2 != '-') return -1;
    if (*number1 != '-' && *number2 == '-') return 1;
    if (*number1 == '-') {
        number1++;
        number2++;
        const char *temp = number1;
        number1 = number2;
        number2 = temp;
    }
    if ((*number1 == '0' && *(number1 + 1) != '\0') || (*number2 == '0' && *(number2 + 1) != '\0')) return 3;
    if (length(number1) > length(number2)) {
        if (*number1 == '-') {
            return -1;
        } else {
            return 1;
        }
    }
    if (length(number1) < length(number2)) {
        if (*number1 == '-') {
            return 1;
        } else {
            return -1;
        }
    }
    size_t i;
    for (i = 0; i < length(number1); i++) {
        printf("BADANE: %c %c\n", *(number1 + i), *(number2 + i));
        if (*(number1 + i) > *(number2 + i)) {
            printf("1>2\n");
            if (*number1 == '-') {
                return -1;
            } else {
                printf("hejho\n");
                return 1;
            }
        }
        if (*(number1 + i) < *(number2 + i)) {
            printf("1<2\n");
            if (*number1 == '-') {
                return 1;
            } else {
                return -1;
            }
        }
    }
    return 0;

}

int subtract(const char *number1, const char *number2, char **result) {
    if (number1 == 0 || number2 == 0 || result == 0) return 1;
    if (validate(number1) || validate(number2)) return 2;
    if (*number1 == '-' && *number2 != '-') {
        char *arr = malloc(length(number1) + 2);
        clone(number1, arr);
        pull(arr);
        add(arr, number2, result);
        push(*result);
        **result = '-';
        free(arr);
        return 0;
    }
    if (*number1 != '-' && *number2 == '-') {
        char *arr = malloc(length(number2) + 2);
        clone(number2, arr);
        pull(arr);
        add(number1, arr, result);
        free(arr);
        return 0;
    }
    int m = 0;
    if (*number1 == '-' && *number2 == '-') {
        m = 1;
    }

    *result = malloc((length(number1) > length(number2) ? (length(number1)) : (length(number2))) + 2);
    if (*result == NULL) {
        return 3;
    }
    int s = 0;
    int i, l1 = length(number1) - 1, l2 = length(number2) - 1, c = (l1 < l2) ? (l1) : (l2);
    char *arr = malloc(sizeof(*arr) * (l1 + 2));
    if (arr == NULL) {
        free(*result);
        return 3;
    }
    char *arrt = malloc(sizeof(*arrt) * (l2 + 2));
    if (arrt == NULL) {
        free(arr);
        free(*result);
        return 3;
    }

    clone(number1, arr);
    clone(number2, arrt);
    if (m) {
        pull(arr);
        pull(arrt);
        c--;
    }
    char *temp;
    switch (compare(arr, arrt)) {
        case -1:
            temp = arr;
            arr = arrt;
            arrt = temp;
            i = l1;
            l1 = l2;
            l2 = i;
            if (m == 1) {
                m = 0;
            } else {
                m = 1;
            }
            break;
        case 0:
            free(arr);
            free(arrt);
            **result = '0';
            *(*result + 1) = '\0';
            return 0;
        default:
            break;
    }
    revert(arr);
    revert(arrt);
    for (i = 0; i <= c; i++) {
        char num = (char) (*(arr + i) - '0' - *(arrt + i) + '0' - s);
        s = 0;
        if (num < 0) {
            s = 1;
            num += 10;
        }
        *(*result + i) = (char) ('0' + num);
    }
    revert(*result);
    revert(*result);
    if (l1 == l2) {
        *(*result + i) = '\0';
        revert(*result);
    } else {
        int len;
        if (l1 > l2) {
            temp = arr;
            len = l1;
        } else {
            temp = arrt;
            len = l2;
        }
        for (i = c + 1; i <= len; i++) {
            char num = (char) (*(temp + i) - '0' - s);
            s = (num < 0) ? (1) : (0);
            if (num < 0) {
                num += 10;
            }
            *(*result + i) = (char) ('0' + num);
        }
        *(*result + i) = '\0';
        revert(*result);
    }
    free(arr);
    free(arrt);
    zero_delet(*result);
    workaround(*result);
    if (m) {
        if (**result != '-') {
            push(*result);
            **result = '-';
        }
    }
    return 0;
}


int add(const char *number1, const char *number2, char **result) {
    if (number1 == 0 || number2 == 0 || result == 0) return 1;
    if (validate(number1) || validate(number2)) return 2;
    if (*number1 == '-' && *number2 != '-') {
        char *arr = malloc(length(number1) + 2);
        if (arr == NULL) {
            return 3;
        }
        clone(number1, arr);
        pull(arr);
        subtract(number2, arr, result);
        free(arr);
        return 0;
    }
    if (*number1 != '-' && *number2 == '-') {
        char *arr = malloc(length(number2) + 2);
        if (arr == NULL) {
            return 3;
        }
        clone(number2, arr);
        pull(arr);
        subtract(number1, arr, result);
        free(arr);
        return 0;
    }
    int m = 0;
    if (*number1 == '-' && *number2 == '-') {
        m = 1;
    }
    int i, l1 = length(number1) - 1, l2 = length(number2) - 1, c = (l1 < l2) ? (l1) : (l2);
    char *arr = malloc(sizeof(*arr) * (l1 + 2));
    if (arr == NULL) {
        return 3;
    }
    char *arrt = malloc(sizeof(*arrt) * (l2 + 2));
    if (arrt == NULL) {
        free(arr);
        return 3;
    }
    clone(number1, arr);
    clone(number2, arrt);
    if (m) {
        pull(arr);
        pull(arrt);
        l1--;
        c--;
        l2--;
    }
    char s = 0;
    if (length(arr) == length(arrt) && (*(arr) - '0' + *(arrt) - '0' > 9)) s = 1;
    *result = malloc((length(number1) > length(number2) ? (length(number1)) : (length(number2))) + s + 3);
    if (*result == NULL) {
        free(arr);
        free(arrt);
        return 3;
    }
    s = 0;

    revert(arr);
    revert(arrt);
    for (i = 0; i <= c; i++) {
        char num = (char) (*(arr + i) - '0' + *(arrt + i) - '0' + s);
        *(*result + i) = (char) ('0' + num % 10);
        s = (char) (num / 10);
    }
    if (l1 == l2) {
        if (s == 1) {
            *(*result + i) = '1';
            *(*result + i + 1) = '\0';
        } else {
            *(*result + i) = '\0';
        }
        revert(*result);
    } else {
        char *temp;
        int len;
        if (l1 > l2) {
            temp = arr;
            len = l1;
        } else {
            temp = arrt;
            len = l2;
        }
        for (i = c + 1; i <= len; i++) {
            char num = (char) (*(temp + i) - '0' + s);
            *(*result + i) = (char) ('0' + num % 10);
            s = (char) (num / 10);
        }
        if (s == 1) {
            *(*result + i) = '1';
            *(*result + i + 1) = '\0';
        } else {
            *(*result + i) = '\0';
        }
        revert(*result);
    }
    free(arr);
//    arr = NULL;
    free(arrt);
//    arrt = NULL;
    if (m) {
        if (**result != '-') {
            push(*result);
            **result = '-';
        }
    }
    return 0;
}

int multiply(const char *number1, const char *number2, char **result) {
    char symbol = 0;
    if (*number1 == '-') {
        symbol++;
        number1++;
    }
    if (*number2 == '-') {
        symbol = (char) ((symbol + 1) % 2);
        number2++;
    }
    if (!strcmp(number2, "0") != 0) {
        *result = malloc(sizeof(char) * 2);
        if (*result == NULL) {
            return 3;
        }
        *result = "0";
        return 0;
    }
    if (!compare(number2, "1")) {
        *result = malloc(sizeof(char) * strlen(number1));
    }
    char switcher = 0;
    int ret;
    char *temp12 = NULL, *temp22 = NULL, *temp2 = malloc(strlen(number2) + 1), *temp1;
    if (temp2 == NULL) {
        return 3;
    }
    temp1 = malloc(strlen(number1) + 1);
    if (temp1 == NULL) {
        free(temp2);
        return 3;
    }
    strcpy(temp1, number1);
    strcpy(temp12, number2);

    while (1) {
        printf("sw: %d\n", switcher);
        if (!switcher) {
            printf("%s + %s", temp1, number1);
            ret = add(temp1, number1, &temp12);
            printf("dodawanko\n%d\n", ret);
            if (ret) {
                break;
            }
            free(temp1);
            switcher++;
            subtract(temp2, "1", &temp22);
            free(temp2);
            printf("aaa\n");
            if (strcmp(temp22, "0") != 0) {
                break;
            }
            printf("eee\n");
        } else {
            ret = add(temp12, number1, &temp1);
            if (ret) {
                break;
            }
            free(temp12);
            switcher--;
            subtract(temp22, "1", &temp2);
            free(temp22);
            if (strcmp(temp2, "0") != 0) {
                break;
            }
        }
    }
    if (ret) {
        if (switcher) {
            free(temp12);
            free(temp2);
        } else {
            free(temp1);
            free(temp22);
        }
        free(temp2);
    }
    if (switcher) {
        strcpy(*result, temp12);
        free(temp12);
        free(temp2);
    } else {
        strcpy(*result, temp1);
        free(temp1);
        free(temp22);
    }
    if (symbol) {
        char *temp = malloc(strlen(*result) + 2);
        strcpy(temp, *result);
        free(*result);
        push(temp);
        *temp = '-';
        *result = temp;
    }
    return 0;


}

int main(void) {
    char *arr = malloc(201), *arrt = malloc(201), *result = NULL;
    if (arr == NULL || arrt == NULL) {
        if (arr != NULL) {
            free(arr);
        }
        if (arrt != NULL) {
            free(arrt);
        }
        printf("Failed to allocate memory");
        return 2;
    }
    printf("Podaj pierwsza liczbe:\n");
    scanf("%200s", arr);
    char c;
    while ((c = (char) getchar()) != '\n' && c != EOF);
    beksleszendelet(arr);
    printf("Podaj druga liczbe:\n");
    fgets(arrt, 201, stdin);
    beksleszendelet(arrt);
    int ret = multiply(arr, arrt, &result);
    if (ret == 3) {
        free(arr);
        free(arrt);
        printf("failed to allocate memory");
        return 2;
    }
    if (ret) {
        printf("error");
        free(arr);
        free(arrt);
        if (result != NULL) {
            free(result);
        }
        return 1;
    }
    printf("%s\n", result);
    free(result);
    /*   ret = subtract(arr, arrt, &result);
       if (ret == 3) {
           free(arr);
           free(arrt);
           printf("failed to allocate memory");
           return 2;
       }
       if (ret) {
           printf("error");
           free(arr);
           free(arrt);
           if (result != NULL) {
               free(result);
           }
           return 1;
       }
       printf("%s", result);
       free(arr);
       free(arrt);
       free(result);*/
    return 0;
}