#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <ctype.h>
#define NUM_MAX 10
#define EIL_MAX 20
#define INPUT_LIMIT 3
#define IN 1
#define OUT 0
/*

v10 versija

funkcijos:

1. skaitymas - nuskaito eilute ir tikrina ar ivestis tinkama veiksmams;
2. skaidymas - gauta veiksmu eilute, pagal salygas, skaido i kintamuosius ir operatorius;
3. matematika - atlieka matematinius veiksmus su suskaidytais kintamaisiais.

Naujoves v8:
Panaikina tarpus skaitymas funkcijoje

Naujoves v9: veiksmai su skliausteliais - jei skliaustelis pradzioje;

Naujoves v10: veiksmai su skliausteliais - jei skliaustelis ne pradzioje;

Tikslas v11:
-atlikti veiksma kai nera daugybos zeklo pries skliaustus t.y pvz 3*3*3(12+5), o ne 3*3*3*(12+5)
-jeigu ivedame eiilute daugiau nei 20 zenklu - stabdyti.
-kodel nepaima veiksmo (1*5)*(2*3*(2*3))+9. Suskaiciuoja ir nepaima 9 kaip number2 ???????????????????
*/

char * skaitymas();
char * skaidymas (char * veiksmu_eilute);
void matematika(char veiksmas, char * number1, char * number2, int * ptr);

int main()
{
    char * start = NULL;
    int input_count = 0;
    while (start == NULL)
    {
        start = skaidymas(skaitymas());
        input_count++;
        if (input_count == INPUT_LIMIT && start == NULL)
            return 0;
        if (start == NULL)
            printf("\nLIKO BANDYMU: %d\n", INPUT_LIMIT - input_count);
    }
    printf("----------------------\nRezultatas: %s\n", start);
    return 0;
}

char * skaitymas ()
{
    int i = 0;
    char * veiksmu_eilute = NULL;
    veiksmu_eilute = (char *) malloc(EIL_MAX*sizeof(char));
    fgets(veiksmu_eilute, EIL_MAX, stdin);

    //strlen(veiksmu_eilute)-1 - nes fgets paima ir \n ENTER chara. Su -1 mes pries ji perkeliam nuli;
    veiksmu_eilute[strlen(veiksmu_eilute)-1] = '\0';
    int not_space = 0;
    while (veiksmu_eilute[i] != '\0')
    {
        if (!isdigit(veiksmu_eilute[i]) && veiksmu_eilute[i] != 32 && veiksmu_eilute[i] != 43 && veiksmu_eilute[i] != 45 & veiksmu_eilute[i] != 47 &&
        veiksmu_eilute[i] != 42 && veiksmu_eilute[i] != 40 && veiksmu_eilute[i] != 41)
        {
            printf("\nKLAIDA: Bloga ivestis\nGalimi skaitmenys 0-9 ir operatoriai: + - * / ( )\n");
            return NULL;
        }
        // jeigu praleistas char yra ne tarpas, ji dedame indexe 'not_space'
        else if  (veiksmu_eilute[i] != ' ')
            veiksmu_eilute[not_space++] = veiksmu_eilute[i];
        i++;
    }
    veiksmu_eilute[not_space] = '\0';

    return veiksmu_eilute;
}

char * skaidymas (char * veiksmu_eilute)
{
    if (veiksmu_eilute == NULL)
        return NULL;
    char *number1 = NULL;
    number1 = (char *) malloc(NUM_MAX*sizeof(char));
//  char number2[NUM_MAX];

    // perdarau i pointeri, kadangi vykdant rekursija reik grazint i number2;
    char * number2 = NULL;
    number2 = (char *) malloc(NUM_MAX*sizeof(char));


    char skliaustas[NUM_MAX];
    memset(number1, 0, sizeof(number1));
    memset(number2, 0, sizeof(number2));
    int counter_a = 0;
    int counter_b = 0;
    int counter_c = 0;
    int counter_d = 0;
    int * counter_b_ptr = NULL;
    counter_b_ptr = &counter_b;
    char veiksmas = 0;

    for (counter_a = 0; counter_a < strlen(veiksmu_eilute); counter_a++)
    {
        //jeigu skliaustinis veiksmas yra pradzioje veiksmu_eilute
        if (veiksmu_eilute[counter_a] == '(' && number1[0] == '\0' && veiksmas == 0)
        {
            while(veiksmu_eilute[counter_a] != ')')
            {
                // jeigu nebus stringe ), gausime segmenta. Kad to nebutu, jeigu atsimusam i \0 iseinam is loopo
                if (veiksmu_eilute[counter_a] == '\0')
                    break;
                skliaustas[counter_d++] = veiksmu_eilute[++counter_a];
            }
        skliaustas[counter_d-1] = '\0';
        number1=skaidymas(skliaustas);
        counter_b = strlen(number1);
        //Isvalome skliausta ir counter_d;
        counter_d = 0;
        memset(skliaustas, 0, sizeof(skliaustas));

            // jeigu nebuvo uzdaromo skliausto ')' iki galo veiksmu_eilutes, - graziname number1
            if (veiksmu_eilute[counter_a] == '\0')
                return number1;
        }
        if (number1[0] != 0 && veiksmas != 0 && veiksmu_eilute[counter_a] == '(')
        {
            while(veiksmu_eilute[counter_a] != ')')
            {
                if(veiksmu_eilute[counter_a] == '\0')
                    break;
                skliaustas[counter_d++] = veiksmu_eilute[++counter_a];
            }
        skliaustas[counter_d-1] = '\0';
        number2=skaidymas(skliaustas);
        counter_c = strlen(number2);
        counter_d = 0;
        memset(skliaustas, 0, sizeof(skliaustas));
        }

        // number1 ir number2 uzpildyti, todel atlieku matematini veiksma
        if(!isdigit(veiksmu_eilute[counter_a]) && veiksmas != 0 && number1[0] != '\0' && number2[0] != '\0')
        {
            number1[counter_b] = '\0';
            number2[counter_c] = '\0';
            matematika(veiksmas, number1, number2, counter_b_ptr);
            // vietoje number2[0] = 0 naudoju memset, kadangi pilnai neisvalo
            memset(number2, 0, sizeof(number2));
            // veiksmas ne 0 (veiksmas=0), o naujas zenklas, kadangi ji skanuojam ateiciai;

            // jeigu turime zenkla ne ) - priskiriame ji veiksmui.
            if (veiksmu_eilute[counter_a] != ')')
            {

                veiksmas = veiksmu_eilute[counter_a];

            }
            // jeigu turime ) - dedame veiksma 0, kadangi jis netinka - ieskom kito zenklo. Kad ieskot kito zenklo, reik ji nunulint;
            else
                veiksmas = 0;

            counter_c = 0;
        }
        else if(isdigit(veiksmu_eilute[counter_a]) && veiksmas == 0)
        {
            number1[counter_b] = veiksmu_eilute[counter_a];
            counter_b++;
        }
        else if(!isdigit(veiksmu_eilute[counter_a]) && veiksmas == 0 && veiksmu_eilute[counter_a] != ')')
        {
            veiksmas = veiksmu_eilute[counter_a];
        }
        else if(isdigit(veiksmu_eilute[counter_a]) && veiksmas != 0)
        {
            number2[counter_c] = veiksmu_eilute[counter_a];
            counter_c++;
        }
        //jeigu visa veiksmu_eilute yra veiksmas skliaustuose, pvz, (2*2)
        else if (veiksmu_eilute[counter_a] == ')' && veiksmu_eilute[counter_a+1] == '\0')
            return number1;
    }
        matematika(veiksmas, number1, number2, counter_b_ptr);
    return number1;
}

void matematika(char veiksmas, char * number1, char * number2, int * ptr)
{
//  printf("Tikriname # %c # %s # %s\n", veiksmas, number1, number2);
    // paskutinis veiksmas gali gautis, jog number2 yra tuscias, todel tokiu atveju graziname number1.
    if (number2[0] == '\0')
        return;

    int atsakymas = 0;
    switch (veiksmas)
    {
        case '+':
        atsakymas = atoi(number1) + atoi(number2);
        break;
        case '-':
        atsakymas = atoi(number1) - atoi(number2);
        break;
        case '*':
        atsakymas = atoi(number1) * atoi(number2);
        break;
        // pataisyti su %, kad normaliai dalintu;
        case '/':
        atsakymas = atoi(number1) / atoi(number2);
        break;
    }
    // isvalome number1 elementus
    memset(number1, 0, sizeof(number1));
    sprintf(number1, "%d", atsakymas);
    // Po veiksmu reikalinga atnaujinti counter_b pozicija, kad zinoti, kur terminaitinti 'number_1' stringa;
    *ptr = strlen(number1);
}