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

#define BUFFER_SIZE 10128


char *get_content(int );
char *get_sample(char*);
void count(char*, int*, int*);
void generate_categories(char ***, char *);
void completare(char***, int, char *);
void afisare(char ***data,int col, int row, FILE *out_file);


int main()
{
    int in_file = open("convertor.in", O_RDONLY);
    FILE *out_file = fopen("convertor.out", "w");
    char *everything;
    char *sample;
    char ***data;
    int col;
    int row;
    int i;

    row = 0;
    col = 0;

    everything = get_content(in_file);
    count(everything, &col, &row);
    sample = get_sample(everything);

    data = (char***)malloc(col*sizeof(char**));
    for(i = 0; i < col; i++)
        data[i] = (char**)malloc((row+1) * sizeof(char*));


    generate_categories(data, sample);


    while(sample != NULL) {
        completare(data, col, sample);
        sample = get_sample(everything);
    }

    afisare(data, col, row, out_file);

    fclose(out_file);
    close(in_file);
    return 0;
}


char *get_content(int in_file) {
    char *buffer;
    int end;
    int cbs;
    int bytes_read;

    buffer = (char*)malloc(BUFFER_SIZE * sizeof(char));
    end = 0;
    cbs = 0;
    bytes_read = 0;

    while (!end) {
        bytes_read = read(in_file, buffer + cbs, BUFFER_SIZE);
        if(bytes_read < BUFFER_SIZE) {
            end = 1;
        } else {
            cbs += BUFFER_SIZE;
            buffer = (char*)realloc(buffer, cbs + BUFFER_SIZE);
        }
    }

    buffer[cbs+bytes_read - 1] = 0;
    return buffer;
}

char *get_sample(char *everything) {
    static int offset = 0;
    char *current = everything + offset;
    char *ptr1, *ptr2;
    int i;
    int balanced;

    ptr1 = NULL;
    balanced = 0;
    for(i = 0; i < strlen(current); i++) {
        if (current[i] == '}' && balanced == 1){
            ptr2 = current + i;
            break;
        }

        if(current[i] == '{') {
            ptr1 = current + i;
            balanced = 1;
        }
    }

    if (ptr1 == NULL)
        return NULL;

    *ptr2 = 0;
    offset += ptr2 - current + 1;
    return ptr1 + 1;
}


void count(char* everything, int *col, int *row) {
    int i;
    int size;
    int balance;

    balance = 0;
    size = strlen(everything);

    for(i = 0; i <size; i++) {
        if(everything[i] == '}') {
            (*row)++;
            balance = 1;
        }
        if(everything[i] == ':' && balance == 0)
            (*col)++;
    }
}

void generate_categories(char ***data, char *buffer) {
    int j, i;
    char *pct;
    char *ghi1, *ghi2, *nume;
    int contor;

    i = 0;
    while ((pct = strstr(buffer, ":")) != NULL){
        contor = 0;
        for(j = pct - buffer; j >= 0; j--) {
            if (buffer[j] == '"') {
                contor++;
                if(contor == 1)
                    ghi2 = buffer + j;
                else if(contor == 2)
                    ghi1 = buffer + j;
            }
            if (contor == 2){
                contor = ghi2 - ghi1 - 1;
                nume = (char*)calloc((contor + 1), sizeof(char));
                strncpy(nume, ghi1 + 1, contor);
                data[i][0] = nume;
                i++;
                break;
            }
        }
        buffer = pct + 1;
    }
}


void completare(char ***data, int col, char *buffer) {
    static level = 1;
    int i, j, k;
    char *pct;
    char *ghi1, *nume;
    int size = strlen(buffer);

    for(i = 0; i < col; i++) {

        pct = strstr(buffer, ":");
        for(j = 0 ;j < buffer + size - pct; j++) {

            if(pct[j] == '"') {
                ghi1 = pct + j;
                for (k = 1; k < buffer + size - pct; k++) {
                    if(ghi1[k] == '"') {
                        ghi1[k] = 0;
                        nume = ghi1 + 1;
                        data[i][level] = nume;
                        break;
                    }
                }
                break;
            } else if (pct[j] >= '0' && pct[j] <= '9' ) {
                ghi1 = pct + j;
                for (k = 1; k < buffer + size - pct; k++) {
                    if(ghi1[k] < '0' || ghi1[k] > '9') {
                        ghi1[k] = 0;
                        nume = ghi1;
                        data[i][level] = nume;
                        break;
                    }
                }
                break;
            }
        }
        buffer = ghi1 + k + 1;
    }
    level++;
}

void afisare(char ***data,int col,int row, FILE *out_file) {
    int i, j;
    for(i = 0; i <= row; i++){
        for(j = 0; j < col; j++)
            fprintf(out_file, "%s,", data[i][j]);
        fprintf(out_file, "\n");
    }
}