#include "kwil_deserialize.h"
#include "kwil_generate.h"
#include <string.h>

static
void generate_read_to_comma(FILE* file) {
    fprintf(file, "            while(*reader == ' ' || *reader == ':') { reader++; }\\\n"
                  "            writer = buffer;\\\n"
                  "            do {\\\n"
                  "                *writer = *reader;\\\n"
                  "                writer++; reader++;\\\n"
                  "            } while(*reader != ',' && *reader != '}');\\\n"
                  "            *writer = '\\0';\\\n");
}

static
void generate_read_name(FILE* file) {
    fprintf(file, "        while(*reader != '\"') { reader++; }\\\n"
                  "        reader++;\\\n"
                  "        writer = buffer;\\\n"
                  "        do {\\\n"
                  "            *writer = *reader;\\\n"
                  "            writer++; reader++;\\\n"
                  "        } while(*reader != '\"');\\\n"
                  "        *writer = '\\0';\\\n"
                  "        do {\\\n"
                  "            reader++;\\\n"
                  "        } while(*reader != ':');\\\n");
}

static
void generate_read_field(FILE* file, struct kwil_field_t* field) {
    fprintf(file, "if(strcmp(buffer, \"%s\") == 0) {\\\n", field->name_str);
    char prefix[48];
    switch(field->type_tag) {
        case KWIL_FIELD_CUSTOM:
            kwil_typename_to_prefix(field->type_str, prefix, 47);
            fprintf(file, "           while(*reader != '{' && *reader != '\"') { reader++; }\\\n"
                          "           dest.%s = %s_from_json(reader);\\\n", field->name_str, prefix);
            fprintf(file, "           counter = 0;\\\n"
                          "           do {\\\n"
                          "               if(*reader == '}') counter--;\\\n"
                          "               else if(*reader == '{') counter++;\\\n"
                          "               reader++;\\\n"
                          "           } while(counter > 0 || (counter == 0 && *reader != ','));\\\n"
                          "           if(*reader == '\\0') {\\\n"
                          "               reader--;\\\n"
                          "           } else {\\\n"
                          "               reader++;\\\n"
                          "           }\\\n");
            break;
        case KWIL_FIELD_FLOAT:
            generate_read_to_comma(file);
            fprintf(file, "            dest.%s = atof(buffer);\\\n", field->name_str);
            break;
        case KWIL_FIELD_INT:
        case KWIL_FIELD_UNSIGNED:
            generate_read_to_comma(file);
            fprintf(file, "            dest.%s = atoi(buffer);\\\n", field->name_str);
            break;
        case KWIL_FIELD_CHAR:
            generate_read_to_comma(file);
            if(field->array_dynamic) {
                fprintf(file, "            dest.%s = malloc(strlen(buffer)-1);\\\n"
                              "            dest.%s[0] = '\\0';\\\n", field->name_str, field->name_str);
            }
            if(field->array_length > 0 || field->array_dynamic) {
                fprintf(file, "            strncpy(dest.%s, buffer+1, strlen(buffer)-2);\\\n", field->name_str);
            }
            break;
    }

    fprintf(file, "        } else ");
}

int kwil_struct_generate_from_json(struct kwil_struct_t* self, const char* type_name, FILE* file) {
    char prefix[48];
    kwil_typename_to_prefix(type_name, prefix, 47);
    fprintf(file, "struct %s %s_from_json(const char* json) {\\\n"
                  "    struct %s dest;\\\n"
                  "    memset(&dest, 0x0, sizeof(struct %s));",
                  type_name, prefix, type_name, type_name);

    fprintf(file, "    const char* reader = json;\\\n"
                  "    char buffer[48];\\\n"
                  "    char* writer = buffer;\\\n"
                  "    buffer[47] = '\\0';\\\n"
                  "    int counter = 0;counter = counter;\\\n"
                  "    do {\\\n");

    generate_read_name(file);
    fprintf(file, "        ");
    for(int field = 0; field < self->fields_len; ++field) {
        generate_read_field(file, &self->fields[field]);
    }
    fprintf(file, "    {}\\\n");
    
    fprintf(file, "    } while(*reader != '}');\\\n");
    fprintf(file, "    return dest;\\\n"
                  "}\\\n");

    return 0;
}

int kwil_enum_generate_from_json(struct kwil_enum_t* self, const char* type_name, FILE* file) {
    char prefix[48];
    kwil_typename_to_prefix(type_name, prefix, 47);
    fprintf(file, "enum %s %s_from_json(const char* json) {\\\n",
            type_name, prefix);
    fprintf(file, "    ");
    for(int option = 0; option < self->enum_values_len; ++option) {
        fprintf(file, "if(strncmp(\"\\\"%s\\\"\", json, %zu) == 0) {\\\n"
                      "        return %s;\\\n"
                      "    } else ", self->enum_values[option].name, strlen(self->enum_values[option].name) + 1, self->enum_values[option].name);
    }
    fprintf(file, "    { return %s; }\\\n"
                  "}\\\n", self->enum_values[0].name);
    return 0;
}