#include <stdlib.h>
#include <sys/mman.h>
#include <sys/stat.h>
#include <stdio.h>
#include <string.h>
#include <errno.h>
#include <ctype.h>

#define ARGS_NUM 4

typedef struct Field {
    const char *name;
    int is_found;
    char *value;
} Field;

void Field_show(const Field *field) {
    printf("Field: %s\nValue: ", field->name);
    if (field->is_found) {
        printf("%s\n", field->value);
    } else {
        printf("VALUE NOT FOUND\n");
    }
}

size_t how_many_includes(const char *source, const char *str) {
    size_t how_many = 0;
    const char *iterator = source;

    while ((iterator = strstr(iterator, str))) {
        iterator += strlen(str);
        ++how_many;
    }

    how_many -= 2;

    return how_many;
}
int main(int argc, const char **argv) {
    if (argc != 2) {
        //return 1;
    }

    const char *path_to_eml = argv[1];

    FILE *f = fopen(path_to_eml, "r");
    if (!f) {
        return 2;
    }

    struct stat st;
    if (fstat(fileno(f), &st) != 0) {
        printf("fstat failed: %s", strerror(errno));

        return 3;
    }

    const char *letter = mmap(
            NULL,
            st.st_size,
            PROT_READ,
            MAP_FILE | MAP_PRIVATE,
            fileno(f),
            0);

    if (letter == MAP_FAILED) {
        printf("mmap failed: %s", strerror(errno));

        return 4;
    }

    Field args_find[] = {
            {
                    .name = "from: ",
                    .is_found = 0
            },
            {
                    .name = "to: ",
                    .is_found = 0
            },
            {
                    .name = "date: ",
                    .is_found = 0
            },
            {
                    .name = "boundary=",
                    .is_found = 0
            }
    };

    const char *title_end = letter + st.st_size;
    const char *title_ends[] = {"\n\n", "\n\r\n\r", "\r\n\r\n"};

    for (size_t i = 0; i < 3; ++i) {
        const char *temp = strstr(letter, title_ends[i]);
        if(temp != NULL && temp < title_end) {
            title_end = temp;
        }
    }

    char *lower_title = malloc(sizeof(char) * (title_end - letter + 1));
    for (size_t i = 0;  letter + i < title_end; ++i) {
        lower_title[i] = (char)tolower(letter[i]);
    }
    lower_title[title_end - letter] = '\0';

    for (size_t i = 0; i < ARGS_NUM; ++i) {
        const char *arg_begin = strstr(lower_title, args_find[i].name);

        if (i < 3) {
            while (arg_begin != NULL && arg_begin > lower_title && *(arg_begin - 1) != '\n' && *(arg_begin - 1) != '\r') {
                arg_begin = strstr(arg_begin + 1, args_find[i].name);
            }
        }

        if(arg_begin != NULL) {
            arg_begin = letter + (arg_begin - lower_title);
        }

        if (!arg_begin) {
            //printf("\"%s\" search failed.\n", args_find[i].name);

            continue;
        }

        arg_begin += strlen(args_find[i].name);
        if ((i == 3 && *arg_begin == '\"')|| *arg_begin == ' ') {
            ++arg_begin;
        }

        const char *arg_end = arg_begin;
        while (*arg_end != '\n' && *arg_end != '\r' && *arg_end != ';') {
            if (i == 3 && *arg_end == '\"') {
                break;
            }
            ++arg_end;
        }


        // printf("|\n");

        size_t arg_size = arg_end - arg_begin;

        args_find[i].value = malloc(sizeof(char) * arg_size + 1);  // TODO(Tony_Sysoev): make a mem_alloc check
        strncpy(args_find[i].value , arg_begin, arg_size);         // ...and other checks
        args_find[i].value[arg_size] = '\0';

        args_find[i].is_found = 1;
    }

    for (size_t i = 0; i < ARGS_NUM - 1; ++i) {
        if(args_find[i].is_found) {
            printf("%s",args_find[i].value);
        }

        printf("|");
    }

    size_t parts = 0;
    if (args_find[3].is_found) {
        parts += how_many_includes(letter, args_find[3].value);
    } else {    // FIX
        const char *iterator = title_end;
        while(iterator != '\0') {
            ++iterator;
            if (*iterator != '\n' && *iterator != '\r') {
                parts = 1;

                break;
            }
        }
    }       // ENDFIX
    printf("%zu", parts);

    for (size_t i = 0; i < ARGS_NUM; ++i) {
        if (args_find[i].is_found) {
            free(args_find[i].value);
        }
    }

    free(lower_title);

    munmap((void *)letter, st.st_size);

    fclose(f);

    return 0;
}