#include "http.h"

#include <assert.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>

static const char* EMPTY_STRING = "";

HTTPHeaderList* http_header_list_push(HTTPHeaderList* list, const char* key,
    const char* value)
{
    HTTPHeaderList* new = malloc(sizeof(HTTPHeaderList));
    if (!new) {
        return NULL;
    }
    new->key_length = strlen(key);
    new->key = malloc(new->key_length + 1);
    if (!new->key) {
        free(new);
        return NULL;
    }
    memcpy(new->key, key, new->key_length + 1);
    new->value_length = strlen(value);
    new->value = malloc(new->value_length + 1);
    if (!new->value) {
        free(new->key);
        free(new);
        return NULL;
    }
    memcpy(new->value, value, new->value_length + 1);
    new->next = list;
    return new;
}

void free_http_header_list(HTTPHeaderList* list)
{
    while (list) {
        HTTPHeaderList* next = list->next;
        free(list->key);
        free(list->value);
        free(list);
        list = next;
    }
}

const char* http_header_list_search(HTTPHeaderList* list, const char* key,
    const char* def)
{
    while (list) {
        if (strcmp(list->key, key) == 0) {
            return list->value;
        }
        list = list->next;
    }
    return def;
}

#define MAX_REQUEST_LENGTH 16384
#define MAX_METHOD_LENGTH 16
#define MAX_URI_LENGTH 256
#define MAX_VERSION_LENGTH 3
#define MAX_HEADER_KEY_LENGTH 2048
#define MAX_HEADER_VALUE_LENGTH 2048

#define RETURN_IF_READ_ERROR(s)  \
    if (ferror((s))) {           \
        return HRPR_READ_FAILED; \
    }

// if an error occured, req->uri is not allocated
static HTTPRequestParseResult parse_method_uri_line(FILE* stream,
    size_t* restrict bytes_read,
    HTTPRequest* restrict req)
{
    // allow for some leeway in passing incorrect methods
    char method[MAX_METHOD_LENGTH + 1];
    char uri[MAX_URI_LENGTH + 1];
    char version_str[MAX_VERSION_LENGTH + 1];
    char whitespace[4];
    ssize_t signed_bytes_read;
#define S1(s) #s
#define S(s) S1(s)
    int nconv = fscanf(
        stream,
        // clang-format off
        "%" S(MAX_METHOD_LENGTH) "[A-Z]"
        "%c"
        "%" S(MAX_URI_LENGTH) "[^ \n\r]"
        "%c"
        "HTTP/%" S(MAX_VERSION_LENGTH) "[0-9.]"
        "%c%c"
        "%zn",
        // clang-format on
        method, &whitespace[0], uri, &whitespace[1], version_str,
        &whitespace[2], &whitespace[3], &signed_bytes_read);
#undef S
    *bytes_read = signed_bytes_read;
    RETURN_IF_READ_ERROR(stream);
    if (nconv != 7 || memcmp(whitespace, "  \r\n", 4) != 0) {
        return HRPR_BAD_FORMAT;
    }
    req->method = strdup(method);
    if (!req->method) {
        return HRPR_NO_MEM;
    }
    req->uri = strdup(uri);
    if (!req->uri) {
        return HRPR_NO_MEM;
    }
    req->path = req->uri;
    while (*req->path == '/') {
        ++req->path;
    }
    return strcmp(version_str, "1.1") == 0 ? HRPR_OK : HRPR_BAD_VERSION;
}

// return true if there are more headers and no error occurred, false otherwise
// this will *not* free LIST if an error occurs
static bool next_header(FILE* stream, size_t* restrict bytes_read,
    HTTPRequestParseResult* restrict res,
    HTTPHeaderList* restrict* restrict list)
{
    char c = fgetc(stream);
    RETURN_IF_READ_ERROR(stream);
    if (c == '\r') {
        c = fgetc(stream);
        RETURN_IF_READ_ERROR(stream);
        if (c != '\n') {
            *res = HRPR_BAD_FORMAT;
            return false;
        }
        *bytes_read = 2;
        *res = HRPR_OK;
        return false;
    }
    ungetc(c, stream);
    char key[MAX_HEADER_KEY_LENGTH + 1];
    char value[MAX_HEADER_VALUE_LENGTH + 1];
    char whitespace[3];
    ssize_t signed_bytes_read;
#define S1(s) #s
#define S(s) S1(s)
    int nconv = fscanf(stream,
        // clang-format off
               "%" S(MAX_HEADER_KEY_LENGTH) "[a-zA-Z0-9.-]"
               ":%c"
               "%" S(MAX_HEADER_VALUE_LENGTH) "[ -~]"
               "%c%c"
               "%zn",
        // clang-format on
        key, &whitespace[0], value, &whitespace[1], &whitespace[2],
        &signed_bytes_read);
#undef S
    *bytes_read = signed_bytes_read;
    RETURN_IF_READ_ERROR(stream);
    if (nconv != 5 || memcmp(whitespace, " \r\n", 3) != 0) {
        return HRPR_BAD_FORMAT;
    }
    *list = http_header_list_push(*list, key, value);
    if (!*list) {
        *res = HRPR_NO_MEM;
        return false;
    }
    return true;
}

HTTPRequestParseResult parse_http_request(FILE* stream,
    HTTPRequest* restrict out)
{
    out->uri = EMPTY_STRING;
    out->path = EMPTY_STRING;
    out->method = EMPTY_STRING;
    size_t total_bytes;
    HTTPRequestParseResult res;
    if ((res = parse_method_uri_line(stream, &total_bytes, out)) != HRPR_OK) {
        return res;
    }
    out->headers = NULL;
    size_t bytes_read;
    while (next_header(stream, &bytes_read, &res, &out->headers)) {
        if ((total_bytes += bytes_read) > MAX_REQUEST_LENGTH) {
            res = HRPR_BAD_FORMAT;
            break;
        }
    }
    return res;
}

void free_http_request(HTTPRequest* restrict req)
{
    if (req->method != EMPTY_STRING) {
        free((char*)req->method);
    }
    if (req->uri != EMPTY_STRING) {
        free((char*)req->uri);
    }
    free_http_header_list(req->headers);
}

const char* status_code_to_message(int status, size_t* restrict length)
{
    static const struct {
        int code;
        const char* msg;
        size_t size;
    } CODES[] = {
#define P(s, m) { s, m, sizeof(m) - 1 }
        P(200, "OK"),
        P(201, "Created"),
        P(400, "Bad Request"),
        P(403, "Forbidden"),
        P(404, "Not Found"),
        P(500, "Internal Server Error"),
        P(501, "Not Implemented"),
        P(505, "Version Not Supported"),
#undef P
    };
    static const size_t NCODES = sizeof(CODES) / sizeof(CODES[0]);
    for (size_t i = 0; i < NCODES; ++i) {
        if (status == CODES[i].code) {
            if (length) {
                *length = CODES[i].size;
            }
            return CODES[i].msg;
        }
    }
    return NULL;
}

void format_http_response(FILE* stream, HTTPResponse* restrict resp)
{
    assert(status_code_to_message(resp->status, NULL));
    fprintf(stream, "HTTP/1.1 %d %s\r\n", resp->status,
        status_code_to_message(resp->status, NULL));
    fprintf(stream, "Content-Length: %zu\r\n", resp->body_length);
    for (HTTPHeaderList* h = resp->headers; h; h = h->next) {
        fwrite(h->key, 1, h->key_length, stream);
        fwrite(": ", 1, 2, stream);
        fwrite(h->value, 1, h->value_length, stream);
        fwrite("\r\n", 1, 2, stream);
    }
    fwrite("\r\n", 1, 2, stream);
}