#include <assert.h>          // assert
#include <errno.h>           // errno
#include <stddef.h>          // NULL, size_t
#include <stdio.h>           // fclose
#include <stdlib.h>          // calloc, free
#include <string.h>          // memcpy

#include "gemtext-parser.h"

int lineBufferInit(lineBuffer *lb) {
    char *buf = calloc(1, LBUF_SIZE);
    if (buf == NULL) return 2;
    lb->len = 0;
    lb->capacity = LBUF_SIZE;
    lb->buf = buf;
    lb->cursor = buf;
    return 0;
}

int gemtextParserInit(gemtextParser *parser, FILE *stream) {
    int ret = 0;

    parser->stream = stream;
    parser->nodeType = unset;
    parser->state = lineStart;
    parser->linkUrl = NULL;
    ret = lineBufferInit(&parser->buffer);
    return ret;
}

gemtextParser* gemtextParserNew(FILE *stream) {
    gemtextParser *parser = calloc(1, sizeof(gemtextParser));
    if (parser == NULL)
        return NULL;
    if (gemtextParserInit(parser, stream) != 0) {
        free(parser);
        return NULL;
    }
    return parser;
}

void gemtextParserDeinit(gemtextParser *parser) {
    fclose(parser->stream);
    free(parser->buffer.buf);
    if (parser->nodeType == linkNode && parser->linkUrl != NULL) {
        free(parser->linkUrl);
    } else if (parser->nodeType == preformattedNode && parser->altText != NULL) {
        free(parser->altText);
    }
}

void gemtextParserDestroy(gemtextParser *parser) {
    gemtextParserDeinit(parser);
    free(parser);
}

int gemtextNodeQueueInit(gemtextNodeQueue *nq) {
    int ret;

    nq->head = NULL;
    nq->tail = NULL;
    ret = pthread_mutex_init(&nq->mutex, NULL);
    if (ret != 0)
        return ret;
    return pthread_cond_init(&nq->cond, NULL);
}

void gemtextNodeQueuePush(gemtextNodeQueue *nq, gemtextNode *node) {
    pthread_mutex_lock(&nq->mutex);
    if (nq->tail == NULL) {
        nq->tail = nq->head = node;
    } else {
        node->next = nq->tail;
        nq->tail->prev = node;
        nq->tail = node;
    }
    nq->count++;
    pthread_mutex_unlock(&nq->mutex);
}

gemtextNode* gemtextNodeQueuePop(gemtextNodeQueue *nq) {
    gemtextNode *node;

    while (nq->count == 0)
        pthread_cond_wait(&nq->cond, &nq->mutex);
    pthread_mutex_lock(&nq->mutex);
    nq->count++;
    node = nq->head;
    if (node->nodeType == endOfStream)
        return node;
    if (nq->tail == nq->head) {
        nq->tail = nq->head = NULL;
    } else {
        nq->head = nq->head->prev;
    }
    pthread_mutex_unlock(&nq->mutex);
    node->prev = node->next = NULL;
    return node;
}

gemtextNode* gemtextNodeQueueTryPop(gemtextNodeQueue *nq) {
    gemtextNode *node;

    if (nq->count == 0)
        return NULL;
    pthread_mutex_lock(&nq->mutex);
    nq->count++;
    node = nq->head;
    if (node->nodeType == endOfStream)
        return node;
    if (nq->tail == nq->head) {
        nq->tail = nq->head = NULL;
    } else {
        nq->head = nq->head->prev;
    }
    pthread_mutex_unlock(&nq->mutex);
    node->prev = node->next = NULL;
    return node;
}

void gemtextNodeDeinit(gemtextNode *node) {
    switch (node->nodeType) {
    case linkNode:
        if (node->link->display != NULL) {
            free(node->link->display);
        }
        free(node->link->url);
        free(node->link);
        break;
    case preformattedNode:
        if (node->block->altText != NULL) {
            free(node->block->altText);
        }
        free(node->block->body);
        free(node->block);
        break;
    case endOfStream:
        break;
    default:
        free(node->str);
        break;
    }
    free(node);
}

int lineBufferExtend(lineBuffer *lb, size_t len) {
    char  *buf = calloc(1, lb->capacity + len);
    if (buf == NULL) return 2;
    memcpy(buf, lb->buf, lb->len);
    free(lb->buf);
    lb->buf = buf;
    lb->cursor = buf + lb->len;
    return 0;
}

int lineBufferAppendChar(lineBuffer *lb, char c) {
    int ret    = 0;

    if (lb->len >= lb->capacity - 1) {
        ret = lineBufferExtend(lb, LBUF_SIZE);
        if (ret != 0) return ret;
    }
    *lb->cursor = c;
    lb->cursor++;
    lb->len++;
    return ret;
}

void lineBufferAppendCharUnchecked(lineBuffer *lb, char c) {
    *lb->cursor = c;
    lb->cursor++;
    lb->len++;
}

int lineBufferAppendString(lineBuffer *lb, char *c, size_t len) {
    int    ret = 0, i = 0;
    size_t rem = 0;

    // Find the remaining length
    rem = lb->capacity - lb->len;
    // if the length won't fit our string, extend the buffer.
    // We do len - rem + LBUF_SIZE for a safety margin
    if (rem < len) {
        ret = lineBufferExtend(lb, len - rem + LBUF_SIZE);
        if (ret != 0) return ret;
    }

    for (i = 0; i < len; i++) {
        // We use 'unchecked' because we did our checks above
        lineBufferAppendCharUnchecked(lb, *c);
        c++;
    }
    return ret;
}

void lineBufferRewind(lineBuffer *lb) {
    lb->len--;
    lb->cursor--;
}

void lineBufferReset(lineBuffer *lb) {
    lb->len = 0;
    lb->cursor = lb->buf;
}

int gemtextParserSendPreformatted(gemtextParser *parser, gemtextNodeQueue *nq) {
    preformattedBlock *block;
    gemtextNode       *node;
    char              *buf;

    node = calloc(1, sizeof(gemtextNode));
    if (node == NULL) return errno;
    node->nodeType = preformattedNode;
    block = calloc(1, sizeof(preformattedBlock));
    if (block == NULL) return errno;
    // back up our cursor four spaces and insert a lf char
    parser->buffer.cursor -= 4;
    parser->buffer.len -= 4;
    lineBufferAppendCharUnchecked(&parser->buffer, '\n');
    buf = strndup(parser->buffer.buf, parser->buffer.len);
    if (buf == NULL) return errno;
    block->altText = parser->altText;
    parser->altText = NULL;
    block->body = buf;
    node->block = block;
    gemtextNodeQueuePush(nq, node);
    lineBufferReset(&parser->buffer);
    parser->state = lineStart;
    parser->nodeType = unset;
    return 0;
}

int gemtextParserSendLink(gemtextParser *parser, gemtextNodeQueue *nq) {
    gemtextLink *link;
    gemtextNode *node;
    char        *url = NULL, *display = NULL;

    link = calloc(1, sizeof(gemtextLink));
    if (link == NULL) return errno;
    link->display = link->url = NULL;
    node = calloc(1, sizeof(gemtextNode));
    if (node == NULL) {
        free(link);
        return errno;
    }
    if (parser->linkUrl == NULL) {
        url = strndup(parser->buffer.buf, parser->buffer.len - 1);
    } else {
        url = parser->linkUrl;
        display = strndup(parser->buffer.buf, parser->buffer.len);
        if (display == NULL) {
            free(link);
            free(node);
            return errno;
        }
    }
    link->url = url;
    link->display = display;
    node->nodeType = linkNode;
    node->link = link;
    gemtextNodeQueuePush(nq, node);
    lineBufferReset(&parser->buffer);
    parser->state = lineStart;
    parser->nodeType = unset;
    parser->linkUrl = NULL;
    return 0;
}

int gemtextParserSend(gemtextParser *parser, gemtextNodeQueue *nq) {
    gemtextNode *node;
    char        *buf;

    node = calloc(1, sizeof(gemtextNode));
    if (node == NULL) return errno;
    node->nodeType = parser->nodeType;
    buf = strndup(parser->buffer.buf, parser->buffer.len);
    if (buf == NULL) return errno;
    node->str = buf;
    gemtextNodeQueuePush(nq, node);
    lineBufferReset(&parser->buffer);
    parser->state = lineStart;
    parser->nodeType = unset;
    return 0;
}

void logParseError(int err) {
    //todo
}

void switchMode(gemtextParser *parser, gemtextNodeType node_type, char c) {
    lineBufferReset(&parser->buffer);
    switch (c) {
    case ' ':
    case '\t':
        parser->state = trimStart;
        break;
    default:
        lineBufferReset(&parser->buffer);
        lineBufferAppendCharUnchecked(&parser->buffer, c);
        parser->state = normalState;
    }
    parser->nodeType = node_type;
}

void enterPreformattedMode(gemtextParser *parser) {
    parser->nodeType = preformattedNode;
    parser->state = trimStart;
    lineBufferReset(&parser->buffer);
}

int parseLink(gemtextParser *parser, gemtextNodeQueue *lq, char c) {
    int   ret = 0;
    char *buf = NULL;

    assert(parser->nodeType == linkNode);
    switch (parser->state) {
   case lineStart:
        if (c != ' ' && c != '\t') {
            lineBufferReset(&parser->buffer);
            lineBufferAppendCharUnchecked(&parser->buffer, c);
            parser->state = normalState;
        } else if (c == '\n') {
            ret = gemtextParserSend(parser, lq);
        }
        break;
    case normalState:
        if (c == ' ' || c == '\t') {
            buf = strndup(parser->buffer.buf, parser->buffer.len - 1);
            if (buf == NULL) return errno;
            parser->linkUrl = buf;
            parser->state = linkDisplayStart;
            lineBufferReset(&parser->buffer);
        } else if (c == '\n') {
            buf = strndup(parser->buffer.buf, parser->buffer.len);
            if (buf == NULL) return errno;
            ret = gemtextParserSendLink(parser, lq);
        }
        break;
    case linkDisplayStart:
        if (c == ' ' || c == '\t') {
            lineBufferRewind(&parser->buffer);
        } else if (c == '\n') {
            ret = gemtextParserSendLink(parser, lq);
        } else {
            parser->state = linkDisplay;
        }
        break;
    case linkDisplay:
        if (c == '\n') {
            ret = gemtextParserSendLink(parser, lq);
        }
        break;
    default:
        ret = 1;
        break;
    }
    return ret;
}

int parsePreformatted(gemtextParser *parser, gemtextNodeQueue *lq, char c) {
    char *buf = NULL;

    assert(parser->nodeType == preformattedNode);
    switch (parser->state) {
    case trimStart:
        if (c == '\n') {
            lineBufferReset(&parser->buffer);
            parser->state = lineStart;
            parser->altText = NULL;
        } else if (c == ' ' || c == '\t') {
            lineBufferRewind(&parser->buffer);
        } else {
            parser->state = preformattedAlt;
        }
        break;
    case preformattedAlt:
        if (c == '\n') {
            parser->state = lineStart;
            if (parser->buffer.len > 0) {
                buf = strndup(parser->buffer.buf, parser->buffer.len - 1);
                if (buf == NULL) return errno;
                parser->altText = buf;
                lineBufferReset(&parser->buffer);
            }
        }
        break;
    case normalState:
        if (c == '\n') {
            parser->state = lineStart;
        }
        break;
    case lineStart:
        if (c == '\n') {
            parser->state = lineStart;
        } else if (c == '`') {
            parser->state = firstBacktickChar;
        } else {
            parser->state = normalState;
        }
        break;
    case firstBacktickChar:
        if (c == '`') {
            parser->state = secondBacktickChar;
        } else {
            parser->state = normalState;
        }
        break;
    case secondBacktickChar:
        if (c == '`') {
            parser->state = thirdBacktickChar;
        } else {
            parser->state = normalState;
        }
        break;
    case thirdBacktickChar:
        if (c == '\n') {
            gemtextParserSendPreformatted(parser, lq);
        } else {
            // We discard anything past the third backtick
            parser->buffer.cursor--;
            parser->buffer.len--;
        }
        break;
    default:
        return 1;
    }
    return 0;
}

int parseQuote(gemtextParser *parser, gemtextNodeQueue *lq, char c) {
    int ret = 0;

    switch (parser->state) {
    case lineStart:
        if (c == '>') {
            parser->state = trimStart;
            lineBufferRewind(&parser->buffer);
        } else {
            lineBufferRewind(&parser->buffer);
            ret = gemtextParserSend(parser, lq);
            if (ret) return ret;
            ret = fseek(parser->stream, -1, SEEK_CUR);
            if (ret) return ret;
            parser->state = lineStart;
            parser->nodeType = normalNode;
        }
        break;
    case normalState:
        if (c == '\n') {
            parser->state = lineStart;
        }
        break;
    case trimStart:
        if (c == ' ' || c == '\t') {
            // rewind and trim the whitespace
            parser->buffer.len--;
            parser->buffer.cursor--;
        } else if (c == '\n') {
            if (parser->buffer.len == 1) {
                parser->nodeType = normalNode;
            }
            ret = gemtextParserSend(parser, lq);
        } else {
            parser->state = normalState;
        }
        break;
    default:
        // Should be unreachable
        ret = 1;
        break;
    }
    return ret;
}

int parseGeneric(gemtextParser *parser, gemtextNodeQueue *nq, char c) {
    int ret = 0;

    switch (parser->state) {
    case lineStart:
    case trimStart:
        if (c == ' ' || c == '\t') {
            // rewind the cursor to trim the line start
            parser->buffer.len--;
            parser->buffer.cursor--;
        } else if (c == '\n') {
            ret = gemtextParserSend(parser, nq);
        } else {
            parser->state = normalState;
        }
        break;
    case normalState:
        if (c == '\n') {
            ret = gemtextParserSend(parser, nq);
        }
        break;
    default:
        // Should be unreachable
        ret = 1;
        break;
    }
    return ret;
}

int parseNormal(gemtextParser *parser, gemtextNodeQueue *nq, char c) {
    int ret;

    switch (parser->state) {
    case lineStart:
        switch (c) {
        case '=':
            parser->state = firstLinkChar;
            break;
        case '>':
            parser->nodeType = quoteNode;
            parser->state = trimStart;
            lineBufferRewind(&parser->buffer);
            break;
        case '*':
            parser->nodeType = listNode;
            parser->state = trimStart;
            lineBufferRewind(&parser->buffer);
            break;
        case '#':
            parser->state = firstHashChar;
            break;
        case '`':
            parser->state = firstBacktickChar;
            break;
        case '\n':
            parser->nodeType = normalNode;
            ret = gemtextParserSend(parser, nq);
            if (ret) return ret;
            break;
        default:
            break;
        }
        break;
    case firstLinkChar:
        if (c == '>') {
            parser->nodeType = linkNode;
            parser->state = lineStart;
        } else if (c == '\n') {
            parser->nodeType = normalNode;
            ret = gemtextParserSend(parser, nq);
            if (ret) return ret;
        } else {
            parser->state = normalState;
        }
        break;
    case firstHashChar:
        if (c == '#') {
            parser->state = secondHashChar;
        } else if (c == '\n') {
            parser->nodeType = normalNode;
            ret = gemtextParserSend(parser, nq);
            if (ret) return ret;
        } else {
            switchMode(parser, h1Node, c);
        }
        break;
    case secondHashChar:
        if (c == '#') {
            parser->nodeType = h3Node;
            parser->state = trimStart;
            lineBufferReset(&parser->buffer);
        } else if (c == '\n') {
            parser->nodeType = normalNode;
            ret = gemtextParserSend(parser, nq);
            if (ret) return ret;
        } else {
            switchMode(parser, h2Node, c);
        }
        break;
    case thirdHashChar:
        if (c == '\n') {
            parser->nodeType = normalNode;
            ret = gemtextParserSend(parser, nq);
            if (ret) return ret;
        } else {
            switchMode(parser, h3Node, c);
        }
        break;
    case firstBacktickChar:
        if (c == '\n') {
            parser->nodeType = normalNode;
            ret = gemtextParserSend(parser, nq);
            if (ret) return ret;
        } else if (c == '`') {
            parser->state = secondBacktickChar;
        } else {
            parser->state = normalState;
            parser->nodeType = normalNode;
        }
        break;
    case secondBacktickChar:
        if (c == '`') {
            enterPreformattedMode(parser);
        } else if (c == '\n') {
            parser->nodeType = normalNode;
            ret = gemtextParserSend(parser, nq);
            if (ret) return ret;
        } else {
            parser->state = normalState;
            parser->nodeType = normalNode;
        }
        break;
    default:
        break;
    }
    return 0;
}

int parseGemtext(gemtextParser *parser, gemtextNodeQueue *nq) {
    char         c;
    int          ret;
    gemtextNode *node;

    for (;;) {
        ret = fread(&c, 1, 1, parser->stream);
        if (ret == 1) {
            ret = lineBufferAppendChar(&parser->buffer, c);
            if (ret) {
                logParseError(ret);
                return ret;
            }
        } else {
            // If we were unable to read a char, assume we're at the end of the
            // stream and send the node to the queue
            if (parser->state != lineStart && parser->state != trimStart) {
                switch (parser->nodeType) {
                case preformattedNode:
                    ret = gemtextParserSendPreformatted(parser, nq);
                    break;
                case linkNode:
                    ret = gemtextParserSendLink(parser, nq);
                    break;
                default:
                    ret = gemtextParserSend(parser, nq);
                    break;
                }
                if (ret) return ret;
            }
            // Send an `endOfStream` node since we know we're done
            node = calloc(1, sizeof(gemtextNode));
            if (node == NULL) return errno;
            node->nodeType = endOfStream;
            node->prev = node->next = NULL;
            node->str = NULL;
            gemtextNodeQueuePush(nq, node);
            break;
        }
        switch (parser->nodeType) {
        case unset:
        case normalNode:
            ret = parseNormal(parser, nq, c);
            break;
        case preformattedNode:
            ret = parsePreformatted(parser, nq, c);
            break;
        case quoteNode:
            ret = parseQuote(parser, nq, c);
            break;
        case linkNode:
            ret = parseLink(parser, nq, c);
            break;
        default:
            ret = parseGeneric(parser, nq, c);
            break;
        }
        if (ret) {
            logParseError(ret);
            return ret;
        }
    }
    return 0;
}