/********** src/http.h **********/

/**
 * HTTP client extension for SQLite.
 *
 * https://github.com/oskaritimperi/sqlite-http-c
 *
 * MIT License
 *
 * Copyright (c) 2022 Oskari Timperi
 *
 * Permission is hereby granted, free of charge, to any person obtaining a copy
 * of this software and associated documentation files (the "Software"), to deal
 * in the Software without restriction, including without limitation the rights
 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 * copies of the Software, and to permit persons to whom the Software is
 * furnished to do so, subject to the following conditions:
 *
 * The above copyright notice and this permission notice shall be included in all
 * copies or substantial portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 * SOFTWARE.
 */

#ifndef HTTP_H
#define HTTP_H

#include "sqlite3ext.h"

typedef struct http_request http_request;
struct http_request {
    char* zMethod;
    char* zUrl;
    const void* pBody;
    sqlite3_int64 szBody;
    const char* zHeaders;
};

typedef struct http_response http_response;
struct http_response {
    void* pBody;
    sqlite3_int64 szBody;
    char* zHeaders;
    int szHeaders;
    int iStatusCode;
    char* zStatus;
};

int http_do_request(http_request* req, http_response* resp, char** ppErrMsg);

int http_next_header(const char* headers,
                     int size,
                     int* pParsed,
                     const char** ppName,
                     int* pNameSize,
                     const char** ppValue,
                     int* pValueSize);

void remove_all_but_last_headers(char* zHeaders);
void separate_status_and_headers(char** ppStatus, char* zHeaders);

#endif

/********** src/http.c **********/

#include "http.h"

SQLITE_EXTENSION_INIT1

#include <assert.h>
#include <ctype.h>
#include <string.h>

typedef struct http_vtab http_vtab;
struct http_vtab {
    sqlite3_vtab base;
    char* zMethod;
};

typedef struct http_cursor http_cursor;
struct http_cursor {
    sqlite3_vtab_cursor base;
    sqlite3_int64 iRowid;
    http_request req;
    http_response resp;
};

// If zHeaders contains headers for multiple responses, then this will strip
// headers from all but the last response.
void remove_all_but_last_headers(char* zHeaders) {
    int szHeaders = strlen(zHeaders);
    char* pLastTerminator = NULL;
    char* pSearch = zHeaders;

    for (;;) {
        char* p = strstr(pSearch, "\r\n\r\n");
        // If there isn't more terminators, we are done here
        if (!p) {
            break;
        }
        // If it's at the end of zHeaders, we are done here
        if (szHeaders - (p - zHeaders) == 4) {
            break;
        }
        pSearch = p + 4;
        pLastTerminator = p;
    }

    if (pLastTerminator) {
        pLastTerminator += 4;
        memmove(zHeaders, pLastTerminator, strlen(pLastTerminator) + 1);
    }
}

// Separate the status and header lines
void separate_status_and_headers(char** ppStatus, char* zHeaders) {
    char* cr = strchr(zHeaders, '\r');
    *ppStatus = sqlite3_mprintf("%.*s", cr - zHeaders, zHeaders);
    memmove(zHeaders, cr + 2, strlen(cr + 2) + 1);
}

static int httpConnect(sqlite3* db,
                       void* pAux,
                       int argc,
                       const char* const* argv,
                       sqlite3_vtab** ppVtab,
                       char** pzErr) {
    http_vtab* pNew;
    int rc;

    rc = sqlite3_declare_vtab(db,
                              "CREATE TABLE x(response_status TEXT, "
                              "response_status_code INT, response_headers TEXT, "
                              "response_body BLOB, request_method TEXT HIDDEN, "
                              "request_url TEXT HIDDEN, "
                              "request_headers TEXT HIDDEN, "
                              "request_body BLOB HIDDEN)");

#define HTTP_COL_RESPONSE_STATUS 0
#define HTTP_COL_RESPONSE_STATUS_CODE 1
#define HTTP_COL_RESPONSE_HEADERS 2
#define HTTP_COL_RESPONSE_BODY 3
#define HTTP_COL_REQUEST_METHOD 4
#define HTTP_COL_REQUEST_URL 5
#define HTTP_COL_REQUEST_HEADERS 6
#define HTTP_COL_REQUEST_BODY 7

    if (rc == SQLITE_OK) {
        pNew = sqlite3_malloc(sizeof(*pNew));
        *ppVtab = (sqlite3_vtab*)pNew;
        if (pNew == 0)
            return SQLITE_NOMEM;
        memset(pNew, 0, sizeof(*pNew));
        if (sqlite3_stricmp(argv[0], "http_get") == 0) {
            pNew->zMethod = sqlite3_mprintf("GET");
        } else if (sqlite3_stricmp(argv[0], "http_post") == 0) {
            pNew->zMethod = sqlite3_mprintf("POST");
        }
    }
    return rc;
}

static int httpDisconnect(sqlite3_vtab* pVtab) {
    http_vtab* p = (http_vtab*)pVtab;
    sqlite3_free(p->zMethod);
    sqlite3_free(p);
    return SQLITE_OK;
}

static int httpOpen(sqlite3_vtab* p, sqlite3_vtab_cursor** ppCursor) {
    http_cursor* pCur;
    http_vtab* pVtab = (http_vtab*)p;
    pCur = sqlite3_malloc(sizeof(*pCur));
    if (pCur == 0)
        return SQLITE_NOMEM;
    memset(pCur, 0, sizeof(*pCur));
    if (pVtab->zMethod) {
        pCur->req.zMethod = sqlite3_mprintf("%s", pVtab->zMethod);
    }
    *ppCursor = &pCur->base;
    return SQLITE_OK;
}

static int httpClose(sqlite3_vtab_cursor* cur) {
    http_cursor* pCur = (http_cursor*)cur;
    sqlite3_free(pCur->resp.pBody);
    sqlite3_free(pCur->req.zUrl);
    sqlite3_free(pCur->req.zMethod);
    sqlite3_free(pCur);
    return SQLITE_OK;
}

static int httpNext(sqlite3_vtab_cursor* cur) {
    http_cursor* pCur = (http_cursor*)cur;
    pCur->iRowid++;
    return SQLITE_OK;
}

static int httpColumn(sqlite3_vtab_cursor* cur, sqlite3_context* ctx, int i) {
    http_cursor* pCur = (http_cursor*)cur;

    switch (i) {
    case HTTP_COL_RESPONSE_STATUS:
        sqlite3_result_text(ctx, pCur->resp.zStatus, -1, SQLITE_TRANSIENT);
        break;

    case HTTP_COL_RESPONSE_STATUS_CODE:
        sqlite3_result_int(ctx, pCur->resp.iStatusCode);
        break;

    case HTTP_COL_RESPONSE_HEADERS:
        sqlite3_result_text(ctx, pCur->resp.zHeaders, -1, SQLITE_TRANSIENT);
        break;

    case HTTP_COL_RESPONSE_BODY:
        sqlite3_result_blob(ctx, pCur->resp.pBody, pCur->resp.szBody, SQLITE_TRANSIENT);
        break;

    case HTTP_COL_REQUEST_METHOD:
        sqlite3_result_text(ctx, pCur->req.zMethod, -1, SQLITE_TRANSIENT);
        break;

    case HTTP_COL_REQUEST_URL:
        sqlite3_result_text(ctx, pCur->req.zUrl, -1, SQLITE_TRANSIENT);
        break;

    case HTTP_COL_REQUEST_HEADERS:
        if (pCur->req.zHeaders) {
            sqlite3_result_text(ctx, pCur->req.zHeaders, -1, SQLITE_TRANSIENT);
        } else {
            sqlite3_result_null(ctx);
        }
        break;

    case HTTP_COL_REQUEST_BODY:
        if (pCur->req.pBody) {
            sqlite3_result_blob(ctx, pCur->req.pBody, pCur->req.szBody, SQLITE_TRANSIENT);
        } else {
            sqlite3_result_null(ctx);
        }
        break;
    }

    return SQLITE_OK;
}

static int httpRowid(sqlite3_vtab_cursor* cur, sqlite_int64* pRowid) {
    http_cursor* pCur = (http_cursor*)cur;
    *pRowid = pCur->iRowid;
    return SQLITE_OK;
}

static int httpEof(sqlite3_vtab_cursor* cur) {
    http_cursor* pCur = (http_cursor*)cur;
    return pCur->iRowid >= 1;
}

#define HTTP_FLAG_METHOD 1
#define HTTP_FLAG_URL 2
#define HTTP_FLAG_HEADERS 4
#define HTTP_FLAG_BODY 8

static int httpFilter(sqlite3_vtab_cursor* pVtabCursor,
                      int idxNum,
                      const char* idxStr,
                      int argc,
                      sqlite3_value** argv) {
    http_cursor* pCur = (http_cursor*)pVtabCursor;
    http_vtab* pVtab = (http_vtab*)pVtabCursor->pVtab;
    int bIsDo = pVtab->zMethod == NULL;
    char* zErrMsg = NULL;
    int rc;
    if (bIsDo) {
        pCur->req.zMethod = sqlite3_mprintf("%s", sqlite3_value_text(argv[0]));
        pCur->req.zUrl = sqlite3_mprintf("%s", sqlite3_value_text(argv[1]));
        if (idxNum & HTTP_FLAG_HEADERS) {
            pCur->req.zHeaders = sqlite3_mprintf("%s", sqlite3_value_text(argv[2]));
        }
        if (idxNum & HTTP_FLAG_BODY) {
            pCur->req.szBody = sqlite3_value_bytes(argv[3]);
            pCur->req.pBody = sqlite3_value_blob(argv[3]);
        }
    } else {
        pCur->req.zUrl = sqlite3_mprintf("%s", sqlite3_value_text(argv[0]));
        if (idxNum & HTTP_FLAG_HEADERS) {
            pCur->req.zHeaders = sqlite3_mprintf("%s", sqlite3_value_text(argv[1]));
        }
        if (idxNum & HTTP_FLAG_BODY) {
            pCur->req.szBody = sqlite3_value_bytes(argv[2]);
            pCur->req.pBody = sqlite3_value_blob(argv[2]);
        }
    }
    rc = http_do_request(&pCur->req, &pCur->resp, &zErrMsg);
    if (rc != SQLITE_OK) {
        sqlite3_free(pCur->base.pVtab->zErrMsg);
        pCur->base.pVtab->zErrMsg = zErrMsg;
    }
    return rc;
}

static int httpBestIndex(sqlite3_vtab* tab, sqlite3_index_info* pIdxInfo) {
    http_vtab* pTab = (http_vtab*)tab;
    int bIsDo = pTab->zMethod == NULL;
    int i;
    int idxNum = 0;
    const struct sqlite3_index_constraint* pConstraint;

    pConstraint = pIdxInfo->aConstraint;

    for (i = 0; i < pIdxInfo->nConstraint; ++i, ++pConstraint) {
        if (!pIdxInfo->aConstraint[i].usable) {
            return SQLITE_CONSTRAINT;
        }
        if (pConstraint->op != SQLITE_INDEX_CONSTRAINT_EQ) {
            return SQLITE_CONSTRAINT;
        };
        switch (pConstraint->iColumn) {
        case HTTP_COL_REQUEST_METHOD:
            if (bIsDo) {
                idxNum |= HTTP_FLAG_METHOD;
            } else {
                idxNum |= HTTP_FLAG_URL;
            }
            pIdxInfo->aConstraintUsage[i].argvIndex = 1;
            pIdxInfo->aConstraintUsage[i].omit = 1;
            break;

        case HTTP_COL_REQUEST_URL:
            if (bIsDo) {
                idxNum |= HTTP_FLAG_URL;
            } else {
                idxNum |= HTTP_FLAG_HEADERS;
            }
            pIdxInfo->aConstraintUsage[i].argvIndex = 2;
            pIdxInfo->aConstraintUsage[i].omit = 1;
            break;

        case HTTP_COL_REQUEST_HEADERS:
            if (bIsDo) {
                idxNum |= HTTP_FLAG_HEADERS;
            } else {
                idxNum |= HTTP_FLAG_BODY;
            }
            pIdxInfo->aConstraintUsage[i].argvIndex = 3;
            pIdxInfo->aConstraintUsage[i].omit = 1;
            break;

        case HTTP_COL_REQUEST_BODY:
            if (bIsDo) {
                idxNum |= HTTP_FLAG_BODY;
            } else {
                sqlite3_free(tab->zErrMsg);
                tab->zErrMsg = sqlite3_mprintf("too many arguments");
                return SQLITE_ERROR;
            }
            pIdxInfo->aConstraintUsage[i].argvIndex = 4;
            pIdxInfo->aConstraintUsage[i].omit = 1;
            break;
        }
    }

    if (bIsDo && !(idxNum & HTTP_FLAG_METHOD)) {
        sqlite3_free(tab->zErrMsg);
        tab->zErrMsg = sqlite3_mprintf("method missing");
        return SQLITE_ERROR;
    }

    if (!(idxNum & HTTP_FLAG_URL)) {
        sqlite3_free(tab->zErrMsg);
        tab->zErrMsg = sqlite3_mprintf("url missing");
        return SQLITE_ERROR;
    }

    pIdxInfo->estimatedCost = (double)1;
    pIdxInfo->estimatedRows = 1;
    pIdxInfo->idxNum = idxNum;

    return SQLITE_OK;
}

static sqlite3_module httpModule = {
    /* iVersion    */ 0,
    /* xCreate     */ 0,
    /* xConnect    */ httpConnect,
    /* xBestIndex  */ httpBestIndex,
    /* xDisconnect */ httpDisconnect,
    /* xDestroy    */ 0,
    /* xOpen       */ httpOpen,
    /* xClose      */ httpClose,
    /* xFilter     */ httpFilter,
    /* xNext       */ httpNext,
    /* xEof        */ httpEof,
    /* xColumn     */ httpColumn,
    /* xRowid      */ httpRowid,
    /* xUpdate     */ 0,
    /* xBegin      */ 0,
    /* xSync       */ 0,
    /* xCommit     */ 0,
    /* xRollback   */ 0,
    /* xFindMethod */ 0,
    /* xRename     */ 0,
    /* xSavepoint  */ 0,
    /* xRelease    */ 0,
    /* xRollbackTo */ 0,
    /* xShadowName */ 0,
};

static void httpSimpleFunc(sqlite3_context* ctx,
                           int argc,
                           sqlite3_value** argv,
                           const char* zTable,
                           const char* zColumn,
                           int bText) {
    char* zSql;
    int rc;
    sqlite3_stmt* pStmt;

    if (argc == 0) {
        sqlite3_result_error(ctx, "not enough arguments", -1);
        return;
    }

    if (argc == 1) {
        zSql = sqlite3_mprintf(
            "select \"%w\" from \"%w\"(%Q)", zColumn, zTable, sqlite3_value_text(argv[0]));
    }

    if (argc == 2) {
        zSql = sqlite3_mprintf("select \"%w\" from \"%w\"(%Q, %Q)",
                               zColumn,
                               zTable,
                               sqlite3_value_text(argv[0]),
                               sqlite3_value_text(argv[1]));
    }

    if (argc == 3) {
        zSql = sqlite3_mprintf("select \"%w\" from \"%w\"(%Q, %Q, %Q)",
                               zColumn,
                               zTable,
                               sqlite3_value_text(argv[0]),
                               sqlite3_value_text(argv[1]),
                               sqlite3_value_text(argv[2]));
    }

    if (argc >= 4) {
        zSql = sqlite3_mprintf("select \"%w\" from \"%w\"(%Q, %Q, %Q, %Q)",
                               zColumn,
                               zTable,
                               sqlite3_value_text(argv[0]),
                               sqlite3_value_text(argv[1]),
                               sqlite3_value_text(argv[2]),
                               sqlite3_value_text(argv[2]));
    }

    if (zSql == 0) {
        sqlite3_result_error_code(ctx, SQLITE_NOMEM);
        return;
    }

    rc = sqlite3_prepare_v2(sqlite3_context_db_handle(ctx), zSql, -1, &pStmt, 0);

    sqlite3_free(zSql);

    if (rc != SQLITE_OK) {
        sqlite3_result_error_code(ctx, rc);
        return;
    }

    rc = sqlite3_step(pStmt);

    if (rc == SQLITE_ROW) {
        int size = sqlite3_column_bytes(pStmt, 0);
        if (bText) {
            sqlite3_result_text(ctx, sqlite3_column_text(pStmt, 0), size, SQLITE_TRANSIENT);
        } else {
            sqlite3_result_blob(ctx, sqlite3_column_blob(pStmt, 0), size, SQLITE_TRANSIENT);
        }
        sqlite3_finalize(pStmt);
        return;
    }

    rc = sqlite3_finalize(pStmt);
    if (rc != SQLITE_OK) {
        sqlite3_result_error_code(ctx, rc);
    }
}

static void httpGetBodyFunc(sqlite3_context* ctx, int argc, sqlite3_value** argv) {
    httpSimpleFunc(ctx, argc, argv, "http_get", "response_body", 0);
}

static void httpPostBodyFunc(sqlite3_context* ctx, int argc, sqlite3_value** argv) {
    httpSimpleFunc(ctx, argc, argv, "http_post", "response_body", 0);
}

static void httpDoBodyFunc(sqlite3_context* ctx, int argc, sqlite3_value** argv) {
    httpSimpleFunc(ctx, argc, argv, "http_do", "response_body", 0);
}

static void httpGetHeadersFunc(sqlite3_context* ctx, int argc, sqlite3_value** argv) {
    httpSimpleFunc(ctx, argc, argv, "http_get", "response_headers", 1);
}

static void httpPostHeadersFunc(sqlite3_context* ctx, int argc, sqlite3_value** argv) {
    httpSimpleFunc(ctx, argc, argv, "http_post", "response_headers", 1);
}

static void httpDoHeadersFunc(sqlite3_context* ctx, int argc, sqlite3_value** argv) {
    httpSimpleFunc(ctx, argc, argv, "http_do", "response_headers", 1);
}

static void httpHeadersFunc(sqlite3_context* ctx, int argc, sqlite3_value** argv) {
    char* zHeaders = NULL;
    int i;
    int size = 0;
    int offset = 0;
    if (argc < 2) {
        sqlite3_result_error(ctx, "http_headers: expected at least 2 arguments", -1);
        return;
    }
    if (argc % 2 != 0) {
        sqlite3_result_error(ctx, "http_headers: even number of arguments expected", -1);
        return;
    }
    for (i = 0; i < argc; i += 2) {
        size += sqlite3_value_bytes(argv[i]) + 2;
        size += sqlite3_value_bytes(argv[i + 1]) + 2;
    }
    zHeaders = sqlite3_malloc(size);
    if (!zHeaders) {
        sqlite3_result_error_code(ctx, SQLITE_NOMEM);
        return;
    }
    for (i = 0; i < argc; i += 2) {
        memcpy(zHeaders + offset, sqlite3_value_text(argv[i]), sqlite3_value_bytes(argv[i]));
        offset += sqlite3_value_bytes(argv[i]);

        memcpy(zHeaders + offset, ": ", 2);
        offset += 2;

        memcpy(
            zHeaders + offset, sqlite3_value_text(argv[i + 1]), sqlite3_value_bytes(argv[i + 1]));
        offset += sqlite3_value_bytes(argv[i + 1]);

        memcpy(zHeaders + offset, "\r\n", 2);
        offset += 2;
    }
    assert(offset == size);
    sqlite3_result_text(ctx, zHeaders, size, sqlite3_free);
}

static void httpHeadersHasFunc(sqlite3_context* ctx, int argc, sqlite3_value** argv) {
    int zHeadersSize = sqlite3_value_bytes(argv[0]);
    const char* zHeaders = sqlite3_value_text(argv[0]);
    int zHeaderSize = sqlite3_value_bytes(argv[1]);
    const char* zHeader = sqlite3_value_text(argv[1]);
    while (zHeadersSize > 0) {
        int iParsed = 0;
        const char* pName;
        int iNameSize;
        int rc = http_next_header(zHeaders, zHeadersSize, &iParsed, &pName, &iNameSize, NULL, NULL);
        if (rc == SQLITE_ERROR) {
            sqlite3_result_error(ctx, "http_headers_has: malformed headers", -1);
            return;
        }
        if (rc == SQLITE_DONE) {
            sqlite3_result_int(ctx, 0);
            return;
        }
        zHeaders += iParsed;
        zHeadersSize -= iParsed;
        if (iNameSize == zHeaderSize && sqlite3_strnicmp(zHeader, pName, zHeaderSize) == 0) {
            sqlite3_result_int(ctx, 1);
            return;
        }
    }
    sqlite3_result_int(ctx, 0);
}

static void httpHeadersGetFunc(sqlite3_context* ctx, int argc, sqlite3_value** argv) {
    int zHeadersSize = sqlite3_value_bytes(argv[0]);
    const char* zHeaders = sqlite3_value_text(argv[0]);
    int zHeaderSize = sqlite3_value_bytes(argv[1]);
    const char* zHeader = sqlite3_value_text(argv[1]);
    while (zHeadersSize > 0) {
        int iParsed = 0;
        const char* pName;
        int iNameSize;
        const char* pValue;
        int iValueSize;
        int rc = http_next_header(
            zHeaders, zHeadersSize, &iParsed, &pName, &iNameSize, &pValue, &iValueSize);
        if (rc == SQLITE_ERROR) {
            sqlite3_result_error(ctx, "http_headers_get: malformed headers", -1);
            return;
        }
        if (rc == SQLITE_DONE) {
            sqlite3_result_int(ctx, 0);
            return;
        }
        zHeaders += iParsed;
        zHeadersSize -= iParsed;
        if (iNameSize == zHeaderSize && sqlite3_strnicmp(zHeader, pName, zHeaderSize) == 0) {
            sqlite3_result_text(ctx, pValue, iValueSize, SQLITE_TRANSIENT);
            return;
        }
    }
}

#define HTTP_HEADERS_EACH_COL_NAME 0
#define HTTP_HEADERS_EACH_COL_VALUE 1
#define HTTP_HEADERS_EACH_COL_HEADERS 2

typedef struct http_headers_each_vtab http_headers_each_vtab;
struct http_headers_each_vtab {
    sqlite3_vtab base;
};

typedef struct http_headers_each_cursor http_headers_each_cursor;
struct http_headers_each_cursor {
    sqlite3_vtab_cursor base;
    sqlite3_int64 iRowid;
    const char* zHeaders;
    int zHeadersSize;
    const char* p;
    const char* name;
    int nameSize;
    const char* value;
    int valueSize;
    int available;
    int done;
};

static int httpHeadersEachConnect(sqlite3* db,
                                  void* pAux,
                                  int argc,
                                  const char* const* argv,
                                  sqlite3_vtab** ppVtab,
                                  char** pzErr) {
    http_headers_each_vtab* pNew;
    int rc;
    rc = sqlite3_declare_vtab(db, "CREATE TABLE x(name TEXT, value TEXT, headers TEXT HIDDEN)");
    if (rc == SQLITE_OK) {
        pNew = sqlite3_malloc(sizeof(*pNew));
        *ppVtab = (sqlite3_vtab*)pNew;
        if (pNew == 0)
            return SQLITE_NOMEM;
        memset(pNew, 0, sizeof(*pNew));
    }
    return rc;
}

static int httpHeadersEachDisconnect(sqlite3_vtab* pVtab) {
    http_headers_each_vtab* p = (http_headers_each_vtab*)pVtab;
    sqlite3_free(p);
    return SQLITE_OK;
}

static int httpHeadersEachOpen(sqlite3_vtab* p, sqlite3_vtab_cursor** ppCursor) {
    http_headers_each_cursor* pCur;
    pCur = sqlite3_malloc(sizeof(*pCur));
    if (pCur == 0)
        return SQLITE_NOMEM;
    memset(pCur, 0, sizeof(*pCur));
    *ppCursor = &pCur->base;
    return SQLITE_OK;
}

static int httpHeadersEachClose(sqlite3_vtab_cursor* cur) {
    http_headers_each_cursor* pCur = (http_headers_each_cursor*)cur;
    sqlite3_free(pCur);
    return SQLITE_OK;
}

static int httpHeadersEachNext(sqlite3_vtab_cursor* cur) {
    http_headers_each_cursor* pCur = (http_headers_each_cursor*)cur;
    pCur->iRowid++;
    int nparsed = 0;
    int rc = http_next_header(pCur->p,
                              pCur->available,
                              &nparsed,
                              &pCur->name,
                              &pCur->nameSize,
                              &pCur->value,
                              &pCur->valueSize);
    pCur->p += nparsed;
    pCur->available -= nparsed;
    if (rc == SQLITE_ERROR) {
        sqlite3_free(cur->pVtab->zErrMsg);
        cur->pVtab->zErrMsg = sqlite3_mprintf("http_headers_each: malformed headers");
        return SQLITE_ERROR;
    }
    pCur->done = rc == SQLITE_DONE;
    return SQLITE_OK;
}

static int httpHeadersEachColumn(sqlite3_vtab_cursor* cur, sqlite3_context* ctx, int i) {
    http_headers_each_cursor* pCur = (http_headers_each_cursor*)cur;
    switch (i) {
    case HTTP_HEADERS_EACH_COL_NAME:
        sqlite3_result_text(ctx, pCur->name, pCur->nameSize, SQLITE_TRANSIENT);
        break;

    case HTTP_HEADERS_EACH_COL_VALUE:
        sqlite3_result_text(ctx, pCur->value, pCur->valueSize, SQLITE_TRANSIENT);
        break;

    case HTTP_HEADERS_EACH_COL_HEADERS:
        sqlite3_result_text(ctx, pCur->zHeaders, pCur->zHeadersSize, SQLITE_TRANSIENT);
        break;

    default:
        sqlite3_result_error(ctx, "unknown column", -1);
        break;
    }
    return SQLITE_OK;
}

static int httpHeadersEachRowid(sqlite3_vtab_cursor* cur, sqlite_int64* pRowid) {
    http_headers_each_cursor* pCur = (http_headers_each_cursor*)cur;
    *pRowid = pCur->iRowid;
    return SQLITE_OK;
}

static int httpHeadersEachEof(sqlite3_vtab_cursor* cur) {
    http_headers_each_cursor* pCur = (http_headers_each_cursor*)cur;
    return pCur->done;
}

static int httpHeadersEachFilter(sqlite3_vtab_cursor* pVtabCursor,
                                 int idxNum,
                                 const char* idxStr,
                                 int argc,
                                 sqlite3_value** argv) {
    http_headers_each_cursor* pCur = (http_headers_each_cursor*)pVtabCursor;
    pCur->zHeadersSize = sqlite3_value_bytes(argv[0]);
    pCur->available = pCur->zHeadersSize;
    pCur->zHeaders = sqlite3_value_text(argv[0]);
    pCur->p = pCur->zHeaders;
    int nparsed = 0;
    int rc = http_next_header(pCur->p,
                              pCur->available,
                              &nparsed,
                              &pCur->name,
                              &pCur->nameSize,
                              &pCur->value,
                              &pCur->valueSize);
    pCur->p += nparsed;
    pCur->available -= nparsed;
    pCur->iRowid = 1;
    if (rc == SQLITE_ERROR) {
        sqlite3_free(pVtabCursor->pVtab->zErrMsg);
        pVtabCursor->pVtab->zErrMsg = sqlite3_mprintf("http_headers_each: malformed headers");
        return SQLITE_ERROR;
    }
    pCur->done = rc == SQLITE_DONE;
    return SQLITE_OK;
}

static int httpHeadersEachBestIndex(sqlite3_vtab* tab, sqlite3_index_info* pIdxInfo) {
    http_vtab* pTab = (http_vtab*)tab;
    int bHeadersSeen = 0;

    for (int i = 0; i < pIdxInfo->nConstraint; ++i) {
        if (pIdxInfo->aConstraint[i].iColumn == HTTP_HEADERS_EACH_COL_HEADERS) {
            if (!pIdxInfo->aConstraint[i].usable) {
                return SQLITE_CONSTRAINT;
            }
            pIdxInfo->aConstraintUsage[i].argvIndex = 1;
            pIdxInfo->aConstraintUsage[i].omit = 1;
            bHeadersSeen = 1;
        }
    }

    if (!bHeadersSeen) {
        sqlite3_free(tab->zErrMsg);
        tab->zErrMsg = sqlite3_mprintf("headers missing");
        return SQLITE_ERROR;
    }

    pIdxInfo->estimatedCost = (double)1;
    // pIdxInfo->estimatedRows = 1;

    return SQLITE_OK;
}

static sqlite3_module httpHeadersEachModule = {
    /* iVersion    */ 0,
    /* xCreate     */ 0,
    /* xConnect    */ httpHeadersEachConnect,
    /* xBestIndex  */ httpHeadersEachBestIndex,
    /* xDisconnect */ httpHeadersEachDisconnect,
    /* xDestroy    */ 0,
    /* xOpen       */ httpHeadersEachOpen,
    /* xClose      */ httpHeadersEachClose,
    /* xFilter     */ httpHeadersEachFilter,
    /* xNext       */ httpHeadersEachNext,
    /* xEof        */ httpHeadersEachEof,
    /* xColumn     */ httpHeadersEachColumn,
    /* xRowid      */ httpHeadersEachRowid,
    /* xUpdate     */ 0,
    /* xBegin      */ 0,
    /* xSync       */ 0,
    /* xCommit     */ 0,
    /* xRollback   */ 0,
    /* xFindMethod */ 0,
    /* xRename     */ 0,
    /* xSavepoint  */ 0,
    /* xRelease    */ 0,
    /* xRollbackTo */ 0,
    /* xShadowName */ 0,
};

static const struct Func {
    const char* name;
    void (*xFunc)(sqlite3_context*, int, sqlite3_value**);
} funcs[] = {
    {"http_get_body", httpGetBodyFunc},
    {"http_post_body", httpPostBodyFunc},
    {"http_do_body", httpDoBodyFunc},
    {"http_get_headers", httpGetHeadersFunc},
    {"http_post_headers", httpPostHeadersFunc},
    {"http_do_headers", httpDoHeadersFunc},
    {"http_headers", httpHeadersFunc},
    {"http_headers_has", httpHeadersHasFunc},
    {"http_headers_get", httpHeadersGetFunc},
    {NULL, NULL},
};

static const struct Module {
    const char* name;
    const sqlite3_module* module;
} modules[] = {
    {"http_get", &httpModule},
    {"http_post", &httpModule},
    {"http_do", &httpModule},
    {"http_headers_each", &httpHeadersEachModule},
    {NULL, NULL},
};

#ifdef _WIN32
__declspec(dllexport)
#endif
    int sqlite3_http_init(sqlite3* db, char** pzErrMsg, const sqlite3_api_routines* pApi) {
    int rc = SQLITE_OK;
    SQLITE_EXTENSION_INIT2(pApi);
    int i;
    for (i = 0; funcs[i].name && rc == SQLITE_OK; ++i) {
        rc = sqlite3_create_function(
            db, funcs[i].name, -1, SQLITE_UTF8, NULL, funcs[i].xFunc, NULL, NULL);
    }
    for (i = 0; modules[i].name && rc == SQLITE_OK; ++i) {
        rc = sqlite3_create_module(db, modules[i].name, modules[i].module, 0);
    }
    return rc;
}

/********** src/http_backend_curl.c **********/

#ifdef HTTP_BACKEND_CURL

#include "http.h"

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

SQLITE_EXTENSION_INIT3

#ifdef _WIN32
#include <windows.h>

void* http_dlopen(const char* zName) {
    return LoadLibraryA(zName);
}

void http_dlclose(void* library) {
    FreeLibrary(library);
}

void* http_dlsym(void* library, const char* zName) {
    return GetProcAddress(library, zName);
}
#else
#include <dlfcn.h>

void* http_dlopen(const char* zName) {
    return dlopen(zName, RTLD_NOW);
}

void http_dlclose(void* library) {
    dlclose(zName);
}

void* http_dlsym(void* library, const char* zName) {
    return dlsym(library, zName);
}
#endif

#ifndef MIN
#define MIN(A, B) ((A) < (B) ? (A) : (B))
#endif

typedef struct CURL CURL;
typedef int CURLcode;
typedef int CURLoption;
typedef int CURLINFO;
typedef int CURLversion;

#define CURL_ERROR_SIZE 256

#define CURLE_OK 0

#define CURLOPT_ERRORBUFFER (10000 + 10)
#define CURLOPT_URL (10000 + 2)
#define CURLOPT_FOLLOWLOCATION (52)
#define CURLOPT_HTTPGET (80)
#define CURLOPT_POST (47)
#define CURLOPT_SSL_OPTIONS (216)
#define CURLOPT_WRITEFUNCTION (20000 + 11)
#define CURLOPT_WRITEDATA (10000 + 1)
#define CURLOPT_READFUNCTION (20000 + 12)
#define CURLOPT_READDATA (10000 + 9)
#define CURLOPT_HEADERFUNCTION (20000 + 79)
#define CURLOPT_HEADERDATA (10000 + 29)
#define CURLOPT_POSTFIELDS (10000 + 15)
#define CURLOPT_POSTFIELDSIZE_LARGE (30000 + 120)
#define CURLOPT_HTTPHEADER (10000 + 23)
#define CURLOPT_INFILESIZE_LARGE (30000 + 115)
#define CURLOPT_NOBODY (44)
#define CURLOPT_CUSTOMREQUEST (10000 + 36)
#define CURLOPT_PUT (54)

#define CURLSSLOPT_NATIVE_CA (1 << 4)

#define CURLVERSION_NOW 9

#define CURLINFO_RESPONSE_CODE (0x200000 + 2)

// The struct is bigger but I don't need more information for now...
struct curl_version_info_data {
    CURLversion age;
    const char* version;
    unsigned int version_num;
};
typedef struct curl_version_info_data curl_version_info_data;

struct curl_slist;

typedef CURL* (*curl_easy_init_t)();
typedef void (*curl_easy_cleanup_t)(CURL*);
typedef CURLcode (*curl_easy_setopt_t)(CURL*, CURLoption, ...);
typedef CURLcode (*curl_easy_perform_t)(CURL*);
typedef CURLcode (*curl_easy_getinfo_t)(CURL*, CURLINFO, ...);
typedef char* (*curl_version_t)();
typedef curl_version_info_data* (*curl_version_info_t)(CURLversion);
typedef struct curl_slist* (*curl_slist_append_t)(struct curl_slist*, const char*);
typedef void (*curl_slist_free_all_t)(struct curl_slist*);
typedef const char* (*curl_easy_strerror_t)(CURLcode);

struct curl_api_routines {
    void* pLibrary;
    curl_easy_init_t easy_init;
    curl_easy_cleanup_t easy_cleanup;
    curl_easy_setopt_t easy_setopt;
    curl_easy_perform_t easy_perform;
    curl_easy_getinfo_t easy_getinfo;
    curl_version_t version;
    curl_version_info_t version_info;
    curl_slist_append_t slist_append;
    curl_slist_free_all_t slist_free_all;
    curl_easy_strerror_t easy_strerror;
};

static struct curl_api_routines curl_api;

#define curl_easy_init curl_api.easy_init
#define curl_easy_cleanup curl_api.easy_cleanup
#define curl_easy_setopt curl_api.easy_setopt
#define curl_easy_perform curl_api.easy_perform
#define curl_easy_getinfo curl_api.easy_getinfo
#define curl_version curl_api.version
#define curl_version_info curl_api.version_info
#define curl_slist_append curl_api.slist_append
#define curl_slist_free_all curl_api.slist_free_all
#define curl_easy_strerror curl_api.easy_strerror

static const char* aCurlLibNames[] = {
#ifdef _WIN32
    "libcurl-x64.dll",
    "libcurl.dll",
#else
    "libcurl.so",
    "libcurl.so.4",
#endif
};

static const int szCurlLibNames = sizeof(aCurlLibNames) / sizeof(aCurlLibNames[0]);

int http_backend_curl_load(char** zErrMsg) {
    assert(zErrMsg != NULL);

    *zErrMsg = NULL;

    if (!curl_api.pLibrary) {
        for (int i = 0; i < szCurlLibNames && !curl_api.pLibrary; ++i) {
            curl_api.pLibrary = http_dlopen(aCurlLibNames[i]);
        }
    }

    if (!curl_api.pLibrary) {
        *zErrMsg = sqlite3_mprintf("failed to load curl");
        goto error;
    }

    curl_easy_init = (curl_easy_init_t)http_dlsym(curl_api.pLibrary, "curl_easy_init");
    if (!curl_easy_init) {
        *zErrMsg = sqlite3_mprintf("failed to load curl_easy_init");
        goto error;
    }
    curl_easy_cleanup = (curl_easy_cleanup_t)http_dlsym(curl_api.pLibrary, "curl_easy_cleanup");
    if (!curl_easy_cleanup) {
        *zErrMsg = sqlite3_mprintf("failed to load curl_easy_cleanup");
        goto error;
    }
    curl_easy_setopt = (curl_easy_setopt_t)http_dlsym(curl_api.pLibrary, "curl_easy_setopt");
    if (!curl_easy_setopt) {
        *zErrMsg = sqlite3_mprintf("failed to load curl_easy_setopt");
        goto error;
    }
    curl_easy_perform = (curl_easy_perform_t)http_dlsym(curl_api.pLibrary, "curl_easy_perform");
    if (!curl_easy_perform) {
        *zErrMsg = sqlite3_mprintf("failed to load curl_easy_perform");
        goto error;
    }
    curl_easy_getinfo = (curl_easy_getinfo_t)http_dlsym(curl_api.pLibrary, "curl_easy_getinfo");
    if (!curl_easy_getinfo) {
        *zErrMsg = sqlite3_mprintf("failed to load curl_easy_getinfo");
        goto error;
    }
    curl_version = (curl_version_t)http_dlsym(curl_api.pLibrary, "curl_version");
    if (!curl_version) {
        *zErrMsg = sqlite3_mprintf("failed to load curl_version");
        goto error;
    }
    curl_version_info = (curl_version_info_t)http_dlsym(curl_api.pLibrary, "curl_version_info");
    if (!curl_version_info) {
        *zErrMsg = sqlite3_mprintf("failed to load curl_version_info");
        goto error;
    }
    curl_slist_append = (curl_slist_append_t)http_dlsym(curl_api.pLibrary, "curl_slist_append");
    if (!curl_slist_append) {
        *zErrMsg = sqlite3_mprintf("failed to load curl_slist_append");
        goto error;
    }
    curl_slist_free_all =
        (curl_slist_free_all_t)http_dlsym(curl_api.pLibrary, "curl_slist_free_all");
    if (!curl_slist_free_all) {
        *zErrMsg = sqlite3_mprintf("failed to load curl_slist_free_all");
        goto error;
    }
    curl_easy_strerror = (curl_easy_strerror_t)http_dlsym(curl_api.pLibrary, "curl_easy_strerror");
    if (!curl_easy_strerror) {
        *zErrMsg = sqlite3_mprintf("failed to load curl_easy_strerror");
        goto error;
    }

    return SQLITE_OK;

error:

    if (curl_api.pLibrary) {
        http_dlclose(curl_api.pLibrary);
        memset(&curl_api, 0, sizeof(curl_api));
    }

    return SQLITE_ERROR;
}

static size_t write_callback(char* ptr, size_t size, size_t nmemb, void* userdata) {
    http_response* pResp = (http_response*)userdata;
    char* p;
    p = sqlite3_realloc(pResp->pBody, pResp->szBody + size * nmemb);
    if (!p) {
        return 0;
    }
    pResp->pBody = p;
    memcpy((char*)pResp->pBody + pResp->szBody, ptr, size * nmemb);
    pResp->szBody += size * nmemb;
    return size * nmemb;
}

static size_t header_callback(char* ptr, size_t size, size_t nmemb, void* userdata) {
    http_response* pResp = (http_response*)userdata;
    char* p;
    p = sqlite3_realloc(pResp->zHeaders, pResp->szHeaders + size * nmemb + 1);
    if (!p) {
        return 0;
    }
    pResp->zHeaders = p;
    memcpy(pResp->zHeaders + pResp->szHeaders, ptr, size * nmemb);
    pResp->szHeaders += size * nmemb;
    pResp->zHeaders[pResp->szHeaders] = '\0';
    return size * nmemb;
}

struct readdata {
    const char* pBody;
    size_t szBody;
};

static size_t read_callback(char* ptr, size_t size, size_t nmemb, void* userdata) {
    struct readdata* pData = (struct readdata*)userdata;
    size_t szToSend = MIN(size * nmemb, pData->szBody);
    memcpy(ptr, pData->pBody, szToSend);
    pData->pBody += szToSend;
    pData->szBody -= szToSend;
    return szToSend;
}

static int
headers_to_curl_headers(struct curl_slist** pHeaders, const char* zHeaders, int szHeaders) {
    const char* name;
    int szName;
    const char* value;
    int szValue;
    while (szHeaders > 0) {
        int nParsed = 0;
        int rc = http_next_header(zHeaders, szHeaders, &nParsed, &name, &szName, &value, &szValue);
        if (rc == SQLITE_DONE) {
            break;
        } else if (rc == SQLITE_ROW) {
            char* zHeader = sqlite3_mprintf("%.*s: %.*s", szName, name, szValue, value);
            if (!zHeader) {
                return 0;
            }
            void* tmp = curl_slist_append(*pHeaders, zHeader);
            sqlite3_free(zHeader);
            if (!tmp) {
                return 0;
            }
            *pHeaders = tmp;
            szHeaders -= nParsed;
            zHeaders += nParsed;
        } else if (rc == SQLITE_ERROR) {
            return 0;
        }
    }
    return 1;
}

static int set_curl_error_message(char** ppErrMsg, CURLcode rc, const char* message) {
    *ppErrMsg = sqlite3_mprintf("%s: %s (curl error code %d)", message, curl_easy_strerror(rc), rc);
    return SQLITE_ERROR;
}

int http_do_request(http_request* req, http_response* resp, char** ppErrMsg) {
    int rc;
    CURL* curl;
    char aErrorBuf[CURL_ERROR_SIZE];
    curl_version_info_data* pCurlVersionInfo;
    long responseCode;
    struct curl_slist* headers = NULL;
    CURLcode curlrc;
    struct readdata readdata;

    rc = http_backend_curl_load(ppErrMsg);
    if (rc != SQLITE_OK) {
        return rc;
    }

    pCurlVersionInfo = curl_version_info(CURLVERSION_NOW);

    curl = curl_easy_init();
    if (!curl) {
        *ppErrMsg = sqlite3_mprintf("curl_easy_init failed");
        rc = SQLITE_ERROR;
        goto error;
    }

    memset(aErrorBuf, 0, sizeof(aErrorBuf));
    if ((curlrc = curl_easy_setopt(curl, CURLOPT_ERRORBUFFER, aErrorBuf)) != CURLE_OK) {
        rc = set_curl_error_message(ppErrMsg, curlrc, "curl_easy_setopt");
        goto error;
    }

    if ((curlrc = curl_easy_setopt(curl, CURLOPT_URL, req->zUrl)) != CURLE_OK) {
        rc = set_curl_error_message(ppErrMsg, curlrc, "curl_easy_setopt");
        goto error;
    }

    if ((curlrc = curl_easy_setopt(curl, CURLOPT_FOLLOWLOCATION, 1L)) != CURLE_OK) {
        rc = set_curl_error_message(ppErrMsg, curlrc, "curl_easy_setopt");
        goto error;
    }

    if (sqlite3_stricmp(req->zMethod, "GET") == 0) {
        if ((curlrc = curl_easy_setopt(curl, CURLOPT_HTTPGET, 1L)) != CURLE_OK) {
            rc = set_curl_error_message(ppErrMsg, curlrc, "curl_easy_setopt");
            goto error;
        }
    } else if (sqlite3_stricmp(req->zMethod, "POST") == 0) {
        if ((curlrc = curl_easy_setopt(curl, CURLOPT_POST, 1L)) != CURLE_OK) {
            rc = set_curl_error_message(ppErrMsg, curlrc, "curl_easy_setopt");
            goto error;
        }
        if ((curlrc = curl_easy_setopt(curl, CURLOPT_POSTFIELDS, req->pBody)) != CURLE_OK) {
            rc = set_curl_error_message(ppErrMsg, curlrc, "curl_easy_setopt");
            goto error;
        }
        if ((curlrc = curl_easy_setopt(curl, CURLOPT_POSTFIELDSIZE_LARGE, req->szBody)) !=
            CURLE_OK) {
            rc = set_curl_error_message(ppErrMsg, curlrc, "curl_easy_setopt");
            goto error;
        }
    } else if (sqlite3_stricmp(req->zMethod, "PUT") == 0) {
        if ((curlrc = curl_easy_setopt(curl, CURLOPT_PUT, 1L)) != CURLE_OK) {
            rc = set_curl_error_message(ppErrMsg, curlrc, "curl_easy_setopt");
            goto error;
        }
    } else if (sqlite3_stricmp(req->zMethod, "HEAD") == 0) {
        if ((curlrc = curl_easy_setopt(curl, CURLOPT_NOBODY, 1L)) != CURLE_OK) {
            rc = set_curl_error_message(ppErrMsg, curlrc, "curl_easy_setopt");
            goto error;
        }
    } else {
        if ((curlrc = curl_easy_setopt(curl, CURLOPT_HTTPGET, 1L)) != CURLE_OK) {
            rc = set_curl_error_message(ppErrMsg, curlrc, "curl_easy_setopt");
            goto error;
        }

        if (req->pBody && req->szBody) {
            if ((curlrc = curl_easy_setopt(curl, CURLOPT_PUT, 1L)) != CURLE_OK) {
                rc = set_curl_error_message(ppErrMsg, curlrc, "curl_easy_setopt");
                goto error;
            }
        }

        if ((curlrc = curl_easy_setopt(curl, CURLOPT_CUSTOMREQUEST, req->zMethod)) != CURLE_OK) {
            rc = set_curl_error_message(ppErrMsg, curlrc, "curl_easy_setopt");
            goto error;
        }
    }

    if (req->pBody && req->szBody && sqlite3_stricmp(req->zMethod, "POST") != 0) {
        readdata.pBody = (const char*)req->pBody;
        readdata.szBody = (size_t)req->szBody;

        if ((curlrc = curl_easy_setopt(curl, CURLOPT_INFILESIZE_LARGE, req->szBody)) != CURLE_OK) {
            rc = set_curl_error_message(ppErrMsg, curlrc, "curl_easy_setopt");
            goto error;
        }

        if ((curlrc = curl_easy_setopt(curl, CURLOPT_READFUNCTION, read_callback)) != CURLE_OK) {
            rc = set_curl_error_message(ppErrMsg, curlrc, "curl_easy_setopt");
            goto error;
        }

        if ((curlrc = curl_easy_setopt(curl, CURLOPT_READDATA, &readdata)) != CURLE_OK) {
            rc = set_curl_error_message(ppErrMsg, curlrc, "curl_easy_setopt");
            goto error;
        }
    }

    // Since 7.71.0 (Jun 24 2020). Makes life easier on Windows at least.
    if (pCurlVersionInfo->version_num >= ((7 << 16) | (71 << 8))) {
        if ((curlrc = curl_easy_setopt(curl, CURLOPT_SSL_OPTIONS, CURLSSLOPT_NATIVE_CA)) !=
            CURLE_OK) {
            rc = set_curl_error_message(ppErrMsg, curlrc, "curl_easy_setopt");
            goto error;
        }
    }

    if ((curlrc = curl_easy_setopt(curl, CURLOPT_WRITEFUNCTION, write_callback)) != CURLE_OK) {
        rc = set_curl_error_message(ppErrMsg, curlrc, "curl_easy_setopt");
        goto error;
    }

    if ((curlrc = curl_easy_setopt(curl, CURLOPT_WRITEDATA, resp)) != CURLE_OK) {
        rc = set_curl_error_message(ppErrMsg, curlrc, "curl_easy_setopt");
        goto error;
    }

    if ((curlrc = curl_easy_setopt(curl, CURLOPT_HEADERFUNCTION, header_callback)) != CURLE_OK) {
        rc = set_curl_error_message(ppErrMsg, curlrc, "curl_easy_setopt");
        goto error;
    }

    if ((curlrc = curl_easy_setopt(curl, CURLOPT_HEADERDATA, resp)) != CURLE_OK) {
        rc = set_curl_error_message(ppErrMsg, curlrc, "curl_easy_setopt");
        goto error;
    }

    // Remove content-type header by default...
    headers = curl_slist_append(NULL, "content-type;");
    if (!headers) {
        *ppErrMsg = sqlite3_mprintf("curl_slist_append failed");
        rc = SQLITE_ERROR;
        goto error;
    }

    if (req->zHeaders) {
        if (!headers_to_curl_headers(&headers, req->zHeaders, strlen(req->zHeaders))) {
            *ppErrMsg = sqlite3_mprintf("failed to convert headers for curl");
            rc = SQLITE_ERROR;
            goto error;
        }
        if ((curlrc = curl_easy_setopt(curl, CURLOPT_HTTPHEADER, headers)) != CURLE_OK) {
            rc = set_curl_error_message(ppErrMsg, curlrc, "curl_easy_setopt");
            goto error;
        }
    }

    if (curl_easy_perform(curl) != CURLE_OK) {
        *ppErrMsg = sqlite3_mprintf("curl_easy_perform failed: %s", aErrorBuf);
        rc = SQLITE_ERROR;
        goto error;
    }

    curl_easy_getinfo(curl, CURLINFO_RESPONSE_CODE, &responseCode);
    resp->iStatusCode = responseCode;

    remove_all_but_last_headers(resp->zHeaders);
    separate_status_and_headers(&resp->zStatus, resp->zHeaders);

    rc = SQLITE_OK;

error:

done:

    curl_easy_cleanup(curl);
    curl_slist_free_all(headers);

    return rc;
}

#endif // HTTP_BACKEND_CURL

/********** src/http_backend_dummy.c **********/

#ifdef HTTP_BACKEND_DUMMY

#include "http.h"

#include <assert.h>

SQLITE_EXTENSION_INIT3

static http_request sLastRequest;
static http_response* sResponse;
static char* sErrMsg;

void http_backend_dummy_set_response(http_response* response) {
    sResponse = response;
}

void http_backend_dummy_set_errmsg(const char* zErrMsg) {
    sErrMsg = sqlite3_mprintf("%s", zErrMsg);
}

void http_backend_dummy_reset_request() {
    sqlite3_free(sLastRequest.zMethod);
    sqlite3_free((void*)sLastRequest.pBody);
    sqlite3_free((void*)sLastRequest.zHeaders);
    memset(&sLastRequest, 0, sizeof(sLastRequest));
}

const http_request* http_backend_dummy_get_last_request() {
    return &sLastRequest;
}

int http_do_request(http_request* req, http_response* resp, char** ppErrMsg) {
    int rc = SQLITE_OK;
    if (sResponse) {
        *resp = *sResponse;
        sResponse = NULL;
    } else if (sErrMsg) {
        *ppErrMsg = sErrMsg;
        sErrMsg = NULL;
        rc = SQLITE_ERROR;
    } else {
        assert(0);
    }
    http_backend_dummy_reset_request();
    if (req->zMethod) {
        sLastRequest.zMethod = sqlite3_mprintf("%s", req->zMethod);
    }
    if (req->zUrl) {
        sLastRequest.zUrl = sqlite3_mprintf("%s", req->zUrl);
    }
    if (req->pBody) {
        sLastRequest.pBody = sqlite3_malloc(req->szBody);
        memcpy((void*)sLastRequest.pBody, req->pBody, req->szBody);
    }
    sLastRequest.szBody = req->szBody;
    if (req->zHeaders) {
        sLastRequest.zHeaders = sqlite3_mprintf("%s", req->zHeaders);
    }
    return rc;
}

#endif // HTTP_BACKEND_DUMMY

/********** src/http_backend_winhttp.c **********/

#ifdef HTTP_BACKEND_WINHTTP

#include "http.h"

#include <windows.h>
#include <winhttp.h>

#include <assert.h>

SQLITE_EXTENSION_INIT3

static char* unicode_to_utf8(LPCWSTR zWide) {
    DWORD nSize;
    char* zUtf8;
    nSize = WideCharToMultiByte(CP_UTF8, 0, zWide, -1, NULL, 0, NULL, NULL);
    if (nSize == 0) {
        return NULL;
    }
    zUtf8 = sqlite3_malloc(nSize);
    if (!zUtf8) {
        return NULL;
    }
    nSize = WideCharToMultiByte(CP_UTF8, 0, zWide, -1, zUtf8, nSize, NULL, NULL);
    if (nSize == 0) {
        sqlite3_free(zUtf8);
        return NULL;
    }
    return zUtf8;
}

static LPWSTR utf8_to_unicode(const char* zText) {
    DWORD nSize;
    LPWSTR zWide;
    nSize = MultiByteToWideChar(CP_UTF8, 0, zText, -1, NULL, 0);
    if (nSize == 0) {
        return NULL;
    }
    zWide = sqlite3_malloc(sizeof(*zWide) * nSize);
    if (!zWide) {
        return NULL;
    }
    nSize = MultiByteToWideChar(CP_UTF8, 0, zText, -1, zWide, nSize);
    if (nSize == 0) {
        sqlite3_free(zWide);
        return NULL;
    }
    return zWide;
}

static char* win32_get_last_error(DWORD code) {
    LPWSTR zWide = NULL;
    FormatMessageW(FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_SYSTEM |
                       FORMAT_MESSAGE_IGNORE_INSERTS,
                   NULL,
                   code,
                   0,
                   (LPWSTR)&zWide,
                   0,
                   NULL);
    char* zUtf8 = unicode_to_utf8(zWide);
    LocalFree(zWide);
    return zUtf8;
}

static int query_headers(HINTERNET request, DWORD dwInfoLevel, char** ppResult) {
    DWORD szWide = 0;
    LPWSTR zWide = NULL;

    WinHttpQueryHeaders(
        request, dwInfoLevel, WINHTTP_HEADER_NAME_BY_INDEX, NULL, &szWide, WINHTTP_NO_HEADER_INDEX);

    if (GetLastError() != ERROR_INSUFFICIENT_BUFFER) {
        return SQLITE_ERROR;
    }

    zWide = sqlite3_malloc(szWide);
    if (!zWide) {
        return SQLITE_NOMEM;
    }

    if (!WinHttpQueryHeaders(request,
                             dwInfoLevel,
                             WINHTTP_HEADER_NAME_BY_INDEX,
                             zWide,
                             &szWide,
                             WINHTTP_NO_HEADER_INDEX)) {
        sqlite3_free(zWide);
        return SQLITE_ERROR;
    }

    *ppResult = unicode_to_utf8(zWide);

    sqlite3_free(zWide);

    return SQLITE_OK;
}

int http_do_request(http_request* req, http_response* resp, char** ppErrMsg) {
    LPWSTR zUrlWide = NULL;
    LPWSTR zHostWide = NULL;
    LPWSTR zMethodWide = NULL;
    LPWSTR zHeadersWide = NULL;
    HINTERNET session = NULL;
    HINTERNET conn = NULL;
    HINTERNET request = NULL;
    URL_COMPONENTS components;
    DWORD lastErr = 0;
    const char* errFunc = NULL;
    char* zErrMsg = NULL;
    int rc = SQLITE_ERROR;
    LPWSTR zWideResponseHeaders = NULL;
    DWORD szWideResponseHeaders = 0;
    DWORD dwSize = 0;
    DWORD dwStatusCode;

    zUrlWide = utf8_to_unicode(req->zUrl);
    if (!zUrlWide) {
        rc = SQLITE_NOMEM;
        goto error;
    }

    memset(&components, 0, sizeof(components));
    components.dwStructSize = sizeof(components);
    components.dwHostNameLength = 1;
    components.dwUrlPathLength = 1;
    if (!WinHttpCrackUrl(zUrlWide, 0, 0, &components)) {
        lastErr = GetLastError();
        errFunc = "WinHttpCrackUrl";
        goto error;
    }

    session = WinHttpOpen(L"sqlite3-http",
                          WINHTTP_ACCESS_TYPE_AUTOMATIC_PROXY,
                          WINHTTP_NO_PROXY_NAME,
                          WINHTTP_NO_PROXY_BYPASS,
                          0);

    if (!session) {
        lastErr = GetLastError();
        errFunc = "WinHttpCrackOpen";
        goto error;
    }

    // WinHttpSetStatusCallback(session,
    //     (WINHTTP_STATUS_CALLBACK)statusCallback,
    //     WINHTTP_CALLBACK_FLAG_ALL_NOTIFICATIONS,
    //     0);

    zHostWide = sqlite3_malloc(sizeof(wchar_t) * (components.dwHostNameLength + 1));
    if (!zHostWide) {
        rc = SQLITE_NOMEM;
        goto error;
    }
    memcpy(zHostWide, components.lpszHostName, sizeof(wchar_t) * components.dwHostNameLength);
    zHostWide[components.dwHostNameLength] = L'\0';

    conn = WinHttpConnect(session, zHostWide, components.nPort, 0);

    if (!conn) {
        lastErr = GetLastError();
        errFunc = "WinHttpConnect";
        goto error;
    }

    zMethodWide = utf8_to_unicode(req->zMethod);
    if (!zMethodWide) {
        rc = SQLITE_NOMEM;
        goto error;
    }

    request = WinHttpOpenRequest(conn,
                                 zMethodWide,
                                 components.lpszUrlPath,
                                 NULL,
                                 WINHTTP_NO_REFERER,
                                 WINHTTP_DEFAULT_ACCEPT_TYPES,
                                 components.nPort == 443 ? WINHTTP_FLAG_SECURE : 0);

    if (!request) {
        lastErr = GetLastError();
        errFunc = "WinHttpOpenRequest";
        goto error;
    }

    if (req->zHeaders) {
        zHeadersWide = utf8_to_unicode(req->zHeaders);
    }

    if (!WinHttpSendRequest(request,
                            zHeadersWide,
                            zHeadersWide ? -1 : 0,
                            (void*)req->pBody,
                            req->szBody,
                            req->szBody,
                            0)) {
        lastErr = GetLastError();
        errFunc = "WinHttpSendRequest";
        goto error;
    }

    if (!WinHttpReceiveResponse(request, NULL)) {
        lastErr = GetLastError();
        errFunc = "WinHttpReceiveResponse";
        goto error;
    }

    assert(resp->pBody == NULL);
    assert(resp->szBody == 0);
    for (;;) {
        DWORD dwSize = 0;
        DWORD nRead = 0;
        char* nb;
        if (!WinHttpQueryDataAvailable(request, &dwSize)) {
            lastErr = GetLastError();
            errFunc = "WinHttpQueryDataAvailable";
            goto error;
        }
        if (dwSize == 0) {
            break;
        }
        nb = sqlite3_realloc(resp->pBody, resp->szBody + dwSize);
        if (!nb) {
            rc = SQLITE_NOMEM;
            goto error;
        }
        resp->pBody = nb;
        if (!WinHttpReadData(request, (char*)resp->pBody + resp->szBody, dwSize, &nRead)) {
            lastErr = GetLastError();
            errFunc = "WinHttpReadData";
            goto error;
        }
        resp->szBody += dwSize;
        if (nRead == 0) {
            break;
        }
    }

    rc = query_headers(request, WINHTTP_QUERY_RAW_HEADERS_CRLF, &resp->zHeaders);
    if (rc != SQLITE_OK) {
        if (rc == SQLITE_ERROR) {
            lastErr = GetLastError();
            errFunc = "WinHttpQueryHeaders(WINHTTP_QUERY_RAW_HEADERS_CRLF)";
        }
        goto error;
    }
    rc = SQLITE_ERROR; // need to reset this back. Otherwise a jump to error below
                       // could leave rc as SQLITE_OK...

    dwSize = sizeof(dwStatusCode);
    if (!WinHttpQueryHeaders(request,
                             WINHTTP_QUERY_STATUS_CODE | WINHTTP_QUERY_FLAG_NUMBER,
                             WINHTTP_HEADER_NAME_BY_INDEX,
                             &dwStatusCode,
                             &dwSize,
                             WINHTTP_NO_HEADER_INDEX)) {
        lastErr = GetLastError();
        errFunc = "WinHttpQueryHeaders(WINHTTP_QUERY_STATUS_CODE)";
        goto error;
    }

    resp->iStatusCode = dwStatusCode;

    remove_all_but_last_headers(resp->zHeaders);
    separate_status_and_headers(&resp->zStatus, resp->zHeaders);

    rc = SQLITE_OK;

    goto done;

error:

    if (rc == SQLITE_ERROR && errFunc) {
        *ppErrMsg = win32_get_last_error(lastErr);
    }

done:

    sqlite3_free(zUrlWide);
    sqlite3_free(zHostWide);
    sqlite3_free(zMethodWide);
    sqlite3_free(zHeadersWide);
    WinHttpCloseHandle(request);
    WinHttpCloseHandle(conn);
    WinHttpCloseHandle(session);

    return rc;
}

#endif // HTTP_BACKEND_WINHTTP

/********** src/http_next_header.c **********/

#include <ctype.h>
#include <sqlite3.h>

static int is_token_char(int c) {
    return isalnum(c) || (c != 0 && strchr("!#$%&'*+-.^_`|~", c));
}

static int is_header_ws(int c) {
    return c == ' ' || c == '\t';
}

static int is_vchar(int c) {
    return c >= 0x21 && c <= 0x7e;
}

// Return SQLITE_ROW if a header was extracted
// Return SQLITE_DONE if headers has been exhausted
// Return SQLITE_ERROR on malformed input
int http_next_header(const char* headers,
                     int size,
                     int* pParsed,
                     const char** ppName,
                     int* pNameSize,
                     const char** ppValue,
                     int* pValueSize) {
    const char* headersEnd = headers + size;
    const char* nameStart = NULL;
    const char* nameEnd = NULL;
    const char* valueStart = NULL;
    const char* valueEnd = NULL;
    const char* last = NULL;
    const char* p = headers;

    enum {
        StateInit,
        StateName,
        StateNameTrailingWs,
        StateValueLeadingWs,
        StateValue,
        StateCR,
        StateCheckFold,
        StateDone,
        StateError,
    };

    int state = StateInit;

    *ppName = NULL;
    *pNameSize = 0;
    *ppValue = NULL;
    *pValueSize = 0;

    if (size == 0) {
        *pParsed = 0;
        return SQLITE_DONE;
    }

    for (; p != headersEnd && state != StateDone && state != StateError; ++p) {
        switch (state) {
        case StateInit:
            // printf("StateInit %02x %c\n", *p, isalnum(*p) ? *p : ' ');
            if (*p == '\r') {
                state = StateCR;
            } else if (is_header_ws(*p)) {
                // There shouldn't be whitespace here. Folding is handled in
                // StateCR/StateCheckFold.
                state = StateError;
            } else {
                nameStart = p;
                state = StateName;
            }
            break;

        case StateName:
            // printf("StateName %02x %c\n", *p, isalnum(*p) ? *p : ' ');
            if (is_token_char(*p)) {
                // accept
            } else if (*p == ':') {
                nameEnd = p;
                state = StateValueLeadingWs;
            } else if (is_header_ws(*p)) {
                nameEnd = p;
                state = StateNameTrailingWs;
            } else {
                state = StateError;
            }
            break;

        case StateNameTrailingWs:
            // printf("StateNameTrailingWs %02x %c\n", *p, isalnum(*p) ? *p : ' ');
            if (is_header_ws(*p)) {
                // accept and skip
            } else if (*p == ':') {
                state = StateValueLeadingWs;
            } else {
                state = StateError;
            }
            break;

        case StateValueLeadingWs:
            // printf("StateValueLeadingWs %02x %c\n", *p, isalnum(*p) ? *p : ' ');
            if (is_header_ws(*p)) {
                // accept and skip
            } else if (*p == '\r') {
                // empty value
                state = StateCR;
            } else if (is_vchar(*p)) {
                valueStart = p;
                last = p;
                state = StateValue;
            } else {
                state = StateError;
            }
            break;

        case StateValue:
            // printf("StateValue %02x %c\n", *p, isalnum(*p) ? *p : ' ');
            if (is_header_ws(*p)) {
                // accept but keep separate so that we can track trailing ws
            } else if (*p == '\r') {
                valueEnd = last + 1;
                state = StateCR;
            } else if (is_vchar(*p)) {
                // accept
                last = p;
            }
            break;

        case StateCR:
            // printf("StateCr %02x %c\n", *p, isalnum(*p) ? *p : ' ');
            if (*p == '\n') {
                // If there's more data, check for folding.
                if (p + 1 == headers + size) {
                    state = StateDone;
                } else {
                    state = StateCheckFold;
                }
            } else {
                state = StateError;
            }
            break;

        case StateCheckFold:
            // printf("StateCheckFold %02x %c\n", *p, isalnum(*p) ? *p : ' ');
            if (is_header_ws(*p)) {
                state = StateValue;
            } else {
                state = StateDone;
                --p;
            }
            break;
        }
    }

    *pParsed = p - headers;

    if (state != StateDone || state == StateError) {
        return SQLITE_ERROR;
    }

    if (!nameStart) {
        return SQLITE_DONE;
    }

    *ppName = nameStart;
    *pNameSize = nameEnd - nameStart;

    if (valueStart) {
        *ppValue = valueStart;
        *pValueSize = valueEnd - valueStart;
    }

    return SQLITE_ROW;
}