#include "cmp.h"
#include <fontconfig/fontconfig.h>
#include <assert.h>
#include <string.h>
#include <stdlib.h>
#include <stdio.h>

struct bytes {
    uint8_t *start;
    size_t offset;
    size_t length;
};

bool bytes_reader(struct cmp_ctx_s *ctx, void *data, size_t limit) {
    struct bytes *bytes = ctx->buf;
    if (bytes->offset + limit > bytes->length) return false;
    memcpy(data, bytes->start + bytes->offset, limit);
    bytes->offset += limit;
    return true;
}

bool bytes_skipper(struct cmp_ctx_s *ctx, size_t count) {
    struct bytes *bytes = ctx->buf;
    if (bytes->offset + count > bytes->length) return false;
    bytes->offset += count;
    return true;
}

size_t bytes_writer(struct cmp_ctx_s *ctx, const void *data, size_t count) {
    struct bytes *bytes = ctx->buf;
    if (bytes->offset + count > bytes->length) {
        bytes->start = realloc(bytes->start, 2*bytes->length);
        if (bytes->start == NULL) return 0;
        bytes->length = 2*bytes->length;
    }
    memcpy(bytes->start + bytes->offset, data, count);
    bytes->offset += count;
    return count;
}

bool cmp_bytes_init(cmp_ctx_t *ctx, uint8_t *buf, size_t length) {
    struct bytes *inner = malloc(sizeof(struct bytes));
    if (inner == NULL) return false;
    inner->start = buf;
    inner->offset = 0;
    inner->length = length;
    cmp_init(ctx, inner, bytes_reader, bytes_skipper, bytes_writer);
    return true;
}

bool cmp_bytes_alloc(cmp_ctx_t *ctx, size_t length) {
    uint8_t *bytes = malloc(length);
    if (bytes == NULL) return false;
    return cmp_bytes_init(ctx, bytes, length);
}

void cmp_bytes_free(cmp_ctx_t *ctx) {
    struct bytes *bytes = ctx->buf;
    free(bytes->start);
    free(bytes);
}

uint8_t *cmp_bytes_take(cmp_ctx_t *ctx, size_t *length) {
    struct bytes *bytes = ctx->buf;
    uint8_t *ret = bytes->start;
    if (length != NULL) *length = bytes->offset;
    free(bytes);
    return ret;
}

// The encoders, decoders, & (for testing) round-trip routines themselves!

FcStrSet *decodeStrSet(cmp_ctx_t *bytes) {
    if (bytes == NULL) return NULL;

    uint32_t size;
    if (!cmp_read_array(bytes, &size)) return NULL;

    FcStrSet *ret = FcStrSetCreate();
    if (ret == NULL) return NULL;

    for (uint32_t i = 0; i < size; i++) {
        char text[512]; // What's the appropriate size here?
        uint32_t str_size = 512;
        if (!cmp_read_str(bytes, text, &str_size)) goto fail;
        if (!FcStrSetAdd(ret, text)) goto fail;
    }
    return ret;
fail:
    FcStrSetDestroy(ret);
    return NULL;
}

FcStrSet *decodeFileSet(cmp_ctx_t *bytes) {
    if (bytes == NULL) return NULL;

    uint32_t size;
    if (!cmp_read_array(bytes, &size)) return NULL;

    FcStrSet *ret = FcStrSetCreate();
    if (ret == NULL) return NULL;

    for (uint32_t i = 0; i < size; i++) {
        char text[512]; // What's the appropriate size here?
        uint32_t str_size = 512;
        if (!cmp_read_str(bytes, text, &str_size)) goto fail;
        if (!FcStrSetAddFilename(ret, text)) goto fail;
    }
    return ret;
fail:
    FcStrSetDestroy(ret);
    return NULL;
}

bool encodeStrList(cmp_ctx_t *bytes, FcStrList *iter) {
    uint32_t size = 0;
    FcStrListFirst(iter);
    while (FcStrListNext(iter) != NULL) size++;
    if (!cmp_write_array(bytes, size)) return false;

    FcStrListFirst(iter);
    char *text = FcStrListNext(iter);
    while (text != NULL) {
        if (!cmp_write_str(bytes, text, strlen(text))) return false;
        text = FcStrListNext(iter);
    }
    return true;
}

bool encodeStrSet(cmp_ctx_t *bytes, FcStrSet *data) {
    if (bytes == NULL || data == NULL) return false;

    FcStrList *iter = FcStrListCreate(data);
    if (iter == NULL) return false;

    bool ret = encodeStrList(bytes, iter);
    FcStrListDone(iter);
    return ret;
}

uint8_t *testStrSet(uint8_t *in, size_t in_length, size_t *length) {
    if (in == NULL) return NULL;

    cmp_ctx_t bytes;
    if (!cmp_bytes_init(&bytes, in, in_length)) return false;
    FcStrSet *decoded = decodeStrSet(&bytes);
    cmp_bytes_take(&bytes, NULL);
    if (decoded == NULL) return NULL;

    if (!cmp_bytes_alloc(&bytes, in_length)) {FcStrSetDestroy(decoded); goto fail;}
    bool ok = encodeStrSet(&bytes, decoded);
    FcStrSetDestroy(decoded);
    if (ok) return cmp_bytes_take(&bytes, length);
    else {
fail:
        cmp_bytes_free(&bytes);
        return NULL;
    }
}

FcCharSet *decodeObjCharSet(cmp_ctx_t *bytes, cmp_object_t *head, cmp_object_t *first) {
    if (bytes == NULL || head == NULL) return NULL;

    int8_t type; uint32_t size;
    if (cmp_object_as_ext(head, &type, &size) && type == 'c' && size == 0)
        return FcCharSetCreate(); // Special unambiguous empty encoding!
    else if (!cmp_object_as_array(head, &size)) return NULL;

    FcCharSet *ret = FcCharSetCreate();
    if (ret == NULL) return NULL;

    FcChar32 prev = 0;
    /* Allow peek-ahead to different based on type inside list */
    if (size > 0 && first != NULL) {
        if (!cmp_object_as_uint(first, &prev)) goto fail;
        if (!FcCharSetAddChar(ret, prev)) goto fail;
        size--; // We've read the first entry of the array!
    }

    /* The proper decoding! Diff-compressed to minimize temp-memory used. */
    for (uint32_t i = 0; i < size; i++) {
        uint32_t x;
        if (!cmp_read_uint(bytes, &x)) goto fail;
        prev += x;
        if (!FcCharSetAddChar(ret, prev)) goto fail;
    }
    return ret;
fail:
    FcCharSetDestroy(ret);
    return NULL;
}

FcCharSet *decodeCharSet(cmp_ctx_t *bytes) {
    if (bytes == NULL) return NULL;

    cmp_object_t head;
    if (!cmp_read_object(bytes, &head)) return NULL;
    return decodeObjCharSet(bytes, &head, NULL);
}

bool encodeCharSet(cmp_ctx_t *bytes, const FcCharSet *data) {
    if (bytes == NULL || data == NULL) return false;

    FcChar32 size = FcCharSetCount(data);
    if (size == 0) { // Unambiguous empty encoding!
        return cmp_write_ext_marker(bytes, 'c', 0);
    }
    FcChar32 count = 0; // For validation
    if (!cmp_write_array(bytes, size)) return false;

    FcChar32 map[FC_CHARSET_MAP_SIZE];
    FcChar32 next;
    FcChar32 base = FcCharSetFirstPage(data, map, &next);
    FcChar32 prev = 0;
    while (base != FC_CHARSET_DONE) {
        for (unsigned int i = 0; i < FC_CHARSET_MAP_SIZE; i++) for (unsigned int j = 0; j < 32; j++) {
            if (map[i] & (1 << j)) {
                FcChar32 c = base + i*32 + j;
                if (!cmp_write_uinteger(bytes, c - prev)) return false;
                prev = c;
                count++;
            }
        }
        base = FcCharSetNextPage(data, map, &next);
    }
    //assert(size == count);
    return true;
}

uint8_t *testCharSet(uint8_t *in, size_t in_length, size_t *length) {
    if (in == NULL) return NULL;

    cmp_ctx_t bytes;
    if (!cmp_bytes_init(&bytes, in, in_length)) return false;
    FcCharSet *decoded = decodeCharSet(&bytes);
    cmp_bytes_take(&bytes, NULL);
    if (decoded == NULL) {return NULL;}

    if (!cmp_bytes_alloc(&bytes, in_length)) {
        FcCharSetDestroy(decoded);
        goto fail;
    }
    bool ok = encodeCharSet(&bytes, decoded);
    FcCharSetDestroy(decoded);
    if (ok) return cmp_bytes_take(&bytes, length);
    else {
fail:
        cmp_bytes_free(&bytes);
        return NULL;
    }
}

FcLangSet *decodeObjLangSet(cmp_ctx_t *bytes, cmp_object_t *head, cmp_object_t *first) {
    uint32_t size = 0;
    if (bytes == NULL || head == NULL || !cmp_object_as_array(head, &size)) return NULL;

    FcLangSet *ret = FcLangSetCreate();
    if (ret == NULL) return NULL;

    /* Allow peek ahead to differentiate based on type stored in list */
    if (first != NULL && size > 0) {
        #define LANG_BUF_SZ 32 // If I'm reading FontConfig code right, 16's enough, but be generous...
        char buf[LANG_BUF_SZ];
        if (!cmp_object_to_str(bytes, first, buf, LANG_BUF_SZ)) goto fail;
        char *lang = FcLangNormalize(buf);
        if (lang == NULL) goto fail;
        if (!FcLangSetAdd(ret, lang)) {free(lang); goto fail;}
        free(lang);
        size--;
    }

    /* The proper decoding! */
    for (uint32_t i = 0; i < size; i++) {
        char lang[10];
        uint32_t str_size = 10;
        if (!cmp_read_str(bytes, lang, &str_size)) goto fail;
        char *lang2 = FcLangNormalize(lang);
        if (lang2 == NULL) goto fail;
        if (!FcLangSetAdd(ret, lang2)) {free(lang2); goto fail;}
        free(lang2);
    }
    return ret;
fail:
    FcLangSetDestroy(ret);
    return NULL;
}

FcLangSet *decodeLangSet(cmp_ctx_t *bytes) {
    if (bytes == NULL) return NULL;
    cmp_object_t head;
    if (!cmp_read_object(bytes, &head)) return NULL;
    return decodeObjLangSet(bytes, &head, NULL);
}

bool encodeLangSet(cmp_ctx_t *bytes, const FcLangSet *data) {
    if (bytes == NULL || data == NULL) return false;
    FcStrSet *langs = FcLangSetGetLangs(data);
    if (langs == NULL) return false;
    bool ret = encodeStrSet(bytes, langs);
    FcStrSetDestroy(langs);
    return ret;
}

uint8_t *testLangSet(uint8_t *in, size_t in_length, size_t *length) {
    if (in == NULL) return NULL;

    cmp_ctx_t bytes;
    if (!cmp_bytes_init(&bytes, in, in_length)) return false;
    FcLangSet *decoded = decodeLangSet(&bytes);
    cmp_bytes_take(&bytes, NULL);
    if (decoded == NULL) return NULL;

    if (!cmp_bytes_alloc(&bytes, in_length)) {
        FcLangSetDestroy(decoded);
        goto fail;
    }
    bool ok = encodeLangSet(&bytes, decoded);
    FcLangSetDestroy(decoded);
    if (ok) return cmp_bytes_take(&bytes, length);
    else {
fail:
        cmp_bytes_free(&bytes);
        return NULL;
    }
}

FcObjectSet *decodeObjectSet(cmp_ctx_t *bytes) {
    if (bytes == NULL) return NULL;

    uint32_t size;
    if (!cmp_read_array(bytes, &size)) return NULL;

    FcObjectSet *ret = FcObjectSetCreate();
    for (uint32_t i = 0; i < size; i++) {
        char object[20];
        uint32_t o_size = 20;
        if (!cmp_read_str(bytes, object, &o_size)) goto fail;
        if (!FcObjectSetAdd(ret, object)) goto fail;
    }
    return ret;
fail:
    FcObjectSetDestroy(ret);
    return NULL;
}

// No corresponding objectset encoder.

FcRange *decodeObjRange(cmp_ctx_t *bytes, cmp_object_t *head) {
    uint32_t size = 0;
    if (bytes == NULL || head == NULL || !cmp_object_as_map(head, &size)) return NULL;

    double range[2];
    for (uint32_t i = 0; i < size; i++) {
        uint32_t j;
        if (!cmp_read_uint(bytes, &j)) return NULL;
        if (!cmp_read_double(bytes, &range[j])) return NULL;
    }
    return FcRangeCreateDouble(range[0], range[1]);
}

FcRange *decodeRange(cmp_ctx_t *bytes) {
    if (bytes == NULL) return NULL;

    cmp_object_t head;
    if (!cmp_read_object(bytes, &head)) return NULL;
    return decodeObjRange(bytes, &head);
}

bool encodeRange(cmp_ctx_t *bytes, const FcRange *data) {
    if (bytes == NULL || data == NULL) return false;

    double begin, end;
    if (!FcRangeGetDouble(data, &begin, &end)) return false;

    if (!cmp_write_map(bytes, 2)) return false;
    if (!cmp_write_uint(bytes, 0)) return false;
    if (!cmp_write_double(bytes, begin)) return false;
    if (!cmp_write_uint(bytes, 1)) return false;
    if (!cmp_write_double(bytes, end)) return false;
    return true;
}

uint8_t *testRange(uint8_t *in, size_t in_length, size_t *length) {
    if (in == NULL) return NULL;

    cmp_ctx_t bytes;
    if (!cmp_bytes_init(&bytes, in, in_length)) return false;
    FcRange *decoded = decodeRange(&bytes);
    cmp_bytes_take(&bytes, NULL);
    if (decoded == NULL) return NULL;

    if (!cmp_bytes_alloc(&bytes, in_length)) {FcRangeDestroy(decoded); goto fail;}
    bool ok = encodeRange(&bytes, decoded);
    FcRangeDestroy(decoded);
    if (ok) return cmp_bytes_take(&bytes, length);
    else {
fail:
        cmp_bytes_free(&bytes);
        return NULL;
    }
}

FcMatrix *decodeObjMatrix(cmp_ctx_t *bytes, cmp_object_t *head, cmp_object_t *next) {
    uint32_t size = 0;
    if (bytes == NULL || head == NULL) return NULL;
    if (!cmp_object_as_array(head, &size) || size != 4) return NULL;

    cmp_object_t first;
    if (next == NULL) {
        if (!cmp_read_object(bytes, &first)) return NULL;
    } else first = *next;
    if (!cmp_object_is_double(&first)) return NULL;

    FcMatrix *ret = malloc(sizeof(FcMatrix));
    if (ret == NULL) return NULL;
    if (!cmp_object_as_double(&first, &ret->xx)) goto fail;
    if (!cmp_read_double(bytes, &ret->xy)) goto fail;
    if (!cmp_read_double(bytes, &ret->yx)) goto fail;
    if (!cmp_read_double(bytes, &ret->yy)) goto fail;
    return ret;
fail:
    free(ret);
    return NULL;
}

FcMatrix *decodeMatrix(cmp_ctx_t *bytes) {
    if (bytes == NULL) return NULL;

    cmp_object_t head;
    if (!cmp_read_object(bytes, &head)) return NULL;
    return decodeObjMatrix(bytes, &head, NULL);
}

bool encodeMatrix(cmp_ctx_t *bytes, const FcMatrix *data) {
    if (bytes == NULL || data == NULL) return NULL;

    if (!cmp_write_array(bytes, 4)) return false;
    if (!cmp_write_double(bytes, data->xx)) return false;
    if (!cmp_write_double(bytes, data->xy)) return false;
    if (!cmp_write_double(bytes, data->yx)) return false;
    if (!cmp_write_double(bytes, data->yy)) return false;
    return true;
}

uint8_t *testMatrix(uint8_t *in, size_t in_length, size_t *length) {
    if (in == NULL) return NULL;

    cmp_ctx_t bytes;
    if (!cmp_bytes_init(&bytes, in, in_length)) return false;
    FcMatrix *decoded = decodeMatrix(&bytes);
    cmp_bytes_take(&bytes, NULL);
    if (decoded == NULL) return NULL;

    if (!cmp_bytes_alloc(&bytes, in_length)) {free(decoded); goto fail;}
    bool ok = encodeMatrix(&bytes, decoded);
    free(decoded);
    if (ok) return cmp_bytes_take(&bytes, length);
    else {
fail:
        cmp_bytes_free(&bytes);
        return NULL;
    }
}

bool decodeValue(cmp_ctx_t *bytes, FcValue *out) {
    if (bytes == NULL || out == NULL) return false;

    cmp_object_t head;
    if (!cmp_read_object(bytes, &head)) return NULL;
    bool b;
    uint32_t size;
    if (head.type == CMP_TYPE_NIL) out->type = FcTypeVoid;
    else if (cmp_object_as_int(&head, &out->u.i)) out->type = FcTypeInteger;
    else if (cmp_object_as_double(&head, &out->u.d)) out->type = FcTypeDouble;
    else if (cmp_object_as_str(&head, &size)) {
        out->type = FcTypeString;
        size++; // Include space for Nil byte!
        char *str = malloc(size);
        out->u.s = str;
        bool ok = cmp_object_to_str(bytes, &head, str, size);
        if (!ok) free(str);
        return ok;
    } else if (cmp_object_as_bool(&head, &b)) {
        out->type = FcTypeBool;
        out->u.b = b ? FcTrue : FcFalse; // Didn't auto-convert.
    } else if (cmp_object_as_array(&head, &size)) {
        cmp_object_t *first = NULL;
        cmp_object_t first_;
        if (size > 0) {
            first = &first_;
            if (!cmp_read_object(bytes, first)) return false;
        }
        if ((out->u.m = decodeObjMatrix(bytes, &head, first)) != NULL)
            out->type = FcTypeMatrix;
        // For ease of encoding empty lists are treated as lang sets.
        // Hence LangSets take priority during decode!
        else if ((out->u.l = decodeObjLangSet(bytes, &head, first)) != NULL)
            out->type = FcTypeLangSet;
        else if ((out->u.c = decodeObjCharSet(bytes, &head, first)) != NULL)
            out->type = FcTypeCharSet;
    } // Not supporting FcTypeFcFace
    else if ((out->u.r = decodeObjRange(bytes, &head)) != NULL)
        out->type = FcTypeRange;
    else return false;
    return true;
}

bool encodeValue(cmp_ctx_t *bytes, FcValue *data) {
    if (bytes == NULL || data == NULL) return false;

    switch (data->type) {
    case FcTypeVoid:
        return cmp_write_nil(bytes);
    case FcTypeInteger:
        return cmp_write_int(bytes, data->u.i);
    case FcTypeDouble:
        return cmp_write_double(bytes, data->u.d);
    case FcTypeString:
        return cmp_write_str(bytes, data->u.s, strlen(data->u.s));
    case FcTypeBool:
        return cmp_write_bool(bytes, data->u.b);
    case FcTypeMatrix:
        return encodeMatrix(bytes, data->u.m);
    case FcTypeCharSet:
        return encodeCharSet(bytes, data->u.c);
    case FcTypeFTFace:
        return true; // Not supporting this yet...
    case FcTypeLangSet:
        return encodeLangSet(bytes, data->u.l);
    case FcTypeRange:
        return encodeRange(bytes, data->u.r);
    default:
        return false;
    }
}

uint8_t *testValue(uint8_t *in, size_t in_length, size_t *length) {
    if (in == NULL) return NULL;

    cmp_ctx_t bytes;
    if (!cmp_bytes_init(&bytes, in, in_length)) return false;
    FcValue decoded;
    bool ok = decodeValue(&bytes, &decoded);
    cmp_bytes_take(&bytes, NULL);
    if (!ok) return NULL;

    if (!cmp_bytes_alloc(&bytes, in_length)) {FcValueDestroy(decoded); goto fail;}
    ok = encodeValue(&bytes, &decoded);
    FcValueDestroy(decoded);
    if (ok) return cmp_bytes_take(&bytes, length);
    else {
fail:
        cmp_bytes_free(&bytes);
        return NULL;
    }
}

FcPattern *decodePattern(cmp_ctx_t *bytes) {
    if (bytes == NULL) return NULL;

    uint32_t size;
    if (!cmp_read_map(bytes, &size)) return NULL;

    FcPattern *ret = FcPatternCreate();
    if (ret == NULL) return NULL;
    for (uint32_t i = 0; i < size; i++) {
        char object[20];
        uint32_t osize = 20;
        if (!cmp_read_str(bytes, object, &osize)) goto fail;
        uint32_t vsize;
        if (!cmp_read_array(bytes, &vsize)) goto fail;
        for (uint32_t j = 0; j < vsize; j++) {
            uint32_t tsize;
            if (!cmp_read_array(bytes, &tsize) || tsize != 2) goto fail;

            cmp_object_t strength;
            if (!cmp_read_object(bytes, &strength)) goto fail;
            bool is_strong = false;
            if (cmp_object_as_bool(&strength, &is_strong)) {}
            else if (cmp_object_is_nil(&strength)) {}
            else goto fail;

            FcValue val;
            if (!decodeValue(bytes, &val)) goto fail;
            //FcValuePrint(val);
            if (is_strong) {
                if (!FcPatternAdd(ret, object, val, true)) {FcValuePrint(val); goto fail;}
            } else {
                if (!FcPatternAddWeak(ret, object, val, true)) {FcValuePrint(val); goto fail;}
            }
            FcValueDestroy(val);
        }
    }
    return ret;
fail:
    FcPatternDestroy(ret);
    return NULL;
}

bool encodePattern(cmp_ctx_t *bytes, FcPattern *data) {
    if (bytes == NULL || data == NULL) return false;

    int size = FcPatternObjectCount(data);
    if (!cmp_write_map(bytes, size)) return false;

    FcPatternIter iter;
    FcPatternIterStart(data, &iter);
    int count = 0;
    do {
        count++;
        const char *obj = FcPatternIterGetObject(data, &iter);
        if (!cmp_write_str(bytes, obj, strlen(obj))) return false;
        int nvalues = FcPatternIterValueCount(data, &iter);
        if (!cmp_write_array(bytes, nvalues)) return false;
        for (int j = 0; j < nvalues; j++) {
            FcValue val;
            FcValueBinding weight;
            if (FcPatternIterGetValue(data, &iter, j, &val, &weight) != FcResultMatch)
                return false;

            if (!cmp_write_array(bytes, 2)) return false;
            switch (weight) {
            case FcValueBindingWeak:
                if (!cmp_write_bool(bytes, false)) return false;
                break;
            case FcValueBindingStrong:
                if (!cmp_write_bool(bytes, true)) return false;
                break;
            case FcValueBindingSame:
                if (!cmp_write_nil(bytes)) return false;
                break;
            default:
                return false;
            }
            if (!encodeValue(bytes, &val)) return false;
        }
    } while (FcPatternIterNext(data, &iter));
    assert(size == count);
    return true;
}

uint8_t *testPattern(uint8_t *in, size_t in_length, size_t *length) {
    if (in == NULL) return NULL;

    cmp_ctx_t bytes;
    if (!cmp_bytes_init(&bytes, in, in_length)) return false;
    FcPattern *decoded = decodePattern(&bytes);
    cmp_bytes_take(&bytes, NULL);
    if (decoded == NULL) return NULL;

    if (!cmp_bytes_alloc(&bytes, in_length)) {FcPatternDestroy(decoded); goto fail;}
    bool ok = encodePattern(&bytes, decoded);
    FcPatternDestroy(decoded);
    if (ok) return cmp_bytes_take(&bytes, length);
    else {
fail:
        cmp_bytes_free(&bytes);
        return NULL;
    }
}

FcFontSet *decodeFontSet(cmp_ctx_t *bytes) {
    if (bytes == NULL) return NULL;

    uint32_t size;
    if (!cmp_read_array(bytes, &size)) return NULL;

    FcFontSet *ret = FcFontSetCreate();
    if (ret == NULL) return NULL;

    for (uint32_t i = 0; i < size; i++) {
        FcPattern *font = decodePattern(bytes);
        if (font == NULL) goto fail;
        if (!FcFontSetAdd(ret, font)) goto fail;
    }
    return ret;
fail:
    FcFontSetDestroy(ret);
    return NULL;
}

FcFontSet **decodeFontSets(cmp_ctx_t *bytes, size_t *nsets) {
    if (bytes == NULL) return NULL;

    uint32_t size;
    if (!cmp_read_array(bytes, &size)) return NULL;
    if (nsets != NULL) *nsets = size;

    FcFontSet **ret = calloc(sizeof(FcFontSet *), size);
    uint32_t i;
    for (i = 0; i < size; i++) {
        ret[i] = decodeFontSet(bytes);
        if (ret[i] == NULL) goto fail;
        i++;
    }
    return ret;
fail:
    for (uint32_t j = 0; j < i; j++) FcFontSetDestroy(ret[j]);
    free(ret);
    return NULL;
}

bool encodeFontSet(cmp_ctx_t *bytes, FcFontSet *data) {
    if (bytes == NULL || data == NULL) return NULL;

    if (!cmp_write_array(bytes, data->nfont)) return false;
    for (int i = 0; i < data->nfont; i++) {
        if (!encodePattern(bytes, data->fonts[i])) return false;
    }
    return true;
}

uint8_t *testFontSet(uint8_t *in, size_t in_length, size_t *length) {
    if (in == NULL) return NULL;

    cmp_ctx_t bytes;
    if (!cmp_bytes_init(&bytes, in, in_length)) return false;
    FcFontSet *decoded = decodeFontSet(&bytes);
    cmp_bytes_take(&bytes, NULL);
    if (decoded == NULL) return NULL;

    if (!cmp_bytes_alloc(&bytes, in_length)) {
        FcFontSetDestroy(decoded);
        goto fail;
    }
    bool ok = encodeFontSet(&bytes, decoded);
    FcFontSetDestroy(decoded);
    if (ok) return cmp_bytes_take(&bytes, length);
    else {
fail:
        cmp_bytes_free(&bytes);
        return NULL;
    }
}

bool encodeRenderableFontSet(cmp_ctx_t *bytes, FcConfig *conf, FcPattern *pat, FcFontSet *data) {
    if (bytes == NULL || data == NULL) return false;

    if (!cmp_write_array(bytes, data->nfont)) return false;
    for (int i = 0; i < data->nfont; i++) {
        FcPattern *postprocessed = FcFontRenderPrepare(conf, pat, data->fonts[i]);
        if (postprocessed == NULL) return false;

        bool ok = encodePattern(bytes, postprocessed);
        FcPatternDestroy(postprocessed);
        if (!ok) return false;
    }
    return true;
}

bool encodeResult(cmp_ctx_t *bytes, FcResult res) {
    switch (res) {
    case FcResultMatch: // Should be handled by caller! Can't do anything sensible here.
    case FcResultNoMatch: // May be handled by caller.
        return cmp_write_nil(bytes);
    case FcResultTypeMismatch:
        return cmp_write_str(bytes, "ErrType", strlen("ErrType"));
    case FcResultNoId:
        return cmp_write_str(bytes, "ErrNoId", strlen("ErrNoId"));
    case FcResultOutOfMemory:
        return cmp_write_str(bytes, "ErrOOM", strlen("ErrOOM"));
    default:
        // Should never happen!
        return cmp_write_str(bytes, "ErrOther", strlen("ErrOther"));
    }
}