// Part of JoeyLib, Copyright (c) 2026 Scott Duensing, under the MIT License.
// See LICENSE.md for license information.
// SPDX-License-Identifier: MIT
//
// tiled2joey.c - a Tiled map as JoeyLib tiles and tile maps.
//
//     tiled2joey [--header OUT.h] MAP SHEET.png MAPDIR
//
// MAP is a Tiled map, TMX (XML) or TMJ (JSON): orthogonal, finite, with 8x8
// tiles. Its tilesets, embedded or external (TSX or TSJ), are single images,
// indexed PNGs whose colors make one palette of at most 16 between them:
// the first tileset's colors keep their indices (so its index 0 stays the
// background), and the others' are matched by color or given a slot the
// first does not use.
//
// SHEET.png gets the tiles the map's tile layers use, in a row, in the
// order they first appear: what assetbake --type tile bakes into a tile bank
// for each port. A tile Tiled draws flipped or rotated is baked as a tile of
// its own (JoeyLib draws no tile flipped), so the map can use up to 255
// distinct tiles and orientations between all its layers.
//
// MAPDIR gets one LAYER.map for each tile layer (its name, letters, digits,
// - and _ kept): width x height bytes, row after row, each a tile's index in
// the bank or 0xFF (JL_TILE_MAP_SKIP) where the layer is empty, as
// jlTileMapPaste takes them. The files are the same on every port.
//
// --header writes a C header naming the map's size, its tile count, and
// each layer's file. Object and image layers, tile animations, and tile
// properties are left out.

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

#include "toolBase64.h"
#include "toolBuf.h"
#include "toolFile.h"
#include "toolJson.h"
#include "toolPng.h"
#include "toolXml.h"
#include "toolZlib.h"

#define TOOL_NAME        "tiled2joey"
#define USAGE_EXIT       2
#define TILE_SIDE        8
#define TILE_PIXELS      (TILE_SIDE * TILE_SIDE)
#define MAX_TILES        255u
#define SKIP             0xFFu
#define MAX_COLORS       16u
#define FLIP_H           0x80000000u
#define FLIP_V           0x40000000u
#define FLIP_D           0x20000000u
#define ROTATE_HEX       0x10000000u
#define GID_MASK         0x0FFFFFFFu
#define GID_BYTES        4u
#define MAP_EXTENSION    ".map"
// A map is XML when its first bytes, after any space, start with '<'.
#define XML_SNIFF_BYTES  64u
// Room for one field's text, and for a name as Python's repr() shows it.
#define FIELD_TEXT_MAX   64u
#define REPR_MAX         512u
#define PATH_MAX_BYTES   4096u
#define DIR_MODE         0777
#define PRINTABLE_FIRST  0x20u
#define PRINTABLE_END    0x7Fu
#define ASCII_END        0x80u
#define UTF8_CONT_MASK   0xC0u
#define UTF8_CONT        0x80u
// Python's float repr: the shortest of up to this many digits that reads
// back the same.
#define FLOAT_DIGITS_MAX 17

// A header or tileset field as Python held it: missing (None), and if not,
// its str() and, when int() of it works, that.
typedef struct FieldT {
    bool present;
    char text[FIELD_TEXT_MAX];
    bool hasInt;
    long value;
} FieldT;

// A tileset: what the map says of it, and once its image is read, its
// tiles as 8x8 grids of sheet palette indices.
typedef struct TilesetT {
    char    *name;
    long     firstGid;
    long     tileWidth;
    long     tileHeight;
    long     margin;
    long     spacing;
    long     columns;
    char    *image;
    bool     animated;
    uint8_t *tiles;
    size_t   tileCount;
} TilesetT;

typedef struct LayerT {
    char     *name;
    uint32_t *gids;
    size_t    gidCount;
} LayerT;

typedef struct MapT {
    FieldT    orientation;
    FieldT    infinite;
    FieldT    tileWidth;
    FieldT    tileHeight;
    FieldT    width;
    FieldT    height;
    TilesetT *tilesets;
    size_t    tilesetCount;
    LayerT   *layers;
    size_t    layerCount;
} MapT;

// A distinct tile the layers place: its tileset, its tile there, and how
// Tiled flips it.
typedef struct TileKeyT {
    long     firstGid;
    size_t   local;
    uint32_t flags;
} TileKeyT;

static void        decodeData(const char *layerName, const char *text, const ToolJsonT *list, const char *encoding, const char *compression, LayerT *layer);
static char       *dirName(const char *path);
static void        fieldFromJson(FieldT *field, const ToolJsonT *value);
static void        fieldFromText(FieldT *field, const char *text);
static void        gidAdd(LayerT *layer, uint32_t gid);
static bool        isXml(const uint8_t *data, size_t len);
static void        jsonLayers(const ToolJsonT *items, MapT *map);
static long        jsonLong(const ToolJsonT *value, const char *what, const char *name);
static void        layerAdd(MapT *map, const char *name, LayerT *layer);
static void        layerFileName(const char *name, char **taken, size_t takenCount, char *out, size_t outSize);
static void        loadMap(const char *path, MapT *map);
static void        loadTileset(const char *path, TilesetT *tileset);
static void        loadTilesetJson(const ToolJsonT *data, const char *base, TilesetT *tileset);
static void        loadTilesetXml(const ToolXmlT *element, const char *base, TilesetT *tileset);
static void        makeDirs(const char *path);
static char       *pathJoin(const char *base, const char *name);
static const char *pyRepr(const char *s);
static void        pyUpperIdent(const char *s, size_t len, FILE *f);
static uint8_t    *readAll(const char *path, size_t *len);
static char       *stringCopy(const char *s);
static void        tilesetAdd(MapT *map, long firstGid, TilesetT *tileset);
static void        tilesetPixels(TilesetT *tileset, uint8_t palette[MAX_COLORS][3], bool used[MAX_COLORS], bool first);
static void        usage(void);
static void        writeHeader(const char *path, const char *mapPath, long width, long height, size_t count, const MapT *map, char **files);
static void        xmlLayers(const ToolXmlT *element, MapT *map);
static long        xmlLong(const ToolXmlT *element, const char *attr, long fallback, bool required);


// A layer's gids from its data: csv (text, or a JSON list), or base64 of
// little-endian 32-bit words, raw, zlib or gzip.
static void decodeData(const char *layerName, const char *text, const ToolJsonT *list, const char *encoding, const char *compression, LayerT *layer) {
    const char *p;
    const char *start;
    uint8_t    *raw;
    uint8_t    *inflated;
    size_t      rawLen;
    size_t      inflatedLen;
    size_t      i;
    long        v;
    double      d;

    if (encoding == NULL || encoding[0] == '\0' || strcmp(encoding, "csv") == 0) {
        if (list != NULL) {
            for (i = 0; i < list->count; i++) {
                if (list->items[i]->type == TOOL_JSON_NUMBER) {
                    d = trunc(list->items[i]->number);
                    gidAdd(layer, (uint32_t)(int64_t)d);
                } else if (list->items[i]->type == TOOL_JSON_BOOL) {
                    gidAdd(layer, list->items[i]->boolean ? 1u : 0u);
                } else if (list->items[i]->type == TOOL_JSON_STRING && toolParseInt(list->items[i]->string, strlen(list->items[i]->string), &v)) {
                    gidAdd(layer, (uint32_t)v);
                } else {
                    toolFail("layer %s holds a cell that is not a number", pyRepr(layerName));
                }
            }
            return;
        }
        // Numbers apart by any run of commas and space.
        for (p = text; *p != '\0';) {
            while (*p == ',' || isspace((unsigned char)*p)) {
                p++;
            }
            if (*p == '\0') {
                break;
            }
            start = p;
            while (*p != '\0' && *p != ',' && !isspace((unsigned char)*p)) {
                p++;
            }
            if (!toolParseInt(start, (size_t)(p - start), &v)) {
                toolFail("layer %s holds '%.*s', which is not a number", pyRepr(layerName), (int)(p - start), start);
            }
            gidAdd(layer, (uint32_t)v);
        }
        return;
    }
    if (strcmp(encoding, "base64") != 0) {
        toolFail("layer encoding %s is not supported", pyRepr(encoding));
    }
    if (text == NULL || !toolBase64Decode(text, strlen(text), &raw, &rawLen)) {
        toolFail("layer %s's base64 data is broken", pyRepr(layerName));
    }
    if (compression != NULL && compression[0] != '\0') {
        if (strcmp(compression, "zlib") != 0 && strcmp(compression, "gzip") != 0) {
            toolFail("layer compression %s is not supported (use zlib, gzip, or none)", pyRepr(compression));
        }
        if (!toolInflate(raw, rawLen, strcmp(compression, "zlib") == 0 ? TOOL_ZLIB_ZLIB : TOOL_ZLIB_GZIP, &inflated, &inflatedLen)) {
            toolFail("layer %s's %s data is broken", pyRepr(layerName), compression);
        }
        free(raw);
        raw    = inflated;
        rawLen = inflatedLen;
    }
    if (rawLen % GID_BYTES != 0u) {
        toolFail("layer %s's data is not whole 32-bit cells", pyRepr(layerName));
    }
    for (i = 0; i < rawLen; i += GID_BYTES) {
        gidAdd(layer, (uint32_t)raw[i] | ((uint32_t)raw[i + 1u] << 8) | ((uint32_t)raw[i + 2u] << 16) | ((uint32_t)raw[i + 3u] << 24));
    }
    free(raw);
}


// The folder a path is in ("" for a bare name), as Python's os.path.dirname.
static char *dirName(const char *path) {
    const char *slash;
    char       *out;
    size_t      n;

    slash = strrchr(path, '/');
    n     = slash == NULL ? 0u : (size_t)(slash - path);
    // A path's leading slashes stay (dirname("/a") is "/").
    while (slash != NULL && n == 0u && path[n] == '/') {
        n++;
    }
    while (n > 1u && path[n - 1u] == '/') {
        n--;
    }
    if (slash != NULL && n == 0u) {
        n = 1u;
    }
    out = (char *)malloc(n + 1u);
    if (out == NULL) {
        toolFail("out of memory");
    }
    memcpy(out, path, n);
    out[n] = '\0';
    return out;
}


// A JSON member as Python held it: None for null or missing; str() and
// int() as Python makes them of a string, a number, or a bool.
static void fieldFromJson(FieldT *field, const ToolJsonT *value) {
    int    digits;
    double back;

    memset(field, 0, sizeof(*field));
    if (value == NULL || value->type == TOOL_JSON_NULL) {
        snprintf(field->text, FIELD_TEXT_MAX, "None");
        return;
    }
    field->present = true;
    if (value->type == TOOL_JSON_STRING) {
        snprintf(field->text, FIELD_TEXT_MAX, "%s", value->string);
        field->hasInt = toolParseInt(value->string, strlen(value->string), &field->value);
    } else if (value->type == TOOL_JSON_BOOL) {
        snprintf(field->text, FIELD_TEXT_MAX, "%s", value->boolean ? "True" : "False");
        field->hasInt = true;
        field->value  = value->boolean ? 1 : 0;
    } else if (value->type == TOOL_JSON_NUMBER) {
        field->hasInt = isfinite(value->number) != 0;
        field->value  = field->hasInt ? (long)trunc(value->number) : 0;
        if (value->integer) {
            snprintf(field->text, FIELD_TEXT_MAX, "%.0f", value->number);
        } else {
            // Python's repr of a float: the fewest digits that read back.
            for (digits = 1; digits <= FLOAT_DIGITS_MAX; digits++) {
                snprintf(field->text, FIELD_TEXT_MAX, "%.*g", digits, value->number);
                back = strtod(field->text, NULL);
                if (back == value->number) {
                    break;
                }
            }
            if (strpbrk(field->text, ".einf") == NULL) {
                strncat(field->text, ".0", FIELD_TEXT_MAX - strlen(field->text) - 1u);
            }
        }
    } else {
        snprintf(field->text, FIELD_TEXT_MAX, "%s", value->type == TOOL_JSON_ARRAY ? "[...]" : "{...}");
    }
}


// An XML attribute as Python held it: None when missing, else its text, and
// int() of it when that works.
static void fieldFromText(FieldT *field, const char *text) {
    memset(field, 0, sizeof(*field));
    if (text == NULL) {
        snprintf(field->text, FIELD_TEXT_MAX, "None");
        return;
    }
    field->present = true;
    snprintf(field->text, FIELD_TEXT_MAX, "%s", text);
    field->hasInt = toolParseInt(text, strlen(text), &field->value);
}


// A gid added to a layer (the list grows to each next power of two).
static void gidAdd(LayerT *layer, uint32_t gid) {
    uint32_t *gids;

    if ((layer->gidCount & (layer->gidCount - 1u)) == 0u) {
        gids = (uint32_t *)realloc(layer->gids, (layer->gidCount == 0u ? 1u : layer->gidCount * 2u) * sizeof(uint32_t));
        if (gids == NULL) {
            toolFail("out of memory");
        }
        layer->gids = gids;
    }
    layer->gids[layer->gidCount++] = gid;
}


// XML when the first bytes, after any space, start with '<'.
static bool isXml(const uint8_t *data, size_t len) {
    size_t i;
    size_t n;

    n = len < XML_SNIFF_BYTES ? len : XML_SNIFF_BYTES;
    for (i = 0; i < n && (data[i] == ' ' || data[i] == '\t' || data[i] == '\n' || data[i] == '\r' || data[i] == '\v' || data[i] == '\f'); i++) {
    }
    return i < n && data[i] == '<';
}


// A TMJ layer list's tile layers, groups' too, in order.
static void jsonLayers(const ToolJsonT *items, MapT *map) {
    const ToolJsonT *layer;
    const ToolJsonT *type;
    const ToolJsonT *data;
    const ToolJsonT *nameValue;
    const ToolJsonT *encoding;
    const ToolJsonT *compression;
    const char      *name;
    LayerT           out;
    size_t           i;

    if (items == NULL || items->type != TOOL_JSON_ARRAY) {
        return;
    }
    for (i = 0; i < items->count; i++) {
        layer = items->items[i];
        type  = toolJsonGet(layer, "type");
        if (type == NULL || type->type != TOOL_JSON_STRING) {
            continue;
        }
        nameValue = toolJsonGet(layer, "name");
        name      = (nameValue != NULL && nameValue->type == TOOL_JSON_STRING) ? nameValue->string : NULL;
        if (strcmp(type->string, "group") == 0) {
            jsonLayers(toolJsonGet(layer, "layers"), map);
        } else if (strcmp(type->string, "tilelayer") == 0) {
            if (toolJsonGet(layer, "chunks") != NULL) {
                toolFail("layer %s is in chunks (an infinite map); make the map finite", pyRepr(name));
            }
            data = toolJsonGet(layer, "data");
            if (data == NULL) {
                toolFail("layer %s has no data", pyRepr(name));
            }
            encoding    = toolJsonGet(layer, "encoding");
            compression = toolJsonGet(layer, "compression");
            memset(&out, 0, sizeof(out));
            decodeData(name, data->type == TOOL_JSON_STRING ? data->string : NULL, data->type == TOOL_JSON_ARRAY ? data : NULL, (encoding != NULL && encoding->type == TOOL_JSON_STRING) ? encoding->string : NULL, (compression != NULL && compression->type == TOOL_JSON_STRING) ? compression->string : NULL, &out);
            layerAdd(map, name, &out);
        }
    }
}


// A JSON tileset's number field; a fatal error when it is not one.
static long jsonLong(const ToolJsonT *value, const char *what, const char *name) {
    if (value == NULL || value->type != TOOL_JSON_NUMBER) {
        toolFail("tileset %s has no %s", pyRepr(name), what);
    }
    return (long)trunc(value->number);
}


static void layerAdd(MapT *map, const char *name, LayerT *layer) {
    LayerT *layers;

    layers = (LayerT *)realloc(map->layers, (map->layerCount + 1u) * sizeof(LayerT));
    if (layers == NULL) {
        toolFail("out of memory");
    }
    map->layers                       = layers;
    layer->name                       = name != NULL ? stringCopy(name) : NULL;
    map->layers[map->layerCount++]    = *layer;
}


// A layer's file name: its name, every run of characters but letters,
// digits, - and _ made one _, with no _ at either end ("layer" if nothing
// is left), and _2, _3, ... after it while that is taken.
static void layerFileName(const char *name, char **taken, size_t takenCount, char *out, size_t outSize) {
    ToolBufT base;
    size_t   i;
    size_t   start;
    size_t   end;
    size_t   t;
    long     n;
    bool     clash;
    bool     inRun;
    char     c;

    memset(&base, 0, sizeof(base));
    inRun = false;
    for (i = 0; name != NULL && name[i] != '\0'; i++) {
        c = name[i];
        if (isalnum((unsigned char)c) && (unsigned char)c < ASCII_END) {
            toolBufByte(&base, (uint8_t)c);
            inRun = false;
        } else if (c == '_' || c == '-') {
            toolBufByte(&base, (uint8_t)c);
            inRun = false;
        } else if (!inRun) {
            toolBufByte(&base, '_');
            inRun = true;
        }
    }
    start = 0u;
    end   = base.len;
    while (start < end && base.data[start] == '_') {
        start++;
    }
    while (end > start && base.data[end - 1u] == '_') {
        end--;
    }
    if (start == end) {
        snprintf(out, outSize, "layer");
    } else {
        snprintf(out, outSize, "%.*s", (int)(end - start), (const char *)base.data + start);
    }
    toolBufFree(&base);
    start = strlen(out);
    for (n = 2;; n++) {
        clash = false;
        for (t = 0; t < takenCount; t++) {
            if (strcmp(taken[t], out) == 0) {
                clash = true;
            }
        }
        if (!clash) {
            break;
        }
        snprintf(out + start, outSize - start, "_%ld", n);
    }
}


// The map at path: its header, tilesets (sorted by firstgid, a stable
// sort), and tile layers.
static void loadMap(const char *path, MapT *map) {
    uint8_t         *data;
    size_t           len;
    size_t           i;
    size_t           j;
    char            *base;
    char            *joined;
    char             err[TOOL_XML_ERROR_BYTES];
    ToolXmlT        *root;
    ToolJsonT       *json;
    const ToolJsonT *tilesets;
    const ToolJsonT *entry;
    const ToolJsonT *firstGid;
    const ToolJsonT *source;
    const char      *sourceText;
    TilesetT         tileset;
    TilesetT         held;
    long             width;
    long             height;

    memset(map, 0, sizeof(*map));
    data = readAll(path, &len);
    base = dirName(path);
    if (isXml(data, len)) {
        root = toolXmlParse((const char *)data, len, err);
        if (root == NULL) {
            toolFail("%s: %s", path, err);
        }
        fieldFromText(&map->orientation, toolXmlAttr(root, "orientation"));
        fieldFromText(&map->infinite, toolXmlAttr(root, "infinite"));
        fieldFromText(&map->tileWidth, toolXmlAttr(root, "tilewidth"));
        fieldFromText(&map->tileHeight, toolXmlAttr(root, "tileheight"));
        fieldFromText(&map->width, toolXmlAttr(root, "width"));
        fieldFromText(&map->height, toolXmlAttr(root, "height"));
        for (i = 0; i < root->childCount; i++) {
            if (strcmp(root->children[i]->name, "tileset") != 0) {
                continue;
            }
            memset(&tileset, 0, sizeof(tileset));
            sourceText = toolXmlAttr(root->children[i], "source");
            if (sourceText != NULL && sourceText[0] != '\0') {
                joined = pathJoin(base, sourceText);
                loadTileset(joined, &tileset);
                free(joined);
            } else {
                loadTilesetXml(root->children[i], base, &tileset);
            }
            tilesetAdd(map, xmlLong(root->children[i], "firstgid", 0, true), &tileset);
        }
        xmlLayers(root, map);
        toolXmlFree(root);
    } else {
        json = toolJsonParse((const char *)data, len, err);
        if (json == NULL) {
            toolFail("%s: %s", path, err);
        }
        if (json->type != TOOL_JSON_OBJECT) {
            toolFail("%s is not a Tiled map", path);
        }
        fieldFromJson(&map->orientation, toolJsonGet(json, "orientation"));
        fieldFromJson(&map->infinite, toolJsonGet(json, "infinite"));
        fieldFromJson(&map->tileWidth, toolJsonGet(json, "tilewidth"));
        fieldFromJson(&map->tileHeight, toolJsonGet(json, "tileheight"));
        fieldFromJson(&map->width, toolJsonGet(json, "width"));
        fieldFromJson(&map->height, toolJsonGet(json, "height"));
        tilesets = toolJsonGet(json, "tilesets");
        for (i = 0; tilesets != NULL && tilesets->type == TOOL_JSON_ARRAY && i < tilesets->count; i++) {
            entry = tilesets->items[i];
            memset(&tileset, 0, sizeof(tileset));
            source = toolJsonGet(entry, "source");
            if (source != NULL) {
                if (source->type != TOOL_JSON_STRING) {
                    toolFail("a tileset's source is not a file name");
                }
                joined = pathJoin(base, source->string);
                loadTileset(joined, &tileset);
                free(joined);
            } else {
                loadTilesetJson(entry, base, &tileset);
            }
            firstGid = toolJsonGet(entry, "firstgid");
            if (firstGid == NULL || firstGid->type != TOOL_JSON_NUMBER) {
                toolFail("a tileset has no firstgid");
            }
            tilesetAdd(map, (long)trunc(firstGid->number), &tileset);
        }
        jsonLayers(toolJsonGet(json, "layers"), map);
        toolJsonFree(json);
    }
    free(base);
    free(data);
    if (!map->orientation.present || strcmp(map->orientation.text, "orthogonal") != 0) {
        toolFail("the map is %s; only orthogonal maps are supported", map->orientation.text);
    }
    for (i = 0; map->infinite.text[i] != '\0'; i++) {
        map->infinite.text[i] = (char)tolower((unsigned char)map->infinite.text[i]);
    }
    if (map->infinite.present && (strcmp(map->infinite.text, "1") == 0 || strcmp(map->infinite.text, "true") == 0)) {
        toolFail("the map is infinite; make it finite");
    }
    if (!map->tileWidth.hasInt || !map->tileHeight.hasInt) {
        toolFail("the map's tile size is %sx%s, not numbers", map->tileWidth.text, map->tileHeight.text);
    }
    if (map->tileWidth.value != TILE_SIDE || map->tileHeight.value != TILE_SIDE) {
        toolFail("the map's tiles are %sx%s; JoeyLib's are 8x8", map->tileWidth.text, map->tileHeight.text);
    }
    if (!map->width.hasInt || !map->height.hasInt) {
        toolFail("the map's size is %sx%s, not numbers", map->width.text, map->height.text);
    }
    width  = map->width.value;
    height = map->height.value;
    if (map->layerCount == 0u) {
        toolFail("the map has no tile layers");
    }
    for (i = 0; i < map->layerCount; i++) {
        if ((long)map->layers[i].gidCount != width * height) {
            toolFail("layer %s holds %zu cells, not %ld", pyRepr(map->layers[i].name), map->layers[i].gidCount, width * height);
        }
    }
    // A stable insertion sort by firstgid.
    for (i = 1; i < map->tilesetCount; i++) {
        held = map->tilesets[i];
        for (j = i; j > 0u && map->tilesets[j - 1u].firstGid > held.firstGid; j--) {
            map->tilesets[j] = map->tilesets[j - 1u];
        }
        map->tilesets[j] = held;
    }
}


// An external tileset file, TSX or TSJ; its image is relative to it.
static void loadTileset(const char *path, TilesetT *tileset) {
    uint8_t   *data;
    size_t     len;
    char      *base;
    char       err[TOOL_XML_ERROR_BYTES];
    ToolXmlT  *root;
    ToolJsonT *json;

    data = readAll(path, &len);
    base = dirName(path);
    if (isXml(data, len)) {
        root = toolXmlParse((const char *)data, len, err);
        if (root == NULL) {
            toolFail("%s: %s", path, err);
        }
        loadTilesetXml(root, base, tileset);
        toolXmlFree(root);
    } else {
        json = toolJsonParse((const char *)data, len, err);
        if (json == NULL) {
            toolFail("%s: %s", path, err);
        }
        loadTilesetJson(json, base, tileset);
        toolJsonFree(json);
    }
    free(base);
    free(data);
}


static void loadTilesetJson(const ToolJsonT *data, const char *base, TilesetT *tileset) {
    const ToolJsonT *nameValue;
    const ToolJsonT *image;
    const ToolJsonT *value;
    const ToolJsonT *tiles;
    size_t           i;

    nameValue     = toolJsonGet(data, "name");
    tileset->name = (nameValue != NULL && nameValue->type == TOOL_JSON_STRING) ? stringCopy(nameValue->string) : NULL;
    image         = toolJsonGet(data, "image");
    if (image == NULL) {
        toolFail("tileset %s is a collection of images; use one image", pyRepr(tileset->name));
    }
    tileset->tileWidth  = jsonLong(toolJsonGet(data, "tilewidth"), "tilewidth", tileset->name);
    tileset->tileHeight = jsonLong(toolJsonGet(data, "tileheight"), "tileheight", tileset->name);
    value               = toolJsonGet(data, "margin");
    tileset->margin     = value != NULL ? jsonLong(value, "margin", tileset->name) : 0;
    value               = toolJsonGet(data, "spacing");
    tileset->spacing    = value != NULL ? jsonLong(value, "spacing", tileset->name) : 0;
    value               = toolJsonGet(data, "columns");
    tileset->columns    = value != NULL ? jsonLong(value, "columns", tileset->name) : 0;
    if (image->type != TOOL_JSON_STRING) {
        toolFail("tileset %s's image is not a file name", pyRepr(tileset->name));
    }
    tileset->image = pathJoin(base, image->string);
    tiles          = toolJsonGet(data, "tiles");
    for (i = 0; tiles != NULL && tiles->type == TOOL_JSON_ARRAY && i < tiles->count; i++) {
        if (toolJsonGet(tiles->items[i], "animation") != NULL) {
            tileset->animated = true;
        }
    }
}


static void loadTilesetXml(const ToolXmlT *element, const char *base, TilesetT *tileset) {
    const ToolXmlT *image;
    const char     *nameText;
    const char     *source;
    size_t          i;

    nameText      = toolXmlAttr(element, "name");
    tileset->name = nameText != NULL ? stringCopy(nameText) : NULL;
    image         = toolXmlChild(element, "image");
    if (image == NULL) {
        toolFail("tileset %s is a collection of images; use one image", pyRepr(tileset->name));
    }
    tileset->tileWidth  = xmlLong(element, "tilewidth", 0, true);
    tileset->tileHeight = xmlLong(element, "tileheight", 0, true);
    tileset->margin     = xmlLong(element, "margin", 0, false);
    tileset->spacing    = xmlLong(element, "spacing", 0, false);
    tileset->columns    = xmlLong(element, "columns", 0, false);
    source              = toolXmlAttr(image, "source");
    if (source == NULL) {
        toolFail("tileset %s's image has no source", pyRepr(tileset->name));
    }
    tileset->image = pathJoin(base, source);
    for (i = 0; i < element->childCount; i++) {
        if (strcmp(element->children[i]->name, "tile") == 0 && toolXmlChild(element->children[i], "animation") != NULL) {
            tileset->animated = true;
        }
    }
}


// A folder and every folder above it that is not there yet.
static void makeDirs(const char *path) {
    char   buf[PATH_MAX_BYTES];
    size_t i;
    size_t n;

    n = strlen(path);
    if (n == 0u || n >= sizeof(buf)) {
        toolFail("cannot make the folder %s", path);
    }
    memcpy(buf, path, n + 1u);
    for (i = 1; i <= n; i++) {
        if (buf[i] == '/' || buf[i] == '\0') {
            buf[i] = '\0';
            if (mkdir(buf, DIR_MODE) != 0 && errno != EEXIST) {
                toolFail("cannot make the folder %s: %s", buf, strerror(errno));
            }
            buf[i] = path[i];
        }
    }
}


// name in base's folder, as Python's os.path.join: an absolute name as it
// is, a name in an empty base as it is.
static char *pathJoin(const char *base, const char *name) {
    char  *out;
    size_t n;

    if (name[0] == '/' || base[0] == '\0') {
        return stringCopy(name);
    }
    n   = strlen(base) + strlen(name) + 2u;
    out = (char *)malloc(n);
    if (out == NULL) {
        toolFail("out of memory");
    }
    snprintf(out, n, "%s%s%s", base, base[strlen(base) - 1u] == '/' ? "" : "/", name);
    return out;
}


// A string as Python's repr() shows it (None for NULL): single quotes, or
// double when it holds a single quote and no double; backslashes, the
// quote, and control characters escaped. In a static buffer.
static const char *pyRepr(const char *s) {
    static char out[REPR_MAX];
    size_t      n;
    char        quote;
    char        c;

    if (s == NULL) {
        return "None";
    }
    quote    = (strchr(s, '\'') != NULL && strchr(s, '"') == NULL) ? '"' : '\'';
    n        = 0u;
    out[n++] = quote;
    for (; *s != '\0' && n + 5u < sizeof(out); s++) {
        c = *s;
        if (c == '\\' || c == quote) {
            out[n++] = '\\';
            out[n++] = c;
        } else if (c == '\t') {
            n += (size_t)snprintf(out + n, sizeof(out) - n, "\\t");
        } else if (c == '\n') {
            n += (size_t)snprintf(out + n, sizeof(out) - n, "\\n");
        } else if (c == '\r') {
            n += (size_t)snprintf(out + n, sizeof(out) - n, "\\r");
        } else if ((unsigned char)c < PRINTABLE_FIRST || (unsigned char)c == PRINTABLE_END) {
            n += (size_t)snprintf(out + n, sizeof(out) - n, "\\x%02x", (unsigned char)c);
        } else {
            out[n++] = c;
        }
    }
    out[n++] = quote;
    out[n]   = '\0';
    return out;
}


// len bytes of s as an upper-case C identifier, each character but ASCII
// letters and digits made one _ (a multi-byte UTF-8 character one too).
static void pyUpperIdent(const char *s, size_t len, FILE *f) {
    size_t i;

    for (i = 0; i < len; i++) {
        if ((unsigned char)s[i] < ASCII_END && isalnum((unsigned char)s[i])) {
            fputc(toupper((unsigned char)s[i]), f);
        } else if (((unsigned char)s[i] & UTF8_CONT_MASK) != UTF8_CONT) {
            fputc('_', f);
        }
    }
}


static uint8_t *readAll(const char *path, size_t *len) {
    uint8_t *data;

    if (!toolReadFile(path, &data, len)) {
        toolFail("cannot read %s", path);
    }
    return data;
}


static char *stringCopy(const char *s) {
    char  *out;
    size_t n;

    n   = strlen(s) + 1u;
    out = (char *)malloc(n);
    if (out == NULL) {
        toolFail("out of memory");
    }
    memcpy(out, s, n);
    return out;
}


static void tilesetAdd(MapT *map, long firstGid, TilesetT *tileset) {
    TilesetT *tilesets;

    tilesets = (TilesetT *)realloc(map->tilesets, (map->tilesetCount + 1u) * sizeof(TilesetT));
    if (tilesets == NULL) {
        toolFail("out of memory");
    }
    tileset->firstGid                  = firstGid;
    map->tilesets                      = tilesets;
    map->tilesets[map->tilesetCount++] = *tileset;
}


// The tileset's tiles as 8x8 grids of indices into palette (16 colors,
// used marks the slots taken). The first tileset's colors take their own
// indices (a color it holds twice reads as its first); another's are
// matched by color, or take the first free slot.
static void tilesetPixels(TilesetT *tileset, uint8_t palette[MAX_COLORS][3], bool used[MAX_COLORS], bool first) {
    ToolImageT image;
    char       err[TOOL_PNG_ERROR_BYTES];
    bool       inImage[TOOL_PNG_PALETTE_MAX];
    uint8_t    remap[TOOL_PNG_PALETTE_MAX];
    uint32_t   index;
    uint32_t   slot;
    long       columns;
    long       rows;
    long       row;
    long       column;
    long       x0;
    long       y0;
    long       x;
    long       y;
    size_t     i;
    size_t     t;

    if (tileset->tileWidth != TILE_SIDE || tileset->tileHeight != TILE_SIDE) {
        toolFail("tileset %s has %ldx%ld tiles; JoeyLib's are 8x8", pyRepr(tileset->name), tileset->tileWidth, tileset->tileHeight);
    }
    if (tileset->animated) {
        fprintf(stderr, "%s: tileset %s animates tiles; only the tiles the map places are kept\n", TOOL_NAME, pyRepr(tileset->name));
    }
    if (!toolPngLoad(tileset->image, &image, err)) {
        toolFail("%s: %s", tileset->image, err);
    }
    if (!image.indexed) {
        toolFail("%s is not indexed; tilesets must be indexed (palette) PNGs", tileset->image);
    }
    memset(inImage, 0, sizeof(inImage));
    for (i = 0; i < (size_t)image.width * image.height; i++) {
        inImage[image.pixels[i]] = true;
    }
    for (index = 0; index < TOOL_PNG_PALETTE_MAX; index++) {
        if (!inImage[index]) {
            continue;
        }
        if (first) {
            if (index >= MAX_COLORS) {
                toolFail("%s uses palette index %u; tiles have %u colors", tileset->image, index, MAX_COLORS);
            }
            memcpy(palette[index], image.palette[index], 3u);
            used[index] = true;
        } else {
            for (slot = 0; slot < MAX_COLORS && !(used[slot] && memcmp(palette[slot], image.palette[index], 3u) == 0); slot++) {
            }
            if (slot == MAX_COLORS) {
                for (slot = 0; slot < MAX_COLORS && used[slot]; slot++) {
                }
                if (slot == MAX_COLORS) {
                    toolFail("the tilesets' colors make more than %u", MAX_COLORS);
                }
                memcpy(palette[slot], image.palette[index], 3u);
                used[slot] = true;
            }
        }
        for (slot = 0; !(used[slot] && memcmp(palette[slot], image.palette[index], 3u) == 0); slot++) {
        }
        remap[index] = (uint8_t)slot;
    }
    // Python's floor division: a tileset image too small for one tile has
    // no columns or rows.
    columns = tileset->columns;
    if (columns == 0) {
        x       = (long)image.width - 2 * tileset->margin + tileset->spacing;
        columns = x >= 0 ? x / (TILE_SIDE + tileset->spacing) : -((-x + TILE_SIDE + tileset->spacing - 1) / (TILE_SIDE + tileset->spacing));
    }
    y                  = (long)image.height - 2 * tileset->margin + tileset->spacing;
    rows               = y >= 0 ? y / (TILE_SIDE + tileset->spacing) : -((-y + TILE_SIDE + tileset->spacing - 1) / (TILE_SIDE + tileset->spacing));
    tileset->tileCount = (columns > 0 && rows > 0) ? (size_t)(columns * rows) : 0u;
    tileset->tiles     = (uint8_t *)malloc(tileset->tileCount * TILE_PIXELS + 1u);
    if (tileset->tiles == NULL) {
        toolFail("out of memory");
    }
    t = 0u;
    for (row = 0; row < rows; row++) {
        for (column = 0; column < columns; column++) {
            x0 = tileset->margin + column * (TILE_SIDE + tileset->spacing);
            y0 = tileset->margin + row * (TILE_SIDE + tileset->spacing);
            if (x0 < 0 || y0 < 0 || x0 + TILE_SIDE > (long)image.width || y0 + TILE_SIDE > (long)image.height) {
                toolFail("tileset %s's tiles run past its image %s", pyRepr(tileset->name), tileset->image);
            }
            for (y = 0; y < TILE_SIDE; y++) {
                for (x = 0; x < TILE_SIDE; x++) {
                    tileset->tiles[t * TILE_PIXELS + (size_t)(y * TILE_SIDE + x)] = remap[image.pixels[(size_t)(y0 + y) * image.width + (size_t)(x0 + x)]];
                }
            }
            t++;
        }
    }
    toolImageFree(&image);
}


static void usage(void) {
    fprintf(stderr, "usage: %s [--header OUT.h] MAP SHEET.png MAPDIR\n", TOOL_NAME);
    fprintf(stderr, "  MAP: a Tiled map (TMX or TMJ), orthogonal, finite, 8x8 tiles, indexed PNG tilesets\n");
    fprintf(stderr, "  SHEET.png: the tiles its layers use, in a row; MAPDIR: a LAYER.map for each tile layer\n");
    exit(USAGE_EXIT);
}


// The C header: the map's size and tile count as constants named for the
// map, and its layers' files.
static void writeHeader(const char *path, const char *mapPath, long width, long height, size_t count, const MapT *map, char **files) {
    const char *base;
    const char *mapBase;
    const char *dot;
    size_t      stemLen;
    size_t      i;
    FILE       *f;
    bool        ok;

    base    = strrchr(path, '/') != NULL ? strrchr(path, '/') + 1 : path;
    mapBase = strrchr(mapPath, '/') != NULL ? strrchr(mapPath, '/') + 1 : mapPath;
    // The map's name without its extension (Python's splitext: a name that
    // is all dots before its last has none).
    dot     = strrchr(mapBase, '.');
    stemLen = strlen(mapBase);
    if (dot != NULL) {
        for (i = 0; mapBase + i < dot && mapBase[i] == '.'; i++) {
        }
        if (mapBase + i < dot) {
            stemLen = (size_t)(dot - mapBase);
        }
    }
    f = fopen(path, "w");
    if (f == NULL) {
        toolFail("cannot write %s", path);
    }
    fprintf(f, "// Generated by tools/tiled2joey from %s: do not edit.\n#ifndef ", mapBase);
    pyUpperIdent(base, strlen(base), f);
    fprintf(f, "\n#define ");
    pyUpperIdent(base, strlen(base), f);
    fprintf(f, "\n\n#define ");
    pyUpperIdent(mapBase, stemLen, f);
    fprintf(f, "_WIDTH  %ldu    // tiles across\n#define ", width);
    pyUpperIdent(mapBase, stemLen, f);
    fprintf(f, "_HEIGHT %ldu    // tiles down\n#define ", height);
    pyUpperIdent(mapBase, stemLen, f);
    fprintf(f, "_TILES  %zuu    // tiles in the bank\n\n// The layers' map files, in the map's order:\n", count);
    for (i = 0; i < map->layerCount; i++) {
        fprintf(f, "//   %s  (%s)\n", files[i], map->layers[i].name != NULL ? map->layers[i].name : "None");
    }
    fprintf(f, "\n#endif\n");
    ok = !ferror(f);
    ok = fclose(f) == 0 && ok;
    if (!ok) {
        toolFail("cannot write %s", path);
    }
}


// The tile layers among element and everything under it, in document
// order (ElementTree's iter("layer")).
static void xmlLayers(const ToolXmlT *element, MapT *map) {
    const ToolXmlT *data;
    const char     *name;
    LayerT          layer;
    size_t          i;

    if (strcmp(element->name, "layer") == 0) {
        name = toolXmlAttr(element, "name");
        data = toolXmlChild(element, "data");
        if (data == NULL) {
            toolFail("layer %s has no data", pyRepr(name));
        }
        if (toolXmlChild(data, "chunk") != NULL) {
            toolFail("layer %s is in chunks (an infinite map); make the map finite", pyRepr(name));
        }
        memset(&layer, 0, sizeof(layer));
        if (toolXmlChild(data, "tile") != NULL) {
            for (i = 0; i < data->childCount; i++) {
                if (strcmp(data->children[i]->name, "tile") == 0) {
                    gidAdd(&layer, (uint32_t)xmlLong(data->children[i], "gid", 0, false));
                }
            }
        } else {
            decodeData(name, data->text, NULL, toolXmlAttr(data, "encoding"), toolXmlAttr(data, "compression"), &layer);
        }
        layerAdd(map, name, &layer);
    }
    for (i = 0; i < element->childCount; i++) {
        xmlLayers(element->children[i], map);
    }
}


// An XML attribute as a number: fallback when it is missing and not
// required; a fatal error when it is required and missing, or no number.
static long xmlLong(const ToolXmlT *element, const char *attr, long fallback, bool required) {
    const char *text;
    long        value;

    text = toolXmlAttr(element, attr);
    if (text == NULL) {
        if (required) {
            toolFail("<%s> %s has no %s", element->name, pyRepr(toolXmlAttr(element, "name")), attr);
        }
        return fallback;
    }
    if (!toolParseInt(text, strlen(text), &value)) {
        toolFail("<%s> %s has %s=\"%s\", not a number", element->name, pyRepr(toolXmlAttr(element, "name")), attr, text);
    }
    return value;
}


int main(int argc, char **argv) {
    const char *header;
    const char *mapPath;
    const char *sheetPath;
    const char *mapDir;
    MapT        map;
    TileKeyT    keys[MAX_TILES];
    uint8_t     tiles[MAX_TILES][TILE_PIXELS];
    uint8_t     palette[MAX_COLORS][3];
    bool        used[MAX_COLORS];
    uint8_t   **cells;
    char      **taken;
    char      **files;
    char        fileName[PATH_MAX_BYTES];
    char        path[PATH_MAX_BYTES];
    size_t      tileCount;
    size_t      colors;
    size_t      l;
    size_t      c;
    size_t      s;
    size_t      k;
    size_t      best;
    size_t      local;
    uint32_t    gid;
    uint32_t    flags;
    int         a;
    int         x;
    int         y;
    int         sx;
    int         sy;
    int         t;
    ToolImageT  sheet;

    toolFileName(TOOL_NAME);
    header = NULL;
    a      = 1;
    if (argc - a >= 2 && strcmp(argv[a], "--header") == 0) {
        header = argv[a + 1];
        a     += 2;
    }
    if (argc - a != 3) {
        usage();
    }
    mapPath   = argv[a];
    sheetPath = argv[a + 1];
    mapDir    = argv[a + 2];
    loadMap(mapPath, &map);
    memset(palette, 0, sizeof(palette));
    memset(used, 0, sizeof(used));
    for (s = 0; s < map.tilesetCount; s++) {
        tilesetPixels(&map.tilesets[s], palette, used, s == 0u);
    }
    cells = (uint8_t **)calloc(map.layerCount, sizeof(uint8_t *));
    if (cells == NULL) {
        toolFail("out of memory");
    }
    tileCount = 0u;
    for (l = 0; l < map.layerCount; l++) {
        cells[l] = (uint8_t *)malloc(map.layers[l].gidCount + 1u);
        if (cells[l] == NULL) {
            toolFail("out of memory");
        }
        for (c = 0; c < map.layers[l].gidCount; c++) {
            gid = map.layers[l].gids[c];
            if ((gid & ROTATE_HEX) != 0u) {
                toolFail("layer %s rotates a tile 120 degrees (hexagonal maps only)", pyRepr(map.layers[l].name));
            }
            flags = gid & (FLIP_H | FLIP_V | FLIP_D);
            gid  &= GID_MASK;
            if (gid == 0u) {
                cells[l][c] = SKIP;
                continue;
            }
            // The tileset with the greatest firstgid not past gid (the
            // first of equals).
            best = map.tilesetCount;
            for (s = 0; s < map.tilesetCount; s++) {
                if (map.tilesets[s].firstGid <= (long)gid && (best == map.tilesetCount || map.tilesets[s].firstGid > map.tilesets[best].firstGid)) {
                    best = s;
                }
            }
            if (best == map.tilesetCount) {
                toolFail("layer %s places gid %u, before its first tileset", pyRepr(map.layers[l].name), gid);
            }
            local = (size_t)((long)gid - map.tilesets[best].firstGid);
            if (local >= map.tilesets[best].tileCount) {
                toolFail("layer %s places gid %u, past its tileset", pyRepr(map.layers[l].name), gid);
            }
            for (k = 0; k < tileCount && !(keys[k].firstGid == map.tilesets[best].firstGid && keys[k].local == local && keys[k].flags == flags); k++) {
            }
            if (k == tileCount) {
                if (tileCount == MAX_TILES) {
                    toolFail("the map uses more than %u distinct tiles and orientations", MAX_TILES);
                }
                keys[k].firstGid = map.tilesets[best].firstGid;
                keys[k].local    = local;
                keys[k].flags    = flags;
                // As Tiled draws it: the diagonal flip (x and y swapped)
                // first, then the horizontal, then the vertical.
                for (y = 0; y < TILE_SIDE; y++) {
                    for (x = 0; x < TILE_SIDE; x++) {
                        sx = (flags & FLIP_H) != 0u ? TILE_SIDE - 1 - x : x;
                        sy = (flags & FLIP_V) != 0u ? TILE_SIDE - 1 - y : y;
                        if ((flags & FLIP_D) != 0u) {
                            t  = sx;
                            sx = sy;
                            sy = t;
                        }
                        tiles[k][y * TILE_SIDE + x] = map.tilesets[best].tiles[local * TILE_PIXELS + (size_t)(sy * TILE_SIDE + sx)];
                    }
                }
                tileCount++;
            }
            cells[l][c] = (uint8_t)k;
        }
    }
    if (tileCount == 0u) {
        toolFail("the map's tile layers are empty");
    }
    if (!toolImageCreate(&sheet, (uint32_t)(TILE_SIDE * tileCount), TILE_SIDE, true)) {
        toolFail("out of memory");
    }
    sheet.paletteCount = MAX_COLORS;
    for (c = 0; c < MAX_COLORS; c++) {
        memcpy(sheet.palette[c], palette[c], 3u);
        sheet.palette[c][3] = 0xFFu;
    }
    for (k = 0; k < tileCount; k++) {
        for (y = 0; y < TILE_SIDE; y++) {
            memcpy(sheet.pixels + (size_t)y * sheet.width + k * TILE_SIDE, tiles[k] + y * TILE_SIDE, TILE_SIDE);
        }
    }
    if (!toolPngSave(sheetPath, &sheet)) {
        toolFail("cannot write %s", sheetPath);
    }
    toolImageFree(&sheet);
    makeDirs(mapDir);
    taken = (char **)calloc(map.layerCount, sizeof(char *));
    files = (char **)calloc(map.layerCount, sizeof(char *));
    if (taken == NULL || files == NULL) {
        toolFail("out of memory");
    }
    for (l = 0; l < map.layerCount; l++) {
        layerFileName(map.layers[l].name, taken, l, fileName, sizeof(fileName) - strlen(MAP_EXTENSION));
        taken[l] = stringCopy(fileName);
        strcat(fileName, MAP_EXTENSION);
        files[l] = stringCopy(fileName);
        snprintf(path, sizeof(path), "%s/%s", mapDir, fileName);
        if (!toolWriteFile(path, cells[l], map.layers[l].gidCount)) {
            toolFail("cannot write %s", path);
        }
    }
    if (header != NULL) {
        writeHeader(header, mapPath, map.width.value, map.height.value, tileCount, &map, files);
    }
    colors = 0u;
    for (c = 0; c < MAX_COLORS; c++) {
        colors += used[c] ? 1u : 0u;
    }
    printf("%s: %ldx%ld map, %zu tile%s, %zu color%s, layers: ", TOOL_NAME, map.width.value, map.height.value, tileCount, tileCount == 1u ? "" : "s", colors, colors == 1u ? "" : "s");
    for (l = 0; l < map.layerCount; l++) {
        printf("%s%s", l == 0u ? "" : ", ", files[l]);
    }
    printf("\n");
    return 0;
}