garminimgparser.cpp

#include "garminimgparser.h"
#include "osmmodel.h"
#include "osmstyle.h"

#include <QFileInfo>
#include <QDebug>
#include <QElapsedTimer>
#include <cmath>
#include <cstring>

GarminIMGParser::GarminIMGParser(QObject *parent)
    : OsmAbstractParser(parent)
{
}

GarminIMGParser::~GarminIMGParser() = default;

bool GarminIMGParser::isValidIMG(const QString &fileName) {
    FILE *f = fopen(fileName.toUtf8().constData(), "rb");
    if (!f) return false;

    char sig[4];
    size_t rd = fread(sig, 1, 4, f);
    fclose(f);

    if (rd != 4) return false;
    return (memcmp(sig, "UMap", 4) == 0 || memcmp(sig, "IMG ", 4) == 0 ||
            memcmp(sig, "DSK\x37", 4) == 0 || sig[0] == 0x00);
}

bool GarminIMGParser::readFile(FILE *f, uint32_t offset, void *buf, uint32_t size) {
    fseek(f, offset, SEEK_SET);
    return fread(buf, 1, size, f) == size;
}

bool GarminIMGParser::readByteArray(FILE *f, uint32_t offset, QByteArray &buf, uint32_t size) {
    buf.resize(size);
    return readFile(f, offset, buf.data(), size);
}

void GarminIMGParser::xorDecrypt(uint8_t *data, uint32_t size, uint8_t xor_byte) {
    if (xor_byte == 0) return;
    for (uint32_t i = 0; i < size; i++) {
        data[i] ^= xor_byte;
    }
}

bool GarminIMGParser::parseIMGHeader(ParseState &state) {
    uint8_t header[512];
    if (!readFile(state.f, 0, header, 512)) return false;

    memcpy(state.signature, header, 4);
    state.xor_byte = header[4];

    // Decrypt header name
    uint8_t name_buf[40];
    memcpy(name_buf, header + 21, 40);
    xorDecrypt(name_buf, 40, state.xor_byte);
    memcpy(state.map_name, name_buf, 40);
    state.map_name[39] = '\0';

    return true;
}

bool GarminIMGParser::parseFAT(ParseState &state) {
    uint8_t hdr[32];
    if (!readFile(state.f, 0, hdr, sizeof(hdr))) return false;

    uint32_t fat_offset = readU32(hdr + 12);

    // FAT read starts from offset
    uint8_t fat_buf[4096];
    if (!readFile(state.f, fat_offset, fat_buf, sizeof(fat_buf))) return false;

    int pos = 0;
    while (pos < (int)sizeof(fat_buf) - 32) {
        uint8_t *entry = fat_buf + pos;

        // Check if valid
        if (entry[0] == 0xFF || entry[0] == 0x00) break;

        FATEntry fat;
        memcpy(fat.name, entry, 8);
        fat.name[7] = '\0';
        memcpy(fat.type, entry + 8, 3);
        fat.type[3] = '\0';
        fat.size = readU32(entry + 12);
        fat.offset = readU32(entry + 16);
        fat.block_count = readU16(entry + 20);
        fat.first_block = readU16(entry + 22);

        state.fat_entries.append(fat);
        pos += 32;
    }

    return !state.fat_entries.isEmpty();
}

bool GarminIMGParser::parseTRE(ParseState &state) {
    // Find TRE file
    int tre_idx = -1;
    for (int i = 0; i < state.fat_entries.size(); i++) {
        if (strncmp(state.fat_entries[i].name, "TRE", 3) == 0) {
            tre_idx = i;
            break;
        }
    }
    if (tre_idx < 0) return false;

    const FATEntry &tre_entry = state.fat_entries[tre_idx];
    uint32_t tre_offset = tre_entry.offset;

    // Read TRE header (from offset + header size
    uint8_t hdr[64];
    if (!readFile(state.f, tre_offset, hdr, 64)) return false;

    uint16_t header_size = readU16(hdr);
    Q_UNUSED(header_size);

    // Bounding box
    state.bbox_x0 = readS24(hdr + 18);
    state.bbox_y0 = readS24(hdr + 21);
    state.bbox_x1 = readS24(hdr + 24);
    state.bbox_y1 = readS24(hdr + 27);

    // Level info
    uint32_t level_count = readU32(hdr + 30);
    uint32_t level_offset = readU32(hdr + 34);
    uint32_t subdiv_count = readU32(hdr + 38);
    uint32_t subdiv_offset = readU32(hdr + 42);

    state.map_levels = level_count;
    state.tre_count = subdiv_count;

    // Read level definitions
    uint8_t level_data[256];
    uint32_t level_abs = tre_offset + level_offset;
    if (!readFile(state.f, level_abs, level_data, level_count * 16)) return false;

    for (uint32_t i = 0; i < level_count; i++) {
        TRELevel lvl;
        lvl.zoom_level = level_data[i * 16];
        lvl.bits_per_coord = level_data[i * 16 + 1];
        lvl.subdivision_count = readU16(level_data + i * 16 + 2);
        lvl.level_offset = readU32(level_data + i * 16 + 4);
        lvl.start_index = readU32(level_data + i * 16 + 8);
        state.tre_levels.append(lvl);
    }

    // Read all subdivisions
    state.tre_subres.resize(subdiv_count);
    uint32_t subdiv_abs = tre_offset + subdiv_offset;

    // Read one by one (16 bytes each)
    for (uint32_t i = 0; i < subdiv_count; i++) {
        uint8_t sub_data[16];
        if (!readFile(state.f, subdiv_abs + i * 16, sub_data, 16)) return false;

        TRESubre sub;

        // rgn_start: 28 bits (3.5 bytes)
        sub.rgn_start = readU24(sub_data);
        sub.types = (sub_data[3] >> 4) & 0x0F;
        sub.rgn_start |= ((uint32_t)(sub_data[3] & 0x0F)) << 24;

        sub.center_x = readS24(sub_data + 4);
        sub.center_y = readS24(sub_data + 7);

        // TRE subdivision layout (16 bytes):
        // 0-3: rgn_start (28 bits) + types (4 bits)
        // 4-6: center_x (3 bytes)
        // 7-9: center_y (3 bytes)
        // 10-11: x_span (2 bytes)
        // 12-13: y_span (2 bytes)
        // 14-15: end_info flags/child (2 bytes)
        sub.x_span = readU16(sub_data + 10);
        sub.y_span = readU16(sub_data + 12);

        uint32_t end_info = readU32(sub_data + 12);

        sub.is_parent = false;
        sub.end_info.child.rgn_end = end_info & 0x0FFFFFFF;
        sub.end_info.child.types_end = (end_info >> 28) & 0x0F;

        state.tre_subres[i] = sub;
    }

    return true;
}

bool GarminIMGParser::loadRGN(ParseState &state) {
    // Find RGN file
    int rgn_idx = -1;
    for (int i = 0; i < state.fat_entries.size(); i++) {
        if (strncmp(state.fat_entries[i].name, "RGN", 3) == 0) {
            rgn_idx = i;
            break;
        }
    }
    if (rgn_idx < 0) return false;

    const FATEntry &rgn_entry = state.fat_entries[rgn_idx];
    state.rgn_base = rgn_entry.offset;

    // Read RGN header
    uint8_t hdr[32];
    if (!readFile(state.f, rgn_entry.offset, hdr, 32)) return false;

    uint16_t header_size = readU16(hdr);

    state.rgn1_offset = readU32(hdr + 10);
    state.rgn1_len = readU32(hdr + 14);

    // Load entire RGN data
    uint32_t data_size = rgn_entry.size - header_size;
    if (!readByteArray(state.f, rgn_entry.offset + header_size, state.rgn_data, data_size)) return false;

    return true;
}

bool GarminIMGParser::loadLBL(ParseState &state) {
    // Find LBL file
    int lbl_idx = -1;
    for (int i = 0; i < state.fat_entries.size(); i++) {
        if (strncmp(state.fat_entries[i].name, "LBL", 3) == 0) {
            lbl_idx = i;
            break;
        }
    }
    if (lbl_idx < 0) {
        state.lbl_size = 0;
        return true; // LBL is optional
    }

    const FATEntry &lbl_entry = state.fat_entries[lbl_idx];
    state.lbl_offset = lbl_entry.offset;

    // Read LBL header
    uint8_t hdr[32];
    if (!readFile(state.f, lbl_entry.offset, hdr, 32)) return false;

    uint16_t header_size = readU16(hdr);
    Q_UNUSED(header_size);
    state.lbl_coding = hdr[10];
    state.code_page = readU16(hdr + 26);

    uint32_t label_offset = readU32(hdr + 18);
    uint32_t label_size = readU32(hdr + 22);

    state.lbl_size = label_size;

    // Load label data
    if (!readByteArray(state.f, lbl_entry.offset + label_offset, state.lbl_data, label_size)) return false;

    return true;
}

QString GarminIMGParser::readLBLString(ParseState &state, uint32_t offset) {
    if (offset >= (uint32_t)state.lbl_data.size()) return QString();

    int end = offset;
    while (end < state.lbl_data.size() && state.lbl_data[end] != 0) {
        end++;
    }

    QByteArray str = state.lbl_data.mid(offset, end - offset);

    // Convert based on encoding
    if (state.lbl_coding == 6) {
        // 6-bit encoding - simplified to Latin-1
        return QString::fromLatin1(str);
    } else {
        // 8-bit / other encoding
        return QString::fromLatin1(str);
    }
}

bool GarminIMGParser::parseRGNTable(ParseState &state, const TRESubre &sub, RGNTable &table) {
    table.type_count = 0;

    uint32_t rgn_start = state.rgn1_offset + sub.rgn_start;
    if (rgn_start >= (uint32_t)state.rgn_data.size()) return false;

    const uint8_t *rgn_ptr = (const uint8_t*)state.rgn_data.constData();

    // Type count
    int type_count = 0;
    if (sub.types & 0x01) type_count++;
    if (sub.types & 0x02) type_count++;
    if (sub.types & 0x04) type_count++;
    if (sub.types & 0x08) type_count++;

    table.type_count = type_count;
    table.rgn_address[0] = rgn_start;

    if (type_count > 1) {
        table.rgn_address[0] += (type_count - 1) * 2;
        // Read offset table
        table.rgn_address[1] = state.rgn1_offset + readU16(rgn_ptr + rgn_start);
        if (type_count > 2)
            table.rgn_address[2] = state.rgn1_offset + readU16(rgn_ptr + rgn_start + 2);
        if (type_count > 3)
            table.rgn_address[3] = state.rgn1_offset + readU16(rgn_ptr + rgn_start + 4);
    }

    // end
    uint32_t end_addr;
    if (sub.is_parent) {
        end_addr = state.rgn1_offset + sub.end_info.parent.child_rgn_end;
    } else {
        end_addr = state.rgn1_offset + sub.end_info.child.rgn_end;
    }
    table.rgn_address[type_count] = end_addr;

    return true;
}

int GarminIMGParser::mapPOIType(uint8_t type, uint8_t subtype) {
    Q_UNUSED(subtype);
    // Simplified POI type mapping
    switch (type) {
    case 0x01: case 0x02: case 0x03: case 0x04: case 0x05:
    case 0x06: case 0x07: case 0x08: case 0x09: case 0x0A:
    case 0x0D: case 0x011:
        return TagEnum::POI_CITY;
    case 0x20: return TagEnum::POI_HIGHWAY_EXIT;
    case 0x25: return TagEnum::POI_TOLL_BOOTH;
    case 0x2F: return TagEnum::POI_FUEL;
    case 0x43: return TagEnum::POI_MARINA;
    case 0x46: return TagEnum::POI_BAR;
    case 0x48: return TagEnum::POI_CAMPSITE;
    case 0x49: return TagEnum::POI_PARK;
    case 0x4A: return TagEnum::POI_PICNIC;
    case 0x59: return TagEnum::POI_AIRPORT;
    case 0x2E: return TagEnum::POI_SHOPPING;
    default: return TagEnum::POI_DEFAULT;
    }
}

int GarminIMGParser::mapPolylineType(uint8_t type) {
    switch (type & 0x3F) {
    case 0x00: return TagEnum::HIGHWAY_MOTORWAY;
    case 0x01: return TagEnum::HIGHWAY_TRUNK;
    case 0x02: return TagEnum::HIGHWAY_PRIMARY;
    case 0x03: return TagEnum::HIGHWAY_SECONDARY;
    case 0x04: return TagEnum::HIGHWAY_TERTIARY;
    case 0x05: return TagEnum::HIGHWAY_RESIDENTIAL;
    case 0x06: return TagEnum::HIGHWAY_UNCLASSIFIED;
    case 0x07: return TagEnum::HIGHWAY_SERVICE;
    case 0x08: return TagEnum::HIGHWAY_TRACK;
    case 0x09: return TagEnum::HIGHWAY_PATH;
    case 0x0A: return TagEnum::HIGHWAY_FOOTWAY;
    case 0x0B: return TagEnum::HIGHWAY_CYCLEWAY;
    case 0x0F: return TagEnum::HIGHWAY_MOTORWAY_LINK;
    case 0x10: return TagEnum::HIGHWAY_TRUNK_LINK;
    case 0x11: return TagEnum::HIGHWAY_PRIMARY_LINK;
    case 0x14: return TagEnum::BOUNDARY_ADMIN;
    case 0x16: return TagEnum::RAILWAY;
    default: return TagEnum::LINE_DEFAULT;
    }
}

int GarminIMGParser::mapPolygonType(uint8_t type) {
    switch (type & 0x7F) {
    case 0x01: return TagEnum::LANDUSE_RESIDENTIAL;
    case 0x02: return TagEnum::LANDUSE_COMMERCIAL;
    case 0x03: return TagEnum::LANDUSE_INDUSTRIAL;
    case 0x04: return TagEnum::LANDUSE_FOREST;
    case 0x05: return TagEnum::LANDUSE_GRASS;
    case 0x06: return TagEnum::LANDUSE_FARMLAND;
    case 0x09: return TagEnum::LANDUSE_PASTURE;
    case 0x0B: return TagEnum::LANDUSE_MILITARY;
    case 0x0D: return TagEnum::BOUNDARY_NATIONAL_PARK;
    case 0x0E: return TagEnum::LANDUSE_AIRPORT;
    case 0x14: return TagEnum::BOUNDARY_NATIONAL_PARK;
    case 0x32: case 0x33: case 0x3C: case 0x4C:
        return TagEnum::NATURAL_WATER;
    case 0x3D: return TagEnum::NATURAL_LAKE;
    case 0x4B: return TagEnum::AREA_DEFAULT;
    default: return TagEnum::AREA_DEFAULT;
    }
}

int GarminIMGParser::parsePoint(ParseState &state, uint32_t offset, int bit_shift,
                                int32_t start_x, int32_t start_y,
                                int type_flag, OsmModel &model, OsmStyle &style) {
    Q_UNUSED(style);
    Q_UNUSED(type_flag);

    if (offset + 8 > (uint32_t)state.rgn_data.size()) return 8;

    const uint8_t *data = (const uint8_t*)state.rgn_data.constData();
    const uint8_t *p = data + offset;

    uint8_t type = p[0];
    bool long_type = (p[3] & 0x80) != 0;
    uint8_t subtype = p[1] & 0x1F;

    // Coordinates
    int16_t dx = readS16(p + 4);
    int16_t dy = readS16(p + 6);

    int32_t x = start_x + ((int32_t)dx << bit_shift);
    int32_t y = start_y + ((int32_t)dy << bit_shift);

    double lon = garminToDeg(x);
    double lat = garminToDeg(y);

    // Label address (3 bytes, 22 valid bits)
    uint32_t lbl_addr = readU24(p + 1);
    lbl_addr &= 0x3FFFFF;

    int entry_size = long_type ? 9 : 8;

    // Create node
    OsmNode node(state.poi_count * 100, lat, lon);

    int tagHead = -1;

    // Name
    if (lbl_addr > 0 && !state.lbl_data.isEmpty()) {
        QString label = readLBLString(state, lbl_addr);
        if (!label.isEmpty()) {
            int keyId = model.registerKey(QStringLiteral("name"));
            tagHead = model.addTag(keyId, label, tagHead);
        }
    }

    // Type
    int tagType = mapPOIType(type, subtype);
    int typeKeyId = model.registerKey(QStringLiteral("type"));
    tagHead = model.addTag(typeKeyId, QString::number(tagType), tagHead);

    node.setTagHead(tagHead);
    model.addNode(node);
    state.poi_count++;

    return entry_size;
}

int GarminIMGParser::parsePoly(ParseState &state, uint32_t offset, int bit_shift,
                               int32_t start_x, int32_t start_y,
                               int type_flag, bool is_polygon,
                               OsmModel &model, OsmStyle &style) {
    Q_UNUSED(style);
    Q_UNUSED(type_flag);

    if (offset + 10 > (uint32_t)state.rgn_data.size()) return 10;

    const uint8_t *data = (const uint8_t*)state.rgn_data.constData();
    const uint8_t *p = data + offset;

    uint8_t type_byte = p[0];
    bool long_type = (type_byte & 0x80) != 0;
    uint8_t type = type_byte & 0x7F;

    // Label address
    uint32_t lbl_addr = readU24(p + 1);
    lbl_addr &= 0x3FFFFF;

    // Start coordinates
    int16_t dx = readS16(p + 4);
    int16_t dy = readS16(p + 6);

    int32_t x_total = start_x + ((int32_t)dx << bit_shift);
    int32_t y_total = start_y + ((int32_t)dy << bit_shift);

    // Bit stream length
    uint32_t stream_len;
    uint32_t stream_offset;
    uint32_t entry_size;

    if (long_type) {
        stream_len = readU16(p + 8);
        stream_offset = offset + 10;
        entry_size = 10 + stream_len;
    } else {
        stream_len = p[8];
        stream_offset = offset + 9;
        entry_size = 9 + stream_len;
    }

    if (stream_offset + stream_len > (uint32_t)state.rgn_data.size()) {
        return entry_size;
    }

    // Bit stream decoding
    BitStream bs;
    bs.init(data + stream_offset, stream_len);

    // Read bit lengths
    int x_len = bs.readBits(4);
    int y_len = bs.readBits(4);

    x_len = x_len <= 9 ? x_len + 2 : 2 * x_len - 7;
    y_len = y_len <= 9 ? y_len + 2 : 2 * y_len - 7;

    // x type
    int x_type, y_type;
    if (bs.readBits(1)) {
        x_type = bs.readBits(1) ? 1 : 2;
    } else {
        x_len++;
        x_type = 0;
    }

    if (bs.readBits(1)) {
        y_type = bs.readBits(1) ? 1 : 2;
    } else {
        y_len++;
        y_type = 0;
    }

    // Collect coordinates
    QList<QPair<double, double>> coords;
    coords.append(qMakePair(garminToDeg(y_total), garminToDeg(x_total)));

    // Decode all points
    while (!bs.eof()) {
        int32_t dx_val = bs.readValue(x_len, x_type);
        int32_t dy_val = bs.readValue(y_len, y_type);

        x_total += dx_val << bit_shift;
        y_total += dy_val << bit_shift;

        coords.append(qMakePair(garminToDeg(y_total), garminToDeg(x_total)));

        if (bs.bytePosition() >= stream_len) break;
    }

    if (coords.size() < 2) return entry_size;

    // Create Way
    OsmWay way(state.polyline_count * 100 + (is_polygon ? 1 : 0));

    int ndHead = -1;
    for (int i = 0; i < coords.size(); i++) {
        OsmNode node(-(state.polyline_count * 1000 + i), coords[i].first, coords[i].second);
        int nodeIdx = model.addNode(node);
        ndHead = model.addNd(nodeIdx, ndHead);
    }
    way.setNdHead(ndHead);

    int tagHead = -1;

    // Name
    if (lbl_addr > 0 && !state.lbl_data.isEmpty()) {
        QString label = readLBLString(state, lbl_addr);
        if (!label.isEmpty()) {
            int keyId = model.registerKey(QStringLiteral("name"));
            tagHead = model.addTag(keyId, label, tagHead);
        }
    }

    // Type
    int tagType = is_polygon ? mapPolygonType(type) : mapPolylineType(type);
    int typeKeyId = model.registerKey(QStringLiteral("type"));
    tagHead = model.addTag(typeKeyId, QString::number(tagType), tagHead);

    way.setTagHead(tagHead);
    model.addWay(way);

    if (is_polygon)
        state.polygon_count++;
    else
        state.polyline_count++;

    return entry_size;
}

bool GarminIMGParser::parseSubdivision(ParseState &state, int sub_idx, int layer,
                                     OsmModel &model, OsmStyle &style) {
    if (sub_idx < 0 || sub_idx >= state.tre_subres.size()) return false;

    const TRESubre &sub = state.tre_subres[sub_idx];

    // Calculate bit_shift
    int bit_shift = 0;
    if (layer < state.tre_levels.size()) {
        bit_shift = 5;  // Default shift
    }

    // Parse RGN table
    RGNTable table;
    if (!parseRGNTable(state, sub, table)) return false;

    int type_idx = 0;

    // Type order: 0x08 (polygon), 0x04 (polyline), 0x02 (point type 2), 0x01 (point type 1)
    // Corresponding RGN type flag bits:
    // bit 0 = type 1 (point)
    // bit 1 = type 2 (point)
    // bit 2 = type 3 (line)
    // bit 3 = type 4 (area)

    // Process in order 80, 40, 20, 10
    if (sub.types & 0x08) {
        // polygon (area)
        uint32_t start = table.rgn_address[type_idx];
        uint32_t end = table.rgn_address[type_idx + 1];
        while (start < end && start < (uint32_t)state.rgn_data.size()) {
            int sz = parsePoly(state, start, bit_shift, sub.center_x, sub.center_y, 0x80, true, model, style);
            start += sz;
        }
        type_idx++;
    }

    if (sub.types & 0x04) {
        // polyline (line)
        uint32_t start = table.rgn_address[type_idx];
        uint32_t end = table.rgn_address[type_idx + 1];
        while (start < end && start < (uint32_t)state.rgn_data.size()) {
            int sz = parsePoly(state, start, bit_shift, sub.center_x, sub.center_y, 0x40, false, model, style);
            start += sz;
        }
        type_idx++;
    }

    if (sub.types & 0x02) {
        // point type 2 (point)
        uint32_t start = table.rgn_address[type_idx];
        uint32_t end = table.rgn_address[type_idx + 1];
        while (start < end && start < (uint32_t)state.rgn_data.size()) {
            int sz = parsePoint(state, start, bit_shift, sub.center_x, sub.center_y, 0x20, model, style);
            start += sz;
        }
        type_idx++;
    }

    if (sub.types & 0x01) {
        // point type 1 (point)
        uint32_t start = table.rgn_address[type_idx];
        uint32_t end = table.rgn_address[type_idx + 1];
        while (start < end && start < (uint32_t)state.rgn_data.size()) {
            int sz = parsePoint(state, start, bit_shift, sub.center_x, sub.center_y, 0x10, model, style);
            start += sz;
        }
        type_idx++;
    }

    return true;
}

bool GarminIMGParser::parse(const QString &fileName, OsmModel &model, OsmStyle &style) {
    QElapsedTimer totalTimer;
    totalTimer.start();

    emitProgress(0, QStringLiteral("Loading Garmin IMG: %1").arg(fileName));

    ParseState state;
    state.f = fopen(fileName.toUtf8().constData(), "rb");
    if (!state.f) {
        emitProgress(0, QStringLiteral("Cannot open file: %1").arg(fileName));
        emit parseFinished(false, tr("Cannot open file"));
        return false;
    }

    state.path = fileName;
    state.poi_count = 0;
    state.polyline_count = 0;
    state.polygon_count = 0;

    model.clear();

    // Parse file header
    if (!parseIMGHeader(state)) {
        fclose(state.f);
        emitProgress(0, QStringLiteral("Cannot read IMG file header"));
        emit parseFinished(false, tr("Cannot read file header"));
        return false;
    }

    emitProgress(5, QStringLiteral("Map: %1").arg(QString::fromLatin1(state.map_name)));

    // Parse FAT
    if (!parseFAT(state)) {
        fclose(state.f);
        emitProgress(0, QStringLiteral("Cannot parse FAT"));
        emit parseFinished(false, tr("Cannot parse FAT"));
        return false;
    }

    // Parse TRE
    if (!parseTRE(state)) {
        fclose(state.f);
        emitProgress(0, QStringLiteral("Cannot parse TRE"));
        emit parseFinished(false, tr("Cannot parse TRE"));
        return false;
    }

    emitProgress(10, QStringLiteral("Subdivisions: %1 Levels: %2")
        .arg(state.tre_count).arg(state.map_levels));

    // Load RGN
    if (!loadRGN(state)) {
        fclose(state.f);
        emitProgress(0, QStringLiteral("Cannot load RGN"));
        emit parseFinished(false, tr("Cannot load RGN"));
        return false;
    }

    // Load LBL (optional)
    loadLBL(state);

    // Pre-register keys
    model.registerKey(QStringLiteral("source"));
    model.registerKey(QStringLiteral("name"));
    model.registerKey(QStringLiteral("type"));
    model.registerKey(QStringLiteral("highway"));
    model.registerKey(QStringLiteral("landuse"));
    model.registerKey(QStringLiteral("natural"));

    emitProgress(20, QStringLiteral("Parsing features..."));

    // Parse the most detailed layer from all levels
    // Start from the highest resolution level (level 0 is most detailed)
    int layer = 0;
    if (state.tre_levels.size() > 0) {
        layer = 0;  // Most detailed layer
    }

    // Determine the subdivision range to process
    int start_sub = 0;
    int end_sub = state.tre_count;

    if (state.tre_levels.size() > 0) {
        start_sub = state.tre_levels[0].start_index;
        if (state.tre_levels.size() > 1) {
            end_sub = state.tre_levels[1].start_index;
        } else {
            end_sub = state.tre_count;
        }
    }

    int count = end_sub - start_sub;
    for (int i = start_sub; i < end_sub; i++) {
        if (i >= state.tre_count) break;

        if ((i - start_sub) % 50 == 0) {
            int pct = 20 + ((i - start_sub) * 75) / qMax(1, count);
            emitProgress(pct, QStringLiteral("Parsing... %1/%2")
                .arg(i - start_sub).arg(count));
        }

        parseSubdivision(state, i, layer, model, style);
    }

    fclose(state.f);

    // Build draw list
    emitProgress(95, QStringLiteral("Building draw list..."));
    model.finalizeAfterLoad();

    int64_t elapsed = totalTimer.elapsed();
    qDebug() << "=== Garmin IMG parsing total:" << elapsed << "ms"
             << "POIs:" << state.poi_count
             << "polylines:" << state.polyline_count
             << "polygons:" << state.polygon_count << "===";

    emitProgress(100, QStringLiteral("Parsing complete (%1ms): POI=%2 lines=%3 polygons=%4")
        .arg(elapsed).arg(state.poi_count).arg(state.polyline_count).arg(state.polygon_count));
    emit parseFinished(true);
    return true;
}