shapefileparser.cpp

#include "shapefileparser.h"
#include "osmmodel.h"
#include "osmstyle.h"
#include "perfprofiler.h"

#include <QFileInfo>
#include <QDebug>
#include <QElapsedTimer>
#include <QProcess>
#include <QThreadPool>
#include <QMutex>
#include <atomic>
#include <cmath>

// ============================================================================
// Shapelib C wrapper implementation (minimal version, avoids external library)
// ============================================================================

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <stdint.h>

// ============================================================================
// mmap file mapping -- inspired by libosmium's memory mapping strategy
// ============================================================================
#ifdef _WIN32
#include <windows.h>
#else
#include <sys/mman.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <unistd.h>
#endif

class MmapFile {
public:
    MmapFile() = default;
    ~MmapFile() { close(); }

    // No copy, RAII semantics
    MmapFile(const MmapFile &) = delete;
    MmapFile &operator=(const MmapFile &) = delete;

    bool open(const char *path) {
        close();
#ifdef _WIN32
        HANDLE hFile = CreateFileA(path, GENERIC_READ, FILE_SHARE_READ,
                                   nullptr, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, nullptr);
        if (hFile == INVALID_HANDLE_VALUE) return false;

        LARGE_INTEGER fileSize;
        if (!GetFileSizeEx(hFile, &fileSize)) { CloseHandle(hFile); return false; }
        m_size = static_cast<size_t>(fileSize.QuadPart);
        if (m_size == 0) { CloseHandle(hFile); return false; }

        HANDLE hMapping = CreateFileMappingA(hFile, nullptr, PAGE_READONLY, 0, 0, nullptr);
        CloseHandle(hFile);
        if (!hMapping) return false;

        m_data = reinterpret_cast<const unsigned char *>(
                     MapViewOfFile(hMapping, FILE_MAP_READ, 0, 0, 0));
        CloseHandle(hMapping);
        if (!m_data) return false;
#else
        int fd = ::open(path, O_RDONLY);
        if (fd < 0) return false;
        struct stat st;
        if (fstat(fd, &st) < 0) { ::close(fd); return false; }
        m_size = static_cast<size_t>(st.st_size);
        if (m_size == 0) { ::close(fd); return false; }
        m_data = reinterpret_cast<const unsigned char *>(
                     mmap(nullptr, m_size, PROT_READ, MAP_PRIVATE, fd, 0));
        ::close(fd);
        if (m_data == MAP_FAILED) { m_data = nullptr; return false; }
#endif
        return true;
    }

    void close() {
        if (m_data) {
#ifdef _WIN32
            UnmapViewOfFile(m_data);
#else
            munmap(const_cast<void *>(reinterpret_cast<const void *>(m_data)), m_size);
#endif
            m_data = nullptr;
            m_size = 0;
        }
    }

    // release() -- transfer ownership to caller, no longer destroyed by RAII destructor
    const unsigned char *release() {
        auto *p = m_data;
        m_data = nullptr;
        auto sz = m_size;
        m_size = 0;
        (void)sz;
        return p;
    }

    const unsigned char *data() const { return m_data; }
    size_t size() const { return m_size; }
    bool isOpen() const { return m_data != nullptr; }

private:
    const unsigned char *m_data = nullptr;
    size_t m_size = 0;
};

// Read big-endian integer
static int readIntBE(const unsigned char *p) {
    return (p[0] << 24) | (p[1] << 16) | (p[2] << 8) | p[3];
}

// Read little-endian integer
static int readIntLE(const unsigned char *p) {
    return (p[3] << 24) | (p[2] << 16) | (p[1] << 8) | p[0];
}

// Read little-endian double
static double readDoubleLE(const unsigned char *p) {
    double d;
    unsigned char *pd = (unsigned char*)&d;
    for (int i = 0; i < 8; i++) {
        pd[i] = p[i];
    }
    return d;
}

// SHP file header structure
struct SHPHeader {
    int code;
    int version;
    int shapeType;
    double xMin, yMin, zMin, mMin;
    double xMax, yMax, zMax, mMax;
};

// SHP file reader
struct SHPFile {
    FILE *f = nullptr;
    int nEntities = 0;
    int nShapeType = 0;
    SHPHeader header = {};
    long *panRecOffset = nullptr;
    int  *panRecSize = nullptr;
    // mmap support (libosmium-style file mapping)
    const unsigned char *mmapBase = nullptr;  // read-only mapped view
    size_t mmapSize = 0;
    bool useMmap = false;
};

// ---------- mmap path: SHPOpenMmap ----------
// Use memory mapping to scan SHP file, eliminating fseek/fread overhead
static SHPHandle SHPOpenMmap(const char *filename) {
    MmapFile mf;
    if (!mf.open(filename)) return nullptr;

    if (mf.size() < 100) return nullptr;
    const unsigned char *base = mf.data();
    size_t fileSize = mf.size();

    SHPFile *psSHP = new SHPFile();
    psSHP->f = nullptr;  // no FILE handle needed
    psSHP->useMmap = true;
    psSHP->mmapBase = mf.release();  // ownership transferred to SHPFile
    psSHP->mmapSize = fileSize;

    // Parse file header directly from mmap
    psSHP->header.code      = readIntBE(base);
    psSHP->header.version   = readIntLE(base + 28);
    psSHP->header.shapeType = readIntLE(base + 32);
    psSHP->header.xMin      = readDoubleLE(base + 36);
    psSHP->header.yMin      = readDoubleLE(base + 44);
    psSHP->header.xMax      = readDoubleLE(base + 52);
    psSHP->header.yMax      = readDoubleLE(base + 60);
    psSHP->header.zMin      = readDoubleLE(base + 68);
    psSHP->header.zMax      = readDoubleLE(base + 76);
    psSHP->header.mMin      = readDoubleLE(base + 84);
    psSHP->header.mMax      = readDoubleLE(base + 92);

    psSHP->nShapeType = psSHP->header.shapeType;
    psSHP->nEntities = 0;

    // Scan all records directly from memory -- no fseek/fread
    int nAlloced = 0;
    size_t pos = 100;

    while (pos + 8 <= fileSize) {
        int nRecSize = readIntBE(base + pos + 4);
        int nRecContentBytes = nRecSize * 2;

        // Boundary check
        if (pos + 8 + static_cast<size_t>(nRecContentBytes) > fileSize) break;
        if (nRecSize <= 0) break;

        if (psSHP->nEntities >= nAlloced) {
            nAlloced = nAlloced == 0 ? 1024 : nAlloced * 2;
            psSHP->panRecOffset = (long*)realloc(psSHP->panRecOffset,
                                                  static_cast<size_t>(nAlloced) * sizeof(long));
            psSHP->panRecSize = (int*)realloc(psSHP->panRecSize,
                                               static_cast<size_t>(nAlloced) * sizeof(int));
        }

        psSHP->panRecOffset[psSHP->nEntities] = static_cast<long>(pos);
        psSHP->panRecSize[psSHP->nEntities] = nRecSize;
        psSHP->nEntities++;

        pos += 8 + static_cast<size_t>(nRecContentBytes);

        if (psSHP->nEntities % 10000 == 0) {
            qDebug() << "SHPOpenMmap: Scanned" << psSHP->nEntities << "records";
        }
    }

    qDebug() << "SHPOpenMmap: Done. Total entities:" << psSHP->nEntities;
    return (SHPHandle)psSHP;
}

// ---------- SHPOpen: mmap preferred, fread fallback ----------
SHPHandle SHPOpen(const char *filename, const char * /*access*/) {
    // Try mmap path first
    SHPHandle hMmap = SHPOpenMmap(filename);
    if (hMmap) return hMmap;

    // mmap failed, fall back to original fread path
    qDebug() << "SHPOpen: mmap failed, falling back to fread path";

    SHPFile *psSHP = new SHPFile();
    psSHP->f = fopen(filename, "rb");
    if (!psSHP->f) {
        delete psSHP;
        return nullptr;
    }

    unsigned char header[100];
    if (fread(header, 100, 1, psSHP->f) != 1) {
        fclose(psSHP->f);
        delete psSHP;
        return nullptr;
    }

    psSHP->header.code = readIntBE(header);
    psSHP->header.version = readIntLE(header + 28);
    psSHP->header.shapeType = readIntLE(header + 32);
    psSHP->header.xMin = readDoubleLE(header + 36);
    psSHP->header.yMin = readDoubleLE(header + 44);
    psSHP->header.xMax = readDoubleLE(header + 52);
    psSHP->header.yMax = readDoubleLE(header + 60);
    psSHP->header.zMin = readDoubleLE(header + 68);
    psSHP->header.zMax = readDoubleLE(header + 76);
    psSHP->header.mMin = readDoubleLE(header + 84);
    psSHP->header.mMax = readDoubleLE(header + 92);

    psSHP->nShapeType = psSHP->header.shapeType;

    psSHP->nEntities = 0;
    psSHP->panRecOffset = nullptr;
    psSHP->panRecSize = nullptr;

    int nAlloced = 0;
    long nFilePos = 100;

    fseek(psSHP->f, 0, SEEK_END);
    long nFileSize = ftell(psSHP->f);
    fseek(psSHP->f, 100, SEEK_SET);

    while (nFilePos < nFileSize) {
        unsigned char recHeader[8];
        if (fread(recHeader, 8, 1, psSHP->f) != 1) break;

        int nRecSize = readIntBE(recHeader + 4);

        if (psSHP->nEntities >= nAlloced) {
            nAlloced = nAlloced == 0 ? 1024 : nAlloced * 2;
            psSHP->panRecOffset = (long*)realloc(psSHP->panRecOffset, nAlloced * sizeof(long));
            psSHP->panRecSize = (int*)realloc(psSHP->panRecSize, nAlloced * sizeof(int));
        }

        psSHP->panRecOffset[psSHP->nEntities] = nFilePos;
        psSHP->panRecSize[psSHP->nEntities] = nRecSize;
        psSHP->nEntities++;

        nFilePos += 8 + nRecSize * 2;
        fseek(psSHP->f, nFilePos, SEEK_SET);

        if (psSHP->nEntities % 10000 == 0) {
            qDebug() << "SHPOpen: Scanned" << psSHP->nEntities << "records";
        }
    }

    qDebug() << "SHPOpen: Done. Total entities:" << psSHP->nEntities;

    return (SHPHandle)psSHP;
}

void SHPGetInfo(SHPHandle hSHP, int *pnEntities, int *pnShapeType, double *padfMinBound, double *padfMaxBound) {
    SHPFile *psSHP = (SHPFile*)hSHP;
    if (pnEntities) *pnEntities = psSHP->nEntities;
    if (pnShapeType) *pnShapeType = psSHP->nShapeType;
    if (padfMinBound) {
        padfMinBound[0] = psSHP->header.xMin;
        padfMinBound[1] = psSHP->header.yMin;
        padfMinBound[2] = psSHP->header.zMin;
        padfMinBound[3] = psSHP->header.mMin;
    }
    if (padfMaxBound) {
        padfMaxBound[0] = psSHP->header.xMax;
        padfMaxBound[1] = psSHP->header.yMax;
        padfMaxBound[2] = psSHP->header.zMax;
        padfMaxBound[3] = psSHP->header.mMax;
    }
}

#define IS_MULTIPOINT(x) ((x) == SHPT_MULTIPOINT || (x) == SHPT_MULTIPOINTZ || (x) == SHPT_MULTIPOINTM)

SHPObject* SHPReadObject(SHPHandle hSHP, int iShape) {
    SHPFile *psSHP = (SHPFile*)hSHP;

    if (iShape < 0 || iShape >= psSHP->nEntities) return nullptr;

    // ===== mmap path: read directly from mapped memory, zero allocation =====
    if (psSHP->useMmap && psSHP->mmapBase) {
        const unsigned char *base = psSHP->mmapBase;
        long recOffset = psSHP->panRecOffset[iShape];
        int contentLen = psSHP->panRecSize[iShape];
        int contentBytes = contentLen * 2;

        // Boundary check
        if (static_cast<size_t>(recOffset) + 8 + static_cast<size_t>(contentBytes) > psSHP->mmapSize)
            return nullptr;

        const unsigned char *recHdr = base + recOffset;
        int recNum = readIntBE(recHdr);
        // Skip 8-byte record header, point directly to record content
        const unsigned char *record = recHdr + 8;

        SHPObject *obj = new SHPObject();
        memset(obj, 0, sizeof(SHPObject));

        int pos = 0;
        obj->nShapeId = recNum;
        obj->nSHPType = readIntLE(record + pos); pos += 4;

        if (obj->nSHPType == SHPT_NULL) {
            return obj;
        }

        if (IS_POINT(obj->nSHPType)) {
            obj->nVertices = 1;
            obj->nParts = 1;
            obj->panPartStart = new int[1];
            obj->panPartStart[0] = 0;
            obj->panPartType = new int[1];
            obj->panPartType[0] = 0;
            obj->padfX = new double[1];
            obj->padfY = new double[1];
            obj->padfX[0] = readDoubleLE(record + pos); pos += 8;
            obj->padfY[0] = readDoubleLE(record + pos); pos += 8;
            obj->dfXMin = obj->dfXMax = obj->padfX[0];
            obj->dfYMin = obj->dfYMax = obj->padfY[0];

            if (obj->nSHPType == SHPT_POINTZ) {
                obj->padfZ = new double[1];
                obj->padfM = new double[1];
                obj->padfZ[0] = readDoubleLE(record + pos); pos += 8;
                obj->padfM[0] = readDoubleLE(record + pos); pos += 8;
                obj->dfZMin = obj->dfZMax = obj->padfZ[0];
                obj->dfMMin = obj->dfMMax = obj->padfM[0];
            } else if (obj->nSHPType == SHPT_POINTM) {
                obj->padfM = new double[1];
                obj->padfM[0] = readDoubleLE(record + pos); pos += 8;
                obj->dfMMin = obj->dfMMax = obj->padfM[0];
            }
        } else if (IS_MULTIPOINT(obj->nSHPType)) {
            obj->dfXMin = readDoubleLE(record + pos); pos += 8;
            obj->dfYMin = readDoubleLE(record + pos); pos += 8;
            obj->dfXMax = readDoubleLE(record + pos); pos += 8;
            obj->dfYMax = readDoubleLE(record + pos); pos += 8;
            obj->nVertices = readIntLE(record + pos); pos += 4;
            obj->nParts = 1;
            obj->panPartStart = new int[1];
            obj->panPartStart[0] = 0;
            obj->panPartType = new int[1];
            obj->panPartType[0] = 0;

            obj->padfX = new double[obj->nVertices];
            obj->padfY = new double[obj->nVertices];
            for (int i = 0; i < obj->nVertices; i++) {
                obj->padfX[i] = readDoubleLE(record + pos); pos += 8;
                obj->padfY[i] = readDoubleLE(record + pos); pos += 8;
            }

            if (obj->nSHPType == SHPT_MULTIPOINTZ) {
                obj->padfZ = new double[obj->nVertices];
                obj->dfZMin = readDoubleLE(record + pos); pos += 8;
                obj->dfZMax = readDoubleLE(record + pos); pos += 8;
                for (int i = 0; i < obj->nVertices; i++) {
                    obj->padfZ[i] = readDoubleLE(record + pos); pos += 8;
                }
                obj->padfM = new double[obj->nVertices];
                obj->dfMMin = readDoubleLE(record + pos); pos += 8;
                obj->dfMMax = readDoubleLE(record + pos); pos += 8;
                for (int i = 0; i < obj->nVertices; i++) {
                    obj->padfM[i] = readDoubleLE(record + pos); pos += 8;
                }
            } else if (obj->nSHPType == SHPT_MULTIPOINTM) {
                obj->padfM = new double[obj->nVertices];
                obj->dfMMin = readDoubleLE(record + pos); pos += 8;
                obj->dfMMax = readDoubleLE(record + pos); pos += 8;
                for (int i = 0; i < obj->nVertices; i++) {
                    obj->padfM[i] = readDoubleLE(record + pos); pos += 8;
                }
            }
        } else if (IS_ARC(obj->nSHPType) || IS_POLYGON(obj->nSHPType)) {
            obj->dfXMin = readDoubleLE(record + pos); pos += 8;
            obj->dfYMin = readDoubleLE(record + pos); pos += 8;
            obj->dfXMax = readDoubleLE(record + pos); pos += 8;
            obj->dfYMax = readDoubleLE(record + pos); pos += 8;
            obj->nParts = readIntLE(record + pos); pos += 4;
            obj->nVertices = readIntLE(record + pos); pos += 4;

            obj->panPartStart = new int[obj->nParts];
            for (int i = 0; i < obj->nParts; i++) {
                obj->panPartStart[i] = readIntLE(record + pos); pos += 4;
            }

            bool hasM = (obj->nSHPType == SHPT_ARCM || obj->nSHPType == SHPT_POLYGONM);
            bool hasZ = (obj->nSHPType == SHPT_ARCZ || obj->nSHPType == SHPT_POLYGONZ);

            if (hasZ || hasM) {
                obj->panPartType = new int[obj->nParts];
                for (int i = 0; i < obj->nParts; i++) {
                    obj->panPartType[i] = readIntLE(record + pos); pos += 4;
                }
            } else {
                obj->panPartType = nullptr;
            }

            obj->padfX = new double[obj->nVertices];
            obj->padfY = new double[obj->nVertices];
            for (int i = 0; i < obj->nVertices; i++) {
                obj->padfX[i] = readDoubleLE(record + pos); pos += 8;
                obj->padfY[i] = readDoubleLE(record + pos); pos += 8;
            }

            if (obj->nSHPType == SHPT_ARCZ || obj->nSHPType == SHPT_POLYGONZ) {
                obj->padfZ = new double[obj->nVertices];
                obj->dfZMin = readDoubleLE(record + pos); pos += 8;
                obj->dfZMax = readDoubleLE(record + pos); pos += 8;
                for (int i = 0; i < obj->nVertices; i++) {
                    obj->padfZ[i] = readDoubleLE(record + pos); pos += 8;
                }
                obj->padfM = new double[obj->nVertices];
                obj->dfMMin = readDoubleLE(record + pos); pos += 8;
                obj->dfMMax = readDoubleLE(record + pos); pos += 8;
                for (int i = 0; i < obj->nVertices; i++) {
                    obj->padfM[i] = readDoubleLE(record + pos); pos += 8;
                }
            } else if (obj->nSHPType == SHPT_ARCM || obj->nSHPType == SHPT_POLYGONM) {
                obj->padfM = new double[obj->nVertices];
                obj->dfMMin = readDoubleLE(record + pos); pos += 8;
                obj->dfMMax = readDoubleLE(record + pos); pos += 8;
                for (int i = 0; i < obj->nVertices; i++) {
                    obj->padfM[i] = readDoubleLE(record + pos); pos += 8;
                }
            }
        } else if (obj->nSHPType == SHPT_MULTIPATCH) {
            obj->dfXMin = readDoubleLE(record + pos); pos += 8;
            obj->dfYMin = readDoubleLE(record + pos); pos += 8;
            obj->dfXMax = readDoubleLE(record + pos); pos += 8;
            obj->dfYMax = readDoubleLE(record + pos); pos += 8;
            obj->nParts = readIntLE(record + pos); pos += 4;
            obj->nVertices = readIntLE(record + pos); pos += 4;

            obj->panPartStart = new int[obj->nParts];
            obj->panPartType = new int[obj->nParts];
            for (int i = 0; i < obj->nParts; i++) {
                obj->panPartStart[i] = readIntLE(record + pos); pos += 4;
            }
            for (int i = 0; i < obj->nParts; i++) {
                obj->panPartType[i] = readIntLE(record + pos); pos += 4;
            }

            obj->padfX = new double[obj->nVertices];
            obj->padfY = new double[obj->nVertices];
            obj->padfZ = new double[obj->nVertices];
            for (int i = 0; i < obj->nVertices; i++) {
                obj->padfX[i] = readDoubleLE(record + pos); pos += 8;
                obj->padfY[i] = readDoubleLE(record + pos); pos += 8;
                obj->padfZ[i] = readDoubleLE(record + pos); pos += 8;
            }
            obj->dfZMin = readDoubleLE(record + pos); pos += 8;
            obj->dfZMax = readDoubleLE(record + pos); pos += 8;

            obj->padfM = new double[obj->nVertices];
            obj->dfMMin = readDoubleLE(record + pos); pos += 8;
            obj->dfMMax = readDoubleLE(record + pos); pos += 8;
            for (int i = 0; i < obj->nVertices; i++) {
                obj->padfM[i] = readDoubleLE(record + pos); pos += 8;
            }
        }

        // mmap path: no delete[] record, because record is an mmap pointer
        return obj;
    }

    // ===== Original fread fallback path =====
    FILE *f = psSHP->f;
    if (!f) return nullptr;

    fseek(f, psSHP->panRecOffset[iShape], SEEK_SET);

    unsigned char recHeader[8];
    if (fread(recHeader, 8, 1, f) != 1) return nullptr;

    int recNum = readIntBE(recHeader);
    int contentLen = readIntBE(recHeader + 4);

    unsigned char *record = new unsigned char[contentLen * 2];
    if (fread(record, contentLen * 2, 1, f) != 1) {
        delete[] record;
        return nullptr;
    }

    SHPObject *obj = new SHPObject();
    memset(obj, 0, sizeof(SHPObject));

    int pos = 0;
    obj->nShapeId = recNum;
    obj->nSHPType = readIntLE(record + pos); pos += 4;

    if (obj->nSHPType == SHPT_NULL) {
        delete[] record;
        return obj;
    }

    if (IS_POINT(obj->nSHPType)) {
        obj->nVertices = 1;
        obj->nParts = 1;
        obj->panPartStart = new int[1];
        obj->panPartStart[0] = 0;
        obj->panPartType = new int[1];
        obj->panPartType[0] = 0;
        obj->padfX = new double[1];
        obj->padfY = new double[1];
        obj->padfX[0] = readDoubleLE(record + pos); pos += 8;
        obj->padfY[0] = readDoubleLE(record + pos); pos += 8;
        obj->dfXMin = obj->dfXMax = obj->padfX[0];
        obj->dfYMin = obj->dfYMax = obj->padfY[0];

        if (obj->nSHPType == SHPT_POINTZ) {
            obj->padfZ = new double[1];
            obj->padfM = new double[1];
            obj->padfZ[0] = readDoubleLE(record + pos); pos += 8;
            obj->padfM[0] = readDoubleLE(record + pos); pos += 8;
            obj->dfZMin = obj->dfZMax = obj->padfZ[0];
            obj->dfMMin = obj->dfMMax = obj->padfM[0];
        } else if (obj->nSHPType == SHPT_POINTM) {
            obj->padfM = new double[1];
            obj->padfM[0] = readDoubleLE(record + pos); pos += 8;
            obj->dfMMin = obj->dfMMax = obj->padfM[0];
        }
    } else if (IS_MULTIPOINT(obj->nSHPType)) {
        obj->dfXMin = readDoubleLE(record + pos); pos += 8;
        obj->dfYMin = readDoubleLE(record + pos); pos += 8;
        obj->dfXMax = readDoubleLE(record + pos); pos += 8;
        obj->dfYMax = readDoubleLE(record + pos); pos += 8;
        obj->nVertices = readIntLE(record + pos); pos += 4;
        obj->nParts = 1;
        obj->panPartStart = new int[1];
        obj->panPartStart[0] = 0;
        obj->panPartType = new int[1];
        obj->panPartType[0] = 0;

        obj->padfX = new double[obj->nVertices];
        obj->padfY = new double[obj->nVertices];
        for (int i = 0; i < obj->nVertices; i++) {
            obj->padfX[i] = readDoubleLE(record + pos); pos += 8;
            obj->padfY[i] = readDoubleLE(record + pos); pos += 8;
        }

        if (obj->nSHPType == SHPT_MULTIPOINTZ) {
            obj->padfZ = new double[obj->nVertices];
            obj->dfZMin = readDoubleLE(record + pos); pos += 8;
            obj->dfZMax = readDoubleLE(record + pos); pos += 8;
            for (int i = 0; i < obj->nVertices; i++) {
                obj->padfZ[i] = readDoubleLE(record + pos); pos += 8;
            }
            obj->padfM = new double[obj->nVertices];
            obj->dfMMin = readDoubleLE(record + pos); pos += 8;
            obj->dfMMax = readDoubleLE(record + pos); pos += 8;
            for (int i = 0; i < obj->nVertices; i++) {
                obj->padfM[i] = readDoubleLE(record + pos); pos += 8;
            }
        } else if (obj->nSHPType == SHPT_MULTIPOINTM) {
            obj->padfM = new double[obj->nVertices];
            obj->dfMMin = readDoubleLE(record + pos); pos += 8;
            obj->dfMMax = readDoubleLE(record + pos); pos += 8;
            for (int i = 0; i < obj->nVertices; i++) {
                obj->padfM[i] = readDoubleLE(record + pos); pos += 8;
            }
        }
    } else if (IS_ARC(obj->nSHPType) || IS_POLYGON(obj->nSHPType)) {
        obj->dfXMin = readDoubleLE(record + pos); pos += 8;
        obj->dfYMin = readDoubleLE(record + pos); pos += 8;
        obj->dfXMax = readDoubleLE(record + pos); pos += 8;
        obj->dfYMax = readDoubleLE(record + pos); pos += 8;
        obj->nParts = readIntLE(record + pos); pos += 4;
        obj->nVertices = readIntLE(record + pos); pos += 4;

        obj->panPartStart = new int[obj->nParts];
        for (int i = 0; i < obj->nParts; i++) {
            obj->panPartStart[i] = readIntLE(record + pos); pos += 4;
        }

        bool hasM = (obj->nSHPType == SHPT_ARCM || obj->nSHPType == SHPT_POLYGONM);
        bool hasZ = (obj->nSHPType == SHPT_ARCZ || obj->nSHPType == SHPT_POLYGONZ);

        if (hasZ || hasM) {
            obj->panPartType = new int[obj->nParts];
            for (int i = 0; i < obj->nParts; i++) {
                obj->panPartType[i] = readIntLE(record + pos); pos += 4;
            }
        } else {
            obj->panPartType = nullptr;
        }

        obj->padfX = new double[obj->nVertices];
        obj->padfY = new double[obj->nVertices];
        for (int i = 0; i < obj->nVertices; i++) {
            obj->padfX[i] = readDoubleLE(record + pos); pos += 8;
            obj->padfY[i] = readDoubleLE(record + pos); pos += 8;
        }

        if (obj->nSHPType == SHPT_ARCZ || obj->nSHPType == SHPT_POLYGONZ) {
            obj->padfZ = new double[obj->nVertices];
            obj->dfZMin = readDoubleLE(record + pos); pos += 8;
            obj->dfZMax = readDoubleLE(record + pos); pos += 8;
            for (int i = 0; i < obj->nVertices; i++) {
                obj->padfZ[i] = readDoubleLE(record + pos); pos += 8;
            }
            obj->padfM = new double[obj->nVertices];
            obj->dfMMin = readDoubleLE(record + pos); pos += 8;
            obj->dfMMax = readDoubleLE(record + pos); pos += 8;
            for (int i = 0; i < obj->nVertices; i++) {
                obj->padfM[i] = readDoubleLE(record + pos); pos += 8;
            }
        } else if (obj->nSHPType == SHPT_ARCM || obj->nSHPType == SHPT_POLYGONM) {
            obj->padfM = new double[obj->nVertices];
            obj->dfMMin = readDoubleLE(record + pos); pos += 8;
            obj->dfMMax = readDoubleLE(record + pos); pos += 8;
            for (int i = 0; i < obj->nVertices; i++) {
                obj->padfM[i] = readDoubleLE(record + pos); pos += 8;
            }
        }
    } else if (obj->nSHPType == SHPT_MULTIPATCH) {
        obj->dfXMin = readDoubleLE(record + pos); pos += 8;
        obj->dfYMin = readDoubleLE(record + pos); pos += 8;
        obj->dfXMax = readDoubleLE(record + pos); pos += 8;
        obj->dfYMax = readDoubleLE(record + pos); pos += 8;
        obj->nParts = readIntLE(record + pos); pos += 4;
        obj->nVertices = readIntLE(record + pos); pos += 4;

        obj->panPartStart = new int[obj->nParts];
        obj->panPartType = new int[obj->nParts];
        for (int i = 0; i < obj->nParts; i++) {
            obj->panPartStart[i] = readIntLE(record + pos); pos += 4;
        }
        for (int i = 0; i < obj->nParts; i++) {
            obj->panPartType[i] = readIntLE(record + pos); pos += 4;
        }

        obj->padfX = new double[obj->nVertices];
        obj->padfY = new double[obj->nVertices];
        obj->padfZ = new double[obj->nVertices];
        for (int i = 0; i < obj->nVertices; i++) {
            obj->padfX[i] = readDoubleLE(record + pos); pos += 8;
            obj->padfY[i] = readDoubleLE(record + pos); pos += 8;
            obj->padfZ[i] = readDoubleLE(record + pos); pos += 8;
        }
        obj->dfZMin = readDoubleLE(record + pos); pos += 8;
        obj->dfZMax = readDoubleLE(record + pos); pos += 8;

        obj->padfM = new double[obj->nVertices];
        obj->dfMMin = readDoubleLE(record + pos); pos += 8;
        obj->dfMMax = readDoubleLE(record + pos); pos += 8;
        for (int i = 0; i < obj->nVertices; i++) {
            obj->padfM[i] = readDoubleLE(record + pos); pos += 8;
        }
    }

    delete[] record;
    return obj;
}

void SHPDestroyObject(SHPObject *psShape) {
    if (!psShape) return;
    if (psShape->panPartStart) delete[] psShape->panPartStart;
    if (psShape->panPartType) delete[] psShape->panPartType;
    if (psShape->padfX) delete[] psShape->padfX;
    if (psShape->padfY) delete[] psShape->padfY;
    if (psShape->padfZ) delete[] psShape->padfZ;
    if (psShape->padfM) delete[] psShape->padfM;
    delete psShape;
}

void SHPClose(SHPHandle hSHP) {
    if (!hSHP) return;
    SHPFile *psSHP = (SHPFile*)hSHP;
    if (psSHP->f) fclose(psSHP->f);
    // mmap cleanup: since MmapFile::release() transferred ownership, need manual unmap
    if (psSHP->mmapBase) {
#ifdef _WIN32
        UnmapViewOfFile(psSHP->mmapBase);
#else
        munmap(const_cast<void *>(reinterpret_cast<const void *>(psSHP->mmapBase)), psSHP->mmapSize);
#endif
        psSHP->mmapBase = nullptr;
        psSHP->mmapSize = 0;
    }
    if (psSHP->panRecOffset) free(psSHP->panRecOffset);
    if (psSHP->panRecSize) free(psSHP->panRecSize);
    delete psSHP;
}

// ============================================================================
// DBF file reader implementation
// ============================================================================

struct DBFFile {
    FILE *f = nullptr;
    int nRecords = 0;
    int nFields = 0;
    int nHeaderSize = 0;
    int nRecordSize = 0;
    int *panFieldOffset = nullptr;
    int *panFieldWidth = nullptr;
    char (*pachFieldName)[12] = nullptr;
    unsigned char *pachFieldType = nullptr;
    int *panFieldDecimals = nullptr;
    // mmap support
    const unsigned char *mmapBase = nullptr;  // read-only mapped view
    size_t mmapSize = 0;
    bool useMmap = false;
};

// ---------- mmap path: DBFOpenMmap ----------
// Use memory mapping to read DBF file, eliminating per-field fseek/fread overhead
static DBFHandle DBFOpenMmap(const char *filename) {
    MmapFile mf;
    if (!mf.open(filename)) return nullptr;

    if (mf.size() < 32) return nullptr;
    const unsigned char *base = mf.data();
    size_t fileSize = mf.size();

    DBFFile *psDBF = new DBFFile();
    psDBF->f = nullptr;
    psDBF->useMmap = true;
    psDBF->mmapBase = mf.release();  // ownership transferred to DBFFile
    psDBF->mmapSize = fileSize;

    // Parse file header directly from mmap
    psDBF->nRecords     = readIntLE(base + 4);
    psDBF->nHeaderSize  = base[8] | (base[9] << 8);
    psDBF->nRecordSize  = base[10] | (base[11] << 8);
    psDBF->nFields      = (psDBF->nHeaderSize - 33) / 32;

    if (psDBF->nFields <= 0 || psDBF->nHeaderSize + (long)psDBF->nRecords * psDBF->nRecordSize > (long)fileSize) {
        // Invalid DBF
#ifdef _WIN32
        UnmapViewOfFile(psDBF->mmapBase);
#else
        munmap(const_cast<void *>(reinterpret_cast<const void *>(psDBF->mmapBase)), psDBF->mmapSize);
#endif
        psDBF->mmapBase = nullptr;
        delete psDBF;
        return nullptr;
    }

    psDBF->panFieldOffset = new int[psDBF->nFields];
    psDBF->panFieldWidth = new int[psDBF->nFields];
    psDBF->pachFieldName = new char[psDBF->nFields][12];
    psDBF->pachFieldType = new unsigned char[psDBF->nFields];
    psDBF->panFieldDecimals = new int[psDBF->nFields];

    int nFieldOffset = 1;  // DBF record first byte is deletion flag
    for (int i = 0; i < psDBF->nFields; i++) {
        size_t fieldOff = 32 + static_cast<size_t>(i) * 32;
        if (fieldOff + 32 > fileSize) break;

        const unsigned char *fh = base + fieldOff;
        memset(psDBF->pachFieldName[i], 0, 12);
        memcpy(psDBF->pachFieldName[i], fh, 11);
        psDBF->pachFieldType[i] = fh[11];
        psDBF->panFieldWidth[i] = fh[16];
        psDBF->panFieldDecimals[i] = fh[17];
        psDBF->panFieldOffset[i] = nFieldOffset;
        nFieldOffset += fh[16];
    }

    return (DBFHandle)psDBF;
}

// ---------- DBFOpen: mmap preferred, fread fallback ----------
DBFHandle DBFOpen(const char *filename, const char * /*access*/) {
    // Try mmap path first
    DBFHandle hMmap = DBFOpenMmap(filename);
    if (hMmap) return hMmap;

    // mmap failed, fall back to original fread path
    qDebug() << "DBFOpen: mmap failed, falling back to fread path";

    DBFFile *psDBF = new DBFFile();
    psDBF->f = fopen(filename, "rb");
    if (!psDBF->f) {
        delete psDBF;
        return nullptr;
    }

    unsigned char header[32];
    if (fread(header, 32, 1, psDBF->f) != 1) {
        fclose(psDBF->f);
        delete psDBF;
        return nullptr;
    }

    psDBF->nRecords = readIntLE(header + 4);
    psDBF->nHeaderSize = header[8] | (header[9] << 8);
    psDBF->nRecordSize = header[10] | (header[11] << 8);
    psDBF->nFields = (psDBF->nHeaderSize - 33) / 32;

    psDBF->panFieldOffset = new int[psDBF->nFields];
    psDBF->panFieldWidth = new int[psDBF->nFields];
    psDBF->pachFieldName = new char[psDBF->nFields][12];
    psDBF->pachFieldType = new unsigned char[psDBF->nFields];
    psDBF->panFieldDecimals = new int[psDBF->nFields];

    int nFieldOffset = 1;
    for (int i = 0; i < psDBF->nFields; i++) {
        unsigned char fieldHeader[32];
        fseek(psDBF->f, 32 + i * 32, SEEK_SET);
        if (fread(fieldHeader, 32, 1, psDBF->f) != 1) break;

        memset(psDBF->pachFieldName[i], 0, 12);
        memcpy(psDBF->pachFieldName[i], fieldHeader, 11);
        psDBF->pachFieldType[i] = fieldHeader[11];
        psDBF->panFieldWidth[i] = fieldHeader[16];
        psDBF->panFieldDecimals[i] = fieldHeader[17];
        psDBF->panFieldOffset[i] = nFieldOffset;
        nFieldOffset += fieldHeader[16];
    }

    return (DBFHandle)psDBF;
}

int DBFGetFieldCount(DBFHandle hDBF) {
    return ((DBFFile*)hDBF)->nFields;
}

int DBFGetRecordCount(DBFHandle hDBF) {
    return ((DBFFile*)hDBF)->nRecords;
}

DBFFieldType DBFGetFieldInfo(DBFHandle hDBF, int iField, char *pszFieldName, int *pnWidth, int *pnDecimals) {
    DBFFile *psDBF = (DBFFile*)hDBF;
    if (iField < 0 || iField >= psDBF->nFields) return FTInvalid;

    if (pszFieldName) {
        memset(pszFieldName, 0, 12);
        memcpy(pszFieldName, psDBF->pachFieldName[iField], 11);
    }
    if (pnWidth) *pnWidth = psDBF->panFieldWidth[iField];
    if (pnDecimals) *pnDecimals = psDBF->panFieldDecimals[iField];

    switch (psDBF->pachFieldType[iField]) {
        case 'C': case 'B': case 'G': case 'M': return FTString;  // Character/Binary/General/Memo
        case 'N': case 'F': return FTDouble;                       // Numeric/Float
        case 'I': case '+': return FTInteger;                      // Integer/AutoIncrement
        case 'L': return FTInteger;                                 // Logical/Boolean
        case 'D': return FTDate;                                    // Date (refer to C# code)
        case 'T': return FTDate;                                    // DateTime
        default: return FTInvalid;
    }
}

// ShapeType name lookup function (refer to C# ShapeTypeDictionary)
const char* getShapeTypeName(int shapeTypeCode) {
    static const char* shapeTypeNames[] = {
        "Null Shape",
        "Point",
        nullptr,       // 2 - unused
        "PolyLine",    // 3 - Arc
        nullptr,       // 4 - unused
        "Polygon",
        nullptr,       // 6 - unused
        nullptr,       // 7 - unused
        "MultiPoint",
        nullptr,       // 9 - unused
        nullptr,       // 10 - unused
        "PointZ",
        nullptr,       // 12 - unused
        "PolyLineZ",   // 13 - ArcZ
        nullptr,       // 14 - unused
        "PolygonZ",
        nullptr,       // 16 - unused
        nullptr,       // 17 - unused
        "MultiPointZ",
        nullptr,       // 19 - unused
        nullptr,       // 20 - unused
        "PointM",
        nullptr,       // 22 - unused
        "PolyLineM",   // 23 - ArcM
        nullptr,       // 24 - unused
        "PolygonM",
        nullptr,       // 26 - unused
        nullptr,       // 27 - unused
        "MultiPointM",
        nullptr,       // 29 - unused
        nullptr,       // 30 - unused
        "MultiPatch"
    };

    if (shapeTypeCode >= 0 && shapeTypeCode <= 31) {
        if (shapeTypeNames[shapeTypeCode])
            return shapeTypeNames[shapeTypeCode];
    }
    return "Unknown";
}

// Determine ring direction (clockwise = outer ring, counterclockwise = inner ring)
// Using signed area formula: area = 0.5 * sum((x[i+1]-x[i])*(y[i]+y[i+1]))
// Positive area = clockwise (outer ring), Negative area = counterclockwise (inner ring/hole)
RingType determineRingType(const double *xs, const double *ys, int numPoints) {
    if (numPoints < 3 || !xs || !ys) return RING_UNKNOWN;

    double signedArea = 0.0;
    for (int i = 0; i < numPoints - 1; i++) {
        signedArea += (xs[i + 1] - xs[i]) * (ys[i] + ys[i + 1]);
    }
    // Close the ring's last segment
    signedArea += (xs[0] - xs[numPoints - 1]) * (ys[numPoints - 1] + ys[0]);

    // Positive area = clockwise = outer ring
    // Negative area = counterclockwise = inner ring
    return (signedArea > 0) ? RING_OUTER : RING_INNER;
}

static const char* readDBFString(DBFFile *psDBF, int iRecord, int iField) {
    thread_local char buffer[256];
    if (iField < 0 || iField >= psDBF->nFields) return "";
    if (iRecord < 0 || iRecord >= psDBF->nRecords) return "";

    int nFieldWidth = psDBF->panFieldWidth[iField];
    if (nFieldWidth >= 256) nFieldWidth = 255;

    // ===== mmap path: read directly from mapped memory, zero fseek/fread =====
    if (psDBF->useMmap && psDBF->mmapBase) {
        size_t offset = static_cast<size_t>(psDBF->nHeaderSize)
                      + static_cast<size_t>(iRecord) * static_cast<size_t>(psDBF->nRecordSize)
                      + static_cast<size_t>(psDBF->panFieldOffset[iField]);

        if (offset + static_cast<size_t>(nFieldWidth) > psDBF->mmapSize) return "";

        const unsigned char *src = psDBF->mmapBase + offset;

        // Copy directly to thread_local buffer
        memcpy(buffer, src, nFieldWidth);
        buffer[nFieldWidth] = '\0';

        int len = nFieldWidth;
        while (len > 0 && buffer[len-1] == ' ') {
            buffer[--len] = '\0';
        }

        return buffer;
    }

    // ===== Original fread fallback path =====
    long nOffset = psDBF->nHeaderSize + (long)iRecord * psDBF->nRecordSize + psDBF->panFieldOffset[iField];
    fseek(psDBF->f, nOffset, SEEK_SET);

    memset(buffer, 0, 256);
    if (fread(buffer, 1, nFieldWidth, psDBF->f) != (size_t)nFieldWidth) return "";
    buffer[nFieldWidth] = '\0';

    int len = nFieldWidth;
    while (len > 0 && buffer[len-1] == ' ') {
        buffer[--len] = '\0';
    }

    return buffer;
}

const char* DBFReadStringAttribute(DBFHandle hDBF, int iRecord, int iField) {
    return readDBFString((DBFFile*)hDBF, iRecord, iField);
}

int DBFReadIntegerAttribute(DBFHandle hDBF, int iRecord, int iField) {
    const char *str = readDBFString((DBFFile*)hDBF, iRecord, iField);
    return atoi(str);
}

double DBFReadDoubleAttribute(DBFHandle hDBF, int iRecord, int iField) {
    const char *str = readDBFString((DBFFile*)hDBF, iRecord, iField);
    return atof(str);
}

void DBFClose(DBFHandle hDBF) {
    if (!hDBF) return;
    DBFFile *psDBF = (DBFFile*)hDBF;
    if (psDBF->f) fclose(psDBF->f);
    // mmap cleanup
    if (psDBF->mmapBase) {
#ifdef _WIN32
        UnmapViewOfFile(psDBF->mmapBase);
#else
        munmap(const_cast<void *>(reinterpret_cast<const void *>(psDBF->mmapBase)), psDBF->mmapSize);
#endif
        psDBF->mmapBase = nullptr;
        psDBF->mmapSize = 0;
    }
    if (psDBF->panFieldOffset) delete[] psDBF->panFieldOffset;
    if (psDBF->panFieldWidth) delete[] psDBF->panFieldWidth;
    if (psDBF->pachFieldName) delete[] psDBF->pachFieldName;
    if (psDBF->pachFieldType) delete[] psDBF->pachFieldType;
    if (psDBF->panFieldDecimals) delete[] psDBF->panFieldDecimals;
    delete psDBF;
}

// ============================================================================
// OsmShapefileParser implementation
// ============================================================================

OsmShapefileParser::OsmShapefileParser(QObject *parent)
    : OsmAbstractParser(parent)
{
    // Initialize tag mapping rules
    // Format: key, value, tagType
    // highway
    m_tagMappingRules.append(TagMappingRule{"highway", "motorway", TagEnum::HIGHWAY_MOTORWAY});
    m_tagMappingRules.append(TagMappingRule{"highway", "motorway_link", TagEnum::HIGHWAY_MOTORWAY_LINK});
    m_tagMappingRules.append(TagMappingRule{"highway", "trunk", TagEnum::HIGHWAY_TRUNK});
    m_tagMappingRules.append(TagMappingRule{"highway", "trunk_link", TagEnum::HIGHWAY_TRUNK_LINK});
    m_tagMappingRules.append(TagMappingRule{"highway", "primary", TagEnum::HIGHWAY_PRIMARY});
    m_tagMappingRules.append(TagMappingRule{"highway", "primary_link", TagEnum::HIGHWAY_PRIMARY_LINK});
    m_tagMappingRules.append(TagMappingRule{"highway", "secondary", TagEnum::HIGHWAY_SECONDARY});
    m_tagMappingRules.append(TagMappingRule{"highway", "secondary_link", TagEnum::HIGHWAY_SECONDARY_LINK});
    m_tagMappingRules.append(TagMappingRule{"highway", "tertiary", TagEnum::HIGHWAY_TERTIARY});
    m_tagMappingRules.append(TagMappingRule{"highway", "unclassified", TagEnum::HIGHWAY_UNCLASSIFIED});
    m_tagMappingRules.append(TagMappingRule{"highway", "residential", TagEnum::HIGHWAY_RESIDENTIAL});
    m_tagMappingRules.append(TagMappingRule{"highway", "service", TagEnum::HIGHWAY_SERVICE});
    m_tagMappingRules.append(TagMappingRule{"highway", "track", TagEnum::HIGHWAY_TRACK});
    m_tagMappingRules.append(TagMappingRule{"highway", "path", TagEnum::HIGHWAY_PATH});
    m_tagMappingRules.append(TagMappingRule{"highway", "footway", TagEnum::HIGHWAY_FOOTWAY});
    m_tagMappingRules.append(TagMappingRule{"highway", "cycleway", TagEnum::HIGHWAY_CYCLEWAY});

    // railway
    m_tagMappingRules.append(TagMappingRule{"railway", "rail", TagEnum::RAILWAY});
    m_tagMappingRules.append(TagMappingRule{"railway", "tram", TagEnum::RAILWAY_TRAM});
    m_tagMappingRules.append(TagMappingRule{"railway", "subway", TagEnum::RAILWAY_SUBWAY});
    m_tagMappingRules.append(TagMappingRule{"railway", "light_rail", TagEnum::RAILWAY_LIGHT_RAIL});

    // waterway
    m_tagMappingRules.append(TagMappingRule{"waterway", "river", TagEnum::WATERWAY_RIVER});
    m_tagMappingRules.append(TagMappingRule{"waterway", "stream", TagEnum::WATERWAY_STREAM});
    m_tagMappingRules.append(TagMappingRule{"waterway", "canal", TagEnum::WATERWAY_CANAL});
    m_tagMappingRules.append(TagMappingRule{"waterway", "drain", TagEnum::WATERWAY_DRAIN});

    // building
    m_tagMappingRules.append(TagMappingRule{"building", "*", TagEnum::BUILDING});

    // landuse
    m_tagMappingRules.append(TagMappingRule{"landuse", "residential", TagEnum::LANDUSE_RESIDENTIAL});
    m_tagMappingRules.append(TagMappingRule{"landuse", "commercial", TagEnum::LANDUSE_COMMERCIAL});
    m_tagMappingRules.append(TagMappingRule{"landuse", "industrial", TagEnum::LANDUSE_INDUSTRIAL});
    m_tagMappingRules.append(TagMappingRule{"landuse", "forest", TagEnum::LANDUSE_FOREST});
    m_tagMappingRules.append(TagMappingRule{"landuse", "grass", TagEnum::LANDUSE_GRASS});
    m_tagMappingRules.append(TagMappingRule{"landuse", "farmland", TagEnum::LANDUSE_FARMLAND});

    // natural
    m_tagMappingRules.append(TagMappingRule{"natural", "water", TagEnum::NATURAL_WATER});
    m_tagMappingRules.append(TagMappingRule{"natural", "wood", TagEnum::NATURAL_WOOD});
    m_tagMappingRules.append(TagMappingRule{"natural", "grassland", TagEnum::NATURAL_GRASSLAND});
    m_tagMappingRules.append(TagMappingRule{"natural", "beach", TagEnum::NATURAL_BEACH});
    m_tagMappingRules.append(TagMappingRule{"natural", "rock", TagEnum::UNKNOWN});

    // leisure
    m_tagMappingRules.append(TagMappingRule{"leisure", "park", TagEnum::LEISURE_PARK});
    m_tagMappingRules.append(TagMappingRule{"leisure", "garden", TagEnum::LEISURE_GARDEN});
    m_tagMappingRules.append(TagMappingRule{"leisure", "pitch", TagEnum::LEISURE_PITCH});
    m_tagMappingRules.append(TagMappingRule{"leisure", "playground", TagEnum::LEISURE_PLAYGROUND});

    // boundary
    m_tagMappingRules.append(TagMappingRule{"boundary", "administrative", TagEnum::BOUNDARY_ADMIN});
    m_tagMappingRules.append(TagMappingRule{"boundary", "national_park", TagEnum::BOUNDARY_NATIONAL_PARK});

    // Default area type
    m_tagMappingRules.append(TagMappingRule{"", "*", TagEnum::AREA_DEFAULT});
}

OsmShapefileParser::~OsmShapefileParser() = default;

void OsmShapefileParser::transformToWGS84(double &lon, double &lat) {
    static const double ORIGIN_SHIFT = 20037508.342789244;
    static const double HALF_PI = M_PI / 2.0;

    if (lon >= -180.0 && lon <= 180.0 && lat >= -90.0 && lat <= 90.0) {
        return;
    }

    if (lon > ORIGIN_SHIFT || lon < -ORIGIN_SHIFT ||
        lat > ORIGIN_SHIFT || lat < -ORIGIN_SHIFT) {
        return;
    }

    double mx = lon;
    double my = lat;

    lon = mx / ORIGIN_SHIFT * 180.0;
    lat = my / ORIGIN_SHIFT * 180.0;

    lat = 180.0 / M_PI * (2.0 * atan(exp(lat * M_PI / 180.0)) - HALF_PI);
}

int OsmShapefileParser::getTagTypeForGeometry(int shapeType, const QString &typeValue) {
    // If there is a typeValue, use tag mapping first
    if (!typeValue.isEmpty()) {
        for (const auto &rule : m_tagMappingRules) {
            if (rule.key == "highway" && typeValue.startsWith("highway=")) {
                QString val = typeValue.mid(9);
                if (rule.value == val || rule.value == "*") {
                    return rule.tagType;
                }
            }
        }
    }

    // Determine by geometry type
    if (IS_ARC(shapeType) || IS_POLYGON(shapeType)) {
        return TagEnum::AREA_DEFAULT;
    } else if (IS_POINT(shapeType)) {
        return TagEnum::POI_DEFAULT;
    }

    return TagEnum::UNKNOWN;
}

static void convertWebMercatorToWGS84(double &x, double &y) {
    static const double ORIGIN_SHIFT = 20037508.342789244;
    static const double HALF_PI = M_PI / 2.0;

    if (x >= -180.0 && x <= 180.0 && y >= -90.0 && y <= 90.0) {
        return;
    }

    if (x > ORIGIN_SHIFT || x < -ORIGIN_SHIFT ||
        y > ORIGIN_SHIFT || y < -ORIGIN_SHIFT) {
        return;
    }

    double mx = x;
    double my = y;

    x = mx / ORIGIN_SHIFT * 180.0;
    y = my / ORIGIN_SHIFT * 180.0;

    y = 180.0 / M_PI * (2.0 * atan(exp(y * M_PI / 180.0)) - HALF_PI);
}

struct ShpParsedBlock {
    QVector<OsmNode> nodes;
    QVector<OsmWay> ways;
    QVector<int> tagKeyIndices;
    QVector<QString> tagValues;
    QVector<int> tagNext;
    QVector<qint64> ndRefs;
    QVector<int> ndNext;
    QSet<qint64> createdNodes;
    double latMin = 90, latMax = -90, lonMin = 180, lonMax = -180;
};

struct ShpRawRecord {
    QVector<int> attrKeyIndices;
    QVector<QString> attrValues;
    int typeTagKeyIndex = -1;
    QString typeTagValue;
    bool hasTypeTag = false;
    QVector<double> xs, ys;
    QVector<int> partStarts;
    int shapeType = 0;
    int nParts = 0;
    int nVertices = 0;
};

bool OsmShapefileParser::parse(const QString &fileName, OsmModel &model, OsmStyle &style) {
    Q_UNUSED(style);

    QElapsedTimer totalTimer;
    totalTimer.start();

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

    QFileInfo fi(fileName);
    QString basePath = fi.absolutePath() + "/" + fi.baseName();
    QString shpPath = basePath + ".shp";
    QString dbfPath = basePath + ".dbf";

    if (!QFile::exists(shpPath)) {
        emitProgress(0, QStringLiteral("Shapefile does not exist: %1").arg(shpPath));
        emit parseFinished(false, tr("Shapefile not found"));
        return false;
    }

    if (!QFile::exists(dbfPath)) {
        emitProgress(0, QStringLiteral("DBF file does not exist: %1").arg(dbfPath));
        emit parseFinished(false, tr("DBF attribute file not found"));
        return false;
    }

    model.clear();

    // Initialize node cache
    m_nodeCache.clear();
    m_nextNodeId = 1;

    SHPHandle hSHP = SHPOpen(shpPath.toUtf8().constData(), "rb");
    if (!hSHP) {
        emitProgress(0, QStringLiteral("Cannot open SHP file: %1").arg(shpPath));
        emit parseFinished(false, tr("Cannot open SHP file"));
        return false;
    }

    DBFHandle hDBF = DBFOpen(dbfPath.toUtf8().constData(), "rb");
    if (!hDBF) {
        emitProgress(0, QStringLiteral("Cannot open DBF file: %1").arg(dbfPath));
        SHPClose(hSHP);
        emit parseFinished(false, tr("Cannot open DBF file"));
        return false;
    }

    int nEntities, nShapeType;
    SHPGetInfo(hSHP, &nEntities, &nShapeType, nullptr, nullptr);
    int nFields = DBFGetFieldCount(hDBF);

    QString fileNameLower = fi.fileName().toLower();
    qDebug() << "Shapefile:" << fileName << "Type:" << nShapeType << getShapeTypeName(nShapeType) << "Entities:" << nEntities << "Fields:" << nFields;

    emitProgress(5, QStringLiteral("Reading... entities=%1 fields=%2").arg(nEntities).arg(nFields));

    // Analyze DBF fields
    QList<FieldMapping> fieldMappings;
    QVector<DBFFieldType> fieldTypes(nFields);
    for (int i = 0; i < nFields; i++) {
        char fieldName[12];
        int width, decimals;
        DBFFieldType ftype = DBFGetFieldInfo(hDBF, i, fieldName, &width, &decimals);
        fieldTypes[i] = ftype;

        if (ftype == FTInvalid) continue;

        QString name = QString::fromLatin1(fieldName).toLower().trimmed();
        if (name == "osm_id" || name == "osm_way_id" || name == "id" ||
            name == "full_id" || name == "source" || name == "z_order" ||
            name == "way_area" || name == "ref") continue;

        FieldMapping mapping;
        mapping.dbfIndex = i;
        
        QString fileNameLower = fileName.toLower();
        // fclass field special handling - determine mapping based on filename
        if (name == "fclass") {
            if (fileNameLower.contains("railways")) {
                mapping.keyName = QStringLiteral("railway");
            } else if (fileNameLower.contains("waterways") || fileNameLower.contains("river") || fileNameLower.contains("stream")) {
                mapping.keyName = QStringLiteral("waterway");
            } else if (fileNameLower.contains("buildings")) {
                mapping.keyName = QStringLiteral("building");
            } else if (fileNameLower.contains("landuse")) {
                mapping.keyName = QStringLiteral("landuse");
            } else if (fileNameLower.contains("natural") || fileNameLower.contains("water")) {
                mapping.keyName = QStringLiteral("natural");
            } else if (fileNameLower.contains("places")) {
                mapping.keyName = QStringLiteral("place");
            } else if (fileNameLower.contains("pois") || fileNameLower.contains("pofw")) {
                mapping.keyName = QStringLiteral("amenity");
            } else if (fileNameLower.contains("leisure") || fileNameLower.contains("park")) {
                mapping.keyName = QStringLiteral("leisure");
            } else if (fileNameLower.contains("traffic")) {
                mapping.keyName = QStringLiteral("highway");
            } else if (fileNameLower.contains("transport")) {
                mapping.keyName = QStringLiteral("public_transport");
            } else if (fileNameLower.contains("roads")) {
                mapping.keyName = QStringLiteral("highway");
            } else {
                mapping.keyName = QStringLiteral("highway");
            }
            mapping.isTypeField = true;
        } else {
            mapping.keyName = name;
            mapping.isTypeField = (name == "type" || name == "highway" || name == "landuse" ||
                                   name == "natural" || name == "building" || name == "railway" ||
                                   name == "waterway" || name == "leisure" || name == "boundary");
        }
        fieldMappings.append(mapping);
    }

    for (auto &mapping : fieldMappings) {
        mapping.keyIndex = model.registerKey(mapping.keyName);
    }

    // Pre-register common 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"));
    model.registerKey(QStringLiteral("building"));
    model.registerKey(QStringLiteral("railway"));
    model.registerKey(QStringLiteral("ele"));
    model.registerKey(QStringLiteral("z"));
    model.registerKey(QStringLiteral("m"));
    model.registerKey(QStringLiteral("part"));
    model.registerKey(QStringLiteral("amenity"));
    model.registerKey(QStringLiteral("shop"));
    model.registerKey(QStringLiteral("tourism"));
    model.registerKey(QStringLiteral("historic"));
    model.registerKey(QStringLiteral("barrier"));
    model.registerKey(QStringLiteral("boundary"));
    model.registerKey(QStringLiteral("place"));
    model.registerKey(QStringLiteral("aeroway"));
    model.registerKey(QStringLiteral("power"));
    model.registerKey(QStringLiteral("man_made"));
    model.registerKey(QStringLiteral("sport"));
    model.registerKey(QStringLiteral("military"));
    model.registerKey(QStringLiteral("poi"));
    model.registerKey(QStringLiteral("public_transport"));
    model.registerKey(QStringLiteral("leisure"));
    model.registerKey(QStringLiteral("role"));

    // Set up thread pool
    int idealThreads = QThread::idealThreadCount();
    int threadCount = qMax(1, qMin(idealThreads, 8));

    if (nEntities > 50000) {
        threadCount = qMin(idealThreads, 12);
    }
    if (nEntities > 100000) {
        threadCount = qMin(idealThreads, 16);
    }

    qDebug() << "Using" << threadCount << "threads for Shapefile parsing (" << nEntities << "records)";

    // ========== Phase 1: Single-threaded preload SHP/DBF data ==========
    PERF_START("Shapefile_Phase1", "Preload", nEntities);
    emitProgress(5, QStringLiteral("Preloading records..."));

    QVector<ShpRawRecord> rawRecords(nEntities);

    for (int i = 0; i < nEntities; i++) {
        if (i % 10000 == 0) {
            int pct = 5 + (int)(10.0 * i / qMax(1, nEntities));
            emitProgress(pct, QStringLiteral("Preloading... %1/%2").arg(i).arg(nEntities));
        }

        ShpRawRecord record;

        SHPObject *psShape = SHPReadObject(hSHP, i);
        if (!psShape) {
            continue;
        }

        record.shapeType = psShape->nSHPType;
        record.nParts = psShape->nParts;
        record.nVertices = psShape->nVertices;

        record.attrKeyIndices.reserve(fieldMappings.size());
        record.attrValues.reserve(fieldMappings.size());

        for (const auto &mapping : fieldMappings) {
            QString value;
            DBFFieldType ftype = fieldTypes[mapping.dbfIndex];
            if (ftype == FTString) {
                value = QString::fromUtf8(DBFReadStringAttribute(hDBF, i, mapping.dbfIndex));
            } else if (ftype == FTInteger) {
                value = QString::number(DBFReadIntegerAttribute(hDBF, i, mapping.dbfIndex));
            } else if (ftype == FTDouble) {
                value = QString::number(DBFReadDoubleAttribute(hDBF, i, mapping.dbfIndex));
            }
            if (!value.isEmpty()) {
                record.attrKeyIndices.append(mapping.keyIndex);
                record.attrValues.append(value);
                if (mapping.isTypeField) {
                    record.hasTypeTag = true;
                    record.typeTagKeyIndex = mapping.keyIndex;
                    record.typeTagValue = value;
                }
            }
        }

        if (psShape->nVertices > 0) {
            record.xs.resize(psShape->nVertices);
            record.ys.resize(psShape->nVertices);
            for (int j = 0; j < psShape->nVertices; j++) {
                double x = psShape->padfX ? psShape->padfX[j] : 0;
                double y = psShape->padfY ? psShape->padfY[j] : 0;
                convertWebMercatorToWGS84(x, y);
                record.xs[j] = x;
                record.ys[j] = y;
            }
        }

        if (psShape->nParts > 0) {
            record.partStarts.resize(psShape->nParts);
            for (int p = 0; p < psShape->nParts; p++) {
                record.partStarts[p] = psShape->panPartStart ? psShape->panPartStart[p] : 0;
            }
        }

        rawRecords[i] = record;
        SHPDestroyObject(psShape);
    }

    SHPClose(hSHP);
    DBFClose(hDBF);
    PERF_END("Shapefile_Phase1", "Preload", QString("records=%1").arg(nEntities));

    // ========== Phase 2: Parallel parsing into OsmModel data structures ==========
    PERF_START("Shapefile_Phase2", "ParallelParse", nEntities);
    emitProgress(15, QStringLiteral("Starting parallel parsing... record count=%1").arg(nEntities));

    // Pre-compute default tags
    int defaultTagKeyIndex = -1;
    QString defaultTagValue;
    bool hasDefaultTag = false;

    if (fileNameLower.contains("waterways")) {
        defaultTagKeyIndex = model.registerKey(QStringLiteral("waterway"));
        defaultTagValue = QStringLiteral("river");
        hasDefaultTag = true;
    } else if (fileNameLower.contains("roads")) {
        defaultTagKeyIndex = model.registerKey(QStringLiteral("highway"));
        defaultTagValue = QStringLiteral("unclassified");
        hasDefaultTag = true;
    } else if (fileNameLower.contains("railways")) {
        defaultTagKeyIndex = model.registerKey(QStringLiteral("railway"));
        defaultTagValue = QStringLiteral("rail");
        hasDefaultTag = true;
    } else if (fileNameLower.contains("buildings")) {
        defaultTagKeyIndex = model.registerKey(QStringLiteral("building"));
        defaultTagValue = QStringLiteral("yes");
        hasDefaultTag = true;
    } else if (fileNameLower.contains("landuse")) {
        defaultTagKeyIndex = model.registerKey(QStringLiteral("landuse"));
        defaultTagValue = QStringLiteral("residential");
        hasDefaultTag = true;
    } else if (fileNameLower.contains("natural") || fileNameLower.contains("water")) {
        defaultTagKeyIndex = model.registerKey(QStringLiteral("natural"));
        defaultTagValue = QStringLiteral("water");
        hasDefaultTag = true;
    } else if (fileNameLower.contains("traffic")) {
        defaultTagKeyIndex = model.registerKey(QStringLiteral("highway"));
        defaultTagValue = QStringLiteral("unclassified");
        hasDefaultTag = true;
    } else if (fileNameLower.contains("forest") || fileNameLower.contains("wood")) {
        defaultTagKeyIndex = model.registerKey(QStringLiteral("natural"));
        defaultTagValue = QStringLiteral("wood");
        hasDefaultTag = true;
    } else if (fileNameLower.contains("grass") || fileNameLower.contains("green")) {
        defaultTagKeyIndex = model.registerKey(QStringLiteral("landuse"));
        defaultTagValue = QStringLiteral("grass");
        hasDefaultTag = true;
    } else if (fileNameLower.contains("park")) {
        defaultTagKeyIndex = model.registerKey(QStringLiteral("leisure"));
        defaultTagValue = QStringLiteral("park");
        hasDefaultTag = true;
    } else if (fileNameLower.contains("places")) {
        defaultTagKeyIndex = model.registerKey(QStringLiteral("place"));
        defaultTagValue = QStringLiteral("village");
        hasDefaultTag = true;
    } else if (fileNameLower.contains("pois")) {
        defaultTagKeyIndex = model.registerKey(QStringLiteral("poi"));
        defaultTagValue = QStringLiteral("yes");
        hasDefaultTag = true;
    } else if (fileNameLower.contains("adminareas")) {
        defaultTagKeyIndex = model.registerKey(QStringLiteral("boundary"));
        defaultTagValue = QStringLiteral("administrative");
        hasDefaultTag = true;
    } else if (fileNameLower.contains("protected")) {
        defaultTagKeyIndex = model.registerKey(QStringLiteral("boundary"));
        defaultTagValue = QStringLiteral("protected_area");
        hasDefaultTag = true;
    } else if (fileNameLower.contains("pofw")) {
        defaultTagKeyIndex = model.registerKey(QStringLiteral("amenity"));
        defaultTagValue = QStringLiteral("place_of_worship");
        hasDefaultTag = true;
    } else if (fileNameLower.contains("river") || fileNameLower.contains("stream")) {
        defaultTagKeyIndex = model.registerKey(QStringLiteral("waterway"));
        defaultTagValue = QStringLiteral("river");
        hasDefaultTag = true;
    } else if (fileNameLower.contains("lake") || fileNameLower.contains("pond")) {
        defaultTagKeyIndex = model.registerKey(QStringLiteral("natural"));
        defaultTagValue = QStringLiteral("water");
        hasDefaultTag = true;
    } else if (fileNameLower.contains("aeroway") || fileNameLower.contains("airport")) {
        defaultTagKeyIndex = model.registerKey(QStringLiteral("aeroway"));
        defaultTagValue = QStringLiteral("runway");
        hasDefaultTag = true;
    } else if (fileNameLower.contains("power")) {
        defaultTagKeyIndex = model.registerKey(QStringLiteral("power"));
        defaultTagValue = QStringLiteral("line");
        hasDefaultTag = true;
    } else if (fileNameLower.contains("man_made") || fileNameLower.contains("manmade")) {
        defaultTagKeyIndex = model.registerKey(QStringLiteral("man_made"));
        defaultTagValue = QStringLiteral("yes");
        hasDefaultTag = true;
    } else if (fileNameLower.contains("barrier")) {
        defaultTagKeyIndex = model.registerKey(QStringLiteral("barrier"));
        defaultTagValue = QStringLiteral("fence");
        hasDefaultTag = true;
    } else if (fileNameLower.contains("historic")) {
        defaultTagKeyIndex = model.registerKey(QStringLiteral("historic"));
        defaultTagValue = QStringLiteral("yes");
        hasDefaultTag = true;
    } else if (fileNameLower.contains("tourism")) {
        defaultTagKeyIndex = model.registerKey(QStringLiteral("tourism"));
        defaultTagValue = QStringLiteral("attraction");
        hasDefaultTag = true;
    } else if (fileNameLower.contains("military")) {
        defaultTagKeyIndex = model.registerKey(QStringLiteral("military"));
        defaultTagValue = QStringLiteral("area");
        hasDefaultTag = true;
    } else if (nEntities > 0 && IS_POINT(nShapeType)) {
        defaultTagKeyIndex = model.registerKey(QStringLiteral("highway"));
        defaultTagValue = QStringLiteral("unclassified");
        hasDefaultTag = true;
    } else {
        defaultTagKeyIndex = model.registerKey(QStringLiteral("landuse"));
        defaultTagValue = QStringLiteral("residential");
        hasDefaultTag = true;
    }

    int roleKeyIndex = model.registerKey(QStringLiteral("role"));

    QThreadPool parsePool;
    parsePool.setMaxThreadCount(threadCount);

    QVector<ShpParsedBlock*> parsedResults(threadCount);
    for (int t = 0; t < threadCount; t++) {
        parsedResults[t] = new ShpParsedBlock();
        parsedResults[t]->nodes.reserve(nEntities / threadCount + 1000);
        parsedResults[t]->ways.reserve(nEntities / threadCount + 500);
        parsedResults[t]->tagKeyIndices.reserve(nEntities * 3);
        parsedResults[t]->tagValues.reserve(nEntities * 3);
        parsedResults[t]->tagNext.reserve(nEntities * 3);
        parsedResults[t]->ndRefs.reserve(nEntities * 5);
        parsedResults[t]->ndNext.reserve(nEntities * 5);
    }

    std::atomic<bool> parseFailed(false);
    std::atomic<int> parseCompleted(0);

    class ShpParseTask : public QRunnable {
    public:
        int startIdx, endIdx;
        int threadId;
        QVector<ShpRawRecord> *rawRecords;
        QString fileNameLower;
        std::atomic<bool> *failed;
        std::atomic<int> *completedCount;
        ShpParsedBlock *result;

        GeoCoord::CoordMap<qint64> *nodeCache;
        QMutex *nodeCacheMutex;
        std::atomic<qint64> *nextNodeId;

        GeoCoord::CoordMap<qint64> localNodeCache;

        int defaultTagKeyIndex;
        QString defaultTagValue;
        bool hasDefaultTag;

        int roleKeyIndex;

        ShpParseTask(int s, int e, int tid,
                     QVector<ShpRawRecord> *records,
                     const QString &fn,
                     std::atomic<bool> *f,
                     std::atomic<int> *completed,
                     ShpParsedBlock *res,
                     GeoCoord::CoordMap<qint64> *cache,
                     QMutex *mutex,
                     std::atomic<qint64> *id,
                     int defKeyIdx, const QString &defVal, bool hasDef,
                     int roleIdx)
            : startIdx(s), endIdx(e), threadId(tid),
              rawRecords(records), fileNameLower(fn),
              failed(f), completedCount(completed), result(res),
              nodeCache(cache), nodeCacheMutex(mutex), nextNodeId(id),
              defaultTagKeyIndex(defKeyIdx), defaultTagValue(defVal),
              hasDefaultTag(hasDef), roleKeyIndex(roleIdx) {
            setAutoDelete(false);
        }

        qint64 getOrCreateNodeId(double lon, double lat) {
            qint64 existingId;
            if (localNodeCache.value(lon, lat, &existingId)) {
                return existingId;
            }

            QMutexLocker locker(nodeCacheMutex);
            if (nodeCache->value(lon, lat, &existingId)) {
                localNodeCache.insert(lon, lat, existingId);
                return existingId;
            }

            qint64 nodeId = (*nextNodeId)++;
            nodeCache->insert(lon, lat, nodeId);
            localNodeCache.insert(lon, lat, nodeId);
            return nodeId;
        }

        int addTempTag(int keyIndex, const QString &value, int next) {
            result->tagKeyIndices.append(keyIndex);
            result->tagValues.append(value);
            result->tagNext.append(next);
            return result->tagKeyIndices.size() - 1;
        }

        int addTempNd(qint64 ref, int next) {
            result->ndRefs.append(ref);
            result->ndNext.append(next);
            return result->ndRefs.size() - 1;
        }

        // Normalize highway values (handle variants in fclass field)
        QString normalizeHighwayValue(const QString &value) {
            QString v = value.toLower().trimmed();
            
            // Handle link types (connector roads for main roads)
            if (v.endsWith("_link")) {
                v = v.left(v.length() - 5);
            }
            
            // Handle common variant names
            static QHash<QString, QString> highwayMapping = {
                {"motorway", "motorway"},
                {"trunk", "trunk"},
                {"primary", "primary"},
                {"secondary", "secondary"},
                {"tertiary", "tertiary"},
                {"residential", "residential"},
                {"unclassified", "unclassified"},
                {"track", "track"},
                {"path", "path"},
                {"footway", "footway"},
                {"cycleway", "cycleway"},
                {"steps", "steps"},
                {"service", "service"},
                {"living_street", "living_street"},
                {"pedestrian", "pedestrian"},
                {"road", "unclassified"},
                {"unknown", "unclassified"},
                {"minor", "unclassified"},
                {"living", "living_street"},
                {"bridleway", "path"},
                {"byway", "track"},
                {"construction", "unclassified"},
                {"proposed", "unclassified"}
            };
            
            if (highwayMapping.contains(v)) {
                return highwayMapping[v];
            }
            
            return v;
        }

        void run() override {
            if (*failed) return;

            for (int i = startIdx; i < endIdx && !*failed; i++) {
                const ShpRawRecord &record = (*rawRecords)[i];

                if (record.xs.isEmpty() || record.nVertices == 0) continue;

                bool needDefaultTag = !record.hasTypeTag && hasDefaultTag;

                if (IS_POINT(record.shapeType)) {
                    double lon = record.xs[0];
                    double lat = record.ys[0];

                    qint64 nodeId = getOrCreateNodeId(lon, lat);
                    OsmNode node(nodeId, lat, lon);

                    int tagHead = -1;
                    for (int a = 0; a < record.attrKeyIndices.size(); a++) {
                        tagHead = addTempTag(record.attrKeyIndices[a], record.attrValues[a], tagHead);
                    }
                    if (needDefaultTag) {
                        tagHead = addTempTag(defaultTagKeyIndex, defaultTagValue, tagHead);
                    }
                    node.setTagHead(tagHead);

                    if (!result->createdNodes.contains(nodeId)) {
                        result->nodes.append(node);
                        result->createdNodes.insert(nodeId);
                    }

                    if (lat < result->latMin) result->latMin = lat;
                    if (lat > result->latMax) result->latMax = lat;
                    if (lon < result->lonMin) result->lonMin = lon;
                    if (lon > result->lonMax) result->lonMax = lon;
                }
                else if (IS_ARC(record.shapeType) || IS_POLYGON(record.shapeType) || record.shapeType == SHPT_MULTIPATCH) {
                    int actualParts = qMax(1, record.nParts);

                    bool isPolygonType = IS_POLYGON(record.shapeType);
                    bool isPolygon = isPolygonType;

                    QString defaultVal = defaultTagValue;
                    if (hasDefaultTag && !record.hasTypeTag) {
                        if (fileNameLower.contains("natural") || fileNameLower.contains("water")) {
                            defaultVal = isPolygon ? QStringLiteral("water") : QStringLiteral("coastline");
                        } else if (fileNameLower.contains("traffic")) {
                            defaultVal = isPolygon ? QStringLiteral("parking") : QStringLiteral("traffic_signals");
                        } else if (fileNameLower.contains("places")) {
                            defaultVal = isPolygon ? QStringLiteral("town") : QStringLiteral("village");
                        } else if (fileNameLower.contains("aeroway") || fileNameLower.contains("airport")) {
                            defaultVal = isPolygon ? QStringLiteral("aerodrome") : QStringLiteral("runway");
                        }
                    }

                    for (int p = 0; p < actualParts; p++) {
                        int partStart = (!record.partStarts.isEmpty() && p < record.partStarts.size()) ? record.partStarts[p] : 0;
                        int partEnd = (p + 1 < actualParts && p + 1 < record.partStarts.size())
                            ? record.partStarts[p + 1] : record.nVertices;
                        int partVerts = partEnd - partStart;
                        if (partVerts < 2) continue;

                        QVector<qint64> nodeIds;
                        nodeIds.reserve(partVerts);

                        QVector<double> ringXs, ringYs;
                        if (isPolygonType && actualParts > 1) {
                            ringXs.reserve(partVerts);
                            ringYs.reserve(partVerts);
                        }

                        for (int j = 0; j < partVerts; j++) {
                            int idx = partStart + j;
                            double lon = record.xs[idx];
                            double lat = record.ys[idx];

                            qint64 nodeId = getOrCreateNodeId(lon, lat);
                            
                            if (!result->createdNodes.contains(nodeId)) {
                                OsmNode node(nodeId, lat, lon);
                                node.setTagHead(-1);
                                result->nodes.append(node);
                                result->createdNodes.insert(nodeId);
                            }
                            nodeIds.append(nodeId);

                            if (isPolygonType && actualParts > 1) {
                                ringXs.append(lon);
                                ringYs.append(lat);
                            }

                            if (lat < result->latMin) result->latMin = lat;
                            if (lat > result->latMax) result->latMax = lat;
                            if (lon < result->lonMin) result->lonMin = lon;
                            if (lon > result->lonMax) result->lonMax = lon;
                        }

                        int ndHead = -1;
                        for (int k = nodeIds.size() - 1; k >= 0; k--) {
                            ndHead = addTempNd(nodeIds[k], ndHead);
                        }

                        int tagHead = -1;

                        RingType ringType = RING_UNKNOWN;
                        if (isPolygonType && actualParts > 1 && ringXs.size() >= 3) {
                            ringType = determineRingType(
                                ringXs.constData(), ringYs.constData(), ringXs.size());

                            if (ringType == RING_INNER) {
                                tagHead = addTempTag(roleKeyIndex, QStringLiteral("inner"), tagHead);
                            } else {
                                tagHead = addTempTag(roleKeyIndex, QStringLiteral("outer"), tagHead);
                            }
                        }

                        if (!isPolygonType || p == 0 ||
                            (isPolygonType && actualParts > 1 && ringType == RING_OUTER)) {
                            for (int a = 0; a < record.attrKeyIndices.size(); a++) {
                                tagHead = addTempTag(record.attrKeyIndices[a], record.attrValues[a], tagHead);
                            }
                            if (needDefaultTag) {
                                tagHead = addTempTag(defaultTagKeyIndex, defaultVal, tagHead);
                            }
                        }

                        OsmWay way(i * 1000 + p);
                        way.setNdHead(ndHead);
                        way.setTagHead(tagHead);
                        result->ways.append(way);
                    }
                }
            }

            completedCount->fetch_add(1);
        }
    };

    QVector<ShpParseTask*> parseTasks;
    int recordsPerParseTask = (nEntities + threadCount - 1) / threadCount;

    for (int t = 0; t < threadCount; t++) {
        int start = t * recordsPerParseTask;
        int end = qMin(start + recordsPerParseTask, nEntities);
        if (start >= nEntities) break;

        auto *task = new ShpParseTask(start, end, t,
                                      &rawRecords,
                                      fileNameLower,
                                      &parseFailed,
                                      &parseCompleted,
                                      parsedResults[t],
                                      &m_nodeCache,
                                      &m_nodeCacheMutex,
                                      &m_nextNodeId,
                                      defaultTagKeyIndex,
                                      defaultTagValue,
                                      hasDefaultTag,
                                      roleKeyIndex);
        parseTasks.append(task);
        parsePool.start(task);
    }

    int lastParseReported = -1;
    while (!parsePool.waitForDone(100)) {
        if (parseFailed.load()) {
            parsePool.clear();
            parsePool.waitForDone();
            qDeleteAll(parsedResults);
            emitProgress(0, QStringLiteral("Parsing failed"));
            emit parseFinished(false, tr("Parsing failed"));
            return false;
        }
        int done = parseCompleted.load();
        int pct = 15 + (int)(75.0 * done / qMax(1, threadCount));
        if (pct != lastParseReported) {
            lastParseReported = pct;
            emitProgress(pct, QStringLiteral("Parallel parsing in progress... %1/%2").arg(done).arg(threadCount));
        }
    }

    if (parseFailed.load()) {
        qDeleteAll(parsedResults);
        emitProgress(0, QStringLiteral("Parsing failed"));
        emit parseFinished(false, tr("Parsing failed"));
        return false;
    }

    qint64 parseTime = totalTimer.elapsed();
    qDebug() << "Parallel parsing done in" << parseTime << "ms, threads:" << threadCount;
    PERF_END("Shapefile_Phase2", "ParallelParse", QString("time=%1ms").arg(parseTime));
    emitProgress(90, QStringLiteral("Parsing complete (%1ms), merging results...").arg(parseTime));

    // ========== Phase 3: Merge all blocks (following PBF's mergeAllBlocksFast pattern) ==========
    PERF_START("Shapefile_Phase3", "Merge");
    int totalTags = 0, totalNds = 0, totalNodes = 0, totalWays = 0;
    for (int t = 0; t < threadCount; t++) {
        ShpParsedBlock *b = parsedResults[t];
        totalTags += b->tagKeyIndices.size();
        totalNds += b->ndRefs.size();
        totalNodes += b->nodes.size();
        totalWays += b->ways.size();
    }

    model.reserveTags(model.tagCount() + totalTags);
    model.reserveNds(model.nds().size() + totalNds);
    model.reserveNodes(model.nodeCount() + totalNodes);
    model.reserveWays(model.wayCount() + totalWays);

    // Merge data
    int tagOffset = 0, ndOffset = 0;
    OsmBounds bounds;

    for (int t = 0; t < threadCount; t++) {
        ShpParsedBlock *b = parsedResults[t];

        for (int i = 0; i < b->tagKeyIndices.size(); i++) {
            int keyId = b->tagKeyIndices[i];
            int next = (b->tagNext[i] >= 0) ? (b->tagNext[i] + tagOffset) : -1;
            model.addTag(keyId, b->tagValues[i], next);
        }

        for (int i = 0; i < b->ndRefs.size(); i++) {
            int next = (b->ndNext[i] >= 0) ? (b->ndNext[i] + ndOffset) : -1;
            model.addNd(b->ndRefs[i], next);
        }

        for (int i = 0; i < b->nodes.size(); i++) {
            OsmNode node = b->nodes[i];
            if (node.tagHead() >= 0) node.setTagHead(node.tagHead() + tagOffset);
            model.addNode(node);
        }

        for (int i = 0; i < b->ways.size(); i++) {
            OsmWay way = b->ways[i];
            if (way.tagHead() >= 0) way.setTagHead(way.tagHead() + tagOffset);
            if (way.ndHead() >= 0) way.setNdHead(way.ndHead() + ndOffset);
            model.addWay(way);
        }

        bounds.extend(b->latMin, b->lonMin);
        bounds.extend(b->latMax, b->lonMax);

        tagOffset += b->tagKeyIndices.size();
        ndOffset += b->ndRefs.size();
    }

    qDeleteAll(parsedResults);
    PERF_END("Shapefile_Phase3", "Merge", QString("tags=%1 nds=%2 nodes=%3 ways=%4").arg(totalTags).arg(totalNds).arg(totalNodes).arg(totalWays));

    emitProgress(95, QStringLiteral("Building draw list..."));
    PERF_START("Shapefile_Finalize", "BuildDrawList");
    model.finalizeAfterLoad();
    PERF_END("Shapefile_Finalize", "BuildDrawList");

    int64_t elapsed = totalTimer.elapsed();
    qDebug() << "=== Shapefile parallel parsing total:" << elapsed << "ms, nodes:" << model.nodeCount()
             << "ways:" << model.wayCount() << "threads:" << threadCount << "===";

    emitProgress(100, QStringLiteral("Parsing complete (%1ms): nodes=%2 ways=%3")
        .arg(elapsed).arg(model.nodeCount()).arg(model.wayCount()));
    emit parseFinished(true);
    return true;
}