osmmapwidget.cpp

#include "osmmapwidget.h"

#include <QPainter>
#include <QPainterPath>
#include <QPaintEvent>
#include <QResizeEvent>
#include <QWheelEvent>
#include <QMouseEvent>
#include <QKeyEvent>
#include <QFileDialog>
#include <QtMath>
#include <QPolygonF>
#include <QDebug>
#include <QtConcurrent>
#include <QThread>
#include <QVector>
#include <QElapsedTimer>
#include <QSet>
#include <QSvgRenderer>
#include <QCoreApplication>
#include <QToolTip>

// POI icon cache -- pre-render SVGs to QPixmap to avoid repeated SVG parsing every frame
class PoiIconCache {
public:
    static const int ICON_SIZE = 16; // Standard POI icon size

    void init() {
        QString baseDir = QCoreApplication::applicationDirPath()
                          + QStringLiteral("/resources/images/presets/");

        // --- Tourism (110-121) ---
        registerIcon(TagEnum::TOURISM_HOTEL,             baseDir + "accommodation/hotel.svg");
        registerIcon(TagEnum::TOURISM_MOTEL,             baseDir + "accommodation/motel.svg");
        registerIcon(TagEnum::TOURISM_HOSTEL,            baseDir + "accommodation/hostel.svg");
        registerIcon(TagEnum::TOURISM_GUESTHOUSE,        baseDir + "accommodation/guest_house.svg");
        registerIcon(TagEnum::TOURISM_ATTRACTION,        baseDir + "sightseeing/monument.svg");
        registerIcon(TagEnum::TOURISM_MUSEUM,            baseDir + "landmark/cross.svg");
        registerIcon(TagEnum::TOURISM_VIEWPOINT,         baseDir + "landmark/beacon.svg");
        registerIcon(TagEnum::TOURISM_ZOO,               baseDir + "leisure/zoo.svg");
        registerIcon(TagEnum::TOURISM_CAMP_SITE,        baseDir + "accommodation/camping.svg");
        registerIcon(TagEnum::TOURISM_CARAVAN_SITE,      baseDir + "accommodation/caravan.svg");
        registerIcon(TagEnum::TOURISM_PICNIC_SITE,      baseDir + "leisure/picnic.svg");
        registerIcon(TagEnum::TOURISM_THEME_PARK,        baseDir + "leisure/theme_park.svg");

        // --- Amenity (122-141) ---
        registerIcon(TagEnum::AMENITY_HOSPITAL,         baseDir + "health/hospital.svg");
        registerIcon(TagEnum::AMENITY_SCHOOL,           baseDir + "education/school.svg");
        registerIcon(TagEnum::AMENITY_UNIVERSITY,        baseDir + "education/university.svg");
        registerIcon(TagEnum::AMENITY_POLICE,            baseDir + "emergency/assembly_point.svg");
        registerIcon(TagEnum::AMENITY_FIRE_STATION,      baseDir + "emergency/lifeguard.svg");
        registerIcon(TagEnum::AMENITY_PARKING,           baseDir + "vehicle/parking/parking.svg");
        registerIcon(TagEnum::AMENITY_FUEL,              baseDir + "vehicle/fuel.svg");
        registerIcon(TagEnum::AMENITY_RESTAURANT,        baseDir + "food/restaurant.svg");
        registerIcon(TagEnum::AMENITY_CAFE,              baseDir + "food/cafe.svg");
        registerIcon(TagEnum::AMENITY_PUB,               baseDir + "food/pub.svg");
        registerIcon(TagEnum::AMENITY_BAR,               baseDir + "food/bar.svg");
        registerIcon(TagEnum::AMENITY_BANK,              baseDir + "money/bank.svg");
        registerIcon(TagEnum::AMENITY_ATM,               baseDir + "money/atm.svg");
        registerIcon(TagEnum::AMENITY_PHARMACY,          baseDir + "health/pharmacy.svg");
        registerIcon(TagEnum::AMENITY_POST_OFFICE,      baseDir + "misc/flag.svg");
        registerIcon(TagEnum::AMENITY_LIBRARY,          baseDir + "education/library.svg");
        registerIcon(TagEnum::AMENITY_TOWN_HALL,         baseDir + "office/government.svg");
        registerIcon(TagEnum::AMENITY_PUBLIC_BUILDING,   baseDir + "office/government.svg");
        registerIcon(TagEnum::AMENITY_PLACE_OF_WORSHIP,  baseDir + "religion/church.svg");
        registerIcon(TagEnum::AMENITY_CHURCH,            baseDir + "religion/church.svg");

        // --- Shop (142-153) ---
        registerIcon(TagEnum::SHOP_SUPERMARKET,  baseDir + "shop/supermarket.svg");
        registerIcon(TagEnum::SHOP_MALL,         baseDir + "shop/mall.svg");
        registerIcon(TagEnum::SHOP_CONVENIENCE,  baseDir + "shop/convenience.svg");
        registerIcon(TagEnum::SHOP_CLOTHES,      baseDir + "shop/clothes.svg");
        registerIcon(TagEnum::SHOP_BAKERY,       baseDir + "shop/groceries/bakery.svg");
        registerIcon(TagEnum::SHOP_BUTCHER,      baseDir + "shop/groceries/butcher.svg");
        registerIcon(TagEnum::SHOP_GROCERY,      baseDir + "shop/groceries/farm.svg");
        registerIcon(TagEnum::SHOP_HARDWARE,     baseDir + "shop/hardware.svg");
        registerIcon(TagEnum::SHOP_FURNITURE,    baseDir + "shop/furniture.svg");
        registerIcon(TagEnum::SHOP_BICYCLE,      baseDir + "shop/bicycle.svg");
        registerIcon(TagEnum::SHOP_CAR,          baseDir + "vehicle/car_parts.svg");
        registerIcon(TagEnum::SHOP_CAR_REPAIR,   baseDir + "vehicle/repair_shop.svg");

        // --- Sport (154-158) ---
        registerIcon(TagEnum::SPORT_SOCCER,     baseDir + "sport/soccer.svg");
        registerIcon(TagEnum::SPORT_TENNIS,     baseDir + "sport/tennis.svg");
        registerIcon(TagEnum::SPORT_BASKETBALL, baseDir + "sport/basketball.svg");
        registerIcon(TagEnum::SPORT_SWIMMING,    baseDir + "sport/swimming.svg");
        registerIcon(TagEnum::SPORT_BASEBALL,    baseDir + "sport/baseball.svg");

        // --- Leisure (74-84) ---
        registerIcon(TagEnum::LEISURE_PARK,            baseDir + "leisure/park.svg");
        registerIcon(TagEnum::LEISURE_GOLF_COURSE,     baseDir + "sport/golf.svg");
        registerIcon(TagEnum::LEISURE_SPORTS_CENTRE,   baseDir + "sport/sports_centre.svg");
        registerIcon(TagEnum::LEISURE_STADIUM,         baseDir + "sport/stadium.svg");
        registerIcon(TagEnum::LEISURE_PLAYGROUND,      baseDir + "leisure/playground.svg");
        registerIcon(TagEnum::LEISURE_PITCH,           baseDir + "sport/pitch.svg");
        registerIcon(TagEnum::LEISURE_MARINA,          baseDir + "nautical/marina.svg");
        registerIcon(TagEnum::LEISURE_NATURE_RESERVE,  baseDir + "leisure/nature_reserve.svg");
        registerIcon(TagEnum::LEISURE_WATER_PARK,      baseDir + "leisure/water_park.svg");
        registerIcon(TagEnum::LEISURE_GARDEN,          baseDir + "leisure/garden.svg");
        registerIcon(TagEnum::LEISURE_COMMON,           baseDir + "leisure/common.svg");

        // --- Historic (105-109) ---
        registerIcon(TagEnum::HISTORIC_CASTLE,                baseDir + "sightseeing/castle.svg");
        registerIcon(TagEnum::HISTORIC_RUINS,                 baseDir + "sightseeing/ruins.svg");
        registerIcon(TagEnum::HISTORIC_MEMORIAL,              baseDir + "sightseeing/monument.svg");
        registerIcon(TagEnum::HISTORIC_MONUMENT,              baseDir + "sightseeing/monument.svg");
        registerIcon(TagEnum::HISTORIC_ARCHAEOLOGICAL_SITE,   baseDir + "sightseeing/monument.svg");

        // --- Power (102-103) ---
        registerIcon(TagEnum::POWER_TOWER,        baseDir + "power/tower.svg");
        registerIcon(TagEnum::POWER_SUBSTATION,   baseDir + "power/substation.svg");

        // --- Barrier (90-95) ---
        registerIcon(TagEnum::BARRIER_FENCE,          baseDir + "barrier/fence.svg");
        registerIcon(TagEnum::BARRIER_WALL,           baseDir + "barrier/wall.svg");
        registerIcon(TagEnum::BARRIER_HEDGE,          baseDir + "barrier/hedge.svg");
        registerIcon(TagEnum::BARRIER_DITCH,          baseDir + "nautical/waterway_ditch.svg");
        registerIcon(TagEnum::BARRIER_RETAINING_WALL, baseDir + "barrier/retaining_wall.svg");
        registerIcon(TagEnum::BARRIER_CITY_WALL,      baseDir + "barrier/city_wall.svg");

        // --- Highway traffic signals ---
        registerIcon(TagEnum::HIGHWAY_TRAFFIC_SIGNALS, baseDir + "vehicle/traffic_signals.svg");

        // --- Railway ---
        registerIcon(TagEnum::RAILWAY,          baseDir + "transport/railway/rail.svg");
        registerIcon(TagEnum::RAILWAY,         baseDir + "transport/station.svg");

        // --- Waterway / Natural ---
        registerIcon(TagEnum::WATERWAY,         baseDir + "nautical/waterway_river.svg");
        registerIcon(TagEnum::WATERWAY_RIVER,   baseDir + "nautical/waterway_river.svg");
        registerIcon(TagEnum::WATERWAY_STREAM,  baseDir + "nautical/waterway_stream.svg");
        registerIcon(TagEnum::WATERWAY_CANAL,   baseDir + "nautical/waterway_canal.svg");
        registerIcon(TagEnum::NATURAL_WATER,    baseDir + "nautical/water.svg");
        registerIcon(TagEnum::NATURAL_WOOD,     baseDir + "landmark/trees.svg");
        registerIcon(TagEnum::NATURAL_ROCK,    baseDir + "landmark/peak.svg");

        // --- Aeroway ---
        registerIcon(TagEnum::AEROWAY_AERODROME, baseDir + "transport/airport.svg");

        // --- POI types (178-204) ---
        registerIcon(TagEnum::POI_CITY,          baseDir + "place/city.svg");
        registerIcon(TagEnum::POI_TOWN,          baseDir + "place/town.svg");
        registerIcon(TagEnum::POI_VILLAGE,       baseDir + "place/village.svg");
        registerIcon(TagEnum::POI_HIGHWAY_EXIT,  baseDir + "transport/way/motorway.svg");
        registerIcon(TagEnum::POI_TOLL_BOOTH,    baseDir + "vehicle/restriction/toll_gantry.svg");
        registerIcon(TagEnum::POI_FUEL,          baseDir + "vehicle/fuel.svg");
        registerIcon(TagEnum::POI_MARINA,        baseDir + "nautical/marina.svg");
        registerIcon(TagEnum::POI_BAR,           baseDir + "food/bar.svg");
        registerIcon(TagEnum::POI_CAMPSITE,      baseDir + "accommodation/camping.svg");
        registerIcon(TagEnum::POI_PARK,          baseDir + "leisure/park.svg");
        registerIcon(TagEnum::POI_PICNIC,        baseDir + "leisure/picnic.svg");
        registerIcon(TagEnum::POI_AIRPORT,        baseDir + "transport/airport.svg");
        registerIcon(TagEnum::POI_SHOPPING,       baseDir + "shop/mall.svg");
        registerIcon(TagEnum::POI_RESTAURANT,    baseDir + "food/restaurant.svg");
        registerIcon(TagEnum::POI_HOTEL,          baseDir + "accommodation/hotel.svg");
        registerIcon(TagEnum::POI_PARKING,       baseDir + "vehicle/parking/parking.svg");
        registerIcon(TagEnum::POI_DEFAULT,       baseDir + "misc/no_icon.svg");
        registerIcon(TagEnum::POI_HOSPITAL,      baseDir + "health/hospital.svg");
        registerIcon(TagEnum::POI_BRIDGE,        baseDir + "transport/bridge/bridge.svg");
        registerIcon(TagEnum::POI_WATER_FEATURE, baseDir + "nautical/waterfall.svg");
        registerIcon(TagEnum::POI_ISLAND,        baseDir + "place/island.svg");
        registerIcon(TagEnum::POI_LAND_FEATURE,  baseDir + "landmark/peak.svg");
        registerIcon(TagEnum::POI_CAPE,          baseDir + "nautical/cape.svg");
        registerIcon(TagEnum::POI_ATTRACTION,    baseDir + "sightseeing/monument.svg");
        registerIcon(TagEnum::POI_MUSEUM,        baseDir + "sightseeing/monument.svg");

        // --- Place (175-180) ---
        registerIcon(TagEnum::PLACE_CITY,    baseDir + "place/capital.svg");
        registerIcon(TagEnum::PLACE_TOWN,    baseDir + "place/town.svg");
        registerIcon(TagEnum::PLACE_VILLAGE, baseDir + "place/village.svg");
        registerIcon(TagEnum::PLACE_HAMLET,  baseDir + "place/hamlet.svg");

        m_initialized = true;
    }

    const QPixmap *icon(int tagType) const {
        auto it = m_cache.find(tagType);
        return it != m_cache.end() ? &it.value() : nullptr;
    }

    const QPixmap &defaultIcon() const { return m_defaultIcon; }

    bool isInitialized() const { return m_initialized; }

private:
    void registerIcon(int tagType, const QString &fullPath) {
        QSvgRenderer renderer(fullPath);
        if (renderer.isValid()) {
            QPixmap pm(ICON_SIZE, ICON_SIZE);
            pm.fill(Qt::transparent);
            QPainter p(&pm);
            renderer.render(&p, QRectF(0, 0, ICON_SIZE, ICON_SIZE));
            p.end();
            m_cache.insert(tagType, std::move(pm));
        }
    }

    QHash<int, QPixmap> m_cache;
    QPixmap m_defaultIcon;
    bool m_initialized = false;
};

// Global singleton POI icon cache
static PoiIconCache &poiIconCache() {
    static PoiIconCache cache;
    if (!cache.isInitialized()) {
        cache.init();
    }
    return cache;
}

static const int MIN_ZOOM_PIXELS_PER_DEG = 20;
static const int MAX_ZOOM_PIXELS_PER_DEG = 200000;
static const int HOVER_TEST_RADIUS_PX = 6;
static const int MAX_TYPE_COUNT = 256;
static const int TILE_SIZE = 512;
static const int MAX_CACHED_TILES = 64;

struct QuickStyle {
    bool valid;
    QColor fillColor;
    QColor fillOutline;
    QColor lineColor;
    QColor lineOutline;
    double lineWidth;
    double outlineWidth;
    bool dot;
    bool isArea;
    int lodMin;
    int lodMax;
    int drawOrder;
    qreal fillOpacity;
    qreal lineOpacity;
    int zIndex;
    float majorZIndex;
    double distThreshold;  // Show when getDist100Pixel <= threshold
};

static inline bool isRoadType(int type) {
    return type >= TagEnum::HIGHWAY_MOTORWAY && type <= TagEnum::HIGHWAY_LIVING_STREET;
}
static inline bool isRailwayType(int type) {
    return type >= TagEnum::RAILWAY && type <= TagEnum::RAILWAY_DISUSED;
}
static inline bool isWaterType(int type) {
    return (type >= TagEnum::WATERWAY && type <= TagEnum::WATERWAY_DRAIN) || type == TagEnum::NATURAL_WATER;
}
static inline bool isGreenType(int type) {
    return type == TagEnum::NATURAL_WOOD || type == TagEnum::NATURAL_GRASSLAND ||
           type == TagEnum::LEISURE_PARK || type == TagEnum::LANDUSE_FOREST ||
           type == TagEnum::LANDUSE_GRASS;
}
static inline bool isBuildingType(int type) {
    return type == TagEnum::BUILDING;
}
static inline bool isLanduseType(int type) {
    return (type >= TagEnum::LANDUSE_RESIDENTIAL && type <= TagEnum::LANDUSE_AIRPORT) ||
           type == TagEnum::LANDUSE_NATURE_RESERVE;
}

struct ThreadRenderData {
    const OsmModel *model;
    const OsmStyle *style;
    QVector<QuickStyle> quickStyle;
    QList<LineStyle> sortedLineStyles;
    QList<int> fillTypesByOrder;
    QVector<QList<const OsmDrawEntry*>> lineEntriesByType;
    QList<const OsmDrawEntry*> fillEntries;
    QList<const OsmDrawEntry*> pointEntries;
};

static QVector<QuickStyle> buildQuickStyleLookup(const OsmStyle *style) {
    QVector<QuickStyle> lookup(MAX_TYPE_COUNT);
    for (auto &s : lookup) {
        s.valid = false;
        s.fillOpacity = 1.0;
        s.lineOpacity = 1.0;
        s.zIndex = 0;
        s.majorZIndex = 0.0f;
        s.distThreshold = 1e9;
    }

    for (const FillStyle &fs : style->fillStyles()) {
        if (fs.type < 0 || fs.type >= MAX_TYPE_COUNT) continue;
        QuickStyle &qs = lookup[fs.type];
        qs.valid = true;
        qs.fillColor = fs.color;
        qs.fillColor.setAlpha(qRound(fs.opacity * 255));
        qs.fillOutline = fs.color.darker(118);
        qs.fillOutline.setAlpha(qRound(fs.opacity * 255));
        qs.isArea = true;
        qs.lodMin = fs.lodMin;
        qs.lodMax = fs.lodMax;
        qs.drawOrder = -1;
        qs.fillOpacity = fs.opacity;
        qs.zIndex = fs.zIndex;
        qs.majorZIndex = fs.majorZIndex;
        qs.distThreshold = fs.distThreshold;
    }

    for (const LineStyle &ls : style->lineStyles()) {
        if (ls.type < 0 || ls.type >= MAX_TYPE_COUNT) continue;
        if (ls.lineType != LineType::NORMAL) continue;
        QuickStyle &qs = lookup[ls.type];
        qs.valid = true;
        qs.lineColor = ls.color;
        qs.lineColor.setAlpha(qRound(ls.opacity * 255));
        qs.lineOutline = QColor();
        qs.lineWidth = ls.widthPx;
        qs.outlineWidth = 0;
        qs.dot = ls.dot;
        qs.isArea = false;
        qs.lodMin = ls.lodMin;
        qs.lodMax = ls.lodMax;
        qs.drawOrder = ls.drawOrder;
        qs.lineOpacity = ls.opacity;
        qs.zIndex = 0;
        qs.majorZIndex = ls.majorZIndex;
        qs.distThreshold = ls.distThreshold;
    }

    return lookup;
}

static ThreadRenderData prepareThreadData(const OsmModel *model, const OsmStyle *style) {
    ThreadRenderData data;
    data.model = model;
    data.style = style;
    data.quickStyle = buildQuickStyleLookup(style);
    data.sortedLineStyles = style->lineStyles();

    data.lineEntriesByType.resize(MAX_TYPE_COUNT);
    data.fillEntries.reserve(model->fillDrawList().size());
    data.pointEntries.reserve(model->pointDrawList().size());

    for (const OsmDrawEntry &entry : model->fillDrawList()) {
        data.fillEntries.append(&entry);
    }
    std::sort(data.fillEntries.begin(), data.fillEntries.end(),
              [&data](const OsmDrawEntry *a, const OsmDrawEntry *b) {
                  if (a->tagType >= 0 && a->tagType < MAX_TYPE_COUNT &&
                      b->tagType >= 0 && b->tagType < MAX_TYPE_COUNT) {
                      // Sort: majorZIndex first, then zIndex
                      float majA = data.quickStyle[a->tagType].majorZIndex;
                      float majB = data.quickStyle[b->tagType].majorZIndex;
                      if (majA != majB) return majA < majB;
                      return data.quickStyle[a->tagType].zIndex < data.quickStyle[b->tagType].zIndex;
                  }
                  return a->tagType < b->tagType;
              });
    for (const OsmDrawEntry &entry : model->lineDrawList()) {
        if (entry.tagType >= 0 && entry.tagType < MAX_TYPE_COUNT) {
            data.lineEntriesByType[entry.tagType].append(&entry);
        }
    }
    for (const OsmDrawEntry &entry : model->pointDrawList()) {
        data.pointEntries.append(&entry);
    }

    return data;
}

// Road direction arrow drawing helper - standard triangle arrow
static void drawDirectionArrow(QPainter &painter, const QPolygonF &poly, double arrowSize) {
    if (poly.size() < 2) return;

    QPointF p1 = poly[poly.size() - 2];
    QPointF p2 = poly[poly.size() - 1];

    double dx = p2.x() - p1.x();
    double dy = p2.y() - p1.y();
    double len = std::sqrt(dx * dx + dy * dy);

    if (len < 1.0) return;

    // Unit direction vector
    double nx = dx / len;
    double ny = dy / len;

    // Screen coordinate system Y-axis points downward, correct normal vector: rotate 90 degrees CCW for (-ny, nx), CW for (ny, -nx)
    // Arrow tip is at the endpoint position, no extension beyond
    QPointF arrowTip = p2;
    // Arrow base retreats by arrowSize length
    QPointF arrowBase(p2.x() - nx * arrowSize, p2.y() - ny * arrowSize);

    // Arrow half width
    double halfWidth = arrowSize * 0.35;
    QPointF arrowLeft(arrowBase.x() - ny * halfWidth, arrowBase.y() + nx * halfWidth);
    QPointF arrowRight(arrowBase.x() + ny * halfWidth, arrowBase.y() - nx * halfWidth);

    QPolygonF arrowPoly;
    arrowPoly << arrowTip << arrowLeft << arrowRight;
    painter.drawPolygon(arrowPoly);
}

// One-way arrow drawing (draw small arrows along the road at regular intervals)
static void drawOnewayArrows(QPainter &painter, const QPolygonF &poly, double interval, double arrowSize) {
    if (poly.size() < 2) return;

    double accumulatedLen = 0;
    for (int i = 0; i < poly.size() - 1; ++i) {
        QPointF p1 = poly[i];
        QPointF p2 = poly[i + 1];
        double dx = p2.x() - p1.x();
        double dy = p2.y() - p1.y();
        double segLen = std::sqrt(dx * dx + dy * dy);

        if (segLen < 1.0) continue;

        double nx = dx / segLen;
        double ny = dy / segLen;

        double offset = accumulatedLen;
        while (offset + arrowSize * 2 < segLen) {
            double pos = offset + arrowSize;
            QPointF arrowTip(p1.x() + nx * pos, p1.y() + ny * pos);
            QPointF arrowBase(arrowTip.x() - nx * arrowSize, arrowTip.y() - ny * arrowSize);

            double halfWidth = arrowSize * 0.35;
            QPointF arrowLeft(arrowBase.x() - ny * halfWidth, arrowBase.y() + nx * halfWidth);
            QPointF arrowRight(arrowBase.x() + ny * halfWidth, arrowBase.y() - nx * halfWidth);

            QPolygonF arrowPoly;
            arrowPoly << arrowTip << arrowLeft << arrowRight;
            painter.drawPolygon(arrowPoly);

            offset += interval;
        }
        accumulatedLen += segLen;
    }
}

// Road offset line drawing - compute the offset polygon
static QPolygonF offsetPolyline(const QPolygonF &poly, double offset) {
    if (poly.size() < 2 || qFuzzyIsNull(offset)) return poly;

    QPolygonF result;
    result.reserve(poly.size());

    for (int i = 0; i < poly.size() - 1; ++i) {
        QPointF p1 = poly[i];
        QPointF p2 = poly[i + 1];

        double dx = p2.x() - p1.x();
        double dy = p2.y() - p1.y();
        double len = std::sqrt(dx * dx + dy * dy);

        if (len < 0.001) continue;

        double nx = dx / len;
        double ny = dy / len;

        double perpX = -ny * offset;
        double perpY = nx * offset;

        if (i == 0) {
            result.append(QPointF(p1.x() + perpX, p1.y() + perpY));
        }

        if (i < poly.size() - 2) {
            QPointF p3 = poly[i + 2];
            double dx2 = p3.x() - p2.x();
            double dy2 = p3.y() - p2.y();
            double len2 = std::sqrt(dx2 * dx2 + dy2 * dy2);

            if (len2 > 0.001) {
                double nx2 = dx2 / len2;
                double ny2 = dy2 / len2;

                double perpX2 = -ny2 * offset;
                double perpY2 = nx2 * offset;

                double cross = nx * ny2 - ny * nx2;
                if (std::fabs(cross) > 0.001) {
                    double t = ((perpX2 - perpX) * ny - (perpY2 - perpY) * nx) / cross;
                    result.append(QPointF(p2.x() + perpX2 + nx2 * t, p2.y() + perpY2 + ny2 * t));
                } else {
                    result.append(QPointF(p2.x() + (perpX + perpX2) * 0.5, p2.y() + (perpY + perpY2) * 0.5));
                }
            }
        } else {
            result.append(QPointF(p2.x() + perpX, p2.y() + perpY));
        }
    }

    return result;
}

// Standard road drawing function
static double calcLineWidthPx(const LineStyle &ds, double ppd) {
    double wPx;
    double metersPerDegree = 111320.0;
    double pixelsPerMeter = ppd / metersPerDegree;

    if (ds.realWidth > 0) {
        double realWidthPx = ds.realWidth * pixelsPerMeter;
        double minWidthByType;
        using namespace TagEnum;
        if (ds.type <= HIGHWAY_TRUNK) {
            minWidthByType = 0.6;
        } else if (ds.type <= HIGHWAY_SECONDARY) {
            minWidthByType = 0.45;
        } else if (ds.type <= HIGHWAY_TERTIARY) {
            minWidthByType = 0.35;
        } else if (ds.type <= HIGHWAY_UNCLASSIFIED) {
            minWidthByType = 0.25;
        } else {
            minWidthByType = 0.15;
        }
        if (!isRoadType(ds.type)) {
            minWidthByType = 0.1;
        }
        if (ds.lineType == LineType::CASING) {
            minWidthByType += 0.2;
        }
        wPx = qMax(minWidthByType, realWidthPx);
    } else {
        double baseWidthPx = ds.widthPx * (ppd / 5000.0);
        wPx = qMax(0.1, baseWidthPx);
    }

    return qMax(0.1, wPx);
}

static void drawWayStyled(QPainter &painter, const QPolygonF &poly, const LineStyle &ds, double scale, double ppd, bool fastMode) {
    if (poly.size() < 2) return;

    double wPx = calcLineWidthPx(ds, ppd);

    QPolygonF drawPoly = poly;
    if (ds.offset != 0) {
        double offsetPx = ds.offset * (ppd / 5000.0);
        drawPoly = offsetPolyline(poly, offsetPx);
    }

    if (ds.dashBackgroundColor.isValid() && !fastMode) {
        QPen bgPen(ds.dashBackgroundColor, wPx + 2*scale, Qt::SolidLine, Qt::FlatCap, Qt::MiterJoin);
        painter.setPen(bgPen);
        painter.setBrush(Qt::NoBrush);
        painter.drawPolyline(drawPoly);
    }

    QPen linePen(ds.color, wPx, Qt::SolidLine, Qt::FlatCap, Qt::MiterJoin);
    linePen.setMiterLimit(2.0);
    if (!ds.dashArray.isEmpty()) {
        linePen.setDashPattern(ds.dashArray);
    }
    painter.setPen(linePen);
    painter.setBrush(Qt::NoBrush);
    painter.drawPolyline(drawPoly);

    // Only draw arrows on the main layer (NORMAL), not on the outline layer (CASING), to avoid overlapping misalignment
    if (ds.lineType == LineType::NORMAL) {
        // Arrow uses fully opaque rendering to ensure visibility
        painter.setOpacity(1.0);

        // Determine arrow size factor and spacing based on road class
        qreal sizeFactor;
        qreal spacingFactor;
        using namespace TagEnum;
        if (ds.type <= HIGHWAY_TRUNK) {
            // Highways, trunk roads: slightly larger arrows
            sizeFactor = 1.2;
            spacingFactor = 250.0;
        } else if (ds.type <= HIGHWAY_TERTIARY) {
            // Primary, secondary, tertiary roads: medium
            sizeFactor = 1.0;
            spacingFactor = 220.0;
        } else if (ds.type <= HIGHWAY_UNCLASSIFIED) {
            // Residential, unclassified: smaller
            sizeFactor = 0.8;
            spacingFactor = 200.0;
        } else {
            // Minor roads, paths, service roads, etc.: smallest, one-way arrows may also be hidden
            sizeFactor = 0.6;
            spacingFactor = 180.0;
        }

        if (ds.showDirectionArrow && !fastMode) {
            double arrowSize = qMax(3.0, wPx * 1.1 * sizeFactor);
            if (drawPoly.size() >= 2) {
                QPointF p1 = drawPoly[drawPoly.size() - 2];
                QPointF p2 = drawPoly[drawPoly.size() - 1];
                double dx = p2.x() - p1.x();
                double dy = p2.y() - p1.y();
                double len = std::sqrt(dx * dx + dy * dy);
                if (len >= arrowSize * 0.8) {
                    QColor arrowFill(Qt::red);
                    painter.setPen(Qt::NoPen);
                    painter.setBrush(arrowFill);
                    drawDirectionArrow(painter, drawPoly, arrowSize);
                }
            }
        }

        if (ds.showOnewayArrow && !fastMode) {
            double arrowSize = qMax(2.0, wPx * 0.7 * sizeFactor);
            QColor arrowFill(Qt::red);
            painter.setPen(Qt::NoPen);
            painter.setBrush(arrowFill);
            drawOnewayArrows(painter, drawPoly, qMax(spacingFactor, wPx * 40), arrowSize);
        }
    }
}

static QPolygonF buildWayPolyFast(const OsmWay &way, const QVector<OsmNode> &nodes,
                                  double ppdX, double ppdY, double ox, double oy,
                                  const QRect &tileRect, int margin)
{
    QPolygonF poly;
    poly.reserve(way.nodeIndices().size());
    bool anyVisible = false;
    QRectF testRect = tileRect.adjusted(-margin, -margin, margin, margin);

    for (int nodeIdx : way.nodeIndices()) {
        if (nodeIdx < 0 || nodeIdx >= nodes.size()) continue;
        const OsmNode &n = nodes[nodeIdx];
        QPointF pt(n.lon() * ppdX + ox, -n.lat() * ppdY + oy);
        poly.append(pt);
        if (testRect.contains(pt)) anyVisible = true;
    }
    return anyVisible ? poly : QPolygonF();
}

static QPolygonF buildWayPolyFull(const OsmWay &way, const QVector<OsmNode> &nodes,
                                  double ppdX, double ppdY, double ox, double oy)
{
    QPolygonF poly;
    poly.reserve(way.nodeIndices().size());
    for (int nodeIdx : way.nodeIndices()) {
        if (nodeIdx < 0 || nodeIdx >= nodes.size()) continue;
        const OsmNode &n = nodes[nodeIdx];
        poly.append(QPointF(n.lon() * ppdX + ox, -n.lat() * ppdY + oy));
    }
    return poly;
}

// Calculate the geographic distance (meters) corresponding to 100 pixels on screen
static double getDist100Pixel(double ppd, double centerLat) {
    double dist1Deg = 111319.49;
    double cosLat = qCos(centerLat * M_PI / 180.0);
    double dist1Pixel = dist1Deg * cosLat / ppd;
    return dist1Pixel * 100.0;
}

// Calculate opacity based on majorZIndex; higher layers are more transparent
// Lowest layer is opaque, highest layer (z=6) has 80% transparency (20% opacity)
static qreal calcLayerOpacity(float majorZ, qreal baseOpacity) {
    const float maxZ = 6.0f;
    const qreal minOpacityFactor = 0.2;
    qreal factor = 1.0 - (majorZ / maxZ) * (1.0 - minOpacityFactor);
    return baseOpacity * factor;
}

static QImage renderTile(const ThreadRenderData &data, const RenderViewState &state,
                         int tileX, int tileY, bool fastMode)
{
    QImage img(TILE_SIZE, TILE_SIZE, QImage::Format_ARGB32_Premultiplied);
    img.fill(QColor(242, 239, 233));  // Beige background #f2efe9

    QPainter painter(&img);
    painter.setRenderHint(QPainter::Antialiasing, !fastMode);
    painter.translate(-tileX * TILE_SIZE, -tileY * TILE_SIZE);

    double ppd = state.baseScale * state.scale;
    double ox = state.dataOrigin.x() + state.offset.x();
    double oy = state.dataOrigin.y() + state.offset.y();

    QRect tileRectScreen(tileX * TILE_SIZE, tileY * TILE_SIZE, TILE_SIZE, TILE_SIZE);
    double marginGeo = 0.02;

    QRectF tileGeoBBox(
        (tileRectScreen.left() - ox) / ppd - marginGeo,
        -(tileRectScreen.bottom() - oy) / ppd - marginGeo,
        (tileRectScreen.width()) / ppd + marginGeo * 2,
        (tileRectScreen.height()) / ppd + marginGeo * 2
    );

    const QVector<QuickStyle> &qs = data.quickStyle;
    const QVector<OsmWay> &ways = data.model->ways();
    const QVector<OsmNode> &nodes = data.model->nodes();

    double centerLat = tileGeoBBox.center().y();
    double dist100Pixel = getDist100Pixel(ppd, centerLat);

    double ppdX = ppd;
    double ppdY = ppd;

    for (const OsmDrawEntry *entry : data.fillEntries) {
        int type = entry->tagType;
        if (type < 0 || type >= MAX_TYPE_COUNT) continue;
        if (!qs[type].valid) continue;

        if (dist100Pixel > qs[type].distThreshold) continue;

        if (isBuildingType(type) && !state.showBuildings) continue;
        if (isWaterType(type) && !state.showWater) continue;
        if (isGreenType(type) && !state.showGreen) continue;
        if (isLanduseType(type) && !state.showLanduse) continue;
        if (isRoadType(type) && !state.showRoads) continue;
        if (isRailwayType(type) && !state.showRailway) continue;
        if (!isBuildingType(type) && !isWaterType(type) && !isGreenType(type) && !isLanduseType(type) && !isRoadType(type) && !isRailwayType(type)) continue;

        const OsmWay &way = ways[entry->wayIndex];
        if (!way.bbox().isValid()) continue;
        if (!way.bbox().intersects(tileGeoBBox)) continue;

        QPolygonF poly = buildWayPolyFast(way, nodes, ppdX, ppdY, ox, oy, tileRectScreen, 2);
        if (poly.size() < 3) continue;

        qreal layerOpacity = calcLayerOpacity(qs[type].majorZIndex, qs[type].fillOpacity);
        painter.setOpacity(layerOpacity);
        QBrush brush(qs[type].fillColor);
        QPen pen(qs[type].fillOutline, fastMode ? 0.1 : 0.2);
        painter.setBrush(brush);
        painter.setPen(pen);
        painter.drawPolygon(poly);
        painter.setOpacity(1.0);
    }

    for (const LineStyle &ds : data.sortedLineStyles) {
        if (dist100Pixel > ds.distThreshold) continue;
        if (isRoadType(ds.type) && !state.showRoads) continue;
        if (isBuildingType(ds.type) && !state.showBuildings) continue;
        if (isWaterType(ds.type) && !state.showWater) continue;
        if (isGreenType(ds.type) && !state.showGreen) continue;
        if (isRailwayType(ds.type) && !state.showRailway) continue;
        if (isLanduseType(ds.type) && !state.showLanduse) continue;
        if (!isRoadType(ds.type) && !isBuildingType(ds.type) && !isWaterType(ds.type) && !isGreenType(ds.type) && !isRailwayType(ds.type) && !isLanduseType(ds.type)) continue;
        if (ds.type < 0 || ds.type >= MAX_TYPE_COUNT) continue;

        int entryCount = data.lineEntriesByType[ds.type].size();
        if (entryCount > 0) {
            qDebug() << "renderFull line: type=" << ds.type << "entries=" << entryCount;
        }

        qreal layerOpacity = calcLayerOpacity(ds.majorZIndex, ds.opacity);
        painter.setOpacity(layerOpacity);

        for (const OsmDrawEntry *entry : data.lineEntriesByType[ds.type]) {
            const OsmWay &way = ways[entry->wayIndex];
            if (!way.bbox().isValid()) continue;
            if (!way.bbox().intersects(tileGeoBBox)) continue;

            QPolygonF poly = buildWayPolyFast(way, nodes, ppdX, ppdY, ox, oy, tileRectScreen, 4);
            if (poly.size() < 2) continue;

            drawWayStyled(painter, poly, ds, state.scale, ppd, fastMode);
        }

        painter.setOpacity(1.0);
    }

    // Render POI nodes (pointDrawList) -- using SVG icons, with collision detection to avoid overcrowding
    if (state.showPoi) {
        const PoiIconCache &icons = poiIconCache();
        const int halfIcon = PoiIconCache::ICON_SIZE / 2;

        // POI collision detection: collect candidate POIs within screen range, sort by priority, then filter
        // Priority determined by lodMin (lower value = more important), same priority distinguished by type
        const int MIN_POI_SPACING = 18;  // Minimum pixel spacing (slightly larger than icon size 16)
        struct PoiCandidate {
            double sx, sy;
            int type;
            int lodMin;
            const OsmDrawEntry *entry;
            bool operator<(const PoiCandidate &o) const {
                if (lodMin != o.lodMin) return lodMin < o.lodMin;  // Important POIs first
                return type < o.type;
            }
        };
        QVector<PoiCandidate> candidates;
        candidates.reserve(data.pointEntries.size());

        for (const OsmDrawEntry *entry : data.pointEntries) {
            int type = entry->tagType;
            if (type < 0 || type >= MAX_TYPE_COUNT) continue;
            if (state.lod < entry->lodMin || state.lod > entry->lodMax) continue;
            if (!entry->bbox.isValid()) continue;

            const OsmNode &node = nodes[entry->nodeIndex];
            double sx = node.lon() * ppd + ox;
            double sy = -node.lat() * ppd + oy;

            if (sx < tileRectScreen.left() - 10 || sx > tileRectScreen.right() + 10 ||
                sy < tileRectScreen.top() - 10 || sy > tileRectScreen.bottom() + 10) continue;

            candidates.append({sx, sy, type, entry->lodMin, entry});
        }

        // Sort by priority (important ones first)
        std::sort(candidates.begin(), candidates.end());

        // Collision detection: use grid to accelerate spatial queries
        const int gridCell = MIN_POI_SPACING;
        QHash<QPair<int,int>, int> occupied;  // grid -> index in candidates

        int poiVisible = 0;
        for (int ci = 0; ci < candidates.size(); ++ci) {
            const PoiCandidate &c = candidates[ci];
            int gx = (int)(c.sx / gridCell);
            int gy = (int)(c.sy / gridCell);

            // Check surrounding 3x3 grid for already occupied POIs
            bool tooClose = false;
            for (int dx = -1; dx <= 1 && !tooClose; ++dx) {
                for (int dy = -1; dy <= 1 && !tooClose; ++dy) {
                    auto it = occupied.constFind({gx+dx, gy+dy});
                    while (it != occupied.constEnd()) {
                        const PoiCandidate &existing = candidates[it.value()];
                        double ddx = c.sx - existing.sx;
                        double ddy = c.sy - existing.sy;
                        if (ddx*ddx + ddy*ddy < (double)MIN_POI_SPACING * MIN_POI_SPACING) {
                            tooClose = true;
                            break;
                        }
                        ++it;
                    }
                }
            }

            if (!tooClose) {
                const QPixmap *icon = icons.icon(c.type);
                if (icon) {
                    painter.drawPixmap(QPointF(c.sx - halfIcon, c.sy - halfIcon), *icon);
                } else {
                    painter.setPen(Qt::NoPen);
                    painter.setBrush(QColor(255, 100, 100));
                    painter.drawEllipse(QPointF(c.sx, c.sy), 3, 3);
                }
                occupied.insert({gx, gy}, ci);
                poiVisible++;
            }
        }
    } // end showPoi

    // Render all raw nodes (only show at high zoom, avoid visual clutter at low zoom)
    if (state.showNodes && state.lod >= LOD::LOD_BUILDING) {
        QPen nodePen(QColor(255, 100, 100), 2);
        QBrush nodeBrush(QColor(255, 100, 100));
        painter.setPen(nodePen);
        painter.setBrush(nodeBrush);
        for (const OsmNode &n : nodes) {
            double screenX = n.lon() * ppd + ox;
            double screenY = -n.lat() * ppd + oy;
            if (screenX >= tileRectScreen.left() && screenX <= tileRectScreen.right() &&
                screenY >= tileRectScreen.top() && screenY <= tileRectScreen.bottom()) {
                painter.drawEllipse(QPointF(screenX, screenY), 3, 3);
            }
        }
    }

    painter.end();
    return img;
}

static QImage renderFull(const ThreadRenderData &data, const RenderViewState &state, bool fastMode, bool fillBackground = true)
{
    QImage img(state.width, state.height, QImage::Format_ARGB32_Premultiplied);
    if (fillBackground) {
        img.fill(QColor(242, 239, 233));  // Beige background #f2efe9
    } else {
        img.fill(Qt::transparent);
    }

    QPainter painter(&img);
    painter.setRenderHint(QPainter::Antialiasing, !fastMode);

    double ppd = state.baseScale * state.scale;
    double ox = state.dataOrigin.x() + state.offset.x();
    double oy = state.dataOrigin.y() + state.offset.y();

    const QVector<QuickStyle> &qs = data.quickStyle;
    const QVector<OsmWay> &ways = data.model->ways();
    const QVector<OsmNode> &nodes = data.model->nodes();
    QRectF viewBBox = state.viewBBox.adjusted(-0.01, -0.01, 0.01, 0.01);

    qDebug() << "renderFull: fillEntries=" << data.fillEntries.size()
             << "viewBBox=" << viewBBox;

    double centerLat = viewBBox.center().y();
    double dist100Pixel = getDist100Pixel(ppd, centerLat);

    double ppdX = ppd;
    double ppdY = ppd;

    for (const OsmDrawEntry *entry : data.fillEntries) {
        int type = entry->tagType;
        if (type < 0 || type >= MAX_TYPE_COUNT) continue;
        if (!qs[type].valid) continue;

        if (dist100Pixel > qs[type].distThreshold) continue;

        if (isBuildingType(type) && !state.showBuildings) continue;
        if (isWaterType(type) && !state.showWater) continue;
        if (isGreenType(type) && !state.showGreen) continue;
        if (isLanduseType(type) && !state.showLanduse) continue;
        if (isRoadType(type) && !state.showRoads) continue;
        if (isRailwayType(type) && !state.showRailway) continue;
        if (!isBuildingType(type) && !isWaterType(type) && !isGreenType(type) && !isLanduseType(type) && !isRoadType(type) && !isRailwayType(type)) continue;

        const OsmWay &way = ways[entry->wayIndex];
        if (!way.bbox().isValid()) continue;
        if (!way.bbox().intersects(viewBBox)) continue;

        QPolygonF poly = buildWayPolyFull(way, nodes, ppdX, ppdY, ox, oy);
        if (poly.size() < 3) continue;

        qreal layerOpacity = calcLayerOpacity(qs[type].majorZIndex, qs[type].fillOpacity);
        painter.setOpacity(layerOpacity);
        QBrush brush(qs[type].fillColor);
        QPen pen(qs[type].fillOutline, fastMode ? 0.1 : 0.2);
        painter.setBrush(brush);
        painter.setPen(pen);
        painter.drawPolygon(poly);
        painter.setOpacity(1.0);
    }

    for (const LineStyle &ds : data.sortedLineStyles) {
        if (dist100Pixel > ds.distThreshold) continue;
        if (isRoadType(ds.type) && !state.showRoads) continue;
        if (isBuildingType(ds.type) && !state.showBuildings) continue;
        if (isWaterType(ds.type) && !state.showWater) continue;
        if (isGreenType(ds.type) && !state.showGreen) continue;
        if (isRailwayType(ds.type) && !state.showRailway) continue;
        if (isLanduseType(ds.type) && !state.showLanduse) continue;
        if (!isRoadType(ds.type) && !isBuildingType(ds.type) && !isWaterType(ds.type) && !isGreenType(ds.type) && !isRailwayType(ds.type) && !isLanduseType(ds.type)) continue;
        if (ds.type < 0 || ds.type >= MAX_TYPE_COUNT) continue;

        int entryCount = data.lineEntriesByType[ds.type].size();
        if (entryCount > 0) {
            qDebug() << "renderFull line: type=" << ds.type << "entries=" << entryCount;
        }

        qreal layerOpacity = calcLayerOpacity(ds.majorZIndex, ds.opacity);
        painter.setOpacity(layerOpacity);

        for (const OsmDrawEntry *entry : data.lineEntriesByType[ds.type]) {
            const OsmWay &way = ways[entry->wayIndex];
            if (!way.bbox().isValid()) continue;
            if (!way.bbox().intersects(viewBBox)) continue;

            QPolygonF poly = buildWayPolyFull(way, nodes, ppdX, ppdY, ox, oy);
            if (poly.size() < 2) continue;

            drawWayStyled(painter, poly, ds, state.scale, ppd, fastMode);
        }

        painter.setOpacity(1.0);
    }

    // Render POI nodes (pointDrawList) -- using SVG icons, with collision detection to avoid overcrowding
    if (state.showPoi) {
        const PoiIconCache &icons = poiIconCache();
        const int halfIcon = PoiIconCache::ICON_SIZE / 2;

        const int MIN_POI_SPACING = 18;
        struct PoiCandidate {
            double sx, sy;
            int type;
            int lodMin;
            const OsmDrawEntry *entry;
            bool operator<(const PoiCandidate &o) const {
                if (lodMin != o.lodMin) return lodMin < o.lodMin;
                return type < o.type;
            }
        };
        QVector<PoiCandidate> candidates;
        candidates.reserve(data.pointEntries.size());

        for (const OsmDrawEntry *entry : data.pointEntries) {
            int type = entry->tagType;
            if (type < 0 || type >= MAX_TYPE_COUNT) continue;
            if (state.lod < entry->lodMin || state.lod > entry->lodMax) continue;
            if (!entry->bbox.isValid()) continue;

            const OsmNode &node = nodes[entry->nodeIndex];
            double sx = node.lon() * ppd + ox;
            double sy = -node.lat() * ppd + oy;

            if (sx < -10 || sx > state.width + 10 ||
                sy < -10 || sy > state.height + 10) continue;

            candidates.append({sx, sy, type, entry->lodMin, entry});
        }

        std::sort(candidates.begin(), candidates.end());

        const int gridCell = MIN_POI_SPACING;
        QHash<QPair<int,int>, int> occupied;

        int poiVisible = 0;
        for (int ci = 0; ci < candidates.size(); ++ci) {
            const PoiCandidate &c = candidates[ci];
            int gx = (int)(c.sx / gridCell);
            int gy = (int)(c.sy / gridCell);

            bool tooClose = false;
            for (int dx = -1; dx <= 1 && !tooClose; ++dx) {
                for (int dy = -1; dy <= 1 && !tooClose; ++dy) {
                    auto it = occupied.constFind({gx+dx, gy+dy});
                    while (it != occupied.constEnd()) {
                        const PoiCandidate &existing = candidates[it.value()];
                        double ddx = c.sx - existing.sx;
                        double ddy = c.sy - existing.sy;
                        if (ddx*ddx + ddy*ddy < (double)MIN_POI_SPACING * MIN_POI_SPACING) {
                            tooClose = true;
                            break;
                        }
                        ++it;
                    }
                }
            }

            if (!tooClose) {
                const QPixmap *icon = icons.icon(c.type);
                if (icon) {
                    painter.drawPixmap(QPointF(c.sx - halfIcon, c.sy - halfIcon), *icon);
                } else {
                    painter.setPen(Qt::NoPen);
                    painter.setBrush(QColor(255, 100, 100));
                    painter.drawEllipse(QPointF(c.sx, c.sy), 3, 3);
                }
                occupied.insert({gx, gy}, ci);
                poiVisible++;
            }
        }
    } // end showPoi

    // Render all raw nodes (only show at high zoom, avoid visual clutter at low zoom)
    if (state.showNodes && state.lod >= LOD::LOD_BUILDING) {
        QPen nodePen(QColor(255, 100, 100), 2);
        QBrush nodeBrush(QColor(255, 100, 100));
        painter.setPen(nodePen);
        painter.setBrush(nodeBrush);
        for (const OsmNode &n : nodes) {
            double screenX = n.lon() * ppd + ox;
            double screenY = -n.lat() * ppd + oy;
            if (screenX >= 0 && screenX <= state.width && screenY >= 0 && screenY <= state.height) {
                painter.drawEllipse(QPointF(screenX, screenY), 3, 3);
            }
        }
    }

    painter.end();
    return img;
}

class RenderTileTask : public QRunnable {
public:
    ThreadRenderData data;
    RenderViewState state;
    TileCacheKey key;
    OsmMapWidget *widget;
    qint64 generation;
    QImage result;

    RenderTileTask(const ThreadRenderData &d, const RenderViewState &s,
                   const TileCacheKey &k, OsmMapWidget *w, qint64 gen)
        : data(d), state(s), key(k), widget(w), generation(gen) {
        setAutoDelete(true);
    }

    void run() override {
        result = renderTile(data, state, key.tileX, key.tileY, false);
        QMetaObject::invokeMethod(widget, "onTileRendered", Qt::QueuedConnection,
                                  Q_ARG(TileCacheKey, key), Q_ARG(QImage, result),
                                  Q_ARG(qint64, generation));
    }
};

OsmMapWidget::OsmMapWidget(QWidget *parent)
    : QWidget(parent)
{
    setMouseTracking(true);
    setFocusPolicy(Qt::StrongFocus);
    setMinimumSize(400, 300);
    int idealThreads = QThread::idealThreadCount();
    m_renderPool.setMaxThreadCount(qMax(2, qMin(idealThreads, 8)));

    qRegisterMetaType<TileCacheKey>("TileCacheKey");
}

OsmMapWidget::~OsmMapWidget()
{
    m_renderGeneration.fetch_add(1);
    m_renderPool.waitForDone();
    m_renderPool.clear();
}

void OsmMapWidget::setModel(OsmModel *model, OsmStyle *style)
{
    m_renderGeneration.fetch_add(1);
    m_renderPool.waitForDone();

    m_model = model;
    m_style = style;
    m_layers.clear();
    m_hoveredWay = -1;
    m_selectedWay = -1;
    m_arcCache.clear();
    m_fastBufferValid = false;

    if (m_style) {
        m_sortedLineStyles = m_style->lineStyles();
    }

    update();
}

void OsmMapWidget::addLayer(OsmModel *model, const QString &name, const OsmStyle *baseStyle)
{
    m_renderGeneration.fetch_add(1);
    m_renderPool.waitForDone();

    MapLayer layer(model, name);
    if (baseStyle) {
        layer.style = *baseStyle;
    } else if (m_style) {
        layer.style = *m_style;
    }
    m_layers.append(std::move(layer));
    m_arcCache.clear();
    m_fastBufferValid = false;

    if (!m_layers.empty()) {
        fitToData();
    }
}

bool OsmMapWidget::hasAnyData() const
{
    if (m_model && !m_model->isEmpty())
        return true;
    for (const auto &layer : m_layers) {
        if (layer.model && !layer.model->isEmpty())
            return true;
    }
    return false;
}

void OsmMapWidget::clearLayers()
{
    m_renderGeneration.fetch_add(1);
    m_renderPool.waitForDone();

    for (auto &layer : m_layers) {
        delete layer.model;
        layer.model = nullptr;
    }
    m_layers.clear();
    m_arcCache.clear();
    m_fastBufferValid = false;
    update();
}

void OsmMapWidget::setLayerVisible(int index, bool visible)
{
    if (index >= 0 && index < m_layers.size()) {
        m_layers[index].visible = visible;
        invalidateTiles();
        scheduleRepaint();
    }
}

void OsmMapWidget::fitToData()
{
    bool hasData = false;
    double lonMin = 180.0, lonMax = -180.0;
    double latMin = 90.0, latMax = -90.0;

    if (m_model && !m_model->isEmpty()) {
        const OsmBounds &info = m_model->bounds();
        lonMin = qMin(lonMin, info.lonMin);
        lonMax = qMax(lonMax, info.lonMax);
        latMin = qMin(latMin, info.latMin);
        latMax = qMax(latMax, info.latMax);
        hasData = true;
    }

    for (const auto &layer : m_layers) {
        if (layer.model && !layer.model->isEmpty()) {
            const OsmBounds &info = layer.model->bounds();
            lonMin = qMin(lonMin, info.lonMin);
            lonMax = qMax(lonMax, info.lonMax);
            latMin = qMin(latMin, info.latMin);
            latMax = qMax(latMax, info.latMax);
            hasData = true;
        }
    }

    if (!hasData) return;

    double centerLon = (lonMin + lonMax) / 2.0;
    double centerLat = (latMin + latMax) / 2.0;

    double lonSpan = lonMax - lonMin;
    double latSpan = latMax - latMin;
    if (lonSpan <= 0) lonSpan = 0.01;
    if (latSpan <= 0) latSpan = 0.01;

    double pad = 0.08;
    double scaleX = width() / (lonSpan * (1 + 2 * pad));
    double scaleY = height() / (latSpan * (1 + 2 * pad));
    m_baseScale = qMin(scaleX, scaleY);

    m_scale = 1.0;

    double pixelsPerDeg = m_baseScale * m_scale;
    double dataCenterX = centerLon * pixelsPerDeg;
    double dataCenterY = -centerLat * pixelsPerDeg;

    m_dataOrigin = QPointF(
        width() / 2.0 - dataCenterX,
        height() / 2.0 - dataCenterY
    );

    m_offset = QPointF(0, 0);

    m_arcCache.clear();
    m_fastBufferValid = false;
    m_renderGeneration.fetch_add(1);

    emit scaleChanged(m_scale);
    emit offsetChanged(m_offset);
    m_needRerender = true;
}

void OsmMapWidget::zoomIn() { zoomBy(1.4, QPointF(width() / 2.0, height() / 2.0)); }
void OsmMapWidget::zoomOut() { zoomBy(1.0 / 1.4, QPointF(width() / 2.0, height() / 2.0)); }
void OsmMapWidget::resetView() { fitToData(); }

void OsmMapWidget::exportPng(const QString &fileName)
{
    if (!m_model || m_model->isEmpty()) return;
    RenderViewState state = currentViewState();
    ThreadRenderData data = prepareThreadData(m_model, m_style);
    QImage img = renderFull(data, state, false);
    img.save(fileName, "PNG");
}

void OsmMapWidget::setScale(qreal s)
{
    if (qFuzzyCompare(m_scale, s)) return;
    QPointF center(width() / 2.0, height() / 2.0);
    zoomBy(s / m_scale, center);
}

void OsmMapWidget::setOffset(const QPointF &off)
{
    m_offset = off;
    invalidateTiles();
    emit offsetChanged(m_offset);
    update();
}

void OsmMapWidget::clearSelection()
{
    m_selectedWay = -1;
    m_hoveredWay = -1;
    emit waySelected(-1);
    update();
}

QPointF OsmMapWidget::lonLatToView(double lon, double lat) const
{
    double ppd = m_baseScale * m_scale;
    return QPointF(lon * ppd + m_dataOrigin.x() + m_offset.x(),
                   -lat * ppd + m_dataOrigin.y() + m_offset.y());
}

void OsmMapWidget::viewToLonLat(const QPointF &view, double &lon, double &lat) const
{
    double ppd = m_baseScale * m_scale;
    lon = (view.x() - m_dataOrigin.x() - m_offset.x()) / ppd;
    lat = -(view.y() - m_dataOrigin.y() - m_offset.y()) / ppd;
}

int OsmMapWidget::computeCurrentLod() const
{
    double ppd = m_baseScale * m_scale;
    // ppd (pixels per degree) is independent of data range, directly reflects screen density
    int lod;
    if (ppd < 10)         lod = 0;   // LOD_COUNTRY
    else if (ppd < 50)    lod = 3;   // LOD_PROVINCE
    else if (ppd < 200)   lod = 6;   // LOD_CITY
    else if (ppd < 1000)  lod = 9;   // LOD_TOWN
    else if (ppd < 5000)  lod = 12;  // LOD_STREET
    else if (ppd < 20000) lod = 15;  // LOD_BUILDING
    else if (ppd < 100000) lod = 18;  // LOD_DETAIL -- important POIs appear
    else if (ppd < 500000) lod = 20;  // LOD_POI_FULL -- all POIs appear
    else lod = 21;                      // LOD_MAX
    return lod;
}

QRectF OsmMapWidget::computeVisibleBBox() const
{
    double minLon, minLat, maxLon, maxLat;
    viewToLonLat(QPointF(0, 0), minLon, maxLat);
    viewToLonLat(QPointF(width(), height()), maxLon, minLat);
    return QRectF(minLon, minLat, maxLon - minLon, maxLat - minLat);
}

bool OsmMapWidget::wayInView(const OsmWay &way, const QRectF &viewRect) const
{
    if (!way.bbox().isValid()) return true;
    return way.bbox().intersects(viewRect.adjusted(-0.01, -0.01, 0.01, 0.01));
}

void OsmMapWidget::buildWayPolygon(const OsmWay &way, QPolygonF &poly) const
{
    poly.clear();
    poly.reserve(way.nodeIndices().size());
    double ppd = m_baseScale * m_scale;
    double ox = m_dataOrigin.x() + m_offset.x();
    double oy = m_dataOrigin.y() + m_offset.y();
    for (int nodeIdx : way.nodeIndices()) {
        if (nodeIdx >= 0 && nodeIdx < m_model->nodes().size()) {
            const OsmNode &n = m_model->nodes()[nodeIdx];
            poly.append(QPointF(n.lon() * ppd + ox, -n.lat() * ppd + oy));
        }
    }
}

RenderViewState OsmMapWidget::currentViewState() const
{
    RenderViewState s;
    s.scale = m_scale;
    s.offset = m_offset;
    s.dataOrigin = m_dataOrigin;
    s.baseScale = m_baseScale;
    s.width = width();
    s.height = height();
    s.lod = computeCurrentLod();
    s.viewBBox = computeVisibleBBox();
    s.showRoads = m_showRoads;
    s.showBuildings = m_showBuildings;
    s.showWater = m_showWater;
    s.showGreen = m_showGreen;
    s.showRailway = m_showRailway;
    s.showLanduse = m_showLanduse;
    s.showNodes = m_showNodes;
    s.showPoi = m_showPoi;
    return s;
}

void OsmMapWidget::invalidateTiles()
{
    m_arcCache.clear();
    m_fastBufferValid = false;
    m_renderGeneration.fetch_add(1);
}

void OsmMapWidget::purgeOldTiles()
{
    // ARC cache already auto-evicts during insert(), no manual cleanup needed
    // Keep this function as a safety net: bail out if cache unexpectedly swells
    while (m_arcCache.size() > MAX_CACHED_TILES * 2) {
        m_arcCache.clear();
        break;
    }
}

void OsmMapWidget::scheduleRepaint()
{
    m_needRerender = true;
    update();
}

void OsmMapWidget::triggerAsyncRender()
{
    if (!m_model || m_model->isEmpty() || !m_style) return;
    if (m_rendering.exchange(true)) return;

    m_renderGeneration.fetch_add(1);
    qint64 gen = m_renderGeneration.load();

    RenderViewState state = currentViewState();
    ThreadRenderData data = prepareThreadData(m_model, m_style);

    int tilesX = (width() + TILE_SIZE - 1) / TILE_SIZE;
    int tilesY = (height() + TILE_SIZE - 1) / TILE_SIZE;
    int pending = 0;

    qint64 scaleHash = (qint64)(m_scale * 1000000);

    {
        // ArcTileCache::contains() has internal read lock, no additional m_tileLock needed
        for (int ty = 0; ty <= tilesY; ty++) {
            for (int tx = 0; tx <= tilesX; tx++) {
                TileCacheKey key{tx, ty, state.lod, scaleHash};
                if (!m_arcCache.contains(key)) {
                    pending++;
                }
            }
        }
    }

    if (pending == 0) {
        m_rendering.store(false);
        update();
        return;
    }

    m_pendingTileCount = pending;

    for (int ty = 0; ty <= tilesY; ty++) {
        for (int tx = 0; tx <= tilesX; tx++) {
            TileCacheKey key{tx, ty, state.lod, scaleHash};
            bool needRender = false;
            needRender = !m_arcCache.contains(key);
            if (needRender) {
                RenderTileTask *task = new RenderTileTask(data, state, key, this, gen);
                m_renderPool.start(task);
            }
        }
    }
}

void OsmMapWidget::onTileRendered(TileCacheKey key, QImage image, qint64 generation)
{
    if (generation != m_renderGeneration.load()) {
        m_pendingTileCount.fetch_sub(1);
        if (m_pendingTileCount.load() <= 0) {
            m_rendering.store(false);
            purgeOldTiles();
        }
        return;
    }

    {
        m_arcCache.insert(key, image);
    }

    m_pendingTileCount.fetch_sub(1);
    if (m_pendingTileCount.load() <= 0) {
        m_rendering.store(false);
        purgeOldTiles();
    }

    update();
}

void OsmMapWidget::renderFullSync(QPainter &painter)
{
    QElapsedTimer timer;
    timer.start();

    RenderViewState state = currentViewState();
    bool fastMode = m_rightDragging || m_leftDragging;

    if (fastMode && m_fastBufferValid && m_fastBuffer.size() == QSize(width(), height())) {
        painter.drawImage(0, 0, m_fastBuffer);
        return;
    }

    QImage img(width(), height(), QImage::Format_ARGB32_Premultiplied);
    img.fill(QColor(242, 239, 233));  // Beige background #f2efe9
    QPainter imgPainter(&img);

    if (m_model && m_style && !m_model->isEmpty()) {
        ThreadRenderData data = prepareThreadData(m_model, m_style);
        QImage layerImg = renderFull(data, state, fastMode, false);
        imgPainter.drawImage(0, 0, layerImg);
    }

    for (const auto &layer : m_layers) {
        if (layer.visible && layer.model && !layer.model->isEmpty()) {
            ThreadRenderData data = prepareThreadData(layer.model, &layer.style);
            QImage layerImg = renderFull(data, state, fastMode, false);
            imgPainter.drawImage(0, 0, layerImg);
        }
    }

    imgPainter.end();
    painter.drawImage(0, 0, img);

    if (fastMode) {
        m_fastBuffer = img;
        m_fastBufferValid = true;
    } else {
        m_fastBufferValid = false;
    }

    qint64 elapsed = timer.elapsed();
    if (elapsed > 50) {
        qDebug() << "Full render took" << elapsed << "ms (fastMode:" << fastMode << ", layers:" << m_layers.size() << ")";
    }
    m_lastRenderTime = elapsed;
}

void OsmMapWidget::paintEvent(QPaintEvent *event)
{
    Q_UNUSED(event);
    QPainter painter(this);

    bool hasMainData = (m_model && m_style && !m_model->isEmpty());
    bool hasLayerData = !m_layers.empty();
    for (const auto &layer : m_layers) {
        if (layer.model && !layer.model->isEmpty()) {
            hasLayerData = true;
            break;
        }
    }

    if (!hasMainData && !hasLayerData) {
        painter.fillRect(rect(), Qt::white);
        painter.setPen(Qt::gray);
        painter.drawText(rect(), Qt::AlignCenter, tr("Please open an OSM file (*.osm, *.osm.pbf)"));
        return;
    }

    if (hasLayerData && !hasMainData) {
        renderFullSync(painter);
        return;
    }

    bool fastMode = m_rightDragging || m_leftDragging;
    painter.fillRect(rect(), Qt::white);

    RenderViewState state = currentViewState();
    qint64 scaleHash = (qint64)(m_scale * 1000000);

    int tilesX = (width() + TILE_SIZE - 1) / TILE_SIZE;
    int tilesY = (height() + TILE_SIZE - 1) / TILE_SIZE;

    bool hasAllTiles = true;
    int missingTiles = 0;

    // ArcTileCache::get() has internal write lock (updates access frequency), no additional m_tileLock needed
    for (int ty = 0; ty <= tilesY; ty++) {
        for (int tx = 0; tx <= tilesX; tx++) {
            TileCacheKey key{tx, ty, state.lod, scaleHash};
            const QImage *cached = m_arcCache.get(key);
            if (cached) {
                painter.drawImage(tx * TILE_SIZE, ty * TILE_SIZE, *cached);
            } else {
                hasAllTiles = false;
                missingTiles++;
            }
        }
    }

    if (fastMode) {
        if (!m_fastBufferValid || m_fastBuffer.size() != QSize(width(), height())) {
            ThreadRenderData data = prepareThreadData(m_model, m_style);
            m_fastBuffer = renderFull(data, state, true);
            m_fastBufferValid = true;
        }
        painter.setCompositionMode(QPainter::CompositionMode_SourceOver);
        painter.drawImage(0, 0, m_fastBuffer);
    } else if (!hasAllTiles) {
        ThreadRenderData data = prepareThreadData(m_model, m_style);
        QImage img = renderFull(data, state, true);
        painter.drawImage(0, 0, img);
        triggerAsyncRender();
    } else {
        m_rendering.store(false);
    }

    if (m_hoveredWay >= 0 && m_hoveredWay < m_model->ways().size() && !fastMode) {
        const OsmWay &way = m_model->ways()[m_hoveredWay];
        QPolygonF poly;
        buildWayPolygon(way, poly);

        bool isArea = false;
        for (const OsmDrawEntry &e : m_model->fillDrawList()) {
            if (e.wayIndex == m_hoveredWay) { isArea = true; break; }
        }

        if (isArea && poly.size() >= 3) {
            QColor hl(255, 220, 80, 100);
            painter.setBrush(hl);
            painter.setPen(QPen(QColor(255, 180, 0), 2));
            painter.drawPolygon(poly);
        } else if (poly.size() >= 2) {
            double hoverWidth = qMax(3.0, 4.0 * m_scale / 100.0);
            for (const OsmDrawEntry &e : m_model->lineDrawList()) {
                if (e.wayIndex == m_hoveredWay) {
                    const LineStyle *ls = m_style->lineStyleFor(e.tagType);
                    if (ls) {
                        double ppd = m_baseScale * m_scale;
                        double wPx = calcLineWidthPx(*ls, ppd);
                        hoverWidth = qMax(wPx + 2.0, 3.0);
                    }
                    break;
                }
            }
            painter.setPen(QPen(QColor(255, 180, 0), hoverWidth, Qt::SolidLine, Qt::FlatCap, Qt::MiterJoin));
            painter.setBrush(Qt::NoBrush);
            painter.drawPolyline(poly);
        }
    }

    if (m_selectedWay >= 0 && m_selectedWay < m_model->ways().size()) {
        const OsmWay &way = m_model->ways()[m_selectedWay];
        QPolygonF poly;
        buildWayPolygon(way, poly);

        bool isArea = false;
        for (const OsmDrawEntry &e : m_model->fillDrawList()) {
            if (e.wayIndex == m_selectedWay) { isArea = true; break; }
        }

        if (isArea && poly.size() >= 3) {
            QColor sel(80, 170, 255, 120);
            painter.setBrush(sel);
            painter.setPen(QPen(QColor(0, 120, 230), 2.5));
            painter.drawPolygon(poly);
        } else if (poly.size() >= 2) {
            double selectWidth = qMax(3.0, 4.0 * m_scale / 100.0);
            for (const OsmDrawEntry &e : m_model->lineDrawList()) {
                if (e.wayIndex == m_selectedWay) {
                    const LineStyle *ls = m_style->lineStyleFor(e.tagType);
                    if (ls) {
                        double ppd = m_baseScale * m_scale;
                        double wPx = calcLineWidthPx(*ls, ppd);
                        selectWidth = qMax(wPx + 2.0, 3.0);
                    }
                    break;
                }
            }
            painter.setPen(QPen(QColor(0, 120, 230), selectWidth, Qt::SolidLine, Qt::FlatCap, Qt::MiterJoin));
            painter.setBrush(Qt::NoBrush);
            painter.drawPolyline(poly);
        }
    }

    if (!m_routePath.isEmpty()) {
        QPolygonF routePoly;
        for (const QPointF &p : m_routePath) {
            routePoly.append(lonLatToView(p.x(), p.y()));
        }
        if (routePoly.size() >= 2) {
            double routeWidth = qMax(5.0, 6.0 * m_scale / 100.0);
            painter.setPen(QPen(QColor(255, 80, 80, 200), routeWidth, Qt::SolidLine, Qt::RoundCap, Qt::RoundJoin));
            painter.setBrush(Qt::NoBrush);
            painter.drawPolyline(routePoly);

            painter.setPen(QPen(QColor(255, 255, 255, 220), routeWidth * 0.4, Qt::DashLine, Qt::RoundCap, Qt::RoundJoin));
            painter.drawPolyline(routePoly);

            if (!routePoly.isEmpty()) {
                painter.setPen(QPen(QColor(0, 180, 0), 2));
                painter.setBrush(QColor(0, 220, 0, 180));
                painter.drawEllipse(routePoly.first(), 8, 8);

                painter.setPen(QPen(QColor(200, 0, 0), 2));
                painter.setBrush(QColor(255, 80, 80, 200));
                painter.drawEllipse(routePoly.last(), 8, 8);
            }
        }
    }

    painter.setPen(Qt::black);
    painter.setFont(QFont("Consolas", 9));
    QPointF mousePos = mapFromGlobal(QCursor::pos());
    if (rect().contains(mousePos.toPoint())) {
        double lon, lat;
        viewToLonLat(mousePos, lon, lat);
        painter.drawText(10, height() - 10,
            QString("Lon: %1°  Lat: %2°  LOD: %3  Scale: %4x  Ways: %5  Tiles: %6%7")
                .arg(lon, 0, 'f', 6).arg(lat, 0, 'f', 6).arg(state.lod).arg(m_scale, 0, 'f', 1)
                .arg(m_model->wayCount())
                .arg(((tilesX+1)*(tilesY+1) - missingTiles)).arg(m_rendering.load() ? " [rendering...]" : ""));
    }
}

void OsmMapWidget::wheelEvent(QWheelEvent *event)
{
    QPointF pos = event->position();
    int delta = event->angleDelta().y();
    double factor = qPow(1.25, delta / 120.0);
    zoomBy(factor, pos);
    event->accept();
}

void OsmMapWidget::zoomBy(double factor, const QPointF &center)
{
    double minScale = MIN_ZOOM_PIXELS_PER_DEG / m_baseScale;
    double maxScale = MAX_ZOOM_PIXELS_PER_DEG / m_baseScale;

    double newScale = qBound(minScale, m_scale * factor, maxScale);
    if (qFuzzyCompare(newScale, m_scale)) return;

    double lon, lat;
    viewToLonLat(center, lon, lat);

    m_scale = newScale;
    m_fastBufferValid = false;

    double ppd = m_baseScale * m_scale;
    double newX = lon * ppd + m_dataOrigin.x() + m_offset.x();
    double newY = -lat * ppd + m_dataOrigin.y() + m_offset.y();

    m_offset.rx() += center.x() - newX;
    m_offset.ry() += center.y() - newY;

    m_hoveredWay = -1;
    invalidateTiles();
    emit scaleChanged(m_scale);
    emit offsetChanged(m_offset);
    update();
}

void OsmMapWidget::mousePressEvent(QMouseEvent *event)
{
    m_lastMousePos = event->pos();
    m_dragStartPos = event->pos();
    m_dragMoved = false;

    if (event->button() == Qt::RightButton) {
        m_rightDragging = true;
        setCursor(Qt::ClosedHandCursor);
    } else if (event->button() == Qt::LeftButton) {
        m_leftDragging = true;
    }
    event->accept();
}

void OsmMapWidget::mouseMoveEvent(QMouseEvent *event)
{
    QPoint delta = event->pos() - m_lastMousePos;

    if (m_rightDragging || (m_leftDragging && (event->pos() - m_dragStartPos).manhattanLength() > 4)) {
        m_dragMoved = true;
        m_offset += QPointF(delta);
        m_lastMousePos = event->pos();
        m_hoveredWay = -1;
        m_fastBufferValid = false;
        emit offsetChanged(m_offset);
        update();
    } else if (!m_leftDragging) {
        int hitNode = hitTestPOI(event->position());
        int hitWay = (hitNode < 0) ? hitTestWay(event->position()) : -1;

        if (hitWay != m_hoveredWay || hitNode != m_hoveredNode) {
            m_hoveredWay = hitWay;
            m_hoveredNode = hitNode;
            if (hitWay >= 0) {
                emit wayHovered(hitWay);
                emit nodeHovered(-1);
                QToolTip::hideText();
            } else if (hitNode >= 0) {
                emit nodeHovered(hitNode);
                emit wayHovered(-1);
                // Show POI tooltip
                showPoiTooltip(hitNode, event->globalPosition().toPoint());
            } else {
                emit wayHovered(-1);
                emit nodeHovered(-1);
                QToolTip::hideText();
            }
            update();
        }
        setCursor((hitWay >= 0 || hitNode >= 0) ? Qt::PointingHandCursor : Qt::ArrowCursor);
    }
    m_lastMousePos = event->pos();
    event->accept();
}

void OsmMapWidget::mouseReleaseEvent(QMouseEvent *event)
{
    if (event->button() == Qt::RightButton) {
        m_rightDragging = false;
        setCursor(m_hoveredWay >= 0 ? Qt::PointingHandCursor : Qt::ArrowCursor);
        m_fastBufferValid = false;
        invalidateTiles();
        triggerAsyncRender();
    } else if (event->button() == Qt::LeftButton) {
        m_leftDragging = false;
        if (!m_dragMoved) {
            int hitNode = hitTestPOI(event->position());
            int hitWay = (hitNode < 0) ? hitTestWay(event->position()) : -1;

            bool changed = false;
            if (hitWay != m_selectedWay) {
                m_selectedWay = hitWay;
                emit waySelected(hitWay);
                changed = true;
            }
            if (hitNode != m_selectedNode) {
                m_selectedNode = hitNode;
                emit nodeSelected(hitNode);
                changed = true;
            }
            if (changed) update();
            double lon, lat;
            viewToLonLat(event->position(), lon, lat);
            emit mapClicked(lat, lon, Qt::LeftButton);
        } else {
            m_fastBufferValid = false;
            invalidateTiles();
            triggerAsyncRender();
        }
    } else if (event->button() == Qt::RightButton) {
        if (!m_dragMoved) {
            double lon, lat;
            viewToLonLat(event->position(), lon, lat);
            emit mapClicked(lat, lon, Qt::RightButton);
        }
    }
    event->accept();
}

void OsmMapWidget::mouseDoubleClickEvent(QMouseEvent *event)
{
    if (event->button() == Qt::LeftButton) {
        zoomBy(2.0, event->position());
    }
    event->accept();
}

void OsmMapWidget::keyPressEvent(QKeyEvent *event)
{
    switch (event->key()) {
    case Qt::Key_Plus:
    case Qt::Key_Equal:
        zoomIn();
        break;
    case Qt::Key_Minus:
        zoomOut();
        break;
    case Qt::Key_0:
        resetView();
        break;
    case Qt::Key_Left:
        m_offset.rx() += 50;
        m_fastBufferValid = false;
        invalidateTiles();
        emit offsetChanged(m_offset);
        update();
        break;
    case Qt::Key_Right:
        m_offset.rx() -= 50;
        m_fastBufferValid = false;
        invalidateTiles();
        emit offsetChanged(m_offset);
        update();
        break;
    case Qt::Key_Up:
        m_offset.ry() += 50;
        m_fastBufferValid = false;
        invalidateTiles();
        emit offsetChanged(m_offset);
        update();
        break;
    case Qt::Key_Down:
        m_offset.ry() -= 50;
        m_fastBufferValid = false;
        invalidateTiles();
        emit offsetChanged(m_offset);
        update();
        break;
    case Qt::Key_H:
        if (event->modifiers() & Qt::ShiftModifier) {
            m_showRoads = !m_showRoads;
            invalidateTiles();
            update();
        }
        break;
    case Qt::Key_B:
        m_showBuildings = !m_showBuildings;
        invalidateTiles();
        update();
        break;
    case Qt::Key_W:
        m_showWater = !m_showWater;
        invalidateTiles();
        update();
        break;
    case Qt::Key_G:
        m_showGreen = !m_showGreen;
        invalidateTiles();
        update();
        break;
    case Qt::Key_L:
        m_showLanduse = !m_showLanduse;
        invalidateTiles();
        update();
        break;
    case Qt::Key_R:
        if (event->modifiers() & Qt::ShiftModifier) {
            m_showRailway = !m_showRailway;
            invalidateTiles();
            update();
        }
        break;
    case Qt::Key_Escape:
        clearSelection();
        break;
    default:
        QWidget::keyPressEvent(event);
    }
}

void OsmMapWidget::resizeEvent(QResizeEvent *event)
{
    QWidget::resizeEvent(event);
    invalidateTiles();
}

int OsmMapWidget::hitTestWay(const QPointF &viewPos) const
{
    if (!m_model || !m_style) return -1;

    int bestWay = -1;
    double bestDist = HOVER_TEST_RADIUS_PX;

    double clickLon, clickLat;
    viewToLonLat(viewPos, clickLon, clickLat);
    double tolerance = HOVER_TEST_RADIUS_PX / (m_baseScale * m_scale) * 1.5;
    QList<int> candidateWayIndices = m_model->queryPoint(QPointF(clickLon, clickLat), tolerance);

    double ppd = m_baseScale * m_scale;
    double ox = m_dataOrigin.x() + m_offset.x();
    double oy = m_dataOrigin.y() + m_offset.y();

    QSet<int> candidateSet;
    candidateSet.reserve(candidateWayIndices.size());
    for (int idx : candidateWayIndices) candidateSet.insert(idx);

    auto buildHitPoly = [&](const OsmWay &way, QPolygonF &poly) {
        poly.reserve(way.nodeIndices().size());
        for (int nodeIdx : way.nodeIndices()) {
            if (nodeIdx < 0 || nodeIdx >= m_model->nodes().size()) continue;
            const OsmNode &n = m_model->nodes()[nodeIdx];
            poly.append(QPointF(n.lon() * ppd + ox, -n.lat() * ppd + oy));
        }
    };

    for (const OsmDrawEntry &entry : m_model->fillDrawList()) {
        if (!candidateSet.contains(entry.wayIndex)) continue;

        int type = entry.tagType;
        if (isBuildingType(type) && !m_showBuildings) continue;
        if (isWaterType(type) && !m_showWater) continue;
        if (isGreenType(type) && !m_showGreen) continue;
        if (isLanduseType(type) && !m_showLanduse) continue;
        if (isRoadType(type) && !m_showRoads) continue;
        if (isRailwayType(type) && !m_showRailway) continue;

        const OsmWay &way = m_model->ways()[entry.wayIndex];
        QPolygonF poly;
        buildHitPoly(way, poly);
        if (poly.size() < 3) continue;

        if (poly.containsPoint(viewPos, Qt::OddEvenFill)) {
            return entry.wayIndex;
        }
    }

    for (const OsmDrawEntry &entry : m_model->lineDrawList()) {
        if (!candidateSet.contains(entry.wayIndex)) continue;

        int type = entry.tagType;
        if (isBuildingType(type) && !m_showBuildings) continue;
        if (isWaterType(type) && !m_showWater) continue;
        if (isGreenType(type) && !m_showGreen) continue;
        if (isLanduseType(type) && !m_showLanduse) continue;
        if (isRoadType(type) && !m_showRoads) continue;
        if (isRailwayType(type) && !m_showRailway) continue;

        const OsmWay &way = m_model->ways()[entry.wayIndex];
        QPolygonF poly;
        buildHitPoly(way, poly);
        if (poly.size() < 2) continue;

        for (int i = 0; i < poly.size() - 1; i++) {
            QPointF p1 = poly[i];
            QPointF p2 = poly[i + 1];
            double dx = p2.x() - p1.x();
            double dy = p2.y() - p1.y();
            double len2 = dx*dx + dy*dy;
            if (len2 < 1e-6) continue;

            double t = ((viewPos.x() - p1.x()) * dx + (viewPos.y() - p1.y()) * dy) / len2;
            t = qBound(0.0, t, 1.0);
            double px = p1.x() + t * dx;
            double py = p1.y() + t * dy;
            double dist = qSqrt((viewPos.x() - px)*(viewPos.x() - px) + (viewPos.y() - py)*(viewPos.y() - py));

            const LineStyle *ls = m_style->lineStyleFor(entry.tagType);
            double hitWidth = ls ? qMax(ls->widthPx * m_scale + 2, 4.0) : 4.0;

            if (dist < hitWidth && dist < bestDist) {
                bestDist = dist;
                bestWay = entry.wayIndex;
            }
        }
    }

    return bestWay;
}

int OsmMapWidget::hitTestPOI(const QPointF &viewPos) const
{
    if (!m_model || !m_style || !m_showPoi) return -1;

    double ppd = m_baseScale * m_scale;
    double ox = m_dataOrigin.x() + m_offset.x();
    double oy = m_dataOrigin.y() + m_offset.y();

    int bestNode = -1;
    double bestDist = HOVER_TEST_RADIUS_PX + 2;  // POI hit radius is slightly larger than for ways

    const QVector<OsmNode> &nodes = m_model->nodes();

    for (const OsmDrawEntry &entry : m_model->pointDrawList()) {
        if (entry.nodeIndex < 0 || entry.nodeIndex >= nodes.size()) continue;

        const OsmNode &node = nodes[entry.nodeIndex];
        double screenX = node.lon() * ppd + ox;
        double screenY = -node.lat() * ppd + oy;

        double dx = viewPos.x() - screenX;
        double dy = viewPos.y() - screenY;
        double dist = qSqrt(dx * dx + dy * dy);

        if (dist < bestDist) {
            bestDist = dist;
            bestNode = entry.nodeIndex;
        }
    }

    return bestNode;
}

void OsmMapWidget::showPoiTooltip(int nodeIndex, const QPoint &globalPos)
{
    if (!m_model || nodeIndex < 0 || nodeIndex >= m_model->nodes().size()) {
        QToolTip::hideText();
        return;
    }

    const OsmNode &node = m_model->nodes()[nodeIndex];
    const QVector<OsmTag> &tags = m_model->tags();

    // Preferentially look up the name tag
    QString name;
    QString typeInfo;
    int tt = node.tagHead();
    while (tt >= 0 && tt < tags.size()) {
        const OsmTag &tag = tags[tt];
        QString key = m_model->keyName(tag.keyIndex);
        if (key == "name" && name.isEmpty()) {
            name = tag.value;
        } else if (key == "name:zh" && name.isEmpty()) {
            name = tag.value;
        } else if (key == "name:en" && name.isEmpty()) {
            name = tag.value;
        }
        // Get the first meaningful tag as type description
        if (typeInfo.isEmpty() && key != "name" && !key.startsWith("name:")
            && key != "source" && key != "created_by" && key != "note"
            && key != "fixme" && key != "description") {
            typeInfo = key + "=" + tag.value;
        }
        tt = tag.nextIndex;
    }

    QString tip;
    if (!name.isEmpty()) {
        tip = name;
        if (!typeInfo.isEmpty())
            tip += "\n" + typeInfo;
    } else if (!typeInfo.isEmpty()) {
        tip = typeInfo;
    } else {
        tip = tr("Node #%1").arg(node.id());
    }

    tip += QString("\n(%1, %2)")
        .arg(QString::number(node.lat(), 'f', 6))
        .arg(QString::number(node.lon(), 'f', 6));

    QToolTip::showText(globalPos, tip, this);
}

QPointF OsmMapWidget::lonLatToViewScaled(double lon, double lat, qreal scale, const QPointF &origin) const
{
    double ppd = m_baseScale * scale;
    return QPointF(lon * ppd + origin.x(), -lat * ppd + origin.y());
}

void OsmMapWidget::selectWay(int wayIndex)
{
    m_selectedWay = wayIndex;
    update();
}

void OsmMapWidget::setRoutePath(const QVector<QPointF> &path)
{
    m_routePath = path;
    update();
}

void OsmMapWidget::clearRoutePath()
{
    m_routePath.clear();
    update();
}

void OsmMapWidget::zoomToBBox(const QRectF &bbox)
{
    if (!bbox.isValid() || width() <= 0 || height() <= 0) return;

    double w = bbox.width();
    double h = bbox.height();
    double scaleX = (width() - 40) / w;
    double scaleY = (height() - 40) / h;
    qreal newPpd = qMin(scaleX, scaleY);
    m_scale = newPpd / m_baseScale;
    m_scale = qBound(MIN_ZOOM_PIXELS_PER_DEG / m_baseScale, m_scale, MAX_ZOOM_PIXELS_PER_DEG / m_baseScale);

    double cx = bbox.center().x();
    double cy = bbox.center().y();
    double ppd = m_baseScale * m_scale;
    m_offset = QPointF(width() / 2.0 - cx * ppd - m_dataOrigin.x(),
                       height() / 2.0 + cy * ppd - m_dataOrigin.y());

    invalidateTiles();
    triggerAsyncRender();
    update();
}