//
// Created by Lenn on 2025/12/16.
//

#include "glwidget.h"
#include <QOpenGLShaderProgram>
#include <QByteArray>
#include <QtMath>
#include <QFile>
#include <QDebug>
#include <qevent.h>
#include <qlogging.h>
#include <qminmax.h>
#include <qopenglext.h>
#include <qopenglshaderprogram.h>
#include <qstringliteral.h>
#include <qvectornd.h>
#include <QVector3D>
#include <QVector2D>
#include <QVector4D>
#include <QImage>
#include <QPainter>
#include <QFontMetrics>
#include <algorithm>
#include <limits>

// 读取文本文件内容（这里主要用来从 Qt Resource `:/shaders/...` 读取 shader 源码）
static QByteArray readFile(const QString& path) {
    QFile f(path);
    if (!f.open(QIODevice::ReadOnly)) return {};
    return f.readAll();
}

// 简单的 4x4 单位矩阵（目前只用于保留的 float[16] 版本）
static void matIdentity(float m[16]) {
    for (int i = 0; i < 16; i++) {
        m[i] = 0;
    }

    m[0] = m[5] = m[10] = m[15] = 1;
}

static QVector3D toColorVec(const QColor& color) {
    return QVector3D(color.redF(), color.greenF(), color.blueF());
}

GLWidget::GLWidget(QWidget *parent)
    : QOpenGLWidget(parent) {
    setMinimumSize(640, 480);
}

GLWidget::~GLWidget() {
    makeCurrent();
    delete m_bgProg;
    delete m_panelProg;
    delete m_dotsProg;

    if (m_panelIbo)
        glDeleteBuffers(1, &m_panelIbo);
    if (m_panelVbo)
        glDeleteBuffers(1, &m_panelVbo);
    if (m_panelVao)
        glDeleteVertexArrays(1, &m_panelVao);
    if (m_dotsVao)
        glDeleteVertexArrays(1, &m_dotsVao);
    if (m_dotsVbo)
        glDeleteBuffers(1, &m_dotsVbo);
    if (m_instanceVbo)
        glDeleteBuffers(1, &m_instanceVbo);
    if (m_bgVbo)
        glDeleteBuffers(1, &m_bgVbo);
    if (m_bgVao)
        glDeleteVertexArrays(1, &m_bgVao);

    if (m_dotTex)
        glDeleteTextures(1, &m_dotTex);
    doneCurrent();
}

void GLWidget::setPanelSize(float w, float h, float d) {
    m_panelW = w;
    m_panelH = h;
    m_panelD = d;
    m_panelGeometryDirty = true;
    update();
}

void GLWidget::setPanelThickness(float h) {
    if (qFuzzyCompare(m_panelH, h))
        return;
    m_panelD = h;
    m_panelGeometryDirty = true;
    update();
}

void GLWidget::setSpec(int rows, int cols, float pitch, float dotRaius) {
    m_rows = qMax(0, rows);
    m_cols = qMax(0, cols);
    m_pitch = qMax(0.0f, pitch);
    m_dotRadius = qMax(0.0f, dotRaius);

    // 自动根据点阵尺寸调整 panel 的尺寸（保证圆点不会越过顶面边界）。
    // 约定：点中心覆盖的范围是 (cols-1)*pitch / (rows-1)*pitch，面板需要额外留出 dotRadius 的边缘空间。
    const float gridW = float(qMax(0, m_cols - 1)) * m_pitch;
    const float gridH = float(qMax(0, m_rows - 1)) * m_pitch;
    m_panelW = gridW + 2.0f * m_dotRadius;
    m_panelH = gridH + 2.0f * m_dotRadius;
    m_panelGeometryDirty = true;
    m_dotsGeometryDirty = true;

    QMutexLocker lk(&m_dataMutex);
    m_latestValues.resize(dotCount());
    for (int i = 0; i < m_latestValues.size(); ++i) {
        m_latestValues[i] = m_min;
    }
    m_valuesDirty = true;
    m_hasData = false;
    update();
}

void GLWidget::submitValues(const QVector<float> &values) {
    if (values.size() != dotCount()) return;

    {
        QMutexLocker lk(&m_dataMutex);
        m_latestValues = values;
        m_valuesDirty = true;
        m_hasData = true;
    }

    update();
}

void GLWidget::setRange(int minV, int maxV) {
    m_min = minV;
    m_max = maxV;
    update();
}

void GLWidget::setYaw(float yawDeg) {
    if (qFuzzyCompare(m_camYawDeg, yawDeg))
        return;
    m_camYawDeg = yawDeg;
    emit yawChanged();
    update();
}

void GLWidget::setRenderModeString(const QString &mode) {
    RenderMode next = DataViz;
    if (mode.compare(QStringLiteral("realistic"), Qt::CaseInsensitive) == 0) {
        next = Realistic;
    } else if (mode.compare(QStringLiteral("dataViz"), Qt::CaseInsensitive) == 0) {
        next = DataViz;
    }

    if (m_renderMode == next)
        return;
    m_renderMode = next;
    update();
}

void GLWidget::setLabelModeString(const QString &mode) {
    LabelMode next = LabelsOff;
    if (mode.compare(QStringLiteral("hover"), Qt::CaseInsensitive) == 0) {
        next = LabelsHover;
    } else if (mode.compare(QStringLiteral("always"), Qt::CaseInsensitive) == 0) {
        next = LabelsAlways;
    } else if (mode.compare(QStringLiteral("off"), Qt::CaseInsensitive) == 0) {
        next = LabelsOff;
    }

    if (m_labelMode == next)
        return;
    m_labelMode = next;
    if (m_labelMode == LabelsOff)
        m_hoveredIndex = -1;
    update();
}

void GLWidget::setLightMode(bool on = true) {
    if (on == m_lightMode) {
        return;
    }

    m_lightMode = on;
    update();
}

void GLWidget::setShowBg(bool on = true) {
    if (on == m_showBg) {
        return;
    }
    m_showBg = on;
    update();
}

void GLWidget::setColorLow(const QColor& color) {
    const QVector3D next = toColorVec(color);
    if (m_colorLow == next)
        return;
    m_colorLow = next;
    update();
}

void GLWidget::setColorMid(const QColor& color) {
    const QVector3D next = toColorVec(color);
    if (m_colorMid == next)
        return;
    m_colorMid = next;
    update();
}

void GLWidget::setColorHigh(const QColor& color) {
    const QVector3D next = toColorVec(color);
    if (m_colorHigh == next)
        return;
    m_colorHigh = next;
    update();
}

void GLWidget::initializeGL() {
    initializeOpenGLFunctions();

    // 基础状态：开启深度测试，否则 3D 物体的遮挡关系会不正确
    glEnable(GL_DEPTH_TEST);
    glDepthFunc(GL_LESS);
    initPrograms_();
    initDotTexture_();
    initBackgroundGeometry_();
    initPanelGeometry_();
    initDotGeometry_();
    initRoomGeometry_();
    m_panelGeometryDirty = false;
    m_dotsGeometryDirty = false;

    matIdentity(m_modelPanel);
    matIdentity(m_view);
    matIdentity(m_proj);
}

void GLWidget::initGeometry_() {
    initDotTexture_();
    initBackgroundGeometry_();
    initPanelGeometry_();
    initDotGeometry_();
    initRoomGeometry_(); 
}

void GLWidget::resizeGL(int w, int h) {
    glViewport(0, 0, w, h);
}

void GLWidget::paintGL() {
    glClearColor(1.0f, 1.0f, 1.0f, 1.0f);
    glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);

    // 如果点阵规格/面板尺寸发生变化，需要在有 GL 上下文时重建几何体 buffer。
    if (m_panelGeometryDirty) {
        initPanelGeometry_();
        m_panelGeometryDirty = false;
    }
    if (m_dotsGeometryDirty) {
        initDotGeometry_();
        m_dotsGeometryDirty = false;
        m_valuesDirty = true; // instanceVBO 重新分配后需要重新上传数据
    }

    // --- 背景：屏幕空间网格（不随相机旋转）---
    if (m_bgProg && m_bgVao && m_showBg) {
        const float dpr = devicePixelRatioF();
        const QVector2D viewport(float(width()) * dpr, float(height()) * dpr);

        glDisable(GL_DEPTH_TEST);
        glDepthMask(GL_FALSE);

        m_bgProg->bind();
        m_bgProg->setUniformValue("uViewport", viewport);
        m_bgProg->setUniformValue("uMinorStep", 24.0f * dpr);
        m_bgProg->setUniformValue("uMajorStep", 120.0f * dpr);

        glBindVertexArray(m_bgVao);
        glDrawArrays(GL_TRIANGLES, 0, 6);
        glBindVertexArray(0);

        m_bgProg->release();

        glDepthMask(GL_TRUE);
        glEnable(GL_DEPTH_TEST);
    }

    // 1) 更新相机/投影矩阵（MVP），决定如何把 3D 世界投影到屏幕
    updateMatrices_();
    updateRoom_();
    // 2) 如果外部提交了新数据，就把 CPU 生成的 instance 数据更新到 GPU
    updateInstanceBufferIfNeeded_();

    if (m_panelProg) {
        m_panelProg->bind();
        // uniforms：每次 draw 前设置的一组“常量参数”（对当前 draw call 的所有顶点/片元都一致）
        // uMVP: Model-View-Projection 矩阵（把顶点从世界坐标 -> 裁剪空间；gl_Position 必须输出裁剪空间坐标）
        m_panelProg->setUniformValue("uMVP", m_mvp);
        m_panelProg->setUniformValue("uCameraPos", m_cameraPos);
        m_panelProg->setUniformValue("uPanelW", m_panelW);
        m_panelProg->setUniformValue("uPanelH", m_panelH);
        m_panelProg->setUniformValue("uPanelD", m_panelD);
        m_panelProg->setUniformValue("uRows", m_rows);
        m_panelProg->setUniformValue("uCols", m_cols);
        m_panelProg->setUniformValue("uPitch", m_pitch);
        m_panelProg->setUniformValue("uDotRadius", m_dotRadius);
        m_panelProg->setUniformValue("uRenderMode", 1);
        m_panelProg->setUniformValue("uLightMode", m_lightMode);
        glBindVertexArray(m_panelVao);
        glDrawElements(GL_TRIANGLES, m_panelIndexCount, GL_UNSIGNED_INT, nullptr);
        glBindVertexArray(0);
        m_panelProg->release();
    }

    if (m_dotsProg) {
        m_dotsProg->bind();
        // uniforms：每次 draw 前设置的一组“常量参数”（对当前 draw call 的所有 instance 都一致）
        // uMVP: 同上；用于把每个 dot 的世界坐标变换到屏幕
        m_dotsProg->setUniformValue("uMVP", m_mvp);
        m_dotsProg->setUniformValue("uRenderMode", 1);
        // uDotRadius: dot 的半径（世界坐标单位）
        m_dotsProg->setUniformValue("uDotRadius", m_dotRadius);
        // uBaseY: dot 的高度（放在 panel 顶面上方一点点，避免 z-fighting/闪烁）
        m_dotsProg->setUniformValue("uBaseZ", -(m_panelD * 0.5f) - 0.001f);
        // uMinV/uMaxV: 传感值范围，用于 fragment shader 把 value 映射成颜色
        m_dotsProg->setUniformValue("uMinV", float(m_min));
        m_dotsProg->setUniformValue("uMaxV", float(m_max));
        m_dotsProg->setUniformValue("uColorLow", m_colorLow);
        m_dotsProg->setUniformValue("uColorMid", m_colorMid);
        m_dotsProg->setUniformValue("uColorHigh", m_colorHigh);
        const int hasData = (m_hasData.load() || m_dotTex == 0) ? 1 : 0;
        m_dotsProg->setUniformValue("uHasData", hasData);
        m_dotsProg->setUniformValue("uCameraPos", m_cameraPos);
        m_dotsProg->setUniformValue("uDotTex", 0);
        if (m_dotTex) {
            glActiveTexture(GL_TEXTURE0);
            glBindTexture(GL_TEXTURE_2D, m_dotTex);
        }

        glBindVertexArray(m_dotsVao);
        glDrawArraysInstanced(GL_TRIANGLES, 0, 6, m_instanceCount);
        glBindVertexArray(0);
        if (m_dotTex) {
            glActiveTexture(GL_TEXTURE0);
            glBindTexture(GL_TEXTURE_2D, 0);
        }

        // m_dotsProg->release();
    }

    if (m_labelMode != LabelsOff && dotCount() > 0) {
        QVector<float> valuesCopy;
        {
            QMutexLocker lk(&m_dataMutex);
            valuesCopy = m_latestValues;
        }

        auto projectToScreen = [&](const QVector3D& world, QPointF& out) -> bool {
            const QVector4D clip = m_mvp * QVector4D(world, 1.0f);
            if (clip.w() <= 1e-6f)
                return false;
            const QVector3D ndc = clip.toVector3D() / clip.w();
            if (ndc.z() < -1.2f || ndc.z() > 1.2f)
                return false;

            out.setX((ndc.x() * 0.5f + 0.5f) * float(width()));
            out.setY((1.0f - (ndc.y() * 0.5f + 0.5f)) * float(height()));
            return true;
        };

        const float baseY = (m_panelH * 0.5f) + 0.001f;
        const float w = (m_cols - 1) * m_pitch;
        const float h = (m_rows - 1) * m_pitch;

        QPainter painter(this);
        painter.setRenderHint(QPainter::Antialiasing, true);
        painter.setRenderHint(QPainter::TextAntialiasing, true);

        QFont font = painter.font();
        font.setPixelSize(11);
        painter.setFont(font);
        const QFontMetrics fm(font);

        auto drawLabel = [&](const QPointF& anchor, const QPointF& offset, const QString& text) {
            QRectF box = fm.boundingRect(text);
            box.adjust(-6.0, -3.0, 6.0, 3.0);
            box.moveCenter(anchor + offset);

            const float margin = 4.0f;
            if (box.left() < margin) box.moveLeft(margin);
            if (box.top() < margin) box.moveTop(margin);
            if (box.right() > width() - margin) box.moveRight(width() - margin);
            if (box.bottom() > height() - margin) box.moveBottom(height() - margin);

            painter.setPen(Qt::NoPen);
            painter.setBrush(QColor(0, 0, 0, 150));
            painter.drawRoundedRect(box, 4.0, 4.0);
            painter.setPen(QColor(255, 255, 255, 235));
            painter.drawText(box, Qt::AlignCenter, text);
        };

        auto dotWorldCenter = [&](int i) -> QVector3D {
            const int rr = (m_cols > 0) ? (i / m_cols) : 0;
            const int cc = (m_cols > 0) ? (i % m_cols) : 0;
            const float x = (cc * m_pitch) - w * 0.5f;
            const float z = (rr * m_pitch) - h * 0.5f;
            return QVector3D(x, baseY, z);
        };

        auto dotRadiusPx = [&](const QVector3D& worldCenter, const QPointF& centerPx) -> float {
            QPointF edge;
            if (!projectToScreen(worldCenter + QVector3D(m_dotRadius, 0.0f, 0.0f), edge))
                return 0.0f;
            const float dx = float(edge.x() - centerPx.x());
            const float dy = float(edge.y() - centerPx.y());
            return std::sqrt(dx * dx + dy * dy);
        };

        if (m_labelMode == LabelsAlways && valuesCopy.size() == dotCount()) {
            painter.setPen(QColor(255, 255, 255, 220));
            for (int i = 0; i < dotCount(); ++i) {
                QPointF centerPx;
                const QVector3D world = dotWorldCenter(i);
                if (!projectToScreen(world, centerPx))
                    continue;

                const float rPx = dotRadiusPx(world, centerPx);
                if (rPx < 12.0f)
                    continue;

                const QString text = QString::number(int(valuesCopy[i] + 0.5f));
                drawLabel(centerPx, QPointF(0.0, 0.0), text);
            }
        }

        if (m_hoveredIndex >= 0 && m_hoveredIndex < dotCount() && valuesCopy.size() == dotCount()) {
            QPointF centerPx;
            const QVector3D world = dotWorldCenter(m_hoveredIndex);
            if (projectToScreen(world, centerPx)) {
                const float rPx = dotRadiusPx(world, centerPx);

                painter.setBrush(Qt::NoBrush);
                painter.setPen(QPen(QColor(255, 255, 255, 210), 1.5));
                painter.drawEllipse(centerPx, rPx * 1.08f, rPx * 1.08f);

                if (m_labelMode == LabelsHover) {
                    const QString text = QString::number(int(valuesCopy[m_hoveredIndex] + 0.5f));
                    drawLabel(centerPx, QPointF(0.0, -rPx - 12.0f), text);
                }
            }
        }
    }
}

void GLWidget::mousePressEvent(QMouseEvent *event) {
    m_lastPos = event->pos();
    if (event->button() == Qt::RightButton) {
        m_rightDown = true;
        event->accept();
        return;
    }
    if (event->button() == Qt::LeftButton) {
        QVector3D world;
        const int index = pickDotIndex_(event->pos(), &world);
        qInfo() << "clicked index: " << index;
        if (index >= 0) {
            float value = 0.0f;
            int row = 0;
            int col = 0;
            if (m_cols > 0) {
                row = index / m_cols;
                col = index % m_cols;
            }
            {
                QMutexLocker lk(&m_dataMutex);
                if (index < m_latestValues.size())
                    value = m_latestValues[index];
            }
            emit dotClicked(index, row, col, value);
        }
    }
    QOpenGLWidget::mousePressEvent(event);
}

void GLWidget::mouseMoveEvent(QMouseEvent *event) {
    const QPoint delta = event->pos() - m_lastPos;
    m_lastPos = event->pos();

    if (m_rightDown) {
        m_camYawDeg += delta.x() * 0.3f;
        m_camPitchDeg = qBound(-89.0f, m_camPitchDeg + delta.y() * 0.3f, 89.0f);
        emit yawChanged();
        update();
        event->accept();
        return;
    }

    if (m_labelMode != LabelsOff && dotCount() > 0) {
        auto projectToScreen = [&](const QVector3D& world, QPointF& out) -> bool {
            const QVector4D clip = m_mvp * QVector4D(world, 1.0f);
            if (clip.w() <= 1e-6f)
                return false;
            const QVector3D ndc = clip.toVector3D() / clip.w();
            if (ndc.z() < -1.2f || ndc.z() > 1.2f)
                return false;

            out.setX((ndc.x() * 0.5f + 0.5f) * float(width()));
            out.setY((1.0f - (ndc.y() * 0.5f + 0.5f)) * float(height()));
            return true;
        };

        const QPoint mousePos = event->pos();
        const float baseY = (m_panelH * 0.5f) + 0.001f;
        const float w = (m_cols - 1) * m_pitch;
        const float h = (m_rows - 1) * m_pitch;

        int best = -1;
        float bestDist2 = std::numeric_limits<float>::infinity();
        for (int i = 0; i < dotCount(); ++i) {
            const int rr = (m_cols > 0) ? (i / m_cols) : 0;
            const int cc = (m_cols > 0) ? (i % m_cols) : 0;
            const float x = (cc * m_pitch) - w * 0.5f;
            const float z = (rr * m_pitch) - h * 0.5f;

            QPointF center;
            const QVector3D worldCenter(x, baseY, z);
            if (!projectToScreen(worldCenter, center))
                continue;

            QPointF edge;
            if (!projectToScreen(worldCenter + QVector3D(m_dotRadius, 0.0f, 0.0f), edge))
                continue;

            const float radDx = float(edge.x() - center.x());
            const float radDy = float(edge.y() - center.y());
            const float radPx = std::sqrt(radDx * radDx + radDy * radDy);
            const float threshold = radPx + 6.0f;

            const float dx = float(mousePos.x()) - float(center.x());
            const float dy = float(mousePos.y()) - float(center.y());
            const float dist2 = dx * dx + dy * dy;
            if (dist2 <= threshold * threshold && dist2 < bestDist2) {
                best = i;
                bestDist2 = dist2;
            }
        }

        if (best != m_hoveredIndex) {
            m_hoveredIndex = best;
            update();
        }
    }

    QOpenGLWidget::mouseMoveEvent(event);
}

void GLWidget::mouseReleaseEvent(QMouseEvent *event) {
    if (event->button() == Qt::RightButton) {
        m_rightDown = false;
        event->accept();
        return;
    }
    QOpenGLWidget::mouseReleaseEvent(event);
}

void GLWidget::wheelEvent(QWheelEvent *event) {
    const float steps = event->angleDelta().y() / 120.0f;
    const float factor = std::pow(0.9f, steps);
    m_zoom_ = qBound(0.2f, m_zoom_ * factor, 90.0f);
    update();
    event->accept();
}

bool GLWidget::projectToScreen_(const QVector3D& world, QPointF* out) const {
    if (!out)
        return false;
    const QVector4D clip = m_mvp * QVector4D(world, 1.0f);
    if (clip.w() <= 1e-6f)
        return false;
    const QVector3D ndc = clip.toVector3D() / clip.w();
    if (ndc.z() < -1.2f || ndc.z() > 1.2f)
        return false;

    out->setX((ndc.x() * 0.5f + 0.5f) * float(width()));
    out->setY((1.0f - (ndc.y() * 0.5f + 0.5f)) * float(height()));
    return true;
}

int GLWidget::pickDotIndex_(const QPoint& pos, QVector3D* worldOut) const {
    if (dotCount() <= 0)
        return -1;

    const float baseY = (m_panelH * 0.5f) + 0.001f;
    const float w = (m_cols - 1) * m_pitch;
    const float h = (m_rows - 1) * m_pitch;

    int best = -1;
    float bestDist2 = std::numeric_limits<float>::infinity();
    QVector3D bestWorld;

    for (int i = 0; i < dotCount(); ++i) {
        const int rr = (m_cols > 0) ? (i / m_cols) : 0;
        const int cc = (m_cols > 0) ? (i % m_cols) : 0;
        const QVector3D worldCenter(
            (cc * m_pitch) - w * 0.5f,
            baseY,
            (rr * m_pitch) - h * 0.5f
        );

        QPointF center;
        if (!projectToScreen_(worldCenter, &center))
            continue;

        QPointF edge;
        if (!projectToScreen_(worldCenter + QVector3D(m_dotRadius, 0.0f, 0.0f), &edge))
            continue;

        const float radDx = float(edge.x() - center.x());
        const float radDy = float(edge.y() - center.y());
        const float radPx = std::sqrt(radDx * radDx + radDy * radDy);
        const float threshold = radPx + 6.0f;

        const float dx = float(pos.x()) - float(center.x());
        const float dy = float(pos.y()) - float(center.y());
        const float dist2 = dx * dx + dy * dy;
        if (dist2 <= threshold * threshold && dist2 < bestDist2) {
            best = i;
            bestDist2 = dist2;
            bestWorld = worldCenter;
        }
    }

    if (best >= 0 && worldOut)
        *worldOut = bestWorld;
    return best;
}

void GLWidget::initBackgroundGeometry_() {
    if (m_bgVbo) {
        glDeleteBuffers(1, &m_bgVbo);
        m_bgVbo = 0;
    }
    if (m_bgVao) {
        glDeleteVertexArrays(1, &m_bgVao);
        m_bgVao = 0;
    }

    // 全屏 quad（两个三角形），坐标直接是裁剪空间 NDC [-1,1]
    const float verts[] = {
        -1.0f, -1.0f,
         1.0f, -1.0f,
         1.0f,  1.0f,
        -1.0f, -1.0f,
         1.0f,  1.0f,
        -1.0f,  1.0f,
    };

    glGenVertexArrays(1, &m_bgVao);
    glBindVertexArray(m_bgVao);

    glGenBuffers(1, &m_bgVbo);
    glBindBuffer(GL_ARRAY_BUFFER, m_bgVbo);
    glBufferData(GL_ARRAY_BUFFER, sizeof(verts), verts, GL_STATIC_DRAW);

    glEnableVertexAttribArray(0);
    glVertexAttribPointer(0, 2, GL_FLOAT, GL_FALSE, 2 * sizeof(float), (void*)0);

    glBindVertexArray(0);
}

void GLWidget::initPanelGeometry_() {
    // panel：目前只画“顶面矩形”，y 固定在 +panelH/2
    if (m_panelIbo) {
        glDeleteBuffers(1, &m_panelIbo);
        m_panelIbo = 0;
    }
    if (m_panelVbo) {
        glDeleteBuffers(1, &m_panelVbo);
        m_panelVbo = 0;
    }
    if (m_panelVao) {
        glDeleteVertexArrays(1, &m_panelVao);
        m_panelVao = 0;
    }

    const float y = m_panelH * 0.5f;
    const float hw = m_panelW * 0.5;
    const float hd = m_panelD * 0.5f;

    struct V {
        float x, y, z;
        float nx, ny, nz;
    };
    V verts[24] = {
        // +Y 顶面 (normal 0, +1, 0)
        {-hw, +y, -hd,  0, +1,  0}, // 0
        {+hw, +y, -hd,  0, +1,  0}, // 1
        {+hw, +y, +hd,  0, +1,  0}, // 2
        {-hw, +y, +hd,  0, +1,  0}, // 3

        // +Z 前面 (normal 0, 0, +1)
        {-hw, +y, +hd,  0,  0, +1}, // 4
        {+hw, +y, +hd,  0,  0, +1}, // 5
        {+hw, -y, +hd,  0,  0, +1}, // 6
        {-hw, -y, +hd,  0,  0, +1}, // 7

        // -Y 底面 (normal 0, -1, 0)
        {-hw, -y, +hd,  0, -1,  0}, // 8
        {+hw, -y, +hd,  0, -1,  0}, // 9
        {+hw, -y, -hd,  0, -1,  0}, // 10
        {-hw, -y, -hd,  0, -1,  0}, // 11

        // -Z 后面 (normal 0, 0, -1)
        {+hw, +y, -hd,  0,  0, -1}, // 12
        {-hw, +y, -hd,  0,  0, -1}, // 13
        {-hw, -y, -hd,  0,  0, -1}, // 14
        {+hw, -y, -hd,  0,  0, -1}, // 15

        // -X 左面 (normal -1, 0, 0)
        {-hw, +y, -hd, -1,  0,  0}, // 16
        {-hw, +y, +hd, -1,  0,  0}, // 17
        {-hw, -y, +hd, -1,  0,  0}, // 18
        {-hw, -y, -hd, -1,  0,  0}, // 19

        // +X 右面 (normal +1, 0, 0)
        {+hw, +y, +hd, +1,  0,  0}, // 20
        {+hw, +y, -hd, +1,  0,  0}, // 21
        {+hw, -y, -hd, +1,  0,  0}, // 22
        {+hw, -y, +hd, +1,  0,  0}, // 23
    };

    unsigned int idx[36] = {
        0, 1, 2,  0, 2, 3,       // top
        4, 5, 6,  4, 6, 7,       // front
        8, 9, 10, 8, 10,11,      // bottom
        12,13,14, 12,14,15,      // back
        16,17,18, 16,18,19,      // left
        20,21,22, 20,22,23       // right
    };

    m_panelIndexCount = 36;

    glGenVertexArrays(1, &m_panelVao);
    glBindVertexArray(m_panelVao);

    glGenBuffers(1, &m_panelVbo);
    glBindBuffer(GL_ARRAY_BUFFER, m_panelVbo);
    glBufferData(GL_ARRAY_BUFFER, sizeof(verts), verts, GL_STATIC_DRAW);

    glGenBuffers(1, &m_panelIbo);
    glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, m_panelIbo);
    glBufferData(GL_ELEMENT_ARRAY_BUFFER, sizeof(idx), idx, GL_STATIC_DRAW);

    // attribute layout:
    // location 0: position (x,y,z)
    // location 1: normal   (nx,ny,nz) —— 当前 shader 没用到，先留着
    glEnableVertexAttribArray(0);
    glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, sizeof(V), (void*)0);
    glEnableVertexAttribArray(1);
    glVertexAttribPointer(1, 3, GL_FLOAT, GL_FALSE, sizeof(V), (void*)(3*sizeof(float)));
    glBindVertexArray(0);
}

void GLWidget::initDotGeometry_() {
    // dot：使用 instanced rendering 画很多个“圆点”（本质是一个 quad + fragment shader 里 discard 成圆）
    // vertex buffer 里只有一个单位 quad，instance buffer 里存每个点的位置和数值。
    if (m_instanceVbo) {
        glDeleteBuffers(1, &m_instanceVbo);
        m_instanceVbo = 0;
    }
    if (m_dotsVbo) {
        glDeleteBuffers(1, &m_dotsVbo);
        m_dotsVbo = 0;
    }
    if (m_dotsVao) {
        glDeleteVertexArrays(1, &m_dotsVao);
        m_dotsVao = 0;
    }

    struct V {
        float x, y;
        float u, v;
    };
    V quad[6] = {
        {-1,-1, 0,0},
        { 1,-1, 1,0},
        { 1, 1, 1,1},
        {-1,-1, 0,0},
        { 1, 1, 1,1},
        {-1, 1, 0,1},
    };

    glGenVertexArrays(1, &m_dotsVao);
    glBindVertexArray(m_dotsVao);
    glGenBuffers(1, &m_dotsVbo);
    glBindBuffer(GL_ARRAY_BUFFER, m_dotsVbo);
    glBufferData(GL_ARRAY_BUFFER, sizeof(quad), quad, GL_STATIC_DRAW);

    // attribute layout:
    // location 0: quad 顶点位置 (x,y)，范围 [-1,1]
    // location 1: UV (u,v)，用于 fragment shader 生成圆形
    glEnableVertexAttribArray(0);
    glVertexAttribPointer(0, 2, GL_FLOAT, GL_FALSE, sizeof(V), (void*)0);
    glEnableVertexAttribArray(1);
    glVertexAttribPointer(1, 2, GL_FLOAT, GL_FALSE, sizeof(V), (void*)(2 * sizeof(float)));

    // instance buffer：每个点 3 个 float（offsetX, offsetZ, value）
    // layout location 2/3 对应 shader 里的 iOffsetXZ / iValue
    glGenBuffers(1, &m_instanceVbo);
    glBindBuffer(GL_ARRAY_BUFFER, m_instanceVbo);
    glBufferData(GL_ARRAY_BUFFER, sizeof(float) * 3 * qMax(1, dotCount()), nullptr, GL_DYNAMIC_DRAW);

    // location 2: vec2 iOffsetXZ（每个 instance 一次，divisor=1）
    glEnableVertexAttribArray(2);
    glVertexAttribPointer(2, 2, GL_FLOAT, GL_FALSE, 3 * sizeof(float), (void*)0);
    glVertexAttribDivisor(2, 1);

    // location 3: float iValue（每个 instance 一次，divisor=1）
    glEnableVertexAttribArray(3);
    glVertexAttribPointer(3, 1, GL_FLOAT, GL_FALSE, 3 * sizeof(float), (void*)(2 * sizeof(float)));
    glVertexAttribDivisor(3, 1);

    glBindVertexArray(0);
}
void GLWidget::initDotTexture_() {
    if (m_dotTex) {
        glDeleteTextures(1, &m_dotTex);
        m_dotTex = 0;
    }

    const QString path = QStringLiteral(":/images/metal.jpeg");
    QImage img(path);
    if (img.isNull()) {
        qWarning() << "dot texture load failed:" << path;
        return;
    }

    QImage rgba = img.convertToFormat(QImage::Format_RGBA8888);
    glGenTextures(1, &m_dotTex);
    glBindTexture(GL_TEXTURE_2D, m_dotTex);
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR_MIPMAP_LINEAR);
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
    glPixelStorei(GL_UNPACK_ALIGNMENT, 1);
    glTexImage2D(
        GL_TEXTURE_2D,
        0,
        GL_RGBA8,
        rgba.width(),
        rgba.height(),
        0,
        GL_RGBA,
        GL_UNSIGNED_BYTE,
        rgba.constBits()
    );
    glGenerateMipmap(GL_TEXTURE_2D);
    glBindTexture(GL_TEXTURE_2D, 0);
}

void GLWidget::initRoomGeometry_() {
    qInfo() << "initRoomGeometry_()";
    if (room_vao) {
        glDeleteVertexArrays(1, &room_vao);
        room_vao = 0;
    }
    if (room_vbo) {
        glDeleteBuffers(1, &room_vbo);
        room_vbo = 0;
    }
    if (room_ibo) {
        glDeleteBuffers(1, &room_ibo);
        room_ibo = 0;
    }

    using V = struct {
        float x, y, z;
        float nx, ny, nz;
    };

    V verts[24] = {
            // floor (y = -1), normal +Y
            {-1, -1, -1,  0, +1,  0},
            {+1, -1, -1,  0, +1,  0},
            {+1, -1, +1,  0, +1,  0},
            {-1, -1, +1,  0, +1,  0},

            // ceiling (y = +1), normal -Y
            {-1, +1, +1,  0, -1,  0},
            {+1, +1, +1,  0, -1,  0},
            {+1, +1, -1,  0, -1,  0},
            {-1, +1, -1,  0, -1,  0},

            // back wall (z = -1), normal +Z
            {-1, +1, -1,  0,  0, +1},
            {+1, +1, -1,  0,  0, +1},
            {+1, -1, -1,  0,  0, +1},
            {-1, -1, -1,  0,  0, +1},

            // front wall (z = +1), normal -Z
            {+1, +1, +1,  0,  0, -1},
            {-1, +1, +1,  0,  0, -1},
            {-1, -1, +1,  0,  0, -1},
            {+1, -1, +1,  0,  0, -1},

            // left wall (x = -1), normal +X
            {-1, +1, +1, +1,  0,  0},
            {-1, +1, -1, +1,  0,  0},
            {-1, -1, -1, +1,  0,  0},
            {-1, -1, +1, +1,  0,  0},

            // right wall (x = +1), normal -X
            {+1, +1, -1, -1,  0,  0},
            {+1, +1, +1, -1,  0,  0},
            {+1, -1, +1, -1,  0,  0},
            {+1, -1, -1, -1,  0,  0},
        };
    unsigned int idx[36] = {
        0, 1, 2, 0, 2, 3,
        4, 5, 6, 4, 6, 7,
        8, 9, 10, 8, 10, 11,
        12, 13, 14, 12, 14, 15,
        16, 17, 18, 16, 18, 19,
        20, 21, 22, 20, 22, 23
    };
    room_index_count = 36;

    glGenVertexArrays(1, &room_vao);
    glBindVertexArray(room_vao);

    glGenBuffers(1, &room_vbo);
    glBindBuffer(GL_ARRAY_BUFFER, room_vbo);
    glBufferData(GL_ARRAY_BUFFER, sizeof(verts), verts, GL_STATIC_DRAW);

    glGenBuffers(1, &room_ibo);
    glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, room_ibo);
    glBufferData(GL_ELEMENT_ARRAY_BUFFER, sizeof(idx), idx, GL_STATIC_DRAW);

    glEnableVertexAttribArray(0);
    glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, sizeof(V), (void*)0);
    glEnableVertexAttribArray(1);
    glVertexAttribPointer(1, 3, GL_FLOAT, GL_FALSE, sizeof(V), (void*)(3 * sizeof(float)));

    glBindVertexArray(0);
}
void GLWidget::initPrograms_() {
    // Qt Resource 里打包的 shader 文件路径：使用 `:/` 前缀（不是文件系统路径）
    const QString vsd_path = QStringLiteral(":/shaders/dots.vert");
    const QString fsd_path = QStringLiteral(":/shaders/dots.frag");
    const QString vsb_path = QStringLiteral(":/shaders/bg.vert");
    const QString fsb_path = QStringLiteral(":/shaders/bg.frag");
    const QString vsp_path = QStringLiteral(":/shaders/panel.vert");
    const QString fsp_path = QStringLiteral(":/shaders/panel.frag");
    const QString vsr_path = QStringLiteral(":/shaders/room.vert");
    const QString fsr_path = QStringLiteral(":/shaders/room.frag");

    {
        auto *p = new QOpenGLShaderProgram;
        const bool okV = p->addShaderFromSourceCode(QOpenGLShader::Vertex, readFile(vsb_path));
        const bool okF = p->addShaderFromSourceCode(QOpenGLShader::Fragment, readFile(fsb_path));
        const bool okL = okV && okF && p->link();
        if (!okL) {
            qWarning() << "bg program build failed:" << vsb_path << fsb_path << p->log();
            delete p;
            p = nullptr;
        }
        m_bgProg = p;
    }
    {
        auto *p = new QOpenGLShaderProgram;
        const bool okV = p->addShaderFromSourceCode(QOpenGLShader::Vertex, readFile(vsp_path));
        const bool okF = p->addShaderFromSourceCode(QOpenGLShader::Fragment, readFile(fsp_path));
        const bool okL = okV && okF && p->link();
        if (!okL) {
            qWarning() << "panel program build failed:" << vsp_path << fsp_path << p->log();
            delete p;
            p = nullptr;
        }
        m_panelProg = p;
    }
    {
        auto *p = new QOpenGLShaderProgram;
        const bool okV = p->addShaderFromSourceCode(QOpenGLShader::Vertex, readFile(vsd_path));
        const bool okF = p->addShaderFromSourceCode(QOpenGLShader::Fragment, readFile(fsd_path));
        const bool okL = okV && okF && p->link();
        if (!okL) {
            qWarning() << "dots program build failed:" << vsd_path << fsd_path << p->log();
            delete p;
            p = nullptr;
        }
        m_dotsProg = p;
    }
    {
        auto *p = new QOpenGLShaderProgram;
        const bool okV = p->addShaderFromSourceCode(QOpenGLShader::Vertex, readFile(vsr_path));
        const bool okF = p->addShaderFromSourceCode(QOpenGLShader::Fragment, readFile(fsr_path));
        const bool okL = okV && okF && p->link();
        if (!okL) {
            qWarning() << "dots program build failed:" << vsr_path << fsr_path << p->log();
            delete p;
            p = nullptr;
        }
        m_roomProg = p;
    }
}

void GLWidget::updateInstanceBufferIfNeeded_() {
    if (dotCount() <= 0) {
        m_instanceCount = 0;
        return;
    }

    QVector<float> valuesCopy;
    bool dirty = false;
    {
        QMutexLocker lk(&m_dataMutex);
        dirty = m_valuesDirty;
        if (dirty) {
            valuesCopy = m_latestValues;
            m_valuesDirty = false;
        }
    }
    if (!dirty)
        return;

    const int n = dotCount();
    m_instanceCount = n;
    QVector<float> inst;
    // 每个点 3 个 float：offsetX, offsetZ, value（对应 dots.vert: iOffsetXZ + iValue）
    inst.resize(n * 3);

    const float w = (m_cols - 1) * m_pitch;
    const float h = (m_rows - 1) * m_pitch;

    // 把点阵居中到原点附近（x/z 以中心对称）
    for (int i = 0; i < n; ++i) {
        const int r = (m_cols > 0) ? (i / m_cols) : 0;
        const int c = (m_cols > 0) ? (i % m_cols) : 0;

        const float x = (c * m_pitch) - w * 0.5f;
        const float z = (r * m_pitch) - h * 0.5f;

        inst[i * 3 + 0] = x;
        inst[i * 3 + 1] = z;
        inst[i * 3 + 2] = (i < valuesCopy.size()) ? valuesCopy[i] : m_min;
    }

    // 把 CPU 生成的 instance 数据上传到 GPU（后续 draw 时由 VAO 里的 attribute 2/3 读取）
    glBindBuffer(GL_ARRAY_BUFFER, m_instanceVbo);
    glBufferSubData(GL_ARRAY_BUFFER, 0, inst.size() * sizeof(float), inst.constData());
}

void GLWidget::updateMatrices_() {
    // MVP = Projection * View * Model
    //
    // OpenGL 的顶点最终要写到 gl_Position（裁剪空间），所以我们需要一个矩阵把“世界坐标”变成“屏幕可见”的坐标。
    // 这里为了入门简单：
    // - panel/dots 顶点数据直接当作世界坐标（Model=Identity）
    // - View 用 lookAt 放一个相机
    // - Projection 用透视投影（perspective）
    const int w = width();
    const int h = height();
    if (w <= 0 || h <= 0) {
        m_mvp.setToIdentity();
        return;
    }

    const float aspect = float(w) / float(h);
    const float radius = 0.5f * qSqrt(m_panelW * m_panelW + m_panelD * m_panelD);
    const float distance = qMax(0.5f, radius * 2.5f);

    // 让相机看向 panel 的中心点
    const QVector3D center(0.0f, 0.0f, 0.0f);

    // yaw/pitch 控制相机绕目标点“环绕”（orbit camera）
    const float yawRad = qDegreesToRadians(m_camYawDeg);
    const float pitchRad = qDegreesToRadians(m_camPitchDeg);
    const float cosPitch = qCos(pitchRad);
    const float sinPitch = qSin(pitchRad);

    const QVector3D eye = center + QVector3D(
        distance * cosPitch * qCos(yawRad),
        distance * sinPitch,
        distance * cosPitch * qSin(yawRad)
    );
    m_cameraPos = eye;

    QMatrix4x4 view;
    view.lookAt(eye, center, QVector3D(0.0f, 1.0f, 0.0f));

    QMatrix4x4 proj;
    // fov=45°，near=0.01，far=足够大（保证 panel + dots 在裁剪范围内）
    proj.perspective(m_zoom_, aspect, 0.01f, qMax(10.0f, distance * 10.0f));

    m_mvp = proj * view;
}

void GLWidget::updateRoom_(){
    if (!m_roomProg || !room_vao || room_index_count <= 0) {
        return;
    }

    m_roomProg->bind();

    const float base = std::max({ m_panelW, m_panelH, m_panelD });
    const QVector3D roomHalfSize(
        std::max(1.0f, base * 1.5f),
        std::max(1.0f, base * 1.5f),
        std::max(1.0f, base * 1.5f)
    );

    const float minorStep = std::max(0.05f, base * 0.25f);
    const float majorStep = minorStep * 5.0f;

    m_roomProg->setUniformValue("uMVP", m_mvp);
    m_roomProg->setUniformValue("uCameraPos", m_cameraPos);
    m_roomProg->setUniformValue("uRoomHalfSize", roomHalfSize);
    m_roomProg->setUniformValue("uMinorStep", minorStep);
    m_roomProg->setUniformValue("uMajorStep", majorStep);
    m_roomProg->setUniformValue("uRenderMode", 1);
    m_roomProg->setUniformValue("uLightMode", m_lightMode);
    m_roomProg->setUniformValue("uShowGrid", m_showGrid);

    glBindVertexArray(room_vao);
    glDrawElements(GL_TRIANGLES, room_index_count, GL_UNSIGNED_INT, nullptr);
    glBindVertexArray(0);
    m_roomProg->release();
}

void GLWidget::setShowGrid(bool on) {
    if (m_showGrid == on)
        return;

    m_showGrid = on;
    update();
}

void GLWidget::setRow(int row) {
    row = qMax(0, row);
    if (m_rows == row)
        return;
    setSpec(row, m_cols, m_pitch, m_dotRadius);
}

void GLWidget::setCol(int col) {
    col = qMax(0, col);
    if (m_cols == col)
        return;
    setSpec(m_rows, col, m_pitch, m_dotRadius);
}