#include "MultibandRasterRenderer.h"
#include "RasterDataProvider.h"
#include <QDebug>
#include <algorithm>

MultibandRasterRenderer::MultibandRasterRenderer(RasterDataProvider* provider)
    : RasterRendererBase(provider)
{
}

void MultibandRasterRenderer::stretchTo8bit(const std::vector<float>& in, std::vector<unsigned char>& out, float minVal, float maxVal)
{
    size_t n = in.size();
    out.resize(n);
    if (maxVal <= minVal)
    {
        std::fill(out.begin(), out.end(), 0);
        return;
    }
    float denom = 1.0f / (maxVal - minVal);
    for (size_t i = 0; i < n; ++i)
    {
        float v = (in[i] - minVal) * denom;
        v = std::min(std::max(v, 0.0f), 1.0f);
        out[i] = static_cast<unsigned char>(v * 255.0f);
    }
}

QImage MultibandRasterRenderer::render()
{
    if (!m_provider) return QImage();
    int bands = m_provider->bandCount();
    int w = m_provider->width();
    int h = m_provider->height();
    if (w <= 0 || h <= 0) return QImage();

    // Find nearest bands for requested wavelengths if wavelengths available
    std::vector<double> wavelengths = m_provider->bandWavelengths();

    auto chooseBandIndexForWave = [&](double wave)->int {
        if (wavelengths.empty()) {
            // fallback: select R,G,B as first three bands
            if (bands >= 3) return (wave==m_params.rWave?0:(wave==m_params.gWave?1:2));
            if (bands >= 1) return 0;
            return -1;
        }
        int best = -1; double bestDiff = 1e12;
        for (int i = 0; i < (int)wavelengths.size(); ++i) {
            if (wavelengths[i] < 0) continue;
            double d = std::abs(wavelengths[i] - wave);
            if (d < bestDiff) { bestDiff = d; best = i; }
        }
        if (best >= 0) return best;
        // fallback
        return std::min(2, bands-1);
    };

    int rIdx = chooseBandIndexForWave(m_params.rWave);
    int gIdx = chooseBandIndexForWave(m_params.gWave);
    int bIdx = chooseBandIndexForWave(m_params.bWave);

    std::vector<float> rbuf, gbuf, bbuf;
    if (rIdx >= 0) m_provider->readBandAsFloat(rIdx, rbuf);
    if (gIdx >= 0) m_provider->readBandAsFloat(gIdx, gbuf);
    if (bIdx >= 0) m_provider->readBandAsFloat(bIdx, bbuf);

    std::vector<unsigned char> r8, g8, b8;
    float minV = static_cast<float>(m_params.minValue);
    float maxV = static_cast<float>(m_params.maxValue);
    if (!rbuf.empty()) stretchTo8bit(rbuf, r8, minV, maxV);
    if (!gbuf.empty()) stretchTo8bit(gbuf, g8, minV, maxV);
    if (!bbuf.empty()) stretchTo8bit(bbuf, b8, minV, maxV);

    QImage out(w, h, QImage::Format_RGB888);
    for (int y = 0; y < h; ++y) {
        unsigned char* scan = out.scanLine(y);
        for (int x = 0; x < w; ++x) {
            int idx = y * w + x;
            unsigned char rc = (r8.size() > (size_t)idx) ? r8[idx] : 0;
            unsigned char gc = (g8.size() > (size_t)idx) ? g8[idx] : 0;
            unsigned char bc = (b8.size() > (size_t)idx) ? b8[idx] : 0;
            scan[x*3 + 0] = rc;
            scan[x*3 + 1] = gc;
            scan[x*3 + 2] = bc;
        }
    }
    return out;
}