#include "RasterLayer.h"
#include "RasterDataProvider.h"

RasterLayer::RasterLayer(const QString& name, const QString& uri)
    : MapLayer(name, uri)
{
}

RasterLayer::~RasterLayer()
{
}

MapLayer::LayerType RasterLayer::layerType() const
{
    return MapLayer::LayerType::Raster;
}

RasterDataProvider* RasterLayer::dataProvider() const
{
    return m_provider ? m_provider.get() : nullptr;
}

bool RasterLayer::openDataProvider()
{
    if (!m_provider) m_provider = std::make_unique<RasterDataProvider>(dataPath());
    if (!m_provider) return false;
    return m_provider->open();
}

bool RasterLayer::isValidPixel(int x, int y)
{
    if (!m_provider) {
        if (!openDataProvider()) return false;
    }
    return m_provider->isValidPixel(x, y);
}

bool RasterLayer::readPixelSpectrum(int x, int y, QVector<double>& wavelengths, QVector<double>& spectrum)
{
    if (!m_provider) {
        if (!openDataProvider()) return false;
    }

    std::vector<double> wl;
    std::vector<double> sp;

    if (!m_provider->readPixelSpectrum(x, y, sp)) return false;

    wl = m_provider->bandWavelengths();

    wavelengths = QVector<double>::fromStdVector(wl);
    spectrum = QVector<double>::fromStdVector(sp);

    if (wavelengths.size() != spectrum.size()) {
        wavelengths.resize(spectrum.size());
        for (int i = 0; i < wavelengths.size(); ++i) {
            wavelengths[i] = i;
        }
    }

    return true;
}

bool RasterLayer::wavelengthRange(double& minWave, double& maxWave) const
{
    auto wl = bandWavelengths();
    if (wl.empty()) return false;
    minWave = *std::min_element(wl.begin(), wl.end());
    maxWave = *std::max_element(wl.begin(), wl.end());
    return true;
}

std::vector<double> RasterLayer::bandWavelengths() const
{
    if (!m_provider) {
        auto* self = const_cast<RasterLayer*>(this);
        if (!self->openDataProvider()) return {};
    }
    return m_provider->bandWavelengths();
}

int RasterLayer::width() const
{
    if (!m_provider) {
        auto* self = const_cast<RasterLayer*>(this);
        if (!self->openDataProvider()) return 0;
    }
    return m_provider->width();
}

int RasterLayer::height() const
{
    if (!m_provider) {
        auto* self = const_cast<RasterLayer*>(this);
        if (!self->openDataProvider()) return 0;
    }
    return m_provider->height();
}