#include "RasterImageLayer.h"
#include "RasterLayer.h"
#include "RasterDataProvider.h"
#include "RasterRendererBase.h"
#include "MultibandRasterRenderer.h"
#include "SinglebandRasterRenderer.h"

RasterImageLayer::RasterImageLayer(RasterLayer* layer, RendererType type, bool initRenderParamsFromFile)
    : m_layer(layer)
    , m_rendererType(type)
    , m_rendererInitialized(false)
{
    if (initRenderParamsFromFile)
    {
        // 此处根据头文件（打开影像文件）修改默认渲染波段，只对打开文件的情况下有效；
        // 当边采集边显示时（initRenderParamsFromFile设置为false），应该在实例化RasterImageLayer后调用setMultibandParams设置默认渲染波段
        try
        {
            if (!m_layer) return;

            std::vector<double> wavelengths = m_layer->bandWavelengths();
            if (wavelengths.empty()) return;

            std::sort(wavelengths.begin(), wavelengths.end());
            double m_minWave = wavelengths.front();
            double m_maxWave = wavelengths.back();

            if (m_minWave > 800 && m_maxWave > 1600)
            {
                m_multibandParams.rWave = 1500;
                m_multibandParams.gWave = 1300;
                m_multibandParams.bWave = 1100;
            }
        }
        catch (const std::exception&)
        {

        }

    }
}

void RasterImageLayer::ensureRenderer()
{
    if (m_rendererInitialized) return;
    if (!m_layer) return;

    RasterDataProvider* provider = nullptr;
    if (m_layer->dataProvider())
    {
        provider = m_layer->dataProvider();
    }
    else if (m_layer->openDataProvider())
    {
        provider = m_layer->dataProvider();
    }

    if (!provider) return;

    switch (m_rendererType)
    {
        case RendererType::Multiband:
        {
            auto* multiRenderer = new MultibandRasterRenderer(provider);
            m_renderer.reset(multiRenderer);
            multiRenderer->setParams(m_multibandParams);
            break;
        }
        case RendererType::Singleband:
        {
            auto* singleRenderer = new SinglebandRasterRenderer(provider);
            m_renderer.reset(singleRenderer);
            singleRenderer->setParams(m_singlebandParams);
            break;
        }
    }

    m_rendererInitialized = true;
}

RasterImageLayer::~RasterImageLayer()
{
    m_renderer.reset();
}

QImage RasterImageLayer::render()
{
    ensureRenderer();
    if (!m_renderer) return QImage();
    return m_renderer->render();
}

void RasterImageLayer::setMultibandParams(const MultibandRenderParams& params)
{
    m_multibandParams = params;
    if (m_rendererInitialized && m_rendererType == RendererType::Multiband) {
        auto* r = static_cast<MultibandRasterRenderer*>(m_renderer.get());
        r->setParams(params);
    }
}

void RasterImageLayer::setSinglebandParams(const SinglebandRenderParams& params)
{
    m_singlebandParams = params;
    if (m_rendererInitialized && m_rendererType == RendererType::Singleband) {
        auto* r = static_cast<SinglebandRasterRenderer*>(m_renderer.get());
        r->setParams(params);
    }
}