/*
 * Copyright 2009, Ingo Weinhold, ingo_weinhold@gmx.de.
 * Distributed under the terms of the MIT License.
 */

#include "chart/LineChartRenderer.h"

#include <stdio.h>

#include <Shape.h>
#include <View.h>

#include "chart/ChartDataSource.h"


// #pragma mark - DataSourceInfo


struct LineChartRenderer::DataSourceInfo {
public:
                        ChartDataSource*        source;
                        double*                         samples;
                        int32                           sampleCount;
                        bool                            samplesValid;
                        LineChartRendererDataSourceConfig config;

public:
                                                                DataSourceInfo(ChartDataSource* source,
                                                                        LineChartRendererDataSourceConfig* config);
                                                                ~DataSourceInfo();

                        bool                            UpdateSamples(const ChartDataRange& domain,
                                                                        int32 sampleCount);
};


LineChartRenderer::DataSourceInfo::DataSourceInfo(ChartDataSource* source,
        LineChartRendererDataSourceConfig* config)
        :
        source(source),
        samples(NULL),
        sampleCount(0),
        samplesValid(false)
{
        if (config != NULL)
                this->config = *config;
}


LineChartRenderer::DataSourceInfo::~DataSourceInfo()
{
        delete[] samples;
}


bool
LineChartRenderer::DataSourceInfo::UpdateSamples(const ChartDataRange& domain,
        int32 sampleCount)
{
        if (samplesValid)
                return true;

        // check the sample count -- we might need to realloc the sample array
        if (sampleCount != this->sampleCount) {
                delete[] samples;
                this->sampleCount = 0;

                samples = new(std::nothrow) double[sampleCount];
                if (samples == NULL)
                        return false;

                this->sampleCount = sampleCount;
        }

        // get the new samples
        source->GetSamples(domain.min, domain.max, samples, sampleCount);

        samplesValid = true;
        return true;
}


// #pragma mark - LineChartRenderer


LineChartRenderer::LineChartRenderer()
        :
        fFrame(),
        fDomain(),
        fRange()
{
}


LineChartRenderer::~LineChartRenderer()
{
}


bool
LineChartRenderer::AddDataSource(ChartDataSource* dataSource, int32 index,
        ChartRendererDataSourceConfig* config)
{
        DataSourceInfo* info = new(std::nothrow) DataSourceInfo(dataSource,
                dynamic_cast<LineChartRendererDataSourceConfig*>(config));
        if (info == NULL)
                return false;

        if (!fDataSources.AddItem(info, index)) {
                delete info;
                return false;
        }

        return true;
}


void
LineChartRenderer::RemoveDataSource(ChartDataSource* dataSource)
{
        for (int32 i = 0; DataSourceInfo* info = fDataSources.ItemAt(i); i++) {
                info->samplesValid = false;
                if (info->source == dataSource) {
                        delete fDataSources.RemoveItemAt(i);
                        return;
                }
        }
}


void
LineChartRenderer::SetFrame(const BRect& frame)
{
        fFrame = frame;
        _InvalidateSamples();
}


void
LineChartRenderer::SetDomain(const ChartDataRange& domain)
{
        if (domain != fDomain) {
                fDomain = domain;
                _InvalidateSamples();
        }
}


void
LineChartRenderer::SetRange(const ChartDataRange& range)
{
        if (range != fRange) {
                fRange = range;
                _InvalidateSamples();
        }
}


void
LineChartRenderer::Render(BView* view, BRect updateRect)
{
        if (!updateRect.IsValid() || updateRect.left > fFrame.right
                || fFrame.left > updateRect.right) {
                return;
        }

        if (fDomain.min >= fDomain.max || fRange.min >= fRange.max)
                return;

        if (!_UpdateSamples())
                return;

        // get the range to draw (draw one more sample on each side)
        int32 left = (int32)fFrame.left;
        int32 first = (int32)updateRect.left - left - 1;
        int32 last = (int32)updateRect.right - left + 1;
        if (first < 0)
                first = 0;
        if (last > fFrame.IntegerWidth())
                last = fFrame.IntegerWidth();
        if (first > last)
                return;

        double minRange = fRange.min;
        double sampleRange = fRange.max - minRange;
        if (sampleRange == 0) {
                minRange = fRange.min - 0.5;
                sampleRange = 1;
        }
        double scale = (double)fFrame.IntegerHeight() / sampleRange;

        // draw
        view->SetLineMode(B_ROUND_CAP, B_ROUND_JOIN);
        for (int32 i = 0; DataSourceInfo* info = fDataSources.ItemAt(i); i++) {

                float bottom = fFrame.bottom;
                BShape shape;
                shape.MoveTo(BPoint(left + first,
                        bottom - ((info->samples[first] - minRange) * scale)));

                for (int32 i = first; i <= last; i++) {
                        shape.LineTo(BPoint(float(left + i),
                                float(bottom - ((info->samples[i] - minRange) * scale))));
                }
                view->SetHighColor(info->config.Color());
                view->MovePenTo(B_ORIGIN);
                view->StrokeShape(&shape);
        }
}


void
LineChartRenderer::_InvalidateSamples()
{
        for (int32 i = 0; DataSourceInfo* info = fDataSources.ItemAt(i); i++)
                info->samplesValid = false;
}


bool
LineChartRenderer::_UpdateSamples()
{
        int32 width = fFrame.IntegerWidth() + 1;
        if (width <= 0)
                return false;

        for (int32 i = 0; DataSourceInfo* info = fDataSources.ItemAt(i); i++) {
                if (!info->UpdateSamples(fDomain, width))
                        return false;
        }

        return true;
}


// #pragma mark - LineChartRendererDataSourceConfig


LineChartRendererDataSourceConfig::LineChartRendererDataSourceConfig()
{
        fColor.red = 0;
        fColor.green = 0;
        fColor.blue = 0;
        fColor.alpha = 255;
}


LineChartRendererDataSourceConfig::LineChartRendererDataSourceConfig(
        const rgb_color& color)
{
        fColor = color;
}


LineChartRendererDataSourceConfig::~LineChartRendererDataSourceConfig()
{
}


const rgb_color&
LineChartRendererDataSourceConfig::Color() const
{
        return fColor;
}


void
LineChartRendererDataSourceConfig::SetColor(const rgb_color& color)
{
        fColor = color;
}