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

#include "chart/Chart.h"

#include <stdio.h>

#include <new>

#include <ControlLook.h>
#include <Region.h>
#include <ScrollBar.h>
#include <Window.h>

#include "chart/ChartAxis.h"
#include "chart/ChartDataSource.h"
#include "chart/ChartRenderer.h"


// #pragma mark - Chart::AxisInfo


Chart::AxisInfo::AxisInfo()
        :
        axis(NULL)
{
}


void
Chart::AxisInfo::SetFrame(float left, float top, float right, float bottom)
{
        frame.Set(left, top, right, bottom);
        if (axis != NULL)
                axis->SetFrame(frame);
}


void
Chart::AxisInfo::SetRange(const ChartDataRange& range)
{
        if (axis != NULL)
                axis->SetRange(range);
}


void
Chart::AxisInfo::Render(BView* view, const BRect& updateRect)
{
        if (axis != NULL)
                axis->Render(view, updateRect);
}


// #pragma mark - Chart


Chart::Chart(ChartRenderer* renderer, const char* name)
        :
        BView(name, B_FRAME_EVENTS | B_WILL_DRAW | B_FULL_UPDATE_ON_RESIZE),
        fRenderer(renderer),
        fHScrollSize(0),
        fVScrollSize(0),
        fHScrollValue(0),
        fVScrollValue(0),
        fIgnoreScrollEvent(0),
        fDomainZoomLimit(0),
        fLastMousePos(-1, -1),
        fDraggingStartPos(-1, -1)
{
        SetViewColor(B_TRANSPARENT_32_BIT);

//      fRenderer->SetFrame(Bounds());
}


Chart::~Chart()
{
}


bool
Chart::AddDataSource(ChartDataSource* dataSource, int32 index,
        ChartRendererDataSourceConfig* config)
{
        if (dataSource == NULL)
                return false;

        if (index < 0 || index > fDataSources.CountItems())
                index = fDataSources.CountItems();

        if (!fDataSources.AddItem(dataSource, index))
                return false;

        if (!fRenderer->AddDataSource(dataSource, index, config)) {
                fDataSources.RemoveItemAt(index);
                return false;
        }

        _UpdateDomainAndRange();

        InvalidateLayout();
        Invalidate();

        return true;
}


bool
Chart::AddDataSource(ChartDataSource* dataSource,
        ChartRendererDataSourceConfig* config)
{
        return AddDataSource(dataSource, -1, config);
}


bool
Chart::RemoveDataSource(ChartDataSource* dataSource)
{
        if (dataSource == NULL)
                return false;

        return RemoveDataSource(fDataSources.IndexOf(dataSource));
}


ChartDataSource*
Chart::RemoveDataSource(int32 index)
{
        if (index < 0 || index >= fDataSources.CountItems())
                return NULL;

        ChartDataSource* dataSource = fDataSources.RemoveItemAt(index);

        fRenderer->RemoveDataSource(dataSource);

        _UpdateDomainAndRange();

        Invalidate();

        return dataSource;
}


void
Chart::RemoveAllDataSources()
{
        int32 count = fDataSources.CountItems();
        for (int32 i = count - 1; i >= 0; i--)
                fRenderer->RemoveDataSource(fDataSources.ItemAt(i));

        fDataSources.MakeEmpty();

        _UpdateDomainAndRange();

        InvalidateLayout();
        Invalidate();
}


void
Chart::SetAxis(ChartAxisLocation location, ChartAxis* axis)
{
        switch (location) {
                case CHART_AXIS_LEFT:
                        fLeftAxis.axis = axis;
                        break;
                case CHART_AXIS_TOP:
                        fTopAxis.axis = axis;
                        break;
                case CHART_AXIS_RIGHT:
                        fRightAxis.axis = axis;
                        break;
                case CHART_AXIS_BOTTOM:
                        fBottomAxis.axis = axis;
                        break;
                default:
                        return;
        }

        axis->SetLocation(location);

        InvalidateLayout();
        Invalidate();
}


void
Chart::SetDisplayDomain(ChartDataRange domain)
{
        // sanitize the supplied range
        if (domain.IsValid() && domain.Size() < fDomain.Size()) {
                if (domain.min < fDomain.min)
                        domain.OffsetTo(fDomain.min);
                else if (domain.max > fDomain.max)
                        domain.OffsetBy(fDomain.max - domain.max);
        } else
                domain = fDomain;

        if (domain == fDisplayDomain)
                return;

        fDisplayDomain = domain;

        fRenderer->SetDomain(fDisplayDomain);
        fTopAxis.SetRange(fDisplayDomain);
        fBottomAxis.SetRange(fDisplayDomain);

        _UpdateScrollBar(true);

        InvalidateLayout();
        Invalidate();
}


void
Chart::SetDisplayRange(ChartDataRange range)
{
        // sanitize the supplied range
        if (range.IsValid() && range.Size() < fRange.Size()) {
                if (range.min < fRange.min)
                        range.OffsetTo(fRange.min);
                else if (range.max > fRange.max)
                        range.OffsetBy(fRange.max - range.max);
        } else
                range = fRange;

        if (range == fDisplayRange)
                return;

        fDisplayRange = range;

        fRenderer->SetRange(fDisplayRange);
        fLeftAxis.SetRange(fDisplayRange);
        fRightAxis.SetRange(fDisplayRange);

        _UpdateScrollBar(false);

        InvalidateLayout();
        Invalidate();
}


double
Chart::DomainZoomLimit() const
{
        return fDomainZoomLimit;
}


void
Chart::SetDomainZoomLimit(double limit)
{
        fDomainZoomLimit = limit;
}


void
Chart::DomainChanged()
{
        if (ScrollBar(B_HORIZONTAL) != NULL && fDisplayDomain.IsValid())
                SetDisplayDomain(fDisplayDomain);
        else
                SetDisplayDomain(fDomain);
}


void
Chart::RangeChanged()
{
        if (ScrollBar(B_VERTICAL) != NULL && fDisplayRange.IsValid())
                SetDisplayRange(fDisplayRange);
        else
                SetDisplayRange(fRange);
}


void
Chart::MessageReceived(BMessage* message)
{
        switch (message->what) {
                case B_MOUSE_WHEEL_CHANGED:
                {
                        // We're only interested in Shift + vertical wheel, if the mouse
                        // is in the chart frame.
                        float deltaY;
                        if ((modifiers() & B_SHIFT_KEY) == 0
                                || message->FindFloat("be:wheel_delta_y", &deltaY) != B_OK
                                || !fChartFrame.InsetByCopy(1, 1).Contains(fLastMousePos)) {
                                break;
                        }

                        _Zoom(fLastMousePos.x, deltaY);

                        return;
                }
        }

        BView::MessageReceived(message);
}


void
Chart::FrameResized(float newWidth, float newHeight)
{
//printf("Chart::FrameResized(%f, %f)\n", newWidth, newHeight);
//      fRenderer->SetFrame(Bounds());

        _UpdateScrollBar(true);
        _UpdateScrollBar(false);

        Invalidate();
}


void
Chart::MouseDown(BPoint where)
{
        // ignore, if already dragging or if there's no scrollbar
        if (fDraggingStartPos.x >= 0 || ScrollBar(B_HORIZONTAL) == NULL)
                return;

        // the first button must be pressed
        int32 buttons;
        if (Window()->CurrentMessage()->FindInt32("buttons", &buttons) != B_OK
                || (buttons & B_PRIMARY_MOUSE_BUTTON) == 0) {
                return;
        }

        fDraggingStartPos = where;
        fDraggingStartScrollValue = fHScrollValue;

        SetMouseEventMask(B_POINTER_EVENTS);
}


void
Chart::MouseUp(BPoint where)
{
        // ignore if not dragging, or if the first mouse button is still pressed
        int32 buttons;
        if (fDraggingStartPos.x < 0
                || Window()->CurrentMessage()->FindInt32("buttons", &buttons) != B_OK
                || (buttons & B_PRIMARY_MOUSE_BUTTON) != 0) {
                return;
        }

        // stop dragging
        fDraggingStartPos.x = -1;
}


void
Chart::MouseMoved(BPoint where, uint32 code, const BMessage* dragMessage)
{
        fLastMousePos = where;

        if (fDraggingStartPos.x < 0)
                return;

        ScrollBar(B_HORIZONTAL)->SetValue(fDraggingStartScrollValue
                + fDraggingStartPos.x - where.x);
}


void
Chart::Draw(BRect updateRect)
{
//printf("Chart::Draw((%f, %f) - (%f, %f))\n", updateRect.left, updateRect.top, updateRect.right, updateRect.bottom);
        rgb_color background = ui_color(B_PANEL_BACKGROUND_COLOR);
        rgb_color color;

        // clear the axes background
        if (fLeftAxis.axis != NULL || fTopAxis.axis != NULL
                || fRightAxis.axis != NULL || fBottomAxis.axis != NULL) {
                SetLowColor(background);
                BRegion clippingRegion(Bounds());
                clippingRegion.Exclude(fChartFrame);
                ConstrainClippingRegion(&clippingRegion);
                FillRect(Bounds(), B_SOLID_LOW);
                ConstrainClippingRegion(NULL);
        }

        // render the axes
        fLeftAxis.Render(this, updateRect);
        fTopAxis.Render(this, updateRect);
        fRightAxis.Render(this, updateRect);
        fBottomAxis.Render(this, updateRect);

        // draw the frame around the chart area and clear the background
        BRect chartFrame(fChartFrame);
        be_control_look->DrawBorder(this, chartFrame, updateRect, background,
                B_PLAIN_BORDER);
                // DrawBorder() insets the supplied rect
        SetHighColor(color.set_to(255, 255, 255, 255));
        FillRect(chartFrame);

        // render the chart
        BRegion clippingRegion(chartFrame);
        ConstrainClippingRegion(&clippingRegion);
        fRenderer->Render(this, updateRect);
}


void
Chart::ScrollTo(BPoint where)
{
        if (fIgnoreScrollEvent > 0)
                return;

        _ScrollTo(where.x, true);
        _ScrollTo(where.y, false);
}


BSize
Chart::MinSize()
{
        // TODO: Implement for real!
        return BSize(100, 100);
}


BSize
Chart::MaxSize()
{
        // TODO: Implement for real!
        return BSize(B_SIZE_UNLIMITED, B_SIZE_UNLIMITED);
}


BSize
Chart::PreferredSize()
{
        // TODO: Implement for real!
        return MinSize();
}


void
Chart::DoLayout()
{
        // get size in pixels
        BSize size = Bounds().Size();
//printf("Chart::DoLayout(%f, %f)\n", size.width, size.height);
        int32 width = size.IntegerWidth() + 1;
        int32 height = size.IntegerHeight() + 1;

        // compute the axis insets
        int32 left = 0;
        int32 right = 0;
        int32 top = 0;
        int32 bottom = 0;

        if (fLeftAxis.axis != NULL)
                left = fLeftAxis.axis->PreferredSize(this, size).IntegerWidth() + 1;
        if (fRightAxis.axis != NULL)
                right = fRightAxis.axis->PreferredSize(this, size).IntegerWidth() + 1;
        if (fTopAxis.axis != NULL)
                top = fTopAxis.axis->PreferredSize(this, size).IntegerHeight() + 1;
        if (fBottomAxis.axis != NULL) {
                bottom = fBottomAxis.axis->PreferredSize(this, size).IntegerHeight()
                        + 1;
        }

        fChartFrame = BRect(left, top, width - right - 1, height - bottom - 1);
        fRenderer->SetFrame(fChartFrame.InsetByCopy(1, 1));
//printf("  fChartFrame: (%f, %f) - (%f, %f)\n", fChartFrame.left, fChartFrame.top, fChartFrame.right, fChartFrame.bottom);

        fLeftAxis.SetFrame(0, fChartFrame.top + 1, fChartFrame.left - 1,
                fChartFrame.bottom - 1);
        fRightAxis.SetFrame(fChartFrame.right + 1, fChartFrame.top + 1, width - 1,
                fChartFrame.bottom - 1);
        fTopAxis.SetFrame(fChartFrame.left + 1, 0, fChartFrame.right - 1,
                fChartFrame.top - 1);
        fBottomAxis.SetFrame(fChartFrame.left + 1, fChartFrame.bottom + 1,
                fChartFrame.right - 1, height - 1);
}


void
Chart::_UpdateDomainAndRange()
{
        ChartDataRange oldDomain = fDomain;
        ChartDataRange oldRange = fRange;

        if (fDataSources.IsEmpty()) {
                fDomain = ChartDataRange();
                fRange = ChartDataRange();
        } else {
                ChartDataSource* firstSource = fDataSources.ItemAt(0);
                fDomain = firstSource->Domain();
                fRange = firstSource->Range();

                for (int32 i = 1; ChartDataSource* source = fDataSources.ItemAt(i);
                                i++) {
                        fDomain.Extend(source->Domain());
                        fRange.Extend(source->Range());
                }
        }

        if (fDomain != oldDomain)
                DomainChanged();
        if (fRange != oldRange)
                RangeChanged();
}


void
Chart::_UpdateScrollBar(bool horizontal)
{
        const ChartDataRange& range = horizontal ? fDomain : fRange;
        const ChartDataRange& displayRange = horizontal
                ? fDisplayDomain : fDisplayRange;
        float chartSize = horizontal ? fChartFrame.Width() : fChartFrame.Height();
        chartSize--;    // +1 for pixel size, -2 for border
        float& scrollSize = horizontal ? fHScrollSize : fVScrollSize;
        float& scrollValue = horizontal ? fHScrollValue : fVScrollValue;
        BScrollBar* scrollBar = ScrollBar(horizontal ? B_HORIZONTAL : B_VERTICAL);

        float proportion;

        if (range.IsValid() && displayRange.IsValid()) {
                scrollSize = (range.Size() / displayRange.Size() - 1) * chartSize;
                scrollValue = (displayRange.min - range.min) / displayRange.Size()
                        * chartSize;
                proportion = displayRange.Size() / range.Size();
        } else {
                scrollSize = 0;
                scrollValue = 0;
                proportion = 1;
        }

        if (scrollBar != NULL) {
                fIgnoreScrollEvent++;
                scrollBar->SetRange(0, scrollSize);
                fIgnoreScrollEvent--;
                scrollBar->SetValue(scrollValue);
                scrollBar->SetProportion(proportion);
        }
}


void
Chart::_ScrollTo(float value, bool horizontal)
{
        float& scrollValue = horizontal ? fHScrollValue : fVScrollValue;
        if (value == scrollValue)
                return;

        const ChartDataRange& range = horizontal ? fDomain : fRange;
        ChartDataRange displayRange = horizontal ? fDisplayDomain : fDisplayRange;
        float chartSize = horizontal ? fChartFrame.Width() : fChartFrame.Height();
        chartSize--;    // +1 for pixel size, -2 for border
        const float& scrollSize = horizontal ? fHScrollSize : fVScrollSize;

        scrollValue = value;
        displayRange.OffsetTo(value / scrollSize
                * (range.Size() - displayRange.Size()));
        if (horizontal)
                SetDisplayDomain(displayRange);
        else
                SetDisplayRange(displayRange);
}


void
Chart::_Zoom(float x, float steps)
{
        double displayDomainSize = fDisplayDomain.Size();
        if (fDomainZoomLimit <= 0 || !fDomain.IsValid() || !fDisplayDomain.IsValid()
                || steps == 0) {
                return;
        }

        // compute the domain point where to zoom in
        float chartSize = fChartFrame.Width() - 1;
        x -= fChartFrame.left + 1;
        double domainPos = (fHScrollValue + x) / (fHScrollSize + chartSize)
                * fDomain.Size();

        double factor = 2;
        if (steps < 0) {
                steps = -steps;
                factor = 1.0 / factor;
        }

        for (; steps > 0; steps--)
                displayDomainSize *= factor;

        if (displayDomainSize < fDomainZoomLimit)
                displayDomainSize = fDomainZoomLimit;
        if (displayDomainSize > fDomain.Size())
                displayDomainSize = fDomain.Size();

        if (displayDomainSize == fDisplayDomain.Size())
                return;

        domainPos -= displayDomainSize * x / chartSize;
        SetDisplayDomain(ChartDataRange(domainPos, domainPos + displayDomainSize));
                // will adjust the supplied display domain to fit the domain
}