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

#include "chart/LegendChartAxis.h"

#include <limits.h>
#include <stdio.h>

#include <algorithm>
#include <new>

#include <Font.h>
#include <View.h>

#include "chart/ChartLegend.h"
#include "chart/ChartAxisLegendSource.h"


static const int32 kChartRulerDistance = 2;
static const int32 kRulerSize = 3;
static const int32 kRulerMarkSize = 3;
static const int32 kRulerLegendDistance = 2;
static const int32 kChartLegendDistance
        = kChartRulerDistance + kRulerSize + kRulerMarkSize + kRulerLegendDistance;



struct LegendChartAxis::LegendInfo {
        ChartLegend*    legend;
        double                  value;
        BSize                   size;

        LegendInfo(ChartLegend* legend, double value, BSize size)
                :
                legend(legend),
                value(value),
                size(size)
        {
        }

        ~LegendInfo()
        {
                delete legend;
        }
};


float
LegendChartAxis::_LegendPosition(double value, float legendSize,
        float totalSize, double scale)
{
        float position = (value - fRange.min) * scale - legendSize / 2;
        if (position + legendSize > totalSize)
                position = totalSize - legendSize;
        if (position < 0)
                position = 0;
        return position;
}


void
LegendChartAxis::_FilterLegends(int32 totalSize, int32 spacing,
        float BSize::* sizeField)
{
        // compute the min/max legend levels
        int32 legendCount = fLegends.CountItems();
        int32 minLevel = INT_MAX;
        int32 maxLevel = 0;

        for (int32 i = 0; i < legendCount; i++) {
                LegendInfo* info = fLegends.ItemAt(i);
                int32 level = info->legend->Level();
                if (level < minLevel)
                        minLevel = level;
                if (level > maxLevel)
                        maxLevel = level;
        }

        if (maxLevel <= 0)
                return;

        double rangeSize = fRange.max - fRange.min;
        if (rangeSize == 0)
                rangeSize = 1.0;
        double scale = (double)totalSize / rangeSize;

        // Filter out all higher level legends colliding with lower level or
        // preceeding same-level legends. We iterate backwards from the lower to
        // the higher levels
        for (int32 level = std::max(minLevel, (int32)0); level <= maxLevel;) {
                legendCount = fLegends.CountItems();

                // get the first legend position/end
                LegendInfo* info = fLegends.ItemAt(0);
                float position = _LegendPosition(info->value, info->size.*sizeField,
                        (float)totalSize, scale);;

                int32 previousEnd = (int32)ceilf(position + info->size.*sizeField);
                int32 previousLevel = info->legend->Level();

                for (int32 i = 1; (info = fLegends.ItemAt(i)) != NULL; i++) {
                        float position = _LegendPosition(info->value, info->size.*sizeField,
                                (float)totalSize, scale);;

                        if (position - spacing < previousEnd
                                && (previousLevel <= level
                                        || info->legend->Level() <= level)
                                && std::max(previousLevel, info->legend->Level()) > 0) {
                                // The item intersects with the previous one -- remove the
                                // one at the higher level.
                                if (info->legend->Level() >= previousLevel) {
                                        // This item is at the higher level -- remove it.
                                        delete fLegends.RemoveItemAt(i);
                                        i--;
                                        continue;
                                }

                                // The previous item is at the higher level -- remove it.
                                delete fLegends.RemoveItemAt(i - 1);
                                i--;
                        }

                        if (i == 0 && position < 0)
                                position = 0;
                        previousEnd = (int32)ceilf(position + info->size.*sizeField);
                        previousLevel = info->legend->Level();
                }

                // repeat with the level as long as we've removed something
                if (legendCount == fLegends.CountItems())
                        level++;
        }
}


LegendChartAxis::LegendChartAxis(ChartAxisLegendSource* legendSource,
        ChartLegendRenderer* legendRenderer)
        :
        fLegendSource(legendSource),
        fLegendRenderer(legendRenderer),
        fLocation(CHART_AXIS_BOTTOM),
        fRange(),
        fFrame(),
        fLegends(20),
        fHorizontalSpacing(20),
        fVerticalSpacing(10),
        fLayoutValid(false)
{
}


LegendChartAxis::~LegendChartAxis()
{
}


void
LegendChartAxis::SetLocation(ChartAxisLocation location)
{
        if (location != fLocation) {
                fLocation = location;
                _InvalidateLayout();
        }
}


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


void
LegendChartAxis::SetFrame(BRect frame)
{
        if (frame != fFrame) {
                fFrame = frame;
                _InvalidateLayout();
        }
}


BSize
LegendChartAxis::PreferredSize(BView* view, BSize maxSize)
{
        // estimate the maximum legend count we might need
        float hSpacing, vSpacing;
        int32 maxLegends = _EstimateMaxLegendCount(view, maxSize, &hSpacing,
                &vSpacing);
        BSize spacing(hSpacing, vSpacing);
        if (maxLegends < 4)
                maxLegends = 4;

        // get the legends
        ChartLegend* legends[maxLegends];
        double values[maxLegends];

        int32 legendCount = fLegendSource->GetAxisLegends(fRange, legends, values,
                maxLegends);

        // get the sizes, delete the legends, and compute the preferred size
        float BSize::* sizeField;
        float BSize::* otherSizeField;
        if (fLocation == CHART_AXIS_LEFT || fLocation == CHART_AXIS_RIGHT) {
                sizeField = &BSize::height;
                otherSizeField = &BSize::width;
        } else {
                sizeField = &BSize::width;
                otherSizeField = &BSize::height;
        }

        BSize preferredSize;

        for (int32 i = 0; i < legendCount; i++) {
                ChartLegend* legend = legends[i];
                BSize size = fLegendRenderer->LegendSize(legend, view);
                delete legend;

                if (size.*sizeField > preferredSize.*sizeField)
                        preferredSize.*sizeField = size.*sizeField;
                if (size.*otherSizeField > preferredSize.*otherSizeField)
                        preferredSize.*otherSizeField = size.*otherSizeField;
        }

        // Suppose we want to have at least 2 legends.
        preferredSize.*sizeField
                = ceilf(preferredSize.*sizeField * 2 + spacing.*sizeField);
        preferredSize.*otherSizeField += kChartLegendDistance;

        return preferredSize;
}


void
LegendChartAxis::Render(BView* view, BRect updateRect)
{
        if (!_ValidateLayout(view))
                return;

        float valueDirection;
        float rulerDirection;
        float BSize::* sizeField;
        float BSize::* otherSizeField;
        float BPoint::* pointField;
        float BPoint::* otherPointField;

        switch (fLocation) {
                case CHART_AXIS_LEFT:
                case CHART_AXIS_RIGHT:
                        valueDirection = -1;
                        rulerDirection = fLocation == CHART_AXIS_LEFT ? -1 : 1;
                        sizeField = &BSize::height;
                        otherSizeField = &BSize::width;
                        pointField = &BPoint::y;
                        otherPointField = &BPoint::x;
                        break;
                case CHART_AXIS_TOP:
                case CHART_AXIS_BOTTOM:
                        valueDirection = 1;
                        rulerDirection = fLocation == CHART_AXIS_TOP ? -1 : 1;
                        sizeField = &BSize::width;
                        otherSizeField = &BSize::height;
                        pointField = &BPoint::x;
                        otherPointField = &BPoint::y;
                        break;
                default:
                        return;
        }

        float totalSize = floorf(fFrame.Size().*sizeField) + 1;
        double rangeSize = fRange.max - fRange.min;
        if (rangeSize == 0)
                rangeSize = 1.0;
        double scale = (double)totalSize / rangeSize;

        // draw the ruler
        float rulerStart = fFrame.LeftBottom().*pointField;
        float rulerChartClosest = rulerDirection == 1
                ? fFrame.LeftTop().*otherPointField + kChartRulerDistance
                : fFrame.RightBottom().*otherPointField - kChartRulerDistance;
        float rulerEnd = fFrame.RightTop().*pointField;
        float rulerChartDistant = rulerChartClosest + rulerDirection * kRulerSize;

        rgb_color black = { 0, 0, 0, 255 };
        view->BeginLineArray(3 + fLegends.CountItems());
        BPoint first;
        first.*pointField = rulerStart;
        first.*otherPointField = rulerChartClosest;
        BPoint second = first;
        second.*otherPointField = rulerChartDistant;
        BPoint third = second;
        third.*pointField = rulerEnd;
        BPoint fourth = third;
        fourth.*otherPointField = rulerChartClosest;
        view->AddLine(first, second, black);
        view->AddLine(second, third, black);
        view->AddLine(third, fourth, black);

        // marks
        for (int32 i = 0; LegendInfo* info = fLegends.ItemAt(i); i++) {
                float position = (info->value - fRange.min) * scale;
                position = rulerStart + valueDirection * position;
                first.*pointField = position;
                first.*otherPointField = rulerChartDistant;
                second.*pointField = position;
                second.*otherPointField = rulerChartDistant
                        + rulerDirection * kRulerMarkSize;
                view->AddLine(first, second, black);
        }
        view->EndLineArray();

        // draw the legends
        float legendRulerClosest = rulerChartDistant
                + rulerDirection * (kRulerMarkSize + kRulerLegendDistance);

        for (int32 i = 0; LegendInfo* info = fLegends.ItemAt(i); i++) {
                float position = _LegendPosition(info->value, info->size.*sizeField,
                        (float)totalSize, scale);;

                first.*pointField = rulerStart
                        + (valueDirection == 1
                                ? position : -position - info->size.*sizeField);
                first.*otherPointField = rulerDirection == 1
                        ? legendRulerClosest
                        : legendRulerClosest - info->size.*otherSizeField;

                fLegendRenderer->RenderLegend(info->legend, view, first);
        }
}


void
LegendChartAxis::_InvalidateLayout()
{
        fLayoutValid = false;
}


bool
LegendChartAxis::_ValidateLayout(BView* view)
{
        if (fLayoutValid)
                return true;

        fLegends.MakeEmpty();

        int32 width = fFrame.IntegerWidth() + 1;
        int32 height = fFrame.IntegerHeight() + 1;

        // estimate the maximum legend count we might need
        int32 maxLegends = _EstimateMaxLegendCount(view, fFrame.Size(),
                &fHorizontalSpacing, &fVerticalSpacing);

        if (maxLegends == 0)
                return false;

        // get the legends
        ChartLegend* legends[maxLegends];
        double values[maxLegends];

        int32 legendCount = fLegendSource->GetAxisLegends(fRange, legends, values,
                maxLegends);
        if (legendCount == 0)
                return false;

        // create legend infos
        for (int32 i = 0; i < legendCount; i++) {
                ChartLegend* legend = legends[i];
                BSize size = fLegendRenderer->LegendSize(legend, view);
                LegendInfo* info = new(std::nothrow) LegendInfo(legend, values[i],
                        size);
                if (info == NULL || !fLegends.AddItem(info)) {
                        // TODO: Report error!
                        delete info;
                        for (int32 k = i; k < legendCount; k++)
                                delete legends[k];
                        return false;
                }
        }

        if (fLocation == CHART_AXIS_LEFT || fLocation == CHART_AXIS_RIGHT)
                _FilterLegends(height, fVerticalSpacing, &BSize::height);
        else
                _FilterLegends(width, fHorizontalSpacing, &BSize::width);

        fLayoutValid = true;
        return true;
}


int32
LegendChartAxis::_EstimateMaxLegendCount(BView* view, BSize size,
        float* _hSpacing, float* _vSpacing)
{
        // get the legend spacing
        fLegendRenderer->GetMinimumLegendSpacing(view, _hSpacing, _vSpacing);

        // estimate the maximum legend count we might need
        if (fLocation == CHART_AXIS_LEFT || fLocation == CHART_AXIS_RIGHT)
                return (int32)((size.IntegerHeight() + 1) / (10 + *_vSpacing));
        return (int32)((size.IntegerWidth() + 1) / (20 + *_hSpacing));
}