/****************************************************************************
**
** Copyright (C) 2012 Digia Plc
** All rights reserved.
** For any questions to Digia, please use contact form at http://qt.digia.com
**
** This file is part of the Qt Commercial Charts Add-on.
**
** $QT_BEGIN_LICENSE$
** Licensees holding valid Qt Commercial licenses may use this file in
** accordance with the Qt Commercial License Agreement provided with the
** Software or, alternatively, in accordance with the terms contained in
** a written agreement between you and Digia.
**
** If you have questions regarding the use of this file, please use
** contact form at http://qt.digia.com
** $QT_END_LICENSE$
**
****************************************************************************/

#include "chartlayout_p.h"
#include "chartpresenter_p.h"
#include "qlegend_p.h"
#include "chartaxis_p.h"
#include "charttitle_p.h"
#include "chartbackground_p.h"
#include "legendmarker_p.h"

QTCOMMERCIALCHART_BEGIN_NAMESPACE

static const qreal golden_ratio = 0.25;

ChartLayout::ChartLayout(ChartPresenter* presenter)
    : m_presenter(presenter),
      m_margins(20, 20, 20, 20),
      m_minChartRect(0, 0, 200, 200)
{

}

ChartLayout::~ChartLayout()
{

}

void ChartLayout::setGeometry(const QRectF& rect)
{
    if (!rect.isValid())
        return;

    QList<ChartAxis*> axes = m_presenter->axisItems();
    ChartTitle* title = m_presenter->titleElement();
    QLegend* legend = m_presenter->legend();
    ChartBackground* background = m_presenter->backgroundElement();

    QRectF contentGeometry = calculateBackgroundGeometry(rect, background);

    contentGeometry = calculateContentGeometry(contentGeometry);

    if (title && title->isVisible())
        contentGeometry = calculateTitleGeometry(contentGeometry, title);

    if (legend->isAttachedToChart() && legend->isVisible())
        contentGeometry = calculateLegendGeometry(contentGeometry, legend);

    calculateChartGeometry(contentGeometry, axes);

    //TODO remove me
#ifdef SHOW_LAYOUT
    LayoutDebuger* debuger = LayoutDebuger::instance();
    debuger->reset();
    debuger->setPen(QPen(Qt::red));
    debuger->add(backgroundGeometry, m_presenter->rootItem());
    debuger->add(titleGeometry, m_presenter->rootItem());
    debuger->add(legendGeometry , m_presenter->rootItem());
    debuger->add(axisGeometry , m_presenter->rootItem());
    debuger->add(geometry, m_presenter->rootItem());
    foreach (LegendMarker *marker, legend->d_ptr->markers())
        debuger->add(marker->mapRectToScene(marker->boundingRect()), m_presenter->rootItem());
#endif

    QGraphicsLayout::setGeometry(rect);
}

QRectF ChartLayout::calculateContentGeometry(const QRectF& geometry) const
{
    return geometry.adjusted(m_margins.left(), m_margins.top(), -m_margins.right(), -m_margins.bottom());
}

QRectF ChartLayout::calculateContentMinimum(const QRectF& minimum) const
{
    return  minimum.adjusted(0, 0, m_margins.left() + m_margins.right(), m_margins.top() + m_margins.bottom());
}


QRectF ChartLayout::calculateBackgroundGeometry(const QRectF& geometry, ChartBackground* background) const
{
    qreal left, top, right, bottom;
    getContentsMargins(&left, &top, &right, &bottom);
    QRectF backgroundGeometry = geometry.adjusted(left, top, -right, -bottom);
    if (background)
        background->setRect(backgroundGeometry);
    return backgroundGeometry;
}

QRectF ChartLayout::calculateBackgroundMinimum(const QRectF& minimum) const
{
    qreal left, top, right, bottom;
    getContentsMargins(&left, &top, &right, &bottom);
    return minimum.adjusted(0, 0, left + right, top + bottom);
}

QRectF ChartLayout::calculateChartGeometry(const QRectF& geometry, const QList<ChartAxis*>& axes) const
{

    QSizeF vertical(0, 0);
    QSizeF horizontal(0, 0);

    int topAxisCount = 0;
    int bottomAxisCount = 0;
    int leftAxisCount = 0;
    int rightAxisCount = 0;

    // check axis size
    foreach(ChartAxis* axis , axes) {
        if (axis->orientation() == Qt::Vertical && axis->isVisible()) {
//            vertical = vertical.expandedTo(axis->effectiveSizeHint(Qt::MinimumSize));
            if (axis->alternativePlacement())
                rightAxisCount++;
            else
                leftAxisCount++;
        } else if (axis->orientation() == Qt::Horizontal && axis->isVisible()) {
//            horizontal = horizontal.expandedTo(axis->effectiveSizeHint(Qt::MinimumSize));
            if (axis->alternativePlacement())
                topAxisCount++;
            else
                bottomAxisCount++;
        }
    }

    qreal width = qMin(vertical.width(), geometry.width() * golden_ratio);

    QRectF rect = geometry.adjusted(width, vertical.height() / 2, -horizontal.width() / 2, -horizontal.height());

    // axis area width
    // TODO: replase with dynamic size code
    int axisWidth = 35;

    // get the final size of the plot rect
    rect.adjust(leftAxisCount * axisWidth, topAxisCount * axisWidth, -rightAxisCount * axisWidth, -bottomAxisCount * axisWidth);
    m_presenter->setChartsGeometry(rect);

    leftAxisCount = 0;
    rightAxisCount = 0;
    bottomAxisCount = 0;
    topAxisCount = 0;

    // adjust the axes internal and external rects
    foreach (ChartAxis *axis , axes) {
        if (axis->orientation() == Qt::Vertical) {
            axis->setInternalRect(rect.adjusted(-leftAxisCount * axisWidth, 0, rightAxisCount * axisWidth, 0));
            axis->setGeometry(rect.adjusted(-(leftAxisCount + 1) * axisWidth, 0, (rightAxisCount + 1) * axisWidth, 0));
            if (axis->alternativePlacement())
                rightAxisCount++;
            else
                leftAxisCount++;
        } else if (axis->orientation() == Qt::Horizontal) {
            axis->setInternalRect(rect.adjusted(0, -topAxisCount * axisWidth, 0, bottomAxisCount * axisWidth));
            axis->setGeometry(rect.adjusted(0, -(topAxisCount + 1) * axisWidth, 0, (bottomAxisCount + 1) * axisWidth));
            if (axis->alternativePlacement())
                topAxisCount++;
            else
                bottomAxisCount++;
        }
    }

    return rect;
}

QRectF ChartLayout::calculateAxisMinimum(const QRectF& minimum, const QList<ChartAxis*>& axes) const
{
    QSizeF vertical(0, 0);
    QSizeF horizontal(0, 0);

    // check axis size
    foreach (ChartAxis *axis , axes) {
        if (axis->orientation() == Qt::Vertical && axis->isVisible())
            vertical = vertical.expandedTo(axis->effectiveSizeHint(Qt::MinimumSize));
        else if (axis->orientation() == Qt::Horizontal && axis->isVisible())
            horizontal = horizontal.expandedTo(axis->effectiveSizeHint(Qt::MinimumSize));
    }
    return minimum.adjusted(0, 0, horizontal.width() + vertical.width(), horizontal.height() + vertical.height());
}

QRectF ChartLayout::calculateLegendGeometry(const QRectF& geometry, QLegend* legend) const
{
    QSizeF size = legend->effectiveSizeHint(Qt::PreferredSize, QSizeF(-1, -1));
    QRectF legendRect;
    QRectF result;

    switch (legend->alignment()) {
    case Qt::AlignTop:
        legendRect = QRectF(geometry.topLeft(), QSizeF(geometry.width(), size.height()));
        result = geometry.adjusted(0, legendRect.height(), 0, 0);
        break;
    case Qt::AlignBottom:
        legendRect = QRectF(QPointF(geometry.left(), geometry.bottom() - size.height()), QSizeF(geometry.width(), size.height()));
        result = geometry.adjusted(0, 0, 0, -legendRect.height());
        break;
    case Qt::AlignLeft: {
        qreal width = qMin(size.width(), geometry.width() * golden_ratio);
        legendRect = QRectF(geometry.topLeft(), QSizeF(width, geometry.height()));
        result = geometry.adjusted(width, 0, 0, 0);
        break;
    }
    case Qt::AlignRight: {
        qreal width = qMin(size.width(), geometry.width() * golden_ratio);
        legendRect = QRectF(QPointF(geometry.right() - width, geometry.top()), QSizeF(width, geometry.height()));
        result = geometry.adjusted(0, 0, -width, 0);
        break;
    }
    default:
        legendRect = QRectF(0, 0, 0, 0);
        result = geometry;
        break;
    }

    legend->setGeometry(legendRect);

    return result;
}

QRectF ChartLayout::calculateLegendMinimum(const QRectF& geometry, QLegend* legend) const
{
    QSizeF minSize = legend->effectiveSizeHint(Qt::MinimumSize, QSizeF(-1, -1));
    return geometry.adjusted(0, 0, minSize.width(), minSize.height());
}

QRectF ChartLayout::calculateTitleGeometry(const QRectF& geometry, ChartTitle* title) const
{
    title->setGeometry(geometry);
    QPointF center = geometry.center() - title->boundingRect().center();
    title->setPos(center.x(), title->pos().y());
    return geometry.adjusted(0, title->boundingRect().height(), 0, 0);
}

QRectF ChartLayout::calculateTitleMinimum(const QRectF& minimum, ChartTitle* title) const
{
    QSizeF min = title->sizeHint(Qt::MinimumSize);
    return minimum.adjusted(0, 0, min.width(), min.height());
}

QSizeF ChartLayout::sizeHint(Qt::SizeHint which, const QSizeF & constraint) const
{
    Q_UNUSED(constraint);
    if (which == Qt::MinimumSize) {
        QList<ChartAxis*> axes = m_presenter->axisItems();
        ChartTitle* title = m_presenter->titleElement();
        QLegend* legend = m_presenter->legend();
        QRectF minimumRect(0, 0, 0, 0);
        minimumRect = calculateBackgroundMinimum(minimumRect);
        minimumRect = calculateContentMinimum(minimumRect);
        minimumRect = calculateTitleMinimum(minimumRect, title);
        minimumRect = calculateLegendMinimum(minimumRect, legend);
        minimumRect = calculateAxisMinimum(minimumRect, axes);
        return minimumRect.united(m_minChartRect).size().toSize();
    }
    return QSize(-1, -1);
}

void ChartLayout::setMargins(const QMargins& margins)
{
    if (m_margins != margins) {
        m_margins = margins;
        updateGeometry();
    }
}

QMargins ChartLayout::margins() const
{
    return m_margins;
}

void ChartLayout::adjustChartGeometry()
{
    setGeometry(geometry());
}

QTCOMMERCIALCHART_END_NAMESPACE