// Copyright (C) 2016 The Qt Company Ltd.
// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR GPL-3.0-only

#include <private/legendlayout_p.h>
#include <private/chartpresenter_p.h>
#include <private/qlegend_p.h>
#include <private/abstractchartlayout_p.h>

#include <private/qlegendmarker_p.h>
#include <private/legendmarkeritem_p.h>
#include <QtCharts/QLegendMarker>

QT_BEGIN_NAMESPACE

LegendLayout::LegendLayout(QLegend *legend)
    : m_legend(legend),
      m_offsetX(0),
      m_offsetY(0)
{

}

LegendLayout::~LegendLayout()
{

}

void LegendLayout::setOffset(qreal x, qreal y)
{
    bool scrollHorizontal = true;
    switch (m_legend->alignment()) {
    case Qt::AlignTop:
    case Qt::AlignBottom:
        scrollHorizontal = true;
        break;
    case Qt::AlignLeft:
    case Qt::AlignRight:
        scrollHorizontal = false;
        break;
    }

    // If detached, the scrolling direction is vertical instead of horizontal and vice versa.
    if (!m_legend->isAttachedToChart())
        scrollHorizontal = !scrollHorizontal;

    QRectF boundingRect = geometry();
    qreal left, top, right, bottom;
    getContentsMargins(&left, &top, &right, &bottom);
    boundingRect.adjust(left, top, -right, -bottom);

    // Limit offset between m_minOffset and m_maxOffset
    if (scrollHorizontal) {
        if (m_width <= boundingRect.width())
            return;

        if (x != m_offsetX) {
            m_offsetX = qBound(m_minOffsetX, x, m_maxOffsetX);
            m_legend->d_ptr->items()->setPos(-m_offsetX, boundingRect.top());
        }
    } else {
        if (m_height <= boundingRect.height())
            return;

        if (y != m_offsetY) {
            m_offsetY = qBound(m_minOffsetY, y, m_maxOffsetY);
            m_legend->d_ptr->items()->setPos(boundingRect.left(), -m_offsetY);
        }
    }
}

QPointF LegendLayout::offset() const
{
    return QPointF(m_offsetX, m_offsetY);
}

void LegendLayout::invalidate()
{
    QGraphicsLayout::invalidate();
    if (m_legend->isAttachedToChart())
        m_legend->d_ptr->m_presenter->layout()->invalidate();
}

void LegendLayout::setGeometry(const QRectF &rect)
{
    m_legend->d_ptr->items()->setVisible(m_legend->isVisible());

    QGraphicsLayout::setGeometry(rect);

    if (m_legend->isAttachedToChart())
        setAttachedGeometry(rect);
    else
        setDettachedGeometry(rect);
}

void LegendLayout::setAttachedGeometry(const QRectF &rect)
{
    if (!rect.isValid())
        return;

    qreal oldOffsetX = m_offsetX;
    qreal oldOffsetY = m_offsetY;
    m_offsetX = 0;
    m_offsetY = 0;

    QSizeF size(0, 0);

    if (m_legend->d_ptr->markers().isEmpty()) {
        return;
    }

    m_width = 0;
    m_height = 0;

    qreal left, top, right, bottom;
    getContentsMargins(&left, &top, &right, &bottom);

    QRectF geometry = rect.adjusted(left, top, -right, -bottom);

    switch(m_legend->alignment()) {
    case Qt::AlignTop:
    case Qt::AlignBottom: {
            // Calculate the space required for items and add them to a sorted list.
            qreal markerItemsWidth = 0;
            qreal itemMargins = 0;
            QList<LegendWidthStruct *> legendWidthList;
            foreach (QLegendMarker *marker, m_legend->d_ptr->markers()) {
                LegendMarkerItem *item = marker->d_ptr->item();
                if (item->isVisible()) {
                    QSizeF dummySize;
                    qreal itemWidth = item->sizeHint(Qt::PreferredSize, dummySize).width();
                    LegendWidthStruct *structItem = new LegendWidthStruct;
                    structItem->item = item;
                    structItem->width = itemWidth;
                    legendWidthList.append(structItem);
                    markerItemsWidth += itemWidth;
                    itemMargins += marker->d_ptr->item()->m_margin;
                }
            }
            std::sort(legendWidthList.begin(), legendWidthList.end(), widthLongerThan);

            // If the items would occupy more space than is available, start truncating them
            // from the longest one.
            qreal availableGeometry = geometry.width() - itemMargins;
            if (markerItemsWidth >= availableGeometry && legendWidthList.size() > 0) {
                bool truncated(false);
                int count = legendWidthList.size();
                for (int i = 1; i < count; i++) {
                    int truncateIndex = i - 1;

                    while (legendWidthList.at(truncateIndex)->width >= legendWidthList.at(i)->width
                           && !truncated) {
                        legendWidthList.at(truncateIndex)->width--;
                        markerItemsWidth--;
                        if (i > 1) {
                            // Truncate the items that are before the truncated one in the list.
                            for (int j = truncateIndex - 1; j >= 0; j--) {
                                if (legendWidthList.at(truncateIndex)->width
                                        < legendWidthList.at(j)->width) {
                                    legendWidthList.at(j)->width--;
                                    markerItemsWidth--;
                                }
                            }
                        }
                        if (markerItemsWidth < availableGeometry)
                            truncated = true;
                    }
                    // Truncate the last item if needed.
                    if (i == count - 1) {
                        if (legendWidthList.at(count - 1)->width
                                > legendWidthList.at(truncateIndex)->width) {
                            legendWidthList.at(count - 1)->width--;
                            markerItemsWidth--;
                        }
                    }

                    if (truncated)
                        break;
                }
                // Items are of same width and all of them need to be truncated
                // or there is just one item that is truncated.
                while (markerItemsWidth >= availableGeometry) {
                    for (int i = 0; i < count; i++) {
                        legendWidthList.at(i)->width--;
                        markerItemsWidth--;
                    }
                }
            }

            QPointF point(0,0);

            int markerCount = m_legend->d_ptr->markers().size();
            for (int i = 0; i < markerCount; i++) {
                QLegendMarker *marker;
                if (m_legend->d_ptr->m_reverseMarkers)
                    marker = m_legend->d_ptr->markers().at(markerCount - 1 - i);
                else
                    marker = m_legend->d_ptr->markers().at(i);
                LegendMarkerItem *item = marker->d_ptr->item();
                if (item->isVisible()) {
                    QRectF itemRect = geometry;
                    qreal availableWidth = 0;
                    for (int i = 0; i < legendWidthList.size(); ++i) {
                        if (legendWidthList.at(i)->item == item) {
                            availableWidth = legendWidthList.at(i)->width;
                            break;
                        }
                    }
                    itemRect.setWidth(availableWidth);
                    item->setGeometry(itemRect);
                    item->setPos(point.x(),geometry.height()/2 - item->boundingRect().height()/2);
                    const QRectF &rect = item->boundingRect();
                    size = size.expandedTo(rect.size());
                    qreal w = rect.width();
                    m_width = m_width + w - item->m_margin;
                    point.setX(point.x() + w);
                }
            }
            // Delete structs from the container
            qDeleteAll(legendWidthList);

            // Round to full pixel via QPoint to avoid one pixel clipping on the edge in some cases
            if (m_width < geometry.width()) {
                m_legend->d_ptr->items()->setPos(QPoint(geometry.width() / 2 - m_width / 2,
                                                        geometry.top()));
            } else {
                m_legend->d_ptr->items()->setPos(geometry.topLeft().toPoint());
            }
            m_height = size.height();
        }
        break;
    case Qt::AlignLeft:
    case Qt::AlignRight: {
            QPointF point(0,0);
            int markerCount = m_legend->d_ptr->markers().size();
            for (int i = 0; i < markerCount; i++) {
                QLegendMarker *marker;
                if (m_legend->d_ptr->m_reverseMarkers)
                    marker = m_legend->d_ptr->markers().at(markerCount - 1 - i);
                else
                    marker = m_legend->d_ptr->markers().at(i);
                LegendMarkerItem *item = marker->d_ptr->item();
                if (item->isVisible()) {
                    item->setGeometry(geometry);
                    item->setPos(point);
                    const QRectF &rect = item->boundingRect();
                    qreal h = rect.height();
                    size = size.expandedTo(rect.size());
                    m_height+=h;
                    point.setY(point.y() + h);
                }
            }

            // Round to full pixel via QPoint to avoid one pixel clipping on the edge in some cases
            if (m_height < geometry.height()) {
                m_legend->d_ptr->items()->setPos(QPoint(geometry.left(),
                                                        geometry.height() / 2 - m_height / 2));
            } else {
                m_legend->d_ptr->items()->setPos(geometry.topLeft().toPoint());
            }
            m_width = size.width();
            break;
            }
        }

    m_minOffsetX = -left;
    m_minOffsetY = - top;
    m_maxOffsetX = m_width - geometry.width() - right;
    m_maxOffsetY = m_height - geometry.height() - bottom;

    setOffset(oldOffsetX, oldOffsetY);
}

void LegendLayout::setDettachedGeometry(const QRectF &rect)
{
    if (!rect.isValid())
        return;

    // Detached layout is different.
    // In detached mode legend may have multiple rows and columns, so layout calculations
    // differ a log from attached mode.
    // Also the scrolling logic is bit different.

    qreal oldOffsetX = m_offsetX;
    qreal oldOffsetY = m_offsetY;
    m_offsetX = 0;
    m_offsetY = 0;

    qreal left, top, right, bottom;
    getContentsMargins(&left, &top, &right, &bottom);
    QRectF geometry = rect.adjusted(left, top, -right, -bottom);

    QList<QLegendMarker *> markers = m_legend->d_ptr->markers();

    if (markers.isEmpty())
        return;

    Qt::Alignment align = m_legend->alignment();
    switch (align) {
    case Qt::AlignTop:
    case Qt::AlignBottom: {
        QPointF point(0, (align == Qt::AlignTop) ? 0 : geometry.height());
        m_width = 0;
        m_height = 0;
        for (int i = 0; i < markers.size(); i++) {
            LegendMarkerItem *item = markers.at(i)->d_ptr->item();
            if (item->isVisible()) {
                item->setGeometry(geometry);
                const QRectF &boundingRect = item->boundingRect();
                qreal w = boundingRect.width();
                qreal h = boundingRect.height();
                m_width = qMax(m_width,w);
                m_height = qMax(m_height,h);
                item->setPos(point.x(),point.y() - ((align == Qt::AlignTop) ? 0 : h));
                point.setX(point.x() + w);
                if (point.x() + w > geometry.left() + geometry.width() - right) {
                    // Next item would go off rect.
                    point.setX(0);
                    point.setY(point.y() + ((align == Qt::AlignTop) ? h : -h));
                    if (i+1 < markers.size()) {
                        m_height += h;
                    }
                }
            }
        }
        m_legend->d_ptr->items()->setPos(geometry.topLeft());

        m_minOffsetX = -left;
        m_maxOffsetX = m_width - geometry.width() - right;
        if (align == Qt::AlignTop) {
            m_minOffsetY = -top;
            m_maxOffsetY = m_height - geometry.height() - bottom;
        } else {
            m_minOffsetY = -m_height + geometry.height() - top;
            m_maxOffsetY = -bottom;
        }
    }
    break;
    case Qt::AlignLeft:
    case Qt::AlignRight: {
        QPointF point((align == Qt::AlignLeft) ? 0 : geometry.width(), 0);
        m_width = 0;
        m_height = 0;
        qreal maxWidth = 0;
        for (int i = 0; i < markers.size(); i++) {
            LegendMarkerItem *item = markers.at(i)->d_ptr->item();
            if (item->isVisible()) {
                item->setGeometry(geometry);
                const QRectF &boundingRect = item->boundingRect();
                qreal w = boundingRect.width();
                qreal h = boundingRect.height();
                m_height = qMax(m_height,h);
                maxWidth = qMax(maxWidth,w);
                item->setPos(point.x() - ((align == Qt::AlignLeft) ? 0 : w),point.y());
                point.setY(point.y() + h);
                if (point.y() + h > geometry.bottom()-bottom) {
                    // Next item would go off rect.
                    point.setX(point.x() + ((align == Qt::AlignLeft) ? maxWidth : -maxWidth));
                    point.setY(0);
                    if (i+1 < markers.size()) {
                        m_width += maxWidth;
                        maxWidth = 0;
                    }
                }
            }
        }
        m_width += maxWidth;
        m_legend->d_ptr->items()->setPos(geometry.topLeft());

        m_minOffsetY = -top;
        m_maxOffsetY = m_height - geometry.height() - bottom;
        if (align == Qt::AlignLeft) {
            m_minOffsetX = -left;
            m_maxOffsetX = m_width - geometry.width() - right;
        } else {
            m_minOffsetX = - m_width + geometry.width() - left;
            m_maxOffsetX = - right;
        }
    }
    break;
    default:
        break;
    }

    setOffset(oldOffsetX, oldOffsetY);
}

QSizeF LegendLayout::sizeHint(Qt::SizeHint which, const QSizeF &constraint) const
{
    QSizeF size(0, 0);
    qreal left, top, right, bottom;
    getContentsMargins(&left, &top, &right, &bottom);

    if(constraint.isValid()) {
        foreach(QLegendMarker *marker, m_legend->d_ptr->markers()) {
            LegendMarkerItem *item = marker->d_ptr->item();
            size = size.expandedTo(item->effectiveSizeHint(which));
        }
        size = size.boundedTo(constraint);
    }
    else if (constraint.width() >= 0) {
        qreal width = 0;
        qreal height = 0;
        foreach(QLegendMarker *marker, m_legend->d_ptr->markers()) {
            LegendMarkerItem *item = marker->d_ptr->item();
            width+=item->effectiveSizeHint(which).width();
            height=qMax(height,item->effectiveSizeHint(which).height());
        }

        size = QSizeF(qMin(constraint.width(),width), height);
    }
    else if (constraint.height() >= 0) {
        qreal width = 0;
        qreal height = 0;
        foreach(QLegendMarker *marker, m_legend->d_ptr->markers()) {
            LegendMarkerItem *item = marker->d_ptr->item();
            width=qMax(width,item->effectiveSizeHint(which).width());
            height+=height,item->effectiveSizeHint(which).height();
        }
        size = QSizeF(width,qMin(constraint.height(),height));
    }
    else {
        foreach(QLegendMarker *marker, m_legend->d_ptr->markers()) {
            LegendMarkerItem *item = marker->d_ptr->item();
            size = size.expandedTo(item->effectiveSizeHint(which));
        }
    }
    size += QSize(left + right, top + bottom);
    return size;
}

bool LegendLayout::widthLongerThan(const LegendWidthStruct *item1,
                                   const LegendWidthStruct *item2)
{
    return item1->width > item2->width;
}

QT_END_NAMESPACE
