/*
    This file is part of the KDE libraries
    SPDX-FileCopyrightText: 1998 Jörg Habenicht <j.habenicht@europemail.com>
    SPDX-FileCopyrightText: 2010 Christoph Feck <cfeck@kde.org>

    SPDX-License-Identifier: LGPL-2.0-or-later
*/

#include "kled.h"

#include <QImage>
#include <QPainter>
#include <QStyle>
#include <QStyleOption>

class KLedPrivate
{
public:
    int darkFactor = 300;
    QColor color;
    KLed::State state = KLed::On;
    KLed::Look look = KLed::Raised;
    KLed::Shape shape = KLed::Circular;

    QPixmap cachedPixmap[2]; // for both states
};

KLed::KLed(QWidget *parent)
    : QWidget(parent)
    , d(new KLedPrivate)
{
    setColor(Qt::green);
    updateAccessibleName();
}

KLed::KLed(const QColor &color, QWidget *parent)
    : QWidget(parent)
    , d(new KLedPrivate)
{
    setColor(color);
    updateAccessibleName();
}

KLed::KLed(const QColor &color, State state, Look look, Shape shape, QWidget *parent)
    : QWidget(parent)
    , d(new KLedPrivate)
{
    d->state = (state == Off ? Off : On);
    d->look = look;
    d->shape = shape;

    setColor(color);
    updateAccessibleName();
}

KLed::~KLed() = default;

KLed::State KLed::state() const
{
    return d->state;
}

KLed::Shape KLed::shape() const
{
    return d->shape;
}

QColor KLed::color() const
{
    return d->color;
}

KLed::Look KLed::look() const
{
    return d->look;
}

void KLed::setState(State state)
{
    if (d->state == state) {
        return;
    }

    d->state = (state == Off ? Off : On);
    updateCachedPixmap();
    updateAccessibleName();
}

void KLed::setShape(Shape shape)
{
    if (d->shape == shape) {
        return;
    }

    d->shape = shape;
    updateCachedPixmap();
}

void KLed::setColor(const QColor &color)
{
    if (d->color == color) {
        return;
    }

    d->color = color;
    updateCachedPixmap();
}

void KLed::setDarkFactor(int darkFactor)
{
    if (d->darkFactor == darkFactor) {
        return;
    }

    d->darkFactor = darkFactor;
    updateCachedPixmap();
}

int KLed::darkFactor() const
{
    return d->darkFactor;
}

void KLed::setLook(Look look)
{
    if (d->look == look) {
        return;
    }

    d->look = look;
    updateCachedPixmap();
}

void KLed::toggle()
{
    d->state = (d->state == On ? Off : On);
    updateCachedPixmap();
    updateAccessibleName();
}

void KLed::on()
{
    setState(On);
}

void KLed::off()
{
    setState(Off);
}

void KLed::resizeEvent(QResizeEvent *)
{
    updateCachedPixmap();
}

QSize KLed::sizeHint() const
{
    QStyleOption option;
    option.initFrom(this);
    int iconSize = style()->pixelMetric(QStyle::PM_SmallIconSize, &option, this);
    return QSize(iconSize, iconSize);
}

QSize KLed::minimumSizeHint() const
{
    return QSize(16, 16);
}

void KLed::updateAccessibleName()
{
#ifndef QT_NO_ACCESSIBILITY
    QString onName = tr("LED on", "Accessible name of a Led whose state is on");
    QString offName = tr("LED off", "Accessible name of a Led whose state is off");
    QString lastName = accessibleName();

    if (lastName.isEmpty() || lastName == onName || lastName == offName) {
        // Accessible name has not been manually set.

        setAccessibleName(d->state == On ? onName : offName);
    }
#endif
}

void KLed::updateCachedPixmap()
{
    d->cachedPixmap[Off] = QPixmap();
    d->cachedPixmap[On] = QPixmap();
    update();
}

void KLed::paintEvent(QPaintEvent *)
{
    if (!d->cachedPixmap[d->state].isNull()) {
        QPainter painter(this);
        painter.drawPixmap(1, 1, d->cachedPixmap[d->state]);
        return;
    }

    QSize size(width() - 2, height() - 2);
    if (d->shape == Circular) {
        // Make sure the LED is round
        const int dim = qMin(width(), height()) - 2;
        size = QSize(dim, dim);
    }
    QPointF center(size.width() / 2.0, size.height() / 2.0);
    const int smallestSize = qMin(size.width(), size.height());
    QPainter painter;

    QImage image(size, QImage::Format_ARGB32_Premultiplied);
    image.fill(0);

    QRadialGradient fillGradient(center, smallestSize / 2.0, QPointF(center.x(), size.height() / 3.0));
    const QColor fillColor = d->state != Off ? d->color : d->color.darker(d->darkFactor);
    fillGradient.setColorAt(0.0, fillColor.lighter(250));
    fillGradient.setColorAt(0.5, fillColor.lighter(130));
    fillGradient.setColorAt(1.0, fillColor);

    QConicalGradient borderGradient(center, d->look == Sunken ? 90 : -90);
    QColor borderColor = palette().color(QPalette::Dark);
    if (d->state == On) {
        QColor glowOverlay = fillColor;
        glowOverlay.setAlpha(80);

        // This isn't the fastest way, but should be "fast enough".
        // It's also the only safe way to use QPainter::CompositionMode
        QImage img(1, 1, QImage::Format_ARGB32_Premultiplied);
        QPainter p(&img);
        QColor start = borderColor;
        start.setAlpha(255); // opaque
        p.fillRect(0, 0, 1, 1, start);
        p.setCompositionMode(QPainter::CompositionMode_SourceOver);
        p.fillRect(0, 0, 1, 1, glowOverlay);
        p.end();

        borderColor = img.pixel(0, 0);
    }
    borderGradient.setColorAt(0.2, borderColor);
    borderGradient.setColorAt(0.5, palette().color(QPalette::Light));
    borderGradient.setColorAt(0.8, borderColor);

    painter.begin(&image);
    painter.setRenderHint(QPainter::Antialiasing);
    painter.setBrush(d->look == Flat ? QBrush(fillColor) : QBrush(fillGradient));
    const QBrush penBrush = (d->look == Flat) ? QBrush(borderColor) : QBrush(borderGradient);
    const qreal penWidth = smallestSize / 8.0;
    painter.setPen(QPen(penBrush, penWidth));
    QRectF r(penWidth / 2.0, penWidth / 2.0, size.width() - penWidth, size.height() - penWidth);
    if (d->shape == Rectangular) {
        painter.drawRect(r);
    } else {
        painter.drawEllipse(r);
    }
    painter.end();

    d->cachedPixmap[d->state] = QPixmap::fromImage(image);
    painter.begin(this);
    painter.drawPixmap(1, 1, d->cachedPixmap[d->state]);
    painter.end();
}

#include "moc_kled.cpp"
