#include "BatteryWidget.h"

#include <QPainter>
#include <QTimer>
#include <QDebug>

namespace {
    const int DEFAULT_WIDTH = 90;
    const int DEFAULT_HEIGHT = 120;
    const int DEFAULT_MIN_WIDTH = 30;
    const int DEFAULT_MIN_HEIGHT = 40;

}

BatteryWidget::BatteryWidget(QWidget* parent)
: QWidget(parent)
{
    mMinValue = 0;
    mMaxValue = 100;
    mValue = 0;
    mAlarmValue = 90;
    mStep = 0.5;

    mBorderWidth = 5;
    mBorderRadius = 8;
    mBgRadius = 5;
    mHeadRadius = 3;

    mBorderColorStart = QColor(100, 100, 100);
    mBorderColorEnd = QColor(80, 80, 80);
    mAlarmColorStart = QColor(250, 118, 113);
    mAlarmColorEnd = QColor(204, 38, 38);
    mNormalColorStart = QColor(50, 205, 51);
    mNormalColorEnd = QColor(60, 179, 133);

    mIsForward = false;
    mCurrentValue = 0;

    mTimer = new QTimer(this);
	mTimer->setInterval(10);
	connect(mTimer, SIGNAL(timeout()), this, SLOT(updateValue()));
	this->setFixedSize(DEFAULT_WIDTH,DEFAULT_HEIGHT);
	this->setMinimumSize(DEFAULT_MIN_WIDTH,DEFAULT_MIN_HEIGHT);
}

BatteryWidget::~BatteryWidget()
{
	if (mTimer->isActive()) {
		mTimer->stop();
	}
}

void BatteryWidget::paintEvent(QPaintEvent*)
{
	//绘制准备工作,启用反锯齿
	QPainter painter(this);
	painter.setRenderHints(QPainter::Antialiasing | QPainter::TextAntialiasing);

	//绘制边框
	drawBorder(&painter);
	//绘制背景
	drawBg(&painter);
	//绘制头部
	//drawHead(&painter);
}

void BatteryWidget::drawBorder(QPainter* painter)
{
	painter->save();

	//double headWidth = width() / 15;
	double batteryWidth = width() - mBorderWidth;

	//绘制电池边框
	QPointF topLeft(mBorderWidth, mBorderWidth);
	QPointF bottomRight(batteryWidth, height() - mBorderWidth);
    mBatteryRect = QRectF(topLeft, bottomRight);

	painter->setPen(QPen(mBorderColorStart, mBorderWidth));
	painter->setBrush(Qt::NoBrush);
	painter->drawRoundedRect(mBatteryRect, mBorderRadius, mBorderRadius);

	painter->restore();
}

void BatteryWidget::drawBg(QPainter* painter)
{
	if (mValue == mMinValue) {
		return;
	}

	painter->save();

	QLinearGradient batteryGradient(QPointF(0, 0), QPointF(0, height()));
	if (mCurrentValue >= mAlarmValue) {
		batteryGradient.setColorAt(0.0, mAlarmColorStart);
		batteryGradient.setColorAt(1.0, mAlarmColorEnd);
	}
	else {
		batteryGradient.setColorAt(0.0, mNormalColorStart);
		batteryGradient.setColorAt(1.0, mNormalColorEnd);
	}

	int margin = qMin(width(), height()) / 20;

	double unit = (mBatteryRect.height() - (margin * 2)) / mMaxValue;
	double height = (mMaxValue - mCurrentValue) * unit;
	QPointF topLeft(mBatteryRect.topLeft().x() + margin, margin + height);
	QPointF bottomRight(mBatteryRect.bottomRight().x() - margin, mBatteryRect.bottomRight().y() - margin);

	QRectF rect(topLeft, bottomRight);

	painter->setPen(Qt::NoPen);
	painter->setBrush(batteryGradient);
	painter->drawRoundedRect(rect, mBgRadius, mBgRadius);

	painter->restore();
}

void BatteryWidget::drawHead(QPainter* painter)
{
	painter->save();

	QPointF headRectTopLeft(mBatteryRect.topRight().x(), height() / 3);
	QPointF headRectBottomRight(width(), height() - height() / 3);
	QRectF headRect(headRectTopLeft, headRectBottomRight);

	QLinearGradient headRectGradient(headRect.topLeft(), headRect.bottomLeft());
	headRectGradient.setColorAt(0.0, mBorderColorStart);
	headRectGradient.setColorAt(1.0, mBorderColorEnd);

	painter->setPen(Qt::NoPen);
	painter->setBrush(headRectGradient);
	painter->drawRoundedRect(headRect, mHeadRadius, mHeadRadius);

	painter->restore();
}

void BatteryWidget::updateValue()
{
	if (mIsForward) {
        mCurrentValue -= mStep;
		if (mCurrentValue <= mValue) {
            mCurrentValue = mValue;
			mTimer->stop();
		}
	}
	else {
        mCurrentValue += mStep;
		if (mCurrentValue >= mValue) {
            mCurrentValue = mValue;
			mTimer->stop();
		}
	}

	this->update();
}

double BatteryWidget::getMinValue() const
{
	return this->mMinValue;
}

double BatteryWidget::getMaxValue() const
{
	return this->mMaxValue;
}

double BatteryWidget::getValue() const
{
	return this->mValue;
}

double BatteryWidget::getAlarmValue() const
{
	return this->mAlarmValue;
}

double BatteryWidget::getStep() const
{
	return this->mStep;
}

int BatteryWidget::getBorderWidth() const
{
	return this->mBorderWidth;
}

int BatteryWidget::getBorderRadius() const
{
	return this->mBorderRadius;
}

int BatteryWidget::getBgRadius() const
{
	return this->mBgRadius;
}

int BatteryWidget::getHeadRadius() const
{
	return this->mHeadRadius;
}

QColor BatteryWidget::getBorderColorStart() const
{
	return this->mBorderColorStart;
}

QColor BatteryWidget::getBorderColorEnd() const
{
	return this->mBorderColorEnd;
}

QColor BatteryWidget::getAlarmColorStart() const
{
	return this->mAlarmColorStart;
}

QColor BatteryWidget::getAlarmColorEnd() const
{
	return this->mAlarmColorEnd;
}

QColor BatteryWidget::getNormalColorStart() const
{
	return this->mNormalColorStart;
}

QColor BatteryWidget::getNormalColorEnd() const
{
	return this->mNormalColorEnd;
}

void BatteryWidget::setRange(double minVal, double maxVal)
{
	//如果最小值大于或者等于最大值则不设置
	if (minVal >= maxVal) {
		return;
	}

	this->mMinValue = minVal;
	this->mMaxValue = maxVal;

	//如果目标值不在范围值内,则重新设置目标值
	//值小于最小值则取最小值,大于最大值则取最大值
	if (mValue < mMinValue) {
		setValue(mMinValue);
	}
	else if (mValue > mMaxValue) {
		setValue(mMaxValue);
	}

	this->update();
}

void BatteryWidget::setRange(int minVal, int maxVal)
{
	setRange((double)minVal, (double)maxVal);
}

void BatteryWidget::setMinValue(double minVal)
{
	setRange(minVal, mMaxValue);
}

void BatteryWidget::setMaxValue(double maxVal)
{
	setRange(mMinValue, maxVal);
}

void BatteryWidget::setValue(double value)
{
	//值和当前值一致则无需处理
	if (value == this->mValue) {
		return;
	}

	//值小于最小值则取最小值,大于最大值则取最大值
	if (value < mMinValue) {
		value = mMinValue;
	}
	else if (value > mMaxValue) {
		value = mMaxValue;
	}

	if (value > mCurrentValue) {
        mIsForward = false;
	}
	else if (value < mCurrentValue) {
        mIsForward = true;
	}
	else {
		this->mValue = value;
		this->update();
		return;
	}

	this->mValue = value;
	this->update();
	emit valueChanged(value);
	//timer->stop();
	//timer->start();
}

void BatteryWidget::startAnimation()
{
	mTimer->stop();
	mTimer->start();
}

void BatteryWidget::setValue(int value)
{
	setValue((double)value);
}

void BatteryWidget::setAlarmValue(double alarmValue)
{
	if (this->mAlarmValue != alarmValue) {
		this->mAlarmValue = alarmValue;
		this->update();
	}
}

void BatteryWidget::setAlarmValue(int alarmValue)
{
	setAlarmValue((double)alarmValue);
}

void BatteryWidget::setStep(double step)
{
	if (this->mStep != step) {
		this->mStep = step;
		this->update();
	}
}

void BatteryWidget::setStep(int step)
{
	setStep((double)step);
}

void BatteryWidget::setBorderWidth(int borderWidth)
{
	if (this->mBorderWidth != borderWidth) {
		this->mBorderWidth = borderWidth;
		this->update();
	}
}

void BatteryWidget::setBorderRadius(int borderRadius)
{
	if (this->mBorderRadius != borderRadius) {
		this->mBorderRadius = borderRadius;
		this->update();
	}
}

void BatteryWidget::setBgRadius(int bgRadius)
{
	if (this->mBgRadius != bgRadius) {
		this->mBgRadius = bgRadius;
		this->update();
	}
}

void BatteryWidget::setHeadRadius(int headRadius)
{
	if (this->mHeadRadius != headRadius) {
		this->mHeadRadius = headRadius;
		this->update();
	}
}

void BatteryWidget::setBorderColorStart(const QColor& borderColorStart)
{
	if (this->mBorderColorStart != borderColorStart) {
		this->mBorderColorStart = borderColorStart;
		this->update();
	}
}

void BatteryWidget::setBorderColorEnd(const QColor& borderColorEnd)
{
	if (this->mBorderColorEnd != borderColorEnd) {
		this->mBorderColorEnd = borderColorEnd;
		this->update();
	}
}

void BatteryWidget::setAlarmColorStart(const QColor& alarmColorStart)
{
	if (this->mAlarmColorStart != alarmColorStart) {
		this->mAlarmColorStart = alarmColorStart;
		this->update();
	}
}

void BatteryWidget::setAlarmColorEnd(const QColor& alarmColorEnd)
{
	if (this->mAlarmColorEnd != alarmColorEnd) {
		this->mAlarmColorEnd = alarmColorEnd;
		this->update();
	}
}

void BatteryWidget::setNormalColorStart(const QColor& normalColorStart)
{
	if (this->mNormalColorStart != normalColorStart) {
		this->mNormalColorStart = normalColorStart;
		this->update();
	}
}

void BatteryWidget::setNormalColorEnd(const QColor& normalColorEnd)
{
	if (this->mNormalColorEnd != normalColorEnd) {
		this->mNormalColorEnd = normalColorEnd;
		this->update();
	}
}