/*
This file is part of Telegram Desktop,
the official desktop application for the Telegram messaging service.

For license and copyright information please follow this link:
https://github.com/telegramdesktop/tdesktop/blob/master/LEGAL
*/
#include "ui/effects/premium_bubble.h"

#include "base/debug_log.h"
#include "base/object_ptr.h"
#include "lang/lang_keys.h"
#include "ui/effects/gradient.h"
#include "ui/effects/ministar_particles.h"
#include "ui/effects/premium_graphics.h"
#include "ui/wrap/padding_wrap.h"
#include "ui/wrap/vertical_layout.h"
#include "ui/painter.h"
#include "styles/style_info_levels.h"
#include "styles/style_layers.h"
#include "styles/style_premium.h"

namespace Ui::Premium {
namespace {

constexpr auto kBubbleRadiusSubtractor = 2;
constexpr auto kDeflectionSmall = 20.;
constexpr auto kDeflection = 30.;
constexpr auto kStepBeforeDeflection = 0.75;
constexpr auto kStepAfterDeflection = kStepBeforeDeflection
+ (1. - kStepBeforeDeflection) / 2.;
constexpr auto kSlideDuration = crl::time(1000);

} // namespace

TextFactory ProcessTextFactory(
		std::optional<tr::phrase<lngtag_count>> phrase) {
	return phrase
		? TextFactory([=](int n) -> BubbleText {
			return { (*phrase)(tr::now, lt_count, n) };
		})
		: TextFactory([=](int n) -> BubbleText {
			return { QString::number(n) };
		});
}

Bubble::Bubble(
	const style::PremiumBubble &st,
	Fn<void()> updateCallback,
	TextFactory textFactory,
	const style::icon *icon,
	bool hasTail)
: _st(st)
, _updateCallback(std::move(updateCallback))
, _textFactory(std::move(textFactory))
, _icon(icon)
, _numberAnimation(_st.font, _updateCallback)
, _height(_st.height + _st.tailSize.height())
, _hasTail(hasTail) {
	_numberAnimation.setDisabledMonospace(true);
	_numberAnimation.setWidthChangedCallback([=] {
		_widthChanges.fire({});
	});
	const auto texts = _textFactory(0);
	_numberAnimation.setText(texts.counter, 0);
	_numberAnimation.finishAnimating();
	if (!texts.additional.isEmpty()) {
		_additional.setText(_st.additionalStyle, texts.additional);
	}
}

crl::time Bubble::SlideNoDeflectionDuration() {
	return kSlideDuration * kStepBeforeDeflection;
}

std::optional<int> Bubble::counter() const {
	return _counter;
}

int Bubble::height() const {
	return _height;
}

int Bubble::bubbleRadius() const {
	return (_st.height / 2) - kBubbleRadiusSubtractor;
}

int Bubble::filledWidth() const {
	return _st.padding.left()
		+ _icon->width()
		+ _st.textSkip
		+ _st.padding.right();
}

int Bubble::topTextWidth() const {
	return filledWidth()
		+ _numberAnimation.countWidth()
		+ (_additional.isEmpty()
			? 0
			: (_st.additionalSkip + _additional.maxWidth()));
}

int Bubble::bottomTextWidth() const {
	return _subtext.isEmpty()
		? 0
		: (_st.subtextPadding.left()
			+ _subtext.maxWidth()
			+ _st.subtextPadding.right());
}

int Bubble::width() const {
	return std::max(topTextWidth(), bottomTextWidth());
}

int Bubble::countTargetWidth(int targetCounter) const {
	auto numbers = Ui::NumbersAnimation(_st.font, [] {});
	numbers.setDisabledMonospace(true);
	numbers.setDuration(0);
	const auto texts = _textFactory(targetCounter);
	numbers.setText(texts.counter, targetCounter);
	numbers.finishAnimating();
	const auto top = filledWidth()
		+ numbers.maxWidth()
		+ (_additional.isEmpty()
			? 0
			: (_st.additionalSkip
				+ _st.additionalStyle.font->width(texts.additional)));
	return std::max(top, bottomTextWidth());
}

void Bubble::setCounter(int value) {
	if (_counter != value) {
		_counter = value;
		const auto texts = _textFactory(value);
		_numberAnimation.setText(texts.counter, value);
		if (!texts.additional.isEmpty()) {
			_additional.setText(_st.additionalStyle, texts.additional);
		}
	}
}

void Bubble::setTailEdge(EdgeProgress edge) {
	_tailEdge = std::clamp(edge, 0., 1.);
}

void Bubble::setFlipHorizontal(bool value) {
	_flipHorizontal = value;
}

QRect Bubble::bubbleGeometry(const QRect &r) const {
	const auto penWidth = _st.penWidth;
	const auto penWidthHalf = penWidth / 2;
	return r - style::margins(
		penWidthHalf,
		penWidthHalf,
		penWidthHalf,
		_st.tailSize.height() + penWidthHalf);
}

QPainterPath Bubble::bubblePath(const QRect &r) const {
	const auto bubbleRect = bubbleGeometry(r);
	const auto radius = bubbleRadius();
	auto pathTail = QPainterPath();

	const auto tailWHalf = _st.tailSize.width() / 2.;
	const auto progress = _tailEdge;

	const auto tailTop = bubbleRect.y() + bubbleRect.height();
	const auto tailLeftFull = bubbleRect.x()
		+ (bubbleRect.width() * 0.5)
		- tailWHalf;
	const auto tailLeft = bubbleRect.x()
		+ (bubbleRect.width() * 0.5 * (progress + 1.))
		- tailWHalf;
	const auto tailCenter = tailLeft + tailWHalf;
	const auto tailRight = [&] {
		const auto max = bubbleRect.x() + bubbleRect.width();
		const auto right = tailLeft + _st.tailSize.width();
		const auto bottomMax = max - radius;
		return (right > bottomMax)
			? std::max(float64(tailCenter), float64(bottomMax))
			: right;
	}();
	if (_hasTail) {
		pathTail.moveTo(tailLeftFull, tailTop);
		pathTail.lineTo(tailLeft, tailTop);
		pathTail.lineTo(tailCenter, tailTop + _st.tailSize.height());
		pathTail.lineTo(tailRight, tailTop);
		pathTail.lineTo(tailRight, tailTop - radius);
		pathTail.moveTo(tailLeftFull, tailTop);
	}
	auto pathBubble = QPainterPath();
	pathBubble.setFillRule(Qt::WindingFill);
	pathBubble.addRoundedRect(bubbleRect, radius, radius);

	auto result = pathTail + pathBubble;
	if (_flipHorizontal) {
		auto m = QTransform();
		const auto center = QRectF(bubbleRect).center();
		m.translate(center.x(), center.y());
		m.scale(-1., 1.);
		m.translate(-center.x(), -center.y());
		return m.map(result);
	}
	return result;
}

void Bubble::setSubtext(QString subtext) {
	if (_subtext.toString() == subtext) {
		return;
	} else if (subtext.isEmpty()) {
		_subtext = {};
	} else {
		_subtext.setText(_st.subtextStyle, subtext);
	}
	_widthChanges.fire({});
	_updateCallback();
}

void Bubble::finishAnimating() {
	_numberAnimation.finishAnimating();
}

void Bubble::paintBubble(QPainter &p, const QRect &r, const QBrush &brush) {
	if (!_counter.has_value()) {
		return;
	}

	const auto bubbleRect = bubbleGeometry(r);
	const auto penWidth = _st.penWidth;
	{
		auto hq = PainterHighQualityEnabler(p);
		p.setPen(QPen(
			brush,
			penWidth,
			Qt::SolidLine,
			Qt::RoundCap,
			Qt::RoundJoin));
		p.setBrush(brush);
		p.drawPath(bubblePath(r));
	}
	p.setPen(st::activeButtonFg);
	p.setFont(_st.font);
	const auto withSubtext = !_subtext.isEmpty();
	const auto height = withSubtext
		? (_st.font->height
			+ _st.subtextPadding.top()
			+ _st.subtextStyle.font->height)
		: _st.font->height;
	const auto topWidth = withSubtext ? topTextWidth() : 0;
	const auto bottomWidth = withSubtext ? bottomTextWidth() : 0;
	const auto iconShift = (topWidth >= bottomWidth)
		? 0
		: (bottomWidth - topWidth) / 2;
	const auto iconLeft = r.x() + _st.padding.left() + iconShift;
	const auto topShift = (_st.font->height - height) / 2;
	const auto iconTop = bubbleRect.y()
		+ topShift
		+ (bubbleRect.height() - _icon->height()) / 2;
	_icon->paint(p, iconLeft, iconTop, bubbleRect.width());
	const auto numberLeft = iconLeft + _icon->width() + _st.textSkip;
	const auto numberTop = r.y() + (_st.height - height) / 2;
	_numberAnimation.paint(p, numberLeft, numberTop, width());
	if (!_additional.isEmpty()) {
		p.setOpacity(0.7);
		const auto additionalLeft = numberLeft
			+ _numberAnimation.countWidth()
			+ _st.additionalSkip;
		const auto additionalTop = numberTop
			+ _st.font->ascent
			- _st.additionalStyle.font->ascent;
		_additional.draw(p, {
			.position = { additionalLeft, additionalTop },
			.availableWidth = _additional.maxWidth(),
		});
	}
	if (withSubtext) {
		p.setOpacity(1.);
		const auto subtextShift = (bottomWidth >= topWidth)
			? 0
			: (topWidth - bottomWidth) / 2;
		const auto subtextLeft = r.x()
			+ _st.subtextPadding.left()
			+ subtextShift;
		const auto subtextTop = numberTop
			+ _st.font->height
			+ _st.subtextPadding.top();
		_subtext.draw(p, {
			.position = { subtextLeft, subtextTop },
			.availableWidth = _subtext.maxWidth(),
		});
	}
}

rpl::producer<> Bubble::widthChanges() const {
	return _widthChanges.events();
}

BubbleWidget::BubbleWidget(
	not_null<Ui::RpWidget*> parent,
	const style::PremiumBubble &st,
	TextFactory textFactory,
	rpl::producer<BubbleRowState> state,
	BubbleType type,
	rpl::producer<> showFinishes,
	const style::icon *icon,
	const style::margins &outerPadding)
: AbstractButton(parent)
, _st(st)
, _state(std::move(state))
, _bubble(
	_st,
	[=] { update(); },
	std::move(textFactory),
	icon,
	(type != BubbleType::NoPremium))
, _type(type)
, _outerPadding(outerPadding)
, _deflection(kDeflection)
, _stepBeforeDeflection(kStepBeforeDeflection)
, _stepAfterDeflection(kStepAfterDeflection) {
	if (_type == BubbleType::Credits) {
		setupParticles(parent);
	}
	const auto resizeTo = [=](int w, int h) {
		_deflection = (w > _st.widthLimit)
			? kDeflectionSmall
			: kDeflection;
		_spaceForDeflection = QSize(_st.skip, _st.skip);
		resize(QSize(w, h) + 2 * _spaceForDeflection);
	};

	resizeTo(_bubble.width(), _bubble.height());
	_bubble.widthChanges(
	) | rpl::on_next([=] {
		resizeTo(_bubble.width(), _bubble.height());
	}, lifetime());

	const auto instant = !showFinishes;
	if (instant) {
		showFinishes = rpl::single(rpl::empty);
	}
	std::move(
		showFinishes
	) | rpl::take(1) | rpl::on_next([=] {
		_state.value(
		) | rpl::on_next([=](BubbleRowState state) {
			animateTo(state);
		}, lifetime());
		if (instant) {
			_appearanceAnimation.stop();
			if (const auto onstack = base::take(_appearanceCallback)) {
				onstack(1.);
			}
			_bubble.finishAnimating();
		}

		parent->widthValue() | rpl::on_next([=](int w) {
			if (!_appearanceAnimation.animating()) {
				const auto available = w
					- _outerPadding.left()
					- _outerPadding.right();
				const auto x = (available * _animatingFromResultRatio);
				moveToLeft(-_spaceForDeflection.width()
					+ std::max(
						int(base::SafeRound(x
							- (_bubble.width() / 2)
							+ _outerPadding.left())),
						0),
					0);
			}
		}, lifetime());
	}, lifetime());
}

void BubbleWidget::setupParticles(not_null<Ui::RpWidget*> parent) {
	_particles.emplace(StarParticles::Type::Radial, 50, st::lineWidth * 4);
	_particles->setSpeed(0.1);

	_particlesWidget = Ui::CreateChild<Ui::RpWidget>(parent);
	_particlesWidget->setAttribute(Qt::WA_TransparentForMouseEvents);
	_particlesWidget->show();
	_particlesWidget->raise();

	_particlesAnimation.init([=] { _particlesWidget->update(); });

	_particlesWidget->paintRequest() | rpl::on_next([=] {
		if (!_particlesAnimation.animating()) {
			_particlesAnimation.start();
		}
		auto p = QPainter(_particlesWidget);
		auto hq = PainterHighQualityEnabler(p);

		const auto offset = QPoint(
			(_particlesWidget->width() - width()) / 2,
			(_particlesWidget->height() - height()) / 2);
		const auto bubbleRect = rect().translated(offset)
			- QMargins(
				_spaceForDeflection.width(),
				_spaceForDeflection.height(),
				_spaceForDeflection.width(),
				_spaceForDeflection.height());

		p.save();
		p.translate(offset);
		const auto bubblePath = _bubble.bubblePath(bubbleRect);
		p.restore();

		auto fullRect = QPainterPath();
		fullRect.addRect(QRectF(_particlesWidget->rect()));

		p.setClipPath(bubblePath);
		_particles->setColor(st::premiumButtonFg->c);
		_particles->paint(p, _particlesWidget->rect(), crl::now());
		p.setClipping(false);

		p.setClipPath(fullRect.subtracted(bubblePath));
		_particles->setColor(_brushOverride
			? st::groupCallMemberInactiveIcon->c
			: st::creditsBg3->c);
		_particles->paint(p, _particlesWidget->rect(), crl::now());
	}, _particlesWidget->lifetime());

	geometryValue() | rpl::on_next([=](QRect geometry) {
		const auto particlesSize = QSize(
			int(geometry.width() * 1.5),
			int(geometry.height() * 1.5));
		const auto center = geometry.center();
		_particlesWidget->setGeometry(
			center.x() - particlesSize.width() / 2,
			center.y() - particlesSize.height() / 2,
			particlesSize.width(),
			particlesSize.height());
	}, lifetime());
}

void BubbleWidget::animateTo(BubbleRowState state) {
	const auto targetWidth = _bubble.countTargetWidth(state.counter);
	const auto parent = parentWidget();
	const auto available = parent->width()
		- _outerPadding.left()
		- _outerPadding.right();
	const auto halfWidth = (targetWidth / 2);
	const auto computeLeft = [=](float64 pointRatio, float64 animProgress) {
		const auto delta = (pointRatio - _animatingFromResultRatio);
		const auto center = available
			* (_animatingFromResultRatio + delta * animProgress);
		return center - halfWidth + _outerPadding.left();
	};
	const auto moveEndPoint = state.ratio;
	const auto computeRightEdge = [=] {
		return parent->width() - _outerPadding.right() - targetWidth;
	};
	struct Edge final {
		float64 goodPointRatio = 0.;
		float64 bubbleEdge = 0.;
	};
	const auto desiredFinish = computeLeft(moveEndPoint, 1.);
	const auto leftEdge = [&]() -> Edge {
		const auto edge = _outerPadding.left();
		if (desiredFinish < edge) {
			const auto goodPointRatio = float64(halfWidth) / available;
			const auto bubbleLeftEdge = (desiredFinish - edge)
				/ float64(halfWidth);
			return { goodPointRatio, bubbleLeftEdge };
		}
		return {};
	}();
	const auto rightEdge = [&]() -> Edge {
		const auto edge = computeRightEdge();
		if (desiredFinish > edge) {
			const auto goodPointRatio = 1. - float64(halfWidth) / available;
			const auto bubbleRightEdge = (desiredFinish - edge)
				/ float64(halfWidth);
			return { goodPointRatio, bubbleRightEdge };
		}
		return {};
	}();
	const auto finalEdge = (leftEdge.bubbleEdge < 0.)
		? leftEdge.bubbleEdge
		: rightEdge.bubbleEdge;
	_ignoreDeflection = !_state.current().dynamic && (finalEdge != 0.);
	if (_ignoreDeflection) {
		_stepBeforeDeflection = 1.;
		_stepAfterDeflection = 1.;
	} else {
		_stepBeforeDeflection = kStepBeforeDeflection;
		_stepAfterDeflection = kStepAfterDeflection;
	}
	const auto resultMoveEndPoint = (finalEdge < 0)
		? leftEdge.goodPointRatio
		: (finalEdge > 0)
		? rightEdge.goodPointRatio
		: moveEndPoint;

	const auto duration = kSlideDuration
		* (_ignoreDeflection ? kStepBeforeDeflection : 1.)
		* ((_state.current().ratio < 0.001) ? 0.5 : 1.);
	if (state.animateFromZero) {
		_animatingFrom.ratio = 0.;
		_animatingFrom.counter = 0;
		_animatingFromResultRatio = 0.;
		_animatingFromBubbleEdge = 0.;
	}
	_appearanceCallback = [=](float64 value) {
		if (!_appearanceAnimation.animating()) {
			_animatingFrom = state;
			_animatingFromResultRatio = resultMoveEndPoint;
			_animatingFromBubbleEdge = finalEdge;
			_appearanceCallback = nullptr;
		}
		value = std::abs(value);
		const auto moveProgress = std::clamp(
			(value / _stepBeforeDeflection),
			0.,
			1.);
		const auto counterProgress = std::clamp(
			(value / _stepAfterDeflection),
			0.,
			1.);
		const auto nowBubbleEdge = _animatingFromBubbleEdge
			+ (finalEdge - _animatingFromBubbleEdge) * moveProgress;
		moveToLeft(-_spaceForDeflection.width()
			+ std::max(
				int(base::SafeRound(
					computeLeft(resultMoveEndPoint, moveProgress))),
				0),
			0);

		const auto now = _animatingFrom.counter
			+ counterProgress * (state.counter - _animatingFrom.counter);
		_bubble.setCounter(int(base::SafeRound(now)));

		if (_particles) {
			const auto progress = now / float(state.counter);
			_particles->setSpeed(0.01 + progress * 0.25);
		}

		_bubble.setFlipHorizontal(nowBubbleEdge < 0);
		_bubble.setTailEdge(std::abs(nowBubbleEdge));
		update();
	};
	_appearanceAnimation.start(
		_appearanceCallback,
		0.,
		(state.ratio >= _animatingFrom.ratio) ? 1. : -1.,
		duration,
		anim::easeOutCirc);
}

void BubbleWidget::setBrushOverride(std::optional<QBrush> brushOverride) {
	_brushOverride = std::move(brushOverride);
	update();
}

void BubbleWidget::setSubtext(QString subtext) {
	_bubble.setSubtext(subtext);
}

void BubbleWidget::paintEvent(QPaintEvent *e) {
	if (!_bubble.counter().has_value()) {
		return;
	}

	auto p = QPainter(this);

	const auto padding = QMargins(
		_spaceForDeflection.width(),
		_spaceForDeflection.height(),
		_spaceForDeflection.width(),
		_spaceForDeflection.height());
	const auto bubbleRect = rect() - padding;

	const auto params = GradientParams{
		.left = x() + _spaceForDeflection.width(),
		.width = bubbleRect.width(),
		.outer = parentWidget()->parentWidget()->width(),
	};
	if (_cachedGradientParams != params) {
		_cachedGradient = ComputeGradient(
			parentWidget(),
			params.left,
			params.width);
		_cachedGradientParams = params;
	}
	if (_appearanceAnimation.animating()) {
		const auto value = _appearanceAnimation.value(1.);
		const auto progress = std::abs(value);
		const auto finalScale = (_animatingFromResultRatio > 0.)
			|| (_state.current().ratio < 0.001);
		const auto scaleProgress = finalScale
			? 1.
			: std::clamp((progress / _stepBeforeDeflection), 0., 1.);
		const auto scale = scaleProgress;
		const auto rotationProgress = std::clamp(
			(progress - _stepBeforeDeflection) / (1. - _stepBeforeDeflection),
			0.,
			1.);
		const auto rotationProgressReverse = std::clamp(
			(progress - _stepAfterDeflection) / (1. - _stepAfterDeflection),
			0.,
			1.);

		const auto offsetX = bubbleRect.x() + bubbleRect.width() / 2;
		const auto offsetY = bubbleRect.y() + bubbleRect.height();
		p.translate(offsetX, offsetY);
		p.scale(scale, scale);
		if (!_ignoreDeflection) {
			p.rotate((rotationProgress - rotationProgressReverse)
				* _deflection
				* (value < 0. ? -1. : 1.));
		}
		p.translate(-offsetX, -offsetY);
	}


	_bubble.paintBubble(p, bubbleRect, [&] {
		if (_brushOverride) {
			return *_brushOverride;
		}
		switch (_type) {
		case BubbleType::NoPremium:
		case BubbleType::UpgradePrice:
		case BubbleType::StarRating: return st::windowBgActive->b;
		case BubbleType::NegativeRating: return st::attentionButtonFg->b;
		case BubbleType::Premium: return QBrush(_cachedGradient);
		case BubbleType::Credits: return st::creditsBg3->b;
		}
		Unexpected("Type in Premium::BubbleWidget.");
	}());
}

void BubbleWidget::resizeEvent(QResizeEvent *e) {
	RpWidget::resizeEvent(e);
}

not_null<BubbleWidget*> AddBubbleRow(
		not_null<Ui::VerticalLayout*> parent,
		const style::PremiumBubble &st,
		rpl::producer<> showFinishes,
		int min,
		int current,
		int max,
		BubbleType type,
		std::optional<tr::phrase<lngtag_count>> phrase,
		const style::icon *icon) {
	return AddBubbleRow(
		parent,
		st,
		std::move(showFinishes),
		rpl::single(BubbleRowState{
			.counter = current,
			.ratio = (current - min) / float64(max - min),
		}),
		type,
		ProcessTextFactory(phrase),
		icon,
		st::boxRowPadding);
}

not_null<BubbleWidget*> AddBubbleRow(
		not_null<Ui::VerticalLayout*> parent,
		const style::PremiumBubble &st,
		rpl::producer<> showFinishes,
		rpl::producer<BubbleRowState> state,
		BubbleType type,
		TextFactory text,
		const style::icon *icon,
		const style::margins &outerPadding) {
	const auto container = parent->add(
		object_ptr<Ui::FixedHeightWidget>(parent, 0));
	container->show();

	const auto bubble = Ui::CreateChild<BubbleWidget>(
		container,
		st,
		text ? std::move(text) : ProcessTextFactory(std::nullopt),
		std::move(state),
		type,
		std::move(showFinishes),
		icon,
		outerPadding);
	bubble->setAttribute(Qt::WA_TransparentForMouseEvents);
	rpl::combine(
		container->sizeValue(),
		bubble->sizeValue()
	) | rpl::on_next([=](const QSize &parentSize, const QSize &size) {
		container->resize(parentSize.width(), size.height());
	}, bubble->lifetime());
	bubble->show();
	return bubble;
}

} // namespace Ui::Premium