/*
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 "info/statistics/info_statistics_inner_widget.h"

#include "api/api_statistics.h"
#include "apiwrap.h"
#include "base/call_delayed.h"
#include "base/event_filter.h"
#include "data/data_peer.h"
#include "data/data_session.h"
#include "data/data_stories.h"
#include "data/data_story.h"
#include "history/history_item.h"
#include "info/info_controller.h"
#include "info/info_memento.h"
#include "info/statistics/info_statistics_list_controllers.h"
#include "info/statistics/info_statistics_recent_message.h"
#include "info/statistics/info_statistics_widget.h"
#include "lang/lang_keys.h"
#include "lottie/lottie_icon.h"
#include "main/main_session.h"
#include "settings/settings_common.h" // CreateLottieIcon.
#include "statistics/chart_widget.h"
#include "statistics/statistics_common.h"
#include "statistics/statistics_format_values.h"
#include "statistics/widgets/chart_header_widget.h"
#include "ui/layers/generic_box.h"
#include "ui/rect.h"
#include "ui/vertical_list.h"
#include "ui/toast/toast.h"
#include "ui/widgets/buttons.h"
#include "ui/widgets/popup_menu.h"
#include "ui/widgets/scroll_area.h"
#include "ui/wrap/slide_wrap.h"
#include "styles/style_boxes.h"
#include "styles/style_menu_icons.h"
#include "styles/style_settings.h"
#include "styles/style_statistics.h"

namespace Info::Statistics {
namespace {

struct Descriptor final {
	not_null<PeerData*> peer;
	not_null<Api::Statistics*> api;
	not_null<QWidget*> toastParent;
};

void AddContextMenu(
		not_null<Ui::RpWidget*> button,
		not_null<Controller*> controller,
		not_null<HistoryItem*> item) {
	const auto fullId = item->fullId();
	const auto contextMenu = button->lifetime()
		.make_state<base::unique_qptr<Ui::PopupMenu>>();
	const auto showMenu = [=] {
		*contextMenu = base::make_unique_q<Ui::PopupMenu>(
			button,
			st::popupMenuWithIcons);
		const auto go = [=] {
			const auto &session = controller->parentController();
			if (const auto item = session->session().data().message(fullId)) {
				session->showMessage(item);
			}
		};
		contextMenu->get()->addAction(
			tr::lng_context_to_msg(tr::now),
			crl::guard(controller, go),
			&st::menuIconShowInChat);
		contextMenu->get()->popup(QCursor::pos());
	};

	base::install_event_filter(button, [=](not_null<QEvent*> e) {
		if (e->type() == QEvent::ContextMenu) {
			showMenu();
			return base::EventFilterResult::Cancel;
		}
		return base::EventFilterResult::Continue;
	});
}

void ProcessZoom(
		const Descriptor &d,
		not_null<Statistic::ChartWidget*> widget,
		const QString &zoomToken,
		Statistic::ChartViewType type) {
	if (zoomToken.isEmpty()) {
		return;
	}
	widget->zoomRequests(
	) | rpl::start_with_next([=](float64 x) {
		d.api->requestZoom(
			zoomToken,
			x
		) | rpl::start_with_next_error_done([=](
				const Data::StatisticalGraph &graph) {
			if (graph.chart) {
				widget->setZoomedChartData(graph.chart, x, type);
			} else if (!graph.error.isEmpty()) {
				Ui::Toast::Show(d.toastParent, graph.error);
			}
		}, [=](const QString &error) {
		}, [=] {
		}, widget->lifetime());
	}, widget->lifetime());
}

void FillStatistic(
		not_null<Ui::VerticalLayout*> content,
		const Descriptor &descriptor,
		Data::AnyStatistics &stats,
		Fn<void()> done) {
	using Type = Statistic::ChartViewType;
	const auto &padding = st::statisticsChartEntryPadding;
	const auto &m = st::statisticsLayerMargins;
	const auto addSkip = [&](not_null<Ui::VerticalLayout*> c) {
		Ui::AddSkip(c, padding.bottom());
		Ui::AddDivider(c);
		Ui::AddSkip(c, padding.top());
	};
	struct State final {
		Fn<void()> done;
		int pendingCount = 0;
	};
	const auto state = content->lifetime().make_state<State>(
		State{ std::move(done) });

	const auto singlePendingDone = [=] {
		state->pendingCount--;
		if (!state->pendingCount && state->done) {
			base::take(state->done)();
		}
	};

	const auto addChart = [&](
			Data::StatisticalGraph &graphData,
			rpl::producer<QString> &&title,
			Statistic::ChartViewType type) {
		if (graphData.chart) {
			const auto widget = content->add(
				object_ptr<Statistic::ChartWidget>(content),
				m);

			widget->setChartData(graphData.chart, type);
			ProcessZoom(descriptor, widget, graphData.zoomToken, type);
			widget->setTitle(std::move(title));

			addSkip(content);
		} else if (!graphData.zoomToken.isEmpty()) {
			state->pendingCount++;
			const auto wrap = content->add(
				object_ptr<Ui::SlideWrap<Ui::VerticalLayout>>(
					content,
					object_ptr<Ui::VerticalLayout>(content)));
			wrap->toggle(false, anim::type::instant);
			const auto widget = wrap->entity()->add(
				object_ptr<Statistic::ChartWidget>(content),
				m);

			descriptor.api->requestZoom(
				graphData.zoomToken,
				0
			) | rpl::start_with_next_error_done([=, graphPtr = &graphData](
					const Data::StatisticalGraph &graph) mutable {
				{
					// Save the loaded async data to cache.
					// Guarded by content->lifetime().
					*graphPtr = graph;
				}

				if (graph.chart) {
					widget->setChartData(graph.chart, type);
					wrap->toggle(true, anim::type::instant);
					ProcessZoom(descriptor, widget, graph.zoomToken, type);
					widget->setTitle(rpl::duplicate(title));
				} else if (!graph.error.isEmpty()) {
				}
			}, [=](const QString &error) {
				singlePendingDone();
			}, [=] {
				singlePendingDone();
			}, content->lifetime());

			addSkip(wrap->entity());
		}
	};
	addSkip(content);
	if (stats.channel) {
		addChart(
			stats.channel.memberCountGraph,
			tr::lng_chart_title_member_count(),
			Type::Linear);
		addChart(
			stats.channel.joinGraph,
			tr::lng_chart_title_join(),
			Type::Linear);
		addChart(
			stats.channel.muteGraph,
			tr::lng_chart_title_mute(),
			Type::Linear);
		addChart(
			stats.channel.viewCountByHourGraph,
			tr::lng_chart_title_view_count_by_hour(),
			Type::Linear);
		addChart(
			stats.channel.viewCountBySourceGraph,
			tr::lng_chart_title_view_count_by_source(),
			Type::StackBar);
		addChart(
			stats.channel.joinBySourceGraph,
			tr::lng_chart_title_join_by_source(),
			Type::StackBar);
		addChart(
			stats.channel.languageGraph,
			tr::lng_chart_title_language(),
			Type::StackLinear);
		addChart(
			stats.channel.messageInteractionGraph,
			tr::lng_chart_title_message_interaction(),
			Type::DoubleLinear);
		addChart(
			stats.channel.instantViewInteractionGraph,
			tr::lng_chart_title_instant_view_interaction(),
			Type::DoubleLinear);
		addChart(
			stats.channel.reactionsByEmotionGraph,
			tr::lng_chart_title_reactions_by_emotion(),
			Type::Bar);
		addChart(
			stats.channel.storyInteractionsGraph,
			tr::lng_chart_title_story_interactions(),
			Type::DoubleLinear);
		addChart(
			stats.channel.storyReactionsByEmotionGraph,
			tr::lng_chart_title_story_reactions_by_emotion(),
			Type::Bar);
	} else if (stats.supergroup) {
		addChart(
			stats.supergroup.memberCountGraph,
			tr::lng_chart_title_member_count(),
			Type::Linear);
		addChart(
			stats.supergroup.joinGraph,
			tr::lng_chart_title_group_join(),
			Type::Linear);
		addChart(
			stats.supergroup.joinBySourceGraph,
			tr::lng_chart_title_group_join_by_source(),
			Type::StackBar);
		addChart(
			stats.supergroup.languageGraph,
			tr::lng_chart_title_group_language(),
			Type::StackLinear);
		addChart(
			stats.supergroup.messageContentGraph,
			tr::lng_chart_title_group_message_content(),
			Type::StackBar);
		addChart(
			stats.supergroup.actionGraph,
			tr::lng_chart_title_group_action(),
			Type::DoubleLinear);
		addChart(
			stats.supergroup.dayGraph,
			tr::lng_chart_title_group_day(),
			Type::Linear);
		addChart(
			stats.supergroup.weekGraph,
			tr::lng_chart_title_group_week(),
			Type::StackLinear);
	} else {
		auto &messageOrStory = stats.message
			? stats.message
			: stats.story;
		if (messageOrStory) {
			addChart(
				messageOrStory.messageInteractionGraph,
				tr::lng_chart_title_message_interaction(),
				Type::DoubleLinear);
			addChart(
				messageOrStory.reactionsByEmotionGraph,
				tr::lng_chart_title_reactions_by_emotion(),
				Type::Bar);
		}
	}
	if (!state->pendingCount) {
		++state->pendingCount;
		singlePendingDone();
	}
}

void AddHeader(
		not_null<Ui::VerticalLayout*> content,
		tr::phrase<> text,
		const Data::AnyStatistics &stats) {
	const auto startDate = stats.channel
		? stats.channel.startDate
		: stats.supergroup.startDate;
	const auto endDate = stats.channel
		? stats.channel.endDate
		: stats.supergroup.endDate;
	const auto header = content->add(
		object_ptr<Statistic::Header>(content),
		st::statisticsLayerMargins + st::statisticsChartHeaderPadding);
	header->resizeToWidth(header->width());
	header->setTitle(text(tr::now));
	if (!endDate || !startDate) {
		header->setSubTitle({});
		return;
	}
	header->setSubTitle(Statistic::LangDayMonthYear(startDate)
		+ ' '
		+ QChar(8212)
		+ ' '
		+ Statistic::LangDayMonthYear(endDate));
}

void FillOverview(
		not_null<Ui::VerticalLayout*> content,
		const Data::AnyStatistics &stats,
		bool isChannelStoryStats) {
	using Value = Data::StatisticalValue;

	const auto &channel = stats.channel;
	const auto &supergroup = stats.supergroup;

	if (!isChannelStoryStats) {
		Ui::AddSkip(content, st::statisticsLayerOverviewMargins.top());
		AddHeader(content, tr::lng_stats_overview_title, stats);
		Ui::AddSkip(content);
	}

	struct Second final {
		QColor color;
		QString text;
	};

	const auto parseSecond = [&](const Value &v) -> Second {
		const auto diff = v.value - v.previousValue;
		if (!diff || !v.previousValue) {
			return {};
		}
		constexpr auto kTooMuchDiff = int(1'000'000);
		const auto diffAbs = std::abs(diff);
		const auto diffText = diffAbs > kTooMuchDiff
			? Lang::FormatCountToShort(std::abs(diff)).string
			: QString::number(diffAbs);
		const auto percentage = std::abs(v.growthRatePercentage);
		const auto precision = (percentage == int(percentage)) ? 0 : 1;
		return {
			(diff < 0 ? st::menuIconAttentionColor : st::settingsIconBg2)->c,
			QString("%1%2 (%3%)")
				.arg((diff < 0) ? QChar(0x2212) : QChar(0x002B))
				.arg(diffText)
				.arg(QString::number(percentage, 'f', precision))
		};
	};

	const auto diffBetweenHeaders = 0
		+ st::statisticsOverviewValue.style.font->height
		- st::statisticsHeaderTitleTextStyle.font->height;

	const auto container = content->add(
		object_ptr<Ui::RpWidget>(content),
		st::statisticsLayerMargins);

	const auto addPrimary = [&](const Value &v) {
		return Ui::CreateChild<Ui::FlatLabel>(
			container,
			(v.value >= 0)
				? Lang::FormatCountToShort(v.value).string
				: QString(),
			st::statisticsOverviewValue);
	};
	const auto addSub = [&](
			not_null<Ui::RpWidget*> primary,
			const Value &v,
			tr::phrase<> text) {
		const auto data = parseSecond(v);
		const auto second = Ui::CreateChild<Ui::FlatLabel>(
			container,
			data.text,
			st::statisticsOverviewSecondValue);
		second->setTextColorOverride(data.color);
		const auto sub = Ui::CreateChild<Ui::FlatLabel>(
			container,
			text(),
			st::statisticsOverviewSubtext);
		sub->setTextColorOverride(st::windowSubTextFg->c);

		primary->geometryValue(
		) | rpl::start_with_next([=](const QRect &g) {
			const auto &padding = st::statisticsOverviewSecondValuePadding;
			second->moveToLeft(
				rect::right(g) + padding.left(),
				g.y() + padding.top());
			sub->moveToLeft(
				g.x(),
				st::statisticsChartHeaderHeight
					- st::statisticsOverviewSubtext.style.font->height
					+ g.y()
					+ diffBetweenHeaders);
		}, primary->lifetime());
	};

	const auto isChannel = (!!channel);
	const auto &messageOrStory = stats.message ? stats.message : stats.story;
	const auto isMessage = (!!messageOrStory);

	const auto hasPostReactions = isChannel
		&& (channel.meanReactionCount.value
			|| channel.meanReactionCount.previousValue);

	const auto topLeftLabel = (isChannelStoryStats && isChannel)
		? addPrimary(channel.meanShareCount)
		: isChannel
		? addPrimary(channel.memberCount)
		: isMessage
		? addPrimary({ .value = float64(messageOrStory.views) })
		: addPrimary(supergroup.memberCount);
	const auto topRightLabel = (isChannelStoryStats && isChannel)
		? addPrimary(channel.meanStoryShareCount)
		: isChannel
		? Ui::CreateChild<Ui::FlatLabel>(
			container,
			QString("%1%").arg(0.01
				* std::round(channel.enabledNotificationsPercentage * 100.)),
			st::statisticsOverviewValue)
		: isMessage
		? addPrimary({ .value = float64(messageOrStory.publicForwards) })
		: addPrimary(supergroup.messageCount);
	const auto bottomLeftLabel = (isChannelStoryStats && isChannel)
		? addPrimary(hasPostReactions
			? channel.meanReactionCount
			: channel.meanStoryReactionCount)
		: isChannel
		? addPrimary(channel.meanViewCount)
		: isMessage
		? addPrimary({ .value = float64(messageOrStory.reactions) })
		: addPrimary(supergroup.viewerCount);
	const auto bottomRightLabel = (isChannelStoryStats && isChannel)
		? addPrimary(!hasPostReactions
			? Value{ .value = -1 }
			: channel.meanStoryReactionCount)
		: isChannel
		? addPrimary(channel.meanStoryViewCount)
		: isMessage
		? addPrimary({ .value = float64(messageOrStory.privateForwards) })
		: addPrimary(supergroup.senderCount);
	if (isChannelStoryStats && isChannel) {
		addSub(
			topLeftLabel,
			channel.meanShareCount,
			tr::lng_stats_overview_mean_share_count);
		addSub(
			topRightLabel,
			channel.meanStoryShareCount,
			tr::lng_stats_overview_mean_story_share_count);
		addSub(
			bottomLeftLabel,
			hasPostReactions
				? channel.meanReactionCount
				: channel.meanStoryReactionCount,
			hasPostReactions
				? tr::lng_stats_overview_mean_reactions_count
				: tr::lng_stats_overview_mean_story_reactions_count);
		if (hasPostReactions) {
			addSub(
				bottomRightLabel,
				channel.meanStoryReactionCount,
				tr::lng_stats_overview_mean_story_reactions_count);
		}
	} else if (const auto &s = channel) {
		addSub(
			topLeftLabel,
			s.memberCount,
			tr::lng_stats_overview_member_count);
		addSub(
			topRightLabel,
			{},
			tr::lng_stats_overview_enabled_notifications);
		addSub(
			bottomLeftLabel,
			s.meanViewCount,
			tr::lng_stats_overview_mean_view_count);
		addSub(
			bottomRightLabel,
			s.meanStoryViewCount,
			tr::lng_stats_overview_mean_story_view_count);
	} else if (const auto &s = supergroup) {
		addSub(
			topLeftLabel,
			s.memberCount,
			tr::lng_manage_peer_members);
		addSub(
			topRightLabel,
			s.messageCount,
			tr::lng_stats_overview_messages);
		addSub(
			bottomLeftLabel,
			s.viewerCount,
			tr::lng_stats_overview_group_mean_view_count);
		addSub(
			bottomRightLabel,
			s.senderCount,
			tr::lng_stats_overview_group_mean_post_count);
	} else if (const auto &s = messageOrStory) {
		if (s.views >= 0) {
			addSub(
				topLeftLabel,
				{},
				tr::lng_stats_overview_message_views);
		}
		if (s.publicForwards >= 0) {
			addSub(
				topRightLabel,
				{},
				tr::lng_stats_overview_message_public_shares);
		}
		if (s.reactions >= 0) {
			addSub(
				bottomLeftLabel,
				{},
				tr::lng_manage_peer_reactions);
		}
		if (s.privateForwards >= 0) {
			addSub(
				bottomRightLabel,
				{},
				tr::lng_stats_overview_message_private_shares);
		}
	}
	container->showChildren();
	container->resize(container->width(), topLeftLabel->height() * 5);
	container->sizeValue(
	) | rpl::start_with_next([=](const QSize &s) {
		const auto halfWidth = s.width() / 2;
		{
			const auto &p = st::statisticsOverviewValuePadding;
			topLeftLabel->moveToLeft(p.left(), p.top());
		}
		topRightLabel->moveToLeft(
			topLeftLabel->x() + halfWidth + st::statisticsOverviewRightSkip,
			topLeftLabel->y());
		bottomLeftLabel->moveToLeft(
			topLeftLabel->x(),
			topLeftLabel->y() + st::statisticsOverviewMidSkip);
		bottomRightLabel->moveToLeft(
			topRightLabel->x(),
			bottomLeftLabel->y());
	}, container->lifetime());
	Ui::AddSkip(content, st::statisticsLayerOverviewMargins.bottom());
}

} // namespace

void FillLoading(
		not_null<Ui::VerticalLayout*> container,
		rpl::producer<bool> toggleOn,
		rpl::producer<> showFinished) {
	const auto emptyWrap = container->add(
		object_ptr<Ui::SlideWrap<Ui::VerticalLayout>>(
			container,
			object_ptr<Ui::VerticalLayout>(container)));
	emptyWrap->toggleOn(std::move(toggleOn), anim::type::instant);

	const auto content = emptyWrap->entity();
	auto icon = ::Settings::CreateLottieIcon(
		content,
		{ .name = u"stats"_q, .sizeOverride = Size(st::changePhoneIconSize) },
		st::settingsBlockedListIconPadding);

	(
		std::move(showFinished) | rpl::take(1)
	) | rpl::start_with_next([animate = std::move(icon.animate)] {
		animate(anim::repeat::loop);
	}, icon.widget->lifetime());
	content->add(std::move(icon.widget));

	content->add(
		object_ptr<Ui::CenterWrap<>>(
			content,
			object_ptr<Ui::FlatLabel>(
				content,
				tr::lng_stats_loading(),
				st::changePhoneTitle)),
		st::changePhoneTitlePadding + st::boxRowPadding);

	content->add(
		object_ptr<Ui::CenterWrap<>>(
			content,
			object_ptr<Ui::FlatLabel>(
				content,
				tr::lng_stats_loading_subtext(),
				st::statisticsLoadingSubtext)),
		st::changePhoneDescriptionPadding + st::boxRowPadding);

	Ui::AddSkip(content, st::settingsBlockedListIconPadding.top());
}

InnerWidget::InnerWidget(
	QWidget *parent,
	not_null<Controller*> controller,
	not_null<PeerData*> peer,
	FullMsgId contextId,
	FullStoryId storyId)
: VerticalLayout(parent)
, _controller(controller)
, _peer(peer)
, _contextId(contextId)
, _storyId(storyId) {
}

void InnerWidget::load() {
	const auto inner = this;

	const auto descriptor = Descriptor{
		_peer,
		lifetime().make_state<Api::Statistics>(_peer->asChannel()),
		_controller->uiShow()->toastParent(),
	};

	FillLoading(
		inner,
		_loaded.events_starting_with(false) | rpl::map(!rpl::mappers::_1),
		_showFinished.events());

	_showFinished.events(
	) | rpl::take(1) | rpl::start_with_next([=] {
		if (!_contextId && !_storyId) {
			descriptor.api->request(
			) | rpl::start_with_done([=] {
				_state.stats = Data::AnyStatistics{
					descriptor.api->channelStats(),
					descriptor.api->supergroupStats(),
				};
				fill();

			}, lifetime());
		} else {
			const auto lifetimeApi = lifetime().make_state<rpl::lifetime>();
			const auto api = _storyId
				? lifetimeApi->make_state<Api::MessageStatistics>(
					descriptor.peer->asChannel(),
					_storyId)
				: lifetimeApi->make_state<Api::MessageStatistics>(
					descriptor.peer->asChannel(),
					_contextId);

			api->request([=](const Data::StoryStatistics &data) {
				_state.stats = Data::AnyStatistics{
					.message = _contextId ? data : Data::StoryStatistics(),
					.story = _storyId ? data : Data::StoryStatistics(),
				};
				if (_contextId || _storyId) {
					_state.publicForwardsFirstSlice = api->firstSlice();
				}
				fill();

				lifetimeApi->destroy();
			});
		}
	}, lifetime());
}

void InnerWidget::fill() {
	const auto wrap = this->add(
		object_ptr<Ui::SlideWrap<Ui::VerticalLayout>>(
			this,
			object_ptr<Ui::VerticalLayout>(this)));
	wrap->toggle(false, anim::type::instant);
	const auto inner = wrap->entity();
	const auto descriptor = Descriptor{
		_peer,
		lifetime().make_state<Api::Statistics>(_peer->asChannel()),
		_controller->uiShow()->toastParent(),
	};
	const auto finishLoading = [=] {
		_loaded.fire(true);
		wrap->toggle(true, anim::type::instant);
		this->resizeToWidth(width());
		this->showChildren();
	};
	if (_state.stats.message) {
		if (const auto i = _peer->owner().message(_contextId)) {
			Ui::AddSkip(inner);
			const auto preview = inner->add(
				object_ptr<MessagePreview>(inner, i, QImage()));
			AddContextMenu(preview, _controller, i);
			Ui::AddSkip(inner);
			Ui::AddDivider(inner);
		}
	} else if (_state.stats.story) {
		if (const auto story = _peer->owner().stories().lookup(_storyId)) {
			Ui::AddSkip(inner);
			const auto preview = inner->add(
				object_ptr<MessagePreview>(inner, *story, QImage()));
			preview->setAttribute(Qt::WA_TransparentForMouseEvents);
			Ui::AddSkip(inner);
			Ui::AddDivider(inner);
		}
	}
	FillOverview(inner, _state.stats, false);
	if (_state.stats.channel) {
		FillOverview(inner, _state.stats, true);
	}
	FillStatistic(inner, descriptor, _state.stats, finishLoading);
	const auto &channel = _state.stats.channel;
	const auto &supergroup = _state.stats.supergroup;
	if (channel) {
		fillRecentPosts(inner);
	} else if (supergroup) {
		const auto showPeerInfo = [=](not_null<PeerData*> peer) {
			_showRequests.fire({ .info = peer->id });
		};
		const auto addSkip = [&](not_null<Ui::VerticalLayout*> c) {
			Ui::AddSkip(c);
			Ui::AddDivider(c);
			Ui::AddSkip(c);
			Ui::AddSkip(c);
		};
		if (!supergroup.topSenders.empty()) {
			AddMembersList(
				{ .topSenders = supergroup.topSenders },
				inner,
				showPeerInfo,
				descriptor.peer,
				tr::lng_stats_members_title());
		}
		if (!supergroup.topAdministrators.empty()) {
			addSkip(inner);
			AddMembersList(
				{ .topAdministrators
					= supergroup.topAdministrators },
				inner,
				showPeerInfo,
				descriptor.peer,
				tr::lng_stats_admins_title());
		}
		if (!supergroup.topInviters.empty()) {
			addSkip(inner);
			AddMembersList(
				{ .topInviters = supergroup.topInviters },
				inner,
				showPeerInfo,
				descriptor.peer,
				tr::lng_stats_inviters_title());
		}
	} else if (_state.stats.message || _state.stats.story) {
		using namespace Data;
		AddPublicForwards(
			_state.publicForwardsFirstSlice,
			inner,
			[=](RecentPostId id) {
				_showRequests.fire({
					.info = (!id.messageId && !id.storyId)
						? id.messageId.peer
						: PeerId(0),
					.history = id.messageId,
					.story = id.storyId,
				});
			},
			descriptor.peer,
			RecentPostId{ .messageId = _contextId, .storyId = _storyId });
	}
}

void InnerWidget::fillRecentPosts(not_null<Ui::VerticalLayout*> container) {
	const auto &stats = _state.stats.channel;
	if (!stats || stats.recentMessageInteractions.empty()) {
		return;
	}
	_messagePreviews.reserve(stats.recentMessageInteractions.size());

	const auto wrap = container->add(
		object_ptr<Ui::SlideWrap<Ui::VerticalLayout>>(
			container,
			object_ptr<Ui::VerticalLayout>(container)));
	const auto content = wrap->entity();
	AddHeader(content, tr::lng_stats_recent_messages_title, { stats, {} });
	Ui::AddSkip(content);

	const auto addMessage = [=](
			not_null<Ui::VerticalLayout*> messageWrap,
			HistoryItem *maybeItem,
			Data::Story *maybeStory,
			const Data::StatisticsMessageInteractionInfo &info) {
		const auto button = messageWrap->add(
			object_ptr<Ui::SettingsButton>(
				messageWrap,
				rpl::never<QString>(),
				st::statisticsRecentPostButton));
		const auto fullRecentId = Data::RecentPostId{
			.messageId = maybeItem ? maybeItem->fullId() : FullMsgId(),
			.storyId = maybeStory ? maybeStory->fullId() : FullStoryId(),
		};
		auto it = _state.recentPostPreviews.find(fullRecentId);
		auto cachedPreview = (it != end(_state.recentPostPreviews))
			? base::take(it->second)
			: QImage();
		const auto raw = maybeItem
			? Ui::CreateChild<MessagePreview>(
				button,
				maybeItem,
				std::move(cachedPreview))
			: Ui::CreateChild<MessagePreview>(
				button,
				maybeStory,
				std::move(cachedPreview));
		raw->setInfo(
			info.viewsCount,
			info.forwardsCount,
			info.reactionsCount);

		if (maybeItem) {
			AddContextMenu(button, _controller, maybeItem);
		}

		_messagePreviews.push_back(raw);
		raw->show();
		button->sizeValue(
		) | rpl::start_with_next([=](const QSize &s) {
			if (!s.isNull()) {
				raw->setGeometry(Rect(s)
					- st::statisticsRecentPostButton.padding);
			}
		}, raw->lifetime());
		button->setClickedCallback([=] {
			_showRequests.fire({
				.messageStatistic = fullRecentId.messageId,
				.storyStatistic = fullRecentId.storyId,
			});
		});
		Ui::AddSkip(messageWrap);
		if (!wrap->toggled()) {
			wrap->toggle(true, anim::type::normal);
		}
	};

	const auto buttonWrap = container->add(
		object_ptr<Ui::SlideWrap<Ui::SettingsButton>>(
			container,
			object_ptr<Ui::SettingsButton>(
				container,
				tr::lng_stories_show_more())));

	constexpr auto kFirstPage = int(10);
	constexpr auto kPerPage = int(30);
	const auto max = int(stats.recentMessageInteractions.size());
	if (_state.recentPostsExpanded) {
		_state.recentPostsExpanded = std::max(
			_state.recentPostsExpanded - kPerPage,
			0);
	}
	const auto showMore = [=] {
		const auto from = _state.recentPostsExpanded;
		_state.recentPostsExpanded = std::min(
			max,
			_state.recentPostsExpanded
				? (_state.recentPostsExpanded + kPerPage)
				: kFirstPage);
		if (_state.recentPostsExpanded == max) {
			buttonWrap->toggle(false, anim::type::instant);
		}
		for (auto i = from; i < _state.recentPostsExpanded; i++) {
			const auto &recent = stats.recentMessageInteractions[i];
			const auto messageWrap = content->add(
				object_ptr<Ui::VerticalLayout>(content));
			auto &data = _peer->owner();
			if (recent.messageId) {
				const auto fullId = FullMsgId(_peer->id, recent.messageId);
				if (const auto item = data.message(fullId)) {
					addMessage(messageWrap, item, nullptr, recent);
					continue;
				}
				const auto callback = crl::guard(content, [=] {
					if (const auto item = _peer->owner().message(fullId)) {
						addMessage(messageWrap, item, nullptr, recent);
						content->resizeToWidth(content->width());
					}
				});
				_peer->session().api().requestMessageData(
					_peer,
					fullId.msg,
					callback);
			} else if (recent.storyId) {
				const auto fullId = FullStoryId{ _peer->id, recent.storyId };
				if (const auto story = data.stories().lookup(fullId)) {
					addMessage(messageWrap, nullptr, *story, recent);
					continue;
				}
			}
		}
		container->resizeToWidth(container->width());
	};
	const auto delay = st::defaultRippleAnimation.hideDuration;
	buttonWrap->entity()->setClickedCallback([=] {
		base::call_delayed(delay, crl::guard(container, showMore));
	});
	showMore();
	if (_messagePreviews.empty()) {
		wrap->toggle(false, anim::type::instant);
	}
}

void InnerWidget::saveState(not_null<Memento*> memento) {
	for (const auto &message : _messagePreviews) {
		message->saveState(_state);
	}
	memento->setState(base::take(_state));
}

void InnerWidget::restoreState(not_null<Memento*> memento) {
	_state = memento->state();
	if (_state.stats.channel
		|| _state.stats.supergroup
		|| _state.stats.message
		|| _state.stats.story) {
		fill();
	} else {
		load();
	}
	Ui::RpWidget::resizeToWidth(width());
}

rpl::producer<Ui::ScrollToRequest> InnerWidget::scrollToRequests() const {
	return _scrollToRequests.events();
}

auto InnerWidget::showRequests() const -> rpl::producer<ShowRequest> {
	return _showRequests.events();
}

void InnerWidget::showFinished() {
	_showFinished.fire({});
}

} // namespace Info::Statistics