/*
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 "boxes/peers/edit_peer_requests_box.h"

#include "api/api_chat_participants.h"
#include "styles/palette.h"
#include "api/api_invite_links.h"
#include "apiwrap.h"
#include "base/unixtime.h"
#include "boxes/peer_list_controllers.h"
#include "boxes/peers/edit_participants_box.h" // SubscribeToMigration
#include "boxes/peers/edit_peer_invite_link.h" // PrepareRequestedRowStatus
#include "boxes/peers/edit_peer_requests_box.h"
#include "data/data_channel.h"
#include "data/data_chat.h"
#include "data/data_peer.h"
#include "data/data_session.h"
#include "data/data_user.h"
#include "history/view/history_view_requests_bar.h" // kRecentRequestsLimit
#include "info/info_controller.h"
#include "info/info_memento.h"
#include "info/requests_list/info_requests_list_widget.h"
#include "lang/lang_keys.h"
#include "main/main_session.h"
#include "mtproto/sender.h"
#include "ui/effects/ripple_animation.h"
#include "ui/painter.h"
#include "ui/round_rect.h"
#include "ui/text/text_utilities.h"
#include "window/window_session_controller.h"
#include "styles/style_boxes.h"

namespace {

constexpr auto kFirstPageCount = 16;
constexpr auto kPerPage = 200;
constexpr auto kServerSearchDelay = crl::time(1000);
constexpr auto kAcceptButton = 1;
constexpr auto kRejectButton = 2;
constexpr auto kBanButton = 3;

class RowDelegate {
public:
	[[nodiscard]] virtual QSize rowAcceptButtonSize() = 0;
	[[nodiscard]] virtual QSize rowRejectButtonSize() = 0;
	[[nodiscard]] virtual QSize rowBanButtonSize() = 0;
	virtual void rowPaintAccept(
		Painter &p,
		QRect geometry,
		std::unique_ptr<Ui::RippleAnimation> &ripple,
		int outerWidth,
		bool over) = 0;
	virtual void rowPaintReject(
		Painter &p,
		QRect geometry,
		std::unique_ptr<Ui::RippleAnimation> &ripple,
		int outerWidth,
		bool over) = 0;
	virtual void rowPaintBan(
		Painter &p,
		QRect geometry,
		std::unique_ptr<Ui::RippleAnimation> &ripple,
		int outerWidth,
		bool over) = 0;
};

class Row final : public PeerListRow {
public:
	Row(
		not_null<RowDelegate*> delegate,
		not_null<UserData*> user,
		TimeId date);

	int elementsCount() const override;
	QRect elementGeometry(int element, int outerWidth) const override;
	bool elementDisabled(int element) const override;
	bool elementOnlySelect(int element) const override;
	void elementAddRipple(
		int element,
		QPoint point,
		Fn<void()> updateCallback) override;
	void elementsStopLastRipple() override;
	void elementsPaint(
		Painter &p,
		int outerWidth,
		bool selected,
		int selectedElement) override;

private:
	const not_null<RowDelegate*> _delegate;
	std::unique_ptr<Ui::RippleAnimation> _acceptRipple;
	std::unique_ptr<Ui::RippleAnimation> _rejectRipple;
	std::unique_ptr<Ui::RippleAnimation> _banRipple;

};

Row::Row(
	not_null<RowDelegate*> delegate,
	not_null<UserData*> user,
	TimeId date)
: PeerListRow(user)
, _delegate(delegate) {
	setCustomStatus(PrepareRequestedRowStatus(date));
}

int Row::elementsCount() const {
	return 3;
}

QRect Row::elementGeometry(int element, int outerWidth) const {
	switch (element) {
	case kAcceptButton: {
		const auto size = _delegate->rowAcceptButtonSize();
		return QRect(st::communityRequestAcceptPosition, size);
	} break;
	case kRejectButton: {
		const auto accept = _delegate->rowAcceptButtonSize();
		const auto size = _delegate->rowRejectButtonSize();
		return QRect(
			(st::communityRequestAcceptPosition
				+ QPoint(accept.width() + st::requestButtonsSkip, 0)),
			size);
	} break;
	case kBanButton: {
		const auto accept = _delegate->rowAcceptButtonSize();
		const auto reject = _delegate->rowRejectButtonSize();
		const auto size = _delegate->rowBanButtonSize();
		return QRect(
					(st::communityRequestAcceptPosition
				+ QPoint(accept.width() + reject.width() + st::requestButtonsSkip, 0)),
				size);
	} break;
	}
	return QRect();
}

bool Row::elementDisabled(int element) const {
	return false;
}

bool Row::elementOnlySelect(int element) const {
	return true;
}

void Row::elementAddRipple(
		int element,
		QPoint point,
		Fn<void()> updateCallback) {
	const auto pointer = (element == kAcceptButton)
		? &_acceptRipple
		: (element == kRejectButton)
		? &_rejectRipple
		: (element == kBanButton)
		? &_banRipple
		: nullptr;
	if (!pointer) {
		return;
	}
	auto &ripple = *pointer;
	if (!ripple) {
		auto mask = Ui::RippleAnimation::RoundRectMask(
			(element == kAcceptButton
				? _delegate->rowAcceptButtonSize()
				: _delegate->rowRejectButtonSize()),
			st::requestsAcceptButton.height / 2);
		ripple = std::make_unique<Ui::RippleAnimation>(
			(element == kAcceptButton
				? st::requestsAcceptButton.ripple
				: element == kRejectButton
				? st::requestsRejectButton.ripple
				: st::requestsBanButton.ripple),
			std::move(mask),
			std::move(updateCallback));
	}
	ripple->add(point);
}

void Row::elementsStopLastRipple() {
	if (_acceptRipple) {
		_acceptRipple->lastStop();
	}
	if (_rejectRipple) {
		_rejectRipple->lastStop();
	}
	if (_banRipple) {
		_banRipple->lastStop();
	}
}

void Row::elementsPaint(
		Painter &p,
		int outerWidth,
		bool selected,
		int selectedElement) {
	const auto accept = elementGeometry(kAcceptButton, outerWidth);
	const auto reject = elementGeometry(kRejectButton, outerWidth);
	const auto ban = elementGeometry(kBanButton, outerWidth);

	const auto over = [&](int element) {
		return (selectedElement == element);
	};
	_delegate->rowPaintAccept(
		p,
		accept,
		_acceptRipple,
		outerWidth,
		over(kAcceptButton));
	_delegate->rowPaintReject(
		p,
		reject,
		_rejectRipple,
		outerWidth,
		over(kRejectButton));
	_delegate->rowPaintBan(
		p,
		ban,
		_banRipple,
		outerWidth,
		over(kBanButton));
}

} // namespace

class RequestsBoxController::RowHelper final : public RowDelegate {
public:
	explicit RowHelper(bool isGroup);

	[[nodiscard]] QSize rowAcceptButtonSize() override;
	[[nodiscard]] QSize rowRejectButtonSize() override;
	[[nodiscard]] QSize rowBanButtonSize() override;
	void rowPaintAccept(
		Painter &p,
		QRect geometry,
		std::unique_ptr<Ui::RippleAnimation> &ripple,
		int outerWidth,
		bool over) override;
	void rowPaintReject(
		Painter &p,
		QRect geometry,
		std::unique_ptr<Ui::RippleAnimation> &ripple,
		int outerWidth,
		bool over) override;
	void rowPaintBan(
		Painter &p,
		QRect geometry,
		std::unique_ptr<Ui::RippleAnimation> &ripple,
		int outerWidth,
		bool over) override;

private:
	void paintButton(
		Painter &p,
		QRect geometry,
		const style::RoundButton &st,
		const Ui::RoundRect &rect,
		const Ui::RoundRect &rectOver,
		std::unique_ptr<Ui::RippleAnimation> &ripple,
		const QString &text,
		int textWidth,
		int outerWidth,
		bool over);

	Ui::RoundRect _acceptRect;
	Ui::RoundRect _acceptRectOver;
	Ui::RoundRect _rejectRect;
	Ui::RoundRect _rejectRectOver;
	Ui::RoundRect _banRect;
	Ui::RoundRect _banRectOver;
	QString _acceptText;
	QString _rejectText;
	QString _banText;
	int _acceptTextWidth = 0;
	int _rejectTextWidth = 0;
	int _banTextWidth = 0;

};

RequestsBoxController::RowHelper::RowHelper(bool isGroup)
: _acceptRect(
	st::requestsAcceptButton.height / 2,
	st::requestsAcceptButton.textBg)
, _acceptRectOver(
	st::requestsAcceptButton.height / 2,
	st::requestsAcceptButton.textBgOver)
, _rejectRect(
	st::requestsAcceptButton.height / 2,
	st::requestsRejectButton.textBg)
, _rejectRectOver(
	st::requestsAcceptButton.height / 2,
	st::requestsRejectButton.textBgOver)
, _banRect(
	st::requestsAcceptButton.height / 2,
	st::requestsBanButton.textBg)
, _banRectOver(
	st::requestsAcceptButton.height / 2,
	st::requestsBanButton.textBgOver)
, _acceptText(isGroup
	? tr::lng_group_requests_add(tr::now)
	: tr::lng_group_requests_add_channel(tr::now))
, _rejectText(tr::lng_group_requests_dismiss(tr::now))
, _banText(tr::lng_group_requests_ban(tr::now))
, _acceptTextWidth(st::requestsAcceptButton.style.font->width(_acceptText))
, _rejectTextWidth(st::requestsRejectButton.style.font->width(_rejectText))
, _banTextWidth(st::requestsRejectButton.style.font->width(_banText)){
}

RequestsBoxController::RequestsBoxController(
	not_null<Window::SessionNavigation*> navigation,
	not_null<PeerData*> peer)
: PeerListController(CreateSearchController(peer))
, _navigation(navigation)
, _helper(std::make_unique<RowHelper>(!peer->isBroadcast()))
, _peer(peer)
, _api(&_peer->session().mtp()) {
	setStyleOverrides(&st::communityRequestsBoxList);
	subscribeToMigration();
}

RequestsBoxController::~RequestsBoxController() = default;

void RequestsBoxController::Start(
		not_null<Window::SessionNavigation*> navigation,
		not_null<PeerData*> peer) {
	navigation->showSection(
		std::make_shared<Info::Memento>(
			peer->migrateToOrMe(),
			Info::Section::Type::RequestsList));
}

Main::Session &RequestsBoxController::session() const {
	return _peer->session();
}

auto RequestsBoxController::CreateSearchController(not_null<PeerData*> peer)
-> std::unique_ptr<PeerListSearchController> {
	return std::make_unique<RequestsBoxSearchController>(peer);
}

std::unique_ptr<PeerListRow> RequestsBoxController::createSearchRow(
		not_null<PeerData*> peer) {
	if (const auto user = peer->asUser()) {
		return createRow(user);
	}
	return nullptr;
}

std::unique_ptr<PeerListRow> RequestsBoxController::createRestoredRow(
		not_null<PeerData*> peer) {
	if (const auto user = peer->asUser()) {
		return createRow(user, _dates[user]);
	}
	return nullptr;
}

auto RequestsBoxController::saveState() const
-> std::unique_ptr<PeerListState> {
	auto result = PeerListController::saveState();

	auto my = std::make_unique<SavedState>();
	my->dates = _dates;
	my->offsetDate = _offsetDate;
	my->offsetUser = _offsetUser;
	my->allLoaded = _allLoaded;
	my->wasLoading = (_loadRequestId != 0);
	if (const auto search = searchController()) {
		my->searchState = search->saveState();
	}
	result->controllerState = std::move(my);
	return result;
}

void RequestsBoxController::restoreState(
		std::unique_ptr<PeerListState> state) {
	auto typeErasedState = state
		? state->controllerState.get()
		: nullptr;
	if (const auto my = dynamic_cast<SavedState*>(typeErasedState)) {
		if (const auto requestId = base::take(_loadRequestId)) {
			_api.request(requestId).cancel();
		}
		_dates = std::move(my->dates);
		_offsetDate = my->offsetDate;
		_offsetUser = my->offsetUser;
		_allLoaded = my->allLoaded;
		if (const auto search = searchController()) {
			search->restoreState(std::move(my->searchState));
		}
		if (my->wasLoading) {
			loadMoreRows();
		}
		PeerListController::restoreState(std::move(state));
		if (delegate()->peerListFullRowsCount() || _allLoaded) {
			refreshDescription();
			delegate()->peerListRefreshRows();
		}
	}
}

void RequestsBoxController::prepare() {
	delegate()->peerListSetSearchMode(PeerListSearchMode::Enabled);
	delegate()->peerListSetTitle(_peer->isBroadcast()
		? tr::lng_manage_peer_requests_channel()
		: tr::lng_manage_peer_requests());
	setDescriptionText(tr::lng_contacts_loading(tr::now));
	setSearchNoResultsText(tr::lng_blocked_list_not_found(tr::now));
	loadMoreRows();
}

void RequestsBoxController::loadMoreRows() {
	if (searchController() && searchController()->loadMoreRows()) {
		return;
	} else if (_loadRequestId || _allLoaded) {
		return;
	}

	// First query is small and fast, next loads a lot of rows.
	const auto limit = _offsetDate ? kPerPage : kFirstPageCount;
	using Flag = MTPmessages_GetChatInviteImporters::Flag;
	_loadRequestId = _api.request(MTPmessages_GetChatInviteImporters(
		MTP_flags(Flag::f_requested),
		_peer->input(),
		MTPstring(), // link
		MTPstring(), // q
		MTP_int(_offsetDate),
		_offsetUser ? _offsetUser->inputUser() : MTP_inputUserEmpty(),
		MTP_int(limit)
	)).done([=](const MTPmessages_ChatInviteImporters &result) {
		const auto firstLoad = !_offsetDate;
		_loadRequestId = 0;

		result.match([&](const MTPDmessages_chatInviteImporters &data) {
			session().data().processUsers(data.vusers());
			const auto &importers = data.vimporters().v;
			auto &owner = _peer->owner();
			for (const auto &importer : importers) {
				importer.match([&](const MTPDchatInviteImporter &data) {
					_offsetDate = data.vdate().v;
					_offsetUser = owner.user(data.vuser_id());
					appendRow(_offsetUser, _offsetDate);
				});
			}
			// To be sure - wait for a whole empty result list.
			_allLoaded = importers.isEmpty();
		});

		if (_allLoaded
			|| (firstLoad && delegate()->peerListFullRowsCount() > 0)) {
			refreshDescription();
		}
		delegate()->peerListRefreshRows();
	}).fail([=] {
		_loadRequestId = 0;
		_allLoaded = true;
	}).send();
}

void RequestsBoxController::refreshDescription() {
	setDescriptionText((delegate()->peerListFullRowsCount() > 0)
		? QString()
		: _peer->isBroadcast()
		? tr::lng_group_requests_none_channel(tr::now)
		: tr::lng_group_requests_none(tr::now));
}

void RequestsBoxController::rowClicked(not_null<PeerListRow*> row) {
	_navigation->showPeerInfo(row->peer());
}

void RequestsBoxController::rowElementClicked(
		not_null<PeerListRow*> row,
		int element) {
	processRequest(row->peer()->asUser(), (element == kAcceptButton), (element == kBanButton));
}

void RequestsBoxController::processRequest(
		not_null<UserData*> user,
		bool approved,
		bool banned) {
	const auto remove = [=] {
		if (const auto row = delegate()->peerListFindRow(user->id.value)) {
			delegate()->peerListRemoveRow(row);
			refreshDescription();
			delegate()->peerListRefreshRows();
		}
		static_cast<RequestsBoxSearchController*>(
			searchController())->removeFromCache(user);
	};
	const auto done = crl::guard(this, [=] {
		remove();
		if (approved) {
			delegate()->peerListUiShow()->showToast((_peer->isBroadcast()
				? tr::lng_group_requests_was_added_channel
				: tr::lng_group_requests_was_added)(
					tr::now,
					lt_user,
					tr::bold(user->name()),
					tr::marked));
		}
	});
	if (banned) {
		if (_peer->isChat()) {
			session().api().chatParticipants().kick(_peer->asChat(), user);
		} else {
			session().api().chatParticipants().kick(_peer->asChannel(), user, ChatRestrictionsInfo());
		}
	}
	const auto fail = crl::guard(this, remove);
	session().api().inviteLinks().processRequest(
		_peer,
		QString(), // link
		user,
		approved,
		done,
		fail);
}

void RequestsBoxController::appendRow(
		not_null<UserData*> user,
		TimeId date) {
	if (!delegate()->peerListFindRow(user->id.value)) {
		_dates.emplace(user, date);
		if (auto row = createRow(user, date)) {
			delegate()->peerListAppendRow(std::move(row));
			setDescriptionText(QString());
		}
	}
}

QSize RequestsBoxController::RowHelper::rowAcceptButtonSize() {
	const auto &st = st::requestsAcceptButton;
	return {
		 (st.width <= 0) ? (_acceptTextWidth - st.width) : st.width,
		 st.height,
	};
}

QSize RequestsBoxController::RowHelper::rowRejectButtonSize() {
	const auto &st = st::requestsRejectButton;
	return {
		 (st.width <= 0) ? (_rejectTextWidth - st.width) : st.width,
		 st.height,
	};
}

QSize RequestsBoxController::RowHelper::rowBanButtonSize() {
	const auto &st = st::requestsBanButton;
	return {
			(st.width <= 0) ? (_banTextWidth - st.width) : st.width,
			st.height,
	};
}

void RequestsBoxController::RowHelper::rowPaintAccept(
		Painter &p,
		QRect geometry,
		std::unique_ptr<Ui::RippleAnimation> &ripple,
		int outerWidth,
		bool over) {
	paintButton(
		p,
		geometry,
		st::requestsAcceptButton,
		_acceptRect,
		_acceptRectOver,
		ripple,
		_acceptText,
		_acceptTextWidth,
		outerWidth,
		over);
}

void RequestsBoxController::RowHelper::rowPaintReject(
		Painter &p,
		QRect geometry,
		std::unique_ptr<Ui::RippleAnimation> &ripple,
		int outerWidth,
		bool over) {
	paintButton(
		p,
		geometry,
		st::requestsRejectButton,
		_rejectRect,
		_rejectRectOver,
		ripple,
		_rejectText,
		_rejectTextWidth,
		outerWidth,
		over);
}

void RequestsBoxController::RowHelper::rowPaintBan(
		Painter &p,
		QRect geometry,
		std::unique_ptr<Ui::RippleAnimation> &ripple,
		int outerWidth,
		bool over) {
	_banRect.setColor(st::banButtonBg);
	paintButton(
		p,
		geometry,
		st::requestsBanButton,
		_banRect,
		_banRectOver,
		ripple,
		_banText,
		_banTextWidth,
		outerWidth,
		over);
}

void RequestsBoxController::RowHelper::paintButton(
		Painter &p,
		QRect geometry,
		const style::RoundButton &st,
		const Ui::RoundRect &rect,
		const Ui::RoundRect &rectOver,
		std::unique_ptr<Ui::RippleAnimation> &ripple,
		const QString &text,
		int textWidth,
		int outerWidth,
		bool over) {
	rect.paint(p, geometry);
	if (over) {
		rectOver.paint(p, geometry);
	}
	if (ripple) {
		ripple->paint(p, geometry.x(), geometry.y(), outerWidth);
		if (ripple->empty()) {
			ripple = nullptr;
		}
	}

	const auto textLeft = geometry.x()
		+ ((geometry.width() - textWidth) / 2);
	const auto textTop = geometry.y() + st.textTop;
	p.setFont(st.style.font);
	p.setPen(over ? st.textFgOver : st.textFg);
	p.drawTextLeft(textLeft, textTop, outerWidth, text);
}

std::unique_ptr<PeerListRow> RequestsBoxController::createRow(
		not_null<UserData*> user,
		TimeId date) {
	if (!date) {
		const auto search = static_cast<RequestsBoxSearchController*>(
			searchController());
		date = search->dateForUser(user);
		_dates.emplace(user, date);
	}
	return std::make_unique<Row>(_helper.get(), user, date);
}

void RequestsBoxController::subscribeToMigration() {
	const auto chat = _peer->asChat();
	if (!chat) {
		return;
	}
	SubscribeToMigration(
		chat,
		lifetime(),
		[=](not_null<ChannelData*> channel) { migrate(chat, channel); });
}

void RequestsBoxController::migrate(
		not_null<ChatData*> chat,
		not_null<ChannelData*> channel) {
	_peer = channel;
}

RequestsBoxSearchController::RequestsBoxSearchController(
	not_null<PeerData*> peer)
: _peer(peer)
, _api(&_peer->session().mtp()) {
	_timer.setCallback([=] { searchOnServer(); });
}

void RequestsBoxSearchController::searchQuery(const QString &query) {
	if (_query != query) {
		_query = query;
		_offsetDate = 0;
		_offsetUser = nullptr;
		_requestId = 0;
		_allLoaded = false;
		if (!_query.isEmpty() && !searchInCache()) {
			_timer.callOnce(kServerSearchDelay);
		} else {
			_timer.cancel();
		}
	}
}

void RequestsBoxSearchController::searchOnServer() {
	Expects(!_query.isEmpty());

	loadMoreRows();
}

bool RequestsBoxSearchController::isLoading() {
	return _timer.isActive() || _requestId;
}

void RequestsBoxSearchController::removeFromCache(not_null<UserData*> user) {
	for (auto &entry : _cache) {
		auto &items = entry.second.items;
		const auto j = ranges::remove(items, user, &Item::user);
		if (j != end(items)) {
			entry.second.requestedCount -= (end(items) - j);
			items.erase(j, end(items));
		}
	}
}

TimeId RequestsBoxSearchController::dateForUser(not_null<UserData*> user) {
	if (const auto i = _dates.find(user); i != end(_dates)) {
		return i->second;
	}
	return {};
}

auto RequestsBoxSearchController::saveState() const
-> std::unique_ptr<SavedStateBase> {
	auto result = std::make_unique<SavedState>();
	result->query = _query;
	result->offsetDate = _offsetDate;
	result->offsetUser = _offsetUser;
	result->allLoaded = _allLoaded;
	result->wasLoading = (_requestId != 0);
	return result;
}

void RequestsBoxSearchController::restoreState(
		std::unique_ptr<SavedStateBase> state) {
	if (auto my = dynamic_cast<SavedState*>(state.get())) {
		if (auto requestId = base::take(_requestId)) {
			_api.request(requestId).cancel();
		}
		_cache.clear();
		_queries.clear();

		_allLoaded = my->allLoaded;
		_offsetDate = my->offsetDate;
		_offsetUser = my->offsetUser;
		_query = my->query;
		if (my->wasLoading) {
			searchOnServer();
		}
	}
}

bool RequestsBoxSearchController::searchInCache() {
	const auto i = _cache.find(_query);
	if (i != _cache.cend()) {
		_requestId = 0;
		searchDone(
			_requestId,
			i->second.items,
			i->second.requestedCount);
		return true;
	}
	return false;
}

bool RequestsBoxSearchController::loadMoreRows() {
	if (_query.isEmpty()) {
		return false;
	} else if (_allLoaded || isLoading()) {
		return true;
	}
	// For search we request a lot of rows from the first query.
	// (because we've waited for search request by timer already,
	// so we don't expect it to be fast, but we want to fill cache).
	const auto limit = kPerPage;
	using Flag = MTPmessages_GetChatInviteImporters::Flag;
	_requestId = _api.request(MTPmessages_GetChatInviteImporters(
		MTP_flags(Flag::f_requested | Flag::f_q),
		_peer->input(),
		MTPstring(), // link
		MTP_string(_query),
		MTP_int(_offsetDate),
		_offsetUser ? _offsetUser->inputUser() : MTP_inputUserEmpty(),
		MTP_int(limit)
	)).done([=](
			const MTPmessages_ChatInviteImporters &result,
			mtpRequestId requestId) {
		auto items = std::vector<Item>();
		result.match([&](const MTPDmessages_chatInviteImporters &data) {
			const auto &importers = data.vimporters().v;
			auto &owner = _peer->owner();
			owner.processUsers(data.vusers());
			items.reserve(importers.size());
			for (const auto &importer : importers) {
				importer.match([&](const MTPDchatInviteImporter &data) {
					items.push_back({
						owner.user(data.vuser_id()),
						data.vdate().v,
					});
				});
			}
		});
		searchDone(requestId, items, limit);

		auto it = _queries.find(requestId);
		if (it != _queries.cend()) {
			const auto &query = it->second.text;
			if (it->second.offsetDate == 0) {
				auto &entry = _cache[query];
				entry.items = std::move(items);
				entry.requestedCount = limit;
			}
			_queries.erase(it);
		}
	}).fail([=](const MTP::Error &error, mtpRequestId requestId) {
		if (_requestId == requestId) {
			_requestId = 0;
			_allLoaded = true;
			delegate()->peerListSearchRefreshRows();
		}
	}).send();

	auto entry = Query();
	entry.text = _query;
	entry.offsetDate = _offsetDate;
	_queries.emplace(_requestId, entry);
	return true;
}

void RequestsBoxSearchController::searchDone(
		mtpRequestId requestId,
		const std::vector<Item> &items,
		int requestedCount) {
	if (_requestId != requestId) {
		return;
	}

	_requestId = 0;
	if (!_offsetDate) {
		_dates.clear();
	}
	for (const auto &[user, date] : items) {
		_offsetDate = date;
		_offsetUser = user;
		_dates.emplace(user, date);
		delegate()->peerListSearchAddRow(user);
	}
	if (items.size() < requestedCount) {
		// We want cache to have full information about a query with
		// small results count (that we don't need the second request).
		// So we don't wait for empty list unlike the non-search case.
		_allLoaded = true;
	}
	delegate()->peerListSearchRefreshRows();
}
