mainwidget.cpp

/*
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 "mainwidget.h"

#include "api/api_updates.h"
#include "api/api_views.h"
#include "data/components/scheduled_messages.h"
#include "data/data_document_media.h"
#include "data/data_document_resolver.h"
#include "data/data_forum_topic.h"
#include "data/data_web_page.h"
#include "data/data_game.h"
#include "data/data_peer_values.h"
#include "data/data_session.h"
#include "data/data_changes.h"
#include "data/data_folder.h"
#include "data/data_channel.h"
#include "data/data_chat.h"
#include "data/data_user.h"
#include "data/data_chat_filters.h"
#include "data/data_file_origin.h"
#include "data/data_histories.h"
#include "data/stickers/data_stickers.h"
#include "ui/chat/chat_theme.h"
#include "ui/widgets/buttons.h"
#include "ui/widgets/shadow.h"
#include "ui/widgets/dropdown_menu.h"
#include "ui/focus_persister.h"
#include "ui/resize_area.h"
#include "ui/text/text_utilities.h"
#include "ui/toast/toast.h"
#include "ui/ui_utility.h"
#include "window/window_connecting_widget.h"
#include "window/window_top_bar_wrap.h"
#include "window/notifications_manager.h"
#include "window/window_separate_id.h"
#include "window/window_slide_animation.h"
#include "window/window_history_hider.h"
#include "window/window_controller.h"
#include "window/window_peer_menu.h"
#include "window/window_session_controller_link_info.h"
#include "window/themes/window_theme.h"
#include "chat_helpers/bot_command.h"
#include "chat_helpers/tabbed_selector.h" // TabbedSelector::refreshStickers
#include "chat_helpers/message_field.h"
#include "info/info_memento.h"
#include "apiwrap.h"
#include "dialogs/dialogs_widget.h"
#include "history/history_widget.h"
#include "history/history_item_helpers.h" // GetErrorForSending.
#include "history/view/media/history_view_media.h"
#include "history/view/history_view_service_message.h"
#include "history/view/history_view_sublist_section.h"
#include "lang/lang_keys.h"
#include "lang/lang_cloud_manager.h"
#include "inline_bots/inline_bot_layout_item.h"
#include "ui/boxes/confirm_box.h"
#include "boxes/peer_list_controllers.h"
#include "storage/storage_account.h"
#include "main/main_domain.h"
#include "media/audio/media_audio.h"
#include "media/player/media_player_panel.h"
#include "media/player/media_player_widget.h"
#include "media/player/media_player_dropdown.h"
#include "media/player/media_player_instance.h"
#include "base/qthelp_regex.h"
#include "mtproto/mtproto_dc_options.h"
#include "core/update_checker.h"
#include "core/shortcuts.h"
#include "core/application.h"
#include "core/changelogs.h"
#include "core/mime_type.h"
#include "calls/calls_call.h"
#include "calls/calls_instance.h"
#include "calls/calls_top_bar.h"
#include "calls/group/calls_group_call.h"
#include "export/export_settings.h"
#include "export/export_manager.h"
#include "export/view/export_view_top_bar.h"
#include "export/view/export_view_panel_controller.h"
#include "main/main_session.h"
#include "main/main_session_settings.h"
#include "main/main_app_config.h"
#include "settings/settings_premium.h"
#include "support/support_helper.h"
#include "storage/storage_user_photos.h"
#include "styles/style_dialogs.h"
#include "styles/style_chat.h"
#include "styles/style_window.h"

#include <QtCore/QCoreApplication>
#include <QtCore/QMimeData>

namespace {

void ClearBotStartToken(PeerData *peer) {
	if (peer && peer->isUser() && peer->asUser()->isBot()) {
		peer->asUser()->botInfo->startToken = QString();
	}
}

} // namespace

enum StackItemType {
	HistoryStackItem,
	SectionStackItem,
};

class StackItem {
public:
	explicit StackItem(PeerData *peer) : _peer(peer) {
	}

	[[nodiscard]] PeerData *peer() const {
		return _peer;
	}

	void setThirdSectionMemento(
		std::shared_ptr<Window::SectionMemento> memento);
	[[nodiscard]] auto takeThirdSectionMemento()
	-> std::shared_ptr<Window::SectionMemento> {
		return std::move(_thirdSectionMemento);
	}

	void setThirdSectionWeak(QPointer<Window::SectionWidget> section) {
		_thirdSectionWeak = section;
	}
	[[nodiscard]] QPointer<Window::SectionWidget> thirdSectionWeak() const {
		return _thirdSectionWeak;
	}

	[[nodiscard]] rpl::lifetime &lifetime() {
		return _lifetime;
	}

	[[nodiscard]] virtual StackItemType type() const = 0;
	[[nodiscard]] rpl::producer<> removeRequests() const {
		return rpl::merge(
			_thirdSectionRemoveRequests.events(),
			sectionRemoveRequests());
	}
	virtual ~StackItem() = default;

private:
	[[nodiscard]] virtual rpl::producer<> sectionRemoveRequests() const = 0;

	PeerData *_peer = nullptr;
	QPointer<Window::SectionWidget> _thirdSectionWeak;
	std::shared_ptr<Window::SectionMemento> _thirdSectionMemento;
	rpl::event_stream<> _thirdSectionRemoveRequests;

	rpl::lifetime _lifetime;

};

class StackItemHistory final : public StackItem {
public:
	StackItemHistory(
		not_null<History*> history,
		MsgId msgId,
		QVector<FullMsgId> replyReturns)
	: StackItem(history->peer)
	, history(history)
	, msgId(msgId)
	, replyReturns(replyReturns) {
	}

	StackItemType type() const override {
		return HistoryStackItem;
	}

	not_null<History*> history;
	MsgId msgId;
	QVector<FullMsgId> replyReturns;

private:
	rpl::producer<> sectionRemoveRequests() const override {
		return rpl::never<>();
	}

};

class StackItemSection : public StackItem {
public:
	StackItemSection(
		std::shared_ptr<Window::SectionMemento> memento);

	StackItemType type() const override {
		return SectionStackItem;
	}
	std::shared_ptr<Window::SectionMemento> takeMemento() {
		return std::move(_memento);
	}

private:
	rpl::producer<> sectionRemoveRequests() const override;

	std::shared_ptr<Window::SectionMemento> _memento;

};

void StackItem::setThirdSectionMemento(
		std::shared_ptr<Window::SectionMemento> memento) {
	_thirdSectionMemento = std::move(memento);
	if (const auto memento = _thirdSectionMemento.get()) {
		memento->removeRequests(
		) | rpl::start_to_stream(_thirdSectionRemoveRequests, _lifetime);
	}
}

StackItemSection::StackItemSection(
	std::shared_ptr<Window::SectionMemento> memento)
: StackItem(nullptr)
, _memento(std::move(memento)) {
}

rpl::producer<> StackItemSection::sectionRemoveRequests() const {
	if (const auto topic = _memento->topicForRemoveRequests()) {
		return rpl::merge(_memento->removeRequests(), topic->destroyed());
	}
	return _memento->removeRequests();
}

struct MainWidget::SettingBackground {
	explicit SettingBackground(const Data::WallPaper &data);

	Data::WallPaper data;
	std::shared_ptr<Data::DocumentMedia> dataMedia;
	base::binary_guard generating;
};

MainWidget::SettingBackground::SettingBackground(
	const Data::WallPaper &data)
: data(data) {
}

MainWidget::MainWidget(
	QWidget *parent,
	not_null<Window::SessionController*> controller)
: RpWidget(parent)
, _controller(controller)
, _dialogsWidth(st::columnMinimalWidthLeft)
, _thirdColumnWidth(st::columnMinimalWidthThird)
, _dialogs(windowId().hasChatsList()
	? base::make_unique_q<Dialogs::Widget>(
		this,
		_controller,
		Dialogs::Widget::Layout::Main)
	: nullptr)
, _history(std::in_place, this, _controller)
, _sideShadow(_dialogs
	? base::make_unique_q<Ui::PlainShadow>(this)
	: nullptr)
, _playerPlaylist(this, _controller)
, _changelogs(Core::Changelogs::Create(&controller->session())) {
	if (_dialogs) {
		setupConnectingWidget();
	}

	_history->cancelRequests(
	) | rpl::start_with_next([=] {
		handleHistoryBack();
	}, lifetime());

	Core::App().calls().currentCallValue(
	) | rpl::start_with_next([=](Calls::Call *call) {
		setCurrentCall(call);
	}, lifetime());
	Core::App().calls().currentGroupCallValue(
	) | rpl::start_with_next([=](Calls::GroupCall *call) {
		setCurrentGroupCall(call);
	}, lifetime());
	if (_callTopBar) {
		_callTopBar->finishAnimating();
	}

	controller->window().setDefaultFloatPlayerDelegate(
		floatPlayerDelegate());

	Core::App().floatPlayerClosed(
	) | rpl::start_with_next([=](FullMsgId itemId) {
		floatPlayerClosed(itemId);
	}, lifetime());

	Core::App().exportManager().currentView(
	) | rpl::start_with_next([=](Export::View::PanelController *view) {
		setCurrentExportView(view);
	}, lifetime());
	if (_exportTopBar) {
		_exportTopBar->finishAnimating();
	}

	Media::Player::instance()->closePlayerRequests(
	) | rpl::start_with_next([=] {
		closeBothPlayers();
	}, lifetime());

	Media::Player::instance()->updatedNotifier(
	) | rpl::start_with_next([=](const Media::Player::TrackState &state) {
		handleAudioUpdate(state);
	}, lifetime());
	handleAudioUpdate(Media::Player::instance()->getState(AudioMsgId::Type::Song));
	handleAudioUpdate(Media::Player::instance()->getState(AudioMsgId::Type::Voice));
	if (_player) {
		_player->finishAnimating();
	}

	_controller->chatsForceDisplayWideChanges(
	) | rpl::start_with_next([=] {
		crl::on_main(this, [=] {
			updateDialogsWidthAnimated();
		});
	}, lifetime());

	const auto filter = [=](bool mainSectionShown) {
		return rpl::filter([=] {
			return (_controller->mainSectionShown() == mainSectionShown);
		});
	};
	rpl::merge(
		Core::App().settings().dialogsWithChatWidthRatioChanges(
		) | filter(true) | rpl::to_empty,
		Core::App().settings().dialogsNoChatWidthRatioChanges(
		) | filter(false) | rpl::to_empty,
		Core::App().settings().thirdColumnWidthChanges() | rpl::to_empty
	) | rpl::start_with_next([=] {
		updateControlsGeometry();
	}, lifetime());

	session().changes().historyUpdates(
		Data::HistoryUpdate::Flag::MessageSent
	) | rpl::start_with_next([=](const Data::HistoryUpdate &update) {
		const auto history = update.history;
		history->forgetScrollState();
		if (const auto from = history->peer->migrateFrom()) {
			auto &owner = history->owner();
			if (const auto migrated = owner.historyLoaded(from)) {
				migrated->forgetScrollState();
			}
		}
	}, lifetime());

	session().changes().entryUpdates(
		Data::EntryUpdate::Flag::LocalDraftSet
	) | rpl::start_with_next([=](const Data::EntryUpdate &update) {
		auto params = Window::SectionShow();
		params.reapplyLocalDraft = true;
		controller->showThread(
			update.entry->asThread(),
			ShowAtUnreadMsgId,
			params);
		controller->hideLayer();
	}, lifetime());

	// MSVC BUG + REGRESSION rpl::mappers::tuple :(
	using namespace rpl::mappers;
	_controller->activeChatValue(
	) | rpl::map([](Dialogs::Key key) {
		const auto peer = key.peer();
		const auto topic = key.topic();
		auto canWrite = topic
			? Data::CanSendAnyOfValue(
				topic,
				Data::TabbedPanelSendRestrictions())
			: peer
			? Data::CanSendAnyOfValue(

				peer, Data::TabbedPanelSendRestrictions())
			: rpl::single(false);
		return std::move(
			canWrite
		) | rpl::map([=](bool can) {
			return std::make_tuple(key, can);
		});
	}) | rpl::flatten_latest(
	) | rpl::start_with_next([this](Dialogs::Key key, bool canWrite) {
		updateThirdColumnToCurrentChat(key, canWrite);
	}, lifetime());

	QCoreApplication::instance()->installEventFilter(this);

	Media::Player::instance()->tracksFinished(
	) | rpl::start_with_next([=](AudioMsgId::Type type) {
		if (type == AudioMsgId::Type::Voice) {
			const auto songState = Media::Player::instance()->getState(
				AudioMsgId::Type::Song);
			if (!songState.id || IsStoppedOrStopping(songState.state)) {
				Media::Player::instance()->stopAndClose();
			}
		} else if (type == AudioMsgId::Type::Song) {
			const auto songState = Media::Player::instance()->getState(
				AudioMsgId::Type::Song);
			if (!songState.id) {
				Media::Player::instance()->stopAndClose();
			}
		}
	}, lifetime());

	_controller->adaptive().changes(
	) | rpl::start_with_next([=] {
		handleAdaptiveLayoutUpdate();
	}, lifetime());

	if (_dialogs) {
		_dialogs->show();
	}
	if (_dialogs && isOneColumn()) {
		_history->hide();
	} else {
		_history->show();
	}
	orderWidgets();

	if (!Core::UpdaterDisabled()) {
		Core::UpdateChecker checker;
		checker.start();
	}

	cSetOtherOnline(0);

	session().data().stickers().notifySavedGifsUpdated();
}

MainWidget::~MainWidget() = default;

Main::Session &MainWidget::session() const {
	return _controller->session();
}

not_null<Window::SessionController*> MainWidget::controller() const {
	return _controller;
}

void MainWidget::setupConnectingWidget() {
	using namespace rpl::mappers;
	_connecting = std::make_unique<Window::ConnectionState>(
		this,
		&session().account(),
		_controller->adaptive().oneColumnValue() | rpl::map(!_1));
	_controller->connectingBottomSkipValue(
	) | rpl::start_with_next([=](int skip) {
		_connecting->setBottomSkip(skip);
	}, lifetime());
}

not_null<Media::Player::FloatDelegate*> MainWidget::floatPlayerDelegate() {
	return static_cast<Media::Player::FloatDelegate*>(this);
}

not_null<Ui::RpWidget*> MainWidget::floatPlayerWidget() {
	return this;
}

void MainWidget::floatPlayerToggleGifsPaused(bool paused) {
	constexpr auto kReason = Window::GifPauseReason::RoundPlaying;
	if (paused) {
		_controller->enableGifPauseReason(kReason);
	} else {
		_controller->disableGifPauseReason(kReason);
	}
}

auto MainWidget::floatPlayerGetSection(Window::Column column)
-> not_null<Media::Player::FloatSectionDelegate*> {
	if (isThreeColumn()) {
		if (_dialogs && column == Window::Column::First) {
			return _dialogs;
		} else if (column == Window::Column::Second
			|| !_dialogs
			|| !_thirdSection) {
			if (_mainSection) {
				return _mainSection;
			}
			return _history;
		}
		return _thirdSection;
	} else if (isNormalColumn()) {
		if (_dialogs && column == Window::Column::First) {
			return _dialogs;
		} else if (_mainSection) {
			return _mainSection;
		}
		return _history;
	} else if (_mainSection) {
		return _mainSection;
	} else if (!isOneColumn() || _history->peer()) {
		return _history;
	}
	Assert(_dialogs != nullptr);
	return _dialogs;
}

void MainWidget::floatPlayerEnumerateSections(Fn<void(
		not_null<Media::Player::FloatSectionDelegate*> widget,
		Window::Column widgetColumn)> callback) {
	if (isThreeColumn()) {
		if (_dialogs) {
			callback(_dialogs, Window::Column::First);
		}
		if (_mainSection) {
			callback(_mainSection, Window::Column::Second);
		} else {
			callback(_history, Window::Column::Second);
		}
		if (_thirdSection) {
			callback(_thirdSection, Window::Column::Third);
		}
	} else if (isNormalColumn()) {
		if (_dialogs) {
			callback(_dialogs, Window::Column::First);
		}
		if (_mainSection) {
			callback(_mainSection, Window::Column::Second);
		} else {
			callback(_history, Window::Column::Second);
		}
	} else {
		if (_mainSection) {
			callback(_mainSection, Window::Column::Second);
		} else if (!isOneColumn() || _history->peer()) {
			callback(_history, Window::Column::Second);
		} else {
			Assert(_dialogs != nullptr);
			callback(_dialogs, Window::Column::First);
		}
	}
}

bool MainWidget::floatPlayerIsVisible(not_null<HistoryItem*> item) {
	return session().data().queryItemVisibility(item);
}

void MainWidget::floatPlayerClosed(FullMsgId itemId) {
	if (_player) {
		const auto voiceData = Media::Player::instance()->current(
			AudioMsgId::Type::Voice);
		if (voiceData.contextId() == itemId) {
			stopAndClosePlayer();
		}
	}
}

void MainWidget::floatPlayerDoubleClickEvent(
		not_null<const HistoryItem*> item) {
	_controller->showMessage(item);
}

bool MainWidget::setForwardDraft(
		not_null<Data::Thread*> thread,
		Data::ForwardDraft &&draft) {
	const auto history = thread->owningHistory();
	const auto items = session().data().idsToItems(draft.ids);
	const auto topicRootId = thread->topicRootId();
	const auto error = GetErrorForSending(
		history->peer,
		{
			.topicRootId = topicRootId,
			.forward = &items,
			.ignoreSlowmodeCountdown = true,
		});
	if (error) {
		Data::ShowSendErrorToast(_controller, history->peer, error);
		return false;
	}

	history->setForwardDraft(topicRootId, std::move(draft));
	_controller->showThread(
		thread,
		ShowAtUnreadMsgId,
		SectionShow::Way::Forward);
	return true;
}

bool MainWidget::shareUrl(
		not_null<Data::Thread*> thread,
		const QString &url,
		const QString &text) const {
	if (!Data::CanSendTexts(thread)) {
		_controller->show(Ui::MakeInformBox(tr::lng_share_cant()));
		return false;
	}
	const auto textWithTags = TextWithTags{
		url + '\n' + text,
		TextWithTags::Tags()
	};
	const auto cursor = MessageCursor{
		int(url.size()) + 1,
		int(url.size()) + 1 + int(text.size()),
		Ui::kQFixedMax
	};
	const auto history = thread->owningHistory();
	const auto topicRootId = thread->topicRootId();
	history->setLocalDraft(std::make_unique<Data::Draft>(
		textWithTags,
		FullReplyTo{ .topicRootId = topicRootId },
		cursor,
		Data::WebPageDraft()));
	history->clearLocalEditDraft(topicRootId);
	history->session().changes().entryUpdated(
		thread,
		Data::EntryUpdate::Flag::LocalDraftSet);
	return true;
}

bool MainWidget::sendPaths(
		not_null<Data::Thread*> thread,
		const QStringList &paths) {
	if (!Data::CanSendAnyOf(thread, Data::FilesSendRestrictions())) {
		_controller->showToast(
			tr::lng_forward_send_files_cant(tr::now));
		return false;
	} else if (const auto error = Data::AnyFileRestrictionError(
			thread->peer())) {
		Data::ShowSendErrorToast(controller(), thread->peer(), error);
		return false;
	} else {
		_controller->showThread(
			thread,
			ShowAtTheEndMsgId,
			Window::SectionShow::Way::ClearStack);
	}
	return (_controller->activeChatCurrent().thread() == thread)
		&& (_mainSection
			? _mainSection->confirmSendingFiles(paths)
			: _history->confirmSendingFiles(paths));
}

bool MainWidget::filesOrForwardDrop(
		not_null<Data::Thread*> thread,
		not_null<const QMimeData*> data) {
	if (const auto forum = thread->asForum()) {
		Window::ShowDropMediaBox(
			_controller,
			Core::ShareMimeMediaData(data),
			forum);
		if (_hider) {
			_hider->startHide();
			clearHider(_hider);
		}
		return true;
	}
	if (data->hasFormat(u"application/x-td-forward"_q)) {
		auto draft = Data::ForwardDraft{
			.ids = session().data().takeMimeForwardIds(),
		};
		if (setForwardDraft(thread, std::move(draft))) {
			return true;
		}
		// We've already released the mouse button,
		// so the forwarding is cancelled.
		if (_hider) {
			_hider->startHide();
			clearHider(_hider);
		}
		return false;
	} else if (!Data::CanSendAnyOf(thread, Data::FilesSendRestrictions())) {
		_controller->showToast(
			tr::lng_forward_send_files_cant(tr::now));
		return false;
	} else if (const auto error = Data::AnyFileRestrictionError(
			thread->peer())) {
		Data::ShowSendErrorToast(_controller, thread->peer(), error);
		return false;
	} else {
		_controller->showThread(
			thread,
			ShowAtTheEndMsgId,
			Window::SectionShow::Way::ClearStack);
		if (_controller->activeChatCurrent().thread() != thread) {
			return false;
		}
		(_mainSection
			? _mainSection->confirmSendingFiles(data)
			: _history->confirmSendingFiles(data));
		return true;
	}
}

bool MainWidget::notify_switchInlineBotButtonReceived(const QString &query, UserData *samePeerBot, MsgId samePeerReplyTo) {
	return _history->notify_switchInlineBotButtonReceived(query, samePeerBot, samePeerReplyTo);
}

void MainWidget::clearHider(not_null<Window::HistoryHider*> instance) {
	if (_hider != instance) {
		return;
	}
	_hider.release();
}

void MainWidget::hiderLayer(base::unique_qptr<Window::HistoryHider> hider) {
	if (!_dialogs || _controller->window().locked()) {
		return;
	}

	_hider = std::move(hider);
	_hider->setParent(this);

	_hider->hidden(
	) | rpl::start_with_next([=, instance = _hider.get()] {
		clearHider(instance);
		instance->hide();
		instance->deleteLater();
	}, _hider->lifetime());

	_hider->show();
	updateControlsGeometry();
	_dialogs->setInnerFocus();

	floatPlayerCheckVisibility();
}

void MainWidget::showDragForwardInfo() {
	hiderLayer(base::make_unique_q<Window::HistoryHider>(
		this,
		tr::lng_forward_choose(tr::now)));
}

void MainWidget::hideDragForwardInfo() {
	if (_hider) {
		_hider->startHide();
		_hider.release();
	}
}

void MainWidget::sendBotCommand(Bot::SendCommandRequest request) {
	const auto type = _mainSection
		? _mainSection->sendBotCommand(request)
		: Window::SectionActionResult::Fallback;
	if (type == Window::SectionActionResult::Fallback) {
		_controller->showPeerHistory(
			request.peer,
			SectionShow::Way::Forward,
			ShowAtTheEndMsgId);
		_history->sendBotCommand(request);
	}
}

void MainWidget::hideSingleUseKeyboard(FullMsgId replyToId) {
	_history->hideSingleUseKeyboard(replyToId);
}

void MainWidget::searchMessages(
		const QString &query,
		Dialogs::Key inChat,
		PeerData *searchFrom) {
	const auto complex = Data::HashtagWithUsernameFromQuery(query);
	if (!complex.username.isEmpty()) {
		_controller->showPeerByLink(Window::PeerByLinkInfo{
			.usernameOrId = complex.username,
			.text = complex.hashtag,
			.resolveType = Window::ResolveType::HashtagSearch,
		});
		return;
	}
	auto tags = Data::SearchTagsFromQuery(query);
	if (_dialogs) {
		auto state = Dialogs::SearchState{
			.inChat = ((tags.empty() || inChat.sublist())
				? inChat
				: session().data().history(session().user())),
			.fromPeer = inChat ? searchFrom : nullptr,
			.tags = tags,
			.query = tags.empty() ? query : QString(),
		};
		state.tab = state.defaultTabForMe();
		_dialogs->searchMessages(std::move(state));
		if (isOneColumn()) {
			_controller->clearSectionStack();
		} else {
			_dialogs->setInnerFocus();
		}
	} else {
		if (const auto sublist = inChat.sublist()) {
			controller()->showSection(
				std::make_shared<HistoryView::SublistMemento>(sublist));
		} else if (!tags.empty()) {
			inChat = controller()->session().data().history(
				controller()->session().user());
		}
		if ((!_mainSection
			|| !_mainSection->searchInChatEmbedded(query, inChat, searchFrom))
			&& !_history->searchInChatEmbedded(query, inChat, searchFrom)) {
			const auto account = not_null(&session().account());
			if (const auto window = Core::App().windowFor(account)) {
				if (const auto controller = window->sessionController()) {
					controller->content()->searchMessages(
						query,
						inChat,
						searchFrom);
					controller->widget()->activate();
				}
			}
		}
	}
}

void MainWidget::handleAudioUpdate(const Media::Player::TrackState &state) {
	using State = Media::Player::State;
	const auto document = state.id.audio();
	const auto item = session().data().message(state.id.contextId());
	if (!Media::Player::IsStoppedOrStopping(state.state)) {
		const auto ttlSeconds = item
			&& item->media()
			&& item->media()->ttlSeconds();
		if (!ttlSeconds) {
			createPlayer();
		}
	} else if (state.state == State::StoppedAtStart) {
		Media::Player::instance()->stopAndClose();
	}

	if (item) {
		session().data().requestItemRepaint(item);
	}
	if (document) {
		if (const auto items = InlineBots::Layout::documentItems()) {
			if (const auto i = items->find(document); i != items->end()) {
				for (const auto &item : i->second) {
					item->update();
				}
			}
		}
	}
}

void MainWidget::closeBothPlayers() {
	if (_player) {
		_player->hide(anim::type::normal);
	}
	_playerPlaylist->hideIgnoringEnterEvents();
}

void MainWidget::stopAndClosePlayer() {
	if (_player) {
		_player->entity()->stopAndClose();
	}
}

void MainWidget::createPlayer() {
	if (!_player) {
		_player.create(
			this,
			object_ptr<Media::Player::Widget>(this, this, _controller),
			_controller->adaptive().oneColumnValue());
		rpl::merge(
			_player->heightValue() | rpl::map_to(true),
			_player->shownValue()
		) | rpl::start_with_next(
			[this] { playerHeightUpdated(); },
			_player->lifetime());
		_player->entity()->setCloseCallback([=] {
			Media::Player::instance()->stopAndClose();
		});
		_player->entity()->setShowItemCallback([=](
				not_null<const HistoryItem*> item) {
			const auto peer = item->history()->peer;
			if (const auto window = Core::App().windowFor(peer)) {
				if (const auto controller = window->sessionController()) {
					controller->showMessage(item);
					return;
				}
			}
			_controller->showMessage(item);
		});

		_player->entity()->togglePlaylistRequests(
		) | rpl::start_with_next([=](bool shown) {
			if (!shown) {
				_playerPlaylist->hideFromOther();
				return;
			} else if (_playerPlaylist->isHidden()) {
				auto position = mapFromGlobal(QCursor::pos()).x();
				auto bestPosition = _playerPlaylist->bestPositionFor(position);
				if (rtl()) bestPosition = position + 2 * (position - bestPosition) - _playerPlaylist->width();
				updateMediaPlaylistPosition(bestPosition);
			}
			_playerPlaylist->showFromOther();
		}, _player->lifetime());

		orderWidgets();
		if (_showAnimation) {
			_player->show(anim::type::instant);
			_player->setVisible(false);
			Shortcuts::ToggleMediaShortcuts(true);
		} else {
			_player->hide(anim::type::instant);
		}
	}
	if (_player && !_player->toggled()) {
		if (!_showAnimation) {
			_player->show(anim::type::normal);
			_playerHeight = _contentScrollAddToY = _player->contentHeight();
			updateControlsGeometry();
			Shortcuts::ToggleMediaShortcuts(true);
		}
	}
}

void MainWidget::playerHeightUpdated() {
	if (!_player) {
		// Player could be already "destroyDelayed", but still handle events.
		return;
	}
	auto playerHeight = _player->contentHeight();
	if (playerHeight != _playerHeight) {
		_contentScrollAddToY += playerHeight - _playerHeight;
		_playerHeight = playerHeight;
		updateControlsGeometry();
	}
	if (!_playerHeight && _player->isHidden()) {
		const auto state = Media::Player::instance()->getState(Media::Player::instance()->getActiveType());
		if (!state.id || Media::Player::IsStoppedOrStopping(state.state)) {
			_player.destroyDelayed();
		}
	}
}

void MainWidget::setCurrentCall(Calls::Call *call) {
	if (!call && _currentGroupCall) {
		return;
	}
	_currentCallLifetime.destroy();
	_currentCall = call;
	if (_currentCall) {
		_callTopBar.destroy();
		_currentCall->stateValue(
		) | rpl::start_with_next([=](Calls::Call::State state) {
			using State = Calls::Call::State;
			if (state != State::Established) {
				destroyCallTopBar();
			} else if (!_callTopBar) {
				createCallTopBar();
			}
		}, _currentCallLifetime);
	} else {
		destroyCallTopBar();
	}
}

void MainWidget::setCurrentGroupCall(Calls::GroupCall *call) {
	if (!call && _currentCall) {
		return;
	}
	_currentCallLifetime.destroy();
	_currentGroupCall = call;
	if (_currentGroupCall) {
		_callTopBar.destroy();
		_currentGroupCall->stateValue(
		) | rpl::start_with_next([=](Calls::GroupCall::State state) {
			using State = Calls::GroupCall::State;
			if (state != State::Creating
				&& state != State::Waiting
				&& state != State::Joining
				&& state != State::Joined
				&& state != State::Connecting) {
				destroyCallTopBar();
			} else if (!_callTopBar) {
				createCallTopBar();
			}
		}, _currentCallLifetime);
	} else {
		destroyCallTopBar();
	}
}

void MainWidget::createCallTopBar() {
	Expects(_currentCall != nullptr || _currentGroupCall != nullptr);

	const auto show = controller()->uiShow();
	_callTopBar.create(
		this,
		(_currentCall
			? object_ptr<Calls::TopBar>(this, _currentCall, show)
			: object_ptr<Calls::TopBar>(this, _currentGroupCall, show)));
	_callTopBar->entity()->initBlobsUnder(this, _callTopBar->geometryValue());
	_callTopBar->heightValue(
	) | rpl::start_with_next([this](int value) {
		callTopBarHeightUpdated(value);
	}, lifetime());
	orderWidgets();
	if (_showAnimation) {
		_callTopBar->show(anim::type::instant);
		_callTopBar->setVisible(false);
	} else {
		_callTopBar->hide(anim::type::instant);
		_callTopBar->show(anim::type::normal);
		_callTopBarHeight = _contentScrollAddToY = _callTopBar->height();
		updateControlsGeometry();
	}
}

void MainWidget::destroyCallTopBar() {
	if (_callTopBar) {
		_callTopBar->hide(anim::type::normal);
	}