data_peer.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 "data/data_peer.h"

#include "api/api_sensitive_content.h"
#include "data/data_user.h"
#include "data/data_chat.h"
#include "data/data_chat_participant_status.h"
#include "data/data_channel.h"
#include "data/data_changes.h"
#include "data/data_emoji_statuses.h"
#include "data/data_message_reaction_id.h"
#include "data/data_photo.h"
#include "data/data_folder.h"
#include "data/data_forum.h"
#include "data/data_forum_topic.h"
#include "data/data_saved_messages.h"
#include "data/data_session.h"
#include "data/data_file_origin.h"
#include "data/data_histories.h"
#include "data/data_cloud_themes.h"
#include "base/unixtime.h"
#include "base/crc32hash.h"
#include "lang/lang_keys.h"
#include "apiwrap.h"
#include "api/api_chat_participants.h"
#include "ui/boxes/confirm_box.h"
#include "main/main_session.h"
#include "main/main_session_settings.h"
#include "main/main_domain.h"
#include "main/main_app_config.h"
#include "mtproto/mtproto_config.h"
#include "core/application.h"
#include "core/click_handler_types.h"
#include "window/notifications_manager.h"
#include "window/window_session_controller.h"
#include "window/main_window.h" // Window::LogoNoMargin.
#include "ui/image/image.h"
#include "ui/chat/chat_style.h"
#include "ui/empty_userpic.h"
#include "ui/text/text_options.h"
#include "ui/painter.h"
#include "ui/unread_badge.h"
#include "ui/ui_utility.h"
#include "history/history.h"
#include "history/view/history_view_element.h"
#include "history/history_item.h"
#include "storage/file_download.h"
#include "storage/storage_account.h"
#include "storage/storage_facade.h"
#include "storage/storage_shared_media.h"

namespace {

constexpr auto kUpdateFullPeerTimeout = crl::time(5000); // Not more than once in 5 seconds.
constexpr auto kUserpicSize = 160;

using UpdateFlag = Data::PeerUpdate::Flag;

[[nodiscard]] const std::vector<QString> &IgnoredReasons(
		not_null<Main::Session*> session) {
	return session->appConfig().ignoredRestrictionReasons();
}

[[nodiscard]] int ParseRegistrationDate(const QString &text) {
	// MM.YYYY
	if (text.size() != 7 || text[2] != '.') {
		return 0;
	}
	const auto month = text.mid(0, 2).toInt();
	const auto year = text.mid(3, 4).toInt();
	return (year > 2012 && year < 2100 && month > 0 && month <= 12)
		? (year * 100) + month
		: 0;
}

[[nodiscard]] int RegistrationYear(int date) {
	const auto year = date / 100;
	return (year > 2012 && year < 2100) ? year : 0;
}

[[nodiscard]] int RegistrationMonth(int date) {
	const auto month = date % 100;
	return (month > 0 && month <= 12) ? month : 0;
}

} // namespace

namespace Data {

uint8 DecideColorIndex(PeerId peerId) {
	return Ui::DecideColorIndex(peerId.value & PeerId::kChatTypeMask);
}

PeerId FakePeerIdForJustName(const QString &name) {
	constexpr auto kShift = (0xFEULL << 32);
	const auto base = name.isEmpty()
		? 777
		: base::crc32(name.constData(), name.size() * sizeof(QChar));
	return peerFromUser(kShift + std::abs(base));
}

bool UnavailableReason::sensitive() const {
	return reason == u"sensitive"_q;
}

UnavailableReason UnavailableReason::Sensitive() {
	return { u"sensitive"_q };
}

QString UnavailableReason::Compute(
		not_null<Main::Session*> session,
		const std::vector<UnavailableReason> &list) {
	const auto &skip = IgnoredReasons(session);
	auto &&filtered = ranges::views::all(
		list
	) | ranges::views::filter([&](const Data::UnavailableReason &reason) {
		return !reason.sensitive()
			&& !ranges::contains(skip, reason.reason);
	});
	const auto first = filtered.begin();
	return (first != filtered.end()) ? first->text : QString();
}

bool UnavailableReason::IgnoreSensitiveMark(
		not_null<Main::Session*> session) {
	return ranges::contains(
			IgnoredReasons(session),
			UnavailableReason::Sensitive().reason);
}

// We should get a full restriction in "{full}: {reason}" format and we
// need to find an "-all" tag in {full}, otherwise ignore this restriction.
std::vector<UnavailableReason> UnavailableReason::Extract(
		const MTPvector<MTPRestrictionReason> *list) {
	if (!list) {
		return {};
	}
	return ranges::views::all(
		list->v
	) | ranges::views::filter([](const MTPRestrictionReason &restriction) {
		return restriction.match([&](const MTPDrestrictionReason &data) {
			const auto platform = data.vplatform().v;
			return false
#ifdef OS_MAC_STORE
				|| (platform == "ios"_q)
#elif defined OS_WIN_STORE // OS_MAC_STORE
				|| (platform == "ms"_q)
#endif // OS_MAC_STORE || OS_WIN_STORE
				|| (platform == "all"_q);
		});
	}) | ranges::views::transform([](const MTPRestrictionReason &restriction) {
		return restriction.match([&](const MTPDrestrictionReason &data) {
			return UnavailableReason{ qs(data.vreason()), qs(data.vtext()) };
		});
	}) | ranges::to_vector;
}

bool ApplyBotMenuButton(
		not_null<BotInfo*> info,
		const MTPBotMenuButton *button) {
	auto text = QString();
	auto url = QString();
	if (button) {
		button->match([&](const MTPDbotMenuButton &data) {
			text = qs(data.vtext());
			url = qs(data.vurl());
		}, [&](const auto &) {
		});
	}
	const auto changed = (info->botMenuButtonText != text)
		|| (info->botMenuButtonUrl != url);

	info->botMenuButtonText = text;
	info->botMenuButtonUrl = url;

	return changed;
}

AllowedReactions Parse(
		const MTPChatReactions &value,
		int maxCount,
		bool paidEnabled) {
	return value.match([&](const MTPDchatReactionsNone &) {
		return AllowedReactions{
			.maxCount = maxCount,
			.paidEnabled = paidEnabled,
		};
	}, [&](const MTPDchatReactionsAll &data) {
		return AllowedReactions{
			.maxCount = maxCount,
			.type = (data.is_allow_custom()
				? AllowedReactionsType::All
				: AllowedReactionsType::Default),
			.paidEnabled = paidEnabled,
		};
	}, [&](const MTPDchatReactionsSome &data) {
		return AllowedReactions{
			.some = ranges::views::all(
				data.vreactions().v
			) | ranges::views::transform(
				ReactionFromMTP
			) | ranges::to_vector,
			.maxCount = maxCount,
			.type = AllowedReactionsType::Some,
			.paidEnabled = paidEnabled,
		};
	});
}

PeerData *PeerFromInputMTP(
		not_null<Session*> owner,
		const MTPInputPeer &input) {
	return input.match([&](const MTPDinputPeerUser &data) {
		const auto user = owner->user(data.vuser_id().v);
		user->setAccessHash(data.vaccess_hash().v);
		return (PeerData*)user;
	}, [&](const MTPDinputPeerChat &data) {
		return (PeerData*)owner->chat(data.vchat_id().v);
	}, [&](const MTPDinputPeerChannel &data) {
		const auto channel = owner->channel(data.vchannel_id().v);
		channel->setAccessHash(data.vaccess_hash().v);
		return (PeerData*)channel;
	}, [&](const MTPDinputPeerSelf &data) {
		return (PeerData*)owner->session().user();
	}, [&](const auto &data) {
		return (PeerData*)nullptr;
	});
}

UserData *UserFromInputMTP(
		not_null<Session*> owner,
		const MTPInputUser &input) {
	return input.match([&](const MTPDinputUser &data) {
		const auto user = owner->user(data.vuser_id().v);
		user->setAccessHash(data.vaccess_hash().v);
		return user.get();
	}, [&](const MTPDinputUserSelf &data) {
		return owner->session().user().get();
	}, [](const auto &data) {
		return (UserData*)nullptr;
	});
}

Ui::ColorCollectible ParseColorCollectible(
		const MTPDpeerColorCollectible &data) {
	return {
		.collectibleId = data.vcollectible_id().v,
		.giftEmojiId = data.vgift_emoji_id().v,
		.backgroundEmojiId = data.vbackground_emoji_id().v,
		.accentColor = Ui::ColorFromSerialized(data.vaccent_color()),
		.strip = ranges::views::all(
			data.vcolors().v
		) | ranges::views::transform(
			&Ui::ColorFromSerialized
		) | ranges::to_vector,
		.darkAccentColor = Ui::MaybeColorFromSerialized(
			data.vdark_accent_color()).value_or(QColor(0, 0, 0, 0)),
		.darkStrip = (data.vdark_colors()
			? ranges::views::all(
				data.vdark_colors()->v
			) | ranges::views::transform(
				&Ui::ColorFromSerialized
			) | ranges::to_vector
			: std::vector<QColor>()),
	};
}

} // namespace Data

PeerClickHandler::PeerClickHandler(not_null<PeerData*> peer)
: _peer(peer) {
	setProperty(kPeerLinkPeerIdProperty, peer->id.value);
}

void PeerClickHandler::onClick(ClickContext context) const {
	if (context.button != Qt::LeftButton) {
		return;
	}
	const auto my = context.other.value<ClickHandlerContext>();
	const auto window = [&]() -> Window::SessionController* {
		if (const auto controller = my.sessionWindow.get()) {
			return controller;
		}
		const auto &windows = _peer->session().windows();
		if (windows.empty()) {
			_peer->session().domain().activate(&_peer->session().account());
			if (windows.empty()) {
				return nullptr;
			}
		}
		return windows.front();
	}();
	if (window) {
		window->showPeer(_peer);
	}
}

PeerData::PeerData(not_null<Data::Session*> owner, PeerId id)
: id(id)
, _owner(owner)
, _colorIndex(Data::DecideColorIndex(id)) {
}

Data::Session &PeerData::owner() const {
	return *_owner;
}

Main::Session &PeerData::session() const {
	return _owner->session();
}

Main::Account &PeerData::account() const {
	return session().account();
}

void PeerData::updateNameDelayed(
		const QString &newName,
		const QString &newNameOrPhone,
		const QString &newUsername) {
	if (_name == newName && _nameVersion > 1) {
		if (isUser()) {
			if (asUser()->nameOrPhone == newNameOrPhone
				&& asUser()->editableUsername() == newUsername) {
				return;
			}
		} else if (isChannel()) {
			if (asChannel()->editableUsername() == newUsername) {
				return;
			}
		} else if (isChat()) {
			return;
		}
	}
	_name = newName;
	invalidateEmptyUserpic();

	auto flags = UpdateFlag::None | UpdateFlag::None;
	auto oldFirstLetters = base::flat_set<QChar>();
	const auto nameUpdated = (_nameVersion++ > 1);
	if (nameUpdated) {
		oldFirstLetters = nameFirstLetters();
		flags |= UpdateFlag::Name;
	}
	if (isUser()) {
		if (asUser()->editableUsername() != newUsername) {
			asUser()->setUsername(newUsername);
			flags |= UpdateFlag::Username;
		}
		asUser()->setNameOrPhone(newNameOrPhone);
	} else if (isChannel()) {
		if (asChannel()->editableUsername() != newUsername) {
			asChannel()->setUsername(newUsername);
			if (asChannel()->username().isEmpty()) {
				asChannel()->removeFlags(ChannelDataFlag::Username);
			} else {
				asChannel()->addFlags(ChannelDataFlag::Username);
			}
			flags |= UpdateFlag::Username;
		}
	}
	fillNames();
	if (nameUpdated) {
		session().changes().nameUpdated(this, std::move(oldFirstLetters));
	}
	if (flags) {
		session().changes().peerUpdated(this, flags);
	}
}

not_null<Ui::EmptyUserpic*> PeerData::ensureEmptyUserpic() const {
	if (!_userpicEmpty) {
		const auto user = asUser();
		_userpicEmpty = std::make_unique<Ui::EmptyUserpic>(
			Ui::EmptyUserpic::UserpicColor(colorIndex()),
			((user && user->isInaccessible())
				? Ui::EmptyUserpic::InaccessibleName()
				: name()));
	}
	return _userpicEmpty.get();
}

void PeerData::invalidateEmptyUserpic() {
	_userpicEmpty = nullptr;
}

void PeerData::checkTrustedPayForMessage() {
	if (!_checkedTrustedPayForMessage
		&& !starsPerMessage()
		&& session().local().peerTrustedPayForMessageRead()) {
		_checkedTrustedPayForMessage = 1;
		if (session().local().hasPeerTrustedPayForMessageEntry(id)) {
			session().local().clearPeerTrustedPayForMessage(id);
		}
	}
}

ClickHandlerPtr PeerData::createOpenLink() {
	return std::make_shared<PeerClickHandler>(this);
}

void PeerData::setUserpic(
		PhotoId photoId,
		const ImageLocation &location,
		bool hasVideo) {
	_userpicPhotoId = photoId;
	_userpicHasVideo = hasVideo ? 1 : 0;
	_userpic.set(&session(), ImageWithLocation{ .location = location });
}

void PeerData::setUserpicPhoto(const MTPPhoto &data) {
	const auto photoId = data.match([&](const MTPDphoto &data) {
		const auto photo = owner().processPhoto(data);
		photo->peer = this;
		return photo->id;
	}, [](const MTPDphotoEmpty &data) {
		return PhotoId(0);
	});
	if (_userpicPhotoId != photoId) {
		_userpicPhotoId = photoId;
		session().changes().peerUpdated(this, UpdateFlag::Photo);
	}
}

QImage *PeerData::userpicCloudImage(Ui::PeerUserpicView &view) const {
	if (!_userpic.isCurrentView(view.cloud)) {
		if (!_userpic.empty()) {
			view.cloud = _userpic.createView();
			_userpic.load(&session(), userpicOrigin());
		} else {
			view.cloud = nullptr;
		}
		view.cached = QImage();
	}
	if (const auto image = view.cloud.get(); image && !image->isNull()) {
		_userpicEmpty = nullptr;
		return image;
	} else if (isNotificationsUser()) {
		static auto result = Window::LogoNoMargin().scaledToWidth(
			kUserpicSize,
			Qt::SmoothTransformation);
		return &result;
	}
	return nullptr;
}

void PeerData::paintUserpic(
		QPainter &p,
		Ui::PeerUserpicView &view,
		PaintUserpicContext context) const {
	if (const auto broadcast = monoforumBroadcast()) {
		if (context.shape == Ui::PeerUserpicShape::Auto) {
			context.shape = Ui::PeerUserpicShape::Monoforum;
		}
		broadcast->paintUserpic(p, view, context);
		return;
	}
	const auto size = context.size;
	const auto cloud = userpicCloudImage(view);
	const auto ratio = style::DevicePixelRatio();
	if (context.shape == Ui::PeerUserpicShape::Auto) {
		context.shape = userpicShape();
	}
	Ui::ValidateUserpicCache(
		view,
		cloud,
		cloud ? nullptr : ensureEmptyUserpic().get(),
		size * ratio,
		context.shape);
	p.drawImage(QRect(context.position, QSize(size, size)), view.cached);
}

void PeerData::loadUserpic() {
	_userpic.load(&session(), userpicOrigin());
}

bool PeerData::hasUserpic() const {
	return !_userpic.empty();
}

Ui::PeerUserpicView PeerData::activeUserpicView() {
	return { .cloud = _userpic.empty() ? nullptr : _userpic.activeView() };
}

Ui::PeerUserpicView PeerData::createUserpicView() {
	if (_userpic.empty()) {
		return {};
	}
	auto result = _userpic.createView();
	_userpic.load(&session(), userpicPhotoOrigin());
	return { .cloud = result };
}

bool PeerData::useEmptyUserpic(Ui::PeerUserpicView &view) const {
	return !userpicCloudImage(view);
}

InMemoryKey PeerData::userpicUniqueKey(Ui::PeerUserpicView &view) const {
	if (const auto broadcast = monoforumBroadcast()) {
		return broadcast->userpicUniqueKey(view);
	}
	return useEmptyUserpic(view)
		? ensureEmptyUserpic()->uniqueKey()
		: inMemoryKey(_userpic.location());
}

QImage PeerData::GenerateUserpicImage(
		not_null<PeerData*> peer,
		Ui::PeerUserpicView &view,
		int size,
		std::optional<int> radius) {
	if (const auto userpic = peer->userpicCloudImage(view)) {
		auto image = userpic->scaled(
			{ size, size },
			Qt::IgnoreAspectRatio,
			Qt::SmoothTransformation);
		const auto round = [&](int radius) {
			return Images::Round(
				std::move(image),
				Images::CornersMask(radius / style::DevicePixelRatio()));
		};
		if (radius == 0) {
			return image;
		} else if (radius) {
			return round(*radius);
		} else if (peer->isForum()) {
			return round(size * Ui::ForumUserpicRadiusMultiplier());
		} else {
			return Images::Circle(std::move(image));
		}
	}
	auto result = QImage(
		QSize(size, size),
		QImage::Format_ARGB32_Premultiplied);
	result.fill(Qt::transparent);

	Painter p(&result);
	if (radius == 0) {
		peer->ensureEmptyUserpic()->paintSquare(p, 0, 0, size, size);
	} else if (radius) {
		const auto r = *radius;
		peer->ensureEmptyUserpic()->paintRounded(p, 0, 0, size, size, r);
	} else if (peer->isForum()) {
		peer->ensureEmptyUserpic()->paintRounded(
			p,
			0,
			0,
			size,
			size,
			size * Ui::ForumUserpicRadiusMultiplier());
	} else {
		peer->ensureEmptyUserpic()->paintCircle(p, 0, 0, size, size);
	}
	p.end();

	return result;
}

ImageLocation PeerData::userpicLocation() const {
	return _userpic.location();
}

bool PeerData::userpicPhotoUnknown() const {
	return (_userpicPhotoId == kUnknownPhotoId);
}

PhotoId PeerData::userpicPhotoId() const {
	return userpicPhotoUnknown() ? 0 : _userpicPhotoId;
}

bool PeerData::userpicHasVideo() const {
	return _userpicHasVideo != 0;
}

Data::FileOrigin PeerData::userpicOrigin() const {
	return Data::FileOriginPeerPhoto(id);
}

Data::FileOrigin PeerData::userpicPhotoOrigin() const {
	return (isUser() && userpicPhotoId())
		? Data::FileOriginFullUser(peerToUser(id))
		: Data::FileOrigin();
}

void PeerData::updateUserpic(
		PhotoId photoId,
		MTP::DcId dcId,
		bool hasVideo) {
	setUserpicChecked(
		photoId,
		ImageLocation(
			{ StorageFileLocation(
				dcId,
				isSelf() ? peerToUser(id) : UserId(),
				MTP_inputPeerPhotoFileLocation(
					MTP_flags(0),
					input(),
					MTP_long(photoId))) },
			kUserpicSize,
			kUserpicSize),
		hasVideo);
}

void PeerData::clearUserpic() {
	setUserpicChecked(PhotoId(), ImageLocation(), false);
}

void PeerData::setUserpicChecked(
		PhotoId photoId,
		const ImageLocation &location,
		bool hasVideo) {
	if (_userpicPhotoId != photoId
		|| _userpic.location() != location
		|| _userpicHasVideo != (hasVideo ? 1 : 0)) {
		const auto known = !userpicPhotoUnknown();
		setUserpic(photoId, location, hasVideo);
		session().changes().peerUpdated(this, UpdateFlag::Photo);
		if (known && isPremium() && userpicPhotoUnknown()) {
			updateFull();
		}
	}
}

auto PeerData::unavailableReasons() const
-> const std::vector<Data::UnavailableReason> & {
	static const auto result = std::vector<Data::UnavailableReason>();
	return result;
}

QString PeerData::computeUnavailableReason() const {
	return Data::UnavailableReason::Compute(
		&session(),
		unavailableReasons());
}

bool PeerData::hasSensitiveContent() const {
	return _sensitiveContent == 1;
}

void PeerData::setUnavailableReasonsList(
		std::vector<Data::UnavailableReason> &&reasons) {
	Unexpected("PeerData::setUnavailableReasonsList.");
}

void PeerData::setUnavailableReasons(
		std::vector<Data::UnavailableReason> &&reasons) {
	const auto i = ranges::find(
		reasons,
		true,
		&Data::UnavailableReason::sensitive);
	const auto sensitive = (i != end(reasons));
	if (sensitive) {
		reasons.erase(i);
	}
	auto changed = (sensitive != hasSensitiveContent());
	if (changed) {
		setHasSensitiveContent(sensitive);
	}
	if (reasons != unavailableReasons()) {
		setUnavailableReasonsList(std::move(reasons));
		changed = true;
	}
	if (changed) {
		session().changes().peerUpdated(
			this,
			UpdateFlag::UnavailableReason);
	}
}

void PeerData::setHasSensitiveContent(bool has) {
	_sensitiveContent = has ? 1 : 0;
	if (has) {
		session().api().sensitiveContent().preload();
	}
}

// This is duplicated in CanPinMessagesValue().
bool PeerData::canPinMessages() const {
	if (const auto user = asUser()) {
		return !user->amRestricted(ChatRestriction::PinMessages);
	} else if (const auto chat = asChat()) {
		return chat->amIn()
			&& !chat->amRestricted(ChatRestriction::PinMessages);
	} else if (const auto channel = asChannel()) {
		return channel->isMegagroup()
			? !channel->amRestricted(ChatRestriction::PinMessages)
			: ((channel->amCreator()
				|| channel->adminRights() & ChatAdminRight::EditMessages));
	}
	Unexpected("Peer type in PeerData::canPinMessages.");
}

bool PeerData::canCreatePolls(bool forbidInForums) const {
	if (const auto user = asUser()) {
		return user->isSelf()
			|| (user->isBot()
				&& !user->isSupport()
				&& !user->isRepliesChat()
				&& !user->isVerifyCodes());
	} else if (isMonoforum()) {
		return false;
	}
	return Data::CanSend(this, ChatRestriction::SendPolls, forbidInForums);
}

bool PeerData::canCreateTodoLists(bool forbidInForums) const {
	if (isMonoforum() || isBroadcast()) {
		return false;
	}
	return session().premium()
		&& (Data::CanSend(this, ChatRestriction::SendPolls, forbidInForums)
			|| isUser());
}

bool PeerData::canCreateTopics() const {
	if (const auto bot = asBot()) {
		return bot->isForum();
	} else if (const auto channel = asChannel()) {
		return channel->isForum()
			&& !channel->amRestricted(ChatRestriction::CreateTopics);
	}
	return false;
}

bool PeerData::canManageTopics() const {
	if (const auto bot = asBot()) {
		return bot->isForum();
	} else if (const auto channel = asChannel()) {
		return channel->isForum()
			&& (channel->amCreator()
				|| (channel->adminRights() & ChatAdminRight::ManageTopics));
	}
	return false;
}

bool PeerData::canPostStories() const {
	if (const auto channel = asChannel()) {
		return channel->canPostStories();
	}
	return isSelf();
}

bool PeerData::canEditStories() const {
	if (const auto channel = asChannel()) {
		return channel->canEditStories();
	}
	return isSelf();
}

bool PeerData::canDeleteStories() const {
	if (const auto channel = asChannel()) {
		return channel->canDeleteStories();
	}
	return isSelf();
}

bool PeerData::canManageGifts() const {
	if (const auto channel = asChannel()) {
		return channel->canPostMessages();
	}
	return isSelf();
}

bool PeerData::canTransferGifts() const {
	if (const auto channel = asChannel()) {
		return channel->amCreator();
	}
	return isSelf();
}

bool PeerData::canEditMessagesIndefinitely() const {
	if (const auto user = asUser()) {
		return user->isSelf();
	} else if (isChat()) {
		return false;
	} else if (const auto channel = asChannel()) {
		return channel->isMegagroup()
			? channel->canPinMessages()
			: channel->canEditMessages();
	}
	Unexpected("Peer type in PeerData::canEditMessagesIndefinitely.");
}

bool PeerData::canExportChatHistory() const {
	if (isRepliesChat() || isVerifyCodes() || !allowsForwarding()) {
		return false;
	} else if (const auto channel = asChannel()) {
		if (!channel->amIn() && channel->invitePeekExpires()) {
			return false;
		}
	}
	for (const auto &block : _owner->history(id)->blocks) {
		for (const auto &message : block->messages) {
			if (!message->data()->isService()) {
				return true;
			}
		}
	}
	if (const auto from = migrateFrom()) {
		return from->canExportChatHistory();
	}
	return false;
}

bool PeerData::autoTranslation() const {
	if (const auto channel = asChannel()) {
		return channel->autoTranslation();
	}
	return false;
}

bool PeerData::setAbout(const QString &newAbout) {
	if (_about == newAbout) {
		return false;
	}
	_about = newAbout;
	session().changes().peerUpdated(this, UpdateFlag::About);
	return true;
}

void PeerData::checkFolder(FolderId folderId) {
	const auto folder = folderId
		? owner().folderLoaded(folderId)
		: nullptr;
	if (const auto history = owner().historyLoaded(this)) {
		if (folder && history->folder() != folder) {
			owner().histories().requestDialogEntry(history);
		}
	}
}

void PeerData::clearBusinessBot() {
	if (const auto details = _barDetails.get()) {
		if (details->requestChatDate
			|| details->paysPerMessage
			|| !details->phoneCountryCode.isEmpty()) {
			details->businessBot = nullptr;
			details->businessBotManageUrl = QString();
		} else {
			_barDetails = nullptr;
		}
	}
	if (const auto settings = barSettings()) {
		setBarSettings(*settings
			& ~PeerBarSetting::BusinessBotPaused
			& ~PeerBarSetting::BusinessBotCanReply
			& ~PeerBarSetting::HasBusinessBot);
	}
}

void PeerData::setTranslationDisabled(bool disabled) {
	const auto flag = disabled
		? TranslationFlag::Disabled
		: TranslationFlag::Enabled;
	if (_translationFlag != flag) {
		_translationFlag = flag;
		session().changes().peerUpdated(
			this,
			UpdateFlag::TranslationDisabled);
	}
}

PeerData::TranslationFlag PeerData::translationFlag() const {
	return _translationFlag;
}

void PeerData::saveTranslationDisabled(bool disabled) {
	setTranslationDisabled(disabled);

	using Flag = MTPmessages_TogglePeerTranslations::Flag;
	session().api().request(MTPmessages_TogglePeerTranslations(
		MTP_flags(disabled ? Flag::f_disabled : Flag()),
		input()
	)).send();
}

void PeerData::setBarSettings(const MTPPeerSettings &data) {
	data.match([&](const MTPDpeerSettings &data) {
		const auto wasPaysPerMessage = paysPerMessage();
		if (!data.vbusiness_bot_id()
			&& !data.vrequest_chat_title()
			&& !data.vcharge_paid_message_stars()
			&& !data.vphone_country()
			&& !data.vregistration_month()
			&& !data.vname_change_date()
			&& !data.vphoto_change_date()) {
			_barDetails = nullptr;
		} else if (!_barDetails) {
			_barDetails = std::make_unique<PeerBarDetails>();
		}
		if (_barDetails) {
			_barDetails->phoneCountryCode
				= qs(data.vphone_country().value_or_empty());
			_barDetails->registrationDate = ParseRegistrationDate(
				data.vregistration_month().value_or_empty());
			_barDetails->nameChangeDate
				= data.vname_change_date().value_or_empty();
			_barDetails->photoChangeDate
				= data.vphoto_change_date().value_or_empty();
			_barDetails->requestChatTitle
				= qs(data.vrequest_chat_title().value_or_empty());
			_barDetails->requestChatDate
				= data.vrequest_chat_date().value_or_empty();
			_barDetails->businessBot = data.vbusiness_bot_id()
				? _owner->user(data.vbusiness_bot_id()->v).get()
				: nullptr;
			_barDetails->businessBotManageUrl
				= qs(data.vbusiness_bot_manage_url().value_or_empty());
			_barDetails->paysPerMessage
				= data.vcharge_paid_message_stars().value_or_empty();
		}
		using Flag = PeerBarSetting;
		setBarSettings((data.is_add_contact() ? Flag::AddContact : Flag())
			| (data.is_autoarchived() ? Flag::AutoArchived : Flag())
			| (data.is_block_contact() ? Flag::BlockContact : Flag())
			//| (data.is_invite_members() ? Flag::InviteMembers : Flag())
			| (data.is_need_contacts_exception()
				? Flag::NeedContactsException
				: Flag())
			//| (data.is_report_geo() ? Flag::ReportGeo : Flag())
			| (data.is_report_spam() ? Flag::ReportSpam : Flag())
			| (data.is_share_contact() ? Flag::ShareContact : Flag())
			| (data.vrequest_chat_title() ? Flag::RequestChat : Flag())
			| (data.vbusiness_bot_id() ? Flag::HasBusinessBot : Flag())
			| (data.is_request_chat_broadcast()
				? Flag::RequestChatIsBroadcast
				: Flag())
			| (data.is_business_bot_paused()
				? Flag::BusinessBotPaused
				: Flag())
			| (data.is_business_bot_can_reply()
				? Flag::BusinessBotCanReply
				: Flag()));
		if (wasPaysPerMessage != paysPerMessage()) {
			session().changes().peerUpdated(
				this,
				UpdateFlag::PaysPerMessage);
		}
	});
}

void PeerData::setBarSettings(PeerBarSettings which) {
	const auto was = hideLinks();
	_barSettings.set(which);
	if (was && !hideLinks()) {
		if (const auto history = owner().historyLoaded(this)) {
			crl::on_main(&history->session(), [=] {
				history->refreshHiddenLinksItems();
			});
		}
		if (const auto from = migrateFrom()) {
			if (const auto history = owner().historyLoaded(from)) {
				crl::on_main(&history->session(), [=] {
					history->refreshHiddenLinksItems();
				});
			}
		}
	}
}

int PeerData::paysPerMessage() const {
	return _barDetails ? _barDetails->paysPerMessage : 0;
}

void PeerData::clearPaysPerMessage() {
	if (const auto details = _barDetails.get()) {
		if (details->paysPerMessage) {
			if (details->businessBot
				|| details->requestChatDate
				|| !details->phoneCountryCode.isEmpty()) {
				details->paysPerMessage = 0;
			} else {
				_barDetails = nullptr;
			}
			session().changes().peerUpdated(
				this,
				UpdateFlag::PaysPerMessage);
		}
	}
}

bool PeerData::hideLinks() const {
	//if (!isUser()) {
	//	return false;
	//}
	if (const auto to = migrateTo()) {
		return to->hideLinks();
	}
	const auto settings = barSettings();
	return !settings || (*settings & PeerBarSetting::ReportSpam);
}

QString PeerData::requestChatTitle() const {
	return _barDetails ? _barDetails->requestChatTitle : QString();
}