None,

NoPassword,

Later,

not_null<Ui::GenericBox*> box,

not_null<Main::Session*> session) {

session->api().cloudPassword().state(

) | rpl::on_next([=] {

using namespace Settings;

const auto weak = base::make_weak(box);

if (CheckEditCloudPassword(session)) {

box->getDelegate()->show(

EditCloudPasswordBox(session));

} else {

box->getDelegate()->show(CloudPasswordAppOutdatedBox());

}

if (weak) {

weak->closeBox();

}

}, box->lifetime());

not_null<Ui::GenericBox*> box,

not_null<Main::Session*> session,

TextWithEntities &&about,

PasswordErrorType error) {

box->setTitle(tr::lng_rights_transfer_check());

box->setWidth(st::transferCheckWidth);

auto text = std::move(about).append('\n').append('\n').append(

tr::lng_rights_transfer_check_password(

tr::now,

tr::rich)

).append('\n').append('\n').append(

tr::lng_rights_transfer_check_session(

tr::now,

tr::rich)

);

if (error == PasswordErrorType::Later) {

text.append('\n').append('\n').append(

tr::lng_rights_transfer_check_later(

tr::now,

tr::rich));

}

box->addRow(object_ptr<Ui::FlatLabel>(

box,

rpl::single(text),

st::boxLabel));

if (error == PasswordErrorType::Later) {

box->addButton(tr::lng_box_ok(), [=] { box->closeBox(); });

} else {

box->addButton(tr::lng_rights_transfer_set_password(), [=] {

SetCloudPassword(box, session);

});

box->addButton(tr::lng_cancel(), [=] { box->closeBox(); });

}

not_null<Main::Session*> session,

not_null<Ui::BoxContent*> context,

Fn<void()> close) {

const auto weak = base::make_weak(context.get());

auto lifetime = std::make_shared<rpl::lifetime>();

auto finish = [=](const QString &message) mutable {

if (const auto strong = weak.get()) {

if (!message.isEmpty()) {

strong->getDelegate()->show(Ui::MakeInformBox(message));

}

strong->closeBox();

}

close();

if (lifetime) {

base::take(lifetime)->destroy();

}

};

session->api().cloudPassword().resetPassword(

) | rpl::on_next_error_done([=](

Api::CloudPassword::ResetRetryDate retryDate) {

constexpr auto kMinute = 60;

constexpr auto kHour = 3600;

constexpr auto kDay = 86400;

const auto left = std::max(

retryDate - base::unixtime::now(),

kMinute);

const auto days = (left / kDay);

const auto hours = (left / kHour);

const auto minutes = (left / kMinute);

const auto duration = days

? tr::lng_days(tr::now, lt_count, days)

: hours

? tr::lng_hours(tr::now, lt_count, hours)

: tr::lng_minutes(tr::now, lt_count, minutes);

if (const auto strong = weak.get()) {

strong->getDelegate()->show(Ui::MakeInformBox(

tr::lng_cloud_password_reset_later(

tr::now,

lt_duration,

duration)));

}

}, [=](const QString &error) mutable {

finish("Error: " + error);

}, [=]() mutable {

finish({});

}, *lifetime);

QWidget*,

not_null<Main::Session*> session,

bool turningOff)

: _session(session)

, _api(&_session->mtp())

, _textWidth(st::boxWidth - st::boxPadding.left() * 1.5)

, _turningOff(turningOff)

, _about(_textWidth)

, _oldPasscode(this, st::defaultInputField, tr::lng_passcode_enter_old())

, _newPasscode(

this,

st::defaultInputField,

session->domain().local().hasLocalPasscode()

? tr::lng_passcode_enter_new()

: tr::lng_passcode_enter_first())

, _reenterPasscode(this, st::defaultInputField, tr::lng_passcode_confirm_new())

, _passwordHint(this, st::defaultInputField, tr::lng_cloud_password_hint())

, _recoverEmail(this, st::defaultInputField, tr::lng_cloud_password_email())

, _recover(this, tr::lng_signin_recover(tr::now)) {

QWidget*,

not_null<MTP::Instance*> mtp,

Main::Session *session,

const CloudFields &fields)

: _session(session)

, _api(mtp)

, _textWidth(st::boxWidth - st::boxPadding.left() * 1.5)

, _turningOff(fields.turningOff)

, _cloudPwd(true)

, _cloudFields(fields)

, _about(_textWidth)

, _oldPasscode(this, st::defaultInputField, tr::lng_cloud_password_enter_old())

, _newPasscode(

this,

st::defaultInputField,

(fields.hasPassword

? tr::lng_cloud_password_enter_new()

: tr::lng_cloud_password_enter_first()))

, _reenterPasscode(this, st::defaultInputField, tr::lng_cloud_password_confirm_new())

, _passwordHint(

this,

st::defaultInputField,

(fields.hasPassword

? tr::lng_cloud_password_change_hint()

: tr::lng_cloud_password_hint()))

, _recoverEmail(this, st::defaultInputField, tr::lng_cloud_password_email())

, _recover(this, tr::lng_signin_recover(tr::now))

, _showRecoverLink(_cloudFields.hasRecovery || !_cloudFields.pendingResetDate) {

Expects(session != nullptr || !fields.fromRecoveryCode.isEmpty());

Expects(!_turningOff || _cloudFields.hasPassword);

if (!_cloudFields.hint.isEmpty()) {

_hintText.setText(

st::passcodeTextStyle,

tr::lng_signin_hint(tr::now, lt_password_hint, _cloudFields.hint));

}

QWidget*,

not_null<Main::Session*> session,

const CloudFields &fields)

: PasscodeBox(nullptr, &session->mtp(), session, fields) {

return _cloudPwd

? _cloudFields.hasPassword

: _session->domain().local().hasLocalPasscode();

addButton(

(_cloudFields.customSubmitButton

? std::move(_cloudFields.customSubmitButton)

: _turningOff

? tr::lng_passcode_remove_button()

: tr::lng_settings_save()),

[=] { save(); });

addButton(tr::lng_cancel(), [=] { closeBox(); });

_about.setText(

st::passcodeTextStyle,

(_cloudFields.customDescription

? *_cloudFields.customDescription

: _cloudPwd

? tr::lng_cloud_password_about(tr::now)

: tr::lng_passcode_about(tr::now)));

_aboutHeight = _about.countHeight(_textWidth);

const auto onlyCheck = onlyCheckCurrent();

if (onlyCheck) {

_oldPasscode->show();

setTitle(_cloudFields.customTitle

? std::move(_cloudFields.customTitle)

: _cloudPwd

? tr::lng_cloud_password_remove()

: tr::lng_passcode_remove());

setDimensions(st::boxWidth, st::passcodePadding.top() + _oldPasscode->height() + st::passcodeTextLine + ((_showRecoverLink && !_hintText.isEmpty()) ? st::passcodeTextLine : 0) + st::passcodeAboutSkip + _aboutHeight + st::passcodePadding.bottom());

} else {

if (currentlyHave()) {

_oldPasscode->show();

setTitle(_cloudPwd

? tr::lng_cloud_password_change()

: tr::lng_passcode_change());

setDimensions(st::boxWidth, st::passcodePadding.top() + _oldPasscode->height() + st::passcodeTextLine + ((_showRecoverLink && !_hintText.isEmpty()) ? st::passcodeTextLine : 0) + _newPasscode->height() + st::passcodeLittleSkip + _reenterPasscode->height() + st::passcodeSkip + (_cloudPwd ? _passwordHint->height() + st::passcodeLittleSkip : 0) + st::passcodeAboutSkip + _aboutHeight + st::passcodePadding.bottom());

} else {

_oldPasscode->hide();

setTitle(_cloudPwd

? (_cloudFields.fromRecoveryCode.isEmpty()

? tr::lng_cloud_password_create()

: tr::lng_cloud_password_change())

: tr::lng_passcode_create());

setDimensions(st::boxWidth, st::passcodePadding.top() + _newPasscode->height() + st::passcodeLittleSkip + _reenterPasscode->height() + st::passcodeSkip + (_cloudPwd ? _passwordHint->height() + st::passcodeLittleSkip : 0) + st::passcodeAboutSkip + _aboutHeight + ((_cloudPwd && _cloudFields.fromRecoveryCode.isEmpty()) ? (st::passcodeLittleSkip + _recoverEmail->height() + st::passcodeSkip) : st::passcodePadding.bottom()));

}

}

connect(_oldPasscode, &Ui::MaskedInputField::changed, [=] { oldChanged(); });

connect(_newPasscode, &Ui::MaskedInputField::changed, [=] { newChanged(); });

connect(_reenterPasscode, &Ui::MaskedInputField::changed, [=] { newChanged(); });

_passwordHint->changes(

) | rpl::on_next([=] {

newChanged();

}, _passwordHint->lifetime());

_recoverEmail->changes(

) | rpl::on_next([=] {

if (!_emailError.isEmpty()) {

_emailError = QString();

update();

}

}, _recoverEmail->lifetime());

const auto fieldSubmit = [=] { submit(); };

connect(_oldPasscode, &Ui::MaskedInputField::submitted, fieldSubmit);

connect(_newPasscode, &Ui::MaskedInputField::submitted, fieldSubmit);

connect(_reenterPasscode, &Ui::MaskedInputField::submitted, fieldSubmit);

_passwordHint->submits(

) | rpl::on_next(fieldSubmit, _passwordHint->lifetime());

_recoverEmail->submits(

) | rpl::on_next(fieldSubmit, _recoverEmail->lifetime());

_recover->addClickHandler([=] { recoverByEmail(); });

const auto has = currentlyHave();

_oldPasscode->setVisible(onlyCheck || has);

_recover->setVisible((onlyCheck || has)

&& _cloudPwd

&& _showRecoverLink);

_newPasscode->setVisible(!onlyCheck);

_reenterPasscode->setVisible(!onlyCheck);

_passwordHint->setVisible(!onlyCheck && _cloudPwd);

_recoverEmail->setVisible(!onlyCheck

&& _cloudPwd

&& !has

&& _cloudFields.fromRecoveryCode.isEmpty());

const auto has = currentlyHave();

if (_oldPasscode->hasFocus()) {

if (onlyCheckCurrent()) {

save();

} else {

_newPasscode->setFocus();

}

} else if (_newPasscode->hasFocus()) {

_reenterPasscode->setFocus();

} else if (_reenterPasscode->hasFocus()) {

if (has && _oldPasscode->text().isEmpty()) {

_oldPasscode->setFocus();

_oldPasscode->showError();

} else if (_newPasscode->text().isEmpty()) {

_newPasscode->setFocus();

_newPasscode->showError();

} else if (_reenterPasscode->text().isEmpty()) {

_reenterPasscode->showError();

} else if (!_passwordHint->isHidden()) {

_passwordHint->setFocus();

} else {

save();

}

} else if (_passwordHint->hasFocus()) {

if (_recoverEmail->isHidden()) {

save();

} else {

_recoverEmail->setFocus();

}

} else if (_recoverEmail->hasFocus()) {

save();

}

BoxContent::paintEvent(e);

Painter p(this);

int32 abouty = (_passwordHint->isHidden() ? ((_reenterPasscode->isHidden() ? (_oldPasscode->y() + (_showRecoverLink && !_hintText.isEmpty() ? st::passcodeTextLine : 0)) : _reenterPasscode->y()) + st::passcodeSkip) : _passwordHint->y()) + _oldPasscode->height() + st::passcodeLittleSkip + st::passcodeAboutSkip;

p.setPen(st::boxTextFg);

_about.drawLeft(p, st::boxPadding.left(), abouty, _textWidth, width());

if (!_hintText.isEmpty() && _oldError.isEmpty()) {

_hintText.drawLeftElided(p, st::boxPadding.left(), _oldPasscode->y() + _oldPasscode->height() + ((st::passcodeTextLine - st::normalFont->height) / 2), _textWidth, width(), 1, style::al_topleft);

}

if (!_oldError.isEmpty()) {

p.setPen(st::boxTextFgError);

p.drawText(QRect(st::boxPadding.left(), _oldPasscode->y() + _oldPasscode->height(), _textWidth, st::passcodeTextLine), _oldError, style::al_left);

}

if (!_newError.isEmpty()) {

p.setPen(st::boxTextFgError);

p.drawText(QRect(st::boxPadding.left(), _reenterPasscode->y() + _reenterPasscode->height(), _textWidth, st::passcodeTextLine), _newError, style::al_left);

}

if (!_emailError.isEmpty()) {

p.setPen(st::boxTextFgError);

p.drawText(QRect(st::boxPadding.left(), _recoverEmail->y() + _recoverEmail->height(), _textWidth, st::passcodeTextLine), _emailError, style::al_left);

}

BoxContent::resizeEvent(e);

const auto has = currentlyHave();

int32 w = st::boxWidth - st::boxPadding.left() - st::boxPadding.right();

_oldPasscode->resize(w, _oldPasscode->height());

_oldPasscode->moveToLeft(st::boxPadding.left(), st::passcodePadding.top());

_newPasscode->resize(w, _newPasscode->height());

_newPasscode->moveToLeft(st::boxPadding.left(), _oldPasscode->y() + ((_turningOff || has) ? (_oldPasscode->height() + st::passcodeTextLine + ((_showRecoverLink && !_hintText.isEmpty()) ? st::passcodeTextLine : 0)) : 0));

_reenterPasscode->resize(w, _reenterPasscode->height());

_reenterPasscode->moveToLeft(st::boxPadding.left(), _newPasscode->y() + _newPasscode->height() + st::passcodeLittleSkip);

_passwordHint->resize(w, _passwordHint->height());

_passwordHint->moveToLeft(st::boxPadding.left(), _reenterPasscode->y() + _reenterPasscode->height() + st::passcodeSkip);

_recoverEmail->resize(w, _passwordHint->height());

_recoverEmail->moveToLeft(st::boxPadding.left(), _passwordHint->y() + _passwordHint->height() + st::passcodeLittleSkip + _aboutHeight + st::passcodeLittleSkip);

if (!_recover->isHidden()) {

_recover->moveToLeft(st::boxPadding.left(), _oldPasscode->y() + _oldPasscode->height() + (_hintText.isEmpty() ? ((st::passcodeTextLine - _recover->height()) / 2) : st::passcodeTextLine));

}

if (_skipEmailWarning && !_recoverEmail->isHidden()) {

_recoverEmail->setFocusFast();

} else if (_oldPasscode->isHidden()) {

_newPasscode->setFocusFast();

} else {

_oldPasscode->setFocusFast();

}

const QByteArray &newPasswordBytes,

const MTPauth_Authorization &result) {

if (_replacedBy) {

_replacedBy->closeBox();

}

_setRequest = 0;

const auto weak = base::make_weak(this);

_newAuthorization.fire_copy(result);

if (weak) {

_newPasswordSet.fire_copy(newPasswordBytes);

if (weak) {

getDelegate()->show(Ui::MakeInformBox(

tr::lng_cloud_password_updated()));

if (weak) {

closeBox();

}

}

}

if (_replacedBy) {

_replacedBy->closeBox();

}

_setRequest = 0;

const auto weak = base::make_weak(this);

_newPasswordSet.fire_copy(newPasswordBytes);

if (weak) {

auto text = _reenterPasscode->isHidden()

? tr::lng_cloud_password_removed()

: _oldPasscode->isHidden()

? tr::lng_cloud_password_was_set()

: tr::lng_cloud_password_updated();

getDelegate()->show(Ui::MakeInformBox(std::move(text)));

if (weak) {

closeBox();

}

}

if (isHidden()) {

if (_replacedBy && !_replacedBy->isHidden()) {

_replacedBy->closeBox();

}

}

if (MTP::IsFloodError(type)) {

closeReplacedBy();

_setRequest = 0;

_oldPasscode->selectAll();

_oldPasscode->setFocus();

_oldPasscode->showError();

_oldError = tr::lng_flood_error(tr::now);

if (_showRecoverLink && _hintText.isEmpty()) {

_recover->hide();

}

update();

return;

}

closeReplacedBy();

_setRequest = 0;

if (type == u"PASSWORD_HASH_INVALID"_q

|| type == u"SRP_PASSWORD_CHANGED"_q) {

if (_oldPasscode->isHidden()) {

_passwordReloadNeeded.fire({});

closeBox();

} else {

badOldPasscode();

}

} else if (type == u"SRP_ID_INVALID"_q) {

handleSrpIdInvalid();

//} else if (type == u"NEW_PASSWORD_BAD"_q) {

//} else if (type == u"NEW_SALT_INVALID"_q) {

} else if (type == u"EMAIL_INVALID"_q) {

_emailError = tr::lng_cloud_password_bad_email(tr::now);

_recoverEmail->setFocus();

_recoverEmail->showError();

update();

}

const QByteArray &newPasswordBytes,

const QString &email,

const MTP::Error &error) {

const auto prefix = u"EMAIL_UNCONFIRMED_"_q;

if (error.type().startsWith(prefix)) {

const auto codeLength = base::StringViewMid(error.type(), prefix.size()).toInt();

closeReplacedBy();

_setRequest = 0;

validateEmail(email, codeLength, newPasswordBytes);

} else {

setPasswordFail(error.type());

}

const QString &email,

int codeLength,

const QByteArray &newPasswordBytes) {

const auto errors = std::make_shared<rpl::event_stream<QString>>();

const auto resent = std::make_shared<rpl::event_stream<QString>>();

const auto set = std::make_shared<bool>(false);

const auto submit = crl::guard(this, [=](QString code) {

if (_setRequest) {

return;

}

_setRequest = _api.request(MTPaccount_ConfirmPasswordEmail(

MTP_string(code)

)).done([=] {

*set = true;

setPasswordDone(newPasswordBytes);

}).fail([=](const MTP::Error &error) {

_setRequest = 0;

if (MTP::IsFloodError(error)) {

errors->fire(tr::lng_flood_error(tr::now));

} else if (error.type() == u"CODE_INVALID"_q) {

errors->fire(tr::lng_signin_wrong_code(tr::now));

} else if (error.type() == u"EMAIL_HASH_EXPIRED"_q) {

const auto weak = base::make_weak(this);

_clearUnconfirmedPassword.fire({});

if (const auto strong = weak.get()) {

strong->getDelegate()->show(

Ui::MakeInformBox(

Lang::Hard::EmailConfirmationExpired()),

Ui::LayerOption::CloseOther);

}

} else {

errors->fire(Lang::Hard::ServerError());

}

}).handleFloodErrors().send();

});

const auto resend = crl::guard(this, [=] {

if (_setRequest) {

return;

}

_setRequest = _api.request(MTPaccount_ResendPasswordEmail(

)).done([=] {

_setRequest = 0;

resent->fire(tr::lng_cloud_password_resent(tr::now));

}).fail([=] {

_setRequest = 0;

errors->fire(Lang::Hard::ServerError());

}).send();

});

const auto box = _replacedBy = getDelegate()->show(

Passport::VerifyEmailBox(

email,

codeLength,

submit,

resend,

errors->events(),

resent->events()));

box->setCloseByOutsideClick(false);

box->setCloseByEscape(false);

box->boxClosing(

) | rpl::filter([=] {

return !*set;

}) | on_next([=, weak = base::make_weak(this)] {

if (weak) {

weak->_clearUnconfirmedPassword.fire({});

}

if (weak) {

weak->closeBox();

}

}, box->lifetime());

const auto now = crl::now();

if (_lastSrpIdInvalidTime > 0

&& now - _lastSrpIdInvalidTime < Core::kHandleSrpIdInvalidTimeout) {

_cloudFields.mtp.curRequest.id = 0;

_oldError = Lang::Hard::ServerError();

update();

} else {

_lastSrpIdInvalidTime = now;

requestPasswordData();

}

if (_setRequest) return;

QString old = _oldPasscode->text(), pwd = _newPasscode->text(), conf = _reenterPasscode->text();

const auto has = currentlyHave();

if (!_cloudPwd && (_turningOff || has)) {

if (!passcodeCanTry()) {

_oldError = tr::lng_flood_error(tr::now);

_oldPasscode->setFocus();

_oldPasscode->showError();

update();

return;

}

if (_session->domain().local().checkPasscode(old.toUtf8())) {

cSetPasscodeBadTries(0);

if (_turningOff) pwd = conf = QString();

} else {

cSetPasscodeBadTries(cPasscodeBadTries() + 1);

cSetPasscodeLastTry(crl::now());

badOldPasscode();

return;

}

}

const auto onlyCheck = onlyCheckCurrent();

if (!onlyCheck && pwd.isEmpty()) {

_newPasscode->setFocus();

_newPasscode->showError();

closeReplacedBy();

return;

}

if (!onlyCheck && pwd != conf) {

_reenterPasscode->selectAll();

_reenterPasscode->setFocus();

_reenterPasscode->showError();

if (!conf.isEmpty()) {

_newError = _cloudPwd

? tr::lng_cloud_password_differ(tr::now)

: tr::lng_passcode_differ(tr::now);

update();

}

closeReplacedBy();

} else if (!onlyCheck && has && old == pwd) {

_newPasscode->setFocus();

_newPasscode->showError();

_newError = _cloudPwd

? tr::lng_cloud_password_is_same(tr::now)

: tr::lng_passcode_is_same(tr::now);

update();

closeReplacedBy();

} else if (_cloudPwd) {

QString hint = _passwordHint->getLastText(), email = _recoverEmail->getLastText().trimmed();

if (!onlyCheck

&& !_passwordHint->isHidden()

&& !_newPasscode->isHidden()

&& pwd == hint) {

_newPasscode->setFocus();

_newPasscode->showError();

_newError = tr::lng_cloud_password_bad(tr::now);

update();

closeReplacedBy();

return;

}

if (!onlyCheck && !_recoverEmail->isHidden() && email.isEmpty() && !force) {

_skipEmailWarning = true;

_replacedBy = getDelegate()->show(Ui::MakeConfirmBox({

.text = { tr::lng_cloud_password_about_recover() },

.confirmed = crl::guard(this, [this] { save(true); }),

.confirmText = tr::lng_cloud_password_skip_email(),

.confirmStyle = &st::attentionBoxButton,

}));

} else if (onlyCheck) {

submitOnlyCheckCloudPassword(old);

} else if (_oldPasscode->isHidden()) {

setNewCloudPassword(pwd);

} else {

changeCloudPassword(old, pwd);

}

} else {

closeReplacedBy();

const auto weak = base::make_weak(this);

cSetPasscodeBadTries(0);

_session->domain().local().setPasscode(pwd.toUtf8());

Core::App().localPasscodeChanged();

if (weak) {

closeBox();

}

}

Expects(!_oldPasscode->isHidden());

const auto send = [=] {

sendOnlyCheckCloudPassword(oldPassword);

};

if (_cloudFields.turningOff && _cloudFields.notEmptyPassport) {

Assert(!_cloudFields.customCheckCallback);

getDelegate()->show(Ui::MakeConfirmBox({

.text = tr::lng_cloud_password_passport_losing(),

.confirmed = [=](Fn<void()> &&close) { send(); close(); },

.confirmText = tr::lng_continue(),

}));

} else {

send();

}

checkPassword(oldPassword, [=](const Core::CloudPasswordResult &check) {

if (const auto onstack = _cloudFields.customCheckCallback) {

onstack(check, base::make_weak(this));

} else {

Assert(_cloudFields.turningOff);

sendClearCloudPassword(check);

}

});

const QString &oldPassword,

CheckPasswordCallback callback) {

const auto passwordUtf = oldPassword.toUtf8();

_checkPasswordHash = Core::ComputeCloudPasswordHash(

_cloudFields.mtp.curRequest.algo,

bytes::make_span(passwordUtf));

checkPasswordHash(std::move(callback));

_checkPasswordCallback = std::move(callback);

if (_cloudFields.mtp.curRequest.id) {

passwordChecked();

} else {

requestPasswordData();

}

if (!_cloudFields.mtp.curRequest || !_cloudFields.mtp.curRequest.id || !_checkPasswordCallback) {

return serverError();

}

const auto check = Core::ComputeCloudPasswordCheck(

_cloudFields.mtp.curRequest,

_checkPasswordHash);

if (!check) {

return serverError();

}

_cloudFields.mtp.curRequest.id = 0;

_checkPasswordCallback(check);

if (!_checkPasswordCallback) {

return serverError();

}

_api.request(base::take(_setRequest)).cancel();

_setRequest = _api.request(

MTPaccount_GetPassword()

).done([=](const MTPaccount_Password &result) {

_setRequest = 0;

result.match([&](const MTPDaccount_password &data) {

_cloudFields.mtp.curRequest = Core::ParseCloudPasswordCheckRequest(data);

passwordChecked();

});

}).send();

if (MTP::IsFloodError(type)

|| type == u"PASSWORD_HASH_INVALID"_q

|| type == u"SRP_PASSWORD_CHANGED"_q

|| type == u"SRP_ID_INVALID"_q) {

setPasswordFail(type);

return true;

}

return false;

const Core::CloudPasswordResult &check) {

const auto hint = QString();

const auto email = QString();

const auto flags = MTPDaccount_passwordInputSettings::Flag::f_new_algo

| MTPDaccount_passwordInputSettings::Flag::f_new_password_hash

| MTPDaccount_passwordInputSettings::Flag::f_hint

| MTPDaccount_passwordInputSettings::Flag::f_email;

_setRequest = _api.request(MTPaccount_UpdatePasswordSettings(

check.result,

MTP_account_passwordInputSettings(

MTP_flags(flags),

Core::PrepareCloudPasswordAlgo(_cloudFields.mtp.newAlgo),

MTP_bytes(), // new_password_hash

MTP_string(hint),

MTP_string(email),

MTPSecureSecretSettings())

)).done([=] {

setPasswordDone({});

}).fail([=](const MTP::Error &error) mutable {

setPasswordFail({}, QString(), error);

}).handleFloodErrors().send();

const auto newPasswordBytes = newPassword.toUtf8();

const auto newPasswordHash = Core::ComputeCloudPasswordDigest(

_cloudFields.mtp.newAlgo,

bytes::make_span(newPasswordBytes));

if (newPasswordHash.modpow.empty()) {

return serverError();

}

const auto hint = _passwordHint->getLastText();

const auto email = _recoverEmail->getLastText().trimmed();

using Flag = MTPDaccount_passwordInputSettings::Flag;

const auto flags = Flag::f_new_algo

| Flag::f_new_password_hash

| Flag::f_hint

| (_cloudFields.fromRecoveryCode.isEmpty() ? Flag::f_email : Flag(0));

_checkPasswordCallback = nullptr;

const auto settings = MTP_account_passwordInputSettings(

MTP_flags(flags),

Core::PrepareCloudPasswordAlgo(_cloudFields.mtp.newAlgo),

MTP_bytes(newPasswordHash.modpow),

MTP_string(hint),

MTP_string(email),

MTPSecureSecretSettings());

if (_cloudFields.fromRecoveryCode.isEmpty()) {

_setRequest = _api.request(MTPaccount_UpdatePasswordSettings(

MTP_inputCheckPasswordEmpty(),

settings

)).done([=] {

setPasswordDone(newPasswordBytes);

}).fail([=](const MTP::Error &error) {

setPasswordFail(newPasswordBytes, email, error);

}).handleFloodErrors().send();

} else {

_setRequest = _api.request(MTPauth_RecoverPassword(

MTP_flags(MTPauth_RecoverPassword::Flag::f_new_settings),

MTP_string(_cloudFields.fromRecoveryCode),

settings

)).done([=](const MTPauth_Authorization &result) {

recoverPasswordDone(newPasswordBytes, result);

}).fail([=](const MTP::Error &error) {

if (MTP::IsFloodError(error)) {

_newError = tr::lng_flood_error(tr::now);

update();

}

setPasswordFail(newPasswordBytes, email, error);

}).handleFloodErrors().send();

}

const QString &oldPassword,

const QString &newPassword) {

checkPassword(oldPassword, [=](const Core::CloudPasswordResult &check) {

changeCloudPassword(oldPassword, check, newPassword);

});

const QString &oldPassword,

const Core::CloudPasswordResult &check,

const QString &newPassword) {

_setRequest = _api.request(MTPaccount_GetPasswordSettings(

check.result

)).done([=](const MTPaccount_PasswordSettings &result) {

_setRequest = 0;

Expects(result.type() == mtpc_account_passwordSettings);

const auto &data = result.c_account_passwordSettings();

const auto wrapped = data.vsecure_settings();

if (!wrapped) {

checkPasswordHash([=](const Core::CloudPasswordResult &check) {

const auto empty = QByteArray();

sendChangeCloudPassword(check, newPassword, empty);

});

return;

}

const auto &settings = wrapped->c_secureSecretSettings();

const auto passwordUtf = oldPassword.toUtf8();

const auto secret = Passport::DecryptSecureSecret(

bytes::make_span(settings.vsecure_secret().v),

Core::ComputeSecureSecretHash(

Core::ParseSecureSecretAlgo(settings.vsecure_algo()),

bytes::make_span(passwordUtf)));

if (secret.empty()) {

LOG(("API Error: Failed to decrypt secure secret."));

suggestSecretReset(newPassword);

} else if (Passport::CountSecureSecretId(secret)

!= settings.vsecure_secret_id().v) {

LOG(("API Error: Wrong secure secret id."));

suggestSecretReset(newPassword);

} else {

const auto secureSecret = QByteArray(

reinterpret_cast<const char*>(secret.data()),

secret.size());

checkPasswordHash([=](const Core::CloudPasswordResult &check) {

sendChangeCloudPassword(check, newPassword, secureSecret);

});

}

}).fail([=](const MTP::Error &error) {

setPasswordFail(error.type());

}).handleFloodErrors().send();

auto resetSecretAndSave = [=](Fn<void()> &&close) {

checkPasswordHash([=, close = std::move(close)](

const Core::CloudPasswordResult &check) {

resetSecret(check, newPassword, std::move(close));

});

};

getDelegate()->show(Ui::MakeConfirmBox({

.text = { Lang::Hard::PassportCorruptedChange() },

.confirmed = std::move(resetSecretAndSave),

.confirmText = Lang::Hard::PassportCorruptedReset(),

}));

const Core::CloudPasswordResult &check,

const QString &newPassword,

Fn<void()> callback) {

using Flag = MTPDaccount_passwordInputSettings::Flag;

_setRequest = _api.request(MTPaccount_UpdatePasswordSettings(

check.result,

MTP_account_passwordInputSettings(

MTP_flags(Flag::f_new_secure_settings),

MTPPasswordKdfAlgo(), // new_algo

MTPbytes(), // new_password_hash

MTPstring(), // hint

MTPstring(), // email

MTP_secureSecretSettings(

MTP_securePasswordKdfAlgoUnknown(), // secure_algo

MTP_bytes(), // secure_secret

MTP_long(0))) // secure_secret_id

)).done([=] {

_setRequest = 0;

callback();

checkPasswordHash([=](const Core::CloudPasswordResult &check) {

const auto empty = QByteArray();

sendChangeCloudPassword(check, newPassword, empty);

});

}).fail([=](const MTP::Error &error) {

_setRequest = 0;

if (error.type() == u"SRP_ID_INVALID"_q) {

handleSrpIdInvalid();

}

}).send();

const Core::CloudPasswordResult &check,

const QString &newPassword,