NekoX/TMessagesProj/src/main/java/org/telegram/ui/PassportActivity.java

package org.telegram.ui;

import android.Manifest;
import android.animation.Animator;
import android.animation.AnimatorListenerAdapter;
import android.animation.AnimatorSet;
import android.animation.ObjectAnimator;
import android.annotation.SuppressLint;
import android.app.Activity;
import android.app.Dialog;
import android.content.Context;
import android.content.DialogInterface;
import android.content.Intent;
import android.content.SharedPreferences;
import android.content.pm.PackageInfo;
import android.content.pm.PackageManager;
import android.graphics.Bitmap;
import android.graphics.Canvas;
import android.graphics.Paint;
import android.graphics.PorterDuff;
import android.graphics.PorterDuffColorFilter;
import android.graphics.Rect;
import android.graphics.Typeface;
import android.graphics.drawable.Drawable;
import android.net.Uri;
import android.os.Build;
import android.os.Bundle;
import android.os.Vibrator;
import android.provider.MediaStore;
import androidx.core.content.FileProvider;

import android.telephony.PhoneNumberUtils;
import android.telephony.TelephonyManager;
import android.text.Editable;
import android.text.InputFilter;
import android.text.InputType;
import android.text.Spannable;
import android.text.SpannableStringBuilder;
import android.text.Spanned;
import android.text.StaticLayout;
import android.text.TextPaint;
import android.text.TextUtils;
import android.text.TextWatcher;
import android.text.method.PasswordTransformationMethod;
import android.text.style.ClickableSpan;
import android.text.style.ForegroundColorSpan;
import android.util.Base64;
import android.util.TypedValue;
import android.view.ActionMode;
import android.view.Gravity;
import android.view.KeyEvent;
import android.view.Menu;
import android.view.MenuItem;
import android.view.MotionEvent;
import android.view.View;
import android.view.ViewGroup;
import android.view.animation.AccelerateDecelerateInterpolator;
import android.view.inputmethod.EditorInfo;
import android.widget.FrameLayout;
import android.widget.ImageView;
import android.widget.LinearLayout;
import android.widget.ScrollView;
import android.widget.TextView;
import android.widget.Toast;

import org.json.JSONArray;
import org.json.JSONObject;
import org.telegram.PhoneFormat.PhoneFormat;
import org.telegram.messenger.AndroidUtilities;
import org.telegram.messenger.ApplicationLoader;
import org.telegram.messenger.BuildConfig;
import org.telegram.messenger.BuildVars;
import org.telegram.messenger.DownloadController;
import org.telegram.messenger.FileLoader;
import org.telegram.messenger.FileLog;
import org.telegram.messenger.ImageLoader;
import org.telegram.messenger.ImageLocation;
import org.telegram.messenger.LocaleController;
import org.telegram.messenger.MediaController;
import org.telegram.messenger.MessageObject;
import org.telegram.messenger.MrzRecognizer;
import org.telegram.messenger.NotificationCenter;
import org.telegram.messenger.R;
import org.telegram.messenger.SRPHelper;
import org.telegram.messenger.SecureDocument;
import org.telegram.messenger.SecureDocumentKey;
import org.telegram.messenger.SendMessagesHelper;
import org.telegram.messenger.SharedConfig;
import org.telegram.messenger.UserConfig;
import org.telegram.messenger.UserObject;
import org.telegram.messenger.Utilities;
import org.telegram.messenger.browser.Browser;
import org.telegram.tgnet.ConnectionsManager;
import org.telegram.tgnet.RequestDelegate;
import org.telegram.tgnet.TLObject;
import org.telegram.tgnet.TLRPC;
import org.telegram.ui.ActionBar.ActionBar;
import org.telegram.ui.ActionBar.ActionBarMenu;
import org.telegram.ui.ActionBar.ActionBarMenuItem;
import org.telegram.ui.ActionBar.AlertDialog;
import org.telegram.ui.ActionBar.BaseFragment;
import org.telegram.ui.ActionBar.Theme;
import org.telegram.ui.ActionBar.ThemeDescription;
import org.telegram.ui.Cells.CheckBoxCell;
import org.telegram.ui.Cells.HeaderCell;
import org.telegram.ui.Cells.ShadowSectionCell;
import org.telegram.ui.Cells.TextDetailSettingsCell;
import org.telegram.ui.Cells.TextInfoPrivacyCell;
import org.telegram.ui.Cells.TextSettingsCell;
import org.telegram.ui.Components.AlertsCreator;
import org.telegram.ui.Components.AvatarDrawable;
import org.telegram.ui.Components.ChatAttachAlert;
import org.telegram.ui.Components.BackupImageView;
import org.telegram.ui.Components.ContextProgressView;
import org.telegram.ui.Components.EditTextBoldCursor;
import org.telegram.ui.Components.EmptyTextProgressView;
import org.telegram.ui.Components.HintEditText;
import org.telegram.ui.Components.LayoutHelper;
import org.telegram.ui.Components.RadialProgress;
import org.telegram.ui.Components.SlideView;
import org.telegram.ui.Components.URLSpanNoUnderline;

import java.io.BufferedReader;
import java.io.File;
import java.io.InputStreamReader;
import java.io.RandomAccessFile;
import java.security.KeyFactory;
import java.security.interfaces.RSAPublicKey;
import java.security.spec.X509EncodedKeySpec;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Calendar;
import java.util.Collections;
import java.util.Comparator;
import java.util.HashMap;
import java.util.Iterator;
import java.util.Locale;
import java.util.Timer;
import java.util.TimerTask;

import javax.crypto.Cipher;

public class PassportActivity extends BaseFragment implements NotificationCenter.NotificationCenterDelegate {

    public final static int TYPE_REQUEST = 0;
    public final static int TYPE_IDENTITY = 1;
    public final static int TYPE_ADDRESS = 2;
    public final static int TYPE_PHONE = 3;
    public final static int TYPE_EMAIL = 4;
    public final static int TYPE_PASSWORD = 5;
    public final static int TYPE_EMAIL_VERIFICATION = 6;
    public final static int TYPE_PHONE_VERIFICATION = 7;
    public final static int TYPE_MANAGE = 8;

    private final static int FIELD_NAME = 0;
    private final static int FIELD_MIDNAME = 1;
    private final static int FIELD_SURNAME = 2;
    private final static int FIELD_BIRTHDAY = 3;
    private final static int FIELD_GENDER = 4;
    private final static int FIELD_CITIZENSHIP = 5;
    private final static int FIELD_RESIDENCE = 6;
    private final static int FIELD_CARDNUMBER = 7;
    private final static int FIELD_EXPIRE = 8;
    private final static int FIELD_IDENTITY_COUNT = 9;
    private final static int FIELD_IDENTITY_NODOC_COUNT = 7;

    private final static int FIELD_NATIVE_NAME = 0;
    private final static int FIELD_NATIVE_MIDNAME = 1;
    private final static int FIELD_NATIVE_SURNAME = 2;
    private final static int FIELD_NATIVE_COUNT = 3;

    private final static int FIELD_STREET1 = 0;
    private final static int FIELD_STREET2 = 1;
    private final static int FIELD_POSTCODE = 2;
    private final static int FIELD_CITY = 3;
    private final static int FIELD_STATE = 4;
    private final static int FIELD_COUNTRY = 5;
    private final static int FIELD_ADDRESS_COUNT = 6;

    private final static int FIELD_PHONECOUNTRY = 0;
    private final static int FIELD_PHONECODE = 1;
    private final static int FIELD_PHONE = 2;

    private final static int FIELD_EMAIL = 0;

    private final static int FIELD_PASSWORD = 0;

    private final static int UPLOADING_TYPE_DOCUMENTS = 0;
    private final static int UPLOADING_TYPE_SELFIE = 1;
    private final static int UPLOADING_TYPE_FRONT = 2;
    private final static int UPLOADING_TYPE_REVERSE = 3;
    private final static int UPLOADING_TYPE_TRANSLATION = 4;

    private String initialValues;
    private int currentActivityType;
    private int currentBotId;
    private String currentPayload;
    private String currentNonce;
    private boolean useCurrentValue;
    private String currentScope;
    private String currentCallbackUrl;
    private String currentPublicKey;
    private String currentCitizeship = "";
    private String currentResidence = "";
    private String currentGender;
    private int[] currentExpireDate = new int[3];
    private TLRPC.TL_account_authorizationForm currentForm;

    private TLRPC.TL_secureRequiredType currentType;
    private TLRPC.TL_secureRequiredType currentDocumentsType;
    private ArrayList<TLRPC.TL_secureRequiredType> availableDocumentTypes;
    private TLRPC.TL_secureValue currentTypeValue;
    private TLRPC.TL_secureValue currentDocumentsTypeValue;
    private TLRPC.TL_account_password currentPassword;
    private TLRPC.TL_auth_sentCode currentPhoneVerification;

    private ActionBarMenuItem doneItem;
    private AnimatorSet doneItemAnimation;
    private ContextProgressView progressView;

    private TextView acceptTextView;
    private ContextProgressView progressViewButton;
    private FrameLayout bottomLayout;

    private TextSettingsCell uploadDocumentCell;
    private View extraBackgroundView;
    private View extraBackgroundView2;
    private TextDetailSettingsCell uploadFrontCell;
    private TextDetailSettingsCell uploadReverseCell;
    private TextDetailSettingsCell uploadSelfieCell;
    private TextSettingsCell uploadTranslationCell;
    private EditTextBoldCursor[] inputFields;
    private ViewGroup[] inputFieldContainers;
    private EditTextBoldCursor[] inputExtraFields;
    private ScrollView scrollView;
    private LinearLayout linearLayout2;
    private LinearLayout documentsLayout;
    private LinearLayout frontLayout;
    private LinearLayout reverseLayout;
    private LinearLayout selfieLayout;
    private LinearLayout translationLayout;
    private LinearLayout currentPhotoViewerLayout;
    private HeaderCell headerCell;
    private ArrayList<View> dividers = new ArrayList<>();
    private ShadowSectionCell sectionCell;
    private ShadowSectionCell sectionCell2;
    private TextInfoPrivacyCell bottomCell;
    private TextInfoPrivacyCell bottomCellTranslation;
    private TextInfoPrivacyCell topErrorCell;
    private TextInfoPrivacyCell nativeInfoCell;
    private TextSettingsCell scanDocumentCell;

    private int scrollHeight;

    private boolean[] nonLatinNames = new boolean[3];
    private boolean allowNonLatinName = true;

    private boolean documentOnly;

    private TextView plusTextView;

    private TextSettingsCell addDocumentCell;
    private TextSettingsCell deletePassportCell;
    private ShadowSectionCell addDocumentSectionCell;
    private LinearLayout emptyLayout;
    private ImageView emptyImageView;
    private TextView emptyTextView1;
    private TextView emptyTextView2;
    private TextView emptyTextView3;

    private EmptyTextProgressView emptyView;
    private TextInfoPrivacyCell passwordRequestTextView;
    private TextInfoPrivacyCell passwordInfoRequestTextView;
    private ImageView noPasswordImageView;
    private TextView noPasswordTextView;
    private TextView noPasswordSetTextView;
    private FrameLayout passwordAvatarContainer;
    private TextView passwordForgotButton;
    private int usingSavedPassword;
    private byte[] savedPasswordHash;
    private byte[] savedSaltedPassword;

    private String currentPicturePath;
    private ChatAttachAlert chatAttachAlert;
    private int uploadingFileType;

    private int emailCodeLength;

    private ArrayList<String> countriesArray = new ArrayList<>();
    private HashMap<String, String> countriesMap = new HashMap<>();
    private HashMap<String, String> codesMap = new HashMap<>();
    private HashMap<String, String> phoneFormatMap = new HashMap<>();
    private HashMap<String, String> languageMap;

    private boolean ignoreOnTextChange;
    private boolean ignoreOnPhoneChange;

    private static final int info_item = 1;
    private static final int done_button = 2;

    private final static int attach_photo = 0;
    private final static int attach_document = 4;

    private long secureSecretId;
    private byte[] secureSecret;
    private String currentEmail;
    private byte[] saltedPassword;

    private boolean ignoreOnFailure;
    private boolean callbackCalled;
    private PassportActivity presentAfterAnimation;

    private ArrayList<SecureDocument> documents = new ArrayList<>();
    private SecureDocument selfieDocument;
    private ArrayList<SecureDocument> translationDocuments = new ArrayList<>();
    private SecureDocument frontDocument;
    private SecureDocument reverseDocument;
    private HashMap<SecureDocument, SecureDocumentCell> documentsCells = new HashMap<>();
    private HashMap<String, SecureDocument> uploadingDocuments = new HashMap<>();
    private HashMap<TLRPC.TL_secureRequiredType, HashMap<String, String>> typesValues = new HashMap<>();
    private HashMap<TLRPC.TL_secureRequiredType, TextDetailSecureCell> typesViews = new HashMap<>();
    private HashMap<TLRPC.TL_secureRequiredType, TLRPC.TL_secureRequiredType> documentsToTypesLink = new HashMap<>();
    private HashMap<String, String> currentValues;
    private HashMap<String, String> currentDocumentValues;
    private HashMap<String, HashMap<String, String>> errorsMap = new HashMap<>();
    private HashMap<String, String> mainErrorsMap = new HashMap<>();
    private HashMap<String, String> fieldsErrors;
    private HashMap<String, String> documentsErrors;
    private HashMap<String, String> errorsValues = new HashMap<>();
    private CharSequence noAllDocumentsErrorText;
    private CharSequence noAllTranslationErrorText;

    private PassportActivityDelegate delegate;

    private boolean needActivityResult;

    private interface PassportActivityDelegate {
        void saveValue(TLRPC.TL_secureRequiredType type, String text, String json, TLRPC.TL_secureRequiredType documentType, String documentsJson, ArrayList<SecureDocument> documents, SecureDocument selfie, ArrayList<SecureDocument> translationDocuments, SecureDocument front, SecureDocument reverse, Runnable finishRunnable, ErrorRunnable errorRunnable);
        void deleteValue(TLRPC.TL_secureRequiredType type, TLRPC.TL_secureRequiredType documentType, ArrayList<TLRPC.TL_secureRequiredType> documentRequiredTypes, boolean deleteType, Runnable finishRunnable, ErrorRunnable errorRunnable);
        SecureDocument saveFile(TLRPC.TL_secureFile secureFile);
    }

    private interface ErrorRunnable {
        void onError(String error, String text);
    }

    private PhotoViewer.PhotoViewerProvider provider = new PhotoViewer.EmptyPhotoViewerProvider() {

        @Override
        public PhotoViewer.PlaceProviderObject getPlaceForPhoto(MessageObject messageObject, TLRPC.FileLocation fileLocation, int index, boolean needPreview) {
            if (index < 0 || index >= currentPhotoViewerLayout.getChildCount()) {
                return null;
            }
            SecureDocumentCell cell = (SecureDocumentCell) currentPhotoViewerLayout.getChildAt(index);
            int[] coords = new int[2];
            cell.imageView.getLocationInWindow(coords);
            PhotoViewer.PlaceProviderObject object = new PhotoViewer.PlaceProviderObject();
            object.viewX = coords[0];
            object.viewY = coords[1] - (Build.VERSION.SDK_INT >= 21 ? 0 : AndroidUtilities.statusBarHeight);
            object.parentView = currentPhotoViewerLayout;
            object.imageReceiver = cell.imageView.getImageReceiver();
            object.thumb = object.imageReceiver.getBitmapSafe();
            return object;
        }

        @Override
        public void deleteImageAtIndex(int index) {
            SecureDocument document;
            if (uploadingFileType == UPLOADING_TYPE_SELFIE) {
                document = selfieDocument;
            } else if (uploadingFileType == UPLOADING_TYPE_TRANSLATION) {
                document = translationDocuments.get(index);
            } else if (uploadingFileType == UPLOADING_TYPE_FRONT) {
                document = frontDocument;
            } else if (uploadingFileType == UPLOADING_TYPE_REVERSE) {
                document = reverseDocument;
            } else {
                document = documents.get(index);
            }
            SecureDocumentCell cell = documentsCells.remove(document);
            if (cell == null) {
                return;
            }
            String key = null;
            String hash = getDocumentHash(document);
            if (uploadingFileType == UPLOADING_TYPE_SELFIE) {
                selfieDocument = null;
                key = "selfie" + hash;
            } else if (uploadingFileType == UPLOADING_TYPE_TRANSLATION) {
                key = "translation" + hash;
            } else if (uploadingFileType == UPLOADING_TYPE_FRONT) {
                frontDocument = null;
                key = "front" + hash;
            } else if (uploadingFileType == UPLOADING_TYPE_REVERSE) {
                reverseDocument = null;
                key = "reverse" + hash;
            } else if (uploadingFileType == UPLOADING_TYPE_DOCUMENTS) {
                key = "files" + hash;
            }

            if (key != null) {
                if (documentsErrors != null) {
                    documentsErrors.remove(key);
                }
                if (errorsValues != null) {
                    errorsValues.remove(key);
                }
            }

            updateUploadText(uploadingFileType);
            currentPhotoViewerLayout.removeView(cell);
        }

        @Override
        public String getDeleteMessageString() {
            if (uploadingFileType == UPLOADING_TYPE_SELFIE) {
                return LocaleController.formatString("PassportDeleteSelfieAlert", R.string.PassportDeleteSelfieAlert);
            } else {
                return LocaleController.formatString("PassportDeleteScanAlert", R.string.PassportDeleteScanAlert);
            }
        }
    };

    public class LinkSpan extends ClickableSpan {
        @Override
        public void updateDrawState(TextPaint ds) {
            super.updateDrawState(ds);
            ds.setUnderlineText(true);
            ds.setTypeface(AndroidUtilities.getTypeface("fonts/rmedium.ttf"));
        }

        @Override
        public void onClick(View widget) {
            Browser.openUrl(getParentActivity(), currentForm.privacy_policy_url);
        }
    }

    public class TextDetailSecureCell extends FrameLayout {

        private TextView textView;
        private TextView valueTextView;
        private ImageView checkImageView;
        private boolean needDivider;

        public TextDetailSecureCell(Context context) {
            super(context);

            int padding = currentActivityType == TYPE_MANAGE ? 21 : 51;

            textView = new TextView(context);
            textView.setTextColor(Theme.getColor(Theme.key_windowBackgroundWhiteBlackText));
            textView.setTextSize(TypedValue.COMPLEX_UNIT_DIP, 16);
            textView.setLines(1);
            textView.setMaxLines(1);
            textView.setSingleLine(true);
            textView.setEllipsize(TextUtils.TruncateAt.END);
            textView.setGravity((LocaleController.isRTL ? Gravity.RIGHT : Gravity.LEFT) | Gravity.CENTER_VERTICAL);
            addView(textView, LayoutHelper.createFrame(LayoutHelper.WRAP_CONTENT, LayoutHelper.WRAP_CONTENT, (LocaleController.isRTL ? Gravity.RIGHT : Gravity.LEFT) | Gravity.TOP, (LocaleController.isRTL ? padding : 21), 10, (LocaleController.isRTL ? 21 : padding), 0));

            valueTextView = new TextView(context);
            valueTextView.setTextColor(Theme.getColor(Theme.key_windowBackgroundWhiteGrayText2));
            valueTextView.setTextSize(TypedValue.COMPLEX_UNIT_DIP, 13);
            valueTextView.setGravity(LocaleController.isRTL ? Gravity.RIGHT : Gravity.LEFT);
            valueTextView.setLines(1);
            valueTextView.setMaxLines(1);
            valueTextView.setSingleLine(true);
            valueTextView.setEllipsize(TextUtils.TruncateAt.END);
            valueTextView.setPadding(0, 0, 0, 0);
            addView(valueTextView, LayoutHelper.createFrame(LayoutHelper.WRAP_CONTENT, LayoutHelper.WRAP_CONTENT, (LocaleController.isRTL ? Gravity.RIGHT : Gravity.LEFT) | Gravity.TOP, (LocaleController.isRTL ? padding : 21), 35, (LocaleController.isRTL ? 21 : padding), 0));

            checkImageView = new ImageView(context);
            checkImageView.setColorFilter(new PorterDuffColorFilter(Theme.getColor(Theme.key_featuredStickers_addedIcon), PorterDuff.Mode.MULTIPLY));
            checkImageView.setImageResource(R.drawable.sticker_added);
            addView(checkImageView, LayoutHelper.createFrame(LayoutHelper.WRAP_CONTENT, LayoutHelper.WRAP_CONTENT, (LocaleController.isRTL ? Gravity.LEFT : Gravity.RIGHT) | Gravity.TOP, 21, 25, 21, 0));
        }

        @Override
        protected void onMeasure(int widthMeasureSpec, int heightMeasureSpec) {
            super.onMeasure(MeasureSpec.makeMeasureSpec(MeasureSpec.getSize(widthMeasureSpec), MeasureSpec.EXACTLY), MeasureSpec.makeMeasureSpec(AndroidUtilities.dp(64) + (needDivider ? 1 : 0), MeasureSpec.EXACTLY));
        }

        public void setTextAndValue(String text, CharSequence value, boolean divider) {
            textView.setText(text);
            valueTextView.setText(value);
            needDivider = divider;
            setWillNotDraw(!divider);
        }

        public void setChecked(boolean checked) {
            checkImageView.setVisibility(checked ? VISIBLE : INVISIBLE);
        }

        public void setValue(CharSequence value) {
            valueTextView.setText(value);
        }

        public void setNeedDivider(boolean value) {
            needDivider = value;
            setWillNotDraw(!needDivider);
            invalidate();
        }

        @Override
        protected void onDraw(Canvas canvas) {
            if (needDivider) {
                canvas.drawLine(LocaleController.isRTL ? 0 : AndroidUtilities.dp(20), getMeasuredHeight() - 1, getMeasuredWidth() - (LocaleController.isRTL ? AndroidUtilities.dp(20) : 0), getMeasuredHeight() - 1, Theme.dividerPaint);
            }
        }
    }

    public class SecureDocumentCell extends FrameLayout implements DownloadController.FileDownloadProgressListener {

        private TextView textView;
        private TextView valueTextView;
        private BackupImageView imageView;
        private RadialProgress radialProgress;

        private int buttonState;
        private SecureDocument currentSecureDocument;

        private int TAG;

        public SecureDocumentCell(Context context) {
            super(context);

            TAG = DownloadController.getInstance(currentAccount).generateObserverTag();
            radialProgress = new RadialProgress(this);

            imageView = new BackupImageView(context);
            addView(imageView, LayoutHelper.createFrame(48, 48, (LocaleController.isRTL ? Gravity.RIGHT : Gravity.LEFT) | Gravity.TOP, 21, 8, 21, 0));

            textView = new TextView(context);
            textView.setTextColor(Theme.getColor(Theme.key_windowBackgroundWhiteBlackText));
            textView.setTextSize(TypedValue.COMPLEX_UNIT_DIP, 16);
            textView.setLines(1);
            textView.setMaxLines(1);
            textView.setSingleLine(true);
            textView.setEllipsize(TextUtils.TruncateAt.END);
            textView.setGravity((LocaleController.isRTL ? Gravity.RIGHT : Gravity.LEFT) | Gravity.CENTER_VERTICAL);
            addView(textView, LayoutHelper.createFrame(LayoutHelper.WRAP_CONTENT, LayoutHelper.WRAP_CONTENT, (LocaleController.isRTL ? Gravity.RIGHT : Gravity.LEFT) | Gravity.TOP, (LocaleController.isRTL ? 21 : 81), 10, (LocaleController.isRTL ? 81 : 21), 0));

            valueTextView = new TextView(context);
            valueTextView.setTextColor(Theme.getColor(Theme.key_windowBackgroundWhiteGrayText2));
            valueTextView.setTextSize(TypedValue.COMPLEX_UNIT_DIP, 13);
            valueTextView.setGravity(LocaleController.isRTL ? Gravity.RIGHT : Gravity.LEFT);
            valueTextView.setLines(1);
            valueTextView.setMaxLines(1);
            valueTextView.setSingleLine(true);
            valueTextView.setPadding(0, 0, 0, 0);
            addView(valueTextView, LayoutHelper.createFrame(LayoutHelper.WRAP_CONTENT, LayoutHelper.WRAP_CONTENT, (LocaleController.isRTL ? Gravity.RIGHT : Gravity.LEFT) | Gravity.TOP, (LocaleController.isRTL ? 21 : 81), 35, (LocaleController.isRTL ? 81 : 21), 0));

            setWillNotDraw(false);
        }

        @Override
        protected void onMeasure(int widthMeasureSpec, int heightMeasureSpec) {
            super.onMeasure(MeasureSpec.makeMeasureSpec(MeasureSpec.getSize(widthMeasureSpec), MeasureSpec.EXACTLY), MeasureSpec.makeMeasureSpec(AndroidUtilities.dp(64) + 1, MeasureSpec.EXACTLY));
        }

        @Override
        protected void onLayout(boolean changed, int left, int top, int right, int bottom) {
            super.onLayout(changed, left, top, right, bottom);
            int x = imageView.getLeft() + (imageView.getMeasuredWidth() - AndroidUtilities.dp(24)) / 2;
            int y = imageView.getTop() + (imageView.getMeasuredHeight() - AndroidUtilities.dp(24)) / 2;
            radialProgress.setProgressRect(x, y, x + AndroidUtilities.dp(24), y + AndroidUtilities.dp(24));
        }

        @Override
        protected boolean drawChild(Canvas canvas, View child, long drawingTime) {
            boolean result = super.drawChild(canvas, child, drawingTime);
            if (child == imageView) {
                radialProgress.draw(canvas);
            }
            return result;
        }

        public void setTextAndValueAndImage(String text, CharSequence value, SecureDocument document) {
            textView.setText(text);
            valueTextView.setText(value);
            imageView.setImage(document, "48_48");
            currentSecureDocument = document;

            updateButtonState(false);
        }

        public void setValue(CharSequence value) {
            valueTextView.setText(value);
        }

        public void updateButtonState(boolean animated) {
            String fileName = FileLoader.getAttachFileName(currentSecureDocument);
            File path = FileLoader.getPathToAttach(currentSecureDocument);
            boolean fileExists = path.exists();
            if (TextUtils.isEmpty(fileName)) {
                radialProgress.setBackground(null, false, false);
                return;
            }

            if (currentSecureDocument.path != null) {
                if (currentSecureDocument.inputFile != null) {
                    DownloadController.getInstance(currentAccount).removeLoadingFileObserver(this);
                    radialProgress.setBackground(null, false, animated);
                    buttonState = -1;
                } else {
                    DownloadController.getInstance(currentAccount).addLoadingFileObserver(currentSecureDocument.path, this);
                    buttonState = 1;
                    Float progress = ImageLoader.getInstance().getFileProgress(currentSecureDocument.path);
                    radialProgress.setBackground(Theme.chat_photoStatesDrawables[5][0], true, animated);
                    radialProgress.setProgress(progress != null ? progress : 0, false);
                    invalidate();
                }
            } else {
                if (fileExists) {
                    DownloadController.getInstance(currentAccount).removeLoadingFileObserver(this);
                    buttonState = -1;
                    radialProgress.setBackground(null, false, animated);
                    invalidate();
                } else {
                    DownloadController.getInstance(currentAccount).addLoadingFileObserver(fileName, this);
                    buttonState = 1;
                    Float progress = ImageLoader.getInstance().getFileProgress(fileName);
                    radialProgress.setBackground(Theme.chat_photoStatesDrawables[5][0], true, animated);
                    radialProgress.setProgress(progress != null ? progress : 0, animated);
                    invalidate();
                }
            }
        }

        @Override
        public void invalidate() {
            super.invalidate();
            textView.invalidate();
        }

        @Override
        protected void onDraw(Canvas canvas) {
            canvas.drawLine(LocaleController.isRTL ? 0 : AndroidUtilities.dp(20), getMeasuredHeight() - 1, getMeasuredWidth() - (LocaleController.isRTL ? AndroidUtilities.dp(20) : 0), getMeasuredHeight() - 1, Theme.dividerPaint);
        }

        @Override
        public void onFailedDownload(String fileName, boolean canceled) {
            updateButtonState(false);
        }

        @Override
        public void onSuccessDownload(String fileName) {
            radialProgress.setProgress(1, true);
            updateButtonState(true);
        }

        @Override
        public void onProgressDownload(String fileName, long downloadedSize, long totalSize) {
            radialProgress.setProgress(Math.min(1f, downloadedSize / (float) totalSize), true);
            if (buttonState != 1) {
                updateButtonState(false);
            }
        }

        @Override
        public void onProgressUpload(String fileName, long uploadedSize, long totalSize, boolean isEncrypted) {
            radialProgress.setProgress(Math.min(1f, uploadedSize / (float) totalSize), true);
        }

        @Override
        public int getObserverTag() {
            return TAG;
        }
    }

    public PassportActivity(int type, int botId, String scope, String publicKey, String payload, String nonce, String callbackUrl, TLRPC.TL_account_authorizationForm form, TLRPC.TL_account_password accountPassword) {
        this(type, form, accountPassword, null, null, null, null, null, null);
        currentBotId = botId;
        currentPayload = payload;
        currentNonce = nonce;
        currentScope = scope;
        currentPublicKey = publicKey;
        currentCallbackUrl = callbackUrl;
        if (type == TYPE_REQUEST) {
            if (!form.errors.isEmpty()) {
                try {
                    Collections.sort(form.errors, new Comparator<TLRPC.SecureValueError>() {

                        int getErrorValue(TLRPC.SecureValueError error) {
                            if (error instanceof TLRPC.TL_secureValueError) {
                                return 0;
                            } else if (error instanceof TLRPC.TL_secureValueErrorFrontSide) {
                                return 1;
                            } else if (error instanceof TLRPC.TL_secureValueErrorReverseSide) {
                                return 2;
                            } else if (error instanceof TLRPC.TL_secureValueErrorSelfie) {
                                return 3;
                            } else if (error instanceof TLRPC.TL_secureValueErrorTranslationFile) {
                                return 4;
                            } else if (error instanceof TLRPC.TL_secureValueErrorTranslationFiles) {
                                return 5;
                            } else if (error instanceof TLRPC.TL_secureValueErrorFile) {
                                return 6;
                            } else if (error instanceof TLRPC.TL_secureValueErrorFiles) {
                                return 7;
                            } else if (error instanceof TLRPC.TL_secureValueErrorData) {
                                TLRPC.TL_secureValueErrorData errorData = (TLRPC.TL_secureValueErrorData) error;
                                return getFieldCost(errorData.field);
                            }
                            return 100;
                        }

                        @Override
                        public int compare(TLRPC.SecureValueError e1, TLRPC.SecureValueError e2) {
                            int val1 = getErrorValue(e1);
                            int val2 = getErrorValue(e2);
                            if (val1 < val2) {
                                return -1;
                            } else if (val1 > val2) {
                                return 1;
                            }
                            return 0;
                        }
                    });
                    for (int a = 0, size = form.errors.size(); a < size; a++) {
                        TLRPC.SecureValueError secureValueError = form.errors.get(a);
                        String key;
                        String description;
                        String target;

                        String field = null;
                        byte[] file_hash = null;

                        if (secureValueError instanceof TLRPC.TL_secureValueErrorFrontSide) {
                            TLRPC.TL_secureValueErrorFrontSide secureValueErrorFrontSide = (TLRPC.TL_secureValueErrorFrontSide) secureValueError;
                            key = getNameForType(secureValueErrorFrontSide.type);
                            description = secureValueErrorFrontSide.text;
                            file_hash = secureValueErrorFrontSide.file_hash;
                            target = "front";
                        } else if (secureValueError instanceof TLRPC.TL_secureValueErrorReverseSide) {
                            TLRPC.TL_secureValueErrorReverseSide secureValueErrorReverseSide = (TLRPC.TL_secureValueErrorReverseSide) secureValueError;
                            key = getNameForType(secureValueErrorReverseSide.type);
                            description = secureValueErrorReverseSide.text;
                            file_hash = secureValueErrorReverseSide.file_hash;
                            target = "reverse";
                        } else if (secureValueError instanceof TLRPC.TL_secureValueErrorSelfie) {
                            TLRPC.TL_secureValueErrorSelfie secureValueErrorSelfie = (TLRPC.TL_secureValueErrorSelfie) secureValueError;
                            key = getNameForType(secureValueErrorSelfie.type);
                            description = secureValueErrorSelfie.text;
                            file_hash = secureValueErrorSelfie.file_hash;
                            target = "selfie";
                        } else if (secureValueError instanceof TLRPC.TL_secureValueErrorTranslationFile) {
                            TLRPC.TL_secureValueErrorTranslationFile secureValueErrorTranslationFile = (TLRPC.TL_secureValueErrorTranslationFile) secureValueError;
                            key = getNameForType(secureValueErrorTranslationFile.type);
                            description = secureValueErrorTranslationFile.text;
                            file_hash = secureValueErrorTranslationFile.file_hash;
                            target = "translation";
                        } else if (secureValueError instanceof TLRPC.TL_secureValueErrorTranslationFiles) {
                            TLRPC.TL_secureValueErrorTranslationFiles secureValueErrorTranslationFiles = (TLRPC.TL_secureValueErrorTranslationFiles) secureValueError;
                            key = getNameForType(secureValueErrorTranslationFiles.type);
                            description = secureValueErrorTranslationFiles.text;
                            target = "translation";
                        } else if (secureValueError instanceof TLRPC.TL_secureValueErrorFile) {
                            TLRPC.TL_secureValueErrorFile secureValueErrorFile = (TLRPC.TL_secureValueErrorFile) secureValueError;
                            key = getNameForType(secureValueErrorFile.type);
                            description = secureValueErrorFile.text;
                            file_hash = secureValueErrorFile.file_hash;
                            target = "files";
                        } else if (secureValueError instanceof TLRPC.TL_secureValueErrorFiles) {
                            TLRPC.TL_secureValueErrorFiles secureValueErrorFiles = (TLRPC.TL_secureValueErrorFiles) secureValueError;
                            key = getNameForType(secureValueErrorFiles.type);
                            description = secureValueErrorFiles.text;
                            target = "files";
                        } else if (secureValueError instanceof TLRPC.TL_secureValueError) {
                            TLRPC.TL_secureValueError secureValueErrorAll = (TLRPC.TL_secureValueError) secureValueError;
                            key = getNameForType(secureValueErrorAll.type);
                            description = secureValueErrorAll.text;
                            file_hash = secureValueErrorAll.hash;
                            target = "error_all";
                        } else if (secureValueError instanceof TLRPC.TL_secureValueErrorData) {
                            TLRPC.TL_secureValueErrorData secureValueErrorData = (TLRPC.TL_secureValueErrorData) secureValueError;
                            boolean found = false;
                            for (int b = 0; b < form.values.size(); b++) {
                                TLRPC.TL_secureValue value = form.values.get(b);
                                if (value.data != null && Arrays.equals(value.data.data_hash, secureValueErrorData.data_hash)) {
                                    found = true;
                                    break;
                                }
                            }
                            if (!found) {
                                continue;
                            }
                            key = getNameForType(secureValueErrorData.type);
                            description = secureValueErrorData.text;
                            field = secureValueErrorData.field;
                            file_hash = secureValueErrorData.data_hash;
                            target = "data";
                        } else {
                            continue;
                        }
                        HashMap<String, String> vals = errorsMap.get(key);
                        if (vals == null) {
                            vals = new HashMap<>();
                            errorsMap.put(key, vals);
                            mainErrorsMap.put(key, description);
                        }
                        String hash;
                        if (file_hash != null) {
                            hash = Base64.encodeToString(file_hash, Base64.NO_WRAP);
                        } else {
                            hash = "";
                        }
                        switch (target) {
                            case "data":
                                if (field != null) {
                                    vals.put(field, description);
                                }
                                break;
                            case "files":
                                if (file_hash != null) {
                                    vals.put("files" + hash, description);
                                } else {
                                    vals.put("files_all", description);
                                }
                                break;
                            case "selfie":
                                vals.put("selfie" + hash, description);
                                break;
                            case "translation":
                                if (file_hash != null) {
                                    vals.put("translation" + hash, description);
                                } else {
                                    vals.put("translation_all", description);
                                }
                                break;
                            case "front":
                                vals.put("front" + hash, description);
                                break;
                            case "reverse":
                                vals.put("reverse" + hash, description);
                                break;
                            case "error_all":
                                vals.put("error_all", description);
                                break;
                        }
                    }
                } catch (Exception ignore) {

                }
            }
        }
    }

    public PassportActivity(int type, TLRPC.TL_account_authorizationForm form, TLRPC.TL_account_password accountPassword, TLRPC.TL_secureRequiredType secureType, TLRPC.TL_secureValue secureValue, TLRPC.TL_secureRequiredType secureDocumentsType, TLRPC.TL_secureValue secureDocumentsValue, HashMap<String, String> values, HashMap<String, String> documentValues) {
        super();
        currentActivityType = type;
        currentForm = form;
        currentType = secureType;
        if (currentType != null) {
            allowNonLatinName = currentType.native_names;
        }
        currentTypeValue = secureValue;
        currentDocumentsType = secureDocumentsType;
        currentDocumentsTypeValue = secureDocumentsValue;
        currentPassword = accountPassword;
        currentValues = values;
        currentDocumentValues = documentValues;
        if (currentActivityType == TYPE_PHONE) {
            permissionsItems = new ArrayList<>();
        } else if (currentActivityType == TYPE_PHONE_VERIFICATION) {
            views = new SlideView[3];
        }
        if (currentValues == null) {
            currentValues = new HashMap<>();
        }
        if (currentDocumentValues == null) {
            currentDocumentValues = new HashMap<>();
        }
        if (type == TYPE_PASSWORD) {
            if (UserConfig.getInstance(currentAccount).savedPasswordHash != null && UserConfig.getInstance(currentAccount).savedSaltedPassword != null) {
                usingSavedPassword = 1;
                savedPasswordHash = UserConfig.getInstance(currentAccount).savedPasswordHash;
                savedSaltedPassword = UserConfig.getInstance(currentAccount).savedSaltedPassword;
            }
            if (currentPassword == null) {
                loadPasswordInfo();
            } else {
                TwoStepVerificationActivity.initPasswordNewAlgo(currentPassword);
                if (usingSavedPassword == 1) {
                    onPasswordDone(true);
                }
            }
            if (!SharedConfig.isPassportConfigLoaded()) {
                TLRPC.TL_help_getPassportConfig req = new TLRPC.TL_help_getPassportConfig();
                req.hash = SharedConfig.passportConfigHash;
                ConnectionsManager.getInstance(currentAccount).sendRequest(req, (response, error) -> AndroidUtilities.runOnUIThread(() -> {
                    if (response instanceof TLRPC.TL_help_passportConfig) {
                        TLRPC.TL_help_passportConfig res = (TLRPC.TL_help_passportConfig) response;
                        SharedConfig.setPassportConfig(res.countries_langs.data, res.hash);
                    } else {
                        SharedConfig.getCountryLangs();
                    }
                }));
            }
        }
    }

    @Override
    public void onResume() {
        super.onResume();
        if (chatAttachAlert != null) {
            chatAttachAlert.onResume();
        }
        if (currentActivityType == TYPE_PASSWORD && inputFieldContainers != null && inputFieldContainers[FIELD_PASSWORD] != null && inputFieldContainers[FIELD_PASSWORD].getVisibility() == View.VISIBLE) {
            inputFields[FIELD_PASSWORD].requestFocus();
            AndroidUtilities.showKeyboard(inputFields[FIELD_PASSWORD]);
            AndroidUtilities.runOnUIThread(() -> {
                if (inputFieldContainers != null && inputFieldContainers[FIELD_PASSWORD] != null && inputFieldContainers[FIELD_PASSWORD].getVisibility() == View.VISIBLE) {
                    inputFields[FIELD_PASSWORD].requestFocus();
                    AndroidUtilities.showKeyboard(inputFields[FIELD_PASSWORD]);
                }
            }, 200);
        }
        AndroidUtilities.requestAdjustResize(getParentActivity(), classGuid);
    }

    @Override
    public void onPause() {
        super.onPause();
        if (chatAttachAlert != null) {
            chatAttachAlert.onPause();
        }
    }

    @Override
    public boolean onFragmentCreate() {
        NotificationCenter.getInstance(currentAccount).addObserver(this, NotificationCenter.FileDidUpload);
        NotificationCenter.getInstance(currentAccount).addObserver(this, NotificationCenter.FileDidFailUpload);
        NotificationCenter.getInstance(currentAccount).addObserver(this, NotificationCenter.twoStepPasswordChanged);
        NotificationCenter.getInstance(currentAccount).addObserver(this, NotificationCenter.didRemoveTwoStepPassword);
        return super.onFragmentCreate();
    }

    @Override
    public void onFragmentDestroy() {
        super.onFragmentDestroy();
        NotificationCenter.getInstance(currentAccount).removeObserver(this, NotificationCenter.FileDidUpload);
        NotificationCenter.getInstance(currentAccount).removeObserver(this, NotificationCenter.FileDidFailUpload);
        NotificationCenter.getInstance(currentAccount).removeObserver(this, NotificationCenter.twoStepPasswordChanged);
        NotificationCenter.getInstance(currentAccount).removeObserver(this, NotificationCenter.didRemoveTwoStepPassword);
        callCallback(false);
        if (chatAttachAlert != null) {
            chatAttachAlert.dismissInternal();
            chatAttachAlert.onDestroy();
        }
        if (currentActivityType == TYPE_PHONE_VERIFICATION) {
            for (int a = 0; a < views.length; a++) {
                if (views[a] != null) {
                    views[a].onDestroyActivity();
                }
            }
            if (progressDialog != null) {
                try {
                    progressDialog.dismiss();
                } catch (Exception e) {
                    FileLog.e(e);
                }
                progressDialog = null;
            }
        }
    }

    @Override
    public View createView(Context context) {

        actionBar.setBackButtonImage(R.drawable.ic_ab_back);
        actionBar.setAllowOverlayTitle(true);

        actionBar.setActionBarMenuOnItemClick(new ActionBar.ActionBarMenuOnItemClick() {

            private boolean onIdentityDone(Runnable finishRunnable, ErrorRunnable errorRunnable) {
                if (!uploadingDocuments.isEmpty() || checkFieldsForError()) {
                    return false;
                }
                if (allowNonLatinName) {
                    allowNonLatinName = false;
                    boolean error = false;
                    for (int a = 0; a < nonLatinNames.length; a++) {
                        if (nonLatinNames[a]) {
                            inputFields[a].setErrorText(LocaleController.getString("PassportUseLatinOnly", R.string.PassportUseLatinOnly));
                            if (!error) {
                                error = true;
                                String firstName = nonLatinNames[0] ? getTranslitString(inputExtraFields[FIELD_NATIVE_NAME].getText().toString()) : inputFields[FIELD_NAME].getText().toString();
                                String middleName = nonLatinNames[1] ? getTranslitString(inputExtraFields[FIELD_NATIVE_MIDNAME].getText().toString()) : inputFields[FIELD_MIDNAME].getText().toString();
                                String lastName = nonLatinNames[2] ? getTranslitString(inputExtraFields[FIELD_NATIVE_SURNAME].getText().toString()) : inputFields[FIELD_SURNAME].getText().toString();

                                if (!TextUtils.isEmpty(firstName) && !TextUtils.isEmpty(middleName) && !TextUtils.isEmpty(lastName)) {
                                    int num = a;
                                    AlertDialog.Builder builder = new AlertDialog.Builder(getParentActivity());
                                    builder.setMessage(LocaleController.formatString("PassportNameCheckAlert", R.string.PassportNameCheckAlert, firstName, middleName, lastName));
                                    builder.setTitle(LocaleController.getString("AppName", R.string.AppName));
                                    builder.setPositiveButton(LocaleController.getString("Done", R.string.Done), (dialogInterface, i) -> {
                                        inputFields[FIELD_NAME].setText(firstName);
                                        inputFields[FIELD_MIDNAME].setText(middleName);
                                        inputFields[FIELD_SURNAME].setText(lastName);
                                        showEditDoneProgress(true, true);
                                        onIdentityDone(finishRunnable, errorRunnable);
                                    });
                                    builder.setNegativeButton(LocaleController.getString("Edit", R.string.Edit), (dialogInterface, i) -> onFieldError(inputFields[num]));
                                    showDialog(builder.create());
                                } else {
                                    onFieldError(inputFields[a]);
                                }
                            }
                        }
                    }
                    if (error) {
                        return false;
                    }
                }
                if (isHasNotAnyChanges()) {
                    finishFragment();
                    return false;
                }
                JSONObject json = null;
                JSONObject documentsJson = null;
                try {
                    if (!documentOnly) {
                        HashMap<String, String> valuesToSave = new HashMap<>(currentValues);
                        if (currentType.native_names) {
                            if (nativeInfoCell.getVisibility() == View.VISIBLE) {
                                valuesToSave.put("first_name_native", inputExtraFields[FIELD_NATIVE_NAME].getText().toString());
                                valuesToSave.put("middle_name_native", inputExtraFields[FIELD_NATIVE_MIDNAME].getText().toString());
                                valuesToSave.put("last_name_native", inputExtraFields[FIELD_NATIVE_SURNAME].getText().toString());
                            } else {
                                valuesToSave.put("first_name_native", inputFields[FIELD_NATIVE_NAME].getText().toString());
                                valuesToSave.put("middle_name_native", inputFields[FIELD_NATIVE_MIDNAME].getText().toString());
                                valuesToSave.put("last_name_native", inputFields[FIELD_NATIVE_SURNAME].getText().toString());
                            }
                        }
                        valuesToSave.put("first_name", inputFields[FIELD_NAME].getText().toString());
                        valuesToSave.put("middle_name", inputFields[FIELD_MIDNAME].getText().toString());
                        valuesToSave.put("last_name", inputFields[FIELD_SURNAME].getText().toString());
                        valuesToSave.put("birth_date", inputFields[FIELD_BIRTHDAY].getText().toString());
                        valuesToSave.put("gender", currentGender);
                        valuesToSave.put("country_code", currentCitizeship);
                        valuesToSave.put("residence_country_code", currentResidence);

                        json = new JSONObject();
                        ArrayList<String> keys = new ArrayList<>(valuesToSave.keySet());
                        Collections.sort(keys, (key1, key2) -> {
                            int val1 = getFieldCost(key1);
                            int val2 = getFieldCost(key2);
                            if (val1 < val2) {
                                return -1;
                            } else if (val1 > val2) {
                                return 1;
                            }
                            return 0;
                        });
                        for (int a = 0, size = keys.size(); a < size; a++) {
                            String key = keys.get(a);
                            json.put(key, valuesToSave.get(key));
                        }
                    }

                    if (currentDocumentsType != null) {
                        HashMap<String, String> valuesToSave = new HashMap<>(currentDocumentValues);
                        valuesToSave.put("document_no", inputFields[FIELD_CARDNUMBER].getText().toString());
                        if (currentExpireDate[0] != 0) {
                            valuesToSave.put("expiry_date", String.format(Locale.US, "%02d.%02d.%d", currentExpireDate[2], currentExpireDate[1], currentExpireDate[0]));
                        } else {
                            valuesToSave.put("expiry_date", "");
                        }

                        documentsJson = new JSONObject();
                        ArrayList<String> keys = new ArrayList<>(valuesToSave.keySet());
                        Collections.sort(keys, (key1, key2) -> {
                            int val1 = getFieldCost(key1);
                            int val2 = getFieldCost(key2);
                            if (val1 < val2) {
                                return -1;
                            } else if (val1 > val2) {
                                return 1;
                            }
                            return 0;
                        });
                        for (int a = 0, size = keys.size(); a < size; a++) {
                            String key = keys.get(a);
                            documentsJson.put(key, valuesToSave.get(key));
                        }
                    }
                } catch (Exception ignore) {

                }
                if (fieldsErrors != null) {
                    fieldsErrors.clear();
                }
                if (documentsErrors != null) {
                    documentsErrors.clear();
                }
                delegate.saveValue(currentType, null, json != null ? json.toString() : null, currentDocumentsType, documentsJson != null ? documentsJson.toString() : null, null, selfieDocument, translationDocuments, frontDocument, reverseLayout != null && reverseLayout.getVisibility() == View.VISIBLE ? reverseDocument : null, finishRunnable, errorRunnable);
                return true;
            }

            @Override
            public void onItemClick(int id) {
                if (id == -1) {
                    if (checkDiscard()) {
                        return;
                    }
                    if (currentActivityType == TYPE_REQUEST || currentActivityType == TYPE_PASSWORD) {
                        callCallback(false);
                    }
                    finishFragment();
                } else if (id == info_item) {
                    if (getParentActivity() == null) {
                        return;
                    }
                    final TextView message = new TextView(getParentActivity());
                    String str2 = LocaleController.getString("PassportInfo2", R.string.PassportInfo2);
                    SpannableStringBuilder spanned = new SpannableStringBuilder(str2);
                    int index1 = str2.indexOf('*');
                    int index2 = str2.lastIndexOf('*');
                    if (index1 != -1 && index2 != -1) {
                        spanned.replace(index2, index2 + 1, "");
                        spanned.replace(index1, index1 + 1, "");
                        spanned.setSpan(new URLSpanNoUnderline(LocaleController.getString("PassportInfoUrl", R.string.PassportInfoUrl)) {
                            @Override
                            public void onClick(View widget) {
                                dismissCurrentDialog();
                                super.onClick(widget);
                            }
                        }, index1, index2 - 1, Spanned.SPAN_EXCLUSIVE_EXCLUSIVE);
                    }
                    message.setText(spanned);
                    message.setTextSize(TypedValue.COMPLEX_UNIT_DIP, 16);
                    message.setLinkTextColor(Theme.getColor(Theme.key_dialogTextLink));
                    message.setHighlightColor(Theme.getColor(Theme.key_dialogLinkSelection));
                    message.setPadding(AndroidUtilities.dp(23), 0, AndroidUtilities.dp(23), 0);
                    message.setMovementMethod(new AndroidUtilities.LinkMovementMethodMy());
                    message.setTextColor(Theme.getColor(Theme.key_dialogTextBlack));

                    AlertDialog.Builder builder = new AlertDialog.Builder(getParentActivity());
                    builder.setView(message);
                    builder.setTitle(LocaleController.getString("PassportInfoTitle", R.string.PassportInfoTitle));
                    builder.setNegativeButton(LocaleController.getString("Close", R.string.Close), null);
                    showDialog(builder.create());
                } else if (id == done_button) {
                    if (currentActivityType == TYPE_PASSWORD) {
                        onPasswordDone(false);
                        return;
                    }
                    if (currentActivityType == TYPE_PHONE_VERIFICATION) {
                        views[currentViewNum].onNextPressed();
                    } else {
                        final Runnable finishRunnable = () -> finishFragment();
                        final ErrorRunnable errorRunnable = new ErrorRunnable() {
                            @Override
                            public void onError(String error, String text) {
                                if ("PHONE_VERIFICATION_NEEDED".equals(error)) {
                                    startPhoneVerification(true, text, finishRunnable, this, delegate);
                                } else {
                                    showEditDoneProgress(true, false);
                                }
                            }
                        };

                        if (currentActivityType == TYPE_EMAIL) {
                            String value;
                            if (useCurrentValue) {
                                value = currentEmail;
                            } else {
                                if (checkFieldsForError()) {
                                    return;
                                }
                                value = inputFields[FIELD_EMAIL].getText().toString();
                            }
                            delegate.saveValue(currentType, value, null, null, null, null, null, null, null, null, finishRunnable, errorRunnable);
                        } else if (currentActivityType == TYPE_PHONE) {
                            String value;
                            if (useCurrentValue) {
                                value = UserConfig.getInstance(currentAccount).getCurrentUser().phone;
                            } else {
                                if (checkFieldsForError()) {
                                    return;
                                }
                                value = inputFields[FIELD_PHONECODE].getText().toString() + inputFields[FIELD_PHONE].getText().toString();
                            }
                            delegate.saveValue(currentType, value, null, null, null, null, null, null, null, null, finishRunnable, errorRunnable);
                        } else if (currentActivityType == TYPE_ADDRESS) {
                            if (!uploadingDocuments.isEmpty() || checkFieldsForError()) {
                                return;
                            }
                            if (isHasNotAnyChanges()) {
                                finishFragment();
                                return;
                            }
                            JSONObject json = null;
                            try {
                                if (!documentOnly) {
                                    json = new JSONObject();
                                    json.put("street_line1", inputFields[FIELD_STREET1].getText().toString());
                                    json.put("street_line2", inputFields[FIELD_STREET2].getText().toString());
                                    json.put("post_code", inputFields[FIELD_POSTCODE].getText().toString());
                                    json.put("city", inputFields[FIELD_CITY].getText().toString());
                                    json.put("state", inputFields[FIELD_STATE].getText().toString());
                                    json.put("country_code", currentCitizeship);
                                }
                            } catch (Exception ignore) {

                            }
                            if (fieldsErrors != null) {
                                fieldsErrors.clear();
                            }
                            if (documentsErrors != null) {
                                documentsErrors.clear();
                            }
                            delegate.saveValue(currentType, null, json != null ? json.toString() : null, currentDocumentsType, null, documents, selfieDocument, translationDocuments, null, null, finishRunnable, errorRunnable);
                        } else if (currentActivityType == TYPE_IDENTITY) {
                            if (!onIdentityDone(finishRunnable, errorRunnable)) {
                                return;
                            }
                        } else if (currentActivityType == TYPE_EMAIL_VERIFICATION) {
                            final TLRPC.TL_account_verifyEmail req = new TLRPC.TL_account_verifyEmail();
                            req.email = currentValues.get("email");
                            req.code = inputFields[FIELD_EMAIL].getText().toString();
                            int reqId = ConnectionsManager.getInstance(currentAccount).sendRequest(req, (response, error) -> AndroidUtilities.runOnUIThread(() -> {
                                if (error == null) {
                                    delegate.saveValue(currentType, currentValues.get("email"), null, null, null, null, null, null, null, null, finishRunnable, errorRunnable);
                                } else {
                                    AlertsCreator.processError(currentAccount, error, PassportActivity.this, req);
                                    errorRunnable.onError(null, null);
                                }
                            }));
                            ConnectionsManager.getInstance(currentAccount).bindRequestToGuid(reqId, classGuid);
                        }
                        showEditDoneProgress(true, true);
                    }
                }
            }
        });

        if (currentActivityType == TYPE_PHONE_VERIFICATION) {
            fragmentView = scrollView = new ScrollView(context) {
                @Override
                protected boolean onRequestFocusInDescendants(int direction, Rect previouslyFocusedRect) {
                    return false;
                }

                @Override
                public boolean requestChildRectangleOnScreen(View child, Rect rectangle, boolean immediate) {
                    if (currentViewNum == 1 || currentViewNum == 2 || currentViewNum == 4) {
                        rectangle.bottom += AndroidUtilities.dp(40);
                    }
                    return super.requestChildRectangleOnScreen(child, rectangle, immediate);
                }

                @Override
                protected void onMeasure(int widthMeasureSpec, int heightMeasureSpec) {
                    scrollHeight = MeasureSpec.getSize(heightMeasureSpec) - AndroidUtilities.dp(30);
                    super.onMeasure(widthMeasureSpec, heightMeasureSpec);
                }
            };
            scrollView.setFillViewport(true);
            AndroidUtilities.setScrollViewEdgeEffectColor(scrollView, Theme.getColor(Theme.key_actionBarDefault));
        } else {
            fragmentView = new FrameLayout(context);
            FrameLayout frameLayout = (FrameLayout) fragmentView;
            fragmentView.setBackgroundColor(Theme.getColor(Theme.key_windowBackgroundGray));

            scrollView = new ScrollView(context) {
                @Override
                protected boolean onRequestFocusInDescendants(int direction, Rect previouslyFocusedRect) {
                    return false;
                }

                @Override
                public boolean requestChildRectangleOnScreen(View child, Rect rectangle, boolean immediate) {
                    rectangle.offset(child.getLeft() - child.getScrollX(), child.getTop() - child.getScrollY());
                    rectangle.top += AndroidUtilities.dp(20);
                    rectangle.bottom += AndroidUtilities.dp(50);
                    return super.requestChildRectangleOnScreen(child, rectangle, immediate);
                }
            };
            scrollView.setFillViewport(true);
            AndroidUtilities.setScrollViewEdgeEffectColor(scrollView, Theme.getColor(Theme.key_actionBarDefault));
            frameLayout.addView(scrollView, LayoutHelper.createFrame(LayoutHelper.MATCH_PARENT, LayoutHelper.MATCH_PARENT, Gravity.LEFT | Gravity.TOP, 0, 0, 0, currentActivityType == TYPE_REQUEST ? 48 : 0));

            linearLayout2 = new LinearLayout(context);
            linearLayout2.setOrientation(LinearLayout.VERTICAL);
            scrollView.addView(linearLayout2, new ScrollView.LayoutParams(ViewGroup.LayoutParams.MATCH_PARENT, ViewGroup.LayoutParams.WRAP_CONTENT));
        }

        if (currentActivityType != TYPE_REQUEST && currentActivityType != TYPE_MANAGE) {
            ActionBarMenu menu = actionBar.createMenu();
            doneItem = menu.addItemWithWidth(done_button, R.drawable.ic_done, AndroidUtilities.dp(56), LocaleController.getString("Done", R.string.Done));
            progressView = new ContextProgressView(context, 1);
            progressView.setAlpha(0.0f);
            progressView.setScaleX(0.1f);
            progressView.setScaleY(0.1f);
            progressView.setVisibility(View.INVISIBLE);
            doneItem.addView(progressView, LayoutHelper.createFrame(LayoutHelper.MATCH_PARENT, LayoutHelper.MATCH_PARENT));

            if (currentActivityType == TYPE_IDENTITY || currentActivityType == TYPE_ADDRESS) {
                if (chatAttachAlert != null) {
                    try {
                        if (chatAttachAlert.isShowing()) {
                            chatAttachAlert.dismiss();
                        }
                    } catch (Exception ignore) {

                    }
                    chatAttachAlert.onDestroy();
                    chatAttachAlert = null;
                }
            }
        }

        if (currentActivityType == TYPE_PASSWORD) {
            createPasswordInterface(context);
        } else if (currentActivityType == TYPE_REQUEST) {
            createRequestInterface(context);
        } else if (currentActivityType == TYPE_IDENTITY) {
            createIdentityInterface(context);
            fillInitialValues();
        } else if (currentActivityType == TYPE_ADDRESS) {
            createAddressInterface(context);
            fillInitialValues();
        } else if (currentActivityType == TYPE_PHONE) {
            createPhoneInterface(context);
        } else if (currentActivityType == TYPE_EMAIL) {
            createEmailInterface(context);
        } else if (currentActivityType == TYPE_EMAIL_VERIFICATION) {
            createEmailVerificationInterface(context);
        } else if (currentActivityType == TYPE_PHONE_VERIFICATION) {
            createPhoneVerificationInterface(context);
        } else if (currentActivityType == TYPE_MANAGE) {
            createManageInterface(context);
        }
        return fragmentView;
    }

    @Override
    public boolean dismissDialogOnPause(Dialog dialog) {
        return dialog != chatAttachAlert && super.dismissDialogOnPause(dialog);
    }

    @Override
    public void dismissCurrentDialog() {
        if (chatAttachAlert != null && visibleDialog == chatAttachAlert) {
            chatAttachAlert.getPhotoLayout().closeCamera(false);
            chatAttachAlert.dismissInternal();
            chatAttachAlert.getPhotoLayout().hideCamera(true);
            return;
        }
        super.dismissCurrentDialog();
    }

    private String getTranslitString(String value) {
        return LocaleController.getInstance().getTranslitString(value, true);
    }

    private int getFieldCost(String key) {
        switch (key) {
            case "first_name":
            case "first_name_native":
                return 20;
            case "middle_name":
            case "middle_name_native":
                return 21;
            case "last_name":
            case "last_name_native":
                return 22;
            case "birth_date":
                return 23;
            case "gender":
                return 24;
            case "country_code":
                return 25;
            case "residence_country_code":
                return 26;
            case "document_no":
                return 27;
            case "expiry_date":
                return 28;
            case "street_line1":
                return 29;
            case "street_line2":
                return 30;
            case "post_code":
                return 31;
            case "city":
                return 32;
            case "state":
                return 33;
        }
        return 100;
    }

    private void createPhoneVerificationInterface(Context context) {
        actionBar.setTitle(LocaleController.getString("PassportPhone", R.string.PassportPhone));

        FrameLayout frameLayout = new FrameLayout(context);
        scrollView.addView(frameLayout, LayoutHelper.createScroll(LayoutHelper.MATCH_PARENT, LayoutHelper.WRAP_CONTENT, Gravity.TOP | Gravity.LEFT));

        for (int a = 0; a < 3; a++) {
            views[a] = new PhoneConfirmationView(context, a + 2);
            views[a].setVisibility(View.GONE);
            frameLayout.addView(views[a], LayoutHelper.createFrame(LayoutHelper.MATCH_PARENT, LayoutHelper.MATCH_PARENT, Gravity.TOP | Gravity.LEFT, AndroidUtilities.isTablet() ? 26 : 18, 30, AndroidUtilities.isTablet() ? 26 : 18, 0));
        }
        final Bundle params = new Bundle();
        params.putString("phone", currentValues.get("phone"));
        fillNextCodeParams(params, currentPhoneVerification, false);
    }

    private void loadPasswordInfo() {
        TLRPC.TL_account_getPassword req = new TLRPC.TL_account_getPassword();
        int reqId = ConnectionsManager.getInstance(currentAccount).sendRequest(req, (response, error) -> AndroidUtilities.runOnUIThread(() -> {
            if (response != null) {
                currentPassword = (TLRPC.TL_account_password) response;
                if (!TwoStepVerificationActivity.canHandleCurrentPassword(currentPassword, false)) {
                    AlertsCreator.showUpdateAppAlert(getParentActivity(), LocaleController.getString("UpdateAppAlert", R.string.UpdateAppAlert), true);
                    return;
                }
                TwoStepVerificationActivity.initPasswordNewAlgo(currentPassword);
                updatePasswordInterface();

                if (inputFieldContainers[FIELD_PASSWORD].getVisibility() == View.VISIBLE) {
                    inputFields[FIELD_PASSWORD].requestFocus();
                    AndroidUtilities.showKeyboard(inputFields[FIELD_PASSWORD]);
                }
                if (usingSavedPassword == 1) {
                    onPasswordDone(true);
                }
            }
        }));
        ConnectionsManager.getInstance(currentAccount).bindRequestToGuid(reqId, classGuid);
    }

    private void createEmailVerificationInterface(Context context) {
        actionBar.setTitle(LocaleController.getString("PassportEmail", R.string.PassportEmail));

        inputFields = new EditTextBoldCursor[1];
        for (int a = 0; a < 1; a++) {
            ViewGroup container = new FrameLayout(context);
            linearLayout2.addView(container, LayoutHelper.createLinear(LayoutHelper.MATCH_PARENT, 50));
            container.setBackgroundColor(Theme.getColor(Theme.key_windowBackgroundWhite));

            inputFields[a] = new EditTextBoldCursor(context);
            inputFields[a].setTag(a);
            inputFields[a].setTextSize(TypedValue.COMPLEX_UNIT_DIP, 16);
            inputFields[a].setHintTextColor(Theme.getColor(Theme.key_windowBackgroundWhiteHintText));
            inputFields[a].setTextColor(Theme.getColor(Theme.key_windowBackgroundWhiteBlackText));
            inputFields[a].setBackgroundDrawable(null);
            inputFields[a].setCursorColor(Theme.getColor(Theme.key_windowBackgroundWhiteBlackText));
            inputFields[a].setCursorSize(AndroidUtilities.dp(20));
            inputFields[a].setCursorWidth(1.5f);
            inputFields[a].setInputType(InputType.TYPE_CLASS_PHONE);

            inputFields[a].setImeOptions(EditorInfo.IME_ACTION_DONE | EditorInfo.IME_FLAG_NO_EXTRACT_UI);
            inputFields[a].setHint(LocaleController.getString("PassportEmailCode", R.string.PassportEmailCode));
            inputFields[a].setSelection(inputFields[a].length());
            inputFields[a].setPadding(0, 0, 0, AndroidUtilities.dp(6));
            inputFields[a].setGravity(LocaleController.isRTL ? Gravity.RIGHT : Gravity.LEFT);
            container.addView(inputFields[a], LayoutHelper.createFrame(LayoutHelper.MATCH_PARENT, LayoutHelper.WRAP_CONTENT, Gravity.LEFT | Gravity.TOP, 21, 12, 21, 6));

            inputFields[a].setOnEditorActionListener((textView, i, keyEvent) -> {
                if (i == EditorInfo.IME_ACTION_DONE || i == EditorInfo.IME_ACTION_NEXT) {
                    doneItem.callOnClick();
                    return true;
                }
                return false;
            });

            inputFields[a].addTextChangedListener(new TextWatcher() {
                @Override
                public void beforeTextChanged(CharSequence s, int start, int count, int after) {

                }

                @Override
                public void onTextChanged(CharSequence s, int start, int before, int count) {

                }

                @Override
                public void afterTextChanged(Editable s) {
                    if (ignoreOnTextChange) {
                        return;
                    }
                    if (emailCodeLength != 0 && inputFields[FIELD_EMAIL].length() == emailCodeLength) {
                        doneItem.callOnClick();
                    }
                }
            });
        }

        bottomCell = new TextInfoPrivacyCell(context);
        bottomCell.setBackgroundDrawable(Theme.getThemedDrawable(context, R.drawable.greydivider_bottom, Theme.key_windowBackgroundGrayShadow));
        bottomCell.setText(LocaleController.formatString("PassportEmailVerifyInfo", R.string.PassportEmailVerifyInfo, currentValues.get("email")));
        linearLayout2.addView(bottomCell, LayoutHelper.createLinear(LayoutHelper.MATCH_PARENT, LayoutHelper.WRAP_CONTENT));
    }

    private void createPasswordInterface(Context context) {
        TLRPC.User botUser = null;
        if (currentForm != null) {
            for (int a = 0; a < currentForm.users.size(); a++) {
                TLRPC.User user = currentForm.users.get(a);
                if (user.id == currentBotId) {
                    botUser = user;
                    break;
                }
            }
        } else {
            botUser = UserConfig.getInstance(currentAccount).getCurrentUser();
        }

        FrameLayout frameLayout = (FrameLayout) fragmentView;

        actionBar.setTitle(LocaleController.getString("TelegramPassport", R.string.TelegramPassport));

        emptyView = new EmptyTextProgressView(context);
        emptyView.showProgress();
        frameLayout.addView(emptyView, LayoutHelper.createFrame(LayoutHelper.MATCH_PARENT, LayoutHelper.MATCH_PARENT));

        passwordAvatarContainer = new FrameLayout(context);
        linearLayout2.addView(passwordAvatarContainer, LayoutHelper.createLinear(LayoutHelper.MATCH_PARENT, 100));

        BackupImageView avatarImageView = new BackupImageView(context);
        avatarImageView.setRoundRadius(AndroidUtilities.dp(32));
        passwordAvatarContainer.addView(avatarImageView, LayoutHelper.createFrame(64, 64, Gravity.CENTER, 0, 8, 0, 0));

        AvatarDrawable avatarDrawable = new AvatarDrawable(botUser);
        avatarImageView.setImage(ImageLocation.getForUser(botUser, false), "50_50", avatarDrawable, botUser);

        passwordRequestTextView = new TextInfoPrivacyCell(context);
        passwordRequestTextView.getTextView().setGravity(Gravity.CENTER_HORIZONTAL);
        if (currentBotId == 0) {
            passwordRequestTextView.setText(LocaleController.getString("PassportSelfRequest", R.string.PassportSelfRequest));
        } else {
            passwordRequestTextView.setText(AndroidUtilities.replaceTags(LocaleController.formatString("PassportRequest", R.string.PassportRequest, UserObject.getFirstName(botUser))));
        }
        ((FrameLayout.LayoutParams) passwordRequestTextView.getTextView().getLayoutParams()).gravity = Gravity.CENTER_HORIZONTAL;
        linearLayout2.addView(passwordRequestTextView, LayoutHelper.createFrame(LayoutHelper.WRAP_CONTENT, LayoutHelper.WRAP_CONTENT, (LocaleController.isRTL ? Gravity.RIGHT : Gravity.LEFT) | Gravity.TOP, 21, 0, 21, 0));

        noPasswordImageView = new ImageView(context);
        noPasswordImageView.setImageResource(R.drawable.no_password);
        noPasswordImageView.setColorFilter(new PorterDuffColorFilter(Theme.getColor(Theme.key_chat_messagePanelIcons), PorterDuff.Mode.MULTIPLY));
        linearLayout2.addView(noPasswordImageView, LayoutHelper.createLinear(LayoutHelper.WRAP_CONTENT, LayoutHelper.WRAP_CONTENT, Gravity.TOP | Gravity.CENTER_HORIZONTAL, 0, 13, 0, 0));

        noPasswordTextView = new TextView(context);
        noPasswordTextView.setTextSize(TypedValue.COMPLEX_UNIT_DIP, 14);
        noPasswordTextView.setGravity(Gravity.CENTER_HORIZONTAL);
        noPasswordTextView.setPadding(AndroidUtilities.dp(21), AndroidUtilities.dp(10), AndroidUtilities.dp(21), AndroidUtilities.dp(17));
        noPasswordTextView.setTextColor(Theme.getColor(Theme.key_windowBackgroundWhiteGrayText4));
        noPasswordTextView.setText(LocaleController.getString("TelegramPassportCreatePasswordInfo", R.string.TelegramPassportCreatePasswordInfo));
        linearLayout2.addView(noPasswordTextView, LayoutHelper.createFrame(LayoutHelper.WRAP_CONTENT, LayoutHelper.WRAP_CONTENT, (LocaleController.isRTL ? Gravity.RIGHT : Gravity.LEFT) | Gravity.TOP, 21, 10, 21, 0));

        noPasswordSetTextView = new TextView(context);
        noPasswordSetTextView.setTextColor(Theme.getColor(Theme.key_windowBackgroundWhiteBlueText5));
        noPasswordSetTextView.setGravity(Gravity.CENTER);
        noPasswordSetTextView.setTextSize(TypedValue.COMPLEX_UNIT_DIP, 16);
        noPasswordSetTextView.setTypeface(AndroidUtilities.getTypeface("fonts/rmedium.ttf"));
        noPasswordSetTextView.setText(LocaleController.getString("TelegramPassportCreatePassword", R.string.TelegramPassportCreatePassword));
        linearLayout2.addView(noPasswordSetTextView, LayoutHelper.createFrame(LayoutHelper.MATCH_PARENT, 24, (LocaleController.isRTL ? Gravity.RIGHT : Gravity.LEFT) | Gravity.TOP, 21, 9, 21, 0));
        noPasswordSetTextView.setOnClickListener(v -> {
            TwoStepVerificationSetupActivity activity = new TwoStepVerificationSetupActivity(currentAccount, TwoStepVerificationSetupActivity.TYPE_ENTER_FIRST, currentPassword);
            activity.setCloseAfterSet(true);
            presentFragment(activity);
        });

        inputFields = new EditTextBoldCursor[1];
        inputFieldContainers = new ViewGroup[1];
        for (int a = 0; a < 1; a++) {
            inputFieldContainers[a] = new FrameLayout(context);
            linearLayout2.addView(inputFieldContainers[a], LayoutHelper.createLinear(LayoutHelper.MATCH_PARENT, 50));
            inputFieldContainers[a].setBackgroundColor(Theme.getColor(Theme.key_windowBackgroundWhite));

            inputFields[a] = new EditTextBoldCursor(context);
            inputFields[a].setTag(a);
            inputFields[a].setTextSize(TypedValue.COMPLEX_UNIT_DIP, 16);
            inputFields[a].setHintTextColor(Theme.getColor(Theme.key_windowBackgroundWhiteHintText));
            inputFields[a].setTextColor(Theme.getColor(Theme.key_windowBackgroundWhiteBlackText));
            inputFields[a].setBackgroundDrawable(null);
            inputFields[a].setCursorColor(Theme.getColor(Theme.key_windowBackgroundWhiteBlackText));
            inputFields[a].setCursorSize(AndroidUtilities.dp(20));
            inputFields[a].setCursorWidth(1.5f);
            inputFields[a].setInputType(InputType.TYPE_CLASS_TEXT | InputType.TYPE_TEXT_VARIATION_PASSWORD);
            inputFields[a].setMaxLines(1);
            inputFields[a].setLines(1);
            inputFields[a].setSingleLine(true);
            inputFields[a].setTransformationMethod(PasswordTransformationMethod.getInstance());
            inputFields[a].setTypeface(Typeface.DEFAULT);
            inputFields[a].setImeOptions(EditorInfo.IME_ACTION_DONE | EditorInfo.IME_FLAG_NO_EXTRACT_UI);
            inputFields[a].setPadding(0, 0, 0, AndroidUtilities.dp(6));
            inputFields[a].setGravity(LocaleController.isRTL ? Gravity.RIGHT : Gravity.LEFT);
            inputFieldContainers[a].addView(inputFields[a], LayoutHelper.createFrame(LayoutHelper.MATCH_PARENT, LayoutHelper.WRAP_CONTENT, Gravity.LEFT | Gravity.TOP, 21, 12, 21, 6));

            inputFields[a].setOnEditorActionListener((textView, i, keyEvent) -> {
                if (i == EditorInfo.IME_ACTION_NEXT || i == EditorInfo.IME_ACTION_DONE) {
                    doneItem.callOnClick();
                    return true;
                }
                return false;
            });
            inputFields[a].setCustomSelectionActionModeCallback(new ActionMode.Callback() {
                public boolean onPrepareActionMode(ActionMode mode, Menu menu) {
                    return false;
                }

                public void onDestroyActionMode(ActionMode mode) {
                }

                public boolean onCreateActionMode(ActionMode mode, Menu menu) {
                    return false;
                }

                public boolean onActionItemClicked(ActionMode mode, MenuItem item) {
                    return false;
                }
            });
        }

        passwordInfoRequestTextView = new TextInfoPrivacyCell(context);
        passwordInfoRequestTextView.setBackgroundDrawable(Theme.getThemedDrawable(context, R.drawable.greydivider_bottom, Theme.key_windowBackgroundGrayShadow));
        passwordInfoRequestTextView.setText(LocaleController.formatString("PassportRequestPasswordInfo", R.string.PassportRequestPasswordInfo));
        linearLayout2.addView(passwordInfoRequestTextView, LayoutHelper.createLinear(LayoutHelper.MATCH_PARENT, LayoutHelper.WRAP_CONTENT));

        passwordForgotButton = new TextView(context);
        passwordForgotButton.setTextColor(Theme.getColor(Theme.key_windowBackgroundWhiteBlueText4));
        passwordForgotButton.setTextSize(TypedValue.COMPLEX_UNIT_DIP, 14);
        passwordForgotButton.setText(LocaleController.getString("ForgotPassword", R.string.ForgotPassword));
        passwordForgotButton.setPadding(0, 0, 0, 0);
        linearLayout2.addView(passwordForgotButton, LayoutHelper.createLinear(LayoutHelper.WRAP_CONTENT, 30, (LocaleController.isRTL ? Gravity.RIGHT : Gravity.LEFT) | Gravity.TOP, 21, 0, 21, 0));
        passwordForgotButton.setOnClickListener(v -> {
            if (currentPassword.has_recovery) {
                needShowProgress();
                TLRPC.TL_auth_requestPasswordRecovery req = new TLRPC.TL_auth_requestPasswordRecovery();
                int reqId = ConnectionsManager.getInstance(currentAccount).sendRequest(req, (response, error) -> AndroidUtilities.runOnUIThread(() -> {
                    needHideProgress();
                    if (error == null) {
                        final TLRPC.TL_auth_passwordRecovery res = (TLRPC.TL_auth_passwordRecovery) response;
                        AlertDialog.Builder builder = new AlertDialog.Builder(getParentActivity());
                        builder.setMessage(LocaleController.formatString("RestoreEmailSent", R.string.RestoreEmailSent, res.email_pattern));
                        builder.setTitle(LocaleController.getString("RestoreEmailSentTitle", R.string.RestoreEmailSentTitle));
                        builder.setPositiveButton(LocaleController.getString("OK", R.string.OK), (dialogInterface, i) -> {
                            currentPassword.email_unconfirmed_pattern = res.email_pattern;
                            TwoStepVerificationSetupActivity fragment = new TwoStepVerificationSetupActivity(currentAccount, TwoStepVerificationSetupActivity.TYPE_EMAIL_RECOVERY, currentPassword);
                            presentFragment(fragment);
                        });
                        Dialog dialog = showDialog(builder.create());
                        if (dialog != null) {
                            dialog.setCanceledOnTouchOutside(false);
                            dialog.setCancelable(false);
                        }
                    } else {
                        if (error.text.startsWith("FLOOD_WAIT")) {
                            int time = Utilities.parseInt(error.text);
                            String timeString;
                            if (time < 60) {
                                timeString = LocaleController.formatPluralString("Seconds", time);
                            } else {
                                timeString = LocaleController.formatPluralString("Minutes", time / 60);
                            }
                            showAlertWithText(LocaleController.getString("AppName", R.string.AppName), LocaleController.formatString("FloodWaitTime", R.string.FloodWaitTime, timeString));
                        } else {
                            showAlertWithText(LocaleController.getString("AppName", R.string.AppName), error.text);
                        }
                    }
                }), ConnectionsManager.RequestFlagFailOnServerErrors | ConnectionsManager.RequestFlagWithoutLogin);
                ConnectionsManager.getInstance(currentAccount).bindRequestToGuid(reqId, classGuid);
            } else {
                if (getParentActivity() == null) {
                    return;
                }
                AlertDialog.Builder builder = new AlertDialog.Builder(getParentActivity());
                builder.setPositiveButton(LocaleController.getString("OK", R.string.OK), null);
                builder.setNegativeButton(LocaleController.getString("RestorePasswordResetAccount", R.string.RestorePasswordResetAccount), (dialog, which) -> Browser.openUrl(getParentActivity(), "https://telegram.org/deactivate?phone=" + UserConfig.getInstance(currentAccount).getClientPhone()));
                builder.setTitle(LocaleController.getString("RestorePasswordNoEmailTitle", R.string.RestorePasswordNoEmailTitle));
                builder.setMessage(LocaleController.getString("RestorePasswordNoEmailText", R.string.RestorePasswordNoEmailText));
                showDialog(builder.create());
            }
        });

        updatePasswordInterface();
    }

    private void onPasswordDone(final boolean saved) {
        final String textPassword;
        if (saved) {
            textPassword = null;
        } else {
            textPassword = inputFields[FIELD_PASSWORD].getText().toString();
            if (TextUtils.isEmpty(textPassword)) {
                onPasscodeError(false);
                return;
            }
            showEditDoneProgress(true, true);
        }

        Utilities.globalQueue.postRunnable(() -> {
            TLRPC.TL_account_getPasswordSettings req = new TLRPC.TL_account_getPasswordSettings();

            final byte[] x_bytes;
            if (saved) {
                x_bytes = savedPasswordHash;
            } else if (currentPassword.current_algo instanceof TLRPC.TL_passwordKdfAlgoSHA256SHA256PBKDF2HMACSHA512iter100000SHA256ModPow) {
                byte[] passwordBytes = AndroidUtilities.getStringBytes(textPassword);
                TLRPC.TL_passwordKdfAlgoSHA256SHA256PBKDF2HMACSHA512iter100000SHA256ModPow algo = (TLRPC.TL_passwordKdfAlgoSHA256SHA256PBKDF2HMACSHA512iter100000SHA256ModPow) currentPassword.current_algo;
                x_bytes = SRPHelper.getX(passwordBytes, algo);
            } else {
                x_bytes = null;
            }

            RequestDelegate requestDelegate = new RequestDelegate() {

                private void openRequestInterface() {
                    if (inputFields == null) {
                        return;
                    }
                    if (!saved) {
                        UserConfig.getInstance(currentAccount).savePassword(x_bytes, saltedPassword);
                    }

                    AndroidUtilities.hideKeyboard(inputFields[FIELD_PASSWORD]);
                    ignoreOnFailure = true;
                    int type;
                    if (currentBotId == 0) {
                        type = TYPE_MANAGE;
                    } else {
                        type = TYPE_REQUEST;
                    }
                    PassportActivity activity = new PassportActivity(type, currentBotId, currentScope, currentPublicKey, currentPayload, currentNonce, currentCallbackUrl, currentForm, currentPassword);
                    activity.currentEmail = currentEmail;
                    activity.currentAccount = currentAccount;
                    activity.saltedPassword = saltedPassword;
                    activity.secureSecret = secureSecret;
                    activity.secureSecretId = secureSecretId;
                    activity.needActivityResult = needActivityResult;
                    if (parentLayout == null || !parentLayout.checkTransitionAnimation()) {
                        presentFragment(activity, true);
                    } else {
                        presentAfterAnimation = activity;
                    }
                }

                private void resetSecret() {
                    TLRPC.TL_account_updatePasswordSettings req2 = new TLRPC.TL_account_updatePasswordSettings();
                    if (currentPassword.current_algo instanceof TLRPC.TL_passwordKdfAlgoSHA256SHA256PBKDF2HMACSHA512iter100000SHA256ModPow) {
                        TLRPC.TL_passwordKdfAlgoSHA256SHA256PBKDF2HMACSHA512iter100000SHA256ModPow algo = (TLRPC.TL_passwordKdfAlgoSHA256SHA256PBKDF2HMACSHA512iter100000SHA256ModPow) currentPassword.current_algo;
                        req2.password = SRPHelper.startCheck(x_bytes, currentPassword.srp_id, currentPassword.srp_B, algo);
                    }
                    req2.new_settings = new TLRPC.TL_account_passwordInputSettings();
                    req2.new_settings.new_secure_settings = new TLRPC.TL_secureSecretSettings();
                    req2.new_settings.new_secure_settings.secure_secret = new byte[0];
                    req2.new_settings.new_secure_settings.secure_algo = new TLRPC.TL_securePasswordKdfAlgoUnknown();
                    req2.new_settings.new_secure_settings.secure_secret_id = 0;
                    req2.new_settings.flags |= 4;
                    ConnectionsManager.getInstance(currentAccount).sendRequest(req, (response, error) -> AndroidUtilities.runOnUIThread(() -> {
                        if (error != null && "SRP_ID_INVALID".equals(error.text)) {
                            TLRPC.TL_account_getPassword getPasswordReq = new TLRPC.TL_account_getPassword();
                            ConnectionsManager.getInstance(currentAccount).sendRequest(getPasswordReq, (response2, error2) -> AndroidUtilities.runOnUIThread(() -> {
                                if (error2 == null) {
                                    currentPassword = (TLRPC.TL_account_password) response2;
                                    TwoStepVerificationActivity.initPasswordNewAlgo(currentPassword);
                                    resetSecret();
                                }
                            }), ConnectionsManager.RequestFlagWithoutLogin);
                            return;
                        }
                        generateNewSecret();
                    }));
                }

                private void generateNewSecret() {
                    Utilities.globalQueue.postRunnable(() -> {
                        Utilities.random.setSeed(currentPassword.secure_random);

                        TLRPC.TL_account_updatePasswordSettings req1 = new TLRPC.TL_account_updatePasswordSettings();
                        if (currentPassword.current_algo instanceof TLRPC.TL_passwordKdfAlgoSHA256SHA256PBKDF2HMACSHA512iter100000SHA256ModPow) {
                            TLRPC.TL_passwordKdfAlgoSHA256SHA256PBKDF2HMACSHA512iter100000SHA256ModPow algo = (TLRPC.TL_passwordKdfAlgoSHA256SHA256PBKDF2HMACSHA512iter100000SHA256ModPow) currentPassword.current_algo;
                            req1.password = SRPHelper.startCheck(x_bytes, currentPassword.srp_id, currentPassword.srp_B, algo);
                        }
                        req1.new_settings = new TLRPC.TL_account_passwordInputSettings();

                        secureSecret = getRandomSecret();
                        secureSecretId = Utilities.bytesToLong(Utilities.computeSHA256(secureSecret));
                        if (currentPassword.new_secure_algo instanceof TLRPC.TL_securePasswordKdfAlgoPBKDF2HMACSHA512iter100000) {
                            TLRPC.TL_securePasswordKdfAlgoPBKDF2HMACSHA512iter100000 newAlgo = (TLRPC.TL_securePasswordKdfAlgoPBKDF2HMACSHA512iter100000) currentPassword.new_secure_algo;

                            saltedPassword = Utilities.computePBKDF2(AndroidUtilities.getStringBytes(textPassword), newAlgo.salt);
                            byte[] key = new byte[32];
                            System.arraycopy(saltedPassword, 0, key, 0, 32);
                            byte[] iv = new byte[16];
                            System.arraycopy(saltedPassword, 32, iv, 0, 16);

                            Utilities.aesCbcEncryptionByteArraySafe(secureSecret, key, iv, 0, secureSecret.length, 0, 1);

                            req1.new_settings.new_secure_settings = new TLRPC.TL_secureSecretSettings();
                            req1.new_settings.new_secure_settings.secure_algo = newAlgo;
                            req1.new_settings.new_secure_settings.secure_secret = secureSecret;
                            req1.new_settings.new_secure_settings.secure_secret_id = secureSecretId;
                            req1.new_settings.flags |= 4;
                        }
                        ConnectionsManager.getInstance(currentAccount).sendRequest(req1, (response, error) -> AndroidUtilities.runOnUIThread(() -> {
                            if (error != null && "SRP_ID_INVALID".equals(error.text)) {
                                TLRPC.TL_account_getPassword getPasswordReq = new TLRPC.TL_account_getPassword();
                                ConnectionsManager.getInstance(currentAccount).sendRequest(getPasswordReq, (response2, error2) -> AndroidUtilities.runOnUIThread(() -> {
                                    if (error2 == null) {
                                        currentPassword = (TLRPC.TL_account_password) response2;
                                        TwoStepVerificationActivity.initPasswordNewAlgo(currentPassword);
                                        generateNewSecret();
                                    }
                                }), ConnectionsManager.RequestFlagWithoutLogin);
                                return;
                            }
                            if (currentForm == null) {
                                currentForm = new TLRPC.TL_account_authorizationForm();
                            }
                            openRequestInterface();
                        }));
                    });
                }

                @Override
                public void run(final TLObject response, final TLRPC.TL_error error) {
                    if (error != null && "SRP_ID_INVALID".equals(error.text)) {
                        TLRPC.TL_account_getPassword getPasswordReq = new TLRPC.TL_account_getPassword();
                        ConnectionsManager.getInstance(currentAccount).sendRequest(getPasswordReq, (response2, error2) -> AndroidUtilities.runOnUIThread(() -> {
                            if (error2 == null) {
                                currentPassword = (TLRPC.TL_account_password) response2;
                                TwoStepVerificationActivity.initPasswordNewAlgo(currentPassword);
                                onPasswordDone(saved);
                            }
                        }), ConnectionsManager.RequestFlagWithoutLogin);
                        return;
                    }
                    if (error == null) {
                        Utilities.globalQueue.postRunnable(() -> {
                            TLRPC.TL_account_passwordSettings settings = (TLRPC.TL_account_passwordSettings) response;
                            byte[] secure_salt;
                            if (settings.secure_settings != null) {
                                secureSecret = settings.secure_settings.secure_secret;
                                secureSecretId = settings.secure_settings.secure_secret_id;
                                if (settings.secure_settings.secure_algo instanceof TLRPC.TL_securePasswordKdfAlgoSHA512) {
                                    TLRPC.TL_securePasswordKdfAlgoSHA512 algo = (TLRPC.TL_securePasswordKdfAlgoSHA512) settings.secure_settings.secure_algo;
                                    secure_salt = algo.salt;
                                    saltedPassword = Utilities.computeSHA512(secure_salt, AndroidUtilities.getStringBytes(textPassword), secure_salt);
                                } else if (settings.secure_settings.secure_algo instanceof TLRPC.TL_securePasswordKdfAlgoPBKDF2HMACSHA512iter100000) {
                                    TLRPC.TL_securePasswordKdfAlgoPBKDF2HMACSHA512iter100000 algo = (TLRPC.TL_securePasswordKdfAlgoPBKDF2HMACSHA512iter100000) settings.secure_settings.secure_algo;
                                    secure_salt = algo.salt;
                                    saltedPassword = Utilities.computePBKDF2(AndroidUtilities.getStringBytes(textPassword), algo.salt);
                                } else if (settings.secure_settings.secure_algo instanceof TLRPC.TL_securePasswordKdfAlgoUnknown) {
                                    AndroidUtilities.runOnUIThread(() -> AlertsCreator.showUpdateAppAlert(getParentActivity(), LocaleController.getString("UpdateAppAlert", R.string.UpdateAppAlert), true));
                                    return;
                                } else {
                                    secure_salt = new byte[0];
                                }
                            } else {
                                if (currentPassword.new_secure_algo instanceof TLRPC.TL_securePasswordKdfAlgoPBKDF2HMACSHA512iter100000) {
                                    TLRPC.TL_securePasswordKdfAlgoPBKDF2HMACSHA512iter100000 algo = (TLRPC.TL_securePasswordKdfAlgoPBKDF2HMACSHA512iter100000) currentPassword.new_secure_algo;
                                    secure_salt = algo.salt;
                                    saltedPassword = Utilities.computePBKDF2(AndroidUtilities.getStringBytes(textPassword), algo.salt);
                                } else {
                                    secure_salt = new byte[0];
                                }
                                secureSecret = null;
                                secureSecretId = 0;
                            }
                            AndroidUtilities.runOnUIThread(() -> {
                                currentEmail = settings.email;
                                if (saved) {
                                    saltedPassword = savedSaltedPassword;
                                }

                                if (!checkSecret(decryptSecret(secureSecret, saltedPassword), secureSecretId) || secure_salt.length == 0 || secureSecretId == 0) {
                                    if (saved) {
                                        UserConfig.getInstance(currentAccount).resetSavedPassword();
                                        usingSavedPassword = 0;
                                        updatePasswordInterface();
                                    } else {
                                        if (currentForm != null) {
                                            currentForm.values.clear();
                                            currentForm.errors.clear();
                                        }
                                        if (secureSecret == null || secureSecret.length == 0) {
                                            generateNewSecret();
                                        } else {
                                            resetSecret();
                                        }
                                    }
                                } else if (currentBotId == 0) {
                                    TLRPC.TL_account_getAllSecureValues req12 = new TLRPC.TL_account_getAllSecureValues();
                                    ConnectionsManager.getInstance(currentAccount).sendRequest(req12, (response1, error1) -> AndroidUtilities.runOnUIThread(() -> {
                                        if (response1 != null) {
                                            currentForm = new TLRPC.TL_account_authorizationForm();
                                            TLRPC.Vector vector = (TLRPC.Vector) response1;
                                            for (int a = 0, size = vector.objects.size(); a < size; a++) {
                                                currentForm.values.add((TLRPC.TL_secureValue) vector.objects.get(a));
                                            }
                                            openRequestInterface();
                                        } else {
                                            if ("APP_VERSION_OUTDATED".equals(error1.text)) {
                                                AlertsCreator.showUpdateAppAlert(getParentActivity(), LocaleController.getString("UpdateAppAlert", R.string.UpdateAppAlert), true);
                                            } else {
                                                showAlertWithText(LocaleController.getString("AppName", R.string.AppName), error1.text);
                                            }
                                            showEditDoneProgress(true, false);
                                        }
                                    }));
                                } else {
                                    openRequestInterface();
                                }
                            });
                        });
                    } else {
                        AndroidUtilities.runOnUIThread(() -> {
                            if (saved) {
                                UserConfig.getInstance(currentAccount).resetSavedPassword();
                                usingSavedPassword = 0;
                                updatePasswordInterface();
                                if (inputFieldContainers != null && inputFieldContainers[FIELD_PASSWORD].getVisibility() == View.VISIBLE) {
                                    inputFields[FIELD_PASSWORD].requestFocus();
                                    AndroidUtilities.showKeyboard(inputFields[FIELD_PASSWORD]);
                                }
                            } else {
                                showEditDoneProgress(true, false);
                                if (error.text.equals("PASSWORD_HASH_INVALID")) {
                                    onPasscodeError(true);
                                } else if (error.text.startsWith("FLOOD_WAIT")) {
                                    int time = Utilities.parseInt(error.text);
                                    String timeString;
                                    if (time < 60) {
                                        timeString = LocaleController.formatPluralString("Seconds", time);
                                    } else {
                                        timeString = LocaleController.formatPluralString("Minutes", time / 60);
                                    }
                                    showAlertWithText(LocaleController.getString("AppName", R.string.AppName), LocaleController.formatString("FloodWaitTime", R.string.FloodWaitTime, timeString));
                                } else {
                                    showAlertWithText(LocaleController.getString("AppName", R.string.AppName), error.text);
                                }
                            }
                        });
                    }
                }
            };

            if (currentPassword.current_algo instanceof TLRPC.TL_passwordKdfAlgoSHA256SHA256PBKDF2HMACSHA512iter100000SHA256ModPow) {
                TLRPC.TL_passwordKdfAlgoSHA256SHA256PBKDF2HMACSHA512iter100000SHA256ModPow algo = (TLRPC.TL_passwordKdfAlgoSHA256SHA256PBKDF2HMACSHA512iter100000SHA256ModPow) currentPassword.current_algo;
                req.password = SRPHelper.startCheck(x_bytes, currentPassword.srp_id, currentPassword.srp_B, algo);
                if (req.password == null) {
                    TLRPC.TL_error error = new TLRPC.TL_error();
                    error.text = "ALGO_INVALID";
                    requestDelegate.run(null, error);
                    return;
                }
                int reqId = ConnectionsManager.getInstance(currentAccount).sendRequest(req, requestDelegate, ConnectionsManager.RequestFlagFailOnServerErrors | ConnectionsManager.RequestFlagWithoutLogin);
                ConnectionsManager.getInstance(currentAccount).bindRequestToGuid(reqId, classGuid);
            } else {
                TLRPC.TL_error error = new TLRPC.TL_error();
                error.text = "PASSWORD_HASH_INVALID";
                requestDelegate.run(null, error);
            }
        });
    }

    private boolean isPersonalDocument(TLRPC.SecureValueType type) {
        return type instanceof TLRPC.TL_secureValueTypeDriverLicense ||
                type instanceof TLRPC.TL_secureValueTypePassport ||
                type instanceof TLRPC.TL_secureValueTypeInternalPassport ||
                type instanceof TLRPC.TL_secureValueTypeIdentityCard;
    }

    private boolean isAddressDocument(TLRPC.SecureValueType type) {
        return type instanceof TLRPC.TL_secureValueTypeUtilityBill ||
                type instanceof TLRPC.TL_secureValueTypeBankStatement ||
                type instanceof TLRPC.TL_secureValueTypePassportRegistration ||
                type instanceof TLRPC.TL_secureValueTypeTemporaryRegistration ||
                type instanceof TLRPC.TL_secureValueTypeRentalAgreement;
    }

    private void createRequestInterface(Context context) {
        TLRPC.User botUser = null;
        if (currentForm != null) {
            for (int a = 0; a < currentForm.users.size(); a++) {
                TLRPC.User user = currentForm.users.get(a);
                if (user.id == currentBotId) {
                    botUser = user;
                    break;
                }
            }
        }

        FrameLayout frameLayout = (FrameLayout) fragmentView;

        actionBar.setTitle(LocaleController.getString("TelegramPassport", R.string.TelegramPassport));

        actionBar.createMenu().addItem(info_item, R.drawable.profile_info);

        if (botUser != null) {
            FrameLayout avatarContainer = new FrameLayout(context);
            linearLayout2.addView(avatarContainer, LayoutHelper.createLinear(LayoutHelper.MATCH_PARENT, 100));

            BackupImageView avatarImageView = new BackupImageView(context);
            avatarImageView.setRoundRadius(AndroidUtilities.dp(32));
            avatarContainer.addView(avatarImageView, LayoutHelper.createFrame(64, 64, Gravity.CENTER, 0, 8, 0, 0));

            AvatarDrawable avatarDrawable = new AvatarDrawable(botUser);
            avatarImageView.setImage(ImageLocation.getForUser(botUser, false), "50_50", avatarDrawable, botUser);

            bottomCell = new TextInfoPrivacyCell(context);
            bottomCell.setBackgroundDrawable(Theme.getThemedDrawable(context, R.drawable.greydivider_top, Theme.key_windowBackgroundGrayShadow));
            bottomCell.setText(AndroidUtilities.replaceTags(LocaleController.formatString("PassportRequest", R.string.PassportRequest, UserObject.getFirstName(botUser))));
            bottomCell.getTextView().setGravity(Gravity.CENTER_HORIZONTAL);
            ((FrameLayout.LayoutParams) bottomCell.getTextView().getLayoutParams()).gravity = Gravity.CENTER_HORIZONTAL;
            linearLayout2.addView(bottomCell, LayoutHelper.createLinear(LayoutHelper.MATCH_PARENT, LayoutHelper.WRAP_CONTENT));
        }

        headerCell = new HeaderCell(context);
        headerCell.setText(LocaleController.getString("PassportRequestedInformation", R.string.PassportRequestedInformation));
        headerCell.setBackgroundColor(Theme.getColor(Theme.key_windowBackgroundWhite));
        linearLayout2.addView(headerCell, LayoutHelper.createLinear(LayoutHelper.MATCH_PARENT, LayoutHelper.WRAP_CONTENT));

        if (currentForm != null) {
            int size = currentForm.required_types.size();
            ArrayList<TLRPC.TL_secureRequiredType> personalDocuments = new ArrayList<>();
            ArrayList<TLRPC.TL_secureRequiredType> addressDocuments = new ArrayList<>();
            int personalCount = 0;
            int addressCount = 0;
            boolean hasPersonalInfo = false;
            boolean hasAddressInfo = false;
            for (int a = 0; a < size; a++) {
                TLRPC.SecureRequiredType secureRequiredType = currentForm.required_types.get(a);
                if (secureRequiredType instanceof TLRPC.TL_secureRequiredType) {
                    TLRPC.TL_secureRequiredType requiredType = (TLRPC.TL_secureRequiredType) secureRequiredType;
                    if (isPersonalDocument(requiredType.type)) {
                        personalDocuments.add(requiredType);
                        personalCount++;
                    } else if (isAddressDocument(requiredType.type)) {
                        addressDocuments.add(requiredType);
                        addressCount++;
                    } else if (requiredType.type instanceof TLRPC.TL_secureValueTypePersonalDetails) {
                        hasPersonalInfo = true;
                    } else if (requiredType.type instanceof TLRPC.TL_secureValueTypeAddress) {
                        hasAddressInfo = true;
                    }
                } else if (secureRequiredType instanceof TLRPC.TL_secureRequiredTypeOneOf) {
                    TLRPC.TL_secureRequiredTypeOneOf requiredTypeOneOf = (TLRPC.TL_secureRequiredTypeOneOf) secureRequiredType;
                    if (requiredTypeOneOf.types.isEmpty()) {
                        continue;
                    }
                    TLRPC.SecureRequiredType innerType = requiredTypeOneOf.types.get(0);
                    if (!(innerType instanceof TLRPC.TL_secureRequiredType)) {
                        continue;
                    }
                    TLRPC.TL_secureRequiredType requiredType = (TLRPC.TL_secureRequiredType) innerType;

                    if (isPersonalDocument(requiredType.type)) {
                        for (int b = 0, size2 = requiredTypeOneOf.types.size(); b < size2; b++) {
                            innerType = requiredTypeOneOf.types.get(b);
                            if (!(innerType instanceof TLRPC.TL_secureRequiredType)) {
                                continue;
                            }
                            personalDocuments.add((TLRPC.TL_secureRequiredType) innerType);
                        }
                        personalCount++;
                    } else if (isAddressDocument(requiredType.type)) {
                        for (int b = 0, size2 = requiredTypeOneOf.types.size(); b < size2; b++) {
                            innerType = requiredTypeOneOf.types.get(b);
                            if (!(innerType instanceof TLRPC.TL_secureRequiredType)) {
                                continue;
                            }
                            addressDocuments.add((TLRPC.TL_secureRequiredType) innerType);
                        }
                        addressCount++;
                    }
                }
            }
            boolean separatePersonal = !hasPersonalInfo || personalCount > 1;
            boolean separateAddress = !hasAddressInfo || addressCount > 1;
            for (int a = 0; a < size; a++) {
                TLRPC.SecureRequiredType secureRequiredType = currentForm.required_types.get(a);
                ArrayList<TLRPC.TL_secureRequiredType> documentTypes;
                TLRPC.TL_secureRequiredType requiredType;
                boolean documentOnly;
                if (secureRequiredType instanceof TLRPC.TL_secureRequiredType) {
                    requiredType = (TLRPC.TL_secureRequiredType) secureRequiredType;
                    if (requiredType.type instanceof TLRPC.TL_secureValueTypePhone || requiredType.type instanceof TLRPC.TL_secureValueTypeEmail) {
                        documentTypes = null;
                        documentOnly = false;
                    } else if (requiredType.type instanceof TLRPC.TL_secureValueTypePersonalDetails) {
                        if (separatePersonal) {
                            documentTypes = null;
                        } else {
                            documentTypes = personalDocuments;
                        }
                        documentOnly = false;
                    } else if (requiredType.type instanceof TLRPC.TL_secureValueTypeAddress) {
                        if (separateAddress) {
                            documentTypes = null;
                        } else {
                            documentTypes = addressDocuments;
                        }
                        documentOnly = false;
                    } else if (separatePersonal && isPersonalDocument(requiredType.type)) {
                        documentTypes = new ArrayList<>();
                        documentTypes.add(requiredType);
                        requiredType = new TLRPC.TL_secureRequiredType();
                        requiredType.type = new TLRPC.TL_secureValueTypePersonalDetails();
                        documentOnly = true;
                    } else if (separateAddress && isAddressDocument(requiredType.type)) {
                        documentTypes = new ArrayList<>();
                        documentTypes.add(requiredType);
                        requiredType = new TLRPC.TL_secureRequiredType();
                        requiredType.type = new TLRPC.TL_secureValueTypeAddress();
                        documentOnly = true;
                    } else {
                        continue;
                    }
                } else if (secureRequiredType instanceof TLRPC.TL_secureRequiredTypeOneOf) {
                    TLRPC.TL_secureRequiredTypeOneOf requiredTypeOneOf = (TLRPC.TL_secureRequiredTypeOneOf) secureRequiredType;
                    if (requiredTypeOneOf.types.isEmpty()) {
                        continue;
                    }
                    TLRPC.SecureRequiredType innerType = requiredTypeOneOf.types.get(0);
                    if (!(innerType instanceof TLRPC.TL_secureRequiredType)) {
                        continue;
                    }
                    requiredType = (TLRPC.TL_secureRequiredType) innerType;

                    if (separatePersonal && isPersonalDocument(requiredType.type) || separateAddress && isAddressDocument(requiredType.type)) {
                        documentTypes = new ArrayList<>();
                        for (int b = 0, size2 = requiredTypeOneOf.types.size(); b < size2; b++) {
                            innerType = requiredTypeOneOf.types.get(b);
                            if (!(innerType instanceof TLRPC.TL_secureRequiredType)) {
                                continue;
                            }
                            documentTypes.add((TLRPC.TL_secureRequiredType) innerType);
                        }
                        if (isPersonalDocument(requiredType.type)) {
                            requiredType = new TLRPC.TL_secureRequiredType();
                            requiredType.type = new TLRPC.TL_secureValueTypePersonalDetails();
                        } else {
                            requiredType = new TLRPC.TL_secureRequiredType();
                            requiredType.type = new TLRPC.TL_secureValueTypeAddress();
                        }

                        documentOnly = true;
                    } else {
                        continue;
                    }
                } else {
                    continue;
                }
                addField(context, requiredType, documentTypes, documentOnly, a == size - 1);
            }
        }

        if (botUser != null) {
            bottomCell = new TextInfoPrivacyCell(context);
            bottomCell.setBackgroundDrawable(Theme.getThemedDrawable(context, R.drawable.greydivider_bottom, Theme.key_windowBackgroundGrayShadow));
            bottomCell.setLinkTextColorKey(Theme.key_windowBackgroundWhiteGrayText4);
            if (!TextUtils.isEmpty(currentForm.privacy_policy_url)) {
                String str2 = LocaleController.formatString("PassportPolicy", R.string.PassportPolicy, UserObject.getFirstName(botUser), botUser.username);
                SpannableStringBuilder text = new SpannableStringBuilder(str2);
                int index1 = str2.indexOf('*');
                int index2 = str2.lastIndexOf('*');
                if (index1 != -1 && index2 != -1) {
                    bottomCell.getTextView().setMovementMethod(new AndroidUtilities.LinkMovementMethodMy());
                    text.replace(index2, index2 + 1, "");
                    text.replace(index1, index1 + 1, "");
                    text.setSpan(new LinkSpan(), index1, index2 - 1, Spanned.SPAN_EXCLUSIVE_EXCLUSIVE);
                }
                bottomCell.setText(text);
            } else {
                bottomCell.setText(AndroidUtilities.replaceTags(LocaleController.formatString("PassportNoPolicy", R.string.PassportNoPolicy, UserObject.getFirstName(botUser), botUser.username)));
            }
            bottomCell.getTextView().setHighlightColor(Theme.getColor(Theme.key_windowBackgroundWhiteGrayText4));
            bottomCell.getTextView().setGravity(Gravity.CENTER_HORIZONTAL);
            linearLayout2.addView(bottomCell, LayoutHelper.createLinear(LayoutHelper.MATCH_PARENT, LayoutHelper.WRAP_CONTENT));
        }

        bottomLayout = new FrameLayout(context);
        bottomLayout.setBackgroundDrawable(Theme.createSelectorWithBackgroundDrawable(Theme.getColor(Theme.key_passport_authorizeBackground), Theme.getColor(Theme.key_passport_authorizeBackgroundSelected)));
        frameLayout.addView(bottomLayout, LayoutHelper.createFrame(LayoutHelper.MATCH_PARENT, 48, Gravity.BOTTOM));
        bottomLayout.setOnClickListener(view -> {

            class ValueToSend {
                TLRPC.TL_secureValue value;
                boolean selfie_required;
                boolean translation_required;

                public ValueToSend(TLRPC.TL_secureValue v, boolean s, boolean t) {
                    value = v;
                    selfie_required = s;
                    translation_required = t;
                }
            }

            ArrayList<ValueToSend> valuesToSend = new ArrayList<>();
            for (int a = 0, size = currentForm.required_types.size(); a < size; a++) {

                TLRPC.TL_secureRequiredType requiredType;

                TLRPC.SecureRequiredType secureRequiredType = currentForm.required_types.get(a);
                if (secureRequiredType instanceof TLRPC.TL_secureRequiredType) {
                    requiredType = (TLRPC.TL_secureRequiredType) secureRequiredType;
                } else if (secureRequiredType instanceof TLRPC.TL_secureRequiredTypeOneOf) {
                    TLRPC.TL_secureRequiredTypeOneOf requiredTypeOneOf = (TLRPC.TL_secureRequiredTypeOneOf) secureRequiredType;
                    if (requiredTypeOneOf.types.isEmpty()) {
                        continue;
                    }
                    secureRequiredType = requiredTypeOneOf.types.get(0);
                    if (!(secureRequiredType instanceof TLRPC.TL_secureRequiredType)) {
                        continue;
                    }
                    requiredType = (TLRPC.TL_secureRequiredType) secureRequiredType;

                    for (int b = 0, size2 = requiredTypeOneOf.types.size(); b < size2; b++) {
                        secureRequiredType = requiredTypeOneOf.types.get(b);
                        if (!(secureRequiredType instanceof TLRPC.TL_secureRequiredType)) {
                            continue;
                        }
                        TLRPC.TL_secureRequiredType innerType = (TLRPC.TL_secureRequiredType) secureRequiredType;
                        if (getValueByType(innerType, true) != null) {
                            requiredType = innerType;
                            break;
                        }
                    }
                } else {
                    continue;
                }

                TLRPC.TL_secureValue value = getValueByType(requiredType, true);
                if (value == null) {
                    Vibrator v = (Vibrator) getParentActivity().getSystemService(Context.VIBRATOR_SERVICE);
                    if (v != null) {
                        v.vibrate(200);
                    }
                    AndroidUtilities.shakeView(getViewByType(requiredType), 2, 0);
                    return;
                }
                String key = getNameForType(requiredType.type);
                HashMap<String, String> errors = errorsMap.get(key);
                if (errors != null && !errors.isEmpty()) {
                    Vibrator v = (Vibrator) getParentActivity().getSystemService(Context.VIBRATOR_SERVICE);
                    if (v != null) {
                        v.vibrate(200);
                    }
                    AndroidUtilities.shakeView(getViewByType(requiredType), 2, 0);
                    return;
                }
                valuesToSend.add(new ValueToSend(value, requiredType.selfie_required, requiredType.translation_required));
            }
            showEditDoneProgress(false, true);
            TLRPC.TL_account_acceptAuthorization req = new TLRPC.TL_account_acceptAuthorization();
            req.bot_id = currentBotId;
            req.scope = currentScope;
            req.public_key = currentPublicKey;
            JSONObject jsonObject = new JSONObject();
            for (int a = 0, size = valuesToSend.size(); a < size; a++) {
                ValueToSend valueToSend = valuesToSend.get(a);
                TLRPC.TL_secureValue secureValue = valueToSend.value;

                JSONObject data = new JSONObject();

                if (secureValue.plain_data != null) {
                    if (secureValue.plain_data instanceof TLRPC.TL_securePlainEmail) {
                        TLRPC.TL_securePlainEmail securePlainEmail = (TLRPC.TL_securePlainEmail) secureValue.plain_data;
                    } else if (secureValue.plain_data instanceof TLRPC.TL_securePlainPhone) {
                        TLRPC.TL_securePlainPhone securePlainPhone = (TLRPC.TL_securePlainPhone) secureValue.plain_data;
                    }
                } else {
                    try {
                        JSONObject result = new JSONObject();
                        if (secureValue.data != null) {
                            byte[] decryptedSecret = decryptValueSecret(secureValue.data.secret, secureValue.data.data_hash);

                            data.put("data_hash", Base64.encodeToString(secureValue.data.data_hash, Base64.NO_WRAP));
                            data.put("secret", Base64.encodeToString(decryptedSecret, Base64.NO_WRAP));

                            result.put("data", data);
                        }
                        if (!secureValue.files.isEmpty()) {
                            JSONArray files = new JSONArray();
                            for (int b = 0, size2 = secureValue.files.size(); b < size2; b++) {
                                TLRPC.TL_secureFile secureFile = (TLRPC.TL_secureFile) secureValue.files.get(b);
                                byte[] decryptedSecret = decryptValueSecret(secureFile.secret, secureFile.file_hash);

                                JSONObject file = new JSONObject();
                                file.put("file_hash", Base64.encodeToString(secureFile.file_hash, Base64.NO_WRAP));
                                file.put("secret", Base64.encodeToString(decryptedSecret, Base64.NO_WRAP));
                                files.put(file);
                            }
                            result.put("files", files);
                        }
                        if (secureValue.front_side instanceof TLRPC.TL_secureFile) {
                            TLRPC.TL_secureFile secureFile = (TLRPC.TL_secureFile) secureValue.front_side;
                            byte[] decryptedSecret = decryptValueSecret(secureFile.secret, secureFile.file_hash);

                            JSONObject front = new JSONObject();
                            front.put("file_hash", Base64.encodeToString(secureFile.file_hash, Base64.NO_WRAP));
                            front.put("secret", Base64.encodeToString(decryptedSecret, Base64.NO_WRAP));
                            result.put("front_side", front);
                        }
                        if (secureValue.reverse_side instanceof TLRPC.TL_secureFile) {
                            TLRPC.TL_secureFile secureFile = (TLRPC.TL_secureFile) secureValue.reverse_side;
                            byte[] decryptedSecret = decryptValueSecret(secureFile.secret, secureFile.file_hash);

                            JSONObject reverse = new JSONObject();
                            reverse.put("file_hash", Base64.encodeToString(secureFile.file_hash, Base64.NO_WRAP));
                            reverse.put("secret", Base64.encodeToString(decryptedSecret, Base64.NO_WRAP));
                            result.put("reverse_side", reverse);
                        }
                        if (valueToSend.selfie_required && secureValue.selfie instanceof TLRPC.TL_secureFile) {
                            TLRPC.TL_secureFile secureFile = (TLRPC.TL_secureFile) secureValue.selfie;
                            byte[] decryptedSecret = decryptValueSecret(secureFile.secret, secureFile.file_hash);

                            JSONObject selfie = new JSONObject();
                            selfie.put("file_hash", Base64.encodeToString(secureFile.file_hash, Base64.NO_WRAP));
                            selfie.put("secret", Base64.encodeToString(decryptedSecret, Base64.NO_WRAP));
                            result.put("selfie", selfie);
                        }
                        if (valueToSend.translation_required && !secureValue.translation.isEmpty()) {
                            JSONArray translation = new JSONArray();
                            for (int b = 0, size2 = secureValue.translation.size(); b < size2; b++) {
                                TLRPC.TL_secureFile secureFile = (TLRPC.TL_secureFile) secureValue.translation.get(b);
                                byte[] decryptedSecret = decryptValueSecret(secureFile.secret, secureFile.file_hash);

                                JSONObject file = new JSONObject();
                                file.put("file_hash", Base64.encodeToString(secureFile.file_hash, Base64.NO_WRAP));
                                file.put("secret", Base64.encodeToString(decryptedSecret, Base64.NO_WRAP));
                                translation.put(file);
                            }
                            result.put("translation", translation);
                        }
                        jsonObject.put(getNameForType(secureValue.type), result);
                    } catch (Exception ignore) {

                    }
                }

                TLRPC.TL_secureValueHash hash = new TLRPC.TL_secureValueHash();
                hash.type = secureValue.type;
                hash.hash = secureValue.hash;
                req.value_hashes.add(hash);
            }
            JSONObject result = new JSONObject();
            try {
                result.put("secure_data", jsonObject);
            } catch (Exception ignore) {

            }
            if (currentPayload != null) {
                try {
                    result.put("payload", currentPayload);
                } catch (Exception ignore) {

                }
            }
            if (currentNonce != null) {
                try {
                    result.put("nonce", currentNonce);
                } catch (Exception ignore) {

                }
            }
            String json = result.toString();

            EncryptionResult encryptionResult = encryptData(AndroidUtilities.getStringBytes(json));

            req.credentials = new TLRPC.TL_secureCredentialsEncrypted();
            req.credentials.hash = encryptionResult.fileHash;
            req.credentials.data = encryptionResult.encryptedData;
            try {
                String key = currentPublicKey.replaceAll("\\n", "").replace("-----BEGIN PUBLIC KEY-----", "").replace("-----END PUBLIC KEY-----", "");
                KeyFactory kf = KeyFactory.getInstance("RSA");
                X509EncodedKeySpec keySpecX509 = new X509EncodedKeySpec(Base64.decode(key, Base64.DEFAULT));
                RSAPublicKey pubKey = (RSAPublicKey) kf.generatePublic(keySpecX509);

                Cipher c = Cipher.getInstance("RSA/NONE/OAEPWithSHA1AndMGF1Padding");
                c.init(Cipher.ENCRYPT_MODE, pubKey);
                req.credentials.secret = c.doFinal(encryptionResult.decrypyedFileSecret);
            } catch (Exception e) {
                FileLog.e(e);
            }
            int reqId = ConnectionsManager.getInstance(currentAccount).sendRequest(req, (response, error) -> AndroidUtilities.runOnUIThread(() -> {
                if (error == null) {
                    ignoreOnFailure = true;
                    callCallback(true);
                    finishFragment();
                } else {
                    showEditDoneProgress(false, false);
                    if ("APP_VERSION_OUTDATED".equals(error.text)) {
                        AlertsCreator.showUpdateAppAlert(getParentActivity(), LocaleController.getString("UpdateAppAlert", R.string.UpdateAppAlert), true);
                    } else {
                        showAlertWithText(LocaleController.getString("AppName", R.string.AppName), error.text);
                    }
                }
            }));
            ConnectionsManager.getInstance(currentAccount).bindRequestToGuid(reqId, classGuid);
        });

        acceptTextView = new TextView(context);
        acceptTextView.setCompoundDrawablePadding(AndroidUtilities.dp(8));
        acceptTextView.setCompoundDrawablesWithIntrinsicBounds(R.drawable.authorize, 0, 0, 0);
        acceptTextView.setTextColor(Theme.getColor(Theme.key_passport_authorizeText));
        acceptTextView.setText(LocaleController.getString("PassportAuthorize", R.string.PassportAuthorize));
        acceptTextView.setTextSize(TypedValue.COMPLEX_UNIT_DIP, 14);
        acceptTextView.setGravity(Gravity.CENTER);
        acceptTextView.setTypeface(AndroidUtilities.getTypeface("fonts/rmedium.ttf"));
        bottomLayout.addView(acceptTextView, LayoutHelper.createFrame(LayoutHelper.WRAP_CONTENT, LayoutHelper.MATCH_PARENT, Gravity.CENTER));

        progressViewButton = new ContextProgressView(context, 0);
        progressViewButton.setVisibility(View.INVISIBLE);
        bottomLayout.addView(progressViewButton, LayoutHelper.createFrame(LayoutHelper.MATCH_PARENT, LayoutHelper.MATCH_PARENT));

        View shadow = new View(context);
        shadow.setBackgroundResource(R.drawable.header_shadow_reverse);
        frameLayout.addView(shadow, LayoutHelper.createFrame(LayoutHelper.MATCH_PARENT, 3, Gravity.LEFT | Gravity.BOTTOM, 0, 0, 0, 48));
    }

    private void createManageInterface(Context context) {
        FrameLayout frameLayout = (FrameLayout) fragmentView;

        actionBar.setTitle(LocaleController.getString("TelegramPassport", R.string.TelegramPassport));

        actionBar.createMenu().addItem(info_item, R.drawable.profile_info);

        headerCell = new HeaderCell(context);
        headerCell.setText(LocaleController.getString("PassportProvidedInformation", R.string.PassportProvidedInformation));
        headerCell.setBackgroundColor(Theme.getColor(Theme.key_windowBackgroundWhite));
        linearLayout2.addView(headerCell, LayoutHelper.createLinear(LayoutHelper.MATCH_PARENT, LayoutHelper.WRAP_CONTENT));

        sectionCell = new ShadowSectionCell(context);
        sectionCell.setBackgroundDrawable(Theme.getThemedDrawable(context, R.drawable.greydivider, Theme.key_windowBackgroundGrayShadow));
        linearLayout2.addView(sectionCell, LayoutHelper.createLinear(LayoutHelper.MATCH_PARENT, LayoutHelper.WRAP_CONTENT));

        addDocumentCell = new TextSettingsCell(context);
        addDocumentCell.setBackgroundDrawable(Theme.getSelectorDrawable(true));
        addDocumentCell.setText(LocaleController.getString("PassportNoDocumentsAdd", R.string.PassportNoDocumentsAdd), true);
        linearLayout2.addView(addDocumentCell, LayoutHelper.createLinear(LayoutHelper.MATCH_PARENT, LayoutHelper.WRAP_CONTENT));
        addDocumentCell.setOnClickListener(v -> openAddDocumentAlert());

        deletePassportCell = new TextSettingsCell(context);
        deletePassportCell.setTextColor(Theme.getColor(Theme.key_windowBackgroundWhiteRedText3));
        deletePassportCell.setBackgroundDrawable(Theme.getSelectorDrawable(true));
        deletePassportCell.setText(LocaleController.getString("TelegramPassportDelete", R.string.TelegramPassportDelete), false);
        linearLayout2.addView(deletePassportCell, LayoutHelper.createLinear(LayoutHelper.MATCH_PARENT, LayoutHelper.WRAP_CONTENT));
        deletePassportCell.setOnClickListener(v -> {
            AlertDialog.Builder builder = new AlertDialog.Builder(getParentActivity());
            builder.setTitle(LocaleController.getString("TelegramPassportDeleteTitle", R.string.TelegramPassportDeleteTitle));
            builder.setMessage(LocaleController.getString("TelegramPassportDeleteAlert", R.string.TelegramPassportDeleteAlert));
            builder.setPositiveButton(LocaleController.getString("Delete", R.string.Delete), (dialog, which) -> {
                TLRPC.TL_account_deleteSecureValue req = new TLRPC.TL_account_deleteSecureValue();
                for (int a = 0; a < currentForm.values.size(); a++) {
                    req.types.add(currentForm.values.get(a).type);
                }
                needShowProgress();
                ConnectionsManager.getInstance(currentAccount).sendRequest(req, (response, error) -> AndroidUtilities.runOnUIThread(() -> {
                    for (int a = 0; a < linearLayout2.getChildCount(); a++) {
                        View child = linearLayout2.getChildAt(a);
                        if (child instanceof TextDetailSecureCell) {
                            linearLayout2.removeView(child);
                            a--;
                        }
                    }
                    needHideProgress();
                    typesViews.clear();
                    typesValues.clear();
                    currentForm.values.clear();
                    updateManageVisibility();
                }));
            });
            builder.setNegativeButton(LocaleController.getString("Cancel", R.string.Cancel), null);
            AlertDialog alertDialog = builder.create();
            showDialog(alertDialog);
            TextView button = (TextView) alertDialog.getButton(DialogInterface.BUTTON_POSITIVE);
            if (button != null) {
                button.setTextColor(Theme.getColor(Theme.key_dialogTextRed2));
            }
        });

        addDocumentSectionCell = new ShadowSectionCell(context);
        addDocumentSectionCell.setBackgroundDrawable(Theme.getThemedDrawable(context, R.drawable.greydivider_bottom, Theme.key_windowBackgroundGrayShadow));
        linearLayout2.addView(addDocumentSectionCell, LayoutHelper.createLinear(LayoutHelper.MATCH_PARENT, LayoutHelper.WRAP_CONTENT));

        emptyLayout = new LinearLayout(context);
        emptyLayout.setOrientation(LinearLayout.VERTICAL);
        emptyLayout.setGravity(Gravity.CENTER);
        emptyLayout.setBackgroundDrawable(Theme.getThemedDrawable(context, R.drawable.greydivider_bottom, Theme.key_windowBackgroundGrayShadow));
        if (AndroidUtilities.isTablet()) {
            linearLayout2.addView(emptyLayout, new LinearLayout.LayoutParams(LayoutHelper.MATCH_PARENT, AndroidUtilities.dp(528) - ActionBar.getCurrentActionBarHeight()));
        } else {
            linearLayout2.addView(emptyLayout, new LinearLayout.LayoutParams(LayoutHelper.MATCH_PARENT, AndroidUtilities.displaySize.y - ActionBar.getCurrentActionBarHeight()));
        }

        emptyImageView = new ImageView(context);
        emptyImageView.setImageResource(R.drawable.no_passport);
        emptyImageView.setColorFilter(new PorterDuffColorFilter(Theme.getColor(Theme.key_sessions_devicesImage), PorterDuff.Mode.MULTIPLY));
        emptyLayout.addView(emptyImageView, LayoutHelper.createLinear(LayoutHelper.WRAP_CONTENT, LayoutHelper.WRAP_CONTENT));

        emptyTextView1 = new TextView(context);
        emptyTextView1.setTextColor(Theme.getColor(Theme.key_windowBackgroundWhiteGrayText2));
        emptyTextView1.setGravity(Gravity.CENTER);
        emptyTextView1.setTextSize(TypedValue.COMPLEX_UNIT_DIP, 15);
        emptyTextView1.setTypeface(AndroidUtilities.getTypeface("fonts/rmedium.ttf"));
        emptyTextView1.setText(LocaleController.getString("PassportNoDocuments", R.string.PassportNoDocuments));
        emptyLayout.addView(emptyTextView1, LayoutHelper.createLinear(LayoutHelper.WRAP_CONTENT, LayoutHelper.WRAP_CONTENT, Gravity.CENTER, 0, 16, 0, 0));

        emptyTextView2 = new TextView(context);
        emptyTextView2.setTextColor(Theme.getColor(Theme.key_windowBackgroundWhiteGrayText2));
        emptyTextView2.setGravity(Gravity.CENTER);
        emptyTextView2.setTextSize(TypedValue.COMPLEX_UNIT_DIP, 14);
        emptyTextView2.setPadding(AndroidUtilities.dp(20), 0, AndroidUtilities.dp(20), 0);
        emptyTextView2.setText(LocaleController.getString("PassportNoDocumentsInfo", R.string.PassportNoDocumentsInfo));
        emptyLayout.addView(emptyTextView2, LayoutHelper.createLinear(LayoutHelper.WRAP_CONTENT, LayoutHelper.WRAP_CONTENT, Gravity.CENTER, 0, 14, 0, 0));

        emptyTextView3 = new TextView(context);
        emptyTextView3.setTextColor(Theme.getColor(Theme.key_windowBackgroundWhiteBlueText4));
        emptyTextView3.setGravity(Gravity.CENTER);
        emptyTextView3.setTextSize(TypedValue.COMPLEX_UNIT_DIP, 15);
        emptyTextView3.setTypeface(AndroidUtilities.getTypeface("fonts/rmedium.ttf"));
        emptyTextView3.setGravity(Gravity.CENTER);
        emptyTextView3.setText(LocaleController.getString("PassportNoDocumentsAdd", R.string.PassportNoDocumentsAdd).toUpperCase());
        emptyLayout.addView(emptyTextView3, LayoutHelper.createLinear(LayoutHelper.WRAP_CONTENT, 30, Gravity.CENTER, 0, 16, 0, 0));
        emptyTextView3.setOnClickListener(v -> openAddDocumentAlert());

        for (int a = 0, size = currentForm.values.size(); a < size; a++) {
            TLRPC.TL_secureValue value = currentForm.values.get(a);
            TLRPC.TL_secureRequiredType requiredType;
            ArrayList<TLRPC.TL_secureRequiredType> documentTypes;
            boolean documentOnly;
            if (isPersonalDocument(value.type)) {
                documentTypes = new ArrayList<>();
                requiredType = new TLRPC.TL_secureRequiredType();
                requiredType.type = value.type;
                requiredType.selfie_required = true;
                requiredType.translation_required = true;
                documentTypes.add(requiredType);
                requiredType = new TLRPC.TL_secureRequiredType();
                requiredType.type = new TLRPC.TL_secureValueTypePersonalDetails();
                documentOnly = true;
            } else if (isAddressDocument(value.type)) {
                documentTypes = new ArrayList<>();
                requiredType = new TLRPC.TL_secureRequiredType();
                requiredType.type = value.type;
                requiredType.translation_required = true;
                documentTypes.add(requiredType);
                requiredType = new TLRPC.TL_secureRequiredType();
                requiredType.type = new TLRPC.TL_secureValueTypeAddress();
                documentOnly = true;
            } else {
                requiredType = new TLRPC.TL_secureRequiredType();
                requiredType.type = value.type;
                documentTypes = null;
                documentOnly = false;
            }
            addField(context, requiredType, documentTypes, documentOnly, a == size - 1);
        }

        updateManageVisibility();
    }

    private boolean hasNotValueForType(Class<? extends TLRPC.SecureValueType> type) {
        for (int a = 0, count = currentForm.values.size(); a < count; a++) {
            if (currentForm.values.get(a).type.getClass() == type) {
                return false;
            }
        }
        return true;
    }

    private boolean hasUnfilledValues() {
        return hasNotValueForType(TLRPC.TL_secureValueTypePhone.class) ||
                hasNotValueForType(TLRPC.TL_secureValueTypeEmail.class) ||
                hasNotValueForType(TLRPC.TL_secureValueTypePersonalDetails.class) ||
                hasNotValueForType(TLRPC.TL_secureValueTypePassport.class) ||
                hasNotValueForType(TLRPC.TL_secureValueTypeInternalPassport.class) ||
                hasNotValueForType(TLRPC.TL_secureValueTypeIdentityCard.class) ||
                hasNotValueForType(TLRPC.TL_secureValueTypeDriverLicense.class) ||
                hasNotValueForType(TLRPC.TL_secureValueTypeAddress.class) ||
                hasNotValueForType(TLRPC.TL_secureValueTypeUtilityBill.class) ||
                hasNotValueForType(TLRPC.TL_secureValueTypePassportRegistration.class) ||
                hasNotValueForType(TLRPC.TL_secureValueTypeTemporaryRegistration.class) ||
                hasNotValueForType(TLRPC.TL_secureValueTypeBankStatement.class) ||
                hasNotValueForType(TLRPC.TL_secureValueTypeRentalAgreement.class);
    }

    private void openAddDocumentAlert() {
        ArrayList<CharSequence> values = new ArrayList<>();
        final ArrayList<Class<? extends TLRPC.SecureValueType>> types = new ArrayList<>();

        if (hasNotValueForType(TLRPC.TL_secureValueTypePhone.class)) {
            values.add(LocaleController.getString("ActionBotDocumentPhone", R.string.ActionBotDocumentPhone));
            types.add(TLRPC.TL_secureValueTypePhone.class);
        }
        if (hasNotValueForType(TLRPC.TL_secureValueTypeEmail.class)) {
            values.add(LocaleController.getString("ActionBotDocumentEmail", R.string.ActionBotDocumentEmail));
            types.add(TLRPC.TL_secureValueTypeEmail.class);
        }
        if (hasNotValueForType(TLRPC.TL_secureValueTypePersonalDetails.class)) {
            values.add(LocaleController.getString("ActionBotDocumentIdentity", R.string.ActionBotDocumentIdentity));
            types.add(TLRPC.TL_secureValueTypePersonalDetails.class);
        }
        if (hasNotValueForType(TLRPC.TL_secureValueTypePassport.class)) {
            values.add(LocaleController.getString("ActionBotDocumentPassport", R.string.ActionBotDocumentPassport));
            types.add(TLRPC.TL_secureValueTypePassport.class);
        }
        if (hasNotValueForType(TLRPC.TL_secureValueTypeInternalPassport.class)) {
            values.add(LocaleController.getString("ActionBotDocumentInternalPassport", R.string.ActionBotDocumentInternalPassport));
            types.add(TLRPC.TL_secureValueTypeInternalPassport.class);
        }
        if (hasNotValueForType(TLRPC.TL_secureValueTypePassportRegistration.class)) {
            values.add(LocaleController.getString("ActionBotDocumentPassportRegistration", R.string.ActionBotDocumentPassportRegistration));
            types.add(TLRPC.TL_secureValueTypePassportRegistration.class);
        }
        if (hasNotValueForType(TLRPC.TL_secureValueTypeTemporaryRegistration.class)) {
            values.add(LocaleController.getString("ActionBotDocumentTemporaryRegistration", R.string.ActionBotDocumentTemporaryRegistration));
            types.add(TLRPC.TL_secureValueTypeTemporaryRegistration.class);
        }
        if (hasNotValueForType(TLRPC.TL_secureValueTypeIdentityCard.class)) {
            values.add(LocaleController.getString("ActionBotDocumentIdentityCard", R.string.ActionBotDocumentIdentityCard));
            types.add(TLRPC.TL_secureValueTypeIdentityCard.class);
        }
        if (hasNotValueForType(TLRPC.TL_secureValueTypeDriverLicense.class)) {
            values.add(LocaleController.getString("ActionBotDocumentDriverLicence", R.string.ActionBotDocumentDriverLicence));
            types.add(TLRPC.TL_secureValueTypeDriverLicense.class);
        }
        if (hasNotValueForType(TLRPC.TL_secureValueTypeAddress.class)) {
            values.add(LocaleController.getString("ActionBotDocumentAddress", R.string.ActionBotDocumentAddress));
            types.add(TLRPC.TL_secureValueTypeAddress.class);
        }
        if (hasNotValueForType(TLRPC.TL_secureValueTypeUtilityBill.class)) {
            values.add(LocaleController.getString("ActionBotDocumentUtilityBill", R.string.ActionBotDocumentUtilityBill));
            types.add(TLRPC.TL_secureValueTypeUtilityBill.class);
        }
        if (hasNotValueForType(TLRPC.TL_secureValueTypeBankStatement.class)) {
            values.add(LocaleController.getString("ActionBotDocumentBankStatement", R.string.ActionBotDocumentBankStatement));
            types.add(TLRPC.TL_secureValueTypeBankStatement.class);
        }
        if (hasNotValueForType(TLRPC.TL_secureValueTypeRentalAgreement.class)) {
            values.add(LocaleController.getString("ActionBotDocumentRentalAgreement", R.string.ActionBotDocumentRentalAgreement));
            types.add(TLRPC.TL_secureValueTypeRentalAgreement.class);
        }

        if (getParentActivity() == null || values.isEmpty()) {
            return;
        }
        AlertDialog.Builder builder = new AlertDialog.Builder(getParentActivity());
        builder.setTitle(LocaleController.getString("PassportNoDocumentsAdd", R.string.PassportNoDocumentsAdd));
        builder.setItems(values.toArray(new CharSequence[0]), (dialog, which) -> {
            TLRPC.TL_secureRequiredType requiredType = null;
            TLRPC.TL_secureRequiredType documentRequiredType = null;
            try {
                requiredType = new TLRPC.TL_secureRequiredType();
                requiredType.type = types.get(which).newInstance();
            } catch (Exception ignore) {

            }

            if (isPersonalDocument(requiredType.type)) {
                documentRequiredType = requiredType;
                documentRequiredType.selfie_required = true;
                documentRequiredType.translation_required = true;
                requiredType = new TLRPC.TL_secureRequiredType();
                requiredType.type = new TLRPC.TL_secureValueTypePersonalDetails();
            } else if (isAddressDocument(requiredType.type)) {
                documentRequiredType = requiredType;
                requiredType = new TLRPC.TL_secureRequiredType();
                requiredType.type = new TLRPC.TL_secureValueTypeAddress();
            }

            openTypeActivity(requiredType, documentRequiredType, new ArrayList<>(), documentRequiredType != null);
        });
        showDialog(builder.create());
    }

    private void updateManageVisibility() {
        if (currentForm.values.isEmpty()) {
            emptyLayout.setVisibility(View.VISIBLE);
            sectionCell.setVisibility(View.GONE);
            headerCell.setVisibility(View.GONE);
            addDocumentCell.setVisibility(View.GONE);
            deletePassportCell.setVisibility(View.GONE);
            addDocumentSectionCell.setVisibility(View.GONE);
        } else {
            emptyLayout.setVisibility(View.GONE);
            sectionCell.setVisibility(View.VISIBLE);
            headerCell.setVisibility(View.VISIBLE);
            deletePassportCell.setVisibility(View.VISIBLE);
            addDocumentSectionCell.setVisibility(View.VISIBLE);

            if (hasUnfilledValues()) {
                addDocumentCell.setVisibility(View.VISIBLE);
            } else {
                addDocumentCell.setVisibility(View.GONE);
            }
        }
    }

    private void callCallback(boolean success) {
        if (!callbackCalled) {
            if (!TextUtils.isEmpty(currentCallbackUrl)) {
                if (success) {
                    Browser.openUrl(getParentActivity(), Uri.parse(currentCallbackUrl + "&tg_passport=success"));
                } else if (!ignoreOnFailure && (currentActivityType == TYPE_PASSWORD || currentActivityType == TYPE_REQUEST)) {
                    Browser.openUrl(getParentActivity(), Uri.parse(currentCallbackUrl + "&tg_passport=cancel"));
                }
                callbackCalled = true;
            } else if (needActivityResult) {
                if (success || (!ignoreOnFailure && (currentActivityType == TYPE_PASSWORD || currentActivityType == TYPE_REQUEST))) {
                    getParentActivity().setResult(success ? Activity.RESULT_OK : Activity.RESULT_CANCELED);
                }
                callbackCalled = true;
            }
        }
    }

    private void createEmailInterface(Context context) {
        actionBar.setTitle(LocaleController.getString("PassportEmail", R.string.PassportEmail));

        if (!TextUtils.isEmpty(currentEmail)) {
            TextSettingsCell settingsCell1 = new TextSettingsCell(context);
            settingsCell1.setTextColor(Theme.getColor(Theme.key_windowBackgroundWhiteBlueText4));
            settingsCell1.setBackgroundDrawable(Theme.getSelectorDrawable(true));
            settingsCell1.setText(LocaleController.formatString("PassportPhoneUseSame", R.string.PassportPhoneUseSame, currentEmail), false);
            linearLayout2.addView(settingsCell1, LayoutHelper.createLinear(LayoutHelper.MATCH_PARENT, LayoutHelper.WRAP_CONTENT));
            settingsCell1.setOnClickListener(v -> {
                useCurrentValue = true;
                doneItem.callOnClick();
                useCurrentValue = false;
            });

            bottomCell = new TextInfoPrivacyCell(context);
            bottomCell.setBackgroundDrawable(Theme.getThemedDrawable(context, R.drawable.greydivider_bottom, Theme.key_windowBackgroundGrayShadow));
            bottomCell.setText(LocaleController.getString("PassportPhoneUseSameEmailInfo", R.string.PassportPhoneUseSameEmailInfo));
            linearLayout2.addView(bottomCell, LayoutHelper.createLinear(LayoutHelper.MATCH_PARENT, LayoutHelper.WRAP_CONTENT));
        }

        inputFields = new EditTextBoldCursor[1];
        for (int a = 0; a < 1; a++) {
            ViewGroup container = new FrameLayout(context);
            linearLayout2.addView(container, LayoutHelper.createLinear(LayoutHelper.MATCH_PARENT, 50));
            container.setBackgroundColor(Theme.getColor(Theme.key_windowBackgroundWhite));

            inputFields[a] = new EditTextBoldCursor(context);
            inputFields[a].setTag(a);
            inputFields[a].setTextSize(TypedValue.COMPLEX_UNIT_DIP, 16);
            inputFields[a].setHintTextColor(Theme.getColor(Theme.key_windowBackgroundWhiteHintText));
            inputFields[a].setTextColor(Theme.getColor(Theme.key_windowBackgroundWhiteBlackText));
            inputFields[a].setBackgroundDrawable(null);
            inputFields[a].setCursorColor(Theme.getColor(Theme.key_windowBackgroundWhiteBlackText));
            inputFields[a].setCursorSize(AndroidUtilities.dp(20));
            inputFields[a].setCursorWidth(1.5f);
            inputFields[a].setInputType(EditorInfo.TYPE_CLASS_TEXT | EditorInfo.TYPE_TEXT_VARIATION_EMAIL_ADDRESS);
            inputFields[a].setImeOptions(EditorInfo.IME_ACTION_DONE | EditorInfo.IME_FLAG_NO_EXTRACT_UI);
            inputFields[a].setHint(LocaleController.getString("PaymentShippingEmailPlaceholder", R.string.PaymentShippingEmailPlaceholder));
            if (currentTypeValue != null && currentTypeValue.plain_data instanceof TLRPC.TL_securePlainEmail) {
                TLRPC.TL_securePlainEmail securePlainEmail = (TLRPC.TL_securePlainEmail) currentTypeValue.plain_data;
                if (!TextUtils.isEmpty(securePlainEmail.email)) {
                    inputFields[a].setText(securePlainEmail.email);
                }
            }
            inputFields[a].setSelection(inputFields[a].length());
            inputFields[a].setPadding(0, 0, 0, AndroidUtilities.dp(6));
            inputFields[a].setGravity(LocaleController.isRTL ? Gravity.RIGHT : Gravity.LEFT);
            container.addView(inputFields[a], LayoutHelper.createFrame(LayoutHelper.MATCH_PARENT, LayoutHelper.WRAP_CONTENT, Gravity.LEFT | Gravity.TOP, 21, 12, 21, 6));

            inputFields[a].setOnEditorActionListener((textView, i, keyEvent) -> {
                if (i == EditorInfo.IME_ACTION_DONE || i == EditorInfo.IME_ACTION_NEXT) {
                    doneItem.callOnClick();
                    return true;
                }
                return false;
            });
        }

        bottomCell = new TextInfoPrivacyCell(context);
        bottomCell.setBackgroundDrawable(Theme.getThemedDrawable(context, R.drawable.greydivider_bottom, Theme.key_windowBackgroundGrayShadow));
        bottomCell.setText(LocaleController.getString("PassportEmailUploadInfo", R.string.PassportEmailUploadInfo));
        linearLayout2.addView(bottomCell, LayoutHelper.createLinear(LayoutHelper.MATCH_PARENT, LayoutHelper.WRAP_CONTENT));
    }

    private void createPhoneInterface(Context context) {
        actionBar.setTitle(LocaleController.getString("PassportPhone", R.string.PassportPhone));

        languageMap = new HashMap<>();
        try {
            BufferedReader reader = new BufferedReader(new InputStreamReader(context.getResources().getAssets().open("countries.txt")));
            String line;
            while ((line = reader.readLine()) != null) {
                String[] args = line.split(";");
                countriesArray.add(0, args[2]);
                countriesMap.put(args[2], args[0]);
                codesMap.put(args[0], args[2]);
                if (args.length > 3) {
                    phoneFormatMap.put(args[0], args[3]);
                }
                languageMap.put(args[1], args[2]);
            }
            reader.close();
        } catch (Exception e) {
            FileLog.e(e);
        }

        Collections.sort(countriesArray, String::compareTo);

        String currentPhone = UserConfig.getInstance(currentAccount).getCurrentUser().phone;
        TextSettingsCell settingsCell1 = new TextSettingsCell(context);
        settingsCell1.setTextColor(Theme.getColor(Theme.key_windowBackgroundWhiteBlueText4));
        settingsCell1.setBackgroundDrawable(Theme.getSelectorDrawable(true));
        settingsCell1.setText(LocaleController.formatString("PassportPhoneUseSame", R.string.PassportPhoneUseSame, PhoneFormat.getInstance().format("+" + currentPhone)), false);
        linearLayout2.addView(settingsCell1, LayoutHelper.createLinear(LayoutHelper.MATCH_PARENT, LayoutHelper.WRAP_CONTENT));
        settingsCell1.setOnClickListener(v -> {
            useCurrentValue = true;
            doneItem.callOnClick();
            useCurrentValue = false;
        });

        bottomCell = new TextInfoPrivacyCell(context);
        bottomCell.setBackgroundDrawable(Theme.getThemedDrawable(context, R.drawable.greydivider_bottom, Theme.key_windowBackgroundGrayShadow));
        bottomCell.setText(LocaleController.getString("PassportPhoneUseSameInfo", R.string.PassportPhoneUseSameInfo));
        linearLayout2.addView(bottomCell, LayoutHelper.createLinear(LayoutHelper.MATCH_PARENT, LayoutHelper.WRAP_CONTENT));

        headerCell = new HeaderCell(context);
        headerCell.setText(LocaleController.getString("PassportPhoneUseOther", R.string.PassportPhoneUseOther));
        headerCell.setBackgroundColor(Theme.getColor(Theme.key_windowBackgroundWhite));
        linearLayout2.addView(headerCell, LayoutHelper.createLinear(LayoutHelper.MATCH_PARENT, LayoutHelper.WRAP_CONTENT));

        inputFields = new EditTextBoldCursor[3];
        for (int a = 0; a < 3; a++) {

            if (a == FIELD_PHONE) {
                inputFields[a] = new HintEditText(context);
            } else {
                inputFields[a] = new EditTextBoldCursor(context);
            }

            ViewGroup container;
            if (a == FIELD_PHONECODE) {
                container = new LinearLayout(context);
                ((LinearLayout) container).setOrientation(LinearLayout.HORIZONTAL);
                linearLayout2.addView(container, LayoutHelper.createLinear(LayoutHelper.MATCH_PARENT, 50));
                container.setBackgroundColor(Theme.getColor(Theme.key_windowBackgroundWhite));
            } else if (a == FIELD_PHONE) {
                container = (ViewGroup) inputFields[FIELD_PHONECODE].getParent();
            } else {
                container = new FrameLayout(context);
                linearLayout2.addView(container, LayoutHelper.createLinear(LayoutHelper.MATCH_PARENT, 50));
                container.setBackgroundColor(Theme.getColor(Theme.key_windowBackgroundWhite));
            }

            inputFields[a].setTag(a);
            inputFields[a].setTextSize(TypedValue.COMPLEX_UNIT_DIP, 16);
            inputFields[a].setHintTextColor(Theme.getColor(Theme.key_windowBackgroundWhiteHintText));
            inputFields[a].setTextColor(Theme.getColor(Theme.key_windowBackgroundWhiteBlackText));
            inputFields[a].setBackgroundDrawable(null);
            inputFields[a].setCursorColor(Theme.getColor(Theme.key_windowBackgroundWhiteBlackText));
            inputFields[a].setCursorSize(AndroidUtilities.dp(20));
            inputFields[a].setCursorWidth(1.5f);
            if (a == FIELD_PHONECOUNTRY) {
                inputFields[a].setOnTouchListener((v, event) -> {
                    if (getParentActivity() == null) {
                        return false;
                    }
                    if (event.getAction() == MotionEvent.ACTION_UP) {
                        CountrySelectActivity fragment = new CountrySelectActivity(false);
                        fragment.setCountrySelectActivityDelegate((name, shortName) -> {
                            inputFields[FIELD_PHONECOUNTRY].setText(name);
                            int index = countriesArray.indexOf(name);
                            if (index != -1) {
                                ignoreOnTextChange = true;
                                String code = countriesMap.get(name);
                                inputFields[FIELD_PHONECODE].setText(code);
                                String hint = phoneFormatMap.get(code);
                                inputFields[FIELD_PHONE].setHintText(hint != null ? hint.replace('X', '–') : null);
                                ignoreOnTextChange = false;
                            }
                            AndroidUtilities.runOnUIThread(() -> AndroidUtilities.showKeyboard(inputFields[FIELD_PHONE]), 300);
                            inputFields[FIELD_PHONE].requestFocus();
                            inputFields[FIELD_PHONE].setSelection(inputFields[FIELD_PHONE].length());
                        });
                        presentFragment(fragment);
                    }
                    return true;
                });
                inputFields[a].setText(LocaleController.getString("ChooseCountry", R.string.ChooseCountry));
                inputFields[a].setInputType(0);
                inputFields[a].setFocusable(false);
            } else {
                inputFields[a].setInputType(InputType.TYPE_CLASS_PHONE);
                if (a == FIELD_PHONE) {
                    inputFields[a].setImeOptions(EditorInfo.IME_ACTION_DONE | EditorInfo.IME_FLAG_NO_EXTRACT_UI);
                } else {
                    inputFields[a].setImeOptions(EditorInfo.IME_ACTION_NEXT | EditorInfo.IME_FLAG_NO_EXTRACT_UI);
                }
            }
            inputFields[a].setSelection(inputFields[a].length());

            if (a == FIELD_PHONECODE) {
                plusTextView = new TextView(context);
                plusTextView.setText("+");
                plusTextView.setTextColor(Theme.getColor(Theme.key_windowBackgroundWhiteBlackText));
                plusTextView.setTextSize(TypedValue.COMPLEX_UNIT_DIP, 16);
                container.addView(plusTextView, LayoutHelper.createLinear(LayoutHelper.WRAP_CONTENT, LayoutHelper.WRAP_CONTENT, 21, 12, 0, 6));

                inputFields[a].setPadding(AndroidUtilities.dp(10), 0, 0, 0);
                InputFilter[] inputFilters = new InputFilter[1];
                inputFilters[0] = new InputFilter.LengthFilter(5);
                inputFields[a].setFilters(inputFilters);
                inputFields[a].setGravity(Gravity.LEFT | Gravity.CENTER_VERTICAL);
                container.addView(inputFields[a], LayoutHelper.createLinear(55, LayoutHelper.WRAP_CONTENT, 0, 12, 16, 6));
                inputFields[a].addTextChangedListener(new TextWatcher() {
                    @Override
                    public void beforeTextChanged(CharSequence charSequence, int i, int i2, int i3) {

                    }

                    @Override
                    public void onTextChanged(CharSequence charSequence, int i, int i2, int i3) {

                    }

                    @Override
                    public void afterTextChanged(Editable editable) {
                        if (ignoreOnTextChange) {
                            return;
                        }
                        ignoreOnTextChange = true;
                        String text = PhoneFormat.stripExceptNumbers(inputFields[FIELD_PHONECODE].getText().toString());
                        inputFields[FIELD_PHONECODE].setText(text);
                        HintEditText phoneField = (HintEditText) inputFields[FIELD_PHONE];
                        if (text.length() == 0) {
                            phoneField.setHintText(null);
                            phoneField.setHint(LocaleController.getString("PaymentShippingPhoneNumber", R.string.PaymentShippingPhoneNumber));
                            inputFields[FIELD_PHONECOUNTRY].setText(LocaleController.getString("ChooseCountry", R.string.ChooseCountry));
                        } else {
                            String country;
                            boolean ok = false;
                            String textToSet = null;
                            if (text.length() > 4) {
                                for (int a = 4; a >= 1; a--) {
                                    String sub = text.substring(0, a);
                                    country = codesMap.get(sub);
                                    if (country != null) {
                                        ok = true;
                                        textToSet = text.substring(a) + inputFields[FIELD_PHONE].getText().toString();
                                        inputFields[FIELD_PHONECODE].setText(text = sub);
                                        break;
                                    }
                                }
                                if (!ok) {
                                    textToSet = text.substring(1) + inputFields[FIELD_PHONE].getText().toString();
                                    inputFields[FIELD_PHONECODE].setText(text = text.substring(0, 1));
                                }
                            }
                            country = codesMap.get(text);
                            boolean set = false;
                            if (country != null) {
                                int index = countriesArray.indexOf(country);
                                if (index != -1) {
                                    inputFields[FIELD_PHONECOUNTRY].setText(countriesArray.get(index));
                                    String hint = phoneFormatMap.get(text);
                                    set = true;
                                    if (hint != null) {
                                        phoneField.setHintText(hint.replace('X', '–'));
                                        phoneField.setHint(null);
                                    }
                                }
                            }
                            if (!set) {
                                phoneField.setHintText(null);
                                phoneField.setHint(LocaleController.getString("PaymentShippingPhoneNumber", R.string.PaymentShippingPhoneNumber));
                                inputFields[FIELD_PHONECOUNTRY].setText(LocaleController.getString("WrongCountry", R.string.WrongCountry));
                            }
                            if (!ok) {
                                inputFields[FIELD_PHONECODE].setSelection(inputFields[FIELD_PHONECODE].getText().length());
                            }
                            if (textToSet != null) {
                                phoneField.requestFocus();
                                phoneField.setText(textToSet);
                                phoneField.setSelection(phoneField.length());
                            }
                        }
                        ignoreOnTextChange = false;
                    }
                });
            } else if (a == FIELD_PHONE) {
                inputFields[a].setPadding(0, 0, 0, 0);
                inputFields[a].setGravity(Gravity.LEFT | Gravity.CENTER_VERTICAL);
                inputFields[a].setHintText(null);
                inputFields[a].setHint(LocaleController.getString("PaymentShippingPhoneNumber", R.string.PaymentShippingPhoneNumber));
                container.addView(inputFields[a], LayoutHelper.createLinear(LayoutHelper.MATCH_PARENT, LayoutHelper.WRAP_CONTENT, 0, 12, 21, 6));
                inputFields[a].addTextChangedListener(new TextWatcher() {
                    private int characterAction = -1;
                    private int actionPosition;

                    @Override
                    public void beforeTextChanged(CharSequence s, int start, int count, int after) {
                        if (count == 0 && after == 1) {
                            characterAction = 1;
                        } else if (count == 1 && after == 0) {
                            if (s.charAt(start) == ' ' && start > 0) {
                                characterAction = 3;
                                actionPosition = start - 1;
                            } else {
                                characterAction = 2;
                            }
                        } else {
                            characterAction = -1;
                        }
                    }

                    @Override
                    public void onTextChanged(CharSequence s, int start, int before, int count) {

                    }

                    @Override
                    public void afterTextChanged(Editable s) {
                        if (ignoreOnPhoneChange) {
                            return;
                        }
                        HintEditText phoneField = (HintEditText) inputFields[FIELD_PHONE];
                        int start = phoneField.getSelectionStart();
                        String phoneChars = "0123456789";
                        String str = phoneField.getText().toString();
                        if (characterAction == 3) {
                            str = str.substring(0, actionPosition) + str.substring(actionPosition + 1);
                            start--;
                        }
                        StringBuilder builder = new StringBuilder(str.length());
                        for (int a = 0; a < str.length(); a++) {
                            String ch = str.substring(a, a + 1);
                            if (phoneChars.contains(ch)) {
                                builder.append(ch);
                            }
                        }
                        ignoreOnPhoneChange = true;
                        String hint = phoneField.getHintText();
                        if (hint != null) {
                            for (int a = 0; a < builder.length(); a++) {
                                if (a < hint.length()) {
                                    if (hint.charAt(a) == ' ') {
                                        builder.insert(a, ' ');
                                        a++;
                                        if (start == a && characterAction != 2 && characterAction != 3) {
                                            start++;
                                        }
                                    }
                                } else {
                                    builder.insert(a, ' ');
                                    if (start == a + 1 && characterAction != 2 && characterAction != 3) {
                                        start++;
                                    }
                                    break;
                                }
                            }
                        }
                        phoneField.setText(builder);
                        if (start >= 0) {
                            phoneField.setSelection(Math.min(start, phoneField.length()));
                        }
                        phoneField.onTextChange();
                        ignoreOnPhoneChange = false;
                    }
                });
            } else {
                inputFields[a].setPadding(0, 0, 0, AndroidUtilities.dp(6));
                inputFields[a].setGravity(LocaleController.isRTL ? Gravity.RIGHT : Gravity.LEFT);
                container.addView(inputFields[a], LayoutHelper.createFrame(LayoutHelper.MATCH_PARENT, LayoutHelper.WRAP_CONTENT, Gravity.LEFT | Gravity.TOP, 21, 12, 21, 6));
            }

            inputFields[a].setOnEditorActionListener((textView, i, keyEvent) -> {
                if (i == EditorInfo.IME_ACTION_NEXT) {
                    inputFields[FIELD_PHONE].requestFocus();
                    return true;
                } else if (i == EditorInfo.IME_ACTION_DONE) {
                    doneItem.callOnClick();
                    return true;
                }
                return false;
            });
            if (a == FIELD_PHONE) {
                inputFields[a].setOnKeyListener((v, keyCode, event) -> {
                    if (keyCode == KeyEvent.KEYCODE_DEL && inputFields[FIELD_PHONE].length() == 0) {
                        inputFields[FIELD_PHONECODE].requestFocus();
                        inputFields[FIELD_PHONECODE].setSelection(inputFields[FIELD_PHONECODE].length());
                        inputFields[FIELD_PHONECODE].dispatchKeyEvent(event);
                        return true;
                    }
                    return false;
                });
            }

            if (a == FIELD_PHONECOUNTRY) {
                View divider = new View(context);
                dividers.add(divider);
                divider.setBackgroundColor(Theme.getColor(Theme.key_divider));
                container.addView(divider, new FrameLayout.LayoutParams(ViewGroup.LayoutParams.MATCH_PARENT, 1, Gravity.LEFT | Gravity.BOTTOM));
            }
        }


        String country = null;
        try {
            TelephonyManager telephonyManager = (TelephonyManager) ApplicationLoader.applicationContext.getSystemService(Context.TELEPHONY_SERVICE);
            if (telephonyManager != null) {
                country = telephonyManager.getSimCountryIso().toUpperCase();
            }
        } catch (Exception e) {
            FileLog.e(e);
        }
        if (country != null) {
            String countryName = languageMap.get(country);
            if (countryName != null) {
                int index = countriesArray.indexOf(countryName);
                if (index != -1) {
                    inputFields[FIELD_PHONECODE].setText(countriesMap.get(countryName));
                }
            }
        }

        bottomCell = new TextInfoPrivacyCell(context);
        bottomCell.setBackgroundDrawable(Theme.getThemedDrawable(context, R.drawable.greydivider_bottom, Theme.key_windowBackgroundGrayShadow));
        bottomCell.setText(LocaleController.getString("PassportPhoneUploadInfo", R.string.PassportPhoneUploadInfo));
        linearLayout2.addView(bottomCell, LayoutHelper.createLinear(LayoutHelper.MATCH_PARENT, LayoutHelper.WRAP_CONTENT));
    }

    private void createAddressInterface(Context context) {
        languageMap = new HashMap<>();
        try {
            BufferedReader reader = new BufferedReader(new InputStreamReader(context.getResources().getAssets().open("countries.txt")));
            String line;
            while ((line = reader.readLine()) != null) {
                String[] args = line.split(";");
                languageMap.put(args[1], args[2]);
            }
            reader.close();
        } catch (Exception e) {
            FileLog.e(e);
        }

        topErrorCell = new TextInfoPrivacyCell(context);
        topErrorCell.setBackgroundDrawable(Theme.getThemedDrawable(context, R.drawable.greydivider_top, Theme.key_windowBackgroundGrayShadow));
        topErrorCell.setPadding(0, AndroidUtilities.dp(7), 0, 0);
        linearLayout2.addView(topErrorCell, LayoutHelper.createLinear(LayoutHelper.MATCH_PARENT, LayoutHelper.WRAP_CONTENT));
        checkTopErrorCell(true);

        if (currentDocumentsType != null) {
            if (currentDocumentsType.type instanceof TLRPC.TL_secureValueTypeRentalAgreement) {
                actionBar.setTitle(LocaleController.getString("ActionBotDocumentRentalAgreement", R.string.ActionBotDocumentRentalAgreement));
            } else if (currentDocumentsType.type instanceof TLRPC.TL_secureValueTypeBankStatement) {
                actionBar.setTitle(LocaleController.getString("ActionBotDocumentBankStatement", R.string.ActionBotDocumentBankStatement));
            } else if (currentDocumentsType.type instanceof TLRPC.TL_secureValueTypeUtilityBill) {
                actionBar.setTitle(LocaleController.getString("ActionBotDocumentUtilityBill", R.string.ActionBotDocumentUtilityBill));
            } else if (currentDocumentsType.type instanceof TLRPC.TL_secureValueTypePassportRegistration) {
                actionBar.setTitle(LocaleController.getString("ActionBotDocumentPassportRegistration", R.string.ActionBotDocumentPassportRegistration));
            } else if (currentDocumentsType.type instanceof TLRPC.TL_secureValueTypeTemporaryRegistration) {
                actionBar.setTitle(LocaleController.getString("ActionBotDocumentTemporaryRegistration", R.string.ActionBotDocumentTemporaryRegistration));
            }

            headerCell = new HeaderCell(context);
            headerCell.setText(LocaleController.getString("PassportDocuments", R.string.PassportDocuments));
            headerCell.setBackgroundColor(Theme.getColor(Theme.key_windowBackgroundWhite));
            linearLayout2.addView(headerCell, LayoutHelper.createLinear(LayoutHelper.MATCH_PARENT, LayoutHelper.WRAP_CONTENT));

            documentsLayout = new LinearLayout(context);
            documentsLayout.setOrientation(LinearLayout.VERTICAL);
            linearLayout2.addView(documentsLayout, LayoutHelper.createLinear(LayoutHelper.MATCH_PARENT, LayoutHelper.WRAP_CONTENT));

            uploadDocumentCell = new TextSettingsCell(context);
            uploadDocumentCell.setBackgroundDrawable(Theme.getSelectorDrawable(true));
            linearLayout2.addView(uploadDocumentCell, LayoutHelper.createLinear(LayoutHelper.MATCH_PARENT, LayoutHelper.WRAP_CONTENT));
            uploadDocumentCell.setOnClickListener(v -> {
                uploadingFileType = UPLOADING_TYPE_DOCUMENTS;
                openAttachMenu();
            });

            bottomCell = new TextInfoPrivacyCell(context);
            bottomCell.setBackgroundDrawable(Theme.getThemedDrawable(context, R.drawable.greydivider, Theme.key_windowBackgroundGrayShadow));

            if (currentBotId != 0) {
                noAllDocumentsErrorText = LocaleController.getString("PassportAddAddressUploadInfo", R.string.PassportAddAddressUploadInfo);
            } else {
                if (currentDocumentsType.type instanceof TLRPC.TL_secureValueTypeRentalAgreement) {
                    noAllDocumentsErrorText = LocaleController.getString("PassportAddAgreementInfo", R.string.PassportAddAgreementInfo);
                } else if (currentDocumentsType.type instanceof TLRPC.TL_secureValueTypeUtilityBill) {
                    noAllDocumentsErrorText = LocaleController.getString("PassportAddBillInfo", R.string.PassportAddBillInfo);
                } else if (currentDocumentsType.type instanceof TLRPC.TL_secureValueTypePassportRegistration) {
                    noAllDocumentsErrorText = LocaleController.getString("PassportAddPassportRegistrationInfo", R.string.PassportAddPassportRegistrationInfo);
                } else if (currentDocumentsType.type instanceof TLRPC.TL_secureValueTypeTemporaryRegistration) {
                    noAllDocumentsErrorText = LocaleController.getString("PassportAddTemporaryRegistrationInfo", R.string.PassportAddTemporaryRegistrationInfo);
                } else if (currentDocumentsType.type instanceof TLRPC.TL_secureValueTypeBankStatement) {
                    noAllDocumentsErrorText = LocaleController.getString("PassportAddBankInfo", R.string.PassportAddBankInfo);
                } else {
                    noAllDocumentsErrorText = "";
                }
            }

            CharSequence text = noAllDocumentsErrorText;
            if (documentsErrors != null) {
                String errorText;
                if ((errorText = documentsErrors.get("files_all")) != null) {
                    SpannableStringBuilder stringBuilder = new SpannableStringBuilder(errorText);
                    stringBuilder.append("\n\n");
                    stringBuilder.append(noAllDocumentsErrorText);
                    text = stringBuilder;
                    stringBuilder.setSpan(new ForegroundColorSpan(Theme.getColor(Theme.key_windowBackgroundWhiteRedText3)), 0, errorText.length(), Spannable.SPAN_EXCLUSIVE_EXCLUSIVE);
                    errorsValues.put("files_all", "");
                }
            }
            bottomCell.setText(text);
            linearLayout2.addView(bottomCell, LayoutHelper.createLinear(LayoutHelper.MATCH_PARENT, LayoutHelper.WRAP_CONTENT));

            if (currentDocumentsType.translation_required) {
                headerCell = new HeaderCell(context);
                headerCell.setText(LocaleController.getString("PassportTranslation", R.string.PassportTranslation));
                headerCell.setBackgroundColor(Theme.getColor(Theme.key_windowBackgroundWhite));
                linearLayout2.addView(headerCell, LayoutHelper.createLinear(LayoutHelper.MATCH_PARENT, LayoutHelper.WRAP_CONTENT));

                translationLayout = new LinearLayout(context);
                translationLayout.setOrientation(LinearLayout.VERTICAL);
                linearLayout2.addView(translationLayout, LayoutHelper.createLinear(LayoutHelper.MATCH_PARENT, LayoutHelper.WRAP_CONTENT));

                uploadTranslationCell = new TextSettingsCell(context);
                uploadTranslationCell.setBackgroundDrawable(Theme.getSelectorDrawable(true));
                linearLayout2.addView(uploadTranslationCell, LayoutHelper.createLinear(LayoutHelper.MATCH_PARENT, LayoutHelper.WRAP_CONTENT));
                uploadTranslationCell.setOnClickListener(v -> {
                    uploadingFileType = UPLOADING_TYPE_TRANSLATION;
                    openAttachMenu();
                });

                bottomCellTranslation = new TextInfoPrivacyCell(context);
                bottomCellTranslation.setBackgroundDrawable(Theme.getThemedDrawable(context, R.drawable.greydivider, Theme.key_windowBackgroundGrayShadow));

                if (currentBotId != 0) {
                    noAllTranslationErrorText = LocaleController.getString("PassportAddTranslationUploadInfo", R.string.PassportAddTranslationUploadInfo);
                } else {
                    if (currentDocumentsType.type instanceof TLRPC.TL_secureValueTypeRentalAgreement) {
                        noAllTranslationErrorText = LocaleController.getString("PassportAddTranslationAgreementInfo", R.string.PassportAddTranslationAgreementInfo);
                    } else if (currentDocumentsType.type instanceof TLRPC.TL_secureValueTypeUtilityBill) {
                        noAllTranslationErrorText = LocaleController.getString("PassportAddTranslationBillInfo", R.string.PassportAddTranslationBillInfo);
                    } else if (currentDocumentsType.type instanceof TLRPC.TL_secureValueTypePassportRegistration) {
                        noAllTranslationErrorText = LocaleController.getString("PassportAddTranslationPassportRegistrationInfo", R.string.PassportAddTranslationPassportRegistrationInfo);
                    } else if (currentDocumentsType.type instanceof TLRPC.TL_secureValueTypeTemporaryRegistration) {
                        noAllTranslationErrorText = LocaleController.getString("PassportAddTranslationTemporaryRegistrationInfo", R.string.PassportAddTranslationTemporaryRegistrationInfo);
                    } else if (currentDocumentsType.type instanceof TLRPC.TL_secureValueTypeBankStatement) {
                        noAllTranslationErrorText = LocaleController.getString("PassportAddTranslationBankInfo", R.string.PassportAddTranslationBankInfo);
                    } else {
                        noAllTranslationErrorText = "";
                    }
                }

                text = noAllTranslationErrorText;
                if (documentsErrors != null) {
                    String errorText;
                    if ((errorText = documentsErrors.get("translation_all")) != null) {
                        SpannableStringBuilder stringBuilder = new SpannableStringBuilder(errorText);
                        stringBuilder.append("\n\n");
                        stringBuilder.append(noAllTranslationErrorText);
                        text = stringBuilder;
                        stringBuilder.setSpan(new ForegroundColorSpan(Theme.getColor(Theme.key_windowBackgroundWhiteRedText3)), 0, errorText.length(), Spannable.SPAN_EXCLUSIVE_EXCLUSIVE);
                        errorsValues.put("translation_all", "");
                    }
                }
                bottomCellTranslation.setText(text);
                linearLayout2.addView(bottomCellTranslation, LayoutHelper.createLinear(LayoutHelper.MATCH_PARENT, LayoutHelper.WRAP_CONTENT));
            }
        } else {
            actionBar.setTitle(LocaleController.getString("PassportAddress", R.string.PassportAddress));
        }

        headerCell = new HeaderCell(context);
        headerCell.setText(LocaleController.getString("PassportAddressHeader", R.string.PassportAddressHeader));
        headerCell.setBackgroundColor(Theme.getColor(Theme.key_windowBackgroundWhite));
        linearLayout2.addView(headerCell, LayoutHelper.createLinear(LayoutHelper.MATCH_PARENT, LayoutHelper.WRAP_CONTENT));

        inputFields = new EditTextBoldCursor[FIELD_ADDRESS_COUNT];
        for (int a = 0; a < FIELD_ADDRESS_COUNT; a++) {
            final EditTextBoldCursor field = new EditTextBoldCursor(context);
            inputFields[a] = field;

            ViewGroup container = new FrameLayout(context) {

                private StaticLayout errorLayout;
                float offsetX;

                @Override
                protected void onMeasure(int widthMeasureSpec, int heightMeasureSpec) {
                    int width = MeasureSpec.getSize(widthMeasureSpec) - AndroidUtilities.dp(34);
                    errorLayout = field.getErrorLayout(width);
                    if (errorLayout != null) {
                        int lineCount = errorLayout.getLineCount();
                        if (lineCount > 1) {
                            int height = AndroidUtilities.dp(64) + (errorLayout.getLineBottom(lineCount - 1) - errorLayout.getLineBottom(0));
                            heightMeasureSpec = MeasureSpec.makeMeasureSpec(height, MeasureSpec.EXACTLY);
                        }
                        if (LocaleController.isRTL) {
                            float maxW = 0;
                            for (int a = 0; a < lineCount; a++) {
                                float l = errorLayout.getLineLeft(a);
                                if (l != 0) {
                                    offsetX = 0;
                                    break;
                                }
                                maxW = Math.max(maxW, errorLayout.getLineWidth(a));
                                if (a == lineCount - 1) {
                                    offsetX = width - maxW;
                                }
                            }
                        }
                    }
                    super.onMeasure(widthMeasureSpec, heightMeasureSpec);
                }

                @Override
                protected void onDraw(Canvas canvas) {
                    if (errorLayout != null) {
                        canvas.save();
                        canvas.translate(AndroidUtilities.dp(21) + offsetX, field.getLineY() + AndroidUtilities.dp(3));
                        errorLayout.draw(canvas);
                        canvas.restore();
                    }
                }
            };
            container.setWillNotDraw(false);
            linearLayout2.addView(container, LayoutHelper.createLinear(LayoutHelper.MATCH_PARENT, LayoutHelper.WRAP_CONTENT));
            container.setBackgroundColor(Theme.getColor(Theme.key_windowBackgroundWhite));

            if (a == FIELD_ADDRESS_COUNT - 1) {
                extraBackgroundView = new View(context);
                extraBackgroundView.setBackgroundColor(Theme.getColor(Theme.key_windowBackgroundWhite));
                linearLayout2.addView(extraBackgroundView, LayoutHelper.createLinear(LayoutHelper.MATCH_PARENT, 6));
            }

            if (documentOnly && currentDocumentsType != null) {
                container.setVisibility(View.GONE);
                if (extraBackgroundView != null) {
                    extraBackgroundView.setVisibility(View.GONE);
                }
            }

            inputFields[a].setTag(a);
            inputFields[a].setSupportRtlHint(true);
            inputFields[a].setTextSize(TypedValue.COMPLEX_UNIT_DIP, 16);
            inputFields[a].setHintColor(Theme.getColor(Theme.key_windowBackgroundWhiteHintText));
            inputFields[a].setHeaderHintColor(Theme.getColor(Theme.key_windowBackgroundWhiteBlueHeader));
            inputFields[a].setTransformHintToHeader(true);
            inputFields[a].setTextColor(Theme.getColor(Theme.key_windowBackgroundWhiteBlackText));
            inputFields[a].setBackgroundDrawable(null);
            inputFields[a].setCursorColor(Theme.getColor(Theme.key_windowBackgroundWhiteBlackText));
            inputFields[a].setCursorSize(AndroidUtilities.dp(20));
            inputFields[a].setCursorWidth(1.5f);
            inputFields[a].setLineColors(Theme.getColor(Theme.key_windowBackgroundWhiteInputField), Theme.getColor(Theme.key_windowBackgroundWhiteInputFieldActivated), Theme.getColor(Theme.key_windowBackgroundWhiteRedText3));
            if (a == FIELD_COUNTRY) {
                inputFields[a].setOnTouchListener((v, event) -> {
                    if (getParentActivity() == null) {
                        return false;
                    }
                    if (event.getAction() == MotionEvent.ACTION_UP) {
                        CountrySelectActivity fragment = new CountrySelectActivity(false);
                        fragment.setCountrySelectActivityDelegate((name, shortName) -> {
                            inputFields[FIELD_COUNTRY].setText(name);
                            currentCitizeship = shortName;
                        });
                        presentFragment(fragment);
                    }
                    return true;
                });
                inputFields[a].setInputType(0);
                inputFields[a].setFocusable(false);
            } else {
                inputFields[a].setInputType(InputType.TYPE_CLASS_TEXT | InputType.TYPE_TEXT_FLAG_CAP_SENTENCES);
                inputFields[a].setImeOptions(EditorInfo.IME_ACTION_NEXT | EditorInfo.IME_FLAG_NO_EXTRACT_UI);
            }
            String value;
            final String key;
            switch (a) {
                case FIELD_STREET1:
                    inputFields[a].setHintText(LocaleController.getString("PassportStreet1", R.string.PassportStreet1));
                    key = "street_line1";
                    break;
                case FIELD_STREET2:
                    inputFields[a].setHintText(LocaleController.getString("PassportStreet2", R.string.PassportStreet2));
                    key = "street_line2";
                    break;
                case FIELD_CITY:
                    inputFields[a].setHintText(LocaleController.getString("PassportCity", R.string.PassportCity));
                    key = "city";
                    break;
                case FIELD_STATE:
                    inputFields[a].setHintText(LocaleController.getString("PassportState", R.string.PassportState));
                    key = "state";
                    break;
                case FIELD_COUNTRY:
                    inputFields[a].setHintText(LocaleController.getString("PassportCountry", R.string.PassportCountry));
                    key = "country_code";
                    break;
                case FIELD_POSTCODE:
                    inputFields[a].setHintText(LocaleController.getString("PassportPostcode", R.string.PassportPostcode));
                    key = "post_code";
                    break;
                default:
                    continue;
            }
            setFieldValues(currentValues, inputFields[a], key);
            if (a == FIELD_POSTCODE) {
                inputFields[a].addTextChangedListener(new TextWatcher() {

                    private boolean ignore;

                    @Override
                    public void beforeTextChanged(CharSequence s, int start, int count, int after) {

                    }

                    @Override
                    public void onTextChanged(CharSequence s, int start, int before, int count) {

                    }

                    @Override
                    public void afterTextChanged(Editable s) {
                        if (ignore) {
                            return;
                        }
                        ignore = true;
                        boolean error = false;
                        for (int a = 0; a < s.length(); a++) {
                            char ch = s.charAt(a);
                            if (!(ch >= 'a' && ch <= 'z' || ch >= 'A' && ch <= 'Z' || ch >= '0' && ch <= '9' || ch == '-' || ch == ' ')) {
                                error = true;
                                break;
                            }
                        }
                        ignore = false;
                        if (error) {
                            field.setErrorText(LocaleController.getString("PassportUseLatinOnly", R.string.PassportUseLatinOnly));
                        } else {
                            checkFieldForError(field, key, s, false);
                        }
                    }
                });
                InputFilter[] inputFilters = new InputFilter[1];
                inputFilters[0] = new InputFilter.LengthFilter(10);
                inputFields[a].setFilters(inputFilters);
            } else {
                inputFields[a].addTextChangedListener(new TextWatcher() {
                    @Override
                    public void beforeTextChanged(CharSequence s, int start, int count, int after) {

                    }

                    @Override
                    public void onTextChanged(CharSequence s, int start, int before, int count) {

                    }

                    @Override
                    public void afterTextChanged(Editable s) {
                        checkFieldForError(field, key, s, false);
                    }
                });
            }

            inputFields[a].setSelection(inputFields[a].length());
            inputFields[a].setPadding(0, 0, 0, 0);
            inputFields[a].setGravity((LocaleController.isRTL ? Gravity.RIGHT : Gravity.LEFT) | Gravity.CENTER_VERTICAL);
            container.addView(inputFields[a], LayoutHelper.createFrame(LayoutHelper.MATCH_PARENT, 64, Gravity.LEFT | Gravity.TOP, 21, 0, 21, 0));

            inputFields[a].setOnEditorActionListener((textView, i, keyEvent) -> {
                if (i == EditorInfo.IME_ACTION_NEXT) {
                    int num = (Integer) textView.getTag();
                    num++;
                    if (num < inputFields.length) {
                        if (inputFields[num].isFocusable()) {
                            inputFields[num].requestFocus();
                        } else {
                            inputFields[num].dispatchTouchEvent(MotionEvent.obtain(0, 0, MotionEvent.ACTION_UP, 0, 0, 0));
                            textView.clearFocus();
                            AndroidUtilities.hideKeyboard(textView);
                        }
                    }
                    return true;
                }
                return false;
            });
        }

        sectionCell = new ShadowSectionCell(context);
        linearLayout2.addView(sectionCell, LayoutHelper.createLinear(LayoutHelper.MATCH_PARENT, LayoutHelper.WRAP_CONTENT));

        if (documentOnly && currentDocumentsType != null) {
            headerCell.setVisibility(View.GONE);
            sectionCell.setVisibility(View.GONE);
        }

        if ((currentBotId != 0 || currentDocumentsType == null) && currentTypeValue != null && !documentOnly || currentDocumentsTypeValue != null) {
            if (currentDocumentsTypeValue != null) {
                addDocumentViews(currentDocumentsTypeValue.files);
                addTranslationDocumentViews(currentDocumentsTypeValue.translation);
            }
            sectionCell.setBackgroundDrawable(Theme.getThemedDrawable(context, R.drawable.greydivider, Theme.key_windowBackgroundGrayShadow));

            TextSettingsCell settingsCell1 = new TextSettingsCell(context);
            settingsCell1.setTextColor(Theme.getColor(Theme.key_windowBackgroundWhiteRedText3));
            settingsCell1.setBackgroundDrawable(Theme.getSelectorDrawable(true));
            if (currentDocumentsType == null) {
                settingsCell1.setText(LocaleController.getString("PassportDeleteInfo", R.string.PassportDeleteInfo), false);
            } else {
                settingsCell1.setText(LocaleController.getString("PassportDeleteDocument", R.string.PassportDeleteDocument), false);
            }
            linearLayout2.addView(settingsCell1, LayoutHelper.createLinear(LayoutHelper.MATCH_PARENT, LayoutHelper.WRAP_CONTENT));
            settingsCell1.setOnClickListener(v -> createDocumentDeleteAlert());

            sectionCell = new ShadowSectionCell(context);
            sectionCell.setBackgroundDrawable(Theme.getThemedDrawable(context, R.drawable.greydivider_bottom, Theme.key_windowBackgroundGrayShadow));
            linearLayout2.addView(sectionCell, LayoutHelper.createLinear(LayoutHelper.MATCH_PARENT, LayoutHelper.WRAP_CONTENT));
        } else {
            sectionCell.setBackgroundDrawable(Theme.getThemedDrawable(context, R.drawable.greydivider_bottom, Theme.key_windowBackgroundGrayShadow));
            if (documentOnly && currentDocumentsType != null) {
                bottomCell.setBackgroundDrawable(Theme.getThemedDrawable(context, R.drawable.greydivider_bottom, Theme.key_windowBackgroundGrayShadow));
            }
        }
        updateUploadText(UPLOADING_TYPE_DOCUMENTS);
        updateUploadText(UPLOADING_TYPE_TRANSLATION);
    }

    private void createDocumentDeleteAlert() {
        final boolean[] checks = new boolean[]{true};

        AlertDialog.Builder builder = new AlertDialog.Builder(getParentActivity());
        builder.setPositiveButton(LocaleController.getString("OK", R.string.OK), (dialog, which) -> {
            if (!documentOnly) {
                currentValues.clear();
            }
            currentDocumentValues.clear();
            delegate.deleteValue(currentType, currentDocumentsType, availableDocumentTypes, checks[0], null, null);
            finishFragment();
        });
        builder.setNegativeButton(LocaleController.getString("Cancel", R.string.Cancel), null);
        builder.setTitle(LocaleController.getString("AppName", R.string.AppName));
        if (documentOnly && currentDocumentsType == null && currentType.type instanceof TLRPC.TL_secureValueTypeAddress) {
            builder.setMessage(LocaleController.getString("PassportDeleteAddressAlert", R.string.PassportDeleteAddressAlert));
        } else if (documentOnly && currentDocumentsType == null && currentType.type instanceof TLRPC.TL_secureValueTypePersonalDetails) {
            builder.setMessage(LocaleController.getString("PassportDeletePersonalAlert", R.string.PassportDeletePersonalAlert));
        } else {
            builder.setMessage(LocaleController.getString("PassportDeleteDocumentAlert", R.string.PassportDeleteDocumentAlert));
        }

        if (!documentOnly && currentDocumentsType != null) {
            FrameLayout frameLayout = new FrameLayout(getParentActivity());
            CheckBoxCell cell = new CheckBoxCell(getParentActivity(), 1);
            cell.setBackgroundDrawable(Theme.getSelectorDrawable(false));
            if (currentType.type instanceof TLRPC.TL_secureValueTypeAddress) {
                cell.setText(LocaleController.getString("PassportDeleteDocumentAddress", R.string.PassportDeleteDocumentAddress), "", true, false);
            } else if (currentType.type instanceof TLRPC.TL_secureValueTypePersonalDetails) {
                cell.setText(LocaleController.getString("PassportDeleteDocumentPersonal", R.string.PassportDeleteDocumentPersonal), "", true, false);
            }
            cell.setPadding(LocaleController.isRTL ? AndroidUtilities.dp(16) : AndroidUtilities.dp(8), 0, LocaleController.isRTL ? AndroidUtilities.dp(8) : AndroidUtilities.dp(16), 0);
            frameLayout.addView(cell, LayoutHelper.createFrame(LayoutHelper.MATCH_PARENT, 48, Gravity.TOP | Gravity.LEFT));
            cell.setOnClickListener(v -> {
                if (!v.isEnabled()) {
                    return;
                }
                CheckBoxCell cell1 = (CheckBoxCell) v;
                checks[0] = !checks[0];
                cell1.setChecked(checks[0], true);
            });
            builder.setView(frameLayout);
        }

        showDialog(builder.create());
    }

    private void onFieldError(View field) {
        if (field == null) {
            return;
        }
        Vibrator v = (Vibrator) getParentActivity().getSystemService(Context.VIBRATOR_SERVICE);
        if (v != null) {
            v.vibrate(200);
        }
        AndroidUtilities.shakeView(field, 2, 0);
        scrollToField(field);
    }

    private void scrollToField(View field) {
        while (field != null && linearLayout2.indexOfChild(field) < 0) {
            field = (View) field.getParent();
        }
        if (field != null) {
            scrollView.smoothScrollTo(0, field.getTop() - (scrollView.getMeasuredHeight() - field.getMeasuredHeight()) / 2);
        }
    }

    private String getDocumentHash(SecureDocument document) {
        if (document != null) {
            if (document.secureFile != null && document.secureFile.file_hash != null) {
                return Base64.encodeToString(document.secureFile.file_hash, Base64.NO_WRAP);
            } else if (document.fileHash != null) {
                return Base64.encodeToString(document.fileHash, Base64.NO_WRAP);
            }
        }
        return "";
    }

    private void checkFieldForError(EditTextBoldCursor field, String key, Editable s, boolean document) {
        String value;
        if (errorsValues != null && (value = errorsValues.get(key)) != null) {
            if (TextUtils.equals(value, s)) {
                if (fieldsErrors != null && (value = fieldsErrors.get(key)) != null) {
                    field.setErrorText(value);
                } else if (documentsErrors != null && (value = documentsErrors.get(key)) != null) {
                    field.setErrorText(value);
                }
            } else {
                field.setErrorText(null);
            }
        } else {
            field.setErrorText(null);
        }
        String errorKey = document ? "error_document_all" : "error_all";
        if (errorsValues != null && errorsValues.containsKey(errorKey)) {
            errorsValues.remove(errorKey);
            checkTopErrorCell(false);
        }
    }

    private boolean checkFieldsForError() {
        if (currentDocumentsType != null) {
            if (errorsValues.containsKey("error_all") || errorsValues.containsKey("error_document_all")) {
                onFieldError(topErrorCell);
                return true;
            }
            if (uploadDocumentCell != null) {
                if (documents.isEmpty()) {
                    onFieldError(uploadDocumentCell);
                    return true;
                } else {
                    for (int a = 0, size = documents.size(); a < size; a++) {
                        SecureDocument document = documents.get(a);
                        String key = "files" + getDocumentHash(document);
                        if (key != null && errorsValues.containsKey(key)) {
                            onFieldError(documentsCells.get(document));
                            return true;
                        }
                    }
                }
            }
            if (errorsValues.containsKey("files_all") || errorsValues.containsKey("translation_all")) {
                onFieldError(bottomCell);
                return true;
            }
            if (uploadFrontCell != null) {
                if (frontDocument == null) {
                    onFieldError(uploadFrontCell);
                    return true;
                } else {
                    String key = "front" + getDocumentHash(frontDocument);
                    if (errorsValues.containsKey(key)) {
                        onFieldError(documentsCells.get(frontDocument));
                        return true;
                    }
                }
            }
            if (currentDocumentsType.type instanceof TLRPC.TL_secureValueTypeIdentityCard || currentDocumentsType.type instanceof TLRPC.TL_secureValueTypeDriverLicense) {
                if (uploadReverseCell != null) {
                    if (reverseDocument == null) {
                        onFieldError(uploadReverseCell);
                        return true;
                    } else {
                        String key = "reverse" + getDocumentHash(reverseDocument);
                        if (errorsValues.containsKey(key)) {
                            onFieldError(documentsCells.get(reverseDocument));
                            return true;
                        }
                    }
                }
            }
            if (uploadSelfieCell != null && currentBotId != 0) {
                if (selfieDocument == null) {
                    onFieldError(uploadSelfieCell);
                    return true;
                } else {
                    String key = "selfie" + getDocumentHash(selfieDocument);
                    if (errorsValues.containsKey(key)) {
                        onFieldError(documentsCells.get(selfieDocument));
                        return true;
                    }
                }
            }
            if (uploadTranslationCell != null && currentBotId != 0) {
                if (translationDocuments.isEmpty()) {
                    onFieldError(uploadTranslationCell);
                    return true;
                } else {
                    for (int a = 0, size = translationDocuments.size(); a < size; a++) {
                        SecureDocument document = translationDocuments.get(a);
                        String key = "translation" + getDocumentHash(document);
                        if (key != null && errorsValues.containsKey(key)) {
                            onFieldError(documentsCells.get(document));
                            return true;
                        }
                    }
                }
            }
        }
        for (int i = 0; i < 2; i++) {
            EditTextBoldCursor[] fields;
            if (i == 0) {
                fields = inputFields;
            } else {
                fields = nativeInfoCell != null && nativeInfoCell.getVisibility() == View.VISIBLE ? inputExtraFields : null;
            }
            if (fields == null) {
                continue;
            }
            for (int a = 0; a < fields.length; a++) {
                boolean error = false;
                if (fields[a].hasErrorText()) {
                    error = true;
                }
                if (!errorsValues.isEmpty()) {
                    String key;
                    if (currentType.type instanceof TLRPC.TL_secureValueTypePersonalDetails) {
                        if (i == 0) {
                            switch (a) {
                                case FIELD_NAME:
                                    key = "first_name";
                                    break;
                                case FIELD_MIDNAME:
                                    key = "middle_name";
                                    break;
                                case FIELD_SURNAME:
                                    key = "last_name";
                                    break;
                                case FIELD_BIRTHDAY:
                                    key = "birth_date";
                                    break;
                                case FIELD_GENDER:
                                    key = "gender";
                                    break;
                                case FIELD_CITIZENSHIP:
                                    key = "country_code";
                                    break;
                                case FIELD_RESIDENCE:
                                    key = "residence_country_code";
                                    break;
                                case FIELD_CARDNUMBER:
                                    key = "document_no";
                                    break;
                                case FIELD_EXPIRE:
                                    key = "expiry_date";
                                    break;
                                default:
                                    key = null;
                                    break;
                            }
                        } else {
                            switch (a) {
                                case FIELD_NATIVE_NAME:
                                    key = "first_name_native";
                                    break;
                                case FIELD_NATIVE_MIDNAME:
                                    key = "middle_name_native";
                                    break;
                                case FIELD_NATIVE_SURNAME:
                                    key = "last_name_native";
                                    break;
                                default:
                                    key = null;
                                    break;
                            }
                        }
                    } else if (currentType.type instanceof TLRPC.TL_secureValueTypeAddress) {
                        switch (a) {
                            case FIELD_STREET1:
                                key = "street_line1";
                                break;
                            case FIELD_STREET2:
                                key = "street_line2";
                                break;
                            case FIELD_CITY:
                                key = "city";
                                break;
                            case FIELD_STATE:
                                key = "state";
                                break;
                            case FIELD_COUNTRY:
                                key = "country_code";
                                break;
                            case FIELD_POSTCODE:
                                key = "post_code";
                                break;
                            default:
                                key = null;
                                break;
                        }
                    } else {
                        key = null;
                    }
                    if (key != null) {
                        String value = errorsValues.get(key);
                        if (!TextUtils.isEmpty(value)) {
                            if (value.equals(fields[a].getText().toString())) {
                                error = true;
                            }
                        }
                    }
                }
                if (documentOnly) {
                    if (currentDocumentsType != null && a < FIELD_CARDNUMBER) {
                        continue;
                    }
                }
                if (!error) {
                    int len = fields[a].length();
                    boolean allowZeroLength = false;
                    if (currentActivityType == TYPE_IDENTITY) {
                        if (a == FIELD_EXPIRE) {
                            continue;
                        } else if (i == 0 && (a == FIELD_NAME || a == FIELD_SURNAME || a == FIELD_MIDNAME) ||
                                i == 1 && (a == FIELD_NATIVE_NAME || a == FIELD_NATIVE_MIDNAME || a == FIELD_NATIVE_SURNAME)) {
                            if (len > 255) {
                                error = true;
                            }
                            if (i == 0 && a == FIELD_MIDNAME || i == 1 && a == FIELD_NATIVE_MIDNAME) {
                                allowZeroLength = true;
                            }
                        } else if (a == FIELD_CARDNUMBER) {
                            if (len > 24) {
                                error = true;
                            }
                        }
                    } else if (currentActivityType == TYPE_ADDRESS) {
                        if (a == FIELD_STREET2) {
                            continue;
                        } else if (a == FIELD_CITY) {
                            if (len < 2) {
                                error = true;
                            }
                        } else if (a == FIELD_STATE) {
                            if ("US".equals(currentCitizeship)) {
                                if (len < 2) {
                                    error = true;
                                }
                            } else {
                                continue;
                            }
                        } else if (a == FIELD_POSTCODE) {
                            if (len < 2 || len > 10) {
                                error = true;
                            }
                        }
                    }
                    if (!error && !allowZeroLength && len == 0) {
                        error = true;
                    }
                }
                if (error) {
                    onFieldError(fields[a]);
                    return true;
                }
            }
        }
        return false;
    }

    private void createIdentityInterface(final Context context) {
        languageMap = new HashMap<>();
        try {
            BufferedReader reader = new BufferedReader(new InputStreamReader(context.getResources().getAssets().open("countries.txt")));
            String line;
            while ((line = reader.readLine()) != null) {
                String[] args = line.split(";");
                languageMap.put(args[1], args[2]);
            }
            reader.close();
        } catch (Exception e) {
            FileLog.e(e);
        }

        topErrorCell = new TextInfoPrivacyCell(context);
        topErrorCell.setBackgroundDrawable(Theme.getThemedDrawable(context, R.drawable.greydivider_top, Theme.key_windowBackgroundGrayShadow));
        topErrorCell.setPadding(0, AndroidUtilities.dp(7), 0, 0);
        linearLayout2.addView(topErrorCell, LayoutHelper.createLinear(LayoutHelper.MATCH_PARENT, LayoutHelper.WRAP_CONTENT));
        checkTopErrorCell(true);

        if (currentDocumentsType != null) {
            headerCell = new HeaderCell(context);
            if (documentOnly) {
                headerCell.setText(LocaleController.getString("PassportDocuments", R.string.PassportDocuments));
            } else {
                headerCell.setText(LocaleController.getString("PassportRequiredDocuments", R.string.PassportRequiredDocuments));
            }
            headerCell.setBackgroundColor(Theme.getColor(Theme.key_windowBackgroundWhite));
            linearLayout2.addView(headerCell, LayoutHelper.createLinear(LayoutHelper.MATCH_PARENT, LayoutHelper.WRAP_CONTENT));

            frontLayout = new LinearLayout(context);
            frontLayout.setOrientation(LinearLayout.VERTICAL);
            linearLayout2.addView(frontLayout, LayoutHelper.createLinear(LayoutHelper.MATCH_PARENT, LayoutHelper.WRAP_CONTENT));

            uploadFrontCell = new TextDetailSettingsCell(context);
            uploadFrontCell.setBackgroundDrawable(Theme.getSelectorDrawable(true));
            linearLayout2.addView(uploadFrontCell, LayoutHelper.createLinear(LayoutHelper.MATCH_PARENT, LayoutHelper.WRAP_CONTENT));
            uploadFrontCell.setOnClickListener(v -> {
                uploadingFileType = UPLOADING_TYPE_FRONT;
                openAttachMenu();
            });

            reverseLayout = new LinearLayout(context);
            reverseLayout.setOrientation(LinearLayout.VERTICAL);
            linearLayout2.addView(reverseLayout, LayoutHelper.createLinear(LayoutHelper.MATCH_PARENT, LayoutHelper.WRAP_CONTENT));

            boolean divider = currentDocumentsType.selfie_required;

            uploadReverseCell = new TextDetailSettingsCell(context);
            uploadReverseCell.setBackgroundDrawable(Theme.getSelectorDrawable(true));
            uploadReverseCell.setTextAndValue(LocaleController.getString("PassportReverseSide", R.string.PassportReverseSide), LocaleController.getString("PassportReverseSideInfo", R.string.PassportReverseSideInfo), divider);
            linearLayout2.addView(uploadReverseCell, LayoutHelper.createLinear(LayoutHelper.MATCH_PARENT, LayoutHelper.WRAP_CONTENT));
            uploadReverseCell.setOnClickListener(v -> {
                uploadingFileType = UPLOADING_TYPE_REVERSE;
                openAttachMenu();
            });

            if (currentDocumentsType.selfie_required) {
                selfieLayout = new LinearLayout(context);
                selfieLayout.setOrientation(LinearLayout.VERTICAL);
                linearLayout2.addView(selfieLayout, LayoutHelper.createLinear(LayoutHelper.MATCH_PARENT, LayoutHelper.WRAP_CONTENT));

                uploadSelfieCell = new TextDetailSettingsCell(context);
                uploadSelfieCell.setBackgroundDrawable(Theme.getSelectorDrawable(true));
                uploadSelfieCell.setTextAndValue(LocaleController.getString("PassportSelfie", R.string.PassportSelfie), LocaleController.getString("PassportSelfieInfo", R.string.PassportSelfieInfo), currentType.translation_required);
                linearLayout2.addView(uploadSelfieCell, LayoutHelper.createLinear(LayoutHelper.MATCH_PARENT, LayoutHelper.WRAP_CONTENT));
                uploadSelfieCell.setOnClickListener(v -> {
                    uploadingFileType = UPLOADING_TYPE_SELFIE;
                    openAttachMenu();
                });
            }

            bottomCell = new TextInfoPrivacyCell(context);
            bottomCell.setBackgroundDrawable(Theme.getThemedDrawable(context, R.drawable.greydivider, Theme.key_windowBackgroundGrayShadow));
            bottomCell.setText(LocaleController.getString("PassportPersonalUploadInfo", R.string.PassportPersonalUploadInfo));
            linearLayout2.addView(bottomCell, LayoutHelper.createLinear(LayoutHelper.MATCH_PARENT, LayoutHelper.WRAP_CONTENT));

            if (currentDocumentsType.translation_required) {
                headerCell = new HeaderCell(context);
                headerCell.setText(LocaleController.getString("PassportTranslation", R.string.PassportTranslation));
                headerCell.setBackgroundColor(Theme.getColor(Theme.key_windowBackgroundWhite));
                linearLayout2.addView(headerCell, LayoutHelper.createLinear(LayoutHelper.MATCH_PARENT, LayoutHelper.WRAP_CONTENT));

                translationLayout = new LinearLayout(context);
                translationLayout.setOrientation(LinearLayout.VERTICAL);
                linearLayout2.addView(translationLayout, LayoutHelper.createLinear(LayoutHelper.MATCH_PARENT, LayoutHelper.WRAP_CONTENT));

                uploadTranslationCell = new TextSettingsCell(context);
                uploadTranslationCell.setBackgroundDrawable(Theme.getSelectorDrawable(true));
                linearLayout2.addView(uploadTranslationCell, LayoutHelper.createLinear(LayoutHelper.MATCH_PARENT, LayoutHelper.WRAP_CONTENT));
                uploadTranslationCell.setOnClickListener(v -> {
                    uploadingFileType = UPLOADING_TYPE_TRANSLATION;
                    openAttachMenu();
                });

                bottomCellTranslation = new TextInfoPrivacyCell(context);
                bottomCellTranslation.setBackgroundDrawable(Theme.getThemedDrawable(context, R.drawable.greydivider, Theme.key_windowBackgroundGrayShadow));

                if (currentBotId != 0) {
                    noAllTranslationErrorText = LocaleController.getString("PassportAddTranslationUploadInfo", R.string.PassportAddTranslationUploadInfo);
                } else {
                    if (currentDocumentsType.type instanceof TLRPC.TL_secureValueTypePassport) {
                        noAllTranslationErrorText = LocaleController.getString("PassportAddPassportInfo", R.string.PassportAddPassportInfo);
                    } else if (currentDocumentsType.type instanceof TLRPC.TL_secureValueTypeInternalPassport) {
                        noAllTranslationErrorText = LocaleController.getString("PassportAddInternalPassportInfo", R.string.PassportAddInternalPassportInfo);
                    } else if (currentDocumentsType.type instanceof TLRPC.TL_secureValueTypeIdentityCard) {
                        noAllTranslationErrorText = LocaleController.getString("PassportAddIdentityCardInfo", R.string.PassportAddIdentityCardInfo);
                    } else if (currentDocumentsType.type instanceof TLRPC.TL_secureValueTypeDriverLicense) {
                        noAllTranslationErrorText = LocaleController.getString("PassportAddDriverLicenceInfo", R.string.PassportAddDriverLicenceInfo);
                    } else {
                        noAllTranslationErrorText = "";
                    }
                }

                CharSequence text = noAllTranslationErrorText;
                if (documentsErrors != null) {
                    String errorText;
                    if ((errorText = documentsErrors.get("translation_all")) != null) {
                        SpannableStringBuilder stringBuilder = new SpannableStringBuilder(errorText);
                        stringBuilder.append("\n\n");
                        stringBuilder.append(noAllTranslationErrorText);
                        text = stringBuilder;
                        stringBuilder.setSpan(new ForegroundColorSpan(Theme.getColor(Theme.key_windowBackgroundWhiteRedText3)), 0, errorText.length(), Spannable.SPAN_EXCLUSIVE_EXCLUSIVE);
                        errorsValues.put("translation_all", "");
                    }
                }
                bottomCellTranslation.setText(text);
                linearLayout2.addView(bottomCellTranslation, LayoutHelper.createLinear(LayoutHelper.MATCH_PARENT, LayoutHelper.WRAP_CONTENT));
            }
        } else if (Build.VERSION.SDK_INT >= 18) {
            scanDocumentCell = new TextSettingsCell(context);
            scanDocumentCell.setBackgroundDrawable(Theme.getSelectorDrawable(true));
            scanDocumentCell.setText(LocaleController.getString("PassportScanPassport", R.string.PassportScanPassport), false);
            linearLayout2.addView(scanDocumentCell, LayoutHelper.createLinear(LayoutHelper.MATCH_PARENT, LayoutHelper.WRAP_CONTENT));
            scanDocumentCell.setOnClickListener(v -> {
                if (Build.VERSION.SDK_INT >= 23 && getParentActivity().checkSelfPermission(Manifest.permission.CAMERA) != PackageManager.PERMISSION_GRANTED) {
                    getParentActivity().requestPermissions(new String[]{Manifest.permission.CAMERA}, 22);
                    return;
                }
                CameraScanActivity fragment = new CameraScanActivity(org.telegram.ui.CameraScanActivity.TYPE_MRZ);
                fragment.setDelegate(new CameraScanActivity.CameraScanActivityDelegate() {
                    @Override
                    public void didFindMrzInfo(MrzRecognizer.Result result) {
                        if (!TextUtils.isEmpty(result.firstName)) {
                            inputFields[FIELD_NAME].setText(result.firstName);
                        }
                        if (!TextUtils.isEmpty(result.middleName)) {
                            inputFields[FIELD_MIDNAME].setText(result.middleName);
                        }
                        if (!TextUtils.isEmpty(result.lastName)) {
                            inputFields[FIELD_SURNAME].setText(result.lastName);
                        }
                        if (result.gender != MrzRecognizer.Result.GENDER_UNKNOWN) {
                            switch (result.gender) {
                                case MrzRecognizer.Result.GENDER_MALE:
                                    currentGender = "male";
                                    inputFields[FIELD_GENDER].setText(LocaleController.getString("PassportMale", R.string.PassportMale));
                                    break;
                                case MrzRecognizer.Result.GENDER_FEMALE:
                                    currentGender = "female";
                                    inputFields[FIELD_GENDER].setText(LocaleController.getString("PassportFemale", R.string.PassportFemale));
                                    break;
                            }
                        }
                        if (!TextUtils.isEmpty(result.nationality)) {
                            currentCitizeship = result.nationality;
                            String country = languageMap.get(currentCitizeship);
                            if (country != null) {
                                inputFields[FIELD_CITIZENSHIP].setText(country);
                            }
                        }
                        if (!TextUtils.isEmpty(result.issuingCountry)) {
                            currentResidence = result.issuingCountry;
                            String country = languageMap.get(currentResidence);
                            if (country != null) {
                                inputFields[FIELD_RESIDENCE].setText(country);
                            }
                        }
                        if (result.birthDay > 0 && result.birthMonth > 0 && result.birthYear > 0) {
                            inputFields[FIELD_BIRTHDAY].setText(String.format(Locale.US, "%02d.%02d.%d", result.birthDay, result.birthMonth, result.birthYear));
                        }
                    }
                });
                presentFragment(fragment);
            });

            bottomCell = new TextInfoPrivacyCell(context);
            bottomCell.setBackgroundDrawable(Theme.getThemedDrawable(context, R.drawable.greydivider, Theme.key_windowBackgroundGrayShadow));
            bottomCell.setText(LocaleController.getString("PassportScanPassportInfo", R.string.PassportScanPassportInfo));
            linearLayout2.addView(bottomCell, LayoutHelper.createLinear(LayoutHelper.MATCH_PARENT, LayoutHelper.WRAP_CONTENT));
        }

        headerCell = new HeaderCell(context);
        if (documentOnly) {
            headerCell.setText(LocaleController.getString("PassportDocument", R.string.PassportDocument));
        } else {
            headerCell.setText(LocaleController.getString("PassportPersonal", R.string.PassportPersonal));
        }
        headerCell.setBackgroundColor(Theme.getColor(Theme.key_windowBackgroundWhite));
        linearLayout2.addView(headerCell, LayoutHelper.createLinear(LayoutHelper.MATCH_PARENT, LayoutHelper.WRAP_CONTENT));

        int count = currentDocumentsType != null ? FIELD_IDENTITY_COUNT : FIELD_IDENTITY_NODOC_COUNT;
        inputFields = new EditTextBoldCursor[count];

        for (int a = 0; a < count; a++) {
            final EditTextBoldCursor field = new EditTextBoldCursor(context);
            inputFields[a] = field;

            ViewGroup container = new FrameLayout(context) {

                private StaticLayout errorLayout;
                private float offsetX;

                @Override
                protected void onMeasure(int widthMeasureSpec, int heightMeasureSpec) {
                    int width = MeasureSpec.getSize(widthMeasureSpec) - AndroidUtilities.dp(34);
                    errorLayout = field.getErrorLayout(width);
                    if (errorLayout != null) {
                        int lineCount = errorLayout.getLineCount();
                        if (lineCount > 1) {
                            int height = AndroidUtilities.dp(64) + (errorLayout.getLineBottom(lineCount - 1) - errorLayout.getLineBottom(0));
                            heightMeasureSpec = MeasureSpec.makeMeasureSpec(height, MeasureSpec.EXACTLY);
                        }
                        if (LocaleController.isRTL) {
                            float maxW = 0;
                            for (int a = 0; a < lineCount; a++) {
                                float l = errorLayout.getLineLeft(a);
                                if (l != 0) {
                                    offsetX = 0;
                                    break;
                                }
                                maxW = Math.max(maxW, errorLayout.getLineWidth(a));
                                if (a == lineCount - 1) {
                                    offsetX = width - maxW;
                                }
                            }
                        }
                    }
                    super.onMeasure(widthMeasureSpec, heightMeasureSpec);
                }

                @Override
                protected void onDraw(Canvas canvas) {
                    if (errorLayout != null) {
                        canvas.save();
                        canvas.translate(AndroidUtilities.dp(21) + offsetX, field.getLineY() + AndroidUtilities.dp(3));
                        errorLayout.draw(canvas);
                        canvas.restore();
                    }
                }
            };
            container.setWillNotDraw(false);
            linearLayout2.addView(container, LayoutHelper.createLinear(LayoutHelper.MATCH_PARENT, 64));
            container.setBackgroundColor(Theme.getColor(Theme.key_windowBackgroundWhite));

            if (a == count - 1) {
                extraBackgroundView = new View(context);
                extraBackgroundView.setBackgroundColor(Theme.getColor(Theme.key_windowBackgroundWhite));
                linearLayout2.addView(extraBackgroundView, LayoutHelper.createLinear(LayoutHelper.MATCH_PARENT, 6));
            }

            if (documentOnly && currentDocumentsType != null && a < FIELD_CARDNUMBER) {
                container.setVisibility(View.GONE);
                if (extraBackgroundView != null) {
                    extraBackgroundView.setVisibility(View.GONE);
                }
            }

            inputFields[a].setTag(a);
            inputFields[a].setSupportRtlHint(true);
            inputFields[a].setTextSize(TypedValue.COMPLEX_UNIT_DIP, 16);
            inputFields[a].setHintColor(Theme.getColor(Theme.key_windowBackgroundWhiteHintText));
            inputFields[a].setTextColor(Theme.getColor(Theme.key_windowBackgroundWhiteBlackText));
            inputFields[a].setHeaderHintColor(Theme.getColor(Theme.key_windowBackgroundWhiteBlueHeader));
            inputFields[a].setTransformHintToHeader(true);
            inputFields[a].setBackgroundDrawable(null);
            inputFields[a].setCursorColor(Theme.getColor(Theme.key_windowBackgroundWhiteBlackText));
            inputFields[a].setCursorSize(AndroidUtilities.dp(20));
            inputFields[a].setCursorWidth(1.5f);
            inputFields[a].setLineColors(Theme.getColor(Theme.key_windowBackgroundWhiteInputField), Theme.getColor(Theme.key_windowBackgroundWhiteInputFieldActivated), Theme.getColor(Theme.key_windowBackgroundWhiteRedText3));
            if (a == FIELD_CITIZENSHIP || a == FIELD_RESIDENCE) {
                inputFields[a].setOnTouchListener((v, event) -> {
                    if (getParentActivity() == null) {
                        return false;
                    }
                    if (event.getAction() == MotionEvent.ACTION_UP) {
                        CountrySelectActivity fragment = new CountrySelectActivity(false);
                        fragment.setCountrySelectActivityDelegate((name, shortName) -> {
                            int field12 = (Integer) v.getTag();
                            final EditTextBoldCursor editText = inputFields[field12];
                            if (field12 == FIELD_CITIZENSHIP) {
                                currentCitizeship = shortName;
                            } else {
                                currentResidence = shortName;
                            }
                            editText.setText(name);
                        });
                        presentFragment(fragment);
                    }
                    return true;
                });
                inputFields[a].setInputType(0);
            } else if (a == FIELD_BIRTHDAY || a == FIELD_EXPIRE) {
                inputFields[a].setOnTouchListener((v, event) -> {
                    if (getParentActivity() == null) {
                        return false;
                    }
                    if (event.getAction() == MotionEvent.ACTION_UP) {
                        Calendar calendar = Calendar.getInstance();
                        int year = calendar.get(Calendar.YEAR);
                        int monthOfYear = calendar.get(Calendar.MONTH);
                        int dayOfMonth = calendar.get(Calendar.DAY_OF_MONTH);
                        try {
                            final EditTextBoldCursor field1 = (EditTextBoldCursor) v;
                            int num = (Integer) field1.getTag();
                            int minYear;
                            int maxYear;
                            int currentYearDiff;
                            String title;
                            if (num == FIELD_EXPIRE) {
                                title = LocaleController.getString("PassportSelectExpiredDate", R.string.PassportSelectExpiredDate);
                                minYear = 0;
                                maxYear = 20;
                                currentYearDiff = 0;
                            } else {
                                title = LocaleController.getString("PassportSelectBithdayDate", R.string.PassportSelectBithdayDate);
                                minYear = -120;
                                maxYear = 0;
                                currentYearDiff = -18;
                            }
                            int selectedDay = -1;
                            int selectedMonth = -1;
                            int selectedYear = -1;
                            String[] args = field1.getText().toString().split("\\.");
                            if (args.length == 3) {
                                selectedDay = Utilities.parseInt(args[0]);
                                selectedMonth = Utilities.parseInt(args[1]);
                                selectedYear = Utilities.parseInt(args[2]);
                            }
                            AlertDialog.Builder builder = AlertsCreator.createDatePickerDialog(context, minYear, maxYear, currentYearDiff, selectedDay, selectedMonth, selectedYear, title, num == FIELD_EXPIRE, (year1, month, dayOfMonth1) -> {
                                if (num == FIELD_EXPIRE) {
                                    currentExpireDate[0] = year1;
                                    currentExpireDate[1] = month + 1;
                                    currentExpireDate[2] = dayOfMonth1;
                                }
                                field1.setText(String.format(Locale.US, "%02d.%02d.%d", dayOfMonth1, month + 1, year1));
                            });
                            if (num == FIELD_EXPIRE) {
                                builder.setNegativeButton(LocaleController.getString("PassportSelectNotExpire", R.string.PassportSelectNotExpire), (dialog, which) -> {
                                    currentExpireDate[0] = currentExpireDate[1] = currentExpireDate[2] = 0;
                                    field1.setText(LocaleController.getString("PassportNoExpireDate", R.string.PassportNoExpireDate));
                                });
                            }
                            showDialog(builder.create());
                        } catch (Exception e) {
                            FileLog.e(e);
                        }
                    }
                    return true;
                });
                inputFields[a].setInputType(0);
                inputFields[a].setFocusable(false);
            } else if (a == FIELD_GENDER) {
                inputFields[a].setOnTouchListener((v, event) -> {
                    if (getParentActivity() == null) {
                        return false;
                    }
                    if (event.getAction() == MotionEvent.ACTION_UP) {
                        AlertDialog.Builder builder = new AlertDialog.Builder(getParentActivity());
                        builder.setTitle(LocaleController.getString("PassportSelectGender", R.string.PassportSelectGender));
                        builder.setItems(new CharSequence[]{
                                LocaleController.getString("PassportMale", R.string.PassportMale),
                                LocaleController.getString("PassportFemale", R.string.PassportFemale)
                        }, (dialogInterface, i) -> {
                            if (i == 0) {
                                currentGender = "male";
                                inputFields[FIELD_GENDER].setText(LocaleController.getString("PassportMale", R.string.PassportMale));
                            } else if (i == 1) {
                                currentGender = "female";
                                inputFields[FIELD_GENDER].setText(LocaleController.getString("PassportFemale", R.string.PassportFemale));
                            }
                        });
                        builder.setPositiveButton(LocaleController.getString("Cancel", R.string.Cancel), null);
                        showDialog(builder.create());
                    }
                    return true;
                });
                inputFields[a].setInputType(0);
                inputFields[a].setFocusable(false);
            } else {
                inputFields[a].setInputType(InputType.TYPE_CLASS_TEXT | InputType.TYPE_TEXT_FLAG_CAP_SENTENCES);
                inputFields[a].setImeOptions(EditorInfo.IME_ACTION_NEXT | EditorInfo.IME_FLAG_NO_EXTRACT_UI);
            }
            String value;
            final String key;
            HashMap<String, String> values;
            switch (a) {
                case FIELD_NAME:
                    if (currentType.native_names) {
                        inputFields[a].setHintText(LocaleController.getString("PassportNameLatin", R.string.PassportNameLatin));
                    } else {
                        inputFields[a].setHintText(LocaleController.getString("PassportName", R.string.PassportName));
                    }
                    key = "first_name";
                    values = currentValues;
                    break;
                case FIELD_MIDNAME:
                    if (currentType.native_names) {
                        inputFields[a].setHintText(LocaleController.getString("PassportMidnameLatin", R.string.PassportMidnameLatin));
                    } else {
                        inputFields[a].setHintText(LocaleController.getString("PassportMidname", R.string.PassportMidname));
                    }
                    key = "middle_name";
                    values = currentValues;
                    break;
                case FIELD_SURNAME:
                    if (currentType.native_names) {
                        inputFields[a].setHintText(LocaleController.getString("PassportSurnameLatin", R.string.PassportSurnameLatin));
                    } else {
                        inputFields[a].setHintText(LocaleController.getString("PassportSurname", R.string.PassportSurname));
                    }
                    key = "last_name";
                    values = currentValues;
                    break;
                case FIELD_BIRTHDAY:
                    inputFields[a].setHintText(LocaleController.getString("PassportBirthdate", R.string.PassportBirthdate));
                    key = "birth_date";
                    values = currentValues;
                    break;
                case FIELD_GENDER:
                    inputFields[a].setHintText(LocaleController.getString("PassportGender", R.string.PassportGender));
                    key = "gender";
                    values = currentValues;
                    break;
                case FIELD_CITIZENSHIP:
                    inputFields[a].setHintText(LocaleController.getString("PassportCitizenship", R.string.PassportCitizenship));
                    key = "country_code";
                    values = currentValues;
                    break;
                case FIELD_RESIDENCE:
                    inputFields[a].setHintText(LocaleController.getString("PassportResidence", R.string.PassportResidence));
                    key = "residence_country_code";
                    values = currentValues;
                    break;
                case FIELD_CARDNUMBER:
                    inputFields[a].setHintText(LocaleController.getString("PassportDocumentNumber", R.string.PassportDocumentNumber));
                    key = "document_no";
                    values = currentDocumentValues;
                    break;
                case FIELD_EXPIRE:
                    inputFields[a].setHintText(LocaleController.getString("PassportExpired", R.string.PassportExpired));
                    key = "expiry_date";
                    values = currentDocumentValues;
                    break;
                default:
                    continue;
            }
            setFieldValues(values, inputFields[a], key);
            inputFields[a].setSelection(inputFields[a].length());
            if (a == FIELD_NAME || a == FIELD_SURNAME || a == FIELD_MIDNAME) {
                inputFields[a].addTextChangedListener(new TextWatcher() {

                    private boolean ignore;

                    @Override
                    public void beforeTextChanged(CharSequence s, int start, int count, int after) {

                    }

                    @Override
                    public void onTextChanged(CharSequence s, int start, int before, int count) {

                    }

                    @Override
                    public void afterTextChanged(Editable s) {
                        if (ignore) {
                            return;
                        }
                        int num = (Integer) field.getTag();
                        boolean error = false;
                        for (int a = 0; a < s.length(); a++) {
                            char ch = s.charAt(a);
                            if (!(ch >= '0' && ch <= '9' || ch >= 'a' && ch <= 'z' || ch >= 'A' && ch <= 'Z' || ch == ' ' || ch == '\'' || ch == ',' || ch == '.' || ch == '&' || ch == '-' || ch == '/')) {
                                error = true;
                                break;
                            }
                        }
                        if (error && !allowNonLatinName) {
                            field.setErrorText(LocaleController.getString("PassportUseLatinOnly", R.string.PassportUseLatinOnly));
                        } else {
                            nonLatinNames[num] = error;
                            checkFieldForError(field, key, s, false);
                        }
                    }
                });
            } else {
                inputFields[a].addTextChangedListener(new TextWatcher() {
                    @Override
                    public void beforeTextChanged(CharSequence s, int start, int count, int after) {

                    }

                    @Override
                    public void onTextChanged(CharSequence s, int start, int before, int count) {

                    }

                    @Override
                    public void afterTextChanged(Editable s) {
                        checkFieldForError(field, key, s, values == currentDocumentValues);
                        int field12 = (Integer) field.getTag();
                        final EditTextBoldCursor editText = inputFields[field12];
                        if (field12 == FIELD_RESIDENCE) {
                            checkNativeFields(true);
                        }
                    }
                });
            }

            inputFields[a].setPadding(0, 0, 0, 0);
            inputFields[a].setGravity((LocaleController.isRTL ? Gravity.RIGHT : Gravity.LEFT) | Gravity.CENTER_VERTICAL);
            container.addView(inputFields[a], LayoutHelper.createFrame(LayoutHelper.MATCH_PARENT, LayoutHelper.MATCH_PARENT, Gravity.LEFT | Gravity.TOP, 21, 0, 21, 0));

            inputFields[a].setOnEditorActionListener((textView, i, keyEvent) -> {
                if (i == EditorInfo.IME_ACTION_NEXT) {
                    int num = (Integer) textView.getTag();
                    num++;
                    if (num < inputFields.length) {
                        if (inputFields[num].isFocusable()) {
                            inputFields[num].requestFocus();
                        } else {
                            inputFields[num].dispatchTouchEvent(MotionEvent.obtain(0, 0, MotionEvent.ACTION_UP, 0, 0, 0));
                            textView.clearFocus();
                            AndroidUtilities.hideKeyboard(textView);
                        }
                    }
                    return true;
                }
                return false;
            });
        }

        sectionCell2 = new ShadowSectionCell(context);
        linearLayout2.addView(sectionCell2, LayoutHelper.createLinear(LayoutHelper.MATCH_PARENT, LayoutHelper.WRAP_CONTENT));

        headerCell = new HeaderCell(context);
        headerCell.setBackgroundColor(Theme.getColor(Theme.key_windowBackgroundWhite));
        linearLayout2.addView(headerCell, LayoutHelper.createLinear(LayoutHelper.MATCH_PARENT, LayoutHelper.WRAP_CONTENT));

        inputExtraFields = new EditTextBoldCursor[FIELD_NATIVE_COUNT];
        for (int a = 0; a < FIELD_NATIVE_COUNT; a++) {
            final EditTextBoldCursor field = new EditTextBoldCursor(context);
            inputExtraFields[a] = field;

            ViewGroup container = new FrameLayout(context) {

                private StaticLayout errorLayout;
                private float offsetX;

                @Override
                protected void onMeasure(int widthMeasureSpec, int heightMeasureSpec) {
                    int width = MeasureSpec.getSize(widthMeasureSpec) - AndroidUtilities.dp(34);
                    errorLayout = field.getErrorLayout(width);
                    if (errorLayout != null) {
                        int lineCount = errorLayout.getLineCount();
                        if (lineCount > 1) {
                            int height = AndroidUtilities.dp(64) + (errorLayout.getLineBottom(lineCount - 1) - errorLayout.getLineBottom(0));
                            heightMeasureSpec = MeasureSpec.makeMeasureSpec(height, MeasureSpec.EXACTLY);
                        }
                        if (LocaleController.isRTL) {
                            float maxW = 0;
                            for (int a = 0; a < lineCount; a++) {
                                float l = errorLayout.getLineLeft(a);
                                if (l != 0) {
                                    offsetX = 0;
                                    break;
                                }
                                maxW = Math.max(maxW, errorLayout.getLineWidth(a));
                                if (a == lineCount - 1) {
                                    offsetX = width - maxW;
                                }
                            }
                        }
                    }
                    super.onMeasure(widthMeasureSpec, heightMeasureSpec);
                }

                @Override
                protected void onDraw(Canvas canvas) {
                    if (errorLayout != null) {
                        canvas.save();
                        canvas.translate(AndroidUtilities.dp(21) + offsetX, field.getLineY() + AndroidUtilities.dp(3));
                        errorLayout.draw(canvas);
                        canvas.restore();
                    }
                }
            };
            container.setWillNotDraw(false);
            linearLayout2.addView(container, LayoutHelper.createLinear(LayoutHelper.MATCH_PARENT, 64));
            container.setBackgroundColor(Theme.getColor(Theme.key_windowBackgroundWhite));

            if (a == FIELD_NATIVE_COUNT - 1) {
                extraBackgroundView2 = new View(context);
                extraBackgroundView2.setBackgroundColor(Theme.getColor(Theme.key_windowBackgroundWhite));
                linearLayout2.addView(extraBackgroundView2, LayoutHelper.createLinear(LayoutHelper.MATCH_PARENT, 6));
            }

            inputExtraFields[a].setTag(a);
            inputExtraFields[a].setSupportRtlHint(true);
            inputExtraFields[a].setTextSize(TypedValue.COMPLEX_UNIT_DIP, 16);
            inputExtraFields[a].setHintColor(Theme.getColor(Theme.key_windowBackgroundWhiteHintText));
            inputExtraFields[a].setTextColor(Theme.getColor(Theme.key_windowBackgroundWhiteBlackText));
            inputExtraFields[a].setHeaderHintColor(Theme.getColor(Theme.key_windowBackgroundWhiteBlueHeader));
            inputExtraFields[a].setTransformHintToHeader(true);
            inputExtraFields[a].setBackgroundDrawable(null);
            inputExtraFields[a].setCursorColor(Theme.getColor(Theme.key_windowBackgroundWhiteBlackText));
            inputExtraFields[a].setCursorSize(AndroidUtilities.dp(20));
            inputExtraFields[a].setCursorWidth(1.5f);
            inputExtraFields[a].setLineColors(Theme.getColor(Theme.key_windowBackgroundWhiteInputField), Theme.getColor(Theme.key_windowBackgroundWhiteInputFieldActivated), Theme.getColor(Theme.key_windowBackgroundWhiteRedText3));
            inputExtraFields[a].setInputType(InputType.TYPE_CLASS_TEXT | InputType.TYPE_TEXT_FLAG_CAP_SENTENCES);
            inputExtraFields[a].setImeOptions(EditorInfo.IME_ACTION_NEXT | EditorInfo.IME_FLAG_NO_EXTRACT_UI);

            String value;
            final String key;
            HashMap<String, String> values;
            switch (a) {
                case FIELD_NATIVE_NAME:
                    key = "first_name_native";
                    values = currentValues;
                    break;
                case FIELD_NATIVE_MIDNAME:
                    key = "middle_name_native";
                    values = currentValues;
                    break;
                case FIELD_NATIVE_SURNAME:
                    key = "last_name_native";
                    values = currentValues;
                    break;
                default:
                    continue;
            }
            setFieldValues(values, inputExtraFields[a], key);
            inputExtraFields[a].setSelection(inputExtraFields[a].length());
            if (a == FIELD_NATIVE_NAME || a == FIELD_NATIVE_SURNAME || a == FIELD_NATIVE_MIDNAME) {
                inputExtraFields[a].addTextChangedListener(new TextWatcher() {

                    private boolean ignore;

                    @Override
                    public void beforeTextChanged(CharSequence s, int start, int count, int after) {

                    }

                    @Override
                    public void onTextChanged(CharSequence s, int start, int before, int count) {

                    }

                    @Override
                    public void afterTextChanged(Editable s) {
                        if (ignore) {
                            return;
                        }
                        checkFieldForError(field, key, s, false);
                    }
                });
            }

            inputExtraFields[a].setPadding(0, 0, 0, 0);
            inputExtraFields[a].setGravity((LocaleController.isRTL ? Gravity.RIGHT : Gravity.LEFT) | Gravity.CENTER_VERTICAL);
            container.addView(inputExtraFields[a], LayoutHelper.createFrame(LayoutHelper.MATCH_PARENT, LayoutHelper.MATCH_PARENT, Gravity.LEFT | Gravity.TOP, 21, 0, 21, 0));

            inputExtraFields[a].setOnEditorActionListener((textView, i, keyEvent) -> {
                if (i == EditorInfo.IME_ACTION_NEXT) {
                    int num = (Integer) textView.getTag();
                    num++;
                    if (num < inputExtraFields.length) {
                        if (inputExtraFields[num].isFocusable()) {
                            inputExtraFields[num].requestFocus();
                        } else {
                            inputExtraFields[num].dispatchTouchEvent(MotionEvent.obtain(0, 0, MotionEvent.ACTION_UP, 0, 0, 0));
                            textView.clearFocus();
                            AndroidUtilities.hideKeyboard(textView);
                        }
                    }
                    return true;
                }
                return false;
            });
        }

        nativeInfoCell = new TextInfoPrivacyCell(context);
        linearLayout2.addView(nativeInfoCell, LayoutHelper.createLinear(LayoutHelper.MATCH_PARENT, LayoutHelper.WRAP_CONTENT));

        if ((currentBotId != 0 || currentDocumentsType == null) && currentTypeValue != null && !documentOnly || currentDocumentsTypeValue != null) {
            if (currentDocumentsTypeValue != null) {
                addDocumentViews(currentDocumentsTypeValue.files);
                if (currentDocumentsTypeValue.front_side instanceof TLRPC.TL_secureFile) {
                    addDocumentViewInternal((TLRPC.TL_secureFile) currentDocumentsTypeValue.front_side, UPLOADING_TYPE_FRONT);
                }
                if (currentDocumentsTypeValue.reverse_side instanceof TLRPC.TL_secureFile) {
                    addDocumentViewInternal((TLRPC.TL_secureFile) currentDocumentsTypeValue.reverse_side, UPLOADING_TYPE_REVERSE);
                }
                if (currentDocumentsTypeValue.selfie instanceof TLRPC.TL_secureFile) {
                    addDocumentViewInternal((TLRPC.TL_secureFile) currentDocumentsTypeValue.selfie, UPLOADING_TYPE_SELFIE);
                }
                addTranslationDocumentViews(currentDocumentsTypeValue.translation);
            }

            TextSettingsCell settingsCell1 = new TextSettingsCell(context);
            settingsCell1.setTextColor(Theme.getColor(Theme.key_windowBackgroundWhiteRedText3));
            settingsCell1.setBackgroundDrawable(Theme.getSelectorDrawable(true));
            if (currentDocumentsType == null) {
                settingsCell1.setText(LocaleController.getString("PassportDeleteInfo", R.string.PassportDeleteInfo), false);
            } else {
                settingsCell1.setText(LocaleController.getString("PassportDeleteDocument", R.string.PassportDeleteDocument), false);
            }
            linearLayout2.addView(settingsCell1, LayoutHelper.createLinear(LayoutHelper.MATCH_PARENT, LayoutHelper.WRAP_CONTENT));
            settingsCell1.setOnClickListener(v -> createDocumentDeleteAlert());

            nativeInfoCell.setBackgroundDrawable(Theme.getThemedDrawable(context, R.drawable.greydivider, Theme.key_windowBackgroundGrayShadow));

            sectionCell = new ShadowSectionCell(context);
            sectionCell.setBackgroundDrawable(Theme.getThemedDrawable(context, R.drawable.greydivider_bottom, Theme.key_windowBackgroundGrayShadow));
            linearLayout2.addView(sectionCell, LayoutHelper.createLinear(LayoutHelper.MATCH_PARENT, LayoutHelper.WRAP_CONTENT));
        } else {
            nativeInfoCell.setBackgroundDrawable(Theme.getThemedDrawable(context, R.drawable.greydivider_bottom, Theme.key_windowBackgroundGrayShadow));
        }

        updateInterfaceStringsForDocumentType();
        checkNativeFields(false);
    }

    private void updateInterfaceStringsForDocumentType() {
        if (currentDocumentsType != null) {
            actionBar.setTitle(getTextForType(currentDocumentsType.type));
        } else {
            actionBar.setTitle(LocaleController.getString("PassportPersonal", R.string.PassportPersonal));
        }
        updateUploadText(UPLOADING_TYPE_FRONT);
        updateUploadText(UPLOADING_TYPE_REVERSE);
        updateUploadText(UPLOADING_TYPE_SELFIE);
        updateUploadText(UPLOADING_TYPE_TRANSLATION);
    }

    private void updateUploadText(int type) {
        if (type == UPLOADING_TYPE_DOCUMENTS) {
            if (uploadDocumentCell == null) {
                return;
            }
            if (documents.size() >= 1) {
                uploadDocumentCell.setText(LocaleController.getString("PassportUploadAdditinalDocument", R.string.PassportUploadAdditinalDocument), false);
            } else {
                uploadDocumentCell.setText(LocaleController.getString("PassportUploadDocument", R.string.PassportUploadDocument), false);
            }
        } else if (type == UPLOADING_TYPE_SELFIE) {
            if (uploadSelfieCell == null) {
                return;
            }
            uploadSelfieCell.setVisibility(selfieDocument != null ? View.GONE : View.VISIBLE);
        } else if (type == UPLOADING_TYPE_TRANSLATION) {
            if (uploadTranslationCell == null) {
                return;
            }
            if (translationDocuments.size() >= 1) {
                uploadTranslationCell.setText(LocaleController.getString("PassportUploadAdditinalDocument", R.string.PassportUploadAdditinalDocument), false);
            } else {
                uploadTranslationCell.setText(LocaleController.getString("PassportUploadDocument", R.string.PassportUploadDocument), false);
            }
        } else if (type == UPLOADING_TYPE_FRONT) {
            if (uploadFrontCell == null) {
                return;
            }
            boolean divider = currentDocumentsType != null && (
                    currentDocumentsType.selfie_required ||
                            currentDocumentsType.type instanceof TLRPC.TL_secureValueTypeIdentityCard ||
                            currentDocumentsType.type instanceof TLRPC.TL_secureValueTypeDriverLicense);
            if (currentDocumentsType.type instanceof TLRPC.TL_secureValueTypePassport || currentDocumentsType.type instanceof TLRPC.TL_secureValueTypeInternalPassport) {
                uploadFrontCell.setTextAndValue(LocaleController.getString("PassportMainPage", R.string.PassportMainPage), LocaleController.getString("PassportMainPageInfo", R.string.PassportMainPageInfo), divider);
            } else {
                uploadFrontCell.setTextAndValue(LocaleController.getString("PassportFrontSide", R.string.PassportFrontSide), LocaleController.getString("PassportFrontSideInfo", R.string.PassportFrontSideInfo), divider);
            }
            uploadFrontCell.setVisibility(frontDocument != null ? View.GONE : View.VISIBLE);
        } else if (type == UPLOADING_TYPE_REVERSE) {
            if (uploadReverseCell == null) {
                return;
            }
            if (currentDocumentsType.type instanceof TLRPC.TL_secureValueTypeIdentityCard || currentDocumentsType.type instanceof TLRPC.TL_secureValueTypeDriverLicense) {
                reverseLayout.setVisibility(View.VISIBLE);
                uploadReverseCell.setVisibility(reverseDocument != null ? View.GONE : View.VISIBLE);
            } else {
                reverseLayout.setVisibility(View.GONE);
                uploadReverseCell.setVisibility(View.GONE);
            }
        }
    }

    private void checkTopErrorCell(boolean init) {
        if (topErrorCell == null) {
            return;
        }
        SpannableStringBuilder stringBuilder = null;
        if (fieldsErrors != null && (init || errorsValues.containsKey("error_all"))) {
            String errorText = fieldsErrors.get("error_all");
            if (errorText != null) {
                stringBuilder = new SpannableStringBuilder(errorText);
                if (init) {
                    errorsValues.put("error_all", "");
                }
            }
        }
        if (documentsErrors != null && (init || errorsValues.containsKey("error_document_all"))) {
            String errorText = documentsErrors.get("error_all");
            if (errorText != null) {
                if (stringBuilder == null) {
                    stringBuilder = new SpannableStringBuilder(errorText);
                } else {
                    stringBuilder.append("\n\n").append(errorText);
                }
                if (init) {
                    errorsValues.put("error_document_all", "");
                }
            }
        }
        if (stringBuilder != null) {
            stringBuilder.setSpan(new ForegroundColorSpan(Theme.getColor(Theme.key_windowBackgroundWhiteRedText3)), 0, stringBuilder.length(), Spannable.SPAN_EXCLUSIVE_EXCLUSIVE);
            topErrorCell.setText(stringBuilder);
            topErrorCell.setVisibility(View.VISIBLE);
        } else if (topErrorCell.getVisibility() != View.GONE) {
            topErrorCell.setVisibility(View.GONE);
        }
    }

    private void addDocumentViewInternal(TLRPC.TL_secureFile f, int uploadingType) {
        SecureDocumentKey secureDocumentKey = getSecureDocumentKey(f.secret, f.file_hash);
        SecureDocument secureDocument = new SecureDocument(secureDocumentKey, f, null, null, null);
        addDocumentView(secureDocument, uploadingType);
    }

    private void addDocumentViews(ArrayList<TLRPC.SecureFile> files) {
        documents.clear();
        for (int a = 0, size = files.size(); a < size; a++) {
            TLRPC.SecureFile secureFile = files.get(a);
            if (secureFile instanceof TLRPC.TL_secureFile) {
                addDocumentViewInternal((TLRPC.TL_secureFile) secureFile, UPLOADING_TYPE_DOCUMENTS);
            }
        }
    }

    private void addTranslationDocumentViews(ArrayList<TLRPC.SecureFile> files) {
        translationDocuments.clear();
        for (int a = 0, size = files.size(); a < size; a++) {
            TLRPC.SecureFile secureFile = files.get(a);
            if (secureFile instanceof TLRPC.TL_secureFile) {
                addDocumentViewInternal((TLRPC.TL_secureFile) secureFile, UPLOADING_TYPE_TRANSLATION);
            }
        }
    }

    private void setFieldValues(HashMap<String, String> values, EditTextBoldCursor editText, String key) {
        String value;
        if ((value = values.get(key)) != null) {
            switch (key) {
                case "country_code": {
                    currentCitizeship = value;
                    String country = languageMap.get(currentCitizeship);
                    if (country != null) {
                        editText.setText(country);
                    }
                    break;
                }
                case "residence_country_code": {
                    currentResidence = value;
                    String country = languageMap.get(currentResidence);
                    if (country != null) {
                        editText.setText(country);
                    }
                    break;
                }
                case "gender":
                    if ("male".equals(value)) {
                        currentGender = value;
                        editText.setText(LocaleController.getString("PassportMale", R.string.PassportMale));
                    } else if ("female".equals(value)) {
                        currentGender = value;
                        editText.setText(LocaleController.getString("PassportFemale", R.string.PassportFemale));
                    }
                    break;
                case "expiry_date":
                    boolean ok = false;
                    if (!TextUtils.isEmpty(value)) {
                        String[] args = value.split("\\.");
                        if (args.length == 3) {
                            currentExpireDate[0] = Utilities.parseInt(args[2]);
                            currentExpireDate[1] = Utilities.parseInt(args[1]);
                            currentExpireDate[2] = Utilities.parseInt(args[0]);
                            editText.setText(value);
                            ok = true;
                        }
                    }
                    if (!ok) {
                        currentExpireDate[0] = currentExpireDate[1] = currentExpireDate[2] = 0;
                        editText.setText(LocaleController.getString("PassportNoExpireDate", R.string.PassportNoExpireDate));
                    }
                    break;
                default:
                    editText.setText(value);
                    break;
            }
        }
        if (fieldsErrors != null && (value = fieldsErrors.get(key)) != null) {
            editText.setErrorText(value);
            errorsValues.put(key, editText.getText().toString());
        } else if (documentsErrors != null && (value = documentsErrors.get(key)) != null) {
            editText.setErrorText(value);
            errorsValues.put(key, editText.getText().toString());
        }
    }

    private void addDocumentView(final SecureDocument document, final int type) {
        if (type == UPLOADING_TYPE_SELFIE) {
            selfieDocument = document;
            if (selfieLayout == null) {
                return;
            }
        } else if (type == UPLOADING_TYPE_TRANSLATION) {
            translationDocuments.add(document);
            if (translationLayout == null) {
                return;
            }
        } else if (type == UPLOADING_TYPE_FRONT) {
            frontDocument = document;
            if (frontLayout == null) {
                return;
            }
        } else if (type == UPLOADING_TYPE_REVERSE) {
            reverseDocument = document;
            if (reverseLayout == null) {
                return;
            }
        } else {
            documents.add(document);
            if (documentsLayout == null) {
                return;
            }
        }
        if (getParentActivity() == null) {
            return;
        }
        final SecureDocumentCell cell = new SecureDocumentCell(getParentActivity());

        String value;
        final String key;

        cell.setTag(document);
        cell.setBackgroundDrawable(Theme.getSelectorDrawable(true));
        String text;
        documentsCells.put(document, cell);
        String hash = getDocumentHash(document);
        if (type == UPLOADING_TYPE_SELFIE) {
            text = LocaleController.getString("PassportSelfie", R.string.PassportSelfie);
            selfieLayout.addView(cell, LayoutHelper.createLinear(LayoutHelper.MATCH_PARENT, LayoutHelper.WRAP_CONTENT));
            key = "selfie" + hash;
        } else if (type == UPLOADING_TYPE_TRANSLATION) {
            text = LocaleController.getString("AttachPhoto", R.string.AttachPhoto);
            translationLayout.addView(cell, LayoutHelper.createLinear(LayoutHelper.MATCH_PARENT, LayoutHelper.WRAP_CONTENT));
            key = "translation" + hash;
        } else if (type == UPLOADING_TYPE_FRONT) {
            if (currentDocumentsType.type instanceof TLRPC.TL_secureValueTypePassport || currentDocumentsType.type instanceof TLRPC.TL_secureValueTypeInternalPassport) {
                text = LocaleController.getString("PassportMainPage", R.string.PassportMainPage);
            } else {
                text = LocaleController.getString("PassportFrontSide", R.string.PassportFrontSide);
            }
            frontLayout.addView(cell, LayoutHelper.createLinear(LayoutHelper.MATCH_PARENT, LayoutHelper.WRAP_CONTENT));
            key = "front" + hash;
        } else if (type == UPLOADING_TYPE_REVERSE) {
            text = LocaleController.getString("PassportReverseSide", R.string.PassportReverseSide);
            reverseLayout.addView(cell, LayoutHelper.createLinear(LayoutHelper.MATCH_PARENT, LayoutHelper.WRAP_CONTENT));
            key = "reverse" + hash;
        } else {
            text = LocaleController.getString("AttachPhoto", R.string.AttachPhoto);
            documentsLayout.addView(cell, LayoutHelper.createLinear(LayoutHelper.MATCH_PARENT, LayoutHelper.WRAP_CONTENT));
            key = "files" + hash;
        }

        if (key == null || documentsErrors == null || (value = documentsErrors.get(key)) == null) {
            value = LocaleController.formatDateForBan(document.secureFile.date);
        } else {
            cell.valueTextView.setTextColor(Theme.getColor(Theme.key_windowBackgroundWhiteRedText3));
            errorsValues.put(key, "");
        }

        cell.setTextAndValueAndImage(text, value, document);
        cell.setOnClickListener(v -> {
            uploadingFileType = type;
            if (type == UPLOADING_TYPE_SELFIE) {
                currentPhotoViewerLayout = selfieLayout;
            } else if (type == UPLOADING_TYPE_TRANSLATION) {
                currentPhotoViewerLayout = translationLayout;
            } else if (type == UPLOADING_TYPE_FRONT) {
                currentPhotoViewerLayout = frontLayout;
            } else if (type == UPLOADING_TYPE_REVERSE) {
                currentPhotoViewerLayout = reverseLayout;
            } else {
                currentPhotoViewerLayout = documentsLayout;
            }
            SecureDocument document1 = (SecureDocument) v.getTag();
            PhotoViewer.getInstance().setParentActivity(getParentActivity());
            if (type == UPLOADING_TYPE_SELFIE) {
                ArrayList<SecureDocument> arrayList = new ArrayList<>();
                arrayList.add(selfieDocument);
                PhotoViewer.getInstance().openPhoto(arrayList, 0, provider);
            } else if (type == UPLOADING_TYPE_FRONT) {
                ArrayList<SecureDocument> arrayList = new ArrayList<>();
                arrayList.add(frontDocument);
                PhotoViewer.getInstance().openPhoto(arrayList, 0, provider);
            } else if (type == UPLOADING_TYPE_REVERSE) {
                ArrayList<SecureDocument> arrayList = new ArrayList<>();
                arrayList.add(reverseDocument);
                PhotoViewer.getInstance().openPhoto(arrayList, 0, provider);
            } else if (type == UPLOADING_TYPE_DOCUMENTS) {
                PhotoViewer.getInstance().openPhoto(documents, documents.indexOf(document1), provider);
            } else {
                PhotoViewer.getInstance().openPhoto(translationDocuments, translationDocuments.indexOf(document1), provider);
            }
        });
        cell.setOnLongClickListener(v -> {
            AlertDialog.Builder builder = new AlertDialog.Builder(getParentActivity());
            if (type == UPLOADING_TYPE_SELFIE) {
                builder.setMessage(LocaleController.getString("PassportDeleteSelfie", R.string.PassportDeleteSelfie));
            } else {
                builder.setMessage(LocaleController.getString("PassportDeleteScan", R.string.PassportDeleteScan));
            }
            builder.setNegativeButton(LocaleController.getString("Cancel", R.string.Cancel), null);
            builder.setTitle(LocaleController.getString("AppName", R.string.AppName));
            builder.setPositiveButton(LocaleController.getString("OK", R.string.OK), (dialog, which) -> {
                documentsCells.remove(document);
                if (type == UPLOADING_TYPE_SELFIE) {
                    selfieDocument = null;
                    selfieLayout.removeView(cell);
                } else if (type == UPLOADING_TYPE_TRANSLATION) {
                    translationDocuments.remove(document);
                    translationLayout.removeView(cell);
                } else if (type == UPLOADING_TYPE_FRONT) {
                    frontDocument = null;
                    frontLayout.removeView(cell);
                } else if (type == UPLOADING_TYPE_REVERSE) {
                    reverseDocument = null;
                    reverseLayout.removeView(cell);
                } else {
                    documents.remove(document);
                    documentsLayout.removeView(cell);
                }

                if (key != null) {
                    if (documentsErrors != null) {
                        documentsErrors.remove(key);
                    }
                    if (errorsValues != null) {
                        errorsValues.remove(key);
                    }
                }

                updateUploadText(type);
                if (document.path != null && uploadingDocuments.remove(document.path) != null) {
                    if (uploadingDocuments.isEmpty()) {
                        doneItem.setEnabled(true);
                        doneItem.setAlpha(1.0f);
                    }
                    FileLoader.getInstance(currentAccount).cancelUploadFile(document.path, false);
                }
            });
            showDialog(builder.create());
            return true;
        });
    }

    private String getNameForType(TLRPC.SecureValueType type) {
        if (type instanceof TLRPC.TL_secureValueTypePersonalDetails) {
            return "personal_details";
        } else if (type instanceof TLRPC.TL_secureValueTypePassport) {
            return "passport";
        } else if (type instanceof TLRPC.TL_secureValueTypeInternalPassport) {
            return "internal_passport";
        } else if (type instanceof TLRPC.TL_secureValueTypeDriverLicense) {
            return "driver_license";
        } else if (type instanceof TLRPC.TL_secureValueTypeIdentityCard) {
            return "identity_card";
        } else if (type instanceof TLRPC.TL_secureValueTypeUtilityBill) {
            return "utility_bill";
        } else if (type instanceof TLRPC.TL_secureValueTypeAddress) {
            return "address";
        } else if (type instanceof TLRPC.TL_secureValueTypeBankStatement) {
            return "bank_statement";
        } else if (type instanceof TLRPC.TL_secureValueTypeRentalAgreement) {
            return "rental_agreement";
        } else if (type instanceof TLRPC.TL_secureValueTypeTemporaryRegistration) {
            return "temporary_registration";
        } else if (type instanceof TLRPC.TL_secureValueTypePassportRegistration) {
            return "passport_registration";
        } else if (type instanceof TLRPC.TL_secureValueTypeEmail) {
            return "email";
        } else if (type instanceof TLRPC.TL_secureValueTypePhone) {
            return "phone";
        }
        return "";
    }

    private TextDetailSecureCell getViewByType(TLRPC.TL_secureRequiredType requiredType) {
        TextDetailSecureCell view = typesViews.get(requiredType);
        if (view == null) {
            requiredType = documentsToTypesLink.get(requiredType);
            if (requiredType != null) {
                view = typesViews.get(requiredType);
            }
        }
        return view;
    }

    private String getTextForType(TLRPC.SecureValueType type) {
        if (type instanceof TLRPC.TL_secureValueTypePassport) {
            return LocaleController.getString("ActionBotDocumentPassport", R.string.ActionBotDocumentPassport);
        } else if (type instanceof TLRPC.TL_secureValueTypeDriverLicense) {
            return LocaleController.getString("ActionBotDocumentDriverLicence", R.string.ActionBotDocumentDriverLicence);
        } else if (type instanceof TLRPC.TL_secureValueTypeIdentityCard) {
            return LocaleController.getString("ActionBotDocumentIdentityCard", R.string.ActionBotDocumentIdentityCard);
        } else if (type instanceof TLRPC.TL_secureValueTypeUtilityBill) {
            return LocaleController.getString("ActionBotDocumentUtilityBill", R.string.ActionBotDocumentUtilityBill);
        } else if (type instanceof TLRPC.TL_secureValueTypeBankStatement) {
            return LocaleController.getString("ActionBotDocumentBankStatement", R.string.ActionBotDocumentBankStatement);
        } else if (type instanceof TLRPC.TL_secureValueTypeRentalAgreement) {
            return LocaleController.getString("ActionBotDocumentRentalAgreement", R.string.ActionBotDocumentRentalAgreement);
        } else if (type instanceof TLRPC.TL_secureValueTypeInternalPassport) {
            return LocaleController.getString("ActionBotDocumentInternalPassport", R.string.ActionBotDocumentInternalPassport);
        } else if (type instanceof TLRPC.TL_secureValueTypePassportRegistration) {
            return LocaleController.getString("ActionBotDocumentPassportRegistration", R.string.ActionBotDocumentPassportRegistration);
        } else if (type instanceof TLRPC.TL_secureValueTypeTemporaryRegistration) {
            return LocaleController.getString("ActionBotDocumentTemporaryRegistration", R.string.ActionBotDocumentTemporaryRegistration);
        } else if (type instanceof TLRPC.TL_secureValueTypePhone) {
            return LocaleController.getString("ActionBotDocumentPhone", R.string.ActionBotDocumentPhone);
        } else if (type instanceof TLRPC.TL_secureValueTypeEmail) {
            return LocaleController.getString("ActionBotDocumentEmail", R.string.ActionBotDocumentEmail);
        }
        return "";
    }

    private void setTypeValue(TLRPC.TL_secureRequiredType requiredType, String text, String json, TLRPC.TL_secureRequiredType documentRequiredType, String documentsJson, boolean documentOnly, int availableDocumentTypesCount) {
        TextDetailSecureCell view = typesViews.get(requiredType);
        if (view == null) {
            if (currentActivityType == TYPE_MANAGE) {
                ArrayList<TLRPC.TL_secureRequiredType> documentTypes = new ArrayList<>();
                if (documentRequiredType != null) {
                    documentTypes.add(documentRequiredType);
                }
                View prev = linearLayout2.getChildAt(linearLayout2.getChildCount() - 6);
                if (prev instanceof TextDetailSecureCell) {
                    ((TextDetailSecureCell) prev).setNeedDivider(true);
                }
                view = addField(getParentActivity(), requiredType, documentTypes, true, true);
                updateManageVisibility();
            } else {
                return;
            }
        }
        HashMap<String, String> values = typesValues.get(requiredType);
        HashMap<String, String> documentValues = documentRequiredType != null ? typesValues.get(documentRequiredType) : null;
        TLRPC.TL_secureValue requiredTypeValue = getValueByType(requiredType, true);
        TLRPC.TL_secureValue documentRequiredTypeValue = getValueByType(documentRequiredType, true);

        if (json != null && languageMap == null) {
            languageMap = new HashMap<>();
            try {
                BufferedReader reader = new BufferedReader(new InputStreamReader(ApplicationLoader.applicationContext.getResources().getAssets().open("countries.txt")));
                String line;
                while ((line = reader.readLine()) != null) {
                    String[] args = line.split(";");
                    languageMap.put(args[1], args[2]);
                }
                reader.close();
            } catch (Exception e) {
                FileLog.e(e);
            }
        } else {
            languageMap = null;
        }

        String value = null;
        if (text != null) {
            if (requiredType.type instanceof TLRPC.TL_secureValueTypePhone) {
                value = PhoneFormat.getInstance().format("+" + text);
            } else if (requiredType.type instanceof TLRPC.TL_secureValueTypeEmail) {
                value = text;
            }
        } else {
            StringBuilder stringBuilder = null;
            if (currentActivityType != TYPE_MANAGE && documentRequiredType != null && (!TextUtils.isEmpty(documentsJson) || documentRequiredTypeValue != null)) {
                if (stringBuilder == null) {
                    stringBuilder = new StringBuilder();
                }
                if (availableDocumentTypesCount > 1) {
                    stringBuilder.append(getTextForType(documentRequiredType.type));
                } else if (TextUtils.isEmpty(documentsJson)) {
                    stringBuilder.append(LocaleController.getString("PassportDocuments", R.string.PassportDocuments));
                }
            }
            if (json != null || documentsJson != null) {
                if (values == null) {
                    return;
                }
                values.clear();
                String[] keys = null;
                String[] documentKeys = null;
                if (requiredType.type instanceof TLRPC.TL_secureValueTypePersonalDetails) {
                    if (currentActivityType == TYPE_REQUEST && !documentOnly || currentActivityType == TYPE_MANAGE && documentRequiredType == null) {
                        keys = new String[]{
                                "first_name",
                                "middle_name",
                                "last_name",
                                "first_name_native",
                                "middle_name_native",
                                "last_name_native",
                                "birth_date",
                                "gender",
                                "country_code",
                                "residence_country_code"
                        };
                    }
                    if (currentActivityType == TYPE_REQUEST || currentActivityType == TYPE_MANAGE && documentRequiredType != null) {
                        documentKeys = new String[]{
                                "document_no",
                                "expiry_date"
                        };
                    }
                } else if (requiredType.type instanceof TLRPC.TL_secureValueTypeAddress) {
                    if (currentActivityType == TYPE_REQUEST && !documentOnly || currentActivityType == TYPE_MANAGE && documentRequiredType == null) {
                        keys = new String[]{
                                "street_line1",
                                "street_line2",
                                "post_code",
                                "city",
                                "state",
                                "country_code"
                        };
                    }
                }
                if (keys != null || documentKeys != null) {
                    try {
                        JSONObject jsonObject = null;
                        String[] currentKeys = null;
                        for (int b = 0; b < 2; b++) {
                            if (b == 0) {
                                if (json != null) {
                                    jsonObject = new JSONObject(json);
                                    currentKeys = keys;
                                }
                            } else {
                                if (documentValues == null) {
                                    continue;
                                }
                                if (documentsJson != null) {
                                    jsonObject = new JSONObject(documentsJson);
                                    currentKeys = documentKeys;
                                }
                            }
                            if (currentKeys == null || jsonObject == null) {
                                continue;
                            }
                            try {
                                Iterator<String> iter = jsonObject.keys();
                                while (iter.hasNext()) {
                                    String key = iter.next();
                                    if (b == 0) {
                                        values.put(key, jsonObject.getString(key));
                                    } else {
                                        documentValues.put(key, jsonObject.getString(key));
                                    }
                                }
                            } catch (Throwable e) {
                                FileLog.e(e);
                            }

                            for (int a = 0; a < currentKeys.length; a++) {
                                if (jsonObject.has(currentKeys[a])) {
                                    if (stringBuilder == null) {
                                        stringBuilder = new StringBuilder();
                                    }
                                    String jsonValue = jsonObject.getString(currentKeys[a]);
                                    if (jsonValue != null) {
                                        if (!TextUtils.isEmpty(jsonValue)) {
                                            if ("first_name_native".equals(currentKeys[a]) ||
                                                    "middle_name_native".equals(currentKeys[a]) ||
                                                    "last_name_native".equals(currentKeys[a])) {
                                                continue;
                                            }
                                            if (stringBuilder.length() > 0) {
                                                if ("last_name".equals(currentKeys[a]) || "last_name_native".equals(currentKeys[a]) || "middle_name".equals(currentKeys[a]) || "middle_name_native".equals(currentKeys[a])) {
                                                    stringBuilder.append(" ");
                                                } else {
                                                    stringBuilder.append(", ");
                                                }
                                            }
                                            switch (currentKeys[a]) {
                                                case "country_code":
                                                case "residence_country_code":
                                                    String country = languageMap.get(jsonValue);
                                                    if (country != null) {
                                                        stringBuilder.append(country);
                                                    }
                                                    break;
                                                case "gender":
                                                    if ("male".equals(jsonValue)) {
                                                        stringBuilder.append(LocaleController.getString("PassportMale", R.string.PassportMale));
                                                    } else if ("female".equals(jsonValue)) {
                                                        stringBuilder.append(LocaleController.getString("PassportFemale", R.string.PassportFemale));
                                                    }
                                                    break;
                                                default:
                                                    stringBuilder.append(jsonValue);
                                                    break;
                                            }
                                        }
                                    }
                                }
                            }
                        }
                    } catch (Exception ignore) {

                    }
                }
            }
            if (stringBuilder != null) {
                value = stringBuilder.toString();
            }
        }

        boolean isError = false;
        HashMap<String, String> errors = !documentOnly ? errorsMap.get(getNameForType(requiredType.type)) : null;
        HashMap<String, String> documentsErrors = documentRequiredType != null ? errorsMap.get(getNameForType(documentRequiredType.type)) : null;
        if (errors != null && errors.size() > 0 || documentsErrors != null && documentsErrors.size() > 0) {
            value = null;
            if (!documentOnly) {
                value = mainErrorsMap.get(getNameForType(requiredType.type));
            }
            if (value == null) {
                value = mainErrorsMap.get(getNameForType(documentRequiredType.type));
            }
            isError = true;
        } else {
            if (requiredType.type instanceof TLRPC.TL_secureValueTypePersonalDetails) {
                if (TextUtils.isEmpty(value)) {
                    if (documentRequiredType == null) {
                        value = LocaleController.getString("PassportPersonalDetailsInfo", R.string.PassportPersonalDetailsInfo);
                    } else {
                        if (currentActivityType == TYPE_MANAGE) {
                            value = LocaleController.getString("PassportDocuments", R.string.PassportDocuments);
                        } else {
                            if (availableDocumentTypesCount == 1) {
                                if (documentRequiredType.type instanceof TLRPC.TL_secureValueTypePassport) {
                                    value = LocaleController.getString("PassportIdentityPassport", R.string.PassportIdentityPassport);
                                } else if (documentRequiredType.type instanceof TLRPC.TL_secureValueTypeInternalPassport) {
                                    value = LocaleController.getString("PassportIdentityInternalPassport", R.string.PassportIdentityInternalPassport);
                                } else if (documentRequiredType.type instanceof TLRPC.TL_secureValueTypeDriverLicense) {
                                    value = LocaleController.getString("PassportIdentityDriverLicence", R.string.PassportIdentityDriverLicence);
                                } else if (documentRequiredType.type instanceof TLRPC.TL_secureValueTypeIdentityCard) {
                                    value = LocaleController.getString("PassportIdentityID", R.string.PassportIdentityID);
                                }
                            } else {
                                value = LocaleController.getString("PassportIdentityDocumentInfo", R.string.PassportIdentityDocumentInfo);
                            }
                        }
                    }
                }
            } else if (requiredType.type instanceof TLRPC.TL_secureValueTypeAddress) {
                if (TextUtils.isEmpty(value)) {
                    if (documentRequiredType == null) {
                        value = LocaleController.getString("PassportAddressNoUploadInfo", R.string.PassportAddressNoUploadInfo);
                    } else {
                        if (currentActivityType == TYPE_MANAGE) {
                            value = LocaleController.getString("PassportDocuments", R.string.PassportDocuments);
                        } else {
                            if (availableDocumentTypesCount == 1) {
                                if (documentRequiredType.type instanceof TLRPC.TL_secureValueTypeRentalAgreement) {
                                    value = LocaleController.getString("PassportAddAgreementInfo", R.string.PassportAddAgreementInfo);
                                } else if (documentRequiredType.type instanceof TLRPC.TL_secureValueTypeUtilityBill) {
                                    value = LocaleController.getString("PassportAddBillInfo", R.string.PassportAddBillInfo);
                                } else if (documentRequiredType.type instanceof TLRPC.TL_secureValueTypePassportRegistration) {
                                    value = LocaleController.getString("PassportAddPassportRegistrationInfo", R.string.PassportAddPassportRegistrationInfo);
                                } else if (documentRequiredType.type instanceof TLRPC.TL_secureValueTypeTemporaryRegistration) {
                                    value = LocaleController.getString("PassportAddTemporaryRegistrationInfo", R.string.PassportAddTemporaryRegistrationInfo);
                                } else if (documentRequiredType.type instanceof TLRPC.TL_secureValueTypeBankStatement) {
                                    value = LocaleController.getString("PassportAddBankInfo", R.string.PassportAddBankInfo);
                                }
                            } else {
                                value = LocaleController.getString("PassportAddressInfo", R.string.PassportAddressInfo);
                            }
                        }
                    }
                }
            } else if (requiredType.type instanceof TLRPC.TL_secureValueTypePhone) {
                if (TextUtils.isEmpty(value)) {
                    value = LocaleController.getString("PassportPhoneInfo", R.string.PassportPhoneInfo);
                }
            } else if (requiredType.type instanceof TLRPC.TL_secureValueTypeEmail) {
                if (TextUtils.isEmpty(value)) {
                    value = LocaleController.getString("PassportEmailInfo", R.string.PassportEmailInfo);
                }
            }
        }
        view.setValue(value);
        view.valueTextView.setTextColor(Theme.getColor(isError ? Theme.key_windowBackgroundWhiteRedText3 : Theme.key_windowBackgroundWhiteGrayText2));
        view.setChecked(!isError && currentActivityType != TYPE_MANAGE && (documentOnly && documentRequiredType != null || !documentOnly && requiredTypeValue != null) && (documentRequiredType == null || documentRequiredTypeValue != null));
    }

    private void checkNativeFields(boolean byEdit) {
        if (inputExtraFields == null) {
            return;
        }
        String country = languageMap.get(currentResidence);
        HashMap<String, String> map = SharedConfig.getCountryLangs();
        String lang = map.get(currentResidence);

        if (!currentType.native_names || TextUtils.isEmpty(currentResidence) || "EN".equals(lang)) {
            if (nativeInfoCell.getVisibility() != View.GONE) {
                nativeInfoCell.setVisibility(View.GONE);
                headerCell.setVisibility(View.GONE);
                extraBackgroundView2.setVisibility(View.GONE);
                for (int a = 0; a < inputExtraFields.length; a++) {
                    ((View) inputExtraFields[a].getParent()).setVisibility(View.GONE);
                }

                if ((currentBotId != 0 || currentDocumentsType == null) && currentTypeValue != null && !documentOnly || currentDocumentsTypeValue != null) {
                    sectionCell2.setBackgroundDrawable(Theme.getThemedDrawable(getParentActivity(), R.drawable.greydivider, Theme.key_windowBackgroundGrayShadow));
                } else {
                    sectionCell2.setBackgroundDrawable(Theme.getThemedDrawable(getParentActivity(), R.drawable.greydivider_bottom, Theme.key_windowBackgroundGrayShadow));
                }
            }
        } else {
            if (nativeInfoCell.getVisibility() != View.VISIBLE) {
                nativeInfoCell.setVisibility(View.VISIBLE);
                headerCell.setVisibility(View.VISIBLE);
                extraBackgroundView2.setVisibility(View.VISIBLE);
                for (int a = 0; a < inputExtraFields.length; a++) {
                    ((View) inputExtraFields[a].getParent()).setVisibility(View.VISIBLE);
                }
                if (inputExtraFields[FIELD_NATIVE_NAME].length() == 0 && inputExtraFields[FIELD_NATIVE_MIDNAME].length() == 0 && inputExtraFields[FIELD_NATIVE_SURNAME].length() == 0) {
                    for (int a = 0; a < nonLatinNames.length; a++) {
                        if (nonLatinNames[a]) {
                            inputExtraFields[FIELD_NATIVE_NAME].setText(inputFields[FIELD_NAME].getText());
                            inputExtraFields[FIELD_NATIVE_MIDNAME].setText(inputFields[FIELD_MIDNAME].getText());
                            inputExtraFields[FIELD_NATIVE_SURNAME].setText(inputFields[FIELD_SURNAME].getText());
                            break;
                        }
                    }
                }
                sectionCell2.setBackgroundDrawable(Theme.getThemedDrawable(getParentActivity(), R.drawable.greydivider, Theme.key_windowBackgroundGrayShadow));
            }

            nativeInfoCell.setText(LocaleController.formatString("PassportNativeInfo", R.string.PassportNativeInfo, country));


            String header = lang != null ? LocaleController.getServerString("PassportLanguage_" + lang) : null;
            if (header != null) {
                headerCell.setText(LocaleController.formatString("PassportNativeHeaderLang", R.string.PassportNativeHeaderLang, header));
            } else {
                headerCell.setText(LocaleController.getString("PassportNativeHeader", R.string.PassportNativeHeader));
            }
            for (int a = 0; a < FIELD_NATIVE_COUNT; a++) {
                switch (a) {
                    case FIELD_NATIVE_NAME:
                        if (header != null) {
                            inputExtraFields[a].setHintText(LocaleController.getString("PassportName", R.string.PassportName));
                        } else {
                            inputExtraFields[a].setHintText(LocaleController.formatString("PassportNameCountry", R.string.PassportNameCountry, country));
                        }
                        break;
                    case FIELD_NATIVE_MIDNAME:
                        if (header != null) {
                            inputExtraFields[a].setHintText(LocaleController.getString("PassportMidname", R.string.PassportMidname));
                        } else {
                            inputExtraFields[a].setHintText(LocaleController.formatString("PassportMidnameCountry", R.string.PassportMidnameCountry, country));
                        }
                        break;
                    case FIELD_NATIVE_SURNAME:
                        if (header != null) {
                            inputExtraFields[a].setHintText(LocaleController.getString("PassportSurname", R.string.PassportSurname));
                        } else {
                            inputExtraFields[a].setHintText(LocaleController.formatString("PassportSurnameCountry", R.string.PassportSurnameCountry, country));
                        }
                        break;
                }
            }

            if (byEdit) {
                AndroidUtilities.runOnUIThread(() -> {
                    if (inputExtraFields != null) {
                        scrollToField(inputExtraFields[FIELD_NATIVE_NAME]);
                    }
                });

            }
        }
    }

    private String getErrorsString(HashMap<String, String> errors, HashMap<String, String> documentErrors) {
        StringBuilder stringBuilder = new StringBuilder();
        for (int a = 0; a < 2; a++) {
            HashMap<String, String> hashMap;
            if (a == 0) {
                hashMap = errors;
            } else {
                hashMap = documentErrors;
            }
            if (hashMap == null) {
                continue;
            }
            for (HashMap.Entry<String, String> entry : hashMap.entrySet()) {
                String value = entry.getValue();
                if (stringBuilder.length() > 0) {
                    stringBuilder.append(", ");
                    value = value.toLowerCase();
                }
                if (value.endsWith(".")) {
                    value = value.substring(0, value.length() - 1);
                }
                stringBuilder.append(value);
            }
        }
        if (stringBuilder.length() > 0) {
            stringBuilder.append('.');
        }
        return stringBuilder.toString();
    }

    private TLRPC.TL_secureValue getValueByType(TLRPC.TL_secureRequiredType requiredType, boolean check) {
        if (requiredType == null) {
            return null;
        }
        for (int a = 0, size = currentForm.values.size(); a < size; a++) {
            TLRPC.TL_secureValue secureValue = currentForm.values.get(a);
            if (requiredType.type.getClass() == secureValue.type.getClass()) {
                if (check) {
                    if (requiredType.selfie_required) {
                        if (!(secureValue.selfie instanceof TLRPC.TL_secureFile)) {
                            return null;
                        }
                    }
                    if (requiredType.translation_required) {
                        if (secureValue.translation.isEmpty()) {
                            return null;
                        }
                    }
                    if (isAddressDocument(requiredType.type)) {
                        if (secureValue.files.isEmpty()) {
                            return null;
                        }
                    }
                    if (isPersonalDocument(requiredType.type)) {
                        if (!(secureValue.front_side instanceof TLRPC.TL_secureFile)) {
                            return null;
                        }
                    }
                    if (requiredType.type instanceof TLRPC.TL_secureValueTypeDriverLicense || requiredType.type instanceof TLRPC.TL_secureValueTypeIdentityCard) {
                        if (!(secureValue.reverse_side instanceof TLRPC.TL_secureFile)) {
                            return null;
                        }
                    }
                    if (requiredType.type instanceof TLRPC.TL_secureValueTypePersonalDetails || requiredType.type instanceof TLRPC.TL_secureValueTypeAddress) {
                        String[] keys;
                        if (requiredType.type instanceof TLRPC.TL_secureValueTypePersonalDetails) {
                            if (requiredType.native_names) {
                                keys = new String[]{
                                        "first_name_native",
                                        "last_name_native",
                                        "birth_date",
                                        "gender",
                                        "country_code",
                                        "residence_country_code"
                                };
                            } else {
                                keys = new String[]{
                                        "first_name",
                                        "last_name",
                                        "birth_date",
                                        "gender",
                                        "country_code",
                                        "residence_country_code"
                                };
                            }
                        } else {
                            keys = new String[]{
                                    "street_line1",
                                    "street_line2",
                                    "post_code",
                                    "city",
                                    "state",
                                    "country_code"
                            };
                        }
                        try {
                            JSONObject jsonObject = new JSONObject(decryptData(secureValue.data.data, decryptValueSecret(secureValue.data.secret, secureValue.data.data_hash), secureValue.data.data_hash));
                            for (int b = 0; b < keys.length; b++) {
                                if (!jsonObject.has(keys[b]) || TextUtils.isEmpty(jsonObject.getString(keys[b]))) {
                                    return null;
                                }
                            }
                        } catch (Throwable ignore) {
                            return null;
                        }
                    }
                }
                return secureValue;
            }
        }
        return null;
    }

    private void openTypeActivity(TLRPC.TL_secureRequiredType requiredType, TLRPC.TL_secureRequiredType documentRequiredType, ArrayList<TLRPC.TL_secureRequiredType> availableDocumentTypes, boolean documentOnly) {
        int activityType = -1;
        final int availableDocumentTypesCount = availableDocumentTypes != null ? availableDocumentTypes.size() : 0;
        TLRPC.SecureValueType type = requiredType.type;
        TLRPC.SecureValueType documentType = documentRequiredType != null ? documentRequiredType.type : null;
        if (type instanceof TLRPC.TL_secureValueTypePersonalDetails) {
            activityType = TYPE_IDENTITY;
        } else if (type instanceof TLRPC.TL_secureValueTypeAddress) {
            activityType = TYPE_ADDRESS;
        } else if (type instanceof TLRPC.TL_secureValueTypePhone) {
            activityType = TYPE_PHONE;
        } else if (type instanceof TLRPC.TL_secureValueTypeEmail) {
            activityType = TYPE_EMAIL;
        }
        if (activityType != -1) {
            HashMap<String, String> errors = !documentOnly ? errorsMap.get(getNameForType(type)) : null;
            HashMap<String, String> documentsErrors = errorsMap.get(getNameForType(documentType));
            TLRPC.TL_secureValue value = getValueByType(requiredType, false);
            TLRPC.TL_secureValue documentsValue = getValueByType(documentRequiredType, false);

            final PassportActivity activity = new PassportActivity(activityType, currentForm, currentPassword, requiredType, value, documentRequiredType, documentsValue, typesValues.get(requiredType), documentRequiredType != null ? typesValues.get(documentRequiredType) : null);
            activity.delegate = new PassportActivityDelegate() {

                private TLRPC.InputSecureFile getInputSecureFile(SecureDocument document) {
                    if (document.inputFile != null) {
                        TLRPC.TL_inputSecureFileUploaded inputSecureFileUploaded = new TLRPC.TL_inputSecureFileUploaded();
                        inputSecureFileUploaded.id = document.inputFile.id;
                        inputSecureFileUploaded.parts = document.inputFile.parts;
                        inputSecureFileUploaded.md5_checksum = document.inputFile.md5_checksum;
                        inputSecureFileUploaded.file_hash = document.fileHash;
                        inputSecureFileUploaded.secret = document.fileSecret;
                        return inputSecureFileUploaded;
                    } else {
                        TLRPC.TL_inputSecureFile inputSecureFile = new TLRPC.TL_inputSecureFile();
                        inputSecureFile.id = document.secureFile.id;
                        inputSecureFile.access_hash = document.secureFile.access_hash;
                        return inputSecureFile;
                    }
                }

                private void renameFile(SecureDocument oldDocument, TLRPC.TL_secureFile newSecureFile) {
                    File oldFile = FileLoader.getPathToAttach(oldDocument);
                    String oldKey = oldDocument.secureFile.dc_id + "_" + oldDocument.secureFile.id;
                    File newFile = FileLoader.getPathToAttach(newSecureFile);
                    String newKey = newSecureFile.dc_id + "_" + newSecureFile.id;
                    oldFile.renameTo(newFile);
                    ImageLoader.getInstance().replaceImageInCache(oldKey, newKey, null, false);
                }

                @Override
                public void saveValue(final TLRPC.TL_secureRequiredType requiredType, final String text, final String json, final TLRPC.TL_secureRequiredType documentRequiredType, final String documentsJson, final ArrayList<SecureDocument> documents, final SecureDocument selfie, final ArrayList<SecureDocument> translationDocuments, final SecureDocument front, final SecureDocument reverse, final Runnable finishRunnable, final ErrorRunnable errorRunnable) {
                    TLRPC.TL_inputSecureValue inputSecureValue = null;

                    if (!TextUtils.isEmpty(json)) {
                        inputSecureValue = new TLRPC.TL_inputSecureValue();
                        inputSecureValue.type = requiredType.type;
                        inputSecureValue.flags |= 1;

                        EncryptionResult result = encryptData(AndroidUtilities.getStringBytes(json));
                        inputSecureValue.data = new TLRPC.TL_secureData();
                        inputSecureValue.data.data = result.encryptedData;
                        inputSecureValue.data.data_hash = result.fileHash;
                        inputSecureValue.data.secret = result.fileSecret;
                    } else if (!TextUtils.isEmpty(text)) {
                        TLRPC.SecurePlainData plainData;
                        if (type instanceof TLRPC.TL_secureValueTypeEmail) {
                            TLRPC.TL_securePlainEmail securePlainEmail = new TLRPC.TL_securePlainEmail();
                            securePlainEmail.email = text;
                            plainData = securePlainEmail;
                        } else if (type instanceof TLRPC.TL_secureValueTypePhone) {
                            TLRPC.TL_securePlainPhone securePlainPhone = new TLRPC.TL_securePlainPhone();
                            securePlainPhone.phone = text;
                            plainData = securePlainPhone;
                        } else {
                            return;
                        }
                        inputSecureValue = new TLRPC.TL_inputSecureValue();
                        inputSecureValue.type = requiredType.type;
                        inputSecureValue.flags |= 32;

                        inputSecureValue.plain_data = plainData;
                    }

                    if (!documentOnly && inputSecureValue == null) {
                        if (errorRunnable != null) {
                            errorRunnable.onError(null, null);
                        }
                        return;
                    }

                    TLRPC.TL_inputSecureValue fileInputSecureValue;
                    if (documentRequiredType != null) {
                        fileInputSecureValue = new TLRPC.TL_inputSecureValue();
                        fileInputSecureValue.type = documentRequiredType.type;

                        if (!TextUtils.isEmpty(documentsJson)) {
                            fileInputSecureValue.flags |= 1;

                            EncryptionResult result = encryptData(AndroidUtilities.getStringBytes(documentsJson));
                            fileInputSecureValue.data = new TLRPC.TL_secureData();
                            fileInputSecureValue.data.data = result.encryptedData;
                            fileInputSecureValue.data.data_hash = result.fileHash;
                            fileInputSecureValue.data.secret = result.fileSecret;
                        }

                        if (front != null) {
                            fileInputSecureValue.front_side = getInputSecureFile(front);
                            fileInputSecureValue.flags |= 2;
                        }
                        if (reverse != null) {
                            fileInputSecureValue.reverse_side = getInputSecureFile(reverse);
                            fileInputSecureValue.flags |= 4;
                        }
                        if (selfie != null) {
                            fileInputSecureValue.selfie = getInputSecureFile(selfie);
                            fileInputSecureValue.flags |= 8;
                        }
                        if (translationDocuments != null && !translationDocuments.isEmpty()) {
                            fileInputSecureValue.flags |= 64;
                            for (int a = 0, size = translationDocuments.size(); a < size; a++) {
                                fileInputSecureValue.translation.add(getInputSecureFile(translationDocuments.get(a)));
                            }
                        }
                        if (documents != null && !documents.isEmpty()) {
                            fileInputSecureValue.flags |= 16;
                            for (int a = 0, size = documents.size(); a < size; a++) {
                                fileInputSecureValue.files.add(getInputSecureFile(documents.get(a)));
                            }
                        }

                        if (documentOnly) {
                            inputSecureValue = fileInputSecureValue;
                            fileInputSecureValue = null;
                        }
                    } else {
                        fileInputSecureValue = null;
                    }

                    final PassportActivityDelegate currentDelegate = this;
                    final TLRPC.TL_inputSecureValue finalFileInputSecureValue = fileInputSecureValue;

                    final TLRPC.TL_account_saveSecureValue req = new TLRPC.TL_account_saveSecureValue();
                    req.value = inputSecureValue;
                    req.secure_secret_id = secureSecretId;
                    ConnectionsManager.getInstance(currentAccount).sendRequest(req, new RequestDelegate() {

                        private void onResult(final TLRPC.TL_error error, final TLRPC.TL_secureValue newValue, final TLRPC.TL_secureValue newPendingValue) {
                            AndroidUtilities.runOnUIThread(() -> {
                                if (error != null) {
                                    if (errorRunnable != null) {
                                        errorRunnable.onError(error.text, text);
                                    }
                                    AlertsCreator.processError(currentAccount, error, PassportActivity.this, req, text);
                                } else {
                                    if (documentOnly) {
                                        if (documentRequiredType != null) {
                                            removeValue(documentRequiredType);
                                        } else {
                                            removeValue(requiredType);
                                        }
                                    } else {
                                        removeValue(requiredType);
                                        removeValue(documentRequiredType);
                                    }
                                    if (newValue != null) {
                                        currentForm.values.add(newValue);
                                    }
                                    if (newPendingValue != null) {
                                        currentForm.values.add(newPendingValue);
                                    }
                                    if (documents != null && !documents.isEmpty()) {
                                        for (int a = 0, size = documents.size(); a < size; a++) {
                                            SecureDocument document = documents.get(a);
                                            if (document.inputFile != null) {
                                                for (int b = 0, size2 = newValue.files.size(); b < size2; b++) {
                                                    TLRPC.SecureFile file = newValue.files.get(b);
                                                    if (file instanceof TLRPC.TL_secureFile) {
                                                        TLRPC.TL_secureFile secureFile = (TLRPC.TL_secureFile) file;
                                                        if (Utilities.arraysEquals(document.fileSecret, 0, secureFile.secret, 0)) {
                                                            renameFile(document, secureFile);
                                                            break;
                                                        }
                                                    }
                                                }
                                            }
                                        }
                                    }
                                    if (selfie != null && selfie.inputFile != null && newValue.selfie instanceof TLRPC.TL_secureFile) {
                                        TLRPC.TL_secureFile secureFile = (TLRPC.TL_secureFile) newValue.selfie;
                                        if (Utilities.arraysEquals(selfie.fileSecret, 0, secureFile.secret, 0)) {
                                            renameFile(selfie, secureFile);
                                        }
                                    }
                                    if (front != null && front.inputFile != null && newValue.front_side instanceof TLRPC.TL_secureFile) {
                                        TLRPC.TL_secureFile secureFile = (TLRPC.TL_secureFile) newValue.front_side;
                                        if (Utilities.arraysEquals(front.fileSecret, 0, secureFile.secret, 0)) {
                                            renameFile(front, secureFile);
                                        }
                                    }
                                    if (reverse != null && reverse.inputFile != null && newValue.reverse_side instanceof TLRPC.TL_secureFile) {
                                        TLRPC.TL_secureFile secureFile = (TLRPC.TL_secureFile) newValue.reverse_side;
                                        if (Utilities.arraysEquals(reverse.fileSecret, 0, secureFile.secret, 0)) {
                                            renameFile(reverse, secureFile);
                                        }
                                    }
                                    if (translationDocuments != null && !translationDocuments.isEmpty()) {
                                        for (int a = 0, size = translationDocuments.size(); a < size; a++) {
                                            SecureDocument document = translationDocuments.get(a);
                                            if (document.inputFile != null) {
                                                for (int b = 0, size2 = newValue.translation.size(); b < size2; b++) {
                                                    TLRPC.SecureFile file = newValue.translation.get(b);
                                                    if (file instanceof TLRPC.TL_secureFile) {
                                                        TLRPC.TL_secureFile secureFile = (TLRPC.TL_secureFile) file;
                                                        if (Utilities.arraysEquals(document.fileSecret, 0, secureFile.secret, 0)) {
                                                            renameFile(document, secureFile);
                                                            break;
                                                        }
                                                    }
                                                }
                                            }
                                        }
                                    }

                                    setTypeValue(requiredType, text, json, documentRequiredType, documentsJson, documentOnly, availableDocumentTypesCount);
                                    if (finishRunnable != null) {
                                        finishRunnable.run();
                                    }
                                }
                            });
                        }

                        @Override
                        public void run(final TLObject response, final TLRPC.TL_error error) {
                            if (error != null) {
                                if (error.text.equals("EMAIL_VERIFICATION_NEEDED")) {
                                    TLRPC.TL_account_sendVerifyEmailCode req = new TLRPC.TL_account_sendVerifyEmailCode();
                                    req.email = text;
                                    ConnectionsManager.getInstance(currentAccount).sendRequest(req, (response1, error1) -> AndroidUtilities.runOnUIThread(() -> {
                                        if (response1 != null) {
                                            TLRPC.TL_account_sentEmailCode res = (TLRPC.TL_account_sentEmailCode) response1;
                                            HashMap<String, String> values = new HashMap<>();
                                            values.put("email", text);
                                            values.put("pattern", res.email_pattern);
                                            PassportActivity activity1 = new PassportActivity(TYPE_EMAIL_VERIFICATION, currentForm, currentPassword, requiredType, null, null, null, values, null);
                                            activity1.currentAccount = currentAccount;
                                            activity1.emailCodeLength = res.length;
                                            activity1.saltedPassword = saltedPassword;
                                            activity1.secureSecret = secureSecret;
                                            activity1.delegate = currentDelegate;
                                            presentFragment(activity1, true);
                                        } else {
                                            showAlertWithText(LocaleController.getString("PassportEmail", R.string.PassportEmail), error1.text);
                                            if (errorRunnable != null) {
                                                errorRunnable.onError(error1.text, text);
                                            }
                                        }
                                    }));
                                    return;
                                } else if (error.text.equals("PHONE_VERIFICATION_NEEDED")) {
                                    AndroidUtilities.runOnUIThread(() -> errorRunnable.onError(error.text, text));
                                    return;
                                }
                            }
                            if (error == null && finalFileInputSecureValue != null) {
                                final TLRPC.TL_secureValue pendingValue = (TLRPC.TL_secureValue) response;
                                final TLRPC.TL_account_saveSecureValue req = new TLRPC.TL_account_saveSecureValue();
                                req.value = finalFileInputSecureValue;
                                req.secure_secret_id = secureSecretId;
                                ConnectionsManager.getInstance(currentAccount).sendRequest(req, (response12, error12) -> onResult(error12, (TLRPC.TL_secureValue) response12, pendingValue));
                            } else {
                                onResult(error, (TLRPC.TL_secureValue) response, null);
                            }
                        }
                    });
                }

                @Override
                public SecureDocument saveFile(TLRPC.TL_secureFile secureFile) {
                    String path = FileLoader.getDirectory(FileLoader.MEDIA_DIR_CACHE) + "/" + secureFile.dc_id + "_" + secureFile.id + ".jpg";
                    EncryptionResult result = createSecureDocument(path);
                    return new SecureDocument(result.secureDocumentKey, secureFile, path, result.fileHash, result.fileSecret);
                }

                @Override
                public void deleteValue(TLRPC.TL_secureRequiredType requiredType, TLRPC.TL_secureRequiredType documentRequiredType, ArrayList<TLRPC.TL_secureRequiredType> documentRequiredTypes, boolean deleteType, Runnable finishRunnable, ErrorRunnable errorRunnable) {
                    deleteValueInternal(requiredType, documentRequiredType, documentRequiredTypes, deleteType, finishRunnable, errorRunnable, documentOnly);
                }
            };
            activity.currentAccount = currentAccount;
            activity.saltedPassword = saltedPassword;
            activity.secureSecret = secureSecret;
            activity.currentBotId = currentBotId;
            activity.fieldsErrors = errors;
            activity.documentOnly = documentOnly;
            activity.documentsErrors = documentsErrors;
            activity.availableDocumentTypes = availableDocumentTypes;
            if (activityType == TYPE_EMAIL) {
                activity.currentEmail = currentEmail;
            }
            presentFragment(activity);
        }
    }

    private TLRPC.TL_secureValue removeValue(TLRPC.TL_secureRequiredType requiredType) {
        if (requiredType == null) {
            return null;
        }
        for (int a = 0, size = currentForm.values.size(); a < size; a++) {
            TLRPC.TL_secureValue secureValue = currentForm.values.get(a);
            if (requiredType.type.getClass() == secureValue.type.getClass()) {
                return currentForm.values.remove(a);
            }
        }
        return null;
    }

    private void deleteValueInternal(final TLRPC.TL_secureRequiredType requiredType, final TLRPC.TL_secureRequiredType documentRequiredType, final ArrayList<TLRPC.TL_secureRequiredType> documentRequiredTypes, final boolean deleteType, final Runnable finishRunnable, final ErrorRunnable errorRunnable, boolean documentOnly) {
        if (requiredType == null) {
            return;
        }
        TLRPC.TL_account_deleteSecureValue req = new TLRPC.TL_account_deleteSecureValue();
        if (documentOnly && documentRequiredType != null) {
            req.types.add(documentRequiredType.type);
        } else {
            if (deleteType) {
                req.types.add(requiredType.type);
            }
            if (documentRequiredType != null) {
                req.types.add(documentRequiredType.type);
            }
        }
        ConnectionsManager.getInstance(currentAccount).sendRequest(req, (response, error) -> AndroidUtilities.runOnUIThread(() -> {
            if (error != null) {
                if (errorRunnable != null) {
                    errorRunnable.onError(error.text, null);
                }
                showAlertWithText(LocaleController.getString("AppName", R.string.AppName), error.text);
            } else {
                if (documentOnly) {
                    if (documentRequiredType != null) {
                        removeValue(documentRequiredType);
                    } else {
                        removeValue(requiredType);
                    }
                } else {
                    if (deleteType) {
                        removeValue(requiredType);
                    }
                    removeValue(documentRequiredType);
                }
                if (currentActivityType == TYPE_MANAGE) {
                    TextDetailSecureCell view = typesViews.remove(requiredType);
                    if (view != null) {
                        linearLayout2.removeView(view);
                        View child = linearLayout2.getChildAt(linearLayout2.getChildCount() - 6);
                        if (child instanceof TextDetailSecureCell) {
                            ((TextDetailSecureCell) child).setNeedDivider(false);
                        }
                    }
                    updateManageVisibility();
                } else {

                    String documentJson = null;
                    TLRPC.TL_secureRequiredType documentsType = documentRequiredType;
                    if (documentsType != null && documentRequiredTypes != null && documentRequiredTypes.size() > 1) {
                        for (int a = 0, count = documentRequiredTypes.size(); a < count; a++) {
                            TLRPC.TL_secureRequiredType documentType = documentRequiredTypes.get(a);
                            TLRPC.TL_secureValue documentValue = getValueByType(documentType, false);
                            if (documentValue != null) {
                                if (documentValue.data != null) {
                                    documentJson = decryptData(documentValue.data.data, decryptValueSecret(documentValue.data.secret, documentValue.data.data_hash), documentValue.data.data_hash);
                                }
                                documentsType = documentType;
                                break;
                            }
                        }
                        if (documentsType == null) {
                            documentsType = documentRequiredTypes.get(0);
                        }
                    }

                    if (deleteType) {
                        setTypeValue(requiredType, null, null, documentsType, documentJson, documentOnly, documentRequiredTypes != null ? documentRequiredTypes.size() : 0);
                    } else {
                        String json = null;
                        TLRPC.TL_secureValue value = getValueByType(requiredType, false);
                        if (value != null && value.data != null) {
                            json = decryptData(value.data.data, decryptValueSecret(value.data.secret, value.data.data_hash), value.data.data_hash);
                        }
                        setTypeValue(requiredType, null, json, documentsType, documentJson, documentOnly, documentRequiredTypes != null ? documentRequiredTypes.size() : 0);
                    }
                }
                if (finishRunnable != null) {
                    finishRunnable.run();
                }
            }
        }));
    }

    private TextDetailSecureCell addField(Context context, final TLRPC.TL_secureRequiredType requiredType, final ArrayList<TLRPC.TL_secureRequiredType> documentRequiredTypes, boolean documentOnly, boolean last) {
        final int availableDocumentTypesCount = documentRequiredTypes != null ? documentRequiredTypes.size() : 0;
        TextDetailSecureCell view = new TextDetailSecureCell(context);
        view.setBackgroundDrawable(Theme.getSelectorDrawable(true));
        if (requiredType.type instanceof TLRPC.TL_secureValueTypePersonalDetails) {
            String text;
            if (documentRequiredTypes == null || documentRequiredTypes.isEmpty()) {
                text = LocaleController.getString("PassportPersonalDetails", R.string.PassportPersonalDetails);
            } else if (documentOnly && documentRequiredTypes.size() == 1) {
                text = getTextForType(documentRequiredTypes.get(0).type);
            } else if (documentOnly && documentRequiredTypes.size() == 2) {
                text = LocaleController.formatString("PassportTwoDocuments", R.string.PassportTwoDocuments, getTextForType(documentRequiredTypes.get(0).type), getTextForType(documentRequiredTypes.get(1).type));
            } else {
                text = LocaleController.getString("PassportIdentityDocument", R.string.PassportIdentityDocument);
            }
            view.setTextAndValue(text, "", !last);
        } else if (requiredType.type instanceof TLRPC.TL_secureValueTypeAddress) {
            String text;
            if (documentRequiredTypes == null || documentRequiredTypes.isEmpty()) {
                text = LocaleController.getString("PassportAddress", R.string.PassportAddress);
            } else if (documentOnly && documentRequiredTypes.size() == 1) {
                text = getTextForType(documentRequiredTypes.get(0).type);
            } else if (documentOnly && documentRequiredTypes.size() == 2) {
                text = LocaleController.formatString("PassportTwoDocuments", R.string.PassportTwoDocuments, getTextForType(documentRequiredTypes.get(0).type), getTextForType(documentRequiredTypes.get(1).type));
            } else {
                text = LocaleController.getString("PassportResidentialAddress", R.string.PassportResidentialAddress);
            }
            view.setTextAndValue(text, "", !last);
        } else if (requiredType.type instanceof TLRPC.TL_secureValueTypePhone) {
            view.setTextAndValue(LocaleController.getString("PassportPhone", R.string.PassportPhone), "", !last);
        } else if (requiredType.type instanceof TLRPC.TL_secureValueTypeEmail) {
            view.setTextAndValue(LocaleController.getString("PassportEmail", R.string.PassportEmail), "", !last);
        }
        if (currentActivityType == TYPE_MANAGE) {
            linearLayout2.addView(view, linearLayout2.getChildCount() - 5, LayoutHelper.createLinear(LayoutHelper.MATCH_PARENT, LayoutHelper.WRAP_CONTENT));
        } else {
            linearLayout2.addView(view, LayoutHelper.createLinear(LayoutHelper.MATCH_PARENT, LayoutHelper.WRAP_CONTENT));
        }
        view.setOnClickListener(v -> {
            TLRPC.TL_secureRequiredType documentsType = null;
            if (documentRequiredTypes != null) {
                for (int a = 0, count = documentRequiredTypes.size(); a < count; a++) {
                    TLRPC.TL_secureRequiredType documentType = documentRequiredTypes.get(a);
                    if (getValueByType(documentType, false) != null || count == 1) {
                        documentsType = documentType;
                        break;
                    }
                }
            }
            if (requiredType.type instanceof TLRPC.TL_secureValueTypePersonalDetails || requiredType.type instanceof TLRPC.TL_secureValueTypeAddress) {
                if (documentsType == null && documentRequiredTypes != null && !documentRequiredTypes.isEmpty()) {
                    AlertDialog.Builder builder = new AlertDialog.Builder(getParentActivity());
                    builder.setPositiveButton(LocaleController.getString("Cancel", R.string.Cancel), null);

                    if (requiredType.type instanceof TLRPC.TL_secureValueTypePersonalDetails) {
                        builder.setTitle(LocaleController.getString("PassportIdentityDocument", R.string.PassportIdentityDocument));
                    } else if (requiredType.type instanceof TLRPC.TL_secureValueTypeAddress) {
                        builder.setTitle(LocaleController.getString("PassportAddress", R.string.PassportAddress));
                    }

                    ArrayList<String> strings = new ArrayList<>();
                    for (int a = 0, count = documentRequiredTypes.size(); a < count; a++) {
                        TLRPC.TL_secureRequiredType documentType = documentRequiredTypes.get(a);
                        if (documentType.type instanceof TLRPC.TL_secureValueTypeDriverLicense) {
                            strings.add(LocaleController.getString("PassportAddLicence", R.string.PassportAddLicence));
                        } else if (documentType.type instanceof TLRPC.TL_secureValueTypePassport) {
                            strings.add(LocaleController.getString("PassportAddPassport", R.string.PassportAddPassport));
                        } else if (documentType.type instanceof TLRPC.TL_secureValueTypeInternalPassport) {
                            strings.add(LocaleController.getString("PassportAddInternalPassport", R.string.PassportAddInternalPassport));
                        } else if (documentType.type instanceof TLRPC.TL_secureValueTypeIdentityCard) {
                            strings.add(LocaleController.getString("PassportAddCard", R.string.PassportAddCard));
                        } else if (documentType.type instanceof TLRPC.TL_secureValueTypeUtilityBill) {
                            strings.add(LocaleController.getString("PassportAddBill", R.string.PassportAddBill));
                        } else if (documentType.type instanceof TLRPC.TL_secureValueTypeBankStatement) {
                            strings.add(LocaleController.getString("PassportAddBank", R.string.PassportAddBank));
                        } else if (documentType.type instanceof TLRPC.TL_secureValueTypeRentalAgreement) {
                            strings.add(LocaleController.getString("PassportAddAgreement", R.string.PassportAddAgreement));
                        } else if (documentType.type instanceof TLRPC.TL_secureValueTypeTemporaryRegistration) {
                            strings.add(LocaleController.getString("PassportAddTemporaryRegistration", R.string.PassportAddTemporaryRegistration));
                        } else if (documentType.type instanceof TLRPC.TL_secureValueTypePassportRegistration) {
                            strings.add(LocaleController.getString("PassportAddPassportRegistration", R.string.PassportAddPassportRegistration));
                        }
                    }

                    builder.setItems(strings.toArray(new CharSequence[0]), (dialog, which) -> openTypeActivity(requiredType, documentRequiredTypes.get(which), documentRequiredTypes, documentOnly));
                    showDialog(builder.create());
                    return;
                }
            } else {
                boolean phoneField;
                if ((phoneField = (requiredType.type instanceof TLRPC.TL_secureValueTypePhone)) || requiredType.type instanceof TLRPC.TL_secureValueTypeEmail) {
                    final TLRPC.TL_secureValue value = getValueByType(requiredType, false);
                    if (value != null) {
                        AlertDialog.Builder builder = new AlertDialog.Builder(getParentActivity());
                        builder.setPositiveButton(LocaleController.getString("OK", R.string.OK), (dialog, which) -> {
                            needShowProgress();
                            deleteValueInternal(requiredType, null, null, true, this::needHideProgress, (error, text) -> needHideProgress(), documentOnly);
                        });
                        builder.setNegativeButton(LocaleController.getString("Cancel", R.string.Cancel), null);
                        builder.setTitle(LocaleController.getString("AppName", R.string.AppName));
                        builder.setMessage(phoneField ? LocaleController.getString("PassportDeletePhoneAlert", R.string.PassportDeletePhoneAlert) : LocaleController.getString("PassportDeleteEmailAlert", R.string.PassportDeleteEmailAlert));
                        showDialog(builder.create());
                        return;
                    }
                }
            }
            openTypeActivity(requiredType, documentsType, documentRequiredTypes, documentOnly);
        });
        typesViews.put(requiredType, view);

        String text = null;
        String json = null;
        String documentJson = null;
        typesValues.put(requiredType, new HashMap<>());

        TLRPC.TL_secureValue value = getValueByType(requiredType, false);
        if (value != null) {
            if (value.plain_data instanceof TLRPC.TL_securePlainEmail) {
                text = ((TLRPC.TL_securePlainEmail) value.plain_data).email;
            } else if (value.plain_data instanceof TLRPC.TL_securePlainPhone) {
                text = ((TLRPC.TL_securePlainPhone) value.plain_data).phone;
            } else if (value.data != null) {
                json = decryptData(value.data.data, decryptValueSecret(value.data.secret, value.data.data_hash), value.data.data_hash);
            }
        }
        TLRPC.TL_secureRequiredType documentsType = null;
        if (documentRequiredTypes != null && !documentRequiredTypes.isEmpty()) {
            boolean found = false;
            for (int a = 0, count = documentRequiredTypes.size(); a < count; a++) {
                TLRPC.TL_secureRequiredType documentType = documentRequiredTypes.get(a);
                typesValues.put(documentType, new HashMap<>());
                documentsToTypesLink.put(documentType, requiredType);
                if (!found) {
                    TLRPC.TL_secureValue documentValue = getValueByType(documentType, false);
                    if (documentValue != null) {
                        if (documentValue.data != null) {
                            documentJson = decryptData(documentValue.data.data, decryptValueSecret(documentValue.data.secret, documentValue.data.data_hash), documentValue.data.data_hash);
                        }
                        documentsType = documentType;
                        found = true;
                    }
                }
            }
            if (documentsType == null) {
                documentsType = documentRequiredTypes.get(0);
            }
        }

        setTypeValue(requiredType, text, json, documentsType, documentJson, documentOnly, availableDocumentTypesCount);
        return view;
    }

    private static class EncryptionResult {
        byte[] fileSecret;
        byte[] decrypyedFileSecret;
        byte[] encryptedData;
        byte[] fileHash;
        SecureDocumentKey secureDocumentKey;

        public EncryptionResult(byte[] d, byte[] fs, byte[] dfs, byte[] fh, byte[] fk, byte[] fi) {
            encryptedData = d;
            fileSecret = fs;
            fileHash = fh;
            decrypyedFileSecret = dfs;
            secureDocumentKey = new SecureDocumentKey(fk, fi);
        }
    }

    private SecureDocumentKey getSecureDocumentKey(byte[] file_secret, byte[] file_hash) {
        byte[] decrypted_file_secret = decryptValueSecret(file_secret, file_hash);

        byte[] file_secret_hash = Utilities.computeSHA512(decrypted_file_secret, file_hash);
        byte[] file_key = new byte[32];
        System.arraycopy(file_secret_hash, 0, file_key, 0, 32);
        byte[] file_iv = new byte[16];
        System.arraycopy(file_secret_hash, 32, file_iv, 0, 16);

        return new SecureDocumentKey(file_key, file_iv);
    }

    private byte[] decryptSecret(byte[] secret, byte[] passwordHash) {
        if (secret == null || secret.length != 32) {
            return null;
        }
        byte[] key = new byte[32];
        System.arraycopy(passwordHash, 0, key, 0, 32);
        byte[] iv = new byte[16];
        System.arraycopy(passwordHash, 32, iv, 0, 16);

        byte[] decryptedSecret = new byte[32];
        System.arraycopy(secret, 0, decryptedSecret, 0, 32);
        Utilities.aesCbcEncryptionByteArraySafe(decryptedSecret, key, iv, 0, decryptedSecret.length, 0, 0);
        return decryptedSecret;
    }

    private byte[] decryptValueSecret(byte[] encryptedSecureValueSecret, byte[] hash) {
        if (encryptedSecureValueSecret == null || encryptedSecureValueSecret.length != 32 || hash == null || hash.length != 32) {
            return null;
        }
        byte[] key = new byte[32];
        System.arraycopy(saltedPassword, 0, key, 0, 32);
        byte[] iv = new byte[16];
        System.arraycopy(saltedPassword, 32, iv, 0, 16);

        byte[] decryptedSecret = new byte[32];
        System.arraycopy(secureSecret, 0, decryptedSecret, 0, 32);
        Utilities.aesCbcEncryptionByteArraySafe(decryptedSecret, key, iv, 0, decryptedSecret.length, 0, 0);
        if (!checkSecret(decryptedSecret, null)) {
            return null;
        }

        byte[] secret_hash = Utilities.computeSHA512(decryptedSecret, hash);
        byte[] file_secret_key = new byte[32];
        System.arraycopy(secret_hash, 0, file_secret_key, 0, 32);
        byte[] file_secret_iv = new byte[16];
        System.arraycopy(secret_hash, 32, file_secret_iv, 0, 16);

        byte[] result = new byte[32];
        System.arraycopy(encryptedSecureValueSecret, 0, result, 0, 32);
        Utilities.aesCbcEncryptionByteArraySafe(result, file_secret_key, file_secret_iv, 0, result.length, 0, 0);

        return result;
    }

    private EncryptionResult createSecureDocument(String path) {
        File file = new File(path);
        int length = (int) file.length();
        byte[] b = new byte[length];
        RandomAccessFile f = null;
        try {
            f = new RandomAccessFile(path, "rws");
            f.readFully(b);
        } catch (Exception ignore) {

        }
        EncryptionResult result = encryptData(b);
        try {
            f.seek(0);
            f.write(result.encryptedData);
            f.close();
        } catch (Exception ignore) {

        }
        return result;
    }

    private String decryptData(byte[] data, byte[] file_secret, byte[] file_hash) {
        if (data == null || file_secret == null || file_secret.length != 32 || file_hash == null || file_hash.length != 32) {
            return null;
        }
        byte[] file_secret_hash = Utilities.computeSHA512(file_secret, file_hash);
        byte[] file_key = new byte[32];
        System.arraycopy(file_secret_hash, 0, file_key, 0, 32);
        byte[] file_iv = new byte[16];
        System.arraycopy(file_secret_hash, 32, file_iv, 0, 16);

        byte[] decryptedData = new byte[data.length];
        System.arraycopy(data, 0, decryptedData, 0, data.length);
        Utilities.aesCbcEncryptionByteArraySafe(decryptedData, file_key, file_iv, 0, decryptedData.length, 0, 0);

        byte[] hash = Utilities.computeSHA256(decryptedData);
        if (!Arrays.equals(hash, file_hash)) {
            return null;
        }

        int dataOffset = decryptedData[0] & 0xff;

        return new String(decryptedData, dataOffset, decryptedData.length - dataOffset);
    }

    public static boolean checkSecret(byte[] secret, Long id) {
        if (secret == null || secret.length != 32) {
            return false;
        }
        int sum = 0;
        int a;
        for (a = 0; a < secret.length; a++) {
            sum += secret[a] & 0xff;
        }
        if (sum % 255 != 239) {
            return false;
        }

        if (id != null && Utilities.bytesToLong(Utilities.computeSHA256(secret)) != id) {
            return false;
        }

        return true;
    }

    private byte[] getRandomSecret() {
        byte[] secret = new byte[32];
        Utilities.random.nextBytes(secret);
        int sum = 0;
        int a;
        for (a = 0; a < secret.length; a++) {
            sum += secret[a] & 0xff;
        }
        sum = sum % 255;
        if (sum != 239) {
            sum = 239 - sum;

            a = Utilities.random.nextInt(32);
            int val = secret[a] & 0xff;
            val += sum;
            if (val < 255) {
                val = 255 + val;
            }
            secret[a] = (byte) (val % 255);
        }
        return secret;
    }

    private EncryptionResult encryptData(byte[] data) {
        byte[] file_secret = getRandomSecret();

        int extraLen = 32 + Utilities.random.nextInt(256 - 32 - 16);
        while ((data.length + extraLen) % 16 != 0) {
            extraLen++;
        }
        byte[] padding = new byte[extraLen];
        Utilities.random.nextBytes(padding);
        padding[0] = (byte) extraLen;
        byte[] paddedData = new byte[extraLen + data.length];
        System.arraycopy(padding, 0, paddedData, 0, extraLen);
        System.arraycopy(data, 0, paddedData, extraLen, data.length);

        byte[] file_hash = Utilities.computeSHA256(paddedData);
        byte[] file_secret_hash = Utilities.computeSHA512(file_secret, file_hash);
        byte[] file_key = new byte[32];
        System.arraycopy(file_secret_hash, 0, file_key, 0, 32);
        byte[] file_iv = new byte[16];
        System.arraycopy(file_secret_hash, 32, file_iv, 0, 16);

        Utilities.aesCbcEncryptionByteArraySafe(paddedData, file_key, file_iv, 0, paddedData.length, 0, 1);

        byte[] key = new byte[32];
        System.arraycopy(saltedPassword, 0, key, 0, 32);
        byte[] iv = new byte[16];
        System.arraycopy(saltedPassword, 32, iv, 0, 16);

        byte[] decryptedSecret = new byte[32];
        System.arraycopy(secureSecret, 0, decryptedSecret, 0, 32);
        Utilities.aesCbcEncryptionByteArraySafe(decryptedSecret, key, iv, 0, decryptedSecret.length, 0, 0);

        byte[] secret_hash = Utilities.computeSHA512(decryptedSecret, file_hash);
        byte[] file_secret_key = new byte[32];
        System.arraycopy(secret_hash, 0, file_secret_key, 0, 32);
        byte[] file_secret_iv = new byte[16];
        System.arraycopy(secret_hash, 32, file_secret_iv, 0, 16);

        byte[] encrypyed_file_secret = new byte[32];
        System.arraycopy(file_secret, 0, encrypyed_file_secret, 0, 32);
        Utilities.aesCbcEncryptionByteArraySafe(encrypyed_file_secret, file_secret_key, file_secret_iv, 0, encrypyed_file_secret.length, 0, 1);

        return new EncryptionResult(paddedData, encrypyed_file_secret, file_secret, file_hash, file_key, file_iv);
    }

    private void showAlertWithText(String title, String text) {
        if (getParentActivity() == null) {
            return;
        }
        AlertDialog.Builder builder = new AlertDialog.Builder(getParentActivity());
        builder.setPositiveButton(LocaleController.getString("OK", R.string.OK), null);
        builder.setTitle(title);
        builder.setMessage(text);
        showDialog(builder.create());
    }

    private void onPasscodeError(boolean clear) {
        if (getParentActivity() == null) {
            return;
        }
        Vibrator v = (Vibrator) getParentActivity().getSystemService(Context.VIBRATOR_SERVICE);
        if (v != null) {
            v.vibrate(200);
        }
        if (clear) {
            inputFields[FIELD_PASSWORD].setText("");
        }
        AndroidUtilities.shakeView(inputFields[FIELD_PASSWORD], 2, 0);
    }

    private void startPhoneVerification(boolean checkPermissions, final String phone, Runnable finishRunnable, ErrorRunnable errorRunnable, final PassportActivityDelegate delegate) {
        TelephonyManager tm = (TelephonyManager) ApplicationLoader.applicationContext.getSystemService(Context.TELEPHONY_SERVICE);
        boolean simcardAvailable = tm.getSimState() != TelephonyManager.SIM_STATE_ABSENT && tm.getPhoneType() != TelephonyManager.PHONE_TYPE_NONE;
        boolean allowCall = true;
        if (getParentActivity() != null && Build.VERSION.SDK_INT >= 23 && simcardAvailable) {
            allowCall = getParentActivity().checkSelfPermission(Manifest.permission.READ_PHONE_STATE) == PackageManager.PERMISSION_GRANTED;
            if (checkPermissions) {
                permissionsItems.clear();
                if (!allowCall) {
                    permissionsItems.add(Manifest.permission.READ_PHONE_STATE);
                }
                if (!permissionsItems.isEmpty()) {
                    if (getParentActivity().shouldShowRequestPermissionRationale(Manifest.permission.READ_PHONE_STATE)) {
                        AlertDialog.Builder builder = new AlertDialog.Builder(getParentActivity());
                        builder.setTitle(LocaleController.getString("AppName", R.string.AppName));
                        builder.setPositiveButton(LocaleController.getString("OK", R.string.OK), null);
                        builder.setMessage(LocaleController.getString("AllowReadCall", R.string.AllowReadCall));
                        permissionsDialog = showDialog(builder.create());
                    } else {
                        getParentActivity().requestPermissions(permissionsItems.toArray(new String[0]), 6);
                    }
                    pendingPhone = phone;
                    pendingErrorRunnable = errorRunnable;
                    pendingFinishRunnable = finishRunnable;
                    pendingDelegate = delegate;
                    return;
                }
            }
        }
        final TLRPC.TL_account_sendVerifyPhoneCode req = new TLRPC.TL_account_sendVerifyPhoneCode();
        req.phone_number = phone;
        req.settings = new TLRPC.TL_codeSettings();
        req.settings.allow_flashcall = simcardAvailable && allowCall;
        req.settings.allow_app_hash = ApplicationLoader.hasPlayServices;
        SharedPreferences preferences = ApplicationLoader.applicationContext.getSharedPreferences("mainconfig", Activity.MODE_PRIVATE);
        if (req.settings.allow_app_hash) {
            preferences.edit().putString("sms_hash", BuildVars.SMS_HASH).commit();
        } else {
            preferences.edit().remove("sms_hash").commit();
        }
        if (req.settings.allow_flashcall) {
            try {
                @SuppressLint("HardwareIds")
                String number = tm.getLine1Number();
                if (!TextUtils.isEmpty(number)) {
                    req.settings.current_number = PhoneNumberUtils.compare(phone, number);
                    if (!req.settings.current_number) {
                        req.settings.allow_flashcall = false;
                    }
                } else {
                    req.settings.current_number = false;
                }
            } catch (Exception e) {
                req.settings.allow_flashcall = false;
                FileLog.e(e);
            }
        }

        ConnectionsManager.getInstance(currentAccount).sendRequest(req, (response, error) -> AndroidUtilities.runOnUIThread(() -> {
            if (error == null) {
                HashMap<String, String> values = new HashMap<>();
                values.put("phone", phone);
                PassportActivity activity = new PassportActivity(TYPE_PHONE_VERIFICATION, currentForm, currentPassword, currentType, null, null, null, values, null);
                activity.currentAccount = currentAccount;
                activity.saltedPassword = saltedPassword;
                activity.secureSecret = secureSecret;
                activity.delegate = delegate;
                activity.currentPhoneVerification = (TLRPC.TL_auth_sentCode) response;
                presentFragment(activity, true);
            } else {
                AlertsCreator.processError(currentAccount, error, PassportActivity.this, req, phone);
            }
        }), ConnectionsManager.RequestFlagFailOnServerErrors);
    }

    private void updatePasswordInterface() {
        if (noPasswordImageView == null) {
            return;
        }
        if (currentPassword == null || usingSavedPassword != 0) {
            noPasswordImageView.setVisibility(View.GONE);
            noPasswordTextView.setVisibility(View.GONE);
            noPasswordSetTextView.setVisibility(View.GONE);
            passwordAvatarContainer.setVisibility(View.GONE);
            inputFieldContainers[FIELD_PASSWORD].setVisibility(View.GONE);
            doneItem.setVisibility(View.GONE);
            passwordForgotButton.setVisibility(View.GONE);
            passwordInfoRequestTextView.setVisibility(View.GONE);
            passwordRequestTextView.setVisibility(View.GONE);
            emptyView.setVisibility(View.VISIBLE);
        } else if (!currentPassword.has_password) {
            passwordRequestTextView.setVisibility(View.VISIBLE);

            noPasswordImageView.setVisibility(View.VISIBLE);
            noPasswordTextView.setVisibility(View.VISIBLE);
            noPasswordSetTextView.setVisibility(View.VISIBLE);

            passwordAvatarContainer.setVisibility(View.GONE);
            inputFieldContainers[FIELD_PASSWORD].setVisibility(View.GONE);
            doneItem.setVisibility(View.GONE);
            passwordForgotButton.setVisibility(View.GONE);
            passwordInfoRequestTextView.setVisibility(View.GONE);
            passwordRequestTextView.setLayoutParams(LayoutHelper.createLinear(LayoutHelper.MATCH_PARENT, LayoutHelper.WRAP_CONTENT, 0, 25, 0, 0));
            emptyView.setVisibility(View.GONE);
        } else {
            passwordRequestTextView.setVisibility(View.VISIBLE);

            noPasswordImageView.setVisibility(View.GONE);
            noPasswordTextView.setVisibility(View.GONE);
            noPasswordSetTextView.setVisibility(View.GONE);
            emptyView.setVisibility(View.GONE);

            passwordAvatarContainer.setVisibility(View.VISIBLE);
            inputFieldContainers[FIELD_PASSWORD].setVisibility(View.VISIBLE);
            doneItem.setVisibility(View.VISIBLE);
            passwordForgotButton.setVisibility(View.VISIBLE);
            passwordInfoRequestTextView.setVisibility(View.VISIBLE);
            passwordRequestTextView.setLayoutParams(LayoutHelper.createLinear(LayoutHelper.MATCH_PARENT, LayoutHelper.WRAP_CONTENT, 0, 0, 0, 0));

            if (inputFields != null) {
                if (currentPassword != null && !TextUtils.isEmpty(currentPassword.hint)) {
                    inputFields[FIELD_PASSWORD].setHint(currentPassword.hint);
                } else {
                    inputFields[FIELD_PASSWORD].setHint(LocaleController.getString("LoginPassword", R.string.LoginPassword));
                }
            }
        }
    }

    private void showEditDoneProgress(final boolean animateDoneItem, final boolean show) {
        if (doneItemAnimation != null) {
            doneItemAnimation.cancel();
        }
        if (animateDoneItem && doneItem != null) {
            doneItemAnimation = new AnimatorSet();
            if (show) {
                progressView.setVisibility(View.VISIBLE);
                doneItem.setEnabled(false);
                doneItemAnimation.playTogether(
                        ObjectAnimator.ofFloat(doneItem.getContentView(), View.SCALE_X, 0.1f),
                        ObjectAnimator.ofFloat(doneItem.getContentView(), View.SCALE_Y, 0.1f),
                        ObjectAnimator.ofFloat(doneItem.getContentView(), View.ALPHA, 0.0f),
                        ObjectAnimator.ofFloat(progressView, View.SCALE_X, 1.0f),
                        ObjectAnimator.ofFloat(progressView, View.SCALE_Y, 1.0f),
                        ObjectAnimator.ofFloat(progressView, View.ALPHA, 1.0f));
            } else {
                doneItem.getContentView().setVisibility(View.VISIBLE);
                doneItem.setEnabled(true);
                doneItemAnimation.playTogether(
                        ObjectAnimator.ofFloat(progressView, View.SCALE_X, 0.1f),
                        ObjectAnimator.ofFloat(progressView, View.SCALE_Y, 0.1f),
                        ObjectAnimator.ofFloat(progressView, View.ALPHA, 0.0f),
                        ObjectAnimator.ofFloat(doneItem.getContentView(), View.SCALE_X, 1.0f),
                        ObjectAnimator.ofFloat(doneItem.getContentView(), View.SCALE_Y, 1.0f),
                        ObjectAnimator.ofFloat(doneItem.getContentView(), View.ALPHA, 1.0f));
            }
            doneItemAnimation.addListener(new AnimatorListenerAdapter() {
                @Override
                public void onAnimationEnd(Animator animation) {
                    if (doneItemAnimation != null && doneItemAnimation.equals(animation)) {
                        if (!show) {
                            progressView.setVisibility(View.INVISIBLE);
                        } else {
                            doneItem.getContentView().setVisibility(View.INVISIBLE);
                        }
                    }
                }

                @Override
                public void onAnimationCancel(Animator animation) {
                    if (doneItemAnimation != null && doneItemAnimation.equals(animation)) {
                        doneItemAnimation = null;
                    }
                }
            });
            doneItemAnimation.setDuration(150);
            doneItemAnimation.start();
        } else if (acceptTextView != null) {
            doneItemAnimation = new AnimatorSet();
            if (show) {
                progressViewButton.setVisibility(View.VISIBLE);
                bottomLayout.setEnabled(false);
                doneItemAnimation.playTogether(
                        ObjectAnimator.ofFloat(acceptTextView, View.SCALE_X, 0.1f),
                        ObjectAnimator.ofFloat(acceptTextView, View.SCALE_Y, 0.1f),
                        ObjectAnimator.ofFloat(acceptTextView, View.ALPHA, 0.0f),
                        ObjectAnimator.ofFloat(progressViewButton, View.SCALE_X, 1.0f),
                        ObjectAnimator.ofFloat(progressViewButton, View.SCALE_Y, 1.0f),
                        ObjectAnimator.ofFloat(progressViewButton, View.ALPHA, 1.0f));
            } else {
                acceptTextView.setVisibility(View.VISIBLE);
                bottomLayout.setEnabled(true);
                doneItemAnimation.playTogether(
                        ObjectAnimator.ofFloat(progressViewButton, View.SCALE_X, 0.1f),
                        ObjectAnimator.ofFloat(progressViewButton, View.SCALE_Y, 0.1f),
                        ObjectAnimator.ofFloat(progressViewButton, View.ALPHA, 0.0f),
                        ObjectAnimator.ofFloat(acceptTextView, View.SCALE_X, 1.0f),
                        ObjectAnimator.ofFloat(acceptTextView, View.SCALE_Y, 1.0f),
                        ObjectAnimator.ofFloat(acceptTextView, View.ALPHA, 1.0f));

            }
            doneItemAnimation.addListener(new AnimatorListenerAdapter() {
                @Override
                public void onAnimationEnd(Animator animation) {
                    if (doneItemAnimation != null && doneItemAnimation.equals(animation)) {
                        if (!show) {
                            progressViewButton.setVisibility(View.INVISIBLE);
                        } else {
                            acceptTextView.setVisibility(View.INVISIBLE);
                        }
                    }
                }

                @Override
                public void onAnimationCancel(Animator animation) {
                    if (doneItemAnimation != null && doneItemAnimation.equals(animation)) {
                        doneItemAnimation = null;
                    }
                }
            });
            doneItemAnimation.setDuration(150);
            doneItemAnimation.start();
        }
    }

    @Override
    public void didReceivedNotification(int id, int account, Object... args) {
        if (id == NotificationCenter.FileDidUpload) {
            final String location = (String) args[0];
            SecureDocument document = uploadingDocuments.get(location);
            if (document != null) {
                document.inputFile = (TLRPC.TL_inputFile) args[1];
                uploadingDocuments.remove(location);
                if (uploadingDocuments.isEmpty()) {
                    if (doneItem != null) {
                        doneItem.setEnabled(true);
                        doneItem.setAlpha(1.0f);
                    }
                }
                if (documentsCells != null) {
                    SecureDocumentCell cell = documentsCells.get(document);
                    if (cell != null) {
                        cell.updateButtonState(true);
                    }
                }
                if (errorsValues != null && errorsValues.containsKey("error_document_all")) {
                    errorsValues.remove("error_document_all");
                    checkTopErrorCell(false);
                }
                if (document.type == UPLOADING_TYPE_DOCUMENTS) {
                    if (bottomCell != null && !TextUtils.isEmpty(noAllDocumentsErrorText)) {
                        bottomCell.setText(noAllDocumentsErrorText);
                    }
                    errorsValues.remove("files_all");
                } else if (document.type == UPLOADING_TYPE_TRANSLATION) {
                    if (bottomCellTranslation != null && !TextUtils.isEmpty(noAllTranslationErrorText)) {
                        bottomCellTranslation.setText(noAllTranslationErrorText);
                    }
                    errorsValues.remove("translation_all");
                }
            }
        } else if (id == NotificationCenter.FileDidFailUpload) {

        } else if (id == NotificationCenter.twoStepPasswordChanged) {
            if (args != null && args.length > 0) {
                if (args[7] != null && inputFields[FIELD_PASSWORD] != null) {
                    inputFields[FIELD_PASSWORD].setText((String) args[7]);
                }
                if (args[6] == null) {
                    currentPassword = new TLRPC.TL_account_password();
                    currentPassword.current_algo = (TLRPC.PasswordKdfAlgo) args[1];
                    currentPassword.new_secure_algo = (TLRPC.SecurePasswordKdfAlgo) args[2];
                    currentPassword.secure_random = (byte[]) args[3];
                    currentPassword.has_recovery = !TextUtils.isEmpty((String) args[4]);
                    currentPassword.hint = (String) args[5];
                    currentPassword.srp_id = -1;
                    currentPassword.srp_B = new byte[256];
                    Utilities.random.nextBytes(currentPassword.srp_B);

                    if (inputFields[FIELD_PASSWORD] != null && inputFields[FIELD_PASSWORD].length() > 0) {
                        usingSavedPassword = 2;
                    }
                }
            } else {
                currentPassword = null;
                loadPasswordInfo();
            }
            updatePasswordInterface();
        } else if (id == NotificationCenter.didRemoveTwoStepPassword) {

        }
    }

    @Override
    public void onTransitionAnimationEnd(boolean isOpen, boolean backward) {
        if (presentAfterAnimation != null) {
            AndroidUtilities.runOnUIThread(() -> {
                presentFragment(presentAfterAnimation, true);
                presentAfterAnimation = null;
            });
        }
        if (currentActivityType == TYPE_PASSWORD) {
            if (isOpen) {
                if (inputFieldContainers[FIELD_PASSWORD].getVisibility() == View.VISIBLE) {
                    inputFields[FIELD_PASSWORD].requestFocus();
                    AndroidUtilities.showKeyboard(inputFields[FIELD_PASSWORD]);
                }
                if (usingSavedPassword == 2) {
                    onPasswordDone(false);
                }
            }
        } else if (currentActivityType == TYPE_PHONE_VERIFICATION) {
            if (isOpen) {
                views[currentViewNum].onShow();
            }
        } else if (currentActivityType == TYPE_EMAIL) {
            if (isOpen) {
                inputFields[FIELD_EMAIL].requestFocus();
                AndroidUtilities.showKeyboard(inputFields[FIELD_EMAIL]);
            }
        } else if (currentActivityType == TYPE_EMAIL_VERIFICATION) {
            if (isOpen) {
                inputFields[FIELD_EMAIL].requestFocus();
                AndroidUtilities.showKeyboard(inputFields[FIELD_EMAIL]);
            }
        } else if (currentActivityType == TYPE_ADDRESS || currentActivityType == TYPE_IDENTITY) {
            if (Build.VERSION.SDK_INT >= 21) {
                createChatAttachView();
            }
        }
    }

    private void showAttachmentError() {
        if (getParentActivity() == null) {
            return;
        }
        Toast toast = Toast.makeText(getParentActivity(), LocaleController.getString("UnsupportedAttachment", R.string.UnsupportedAttachment), Toast.LENGTH_SHORT);
        toast.show();
    }

    @Override
    public void onActivityResultFragment(int requestCode, int resultCode, Intent data) {
        if (resultCode == Activity.RESULT_OK) {
            if (requestCode == 0 || requestCode == 2) {
                createChatAttachView();
                if (chatAttachAlert != null) {
                    chatAttachAlert.onActivityResultFragment(requestCode, data, currentPicturePath);
                }
                currentPicturePath = null;
            } else if (requestCode == 1) {
                if (data == null || data.getData() == null) {
                    showAttachmentError();
                    return;
                }
                ArrayList<SendMessagesHelper.SendingMediaInfo> photos = new ArrayList<>();
                SendMessagesHelper.SendingMediaInfo info = new SendMessagesHelper.SendingMediaInfo();
                info.uri = data.getData();
                photos.add(info);
                processSelectedFiles(photos);
            }
        }
    }

    @Override
    public void onRequestPermissionsResultFragment(int requestCode, String[] permissions, int[] grantResults) {
        if ((currentActivityType == TYPE_IDENTITY || currentActivityType == TYPE_ADDRESS) && chatAttachAlert != null) {
            if (requestCode == 17) {
                chatAttachAlert.getPhotoLayout().checkCamera(false);
            } else if (requestCode == 21) {
                if (getParentActivity() == null) {
                    return;
                }
                if (grantResults != null && grantResults.length != 0 && grantResults[0] != PackageManager.PERMISSION_GRANTED) {
                    AlertDialog.Builder builder = new AlertDialog.Builder(getParentActivity());
                    builder.setTitle(LocaleController.getString("AppName", R.string.AppName));
                    builder.setMessage(LocaleController.getString("PermissionNoAudioVideo", R.string.PermissionNoAudioVideo));
                    builder.setNegativeButton(LocaleController.getString("PermissionOpenSettings", R.string.PermissionOpenSettings), (dialog, which) -> {
                        try {
                            Intent intent = new Intent(android.provider.Settings.ACTION_APPLICATION_DETAILS_SETTINGS);
                            intent.setData(Uri.parse("package:" + ApplicationLoader.applicationContext.getPackageName()));
                            getParentActivity().startActivity(intent);
                        } catch (Exception e) {
                            FileLog.e(e);
                        }
                    });
                    builder.setPositiveButton(LocaleController.getString("OK", R.string.OK), null);
                    builder.show();
                }
            } else if (requestCode == 19 && grantResults != null && grantResults.length > 0 && grantResults[0] == PackageManager.PERMISSION_GRANTED) {
                processSelectedAttach(attach_photo);
            } else if (requestCode == 22 && grantResults != null && grantResults.length > 0 && grantResults[0] == PackageManager.PERMISSION_GRANTED) {
                if (scanDocumentCell != null) {
                    scanDocumentCell.callOnClick();
                }
            }
        } else if (currentActivityType == TYPE_PHONE && requestCode == 6) {
            startPhoneVerification(false, pendingPhone, pendingFinishRunnable, pendingErrorRunnable, pendingDelegate);
        }
    }

    @Override
    public void saveSelfArgs(Bundle args) {
        if (currentPicturePath != null) {
            args.putString("path", currentPicturePath);
        }
    }

    @Override
    public void restoreSelfArgs(Bundle args) {
        currentPicturePath = args.getString("path");
    }

    @Override
    public boolean onBackPressed() {
        if (currentActivityType == TYPE_PHONE_VERIFICATION) {
            views[currentViewNum].onBackPressed(true);
            for (int a = 0; a < views.length; a++) {
                if (views[a] != null) {
                    views[a].onDestroyActivity();
                }
            }
        } else if (currentActivityType == TYPE_REQUEST || currentActivityType == TYPE_PASSWORD) {
            callCallback(false);
        } else if (currentActivityType == TYPE_IDENTITY || currentActivityType == TYPE_ADDRESS) {
            return !checkDiscard();
        }
        return true;
    }

    @Override
    protected void onDialogDismiss(Dialog dialog) {
        if (currentActivityType == TYPE_PHONE) {
            if (Build.VERSION.SDK_INT >= 23 && dialog == permissionsDialog && !permissionsItems.isEmpty()) {
                getParentActivity().requestPermissions(permissionsItems.toArray(new String[0]), 6);
            }
        }
    }

    //-----phone verification
    private String pendingPhone;
    private Runnable pendingFinishRunnable;
    private ErrorRunnable pendingErrorRunnable;
    private PassportActivityDelegate pendingDelegate;
    private int currentViewNum;
    private SlideView[] views;
    private AlertDialog progressDialog;
    private Dialog permissionsDialog;
    private ArrayList<String> permissionsItems;

    public void needShowProgress() {
        if (getParentActivity() == null || getParentActivity().isFinishing() || progressDialog != null) {
            return;
        }
        progressDialog = new AlertDialog(getParentActivity(), 3);
        progressDialog.setCanCacnel(false);
        progressDialog.show();
    }

    public void needHideProgress() {
        if (progressDialog == null) {
            return;
        }
        try {
            progressDialog.dismiss();
        } catch (Exception e) {
            FileLog.e(e);
        }
        progressDialog = null;
    }

    public void setPage(int page, boolean animated, Bundle params) {
        if (page == 3) {
            doneItem.setVisibility(View.GONE);
        }
        final SlideView outView = views[currentViewNum];
        final SlideView newView = views[page];
        currentViewNum = page;

        newView.setParams(params, false);
        newView.onShow();

        if (animated) {
            newView.setTranslationX(AndroidUtilities.displaySize.x);
            AnimatorSet animatorSet = new AnimatorSet();
            animatorSet.setInterpolator(new AccelerateDecelerateInterpolator());
            animatorSet.setDuration(300);
            animatorSet.playTogether(
                    ObjectAnimator.ofFloat(outView, "translationX", -AndroidUtilities.displaySize.x),
                    ObjectAnimator.ofFloat(newView, "translationX", 0));
            animatorSet.addListener(new AnimatorListenerAdapter() {
                @Override
                public void onAnimationStart(Animator animation) {
                    newView.setVisibility(View.VISIBLE);
                }

                @Override
                public void onAnimationEnd(Animator animation) {
                    outView.setVisibility(View.GONE);
                    outView.setX(0);
                }
            });
            animatorSet.start();
        } else {
            newView.setTranslationX(0);
            newView.setVisibility(View.VISIBLE);
            if (outView != newView) {
                outView.setVisibility(View.GONE);
            }
        }
    }

    private void fillNextCodeParams(Bundle params, TLRPC.TL_auth_sentCode res, boolean animated) {
        params.putString("phoneHash", res.phone_code_hash);
        if (res.next_type instanceof TLRPC.TL_auth_codeTypeCall) {
            params.putInt("nextType", 4);
        } else if (res.next_type instanceof TLRPC.TL_auth_codeTypeFlashCall) {
            params.putInt("nextType", 3);
        } else if (res.next_type instanceof TLRPC.TL_auth_codeTypeSms) {
            params.putInt("nextType", 2);
        }
        if (res.timeout == 0) {
            res.timeout = 60;
        }
        params.putInt("timeout", res.timeout * 1000);
        if (res.type instanceof TLRPC.TL_auth_sentCodeTypeCall) {
            params.putInt("type", 4);
            params.putInt("length", res.type.length);
            setPage(2, animated, params);
        } else if (res.type instanceof TLRPC.TL_auth_sentCodeTypeFlashCall) {
            params.putInt("type", 3);
            params.putString("pattern", res.type.pattern);
            setPage(1, animated, params);
        } else if (res.type instanceof TLRPC.TL_auth_sentCodeTypeSms) {
            params.putInt("type", 2);
            params.putInt("length", res.type.length);
            setPage(0, animated, params);
        }
    }

    private void openAttachMenu() {
        if (getParentActivity() == null) {
            return;
        }
        if (uploadingFileType == UPLOADING_TYPE_DOCUMENTS && documents.size() >= 20) {
            showAlertWithText(LocaleController.getString("AppName", R.string.AppName), LocaleController.formatString("PassportUploadMaxReached", R.string.PassportUploadMaxReached, LocaleController.formatPluralString("Files", 20)));
            return;
        }
        createChatAttachView();
        chatAttachAlert.setOpenWithFrontFaceCamera(uploadingFileType == UPLOADING_TYPE_SELFIE);
        chatAttachAlert.setMaxSelectedPhotos(getMaxSelectedDocuments(), false);
        chatAttachAlert.getPhotoLayout().loadGalleryPhotos();
        if (Build.VERSION.SDK_INT == 21 || Build.VERSION.SDK_INT == 22) {
            AndroidUtilities.hideKeyboard(fragmentView.findFocus());
        }
        chatAttachAlert.init();
        showDialog(chatAttachAlert);
    }

    private void createChatAttachView() {
        if (getParentActivity() == null) {
            return;
        }
        if (chatAttachAlert == null) {
            chatAttachAlert = new ChatAttachAlert(getParentActivity(), this);
            chatAttachAlert.setDelegate(new ChatAttachAlert.ChatAttachViewDelegate() {

                @Override
                public void didPressedButton(int button, boolean arg, boolean notify, int scheduleDate) {
                    if (getParentActivity() == null || chatAttachAlert == null) {
                        return;
                    }
                    if (button == 8 || button == 7) {
                        if (button != 8) {
                            chatAttachAlert.dismiss();
                        }
                        HashMap<Object, Object> selectedPhotos = chatAttachAlert.getPhotoLayout().getSelectedPhotos();
                        ArrayList<Object> selectedPhotosOrder = chatAttachAlert.getPhotoLayout().getSelectedPhotosOrder();
                        if (!selectedPhotos.isEmpty()) {
                            ArrayList<SendMessagesHelper.SendingMediaInfo> photos = new ArrayList<>();
                            for (int a = 0; a < selectedPhotosOrder.size(); a++) {
                                MediaController.PhotoEntry photoEntry = (MediaController.PhotoEntry) selectedPhotos.get(selectedPhotosOrder.get(a));
                                SendMessagesHelper.SendingMediaInfo info = new SendMessagesHelper.SendingMediaInfo();
                                if (photoEntry.imagePath != null) {
                                    info.path = photoEntry.imagePath;
                                } else {
                                    info.path = photoEntry.path;
                                }
                                photos.add(info);
                                photoEntry.reset();
                            }
                            processSelectedFiles(photos);
                        }
                        return;
                    } else if (chatAttachAlert != null) {
                        chatAttachAlert.dismissWithButtonClick(button);
                    }
                    processSelectedAttach(button);
                }

                @Override
                public View getRevealView() {
                    return null;
                }

                @Override
                public void didSelectBot(TLRPC.User user) {

                }

                @Override
                public void onCameraOpened() {
                    AndroidUtilities.hideKeyboard(fragmentView.findFocus());
                }

                @Override
                public boolean needEnterComment() {
                    return false;
                }

                @Override
                public void doOnIdle(Runnable runnable) {
                    runnable.run();
                }
            });
        }
    }

    private int getMaxSelectedDocuments() {
        if (uploadingFileType == UPLOADING_TYPE_DOCUMENTS) {
            return 20 - documents.size();
        } else if (uploadingFileType == UPLOADING_TYPE_TRANSLATION) {
            return 20 - translationDocuments.size();
        } else {
            return 1;
        }
    }

    private void processSelectedAttach(int which) {
        if (which == attach_photo) {
            if (Build.VERSION.SDK_INT >= 23 && getParentActivity().checkSelfPermission(Manifest.permission.CAMERA) != PackageManager.PERMISSION_GRANTED) {
                getParentActivity().requestPermissions(new String[]{Manifest.permission.CAMERA}, 19);
                return;
            }
            try {
                Intent takePictureIntent = new Intent(MediaStore.ACTION_IMAGE_CAPTURE);
                File image = AndroidUtilities.generatePicturePath();
                if (image != null) {
                    if (Build.VERSION.SDK_INT >= 24) {
                        takePictureIntent.putExtra(MediaStore.EXTRA_OUTPUT, FileProvider.getUriForFile(getParentActivity(), BuildConfig.APPLICATION_ID + ".provider", image));
                        takePictureIntent.addFlags(Intent.FLAG_GRANT_WRITE_URI_PERMISSION);
                        takePictureIntent.addFlags(Intent.FLAG_GRANT_READ_URI_PERMISSION);
                    } else {
                        takePictureIntent.putExtra(MediaStore.EXTRA_OUTPUT, Uri.fromFile(image));
                    }
                    currentPicturePath = image.getAbsolutePath();
                }
                startActivityForResult(takePictureIntent, 0);
            } catch (Exception e) {
                FileLog.e(e);
            }
        }
    }

    public void didSelectPhotos(ArrayList<SendMessagesHelper.SendingMediaInfo> photos, boolean notify, int scheduleDate) {
        processSelectedFiles(photos);
    }

    public void startDocumentSelectActivity() {
        try {
            Intent photoPickerIntent = new Intent(Intent.ACTION_GET_CONTENT);
            if (Build.VERSION.SDK_INT >= 18) {
                photoPickerIntent.putExtra(Intent.EXTRA_ALLOW_MULTIPLE, true);
            }
            photoPickerIntent.setType("*/*");
            startActivityForResult(photoPickerIntent, 21);
        } catch (Exception e) {
            FileLog.e(e);
        }
    }

    public void didSelectFiles(ArrayList<String> files, String caption, boolean notify, int scheduleDate) {
        ArrayList<SendMessagesHelper.SendingMediaInfo> arrayList = new ArrayList<>();
        for (int a = 0, count = files.size(); a < count; a++) {
            SendMessagesHelper.SendingMediaInfo info = new SendMessagesHelper.SendingMediaInfo();
            info.path = files.get(a);
            arrayList.add(info);
        }
        processSelectedFiles(arrayList);
    }

    private void fillInitialValues() {
        if (initialValues != null) {
            return;
        }
        initialValues = getCurrentValues();
    }

    private String getCurrentValues() {
        StringBuilder values = new StringBuilder();
        for (int a = 0; a < inputFields.length; a++) {
            values.append(inputFields[a].getText()).append(",");
        }
        if (inputExtraFields != null) {
            for (int a = 0; a < inputExtraFields.length; a++) {
                values.append(inputExtraFields[a].getText()).append(",");
            }
        }
        for (int a = 0, count = documents.size(); a < count; a++) {
            values.append(documents.get(a).secureFile.id);
        }
        if (frontDocument != null) {
            values.append(frontDocument.secureFile.id);
        }
        if (reverseDocument != null) {
            values.append(reverseDocument.secureFile.id);
        }
        if (selfieDocument != null) {
            values.append(selfieDocument.secureFile.id);
        }
        for (int a = 0, count = translationDocuments.size(); a < count; a++) {
            values.append(translationDocuments.get(a).secureFile.id);
        }
        return values.toString();
    }

    private boolean isHasNotAnyChanges() {
        return initialValues == null || initialValues.equals(getCurrentValues());
    }

    private boolean checkDiscard() {
        if (isHasNotAnyChanges()) {
            return false;
        }
        AlertDialog.Builder builder = new AlertDialog.Builder(getParentActivity());
        builder.setPositiveButton(LocaleController.getString("PassportDiscard", R.string.PassportDiscard), (dialog, which) -> finishFragment());
        builder.setNegativeButton(LocaleController.getString("Cancel", R.string.Cancel), null);
        builder.setTitle(LocaleController.getString("DiscardChanges", R.string.DiscardChanges));
        builder.setMessage(LocaleController.getString("PassportDiscardChanges", R.string.PassportDiscardChanges));
        showDialog(builder.create());
        return true;
    }

    private void processSelectedFiles(final ArrayList<SendMessagesHelper.SendingMediaInfo> photos) {
        if (photos.isEmpty()) {
            return;
        }
        final boolean needRecoginze;
        if (uploadingFileType == UPLOADING_TYPE_SELFIE || uploadingFileType == UPLOADING_TYPE_TRANSLATION) {
            needRecoginze = false;
        } else if (currentType.type instanceof TLRPC.TL_secureValueTypePersonalDetails) {
            boolean allFieldsAreEmpty = true;
            for (int a = 0; a < inputFields.length; a++) {
                if (a == FIELD_CITIZENSHIP || a == FIELD_EXPIRE || a == FIELD_GENDER || a == FIELD_RESIDENCE) {
                    continue;
                }
                if (inputFields[a].length() > 0) {
                    allFieldsAreEmpty = false;
                    break;
                }
            }
            needRecoginze = allFieldsAreEmpty;
        } else {
            needRecoginze = false;
        }
        final int type = uploadingFileType;
        Utilities.globalQueue.postRunnable(() -> {
            boolean didRecognizeSuccessfully = false;
            for (int a = 0, count = Math.min(uploadingFileType == UPLOADING_TYPE_DOCUMENTS || uploadingFileType == UPLOADING_TYPE_TRANSLATION ? 20 : 1, photos.size()); a < count; a++) {
                SendMessagesHelper.SendingMediaInfo info = photos.get(a);
                Bitmap bitmap = ImageLoader.loadBitmap(info.path, info.uri, 2048, 2048, false);
                if (bitmap == null) {
                    continue;
                }
                TLRPC.PhotoSize size = ImageLoader.scaleAndSaveImage(bitmap, 2048, 2048, 89, false, 320, 320);
                if (size == null) {
                    continue;
                }
                TLRPC.TL_secureFile secureFile = new TLRPC.TL_secureFile();
                secureFile.dc_id = (int) size.location.volume_id;
                secureFile.id = size.location.local_id;
                secureFile.date = (int) (System.currentTimeMillis() / 1000);

                final SecureDocument document = delegate.saveFile(secureFile);
                document.type = type;
                AndroidUtilities.runOnUIThread(() -> {
                    if (uploadingFileType == UPLOADING_TYPE_SELFIE) {
                        if (selfieDocument != null) {
                            SecureDocumentCell cell = documentsCells.remove(selfieDocument);
                            if (cell != null) {
                                selfieLayout.removeView(cell);
                            }
                            selfieDocument = null;
                        }
                    } else if (uploadingFileType == UPLOADING_TYPE_TRANSLATION) {
                        if (translationDocuments.size() >= 20) {
                            return;
                        }
                    } else if (uploadingFileType == UPLOADING_TYPE_FRONT) {
                        if (frontDocument != null) {
                            SecureDocumentCell cell = documentsCells.remove(frontDocument);
                            if (cell != null) {
                                frontLayout.removeView(cell);
                            }
                            frontDocument = null;
                        }
                    } else if (uploadingFileType == UPLOADING_TYPE_REVERSE) {
                        if (reverseDocument != null) {
                            SecureDocumentCell cell = documentsCells.remove(reverseDocument);
                            if (cell != null) {
                                reverseLayout.removeView(cell);
                            }
                            reverseDocument = null;
                        }
                    } else if (uploadingFileType == UPLOADING_TYPE_DOCUMENTS) {
                        if (documents.size() >= 20) {
                            return;
                        }
                    }
                    uploadingDocuments.put(document.path, document);
                    doneItem.setEnabled(false);
                    doneItem.setAlpha(0.5f);
                    FileLoader.getInstance(currentAccount).uploadFile(document.path, false, true, ConnectionsManager.FileTypePhoto);
                    addDocumentView(document, type);
                    updateUploadText(type);
                });

                if (needRecoginze && !didRecognizeSuccessfully) {
                    try {
                        final MrzRecognizer.Result result = MrzRecognizer.recognize(bitmap, currentDocumentsType.type instanceof TLRPC.TL_secureValueTypeDriverLicense);
                        if (result != null) {
                            didRecognizeSuccessfully = true;
                            AndroidUtilities.runOnUIThread(() -> {
                                if (result.type == MrzRecognizer.Result.TYPE_ID) {
                                    if (!(currentDocumentsType.type instanceof TLRPC.TL_secureValueTypeIdentityCard)) {
                                        for (int a1 = 0, count1 = availableDocumentTypes.size(); a1 < count1; a1++) {
                                            TLRPC.TL_secureRequiredType requiredType = availableDocumentTypes.get(a1);
                                            if (requiredType.type instanceof TLRPC.TL_secureValueTypeIdentityCard) {
                                                currentDocumentsType = requiredType;
                                                updateInterfaceStringsForDocumentType();
                                                break;
                                            }
                                        }
                                    }
                                } else if (result.type == MrzRecognizer.Result.TYPE_PASSPORT) {
                                    if (!(currentDocumentsType.type instanceof TLRPC.TL_secureValueTypePassport)) {
                                        for (int a1 = 0, count1 = availableDocumentTypes.size(); a1 < count1; a1++) {
                                            TLRPC.TL_secureRequiredType requiredType = availableDocumentTypes.get(a1);
                                            if (requiredType.type instanceof TLRPC.TL_secureValueTypePassport) {
                                                currentDocumentsType = requiredType;
                                                updateInterfaceStringsForDocumentType();
                                                break;
                                            }
                                        }
                                    }
                                } else if (result.type == MrzRecognizer.Result.TYPE_INTERNAL_PASSPORT) {
                                    if (!(currentDocumentsType.type instanceof TLRPC.TL_secureValueTypeInternalPassport)) {
                                        for (int a1 = 0, count1 = availableDocumentTypes.size(); a1 < count1; a1++) {
                                            TLRPC.TL_secureRequiredType requiredType = availableDocumentTypes.get(a1);
                                            if (requiredType.type instanceof TLRPC.TL_secureValueTypeInternalPassport) {
                                                currentDocumentsType = requiredType;
                                                updateInterfaceStringsForDocumentType();
                                                break;
                                            }
                                        }
                                    }
                                } else if (result.type == MrzRecognizer.Result.TYPE_DRIVER_LICENSE) {
                                    if (!(currentDocumentsType.type instanceof TLRPC.TL_secureValueTypeDriverLicense)) {
                                        for (int a1 = 0, count1 = availableDocumentTypes.size(); a1 < count1; a1++) {
                                            TLRPC.TL_secureRequiredType requiredType = availableDocumentTypes.get(a1);
                                            if (requiredType.type instanceof TLRPC.TL_secureValueTypeDriverLicense) {
                                                currentDocumentsType = requiredType;
                                                updateInterfaceStringsForDocumentType();
                                                break;
                                            }
                                        }
                                    }
                                }
                                if (!TextUtils.isEmpty(result.firstName)) {
                                    inputFields[FIELD_NAME].setText(result.firstName);
                                }
                                if (!TextUtils.isEmpty(result.middleName)) {
                                    inputFields[FIELD_MIDNAME].setText(result.middleName);
                                }
                                if (!TextUtils.isEmpty(result.lastName)) {
                                    inputFields[FIELD_SURNAME].setText(result.lastName);
                                }
                                if (!TextUtils.isEmpty(result.number)) {
                                    inputFields[FIELD_CARDNUMBER].setText(result.number);
                                }
                                if (result.gender != MrzRecognizer.Result.GENDER_UNKNOWN) {
                                    switch (result.gender) {
                                        case MrzRecognizer.Result.GENDER_MALE:
                                            currentGender = "male";
                                            inputFields[FIELD_GENDER].setText(LocaleController.getString("PassportMale", R.string.PassportMale));
                                            break;
                                        case MrzRecognizer.Result.GENDER_FEMALE:
                                            currentGender = "female";
                                            inputFields[FIELD_GENDER].setText(LocaleController.getString("PassportFemale", R.string.PassportFemale));
                                            break;
                                    }
                                }
                                if (!TextUtils.isEmpty(result.nationality)) {
                                    currentCitizeship = result.nationality;
                                    String country = languageMap.get(currentCitizeship);
                                    if (country != null) {
                                        inputFields[FIELD_CITIZENSHIP].setText(country);
                                    }
                                }
                                if (!TextUtils.isEmpty(result.issuingCountry)) {
                                    currentResidence = result.issuingCountry;
                                    String country = languageMap.get(currentResidence);
                                    if (country != null) {
                                        inputFields[FIELD_RESIDENCE].setText(country);
                                    }
                                }
                                if (result.birthDay > 0 && result.birthMonth > 0 && result.birthYear > 0) {
                                    inputFields[FIELD_BIRTHDAY].setText(String.format(Locale.US, "%02d.%02d.%d", result.birthDay, result.birthMonth, result.birthYear));
                                }
                                if (result.expiryDay > 0 && result.expiryMonth > 0 && result.expiryYear > 0) {
                                    currentExpireDate[0] = result.expiryYear;
                                    currentExpireDate[1] = result.expiryMonth;
                                    currentExpireDate[2] = result.expiryDay;
                                    inputFields[FIELD_EXPIRE].setText(String.format(Locale.US, "%02d.%02d.%d", result.expiryDay, result.expiryMonth, result.expiryYear));
                                } else {
                                    currentExpireDate[0] = currentExpireDate[1] = currentExpireDate[2] = 0;
                                    inputFields[FIELD_EXPIRE].setText(LocaleController.getString("PassportNoExpireDate", R.string.PassportNoExpireDate));
                                }
                            });
                        }
                    } catch (Throwable e) {
                        FileLog.e(e);
                    }
                }

            }
            SharedConfig.saveConfig();
        });
    }

    public void setNeedActivityResult(boolean needActivityResult) {
        this.needActivityResult = needActivityResult;
    }

    private static class ProgressView extends View {

        private Paint paint = new Paint();
        private Paint paint2 = new Paint();
        private float progress;

        public ProgressView(Context context) {
            super(context);
            paint.setColor(Theme.getColor(Theme.key_login_progressInner));
            paint2.setColor(Theme.getColor(Theme.key_login_progressOuter));
        }

        public void setProgress(float value) {
            progress = value;
            invalidate();
        }

        @Override
        protected void onDraw(Canvas canvas) {
            int start = (int) (getMeasuredWidth() * progress);
            canvas.drawRect(0, 0, start, getMeasuredHeight(), paint2);
            canvas.drawRect(start, 0, getMeasuredWidth(), getMeasuredHeight(), paint);
        }
    }

    public class PhoneConfirmationView extends SlideView implements NotificationCenter.NotificationCenterDelegate {

        private String phone;
        private String phoneHash;
        private LinearLayout codeFieldContainer;
        private EditTextBoldCursor[] codeField;
        private TextView confirmTextView;
        private TextView titleTextView;
        private ImageView blackImageView;
        private ImageView blueImageView;
        private TextView timeText;
        private TextView problemText;
        private Bundle currentParams;
        private ProgressView progressView;

        private Timer timeTimer;
        private Timer codeTimer;
        private final Object timerSync = new Object();
        private int time = 60000;
        private int codeTime = 15000;
        private double lastCurrentTime;
        private double lastCodeTime;
        private boolean ignoreOnTextChange;
        private boolean waitingForEvent;
        private boolean nextPressed;
        private String lastError = "";
        private int verificationType;
        private int nextType;
        private String pattern = "*";
        private int length;
        private int timeout;

        public PhoneConfirmationView(Context context, final int type) {
            super(context);

            verificationType = type;
            setOrientation(VERTICAL);

            confirmTextView = new TextView(context);
            confirmTextView.setTextColor(Theme.getColor(Theme.key_windowBackgroundWhiteGrayText6));
            confirmTextView.setTextSize(TypedValue.COMPLEX_UNIT_DIP, 14);
            confirmTextView.setLineSpacing(AndroidUtilities.dp(2), 1.0f);

            titleTextView = new TextView(context);
            titleTextView.setTextColor(Theme.getColor(Theme.key_windowBackgroundWhiteBlackText));
            titleTextView.setTextSize(TypedValue.COMPLEX_UNIT_DIP, 18);
            titleTextView.setTypeface(AndroidUtilities.getTypeface("fonts/rmedium.ttf"));
            titleTextView.setGravity(LocaleController.isRTL ? Gravity.RIGHT : Gravity.LEFT);
            titleTextView.setLineSpacing(AndroidUtilities.dp(2), 1.0f);
            titleTextView.setGravity(Gravity.TOP | Gravity.CENTER_HORIZONTAL);

            if (verificationType == 3) {
                confirmTextView.setGravity(Gravity.TOP | (LocaleController.isRTL ? Gravity.RIGHT : Gravity.LEFT));
                FrameLayout frameLayout = new FrameLayout(context);
                addView(frameLayout, LayoutHelper.createLinear(LayoutHelper.WRAP_CONTENT, LayoutHelper.WRAP_CONTENT, LocaleController.isRTL ? Gravity.RIGHT : Gravity.LEFT));

                ImageView imageView = new ImageView(context);
                imageView.setImageResource(R.drawable.phone_activate);
                if (LocaleController.isRTL) {
                    frameLayout.addView(imageView, LayoutHelper.createFrame(64, 76, Gravity.LEFT | Gravity.CENTER_VERTICAL, 2, 2, 0, 0));
                    frameLayout.addView(confirmTextView, LayoutHelper.createFrame(LayoutHelper.MATCH_PARENT, LayoutHelper.WRAP_CONTENT, LocaleController.isRTL ? Gravity.RIGHT : Gravity.LEFT, 64 + 18, 0, 0, 0));
                } else {
                    frameLayout.addView(confirmTextView, LayoutHelper.createFrame(LayoutHelper.MATCH_PARENT, LayoutHelper.WRAP_CONTENT, LocaleController.isRTL ? Gravity.RIGHT : Gravity.LEFT, 0, 0, 64 + 18, 0));
                    frameLayout.addView(imageView, LayoutHelper.createFrame(64, 76, Gravity.RIGHT | Gravity.CENTER_VERTICAL, 0, 2, 0, 2));
                }
            } else {
                confirmTextView.setGravity(Gravity.TOP | Gravity.CENTER_HORIZONTAL);

                FrameLayout frameLayout = new FrameLayout(context);
                addView(frameLayout, LayoutHelper.createLinear(LayoutHelper.WRAP_CONTENT, LayoutHelper.WRAP_CONTENT, Gravity.TOP | Gravity.CENTER_HORIZONTAL));

                if (verificationType == 1) {
                    blackImageView = new ImageView(context);
                    blackImageView.setImageResource(R.drawable.sms_devices);
                    blackImageView.setColorFilter(new PorterDuffColorFilter(Theme.getColor(Theme.key_windowBackgroundWhiteBlackText), PorterDuff.Mode.MULTIPLY));
                    frameLayout.addView(blackImageView, LayoutHelper.createFrame(LayoutHelper.WRAP_CONTENT, LayoutHelper.WRAP_CONTENT, Gravity.LEFT | Gravity.TOP, 0, 0, 0, 0));

                    blueImageView = new ImageView(context);
                    blueImageView.setImageResource(R.drawable.sms_bubble);
                    blueImageView.setColorFilter(new PorterDuffColorFilter(Theme.getColor(Theme.key_chats_actionBackground), PorterDuff.Mode.MULTIPLY));
                    frameLayout.addView(blueImageView, LayoutHelper.createFrame(LayoutHelper.WRAP_CONTENT, LayoutHelper.WRAP_CONTENT, Gravity.LEFT | Gravity.TOP, 0, 0, 0, 0));

                    titleTextView.setText(LocaleController.getString("SentAppCodeTitle", R.string.SentAppCodeTitle));
                } else {
                    blueImageView = new ImageView(context);
                    blueImageView.setImageResource(R.drawable.sms_code);
                    blueImageView.setColorFilter(new PorterDuffColorFilter(Theme.getColor(Theme.key_chats_actionBackground), PorterDuff.Mode.MULTIPLY));
                    frameLayout.addView(blueImageView, LayoutHelper.createFrame(LayoutHelper.WRAP_CONTENT, LayoutHelper.WRAP_CONTENT, Gravity.LEFT | Gravity.TOP, 0, 0, 0, 0));

                    titleTextView.setText(LocaleController.getString("SentSmsCodeTitle", R.string.SentSmsCodeTitle));
                }
                addView(titleTextView, LayoutHelper.createLinear(LayoutHelper.WRAP_CONTENT, LayoutHelper.WRAP_CONTENT, Gravity.CENTER_HORIZONTAL | Gravity.TOP, 0, 18, 0, 0));
                addView(confirmTextView, LayoutHelper.createLinear(LayoutHelper.WRAP_CONTENT, LayoutHelper.WRAP_CONTENT, Gravity.CENTER_HORIZONTAL | Gravity.TOP, 0, 17, 0, 0));
            }

            codeFieldContainer = new LinearLayout(context);
            codeFieldContainer.setOrientation(HORIZONTAL);
            addView(codeFieldContainer, LayoutHelper.createLinear(LayoutHelper.WRAP_CONTENT, 36, Gravity.CENTER_HORIZONTAL));
            if (verificationType == 3) {
                codeFieldContainer.setVisibility(GONE);
            }

            timeText = new TextView(context) {
                @Override
                protected void onMeasure(int widthMeasureSpec, int heightMeasureSpec) {
                    super.onMeasure(widthMeasureSpec, MeasureSpec.makeMeasureSpec(AndroidUtilities.dp(100), MeasureSpec.AT_MOST));
                }
            };
            timeText.setTextColor(Theme.getColor(Theme.key_windowBackgroundWhiteGrayText6));
            timeText.setLineSpacing(AndroidUtilities.dp(2), 1.0f);
            if (verificationType == 3) {
                timeText.setTextSize(TypedValue.COMPLEX_UNIT_DIP, 14);
                addView(timeText, LayoutHelper.createLinear(LayoutHelper.WRAP_CONTENT, LayoutHelper.WRAP_CONTENT, LocaleController.isRTL ? Gravity.RIGHT : Gravity.LEFT));

                progressView = new ProgressView(context);
                timeText.setGravity(LocaleController.isRTL ? Gravity.RIGHT : Gravity.LEFT);
                addView(progressView, LayoutHelper.createLinear(LayoutHelper.MATCH_PARENT, 3, 0, 12, 0, 0));
            } else {
                timeText.setPadding(0, AndroidUtilities.dp(2), 0, AndroidUtilities.dp(10));
                timeText.setTextSize(TypedValue.COMPLEX_UNIT_DIP, 15);
                timeText.setGravity(Gravity.TOP | Gravity.CENTER_HORIZONTAL);
                addView(timeText, LayoutHelper.createLinear(LayoutHelper.WRAP_CONTENT, LayoutHelper.WRAP_CONTENT, Gravity.TOP | Gravity.CENTER_HORIZONTAL));
            }

            problemText = new TextView(context) {
                @Override
                protected void onMeasure(int widthMeasureSpec, int heightMeasureSpec) {
                    super.onMeasure(widthMeasureSpec, MeasureSpec.makeMeasureSpec(AndroidUtilities.dp(100), MeasureSpec.AT_MOST));
                }
            };
            problemText.setTextColor(Theme.getColor(Theme.key_windowBackgroundWhiteBlueText4));
            problemText.setLineSpacing(AndroidUtilities.dp(2), 1.0f);
            problemText.setPadding(0, AndroidUtilities.dp(2), 0, AndroidUtilities.dp(10));
            problemText.setTextSize(TypedValue.COMPLEX_UNIT_DIP, 15);
            problemText.setGravity(Gravity.CENTER_HORIZONTAL | Gravity.TOP);
            if (verificationType == 1) {
                problemText.setText(LocaleController.getString("DidNotGetTheCodeSms", R.string.DidNotGetTheCodeSms));
            } else {
                problemText.setText(LocaleController.getString("DidNotGetTheCode", R.string.DidNotGetTheCode));
            }
            addView(problemText, LayoutHelper.createLinear(LayoutHelper.WRAP_CONTENT, LayoutHelper.WRAP_CONTENT, Gravity.CENTER_HORIZONTAL | Gravity.TOP));
            problemText.setOnClickListener(v -> {
                if (nextPressed) {
                    return;
                }
                boolean email = nextType == 4 && verificationType == 2 || nextType == 0;
                if (!email) {
                    resendCode();
                } else {
                    try {
                        PackageInfo pInfo = ApplicationLoader.applicationContext.getPackageManager().getPackageInfo(ApplicationLoader.applicationContext.getPackageName(), 0);
                        String version = String.format(Locale.US, "%s (%d)", pInfo.versionName, pInfo.versionCode);

                        Intent mailer = new Intent(Intent.ACTION_SEND);
                        mailer.setType("message/rfc822");
                        mailer.putExtra(Intent.EXTRA_EMAIL, new String[]{"sms@stel.com"});
                        mailer.putExtra(Intent.EXTRA_SUBJECT, "Android registration/login issue " + version + " " + phone);
                        mailer.putExtra(Intent.EXTRA_TEXT, "Phone: " + phone + "\nApp version: " + version + "\nOS version: SDK " + Build.VERSION.SDK_INT + "\nDevice Name: " + Build.MANUFACTURER + Build.MODEL + "\nLocale: " + Locale.getDefault() + "\nError: " + lastError);
                        getContext().startActivity(Intent.createChooser(mailer, "Send email..."));
                    } catch (Exception e) {
                        AlertsCreator.showSimpleAlert(PassportActivity.this, LocaleController.getString("NoMailInstalled", R.string.NoMailInstalled));
                    }
                }
            });
        }

        @Override
        protected void onMeasure(int widthMeasureSpec, int heightMeasureSpec) {
            super.onMeasure(widthMeasureSpec, heightMeasureSpec);
            if (verificationType != 3 && blueImageView != null) {
                int innerHeight = blueImageView.getMeasuredHeight() + titleTextView.getMeasuredHeight() + confirmTextView.getMeasuredHeight() + AndroidUtilities.dp(18 + 17);
                int requiredHeight = AndroidUtilities.dp(80);
                int maxHeight = AndroidUtilities.dp(291);
                if (scrollHeight - innerHeight < requiredHeight) {
                    setMeasuredDimension(getMeasuredWidth(), innerHeight + requiredHeight);
                } else {
                    setMeasuredDimension(getMeasuredWidth(), Math.min(scrollHeight, maxHeight));
                }
            }
        }

        @Override
        protected void onLayout(boolean changed, int l, int t, int r, int b) {
            super.onLayout(changed, l, t, r, b);
            if (verificationType != 3 && blueImageView != null) {
                int bottom = confirmTextView.getBottom();
                int height = getMeasuredHeight() - bottom;

                int h;
                if (problemText.getVisibility() == VISIBLE) {
                    h = problemText.getMeasuredHeight();
                    t = bottom + height - h;
                    problemText.layout(problemText.getLeft(), t, problemText.getRight(), t + h);
                } else if (timeText.getVisibility() == VISIBLE) {
                    h = timeText.getMeasuredHeight();
                    t = bottom + height - h;
                    timeText.layout(timeText.getLeft(), t, timeText.getRight(), t + h);
                } else {
                    t = bottom + height;
                }

                height = t - bottom;
                h = codeFieldContainer.getMeasuredHeight();
                t = (height - h) / 2 + bottom;
                codeFieldContainer.layout(codeFieldContainer.getLeft(), t, codeFieldContainer.getRight(), t + h);
            }
        }

        private void resendCode() {
            final Bundle params = new Bundle();
            params.putString("phone", phone);

            nextPressed = true;
            needShowProgress();

            final TLRPC.TL_auth_resendCode req = new TLRPC.TL_auth_resendCode();
            req.phone_number = phone;
            req.phone_code_hash = phoneHash;
            ConnectionsManager.getInstance(currentAccount).sendRequest(req, (response, error) -> AndroidUtilities.runOnUIThread(() -> {
                nextPressed = false;
                if (error == null) {
                    fillNextCodeParams(params, (TLRPC.TL_auth_sentCode) response, true);
                } else {
                    AlertDialog dialog = (AlertDialog) AlertsCreator.processError(currentAccount, error, PassportActivity.this, req);
                    if (dialog != null && error.text.contains("PHONE_CODE_EXPIRED")) {
                        dialog.setPositiveButtonListener((dialog1, which) -> {
                            onBackPressed(true);
                            finishFragment();
                        });
                    }
                }
                needHideProgress();
            }), ConnectionsManager.RequestFlagFailOnServerErrors);
        }

        @Override
        public boolean needBackButton() {
            return true;
        }

        @Override
        public void onCancelPressed() {
            nextPressed = false;
        }

        @Override
        public void setParams(Bundle params, boolean restore) {
            if (params == null) {
                return;
            }
            waitingForEvent = true;
            if (verificationType == 2) {
                AndroidUtilities.setWaitingForSms(true);
                NotificationCenter.getGlobalInstance().addObserver(this, NotificationCenter.didReceiveSmsCode);
            } else if (verificationType == 3) {
                AndroidUtilities.setWaitingForCall(true);
                NotificationCenter.getGlobalInstance().addObserver(this, NotificationCenter.didReceiveCall);
            }

            currentParams = params;
            phone = params.getString("phone");
            phoneHash = params.getString("phoneHash");
            timeout = time = params.getInt("timeout");
            nextType = params.getInt("nextType");
            pattern = params.getString("pattern");
            length = params.getInt("length");
            if (length == 0) {
                length = 5;
            }

            if (codeField == null || codeField.length != length) {
                codeField = new EditTextBoldCursor[length];
                for (int a = 0; a < length; a++) {
                    final int num = a;
                    codeField[a] = new EditTextBoldCursor(getContext());
                    codeField[a].setTextColor(Theme.getColor(Theme.key_windowBackgroundWhiteBlackText));
                    codeField[a].setCursorColor(Theme.getColor(Theme.key_windowBackgroundWhiteBlackText));
                    codeField[a].setCursorSize(AndroidUtilities.dp(20));
                    codeField[a].setCursorWidth(1.5f);

                    Drawable pressedDrawable = getResources().getDrawable(R.drawable.search_dark_activated).mutate();
                    pressedDrawable.setColorFilter(new PorterDuffColorFilter(Theme.getColor(Theme.key_windowBackgroundWhiteInputFieldActivated), PorterDuff.Mode.MULTIPLY));

                    codeField[a].setBackgroundDrawable(pressedDrawable);
                    codeField[a].setImeOptions(EditorInfo.IME_ACTION_NEXT | EditorInfo.IME_FLAG_NO_EXTRACT_UI);
                    codeField[a].setTextSize(TypedValue.COMPLEX_UNIT_DIP, 20);
                    codeField[a].setMaxLines(1);
                    codeField[a].setTypeface(AndroidUtilities.getTypeface("fonts/rmedium.ttf"));
                    codeField[a].setPadding(0, 0, 0, 0);
                    codeField[a].setGravity(Gravity.CENTER_HORIZONTAL | Gravity.TOP);
                    if (verificationType == 3) {
                        codeField[a].setEnabled(false);
                        codeField[a].setInputType(InputType.TYPE_NULL);
                        codeField[a].setVisibility(GONE);
                    } else {
                        codeField[a].setInputType(InputType.TYPE_CLASS_PHONE);
                    }
                    codeFieldContainer.addView(codeField[a], LayoutHelper.createLinear(34, 36, Gravity.CENTER_HORIZONTAL, 0, 0, a != length - 1 ? 7 : 0, 0));
                    codeField[a].addTextChangedListener(new TextWatcher() {

                        @Override
                        public void beforeTextChanged(CharSequence s, int start, int count, int after) {

                        }

                        @Override
                        public void onTextChanged(CharSequence s, int start, int before, int count) {

                        }

                        @Override
                        public void afterTextChanged(Editable s) {
                            if (ignoreOnTextChange) {
                                return;
                            }
                            int len = s.length();
                            if (len >= 1) {
                                if (len > 1) {
                                    String text = s.toString();
                                    ignoreOnTextChange = true;
                                    for (int a = 0; a < Math.min(length - num, len); a++) {
                                        if (a == 0) {
                                            s.replace(0, len, text.substring(a, a + 1));
                                        } else {
                                            codeField[num + a].setText(text.substring(a, a + 1));
                                        }
                                    }
                                    ignoreOnTextChange = false;
                                }

                                if (num != length - 1) {
                                    codeField[num + 1].setSelection(codeField[num + 1].length());
                                    codeField[num + 1].requestFocus();
                                }
                                if ((num == length - 1 || num == length - 2 && len >= 2) && getCode().length() == length) {
                                    onNextPressed();
                                }
                            }
                        }
                    });
                    codeField[a].setOnKeyListener((v, keyCode, event) -> {
                        if (keyCode == KeyEvent.KEYCODE_DEL && codeField[num].length() == 0 && num > 0) {
                            codeField[num - 1].setSelection(codeField[num - 1].length());
                            codeField[num - 1].requestFocus();
                            codeField[num - 1].dispatchKeyEvent(event);
                            return true;
                        }
                        return false;
                    });
                    codeField[a].setOnEditorActionListener((textView, i, keyEvent) -> {
                        if (i == EditorInfo.IME_ACTION_NEXT) {
                            onNextPressed();
                            return true;
                        }
                        return false;
                    });
                }
            } else {
                for (int a = 0; a < codeField.length; a++) {
                    codeField[a].setText("");
                }
            }

            if (progressView != null) {
                progressView.setVisibility(nextType != 0 ? VISIBLE : GONE);
            }

            if (phone == null) {
                return;
            }

            String number = PhoneFormat.getInstance().format("+" + phone);
            CharSequence str = "";
            if (verificationType == 2) {
                str = AndroidUtilities.replaceTags(LocaleController.formatString("SentSmsCode", R.string.SentSmsCode, LocaleController.addNbsp(number)));
            } else if (verificationType == 3) {
                str = AndroidUtilities.replaceTags(LocaleController.formatString("SentCallCode", R.string.SentCallCode, LocaleController.addNbsp(number)));
            } else if (verificationType == 4) {
                str = AndroidUtilities.replaceTags(LocaleController.formatString("SentCallOnly", R.string.SentCallOnly, LocaleController.addNbsp(number)));
            }
            confirmTextView.setText(str);

            if (verificationType != 3) {
                AndroidUtilities.showKeyboard(codeField[0]);
                codeField[0].requestFocus();
            } else {
                AndroidUtilities.hideKeyboard(codeField[0]);
            }

            destroyTimer();
            destroyCodeTimer();

            lastCurrentTime = System.currentTimeMillis();
            if (verificationType == 3 && (nextType == 4 || nextType == 2)) {
                problemText.setVisibility(GONE);
                timeText.setVisibility(VISIBLE);
                if (nextType == 4) {
                    timeText.setText(LocaleController.formatString("CallText", R.string.CallText, 1, 0));
                } else if (nextType == 2) {
                    timeText.setText(LocaleController.formatString("SmsText", R.string.SmsText, 1, 0));
                }
                createTimer();
            } else if (verificationType == 2 && (nextType == 4 || nextType == 3)) {
                timeText.setText(LocaleController.formatString("CallText", R.string.CallText, 2, 0));
                problemText.setVisibility(time < 1000 ? VISIBLE : GONE);
                timeText.setVisibility(time < 1000 ? GONE : VISIBLE);
                createTimer();
            } else if (verificationType == 4 && nextType == 2) {
                timeText.setText(LocaleController.formatString("SmsText", R.string.SmsText, 2, 0));
                problemText.setVisibility(time < 1000 ? VISIBLE : GONE);
                timeText.setVisibility(time < 1000 ? GONE : VISIBLE);
                createTimer();
            } else {
                timeText.setVisibility(GONE);
                problemText.setVisibility(GONE);
                createCodeTimer();
            }
        }

        private void createCodeTimer() {
            if (codeTimer != null) {
                return;
            }
            codeTime = 15000;
            codeTimer = new Timer();
            lastCodeTime = System.currentTimeMillis();
            codeTimer.schedule(new TimerTask() {
                @Override
                public void run() {
                    AndroidUtilities.runOnUIThread(() -> {
                        double currentTime = System.currentTimeMillis();
                        double diff = currentTime - lastCodeTime;
                        lastCodeTime = currentTime;
                        codeTime -= diff;
                        if (codeTime <= 1000) {
                            problemText.setVisibility(VISIBLE);
                            timeText.setVisibility(GONE);
                            destroyCodeTimer();
                        }
                    });
                }
            }, 0, 1000);
        }

        private void destroyCodeTimer() {
            try {
                synchronized (timerSync) {
                    if (codeTimer != null) {
                        codeTimer.cancel();
                        codeTimer = null;
                    }
                }
            } catch (Exception e) {
                FileLog.e(e);
            }
        }

        private void createTimer() {
            if (timeTimer != null) {
                return;
            }
            timeTimer = new Timer();
            timeTimer.schedule(new TimerTask() {
                @Override
                public void run() {
                    if (timeTimer == null) {
                        return;
                    }
                    final double currentTime = System.currentTimeMillis();
                    double diff = currentTime - lastCurrentTime;
                    time -= diff;
                    lastCurrentTime = currentTime;
                    AndroidUtilities.runOnUIThread(() -> {
                        if (time >= 1000) {
                            int minutes = time / 1000 / 60;
                            int seconds = time / 1000 - minutes * 60;
                            if (nextType == 4 || nextType == 3) {
                                timeText.setText(LocaleController.formatString("CallText", R.string.CallText, minutes, seconds));
                            } else if (nextType == 2) {
                                timeText.setText(LocaleController.formatString("SmsText", R.string.SmsText, minutes, seconds));
                            }
                            if (progressView != null) {
                                progressView.setProgress(1.0f - (float) time / (float) timeout);
                            }
                        } else {
                            if (progressView != null) {
                                progressView.setProgress(1.0f);
                            }
                            destroyTimer();
                            if (verificationType == 3) {
                                AndroidUtilities.setWaitingForCall(false);
                                NotificationCenter.getGlobalInstance().removeObserver(PhoneConfirmationView.this, NotificationCenter.didReceiveCall);
                                waitingForEvent = false;
                                destroyCodeTimer();
                                resendCode();
                            } else if (verificationType == 2 || verificationType == 4) {
                                if (nextType == 4 || nextType == 2) {
                                    if (nextType == 4) {
                                        timeText.setText(LocaleController.getString("Calling", R.string.Calling));
                                    } else {
                                        timeText.setText(LocaleController.getString("SendingSms", R.string.SendingSms));
                                    }
                                    createCodeTimer();
                                    TLRPC.TL_auth_resendCode req = new TLRPC.TL_auth_resendCode();
                                    req.phone_number = phone;
                                    req.phone_code_hash = phoneHash;
                                    ConnectionsManager.getInstance(currentAccount).sendRequest(req, (response, error) -> {
                                        if (error != null && error.text != null) {
                                            AndroidUtilities.runOnUIThread(() -> lastError = error.text);
                                        }
                                    }, ConnectionsManager.RequestFlagFailOnServerErrors);
                                } else if (nextType == 3) {
                                    AndroidUtilities.setWaitingForSms(false);
                                    NotificationCenter.getGlobalInstance().removeObserver(PhoneConfirmationView.this, NotificationCenter.didReceiveSmsCode);
                                    waitingForEvent = false;
                                    destroyCodeTimer();
                                    resendCode();
                                }
                            }
                        }
                    });
                }
            }, 0, 1000);
        }

        private void destroyTimer() {
            try {
                synchronized (timerSync) {
                    if (timeTimer != null) {
                        timeTimer.cancel();
                        timeTimer = null;
                    }
                }
            } catch (Exception e) {
                FileLog.e(e);
            }
        }

        private String getCode() {
            if (codeField == null) {
                return "";
            }
            StringBuilder codeBuilder = new StringBuilder();
            for (int a = 0; a < codeField.length; a++) {
                codeBuilder.append(PhoneFormat.stripExceptNumbers(codeField[a].getText().toString()));
            }
            return codeBuilder.toString();
        }

        @Override
        public void onNextPressed() {
            if (nextPressed) {
                return;
            }
            String code = getCode();
            if (TextUtils.isEmpty(code)) {
                AndroidUtilities.shakeView(codeFieldContainer, 2, 0);
                return;
            }
            nextPressed = true;
            if (verificationType == 2) {
                AndroidUtilities.setWaitingForSms(false);
                NotificationCenter.getGlobalInstance().removeObserver(this, NotificationCenter.didReceiveSmsCode);
            } else if (verificationType == 3) {
                AndroidUtilities.setWaitingForCall(false);
                NotificationCenter.getGlobalInstance().removeObserver(this, NotificationCenter.didReceiveCall);
            }
            waitingForEvent = false;
            showEditDoneProgress(true, true);
            final TLRPC.TL_account_verifyPhone req = new TLRPC.TL_account_verifyPhone();
            req.phone_number = phone;
            req.phone_code = code;
            req.phone_code_hash = phoneHash;
            destroyTimer();
            needShowProgress();
            ConnectionsManager.getInstance(currentAccount).sendRequest(req, (response, error) -> AndroidUtilities.runOnUIThread(() -> {
                needHideProgress();
                nextPressed = false;
                if (error == null) {
                    destroyTimer();
                    destroyCodeTimer();
                    delegate.saveValue(currentType, currentValues.get("phone"), null, null, null, null, null, null, null, null, PassportActivity.this::finishFragment, null);
                } else {
                    lastError = error.text;
                    if (verificationType == 3 && (nextType == 4 || nextType == 2) || verificationType == 2 && (nextType == 4 || nextType == 3) || verificationType == 4 && nextType == 2) {
                        createTimer();
                    }
                    if (verificationType == 2) {
                        AndroidUtilities.setWaitingForSms(true);
                        NotificationCenter.getGlobalInstance().addObserver(PhoneConfirmationView.this, NotificationCenter.didReceiveSmsCode);
                    } else if (verificationType == 3) {
                        AndroidUtilities.setWaitingForCall(true);
                        NotificationCenter.getGlobalInstance().addObserver(PhoneConfirmationView.this, NotificationCenter.didReceiveCall);
                    }
                    waitingForEvent = true;
                    if (verificationType != 3) {
                        AlertsCreator.processError(currentAccount, error, PassportActivity.this, req);
                    }
                    showEditDoneProgress(true, false);
                    if (error.text.contains("PHONE_CODE_EMPTY") || error.text.contains("PHONE_CODE_INVALID")) {
                        for (int a = 0; a < codeField.length; a++) {
                            codeField[a].setText("");
                        }
                        codeField[0].requestFocus();
                    } else if (error.text.contains("PHONE_CODE_EXPIRED")) {
                        onBackPressed(true);
                        setPage(0, true, null);
                    }
                }
            }), ConnectionsManager.RequestFlagFailOnServerErrors);
        }

        @Override
        public boolean onBackPressed(boolean force) {
            if (!force) {
                AlertDialog.Builder builder = new AlertDialog.Builder(getParentActivity());
                builder.setTitle(LocaleController.getString("AppName", R.string.AppName));
                builder.setMessage(LocaleController.getString("StopVerification", R.string.StopVerification));
                builder.setPositiveButton(LocaleController.getString("Continue", R.string.Continue), null);
                builder.setNegativeButton(LocaleController.getString("Stop", R.string.Stop), (dialogInterface, i) -> {
                    onBackPressed(true);
                    setPage(0, true, null);
                });
                showDialog(builder.create());
                return false;
            }

            TLRPC.TL_auth_cancelCode req = new TLRPC.TL_auth_cancelCode();
            req.phone_number = phone;
            req.phone_code_hash = phoneHash;
            ConnectionsManager.getInstance(currentAccount).sendRequest(req, (response, error) -> {

            }, ConnectionsManager.RequestFlagFailOnServerErrors);

            destroyTimer();
            destroyCodeTimer();
            currentParams = null;
            if (verificationType == 2) {
                AndroidUtilities.setWaitingForSms(false);
                NotificationCenter.getGlobalInstance().removeObserver(this, NotificationCenter.didReceiveSmsCode);
            } else if (verificationType == 3) {
                AndroidUtilities.setWaitingForCall(false);
                NotificationCenter.getGlobalInstance().removeObserver(this, NotificationCenter.didReceiveCall);
            }
            waitingForEvent = false;
            return true;
        }

        @Override
        public void onDestroyActivity() {
            super.onDestroyActivity();
            if (verificationType == 2) {
                AndroidUtilities.setWaitingForSms(false);
                NotificationCenter.getGlobalInstance().removeObserver(this, NotificationCenter.didReceiveSmsCode);
            } else if (verificationType == 3) {
                AndroidUtilities.setWaitingForCall(false);
                NotificationCenter.getGlobalInstance().removeObserver(this, NotificationCenter.didReceiveCall);
            }
            waitingForEvent = false;
            destroyTimer();
            destroyCodeTimer();
        }

        @Override
        public void onShow() {
            super.onShow();
            if (codeFieldContainer != null && codeFieldContainer.getVisibility() == VISIBLE) {
                for (int a = codeField.length - 1; a >= 0; a--) {
                    if (a == 0 || codeField[a].length() != 0) {
                        codeField[a].requestFocus();
                        codeField[a].setSelection(codeField[a].length());
                        AndroidUtilities.showKeyboard(codeField[a]);
                        break;
                    }
                }
            }
        }

        @Override
        public void didReceivedNotification(int id, int account, Object... args) {
            if (!waitingForEvent || codeField == null) {
                return;
            }
            if (id == NotificationCenter.didReceiveSmsCode) {
                codeField[0].setText("" + args[0]);
                onNextPressed();
            } else if (id == NotificationCenter.didReceiveCall) {
                String num = "" + args[0];
                if (!AndroidUtilities.checkPhonePattern(pattern, num)) {
                    return;
                }
                ignoreOnTextChange = true;
                codeField[0].setText(num);
                ignoreOnTextChange = false;
                onNextPressed();
            }
        }
    }

    @Override
    public ArrayList<ThemeDescription> getThemeDescriptions() {
        ArrayList<ThemeDescription> arrayList = new ArrayList<>();

        arrayList.add(new ThemeDescription(fragmentView, ThemeDescription.FLAG_BACKGROUND, null, null, null, null, Theme.key_windowBackgroundGray));
        arrayList.add(new ThemeDescription(actionBar, ThemeDescription.FLAG_BACKGROUND, null, null, null, null, Theme.key_actionBarDefault));
        arrayList.add(new ThemeDescription(scrollView, ThemeDescription.FLAG_LISTGLOWCOLOR, null, null, null, null, Theme.key_actionBarDefault));
        arrayList.add(new ThemeDescription(actionBar, ThemeDescription.FLAG_AB_ITEMSCOLOR, null, null, null, null, Theme.key_actionBarDefaultIcon));
        arrayList.add(new ThemeDescription(actionBar, ThemeDescription.FLAG_AB_TITLECOLOR, null, null, null, null, Theme.key_actionBarDefaultTitle));
        arrayList.add(new ThemeDescription(actionBar, ThemeDescription.FLAG_AB_SELECTORCOLOR, null, null, null, null, Theme.key_actionBarDefaultSelector));
        arrayList.add(new ThemeDescription(actionBar, ThemeDescription.FLAG_AB_SEARCH, null, null, null, null, Theme.key_actionBarDefaultSearch));
        arrayList.add(new ThemeDescription(actionBar, ThemeDescription.FLAG_AB_SEARCHPLACEHOLDER, null, null, null, null, Theme.key_actionBarDefaultSearchPlaceholder));
        arrayList.add(new ThemeDescription(linearLayout2, 0, new Class[]{View.class}, Theme.dividerPaint, null, null, Theme.key_divider));

        arrayList.add(new ThemeDescription(extraBackgroundView, ThemeDescription.FLAG_BACKGROUND, null, null, null, null, Theme.key_windowBackgroundWhite));
        if (extraBackgroundView2 != null) {
            arrayList.add(new ThemeDescription(extraBackgroundView2, ThemeDescription.FLAG_BACKGROUND, null, null, null, null, Theme.key_windowBackgroundWhite));
        }

        for (int a = 0; a < dividers.size(); a++) {
            arrayList.add(new ThemeDescription(dividers.get(a), ThemeDescription.FLAG_BACKGROUND, null, null, null, null, Theme.key_divider));
        }

        for (HashMap.Entry<SecureDocument, SecureDocumentCell> entry : documentsCells.entrySet()) {
            SecureDocumentCell cell = entry.getValue();
            arrayList.add(new ThemeDescription(cell, ThemeDescription.FLAG_SELECTORWHITE, new Class[]{SecureDocumentCell.class}, null, null, null, Theme.key_windowBackgroundWhite));
            arrayList.add(new ThemeDescription(cell, 0, new Class[]{SecureDocumentCell.class}, new String[]{"textView"}, null, null, null, Theme.key_windowBackgroundWhiteBlackText));
            arrayList.add(new ThemeDescription(cell, 0, new Class[]{SecureDocumentCell.class}, new String[]{"valueTextView"}, null, null, null, Theme.key_windowBackgroundWhiteGrayText2));
        }

        arrayList.add(new ThemeDescription(linearLayout2, ThemeDescription.FLAG_SELECTORWHITE, new Class[]{TextDetailSettingsCell.class}, null, null, null, Theme.key_windowBackgroundWhite));
        arrayList.add(new ThemeDescription(linearLayout2, 0, new Class[]{TextDetailSettingsCell.class}, new String[]{"textView"}, null, null, null, Theme.key_windowBackgroundWhiteBlackText));
        arrayList.add(new ThemeDescription(linearLayout2, 0, new Class[]{TextDetailSettingsCell.class}, new String[]{"valueTextView"}, null, null, null, Theme.key_windowBackgroundWhiteGrayText2));

        arrayList.add(new ThemeDescription(linearLayout2, ThemeDescription.FLAG_SELECTORWHITE, new Class[]{TextSettingsCell.class}, null, null, null, Theme.key_windowBackgroundWhite));
        arrayList.add(new ThemeDescription(linearLayout2, 0, new Class[]{TextSettingsCell.class}, new String[]{"textView"}, null, null, null, Theme.key_windowBackgroundWhiteBlackText));
        arrayList.add(new ThemeDescription(linearLayout2, 0, new Class[]{TextSettingsCell.class}, new String[]{"valueTextView"}, null, null, null, Theme.key_windowBackgroundWhiteValueText));

        arrayList.add(new ThemeDescription(linearLayout2, ThemeDescription.FLAG_BACKGROUNDFILTER, new Class[]{ShadowSectionCell.class}, null, null, null, Theme.key_windowBackgroundGrayShadow));

        arrayList.add(new ThemeDescription(linearLayout2, ThemeDescription.FLAG_SELECTORWHITE, new Class[]{TextDetailSecureCell.class}, null, null, null, Theme.key_windowBackgroundWhite));
        arrayList.add(new ThemeDescription(linearLayout2, ThemeDescription.FLAG_TEXTCOLOR, new Class[]{TextDetailSecureCell.class}, new String[]{"textView"}, null, null, null, Theme.key_windowBackgroundWhiteBlackText));
        arrayList.add(new ThemeDescription(linearLayout2, ThemeDescription.FLAG_TEXTCOLOR, new Class[]{TextDetailSecureCell.class}, null, null, null, Theme.key_divider));
        arrayList.add(new ThemeDescription(linearLayout2, ThemeDescription.FLAG_TEXTCOLOR, new Class[]{TextDetailSecureCell.class}, new String[]{"valueTextView"}, null, null, null, Theme.key_windowBackgroundWhiteGrayText2));
        arrayList.add(new ThemeDescription(linearLayout2, ThemeDescription.FLAG_IMAGECOLOR, new Class[]{TextDetailSecureCell.class}, new String[]{"checkImageView"}, null, null, null, Theme.key_featuredStickers_addedIcon));

        arrayList.add(new ThemeDescription(linearLayout2, ThemeDescription.FLAG_CELLBACKGROUNDCOLOR, new Class[]{HeaderCell.class}, null, null, null, Theme.key_windowBackgroundWhite));
        arrayList.add(new ThemeDescription(linearLayout2, 0, new Class[]{HeaderCell.class}, new String[]{"textView"}, null, null, null, Theme.key_windowBackgroundWhiteBlueHeader));

        arrayList.add(new ThemeDescription(linearLayout2, ThemeDescription.FLAG_BACKGROUNDFILTER, new Class[]{TextInfoPrivacyCell.class}, null, null, null, Theme.key_windowBackgroundGrayShadow));
        arrayList.add(new ThemeDescription(linearLayout2, 0, new Class[]{TextInfoPrivacyCell.class}, new String[]{"textView"}, null, null, null, Theme.key_windowBackgroundWhiteGrayText4));
        if (inputFields != null) {
            for (int a = 0; a < inputFields.length; a++) {
                arrayList.add(new ThemeDescription((View) inputFields[a].getParent(), ThemeDescription.FLAG_BACKGROUND, null, null, null, null, Theme.key_windowBackgroundWhite));
                arrayList.add(new ThemeDescription(inputFields[a], ThemeDescription.FLAG_TEXTCOLOR | ThemeDescription.FLAG_CURSORCOLOR, null, null, null, null, Theme.key_windowBackgroundWhiteBlackText));
                arrayList.add(new ThemeDescription(inputFields[a], ThemeDescription.FLAG_HINTTEXTCOLOR, null, null, null, null, Theme.key_windowBackgroundWhiteHintText));
                arrayList.add(new ThemeDescription(inputFields[a], ThemeDescription.FLAG_HINTTEXTCOLOR | ThemeDescription.FLAG_PROGRESSBAR, null, null, null, null, Theme.key_windowBackgroundWhiteBlueHeader));
                arrayList.add(new ThemeDescription(inputFields[a], ThemeDescription.FLAG_BACKGROUNDFILTER, null, null, null, null, Theme.key_windowBackgroundWhiteInputField));
                arrayList.add(new ThemeDescription(inputFields[a], ThemeDescription.FLAG_BACKGROUNDFILTER | ThemeDescription.FLAG_DRAWABLESELECTEDSTATE, null, null, null, null, Theme.key_windowBackgroundWhiteInputFieldActivated));
                arrayList.add(new ThemeDescription(inputFields[a], ThemeDescription.FLAG_BACKGROUNDFILTER | ThemeDescription.FLAG_PROGRESSBAR, null, null, null, null, Theme.key_windowBackgroundWhiteRedText3));
            }
        } else {
            arrayList.add(new ThemeDescription(null, ThemeDescription.FLAG_TEXTCOLOR, null, null, null, null, Theme.key_windowBackgroundWhiteBlackText));
            arrayList.add(new ThemeDescription(null, ThemeDescription.FLAG_HINTTEXTCOLOR, null, null, null, null, Theme.key_windowBackgroundWhiteHintText));
            arrayList.add(new ThemeDescription(null, ThemeDescription.FLAG_HINTTEXTCOLOR | ThemeDescription.FLAG_PROGRESSBAR, null, null, null, null, Theme.key_windowBackgroundWhiteBlueHeader));
            arrayList.add(new ThemeDescription(null, ThemeDescription.FLAG_BACKGROUNDFILTER, null, null, null, null, Theme.key_windowBackgroundWhiteInputField));
            arrayList.add(new ThemeDescription(null, ThemeDescription.FLAG_BACKGROUNDFILTER | ThemeDescription.FLAG_DRAWABLESELECTEDSTATE, null, null, null, null, Theme.key_windowBackgroundWhiteInputFieldActivated));
            arrayList.add(new ThemeDescription(null, ThemeDescription.FLAG_BACKGROUNDFILTER | ThemeDescription.FLAG_PROGRESSBAR, null, null, null, null, Theme.key_windowBackgroundWhiteRedText3));
        }

        if (inputExtraFields != null) {
            for (int a = 0; a < inputExtraFields.length; a++) {
                arrayList.add(new ThemeDescription((View) inputExtraFields[a].getParent(), ThemeDescription.FLAG_BACKGROUND, null, null, null, null, Theme.key_windowBackgroundWhite));
                arrayList.add(new ThemeDescription(inputExtraFields[a], ThemeDescription.FLAG_TEXTCOLOR | ThemeDescription.FLAG_CURSORCOLOR, null, null, null, null, Theme.key_windowBackgroundWhiteBlackText));
                arrayList.add(new ThemeDescription(inputExtraFields[a], ThemeDescription.FLAG_HINTTEXTCOLOR, null, null, null, null, Theme.key_windowBackgroundWhiteHintText));
                arrayList.add(new ThemeDescription(inputExtraFields[a], ThemeDescription.FLAG_HINTTEXTCOLOR | ThemeDescription.FLAG_PROGRESSBAR, null, null, null, null, Theme.key_windowBackgroundWhiteBlueHeader));
                arrayList.add(new ThemeDescription(inputExtraFields[a], ThemeDescription.FLAG_BACKGROUNDFILTER, null, null, null, null, Theme.key_windowBackgroundWhiteInputField));
                arrayList.add(new ThemeDescription(inputExtraFields[a], ThemeDescription.FLAG_BACKGROUNDFILTER | ThemeDescription.FLAG_DRAWABLESELECTEDSTATE, null, null, null, null, Theme.key_windowBackgroundWhiteInputFieldActivated));
                arrayList.add(new ThemeDescription(inputExtraFields[a], ThemeDescription.FLAG_BACKGROUNDFILTER | ThemeDescription.FLAG_PROGRESSBAR, null, null, null, null, Theme.key_windowBackgroundWhiteRedText3));
            }
        }

        arrayList.add(new ThemeDescription(emptyView, ThemeDescription.FLAG_PROGRESSBAR, null, null, null, null, Theme.key_progressCircle));
        arrayList.add(new ThemeDescription(noPasswordImageView, ThemeDescription.FLAG_IMAGECOLOR, null, null, null, null, Theme.key_chat_messagePanelIcons));
        arrayList.add(new ThemeDescription(noPasswordTextView, ThemeDescription.FLAG_TEXTCOLOR, null, null, null, null, Theme.key_windowBackgroundWhiteGrayText4));
        arrayList.add(new ThemeDescription(noPasswordSetTextView, ThemeDescription.FLAG_TEXTCOLOR, null, null, null, null, Theme.key_windowBackgroundWhiteBlueText5));
        arrayList.add(new ThemeDescription(passwordForgotButton, ThemeDescription.FLAG_TEXTCOLOR, null, null, null, null, Theme.key_windowBackgroundWhiteBlueText4));

        arrayList.add(new ThemeDescription(plusTextView, ThemeDescription.FLAG_TEXTCOLOR, null, null, null, null, Theme.key_windowBackgroundWhiteBlackText));

        arrayList.add(new ThemeDescription(acceptTextView, ThemeDescription.FLAG_TEXTCOLOR, null, null, null, null, Theme.key_passport_authorizeText));
        arrayList.add(new ThemeDescription(bottomLayout, ThemeDescription.FLAG_BACKGROUNDFILTER, null, null, null, null, Theme.key_passport_authorizeBackground));
        arrayList.add(new ThemeDescription(bottomLayout, ThemeDescription.FLAG_BACKGROUNDFILTER | ThemeDescription.FLAG_DRAWABLESELECTEDSTATE, null, null, null, null, Theme.key_passport_authorizeBackgroundSelected));

        arrayList.add(new ThemeDescription(progressView, 0, null, null, null, null, Theme.key_contextProgressInner2));
        arrayList.add(new ThemeDescription(progressView, 0, null, null, null, null, Theme.key_contextProgressOuter2));
        arrayList.add(new ThemeDescription(progressViewButton, 0, null, null, null, null, Theme.key_contextProgressInner2));
        arrayList.add(new ThemeDescription(progressViewButton, 0, null, null, null, null, Theme.key_contextProgressOuter2));

        arrayList.add(new ThemeDescription(emptyImageView, ThemeDescription.FLAG_IMAGECOLOR, null, null, null, null, Theme.key_sessions_devicesImage));
        arrayList.add(new ThemeDescription(emptyTextView1, ThemeDescription.FLAG_TEXTCOLOR, null, null, null, null, Theme.key_windowBackgroundWhiteGrayText2));
        arrayList.add(new ThemeDescription(emptyTextView2, ThemeDescription.FLAG_TEXTCOLOR, null, null, null, null, Theme.key_windowBackgroundWhiteGrayText2));
        arrayList.add(new ThemeDescription(emptyTextView3, ThemeDescription.FLAG_TEXTCOLOR, null, null, null, null, Theme.key_windowBackgroundWhiteBlueText4));

        return arrayList;
    }
}