/*
This file is part of Keepass2Android, Copyright 2013 Philipp Crocoll. This file is based on Keepassdroid, Copyright Brian Pellin.

  Keepass2Android is free software: you can redistribute it and/or modify
  it under the terms of the GNU General Public License as published by
  the Free Software Foundation, either version 3 of the License, or
  (at your option) any later version.

  Keepass2Android is distributed in the hope that it will be useful,
  but WITHOUT ANY WARRANTY; without even the implied warranty of
  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  GNU General Public License for more details.

  You should have received a copy of the GNU General Public License
  along with Keepass2Android.  If not, see <http://www.gnu.org/licenses/>.
  */

using System;
using System.Collections.Generic;
using System.Text;
using System.Linq;
using System.Threading;
using Android.App;
using Android.Content;
using Android.OS;
using Android.Runtime;
using Android.Text;
using Android.Views;
using Android.Widget;
using Android.Preferences;
using Android.Text.Method;
using System.Globalization;
using System.IO;
using System.Net;
using System.Threading.Tasks;
using Android.Content.PM;
using Android.Webkit;
using Android.Graphics;
using keepass2android.EntryActivityClasses;
using KeePassLib;
using KeePassLib.Security;
using KeePassLib.Utility;
using Keepass2android.Pluginsdk;
using keepass2android.Io;
using KeePass.DataExchange;
using KeePass.Util.Spr;
using KeePassLib.Interfaces;
using KeePassLib.Serialization;
using PluginTOTP;
using File = Java.IO.File;
using Uri = Android.Net.Uri;
using keepass2android.fileselect;
using KeeTrayTOTP.Libraries;
using Boolean = Java.Lang.Boolean;
using Android.Util;
using AndroidX.Core.Content;
using Google.Android.Material.Dialog;
using keepass2android;

namespace keepass2android
{
    public class ExportBinaryProcessManager : FileSaveProcessManager
    {
        private readonly string _binaryToSave;

        public ExportBinaryProcessManager(int requestCode, Activity activity, string key) : base(requestCode, activity)
        {
            _binaryToSave = key;
        }

        public ExportBinaryProcessManager(int requestCode, EntryActivity activity, Bundle savedInstanceState) : base(requestCode, activity)
        {
            _binaryToSave = savedInstanceState.GetString("BinaryToSave", null);
        }

        protected override void SaveFile(IOConnectionInfo ioc)
        {
            var task = new EntryActivity.WriteBinaryTask(_activity, App.Kp2a, new ActionOnFinish(_activity, (success, message, activity) =>
                {
                    if (!success)
                        App.Kp2a.ShowMessage(activity, message,  MessageSeverity.Error);
                }
            ), ((EntryActivity)_activity).Entry.Binaries.Get(_binaryToSave), ioc);
            ProgressTask pt = new ProgressTask(App.Kp2a, _activity, task);
            pt.Run();

        }

        public override void OnSaveInstanceState(Bundle outState)
        {
            outState.PutString("BinaryToSave", _binaryToSave);
        }
        

    }


	[Activity (Label = "@string/app_name", ConfigurationChanges = ConfigChanges.Orientation | ConfigChanges.Keyboard | ConfigChanges.KeyboardHidden,
        Theme = "@style/Kp2aTheme_ActionBar")]
	public class EntryActivity : LockCloseActivity 
	{
		public const String KeyEntry = "entry";
        public const String KeyRefreshPos = "refresh_pos";
        public const String KeyEntryHistoryIndex = "entry_history_index";
		public const String KeyActivateKeyboard = "activate_keyboard";
		public const String KeyGroupFullPath = "groupfullpath_key";

	    public const int requestCodeBinaryFilename = 42376;
        public const int requestCodeSelFileStorageForWriteAttachment = 42377;

        protected override View? SnackbarAnchorView => FindViewById(Resource.Id.main_content);

        public static void Launch(Activity act, PwEntry pw, int pos, AppTask appTask, ActivityFlags? flags = null, int historyIndex=-1)
		{
			Intent i = new Intent(act, typeof(EntryActivity));

            var db = App.Kp2a.FindDatabaseForElement(pw);
			i.PutExtra(KeyEntry, new ElementAndDatabaseId(db, pw).FullId);
			i.PutExtra(KeyRefreshPos, pos);
            i.PutExtra(KeyEntryHistoryIndex, historyIndex);

		    if (App.Kp2a.CurrentDb != db)
		    {
		        App.Kp2a.CurrentDb = db;
		    }

			if (flags != null)
				i.SetFlags((ActivityFlags) flags);

			appTask.ToIntent(i);
			if (flags != null && (((ActivityFlags) flags) | ActivityFlags.ForwardResult) == ActivityFlags.ForwardResult)
				act.StartActivity(i);
			else
				act.StartActivityForResult(i, 0);
		}

		public EntryActivity (IntPtr javaReference, JniHandleOwnership transfer)
			: base(javaReference, transfer)
		{
			
		}

		public EntryActivity()
		{
			_activityDesign = new ActivityDesign(this);
		}

		//this is the entry we display. Note that it might be an element from a History list in case _historyIndex >= 0
	    public PwEntry Entry;
		//if _historyIndex >=0, _historyParentEntry stores the PwEntry which contains the history entry "Entry"
        private PwEntry _historyParentEntry;

		private PasswordFont _passwordFont = new PasswordFont();

		internal Dictionary<TextView /*the "ProtectedField" of the ProtectedTextviewGroup*/, bool> _showPassword = new Dictionary<TextView, bool>();
		private int _pos;

        private AppTask _appTask;
        private AppTask AppTask
        {
            get { return _appTask; }
            set
            {
                _appTask = value;
                Kp2aLog.LogTask(value, MyDebugName);
            }
        }

		struct ProtectedTextviewGroup
	    {
	        public TextView ProtectedField;
	        public TextView VisibleProtectedField;
        }

		private List<ProtectedTextviewGroup> _protectedTextViews;
		private IMenu _menu;

		private readonly Dictionary<string, List<IPopupMenuItem>> _popupMenuItems =
			new Dictionary<string, List<IPopupMenuItem>>();

		private readonly Dictionary<string, IStringView> _stringViews = new Dictionary<string, IStringView>();
		private readonly List<PluginMenuOption> _pendingMenuOptions = new List<PluginMenuOption>();
		
		//make sure _timer doesn't go out of scope:
		private Timer _timer;
		private PluginActionReceiver _pluginActionReceiver;
		private PluginFieldReceiver _pluginFieldReceiver;
		private ActivityDesign _activityDesign;
	    


	    protected void SetEntryView()
		{
			SetContentView(Resource.Layout.entry_view);
		}

		protected void SetupEditButtons() {
			View edit =  FindViewById(Resource.Id.entry_edit);
			if (App.Kp2a.CurrentDb.CanWrite && _historyIndex < 0)
			{
				edit.Visibility = ViewStates.Visible;
				edit.Click += (sender, e) =>
				{
					EntryEditActivity.Launch(this, Entry, AppTask);
				};	
			}
			else
			{
				edit.Visibility = ViewStates.Gone;
			}
			
		}

		
		private class PluginActionReceiver : BroadcastReceiver
		{
			private readonly EntryActivity _activity;

			public PluginActionReceiver(EntryActivity activity)
			{
				_activity = activity;
			}

			public override void OnReceive(Context context, Intent intent)
			{
				var pluginPackage = intent.GetStringExtra(Strings.ExtraSender);
				if (new PluginDatabase(context).IsValidAccessToken(pluginPackage,
				                                                   intent.GetStringExtra(Strings.ExtraAccessToken),
				                                                   Strings.ScopeCurrentEntry))
				{
					if (intent.GetStringExtra(Strings.ExtraEntryId) != _activity.Entry.Uuid.ToHexString())
					{
						Kp2aLog.Log("received action for wrong entry " + intent.GetStringExtra(Strings.ExtraEntryId));
						return;
					}
					_activity.AddPluginAction(pluginPackage,
					                          intent.GetStringExtra(Strings.ExtraFieldId),
											  intent.GetStringExtra(Strings.ExtraActionId),
					                          intent.GetStringExtra(Strings.ExtraActionDisplayText),
					                          intent.GetIntExtra(Strings.ExtraActionIconResId, -1),
					                          intent.GetBundleExtra(Strings.ExtraActionData));
				}
				else
				{
					Kp2aLog.Log("received invalid request. Plugin not authorized.");
				}
			}
		}

		private class PluginFieldReceiver : BroadcastReceiver
		{
			private readonly EntryActivity _activity;

			public PluginFieldReceiver(EntryActivity activity)
			{
				_activity = activity;
			}

			public override void OnReceive(Context context, Intent intent)
			{
				if (intent.GetStringExtra(Strings.ExtraEntryId) != _activity.Entry.Uuid.ToHexString())
				{
					Kp2aLog.Log("received field for wrong entry " + intent.GetStringExtra(Strings.ExtraEntryId));
					return;
				}
				if (!new PluginDatabase(context).IsValidAccessToken(intent.GetStringExtra(Strings.ExtraSender),
				                                                    intent.GetStringExtra(Strings.ExtraAccessToken),
				                                                    Strings.ScopeCurrentEntry))
				{
					Kp2aLog.Log("received field with invalid access token from " + intent.GetStringExtra(Strings.ExtraSender));
					return;
				}
				string key = intent.GetStringExtra(Strings.ExtraFieldId);
				string value = intent.GetStringExtra(Strings.ExtraFieldValue);
				bool isProtected = intent.GetBooleanExtra(Strings.ExtraFieldProtected, false);
				_activity.SetPluginField(key, value, isProtected);
			}
		}

		private void SetPluginField(string key, string value, bool isProtected)
		{
			//update or add the string view:
			IStringView existingField;
			if (_stringViews.TryGetValue(key, out existingField))
			{
				existingField.Text = value;
			}
			else
			{
				ViewGroup extraGroup = (ViewGroup) FindViewById(Resource.Id.extra_strings);
				var view = CreateExtraSection(key, value, isProtected);
				extraGroup.AddView(view.View);
			}

            SetPasswordStyle();

			//update the Entry output in the App database and notify the CopyToClipboard service

		    if (App.Kp2a.LastOpenedEntry != null)
		    {
		        App.Kp2a.LastOpenedEntry.OutputStrings.Set(key, new ProtectedString(isProtected, value));
		        Intent updateKeyboardIntent = new Intent(this, typeof(CopyToClipboardService));
		        updateKeyboardIntent.SetAction(Intents.UpdateKeyboard);
		        updateKeyboardIntent.PutExtra(KeyEntry, new ElementAndDatabaseId(App.Kp2a.CurrentDb, Entry).FullId);
		        StartService(updateKeyboardIntent);

		        //notify plugins
		        NotifyPluginsOnModification(Strings.PrefixString + key);
		    }
		}

		private void AddPluginAction(string pluginPackage, string fieldId, string popupItemId, string displayText, int iconId, Bundle bundleExtra)
		{
			if (fieldId != null)
			{
				try
				{
					if (!_popupMenuItems.ContainsKey(fieldId))
					{
						Kp2aLog.Log("Did not find field with key " + fieldId);
						return;
					}
					//create a new popup item for the plugin action:
					var newPopup = new PluginPopupMenuItem(this, pluginPackage, fieldId, popupItemId, displayText, iconId, bundleExtra);
					//see if we already have a popup item for this field with the same item id
					var popupsForField = _popupMenuItems[fieldId];
					var popupItemPos = popupsForField.FindIndex(0,
															item =>
															(item is PluginPopupMenuItem) &&
															((PluginPopupMenuItem)item).PopupItemId == popupItemId);

					//replace existing or add
					if (popupItemPos >= 0)
					{
						popupsForField[popupItemPos] = newPopup;
					}
					else
					{
						popupsForField.Add(newPopup);
					}
				}
				catch (Exception e)
				{
					Kp2aLog.LogUnexpectedError(e);
				}
				
			}
			else
			{
				//we need to add an option to the  menu.
				//As it is not sure that OnCreateOptionsMenu was called yet, we cannot access _menu without a check:

				Intent i = new Intent(Strings.ActionEntryActionSelected);
				i.SetPackage(pluginPackage);
				i.PutExtra(Strings.ExtraActionData, bundleExtra);
				i.PutExtra(Strings.ExtraSender, PackageName);
				PluginHost.AddEntryToIntent(i, App.Kp2a.LastOpenedEntry);

				var menuOption = new PluginMenuOption()
					{
						DisplayText = displayText,
						Icon = PackageManager.GetResourcesForApplication(pluginPackage).GetDrawable(iconId),
						Intent = i
					};

				if (_menu != null)
				{
					AddMenuOption(menuOption);
				}
				else
				{
					lock (_pendingMenuOptions)
					{
						_pendingMenuOptions.Add(menuOption);
					}

				}


			}
		}

		private void AddMenuOption(PluginMenuOption menuOption)
		{
			var menuItem = _menu.Add(menuOption.DisplayText);
			menuItem.SetIcon(menuOption.Icon);
			menuItem.SetIntent(menuOption.Intent);
		}

		


		protected override void OnCreate(Bundle savedInstanceState)
		{
		    if (savedInstanceState != null)
		    {
		        _exportBinaryProcessManager =
		            new ExportBinaryProcessManager(requestCodeSelFileStorageForWriteAttachment, this, savedInstanceState);

		    }

		    ISharedPreferences prefs = PreferenceManager.GetDefaultSharedPreferences(this);

			long usageCount = prefs.GetLong(GetString(Resource.String.UsageCount_key), 0);

			ISharedPreferencesEditor edit = prefs.Edit();
			edit.PutLong(GetString(Resource.String.UsageCount_key), usageCount + 1);
			edit.Commit();

			_showPasswordDefault =
				!prefs.GetBoolean(GetString(Resource.String.maskpass_key), Resources.GetBoolean(Resource.Boolean.maskpass_default));
            _showTotpDefault =
                !prefs.GetBoolean(GetString(Resource.String.masktotp_key), Resources.GetBoolean(Resource.Boolean.masktotp_default));

			RequestWindowFeature(WindowFeatures.IndeterminateProgress);
			
			_activityDesign.ApplyTheme(); 
			base.OnCreate(savedInstanceState);
			

			

			SetEntryView();

			Database db = App.Kp2a.CurrentDb;
			// Likely the app has been killed exit the activity 
			if (db == null || (App.Kp2a.QuickLocked))
			{
				Finish();
				return;
			}

			SetResult(KeePass.ExitNormal);

			Intent i = Intent;
            ElementAndDatabaseId dbAndElementId = new ElementAndDatabaseId(i.GetStringExtra(KeyEntry));
			PwUuid uuid = new PwUuid(MemUtil.HexStringToByteArray(dbAndElementId.ElementIdString));
			_pos = i.GetIntExtra(KeyRefreshPos, -1);
            _historyIndex = i.GetIntExtra(KeyEntryHistoryIndex, -1);

			AppTask = AppTask.GetTaskInOnCreate(savedInstanceState, Intent);

			Entry = db.EntriesById[uuid];

            if (_historyIndex >= 0 && _historyIndex < Entry.History.UCount)
            {
                _historyParentEntry = Entry;
                Entry = Entry.History.Skip(_historyIndex).First();
                FindViewById<Button>(Resource.Id.btn_restore_history).Click += (sender, args) =>
                {
                    RestoreFromHistory();
                    SaveHistoryChangeAndFinish();
                };
                FindViewById<Button>(Resource.Id.btn_remove_history).Click += (sender, args) =>
                {
                    RemoveFromHistory();
                    SaveHistoryChangeAndFinish();
				};


            }
            else
            {
                // Update last access time.
                Entry.Touch(false);
                FindViewById<Button>(Resource.Id.btn_restore_history).Visibility = ViewStates.Gone;
                FindViewById<Button>(Resource.Id.btn_remove_history).Visibility = ViewStates.Gone;
			}

            // Refresh Menu contents in case onCreateMenuOptions was called before Entry was set
			ActivityCompat.InvalidateOptionsMenu(this);

			

			if (PwDefs.IsTanEntry(Entry) 
                && prefs.GetBoolean(GetString(Resource.String.TanExpiresOnUse_key), Resources.GetBoolean(Resource.Boolean.TanExpiresOnUse_default)) 
                && ((Entry.Expires == false) || Entry.ExpiryTime > DateTime.Now))
			{
				PwEntry backupEntry = Entry.CloneDeep();
				Entry.ExpiryTime = DateTime.Now;
				Entry.Expires = true;
				Entry.Touch(true);
				RequiresRefresh();
				UpdateEntry update = new UpdateEntry(this, App.Kp2a, backupEntry, Entry, null);
				ProgressTask pt = new ProgressTask(App.Kp2a, this, update);
				pt.Run();
			}
			FillData();

			SetupEditButtons();
			
			App.Kp2a.LastOpenedEntry = new PwEntryOutput(Entry, App.Kp2a.CurrentDb);

			_pluginActionReceiver = new PluginActionReceiver(this);
			ContextCompat.RegisterReceiver(this, _pluginActionReceiver, new IntentFilter(Strings.ActionAddEntryAction), (int)ReceiverFlags.Exported);
			_pluginFieldReceiver = new PluginFieldReceiver(this);
            ContextCompat.RegisterReceiver(this, _pluginFieldReceiver, new IntentFilter(Strings.ActionSetEntryField), (int)ReceiverFlags.Exported);

            var notifyPluginsOnOpenThread = new Thread(NotifyPluginsOnOpen);
            notifyPluginsOnOpenThread.Start();

			//the rest of the things to do depends on the current app task:
			AppTask.CompleteOnCreateEntryActivity(this, notifyPluginsOnOpenThread);
		}

        private void RemoveFromHistory()
        {
            _historyParentEntry.History.RemoveAt((uint)_historyIndex);
            _historyParentEntry.Touch(true, false);
		}

        private void RestoreFromHistory()
        {
            var db = App.Kp2a.FindDatabaseForElement(_historyParentEntry);
			_historyParentEntry.RestoreFromBackup((uint)_historyIndex, db.KpDatabase);
            _historyParentEntry.Touch(true, false);
		}

        private void SaveHistoryChangeAndFinish()
        {
            PwGroup parent = _historyParentEntry.ParentGroup;
            if (parent != null)
            {
                // Mark parent group dirty (title might have changed etc.)
                App.Kp2a.DirtyGroups.Add(parent);
            }

			var saveTask = new SaveDb(this, App.Kp2a, App.Kp2a.FindDatabaseForElement(Entry), new ActionOnFinish(this, (success, message, activity) =>
            {
                activity.SetResult(KeePass.ExitRefresh);
                activity.Finish();
            }));

            ProgressTask pt = new ProgressTask(App.Kp2a, this, saveTask);
            pt.Run();
		}

        private void NotifyPluginsOnOpen()
		{
			Intent i = new Intent(Strings.ActionOpenEntry);
			i.PutExtra(Strings.ExtraSender, PackageName);
			AddEntryToIntent(i);

			foreach (var plugin in new PluginDatabase(this).GetPluginsWithAcceptedScope(Strings.ScopeCurrentEntry))
			{
				i.SetPackage(plugin);
				SendBroadcast(i);
			}

			new Kp2aTotp().OnOpenEntry();

		}
		private void NotifyPluginsOnModification(string fieldId)
		{
			Intent i = new Intent(Strings.ActionEntryOutputModified);
			i.PutExtra(Strings.ExtraSender, PackageName);
			i.PutExtra(Strings.ExtraFieldId, fieldId);
			AddEntryToIntent(i);


			foreach (var plugin in new PluginDatabase(this).GetPluginsWithAcceptedScope(Strings.ScopeCurrentEntry))
			{
				i.SetPackage(plugin);
				SendBroadcast(i);
			}
		}


        public override void OnRequestPermissionsResult(int requestCode, string[] permissions, [GeneratedEnum] Android.Content.PM.Permission[] grantResults)
        {
            if (permissions.Length == 1 && permissions.First() == Android.Manifest.Permission.PostNotifications &&
                grantResults.First() == Permission.Granted)
            {
                StartNotificationsServiceAfterPermissionsCheck(requestCode == 1 /*requestCode is used to transfer this flag*/);
            }

            base.OnRequestPermissionsResult(requestCode, permissions, grantResults);
        }
        internal void StartNotificationsService(bool activateKeyboard)
        {
            if (PreferenceManager.GetDefaultSharedPreferences(this).GetBoolean(
                    GetString(Resource.String.CopyToClipboardNotification_key),
                    Resources.GetBoolean(Resource.Boolean.CopyToClipboardNotification_default)) == false
                && PreferenceManager.GetDefaultSharedPreferences(this).GetBoolean(
                    GetString(Resource.String.UseKp2aKeyboard_key),
                    Resources.GetBoolean(Resource.Boolean.UseKp2aKeyboard_default)) == false)
            {
				//notifications are disabled
                return;
            }

            if ((int)Build.VERSION.SdkInt < 33 || CheckSelfPermission(Android.Manifest.Permission.PostNotifications) ==
                Permission.Granted)
			{
                StartNotificationsServiceAfterPermissionsCheck(activateKeyboard);
                return;
            }

            //user has not yet granted Android 13's POST_NOTIFICATONS permission for the app.

			//check if we should ask them to grant:
            if (!ShouldShowRequestPermissionRationale(Android.Manifest.Permission.PostNotifications) //this menthod returns false if we haven't asked yet or if the user has denied permission too often
                && PreferenceManager.GetDefaultSharedPreferences(this).GetBoolean("RequestedPostNotificationsPermission", false))//use a preference to tell the difference between "haven't asked yet" and "have asked too often"
            {
				//user has denied permission before. Do not show the dialog. User must give permission in the Android App settings.
                return;
            }

            new MaterialAlertDialogBuilder(this)
                .SetTitle(Resource.String.post_notifications_dialog_title)
                .SetMessage(Resource.String.post_notifications_dialog_message)
                .SetNegativeButton(Resource.String.post_notifications_dialog_disable, (sender, args) =>
                {
					//disable this dialog for the future by disabling the notification preferences
                    var edit= PreferenceManager.GetDefaultSharedPreferences(this).Edit();
                    edit.PutBoolean(GetString(Resource.String.CopyToClipboardNotification_key), false);
                    edit.PutBoolean(GetString(Resource.String.UseKp2aKeyboard_key), false);
                    edit.Commit();
                })
                .SetPositiveButton(Resource.String.post_notifications_dialog_allow, (sender, args) =>
                {

                    //remember that we did ask for permission at least once:
                    var edit = PreferenceManager.GetDefaultSharedPreferences(this).Edit();
                    edit.PutBoolean("RequestedPostNotificationsPermission", true);
                    edit.Commit();

                    //request permission. user must grant, we'll show notifications in the OnRequestPermissionResults() callback
                    AndroidX.Core.App.ActivityCompat.RequestPermissions(this, new[] { Android.Manifest.Permission.PostNotifications }, activateKeyboard ? 1 : 0 /*use requestCode to transfer the flag*/);


                })
                .SetNeutralButton(Resource.String.post_notifications_dialog_notnow, (sender, args) => {  })
                .Show();


        }

        private void StartNotificationsServiceAfterPermissionsCheck(bool activateKeyboard)
        {
            Intent showNotIntent = new Intent(this, typeof(CopyToClipboardService));
            showNotIntent.SetAction(Intents.ShowNotification);
            showNotIntent.PutExtra(KeyEntry, new ElementAndDatabaseId(App.Kp2a.CurrentDb, Entry).FullId);
            AppTask.PopulatePasswordAccessServiceIntent(showNotIntent);
            showNotIntent.PutExtra(KeyActivateKeyboard, activateKeyboard);

            StartService(showNotIntent);
        }


        private String getDateTime(DateTime dt)
		{
			return dt.ToLocalTime().ToString("g", CultureInfo.CurrentUICulture);
		}

		private String concatTags(List<string> tags)
		{
			StringBuilder sb = new StringBuilder();
			foreach (string tag in tags)
			{
				sb.Append(tag);
				sb.Append(", ");
			}
			if (tags.Count > 0)
				sb.Remove(sb.Length - 2, 2);
			return sb.ToString();
		}

		private void PopulateExtraStrings()
		{
			ViewGroup extraGroup = (ViewGroup) FindViewById(Resource.Id.extra_strings);
		    bool hasExtras = false;
			EditModeBase editMode = new DefaultEdit();
			if (KpEntryTemplatedEdit.IsTemplated(App.Kp2a.CurrentDb, this.Entry))
				editMode = new KpEntryTemplatedEdit(App.Kp2a.CurrentDb, this.Entry);
			foreach (var key in  editMode.SortExtraFieldKeys(Entry.Strings.GetKeys().Where(key=> !PwDefs.IsStandardField(key) && key != Kp2aTotp.TotpKey)))
			{
				if (editMode.IsVisible(key))
				{
					hasExtras = true;
					var value = Entry.Strings.Get(key);
					var stringView = CreateExtraSection(key, value.ReadString(), value.IsProtected);
					extraGroup.AddView(stringView.View);
				}
			}
            FindViewById(Resource.Id.extra_strings_container).Visibility = hasExtras ? ViewStates.Visible : ViewStates.Gone;
		}

		private ExtraStringView CreateExtraSection(string key, string value, bool isProtected)
		{
			LinearLayout layout = new LinearLayout(this, null) {Orientation = Orientation.Vertical};
			LinearLayout.LayoutParams layoutParams = new LinearLayout.LayoutParams(ViewGroup.LayoutParams.FillParent,
			                                                                       ViewGroup.LayoutParams.WrapContent);

			layout.LayoutParameters = layoutParams;
			View viewInflated = LayoutInflater.Inflate(Resource.Layout.entry_extrastring_title, null);
			TextView keyView = viewInflated.FindViewById<TextView>(Resource.Id.entry_title);
			if (key != null)
				keyView.Text = key;

			layout.AddView(viewInflated);
			RelativeLayout valueViewContainer =
				(RelativeLayout) LayoutInflater.Inflate(Resource.Layout.entry_extrastring_value, null);
			var valueView = valueViewContainer.FindViewById<TextView>(Resource.Id.entry_extra);
		    var valueViewVisible = valueViewContainer.FindViewById<TextView>(Resource.Id.entry_extra_visible);
		    if (value != null)
		    {
		        valueView.Text = value;
                valueViewVisible.Text = value;

            }
		    SetPasswordTypeface(valueViewVisible);
		    if (isProtected)
		    {
		        RegisterProtectedTextView(key, valueView, valueViewVisible);
                
		    }
		    else
		    {
		        valueView.Visibility = ViewStates.Gone;
		    }

			layout.AddView(valueViewContainer);
			var stringView = new ExtraStringView(layout, valueView, valueViewVisible, keyView);

			_stringViews.Add(key, stringView);
			RegisterTextPopup(valueViewContainer, valueViewContainer.FindViewById(Resource.Id.extra_vdots), key, isProtected, layout);

			return stringView;

		}



		private List<IPopupMenuItem> RegisterPopup(string popupKey, View clickView, View anchorView)
		{
			
			clickView.Click += (sender, args) =>
				{
					ShowPopup(anchorView, popupKey);
				};
			_popupMenuItems[popupKey] = new List<IPopupMenuItem>();
			return _popupMenuItems[popupKey];
		}

	    internal Uri WriteBinaryToFile(string key, bool writeToCacheDirectory)
	    {
	        ProtectedBinary pb = Entry.Binaries.Get(key);
	        System.Diagnostics.Debug.Assert(pb != null);
	        if (pb == null)
	            throw new ArgumentException();


	        ISharedPreferences prefs = PreferenceManager.GetDefaultSharedPreferences(this);
	        
	        if (writeToCacheDirectory)
	        {
	            string binaryDirectory = CacheDir.Path + File.Separator + AttachmentContentProvider.AttachmentCacheSubDir;

	            string filepart = key;
	            Java.Lang.String javaFilename = new Java.Lang.String(filepart);
	            filepart = javaFilename.ReplaceAll("[^a-zA-Z0-9.-]", "_");

	            var targetFile = new File(binaryDirectory, filepart);

	            File parent = targetFile.ParentFile;

	            if (parent == null || (parent.Exists() && !parent.IsDirectory))
	            {
	                App.Kp2a.ShowMessage(this,
	                    Resource.String.error_invalid_path,
	                     MessageSeverity.Error);
	                return null;
	            }

	            if (!parent.Exists())
	            {
	                // Create parent directory
	                if (!parent.Mkdirs())
	                {
	                    App.Kp2a.ShowMessage(this,
	                        Resource.String.error_could_not_create_parent,
	                         MessageSeverity.Error);
	                    return null;

	                }
	            }
	            string filename = targetFile.AbsolutePath;

	            byte[] pbData = pb.ReadData();
	            try
	            {
	                System.IO.File.WriteAllBytes(filename, pbData);
	            }
	            catch (Exception exWrite)
	            {
	                App.Kp2a.ShowMessage(this,
	                    GetString(Resource.String.SaveAttachment_Failed, new Java.Lang.Object[] {filename})
	                    + Util.GetErrorMessage(exWrite),  MessageSeverity.Error);
	                return null;
	            }
	            finally
	            {
	                MemUtil.ZeroByteArray(pbData);
	            }
	            App.Kp2a.ShowMessage(this,
	                GetString(Resource.String.SaveAttachment_doneMessage, new Java.Lang.Object[] {filename}),
	                 MessageSeverity.Info);
	            return Uri.Parse("content://" + AttachmentContentProvider.Authority + "/"
	                             + filename);
	        }
	        else
	        {
	            _exportBinaryProcessManager =
	                new ExportBinaryProcessManager(requestCodeSelFileStorageForWriteAttachment, this, key);
                _exportBinaryProcessManager.StartProcess();
	            return null;
	        }
	    
    	    
		}

		internal void OpenBinaryFile(Android.Net.Uri uri)
		{


			String theMimeType = GetMimeType(uri.Path);
			if (theMimeType != null)
			{

				Intent theIntent = new Intent(Intent.ActionView);
				theIntent.AddFlags(ActivityFlags.NewTask | ActivityFlags.ExcludeFromRecents);
				theIntent.SetDataAndType(uri, theMimeType);
				try
				{
					StartActivity(theIntent);
				}
				catch (ActivityNotFoundException)
				{
					//ignore
					App.Kp2a.ShowMessage(this, "Couldn't open file",  MessageSeverity.Error);
				}
			}

		}



		private void RegisterProtectedTextView(string fieldKey, TextView protectedTextView, TextView visibleTextView)
		{
            if (!_showPassword.ContainsKey(protectedTextView))
            {
                _showPassword[protectedTextView] = fieldKey == Kp2aTotp.TotpKey ? _showTotpDefault : _showPasswordDefault;
            }
		    var protectedTextviewGroup = new ProtectedTextviewGroup { ProtectedField = protectedTextView, VisibleProtectedField = visibleTextView};
		    _protectedTextViews.Add(protectedTextviewGroup);
            SetPasswordStyle(protectedTextviewGroup);
		}


		private void PopulateBinaries()
		{
			ViewGroup binariesGroup = (ViewGroup) FindViewById(Resource.Id.binaries);
			foreach (KeyValuePair<string, ProtectedBinary> pair in Entry.Binaries)
			{
				String key = pair.Key;


				RelativeLayout valueViewContainer =
					(RelativeLayout) LayoutInflater.Inflate(Resource.Layout.entry_extrastring_value, null);
				var valueView = valueViewContainer.FindViewById<TextView>(Resource.Id.entry_extra);
				if (key != null)
					valueView.Text = key;

				string popupKey = Strings.PrefixBinary + key;

				var itemList = RegisterPopup(popupKey, valueViewContainer, valueViewContainer.FindViewById(Resource.Id.extra_vdots));
				itemList.Add(new WriteBinaryToFilePopupItem(key, this));
				itemList.Add(new OpenBinaryPopupItem(key, this));
				itemList.Add(new ViewImagePopupItem(key, this));




				binariesGroup.AddView(valueViewContainer);
				/*
				Button binaryButton = new Button(this);
				RelativeLayout.LayoutParams layoutParams = new RelativeLayout.LayoutParams(ViewGroup.LayoutParams.FillParent, ViewGroup.LayoutParams.WrapContent);
				binaryButton.Text = key;
				binaryButton.SetCompoundDrawablesWithIntrinsicBounds( Resources.GetDrawable(Android.Resource.Drawable.IcMenuSave),null, null, null);
				binaryButton.Click += (sender, e) => 
				{
					Button btnSender = (Button)(sender);

					MaterialAlertDialogBuilder builder = new MaterialAlertDialogBuilder(this);
					builder.SetTitle(GetString(Resource.String.SaveAttachmentDialog_title));
					
					builder.SetMessage(GetString(Resource.String.SaveAttachmentDialog_text));
					
					builder.SetPositiveButton(GetString(Resource.String.SaveAttachmentDialog_save), (dlgSender, dlgEvt) => 
					                                                                                                                    {
							
						});
					
					builder.SetNegativeButton(GetString(Resource.String.SaveAttachmentDialog_open), (dlgSender, dlgEvt) => 
					                                                                                                                   {
							
						});

					Dialog dialog = builder.Create();
					dialog.Show();


				};
				binariesGroup.AddView(binaryButton,layoutParams);
				*/

			}
			FindViewById(Resource.Id.entry_binaries_label).Visibility = Entry.Binaries.Any() ? ViewStates.Visible : ViewStates.Gone;
		}

		// url = file path or whatever suitable URL you want.
		public static String GetMimeType(String url)
		{
			String type = null;
			String extension = MimeTypeMap.GetFileExtensionFromUrl(url);
			if (extension != null)
			{
				MimeTypeMap mime = MimeTypeMap.Singleton;
				type = mime.GetMimeTypeFromExtension(extension.ToLowerInvariant());
			}
			return type;
		}

		public override void OnBackPressed()
		{
			base.OnBackPressed();
			//OverridePendingTransition(Resource.Animation.anim_enter_back, Resource.Animation.anim_leave_back);
		}

		protected void FillData()
		{
			_protectedTextViews = new List<ProtectedTextviewGroup>();
			ImageView iv = (ImageView) FindViewById(Resource.Id.icon);
			if (iv != null)
			{
				iv.SetImageDrawable(Resources.GetDrawable(Resource.Drawable.ic00));
			}

            SupportActionBar.Title = Entry.Strings.ReadSafe(PwDefs.TitleField);
            SupportActionBar.Title = SprEngine.Compile(SupportActionBar.Title, new SprContext(Entry, App.Kp2a.CurrentDb.KpDatabase, SprCompileFlags.All));
			SupportActionBar.SetDisplayHomeAsUpEnabled(true);
            SupportActionBar.SetHomeButtonEnabled(true);

			PopulateGroupText (Resource.Id.entry_group_name, Resource.Id.entryfield_group_container, KeyGroupFullPath);

			PopulateStandardText(Resource.Id.entry_user_name, Resource.Id.entryfield_container_username, PwDefs.UserNameField);
			PopulateStandardText(Resource.Id.entry_url, Resource.Id.entryfield_container_url, PwDefs.UrlField);
            PopulateStandardText(new List<int> { Resource.Id.entry_totp, Resource.Id.entry_totp_visible }, Resource.Id.entryfield_container_totp, Kp2aTotp.TotpKey);
            PopulateStandardText(new List<int> { Resource.Id.entry_password, Resource.Id.entry_password_visible}, Resource.Id.entryfield_container_password, PwDefs.PasswordField);
		    
            RegisterProtectedTextView(PwDefs.PasswordField, FindViewById<TextView>(Resource.Id.entry_password), FindViewById<TextView>(Resource.Id.entry_password_visible));
            RegisterProtectedTextView(Kp2aTotp.TotpKey, FindViewById<TextView>(Resource.Id.entry_totp), FindViewById<TextView>(Resource.Id.entry_totp_visible));

            RegisterTextPopup(FindViewById<RelativeLayout> (Resource.Id.groupname_container),
				              FindViewById (Resource.Id.entry_group_name), KeyGroupFullPath,
                              FindViewById(Resource.Id.entryfield_group_container));

			RegisterTextPopup(FindViewById<RelativeLayout>(Resource.Id.username_container),
			                  FindViewById(Resource.Id.username_vdots), PwDefs.UserNameField,
                              FindViewById(Resource.Id.entryfield_container_username));

			RegisterTextPopup(FindViewById<RelativeLayout>(Resource.Id.url_container),
			                  FindViewById(Resource.Id.url_vdots), PwDefs.UrlField,
                              FindViewById(Resource.Id.entryfield_container_url))
				.Add(new GotoUrlMenuItem(this, PwDefs.UrlField));
			RegisterTextPopup(FindViewById<RelativeLayout>(Resource.Id.password_container),
			                  FindViewById(Resource.Id.password_vdots), PwDefs.PasswordField,
                              FindViewById(Resource.Id.entryfield_container_password));
            RegisterTextPopup(FindViewById<RelativeLayout>(Resource.Id.totp_container),
                FindViewById(Resource.Id.totp_vdots), Kp2aTotp.TotpKey, FindViewById(Resource.Id.entryfield_container_totp));


            PopulateText(Resource.Id.entry_created, Resource.Id.entryfield_container_created, getDateTime(Entry.CreationTime));
			PopulateText(Resource.Id.entry_modified, Resource.Id.entryfield_container_modified, getDateTime(Entry.LastModificationTime));

			if (Entry.Expires)
			{
				PopulateText(Resource.Id.entry_expires, Resource.Id.entryfield_container_expires, getDateTime(Entry.ExpiryTime));

			}
			else
			{
				PopulateText(Resource.Id.entry_expires, Resource.Id.entryfield_container_expires, null);
			}
			PopulateStandardText(Resource.Id.entry_comment, Resource.Id.entryfield_container_comment, PwDefs.NotesField);
			RegisterTextPopup(FindViewById<RelativeLayout>(Resource.Id.comment_container),
							  FindViewById(Resource.Id.comment_vdots), PwDefs.NotesField,
                              FindViewById(Resource.Id.entryfield_container_comment));
                              
			PopulateText(Resource.Id.entry_tags, Resource.Id.entryfield_container_tags, concatTags(Entry.Tags));
			PopulateText(Resource.Id.entry_override_url, Resource.Id.entryfield_container_overrideurl, Entry.OverrideUrl);

			PopulateExtraStrings();

			PopulateBinaries();

            PopulatePreviousVersions();

			SetPasswordStyle();
		}
		
        private async Task UpdateTotpCountdown()
        {
            if (App.Kp2a.LastOpenedEntry == null)
                return;
            var totpData = new Kp2aTotp().TryGetTotpData(App.Kp2a.LastOpenedEntry);

            if (totpData == null || !totpData.IsTotpEntry)
                return;

            var totpProvider = new TOTPProvider(totpData);

            var progressBar = FindViewById<ProgressBar>(Resource.Id.TotpCountdownProgressBar);

            int lastSecondsLeft = -1;
            while (!isPaused && progressBar != null)
            {

                int secondsLeft = totpProvider.Timer;

                if (secondsLeft != lastSecondsLeft)
                {
                    lastSecondsLeft = secondsLeft;
                    // Update the progress bar on the UI thread
                    RunOnUiThread(() =>
                    {
                        progressBar.Progress = secondsLeft;
                        progressBar.Max = totpProvider.Duration;
                    });
                }
                
				await Task.Delay(1000); 
            }
        }

        private void PopulatePreviousVersions()
        {
			ViewGroup historyGroup = (ViewGroup)FindViewById(Resource.Id.previous_versions);
            int index = 0;
			foreach (var previousVersion in Entry.History)
            {
                Button btn = (Button)LayoutInflater.Inflate(Resource.Layout.VersionHistoryButton, null);
				
                btn.Text = getDateTime(previousVersion.LastModificationTime);

				//copy variable from outer scope for capturing it below.
                var index1 = index;
                btn.Click += (sender, args) =>
                {
                    EntryActivity.Launch(this, this.Entry, this._pos, this.AppTask, null, index1);
                };

				historyGroup.AddView(btn);

                index++;


            }
			FindViewById(Resource.Id.entry_history_container).Visibility = Entry.History.Any() ? ViewStates.Visible : ViewStates.Gone;
		}


        protected override void OnDestroy()
		{
			NotifyPluginsOnClose();
			if (_pluginActionReceiver != null)
				UnregisterReceiver(_pluginActionReceiver);
			if (_pluginFieldReceiver != null)
				UnregisterReceiver(_pluginFieldReceiver);
			base.OnDestroy();
		}

		private void NotifyPluginsOnClose()
		{
			Intent i = new Intent(Strings.ActionCloseEntryView);
			i.PutExtra(Strings.ExtraSender, PackageName);
			foreach (var plugin in new PluginDatabase(this).GetPluginsWithAcceptedScope(Strings.ScopeCurrentEntry))
			{
				i.SetPackage(plugin);
				SendBroadcast(i);
			}
		}
		private List<IPopupMenuItem> RegisterTextPopup(View container, View anchor, string fieldKey, View outerContainer)
		{
			return RegisterTextPopup(container, anchor, fieldKey, Entry.Strings.GetSafe(fieldKey).IsProtected || fieldKey == Kp2aTotp.TotpKey, outerContainer);
		}

		private List<IPopupMenuItem> RegisterTextPopup(View container, View anchor, string fieldKey, bool isProtected, View outerContainer)
		{
			string popupKey = Strings.PrefixString + fieldKey;
			var popupItems = RegisterPopup(
				popupKey,
				container,
				anchor);
			popupItems.Add(new CopyToClipboardPopupMenuIcon(this, _stringViews[fieldKey], isProtected));
            if (isProtected)
            {
                var valueView = container.FindViewById<TextView>(fieldKey switch
                {
                    PwDefs.PasswordField => Resource.Id.entry_password,
                    Kp2aTotp.TotpKey => Resource.Id.entry_totp,
                    _ => Resource.Id.entry_extra
                });
				popupItems.Add(new ToggleVisibilityPopupMenuItem(this, valueView));
            }

			//copy text to clipboard when the outer container (including the field icon on the left) or the inner container
			// (containing the textview and the vertical dots for the popup menu) is long-clicked.
            RegisterCopyOnLongClick(outerContainer, fieldKey, isProtected);
            RegisterCopyOnLongClick(container, fieldKey, isProtected);

            if (fieldKey != PwDefs.UrlField //url already has a go-to-url menu
                && (_stringViews[fieldKey].Text.StartsWith(KeePass.AndroidAppScheme)
                    || _stringViews[fieldKey].Text.StartsWith("http://")
                    || _stringViews[fieldKey].Text.StartsWith("https://")))
            {
                popupItems.Add(new GotoUrlMenuItem(this, fieldKey));
			}
			return popupItems;
		}

        private void RegisterCopyOnLongClick(View container, string fieldKey, bool isProtected)
        {
            container.LongClick += (sender, args) =>
                CopyToClipboardService.CopyValueToClipboardWithTimeout(this, _stringViews[fieldKey].Text, isProtected);
        }


		private void ShowPopup(View anchor, string popupKey)
		{
			//PopupMenu popupMenu = new PopupMenu(this, FindViewById(Resource.Id.entry_user_name));
			PopupMenu popupMenu = new PopupMenu(this, anchor);

			AccessManager.PreparePopup(popupMenu);
			int itemId = 0;
			foreach (IPopupMenuItem popupItem in _popupMenuItems[popupKey])
			{
				popupMenu.Menu.Add(0, itemId, 0, popupItem.Text)
				         .SetIcon(popupItem.Icon);
				itemId++;
			}

			popupMenu.MenuItemClick += delegate(object sender, PopupMenu.MenuItemClickEventArgs args)
				{
					_popupMenuItems[popupKey][args.Item.ItemId].HandleClick();
				};
			popupMenu.Show();
		}

		
		private void SetPasswordTypeface(TextView textView)
		{
			_passwordFont.ApplyTo(textView);	
		}

	    private void PopulateText(int viewId, int containerViewId, String text)
	    {
	        PopulateText(new List<int> {viewId}, containerViewId, text);
	    }


        private void PopulateText(List<int> viewIds, int containerViewId, String text)
		{
			View container = FindViewById(containerViewId);
		    foreach (int viewId in viewIds)
		    {
		        TextView tv = (TextView) FindViewById(viewId);
		        if (String.IsNullOrEmpty(text))
		        {
		            container.Visibility = tv.Visibility = ViewStates.Gone;
		        }
		        else
		        {
		            container.Visibility = tv.Visibility = ViewStates.Visible;
		            tv.Text = text;

		        }
		    }
		}

	    private void PopulateStandardText(int viewId, int containerViewId, String key)
	    {
	        PopulateStandardText(new List<int> {viewId}, containerViewId, key);
	    }


        private void PopulateStandardText(List<int> viewIds, int containerViewId, String key)
		{
			String value = Entry.Strings.ReadSafe(key);
			value = SprEngine.Compile(value, new SprContext(Entry, App.Kp2a.CurrentDb.KpDatabase, SprCompileFlags.All));
			PopulateText(viewIds, containerViewId, value);
			_stringViews.Add(key, new StandardStringView(viewIds, containerViewId, this));
            

		}

		private void PopulateGroupText(int viewId, int containerViewId, String key)
		{
			string groupName = null;
			if (PreferenceManager.GetDefaultSharedPreferences(this).GetBoolean(
				"ShowGroupInEntry", false))
			{
				groupName = Entry.ParentGroup?.GetFullPath();
			}

            PopulateText(viewId, containerViewId, groupName);
            _stringViews.Add(key, new StandardStringView(new List<int> { viewId }, containerViewId, this));
        
			
		}

		private void RequiresRefresh()
		{
			Intent ret = new Intent();
			ret.PutExtra(KeyRefreshPos, _pos);
			AppTask.ToIntent(ret);
			SetResult(KeePass.ExitRefresh, ret);
		}
        
        protected override void OnActivityResult(int requestCode, Result resultCode, Intent data) {
			base.OnActivityResult(requestCode, resultCode, data);

            if (_exportBinaryProcessManager?.OnActivityResult(requestCode, resultCode, data) == true)
            {
                return;
            }

            AppTask appTask = null;
            if (AppTask.TryGetFromActivityResult(data, ref appTask))
            {
                
				//make sure app task is passed to calling activity.
				//the result code might be modified later.
				Intent retData = new Intent();
                AppTask = appTask;
				appTask.ToIntent(retData);
				SetResult(KeePass.ExitNormal, retData);	
			}

		
			

			if ( resultCode == KeePass.ExitRefresh || resultCode == KeePass.ExitRefreshTitle ) {
				if ( resultCode == KeePass.ExitRefreshTitle ) {
					RequiresRefresh ();
				}
				Recreate();
			}
		}


	    public class WriteBinaryTask : RunnableOnFinish
	    {
	        private readonly IKp2aApp _app;
	        private readonly ProtectedBinary _data;
	        private IOConnectionInfo _targetIoc;

	        public WriteBinaryTask(Activity activity, IKp2aApp app, OnFinish onFinish, ProtectedBinary data, IOConnectionInfo targetIoc) : base(activity, onFinish)
	        {
	            _app = app;
	            _data = data;
	            _targetIoc = targetIoc;
	        }

	        public override void Run()
	        {
	            try
	            {
	                var fileStorage = _app.GetFileStorage(_targetIoc);
	                if (fileStorage is IOfflineSwitchable)
	                {
	                    ((IOfflineSwitchable)fileStorage).IsOffline = false;
	                }
	                using (var writeTransaction = fileStorage.OpenWriteTransaction(_targetIoc, _app.GetBooleanPreference(PreferenceKey.UseFileTransactions)))
	                {
	                    Stream sOut = writeTransaction.OpenFile();

	                    byte[] byteArray = _data.ReadData();
	                    sOut.Write(byteArray, 0, byteArray.Length);

                        sOut.Close();

	                    writeTransaction.CommitWrite();

	                }
	                if (fileStorage is IOfflineSwitchable)
	                {
	                    ((IOfflineSwitchable)fileStorage).IsOffline = App.Kp2a.OfflineMode;
	                }

	                Finish(true);


	            }
	            catch (Exception ex)
	            {
	                Finish(false, Util.GetErrorMessage(ex));
	            }


	        }
	    }
        
	    private ExportBinaryProcessManager _exportBinaryProcessManager;
        private bool _showPasswordDefault;
        private bool _showTotpDefault;
        private int _historyIndex;

        protected override void OnSaveInstanceState(Bundle outState)
	    {
	        
	        
	        _exportBinaryProcessManager?.OnSaveInstanceState(outState);
	        
	        base.OnSaveInstanceState(outState);
	    }

	    public override bool OnCreateOptionsMenu(IMenu menu)
		{
			_menu = menu;
			base.OnCreateOptionsMenu(menu);

			MenuInflater inflater = MenuInflater;
			inflater.Inflate(Resource.Menu.entry, menu);

			lock (_pendingMenuOptions)
			{
				foreach (var option in _pendingMenuOptions)
					AddMenuOption(option);
				_pendingMenuOptions.Clear();
			}


			UpdateTogglePasswordMenu();

			return true;
		}

		public override bool OnPrepareOptionsMenu(IMenu menu)
		{
			Util.PrepareDonateOptionMenu(menu, this);

			// hide the move and delete options if we're viewing a history element. It is not clear 
			// what the option then means.
			foreach (var id in new List<int>{Resource.Id.menu_move, Resource.Id.menu_delete})
            {
                var menuItem = menu.FindItem(id);
                menuItem?.SetVisible(_historyIndex < 0);
            }

            return base.OnPrepareOptionsMenu(menu);
		}

		bool isPaused = false;

        protected override void OnPause()
        {
            base.OnPause();
			isPaused = true;
        }


        private void UpdateTogglePasswordMenu()
		{
			IMenuItem togglePassword = _menu.FindItem(Resource.Id.menu_toggle_pass);
			if (_showPassword.Values.All(x => x))
			{
				togglePassword.SetTitle(Resource.String.menu_hide_password);
			}
			else
			{
				togglePassword.SetTitle(Resource.String.show_password);
			}
		}

		private void SetPasswordStyle()
		{
			foreach (ProtectedTextviewGroup group in _protectedTextViews)
            {
                SetPasswordStyle(group);
            }
        }

        private void SetPasswordStyle(ProtectedTextviewGroup group)
        {
            bool showPassword = _showPassword.GetValueOrDefault(group.ProtectedField, _showPasswordDefault);
            group.VisibleProtectedField.Visibility = showPassword ? ViewStates.Visible : ViewStates.Gone;
            group.ProtectedField.Visibility = !showPassword ? ViewStates.Visible : ViewStates.Gone;

            SetPasswordTypeface(group.VisibleProtectedField);

            group.ProtectedField.InputType = InputTypes.ClassText | InputTypes.TextVariationPassword;
        }

        protected override void OnResume()
		{
			ClearCache();
			base.OnResume();
			_activityDesign.ReapplyTheme();
            isPaused = false;
            Task.Run(UpdateTotpCountdown);
        }

		public void ClearCache()
		{
			try
			{
				File dir = new File(CacheDir.Path + File.Separator + AttachmentContentProvider.AttachmentCacheSubDir);
				if (dir.IsDirectory)
				{
					IoUtil.DeleteDir(dir);
				}
			}
			catch (Exception)
			{

			}
		}

		public override bool OnOptionsItemSelected(IMenuItem item)
		{
			//check if this is a plugin action
			if ((item.Intent != null) && (item.Intent.Action == Strings.ActionEntryActionSelected))
			{
				//yes. let the plugin handle the click:
				SendBroadcast(item.Intent);
				return true;
			}

			switch (item.ItemId)
			{
				case Resource.Id.menu_donate:
					return Util.GotoDonateUrl(this);
                case Resource.Id.menu_move:
					var navMove = new NavigateToFolderAndLaunchMoveElementTask(App.Kp2a.CurrentDb, Entry.ParentGroup, new List<PwUuid>() {Entry.Uuid}, false);
                    AppTask = navMove;
					navMove.SetActivityResult(this, Result.Ok);
                    Finish();
                    return true;
				case Resource.Id.menu_delete:
                    DeleteEntry task = new DeleteEntry(this, App.Kp2a, Entry,
                        new ActionOnFinish(this, (success, message, activity) => { if (success) { RequiresRefresh(); Finish();}}));
                    task.Start();
                    break;
                case Resource.Id.menu_toggle_pass:
					if (_showPassword.Values.All(x => x))
					{
						item.SetTitle(Resource.String.show_password);
						foreach (var k in _showPassword.Keys.ToList())
						    _showPassword[k] = false;
					}
					else
					{
						item.SetTitle(Resource.String.menu_hide_password);
                        foreach (var k in _showPassword.Keys.ToList())
                            _showPassword[k] = true;
					}
					SetPasswordStyle();

					return true;

				case Resource.Id.menu_lock:
					App.Kp2a.Lock();
					return true;
				case Android.Resource.Id.Home:
					//Currently the action bar only displays the home button when we come from a previous activity.
					//So we can simply Finish. See this page for information on how to do this in more general (future?) cases:
					//http://developer.android.com/training/implementing-navigation/ancestral.html
					Finish();
					//OverridePendingTransition(Resource.Animation.anim_enter_back, Resource.Animation.anim_leave_back);

					return true;
			}


			return base.OnOptionsItemSelected(item);
		}

		
		
		internal void AddUrlToEntry(string url, Action<EntryActivity> finishAction)
		{
			PwEntry initialEntry = Entry.CloneDeep();

			PwEntry newEntry = Entry;
			newEntry.History = newEntry.History.CloneDeep();
			newEntry.CreateBackup(null);

			newEntry.Touch(true, false); // Touch *after* backup

			//if there is no URL in the entry, set that field. If it's already in use, use an additional (not existing) field
			if (!url.StartsWith(KeePass.AndroidAppScheme) && String.IsNullOrEmpty(newEntry.Strings.ReadSafe(PwDefs.UrlField)))
			{
				newEntry.Strings.Set(PwDefs.UrlField, new ProtectedString(false, url));
			}
			else
            {
                Util.SetNextFreeUrlField(newEntry, url);

                
			}

			//save the entry:

			ActionOnFinish closeOrShowError = new ActionOnFinish(this, (success, message, activity) =>
			{
				OnFinish.DisplayMessage(this, message, true);
			    finishAction((EntryActivity)activity);
			});


			RunnableOnFinish runnable = new UpdateEntry(this, App.Kp2a, initialEntry, newEntry, closeOrShowError);

			ProgressTask pt = new ProgressTask(App.Kp2a, this, runnable);
			pt.Run();

		}

        public bool GetVisibilityForProtectedView(TextView protectedView)
        {
            if (protectedView == null)
            {
                return _showPasswordDefault;
            }
            if (_showPassword.ContainsKey(protectedView) == false)
            {
                _showPassword[protectedView] = _showPasswordDefault;
            }

            return _showPassword[protectedView];
        }

		public void ToggleVisibility(TextView valueView)
		{
            
            _showPassword[valueView] = !GetVisibilityForProtectedView(valueView);
			SetPasswordStyle();
			UpdateTogglePasswordMenu();
		}


		public bool GotoUrl(string urlFieldKey)
        {
            string url = _stringViews[urlFieldKey].Text;
			if (url == null) return false;

			// Default https:// if no protocol specified
			if ((!url.Contains(":") || (url.StartsWith("www."))))
			{
				url = "https://" + url;
			}

			try
			{
				Util.GotoUrl(this, url);
			}
			catch (ActivityNotFoundException)
			{
				App.Kp2a.ShowMessage(this, Resource.String.no_url_handler,  MessageSeverity.Error);
			}
			return true;
		}

		public void AddEntryToIntent(Intent intent)
		{
			PluginHost.AddEntryToIntent(intent, App.Kp2a.LastOpenedEntry);
		}

		public void CloseAfterTaskComplete()
		{
			//before closing, wait a little to get plugin updates
			int numPlugins = new PluginDatabase(this).GetPluginsWithAcceptedScope(Strings.ScopeCurrentEntry).Count();
			var timeToWait = TimeSpan.FromMilliseconds(500*numPlugins);
			SetProgressBarIndeterminateVisibility(true);
			_timer = new Timer(obj =>
				{
					RunOnUiThread(() =>
						{
							//task is completed -> return NullTask
							Intent resIntent = new Intent();
							new NullTask().ToIntent(resIntent);
							SetResult(KeePass.ExitCloseAfterTaskComplete, resIntent);
							//close activity:
							Finish();
						}
						);
				},
				null, timeToWait, TimeSpan.FromMilliseconds(-1));
		}

		public void ShowAttachedImage(string key)
		{
			ProtectedBinary pb = Entry.Binaries.Get(key);
			System.Diagnostics.Debug.Assert(pb != null);
			if (pb == null)
				throw new ArgumentException();
			byte[] pbData = pb.ReadData();		

			Intent imageViewerIntent = new Intent(this, typeof(ImageViewActivity));
			imageViewerIntent.PutExtra("EntryId", new ElementAndDatabaseId(App.Kp2a.CurrentDb, Entry).FullId);
			imageViewerIntent.PutExtra("EntryKey", key);
			StartActivity(imageViewerIntent);
		}
	}
}