public VaultCredential Get(string domain)
 {
     var vault = new PasswordVault();
     var credential = vault.FindAllByResource(domain).FirstOrDefault();
     credential.RetrievePassword();
     return new VaultCredential(credential.Resource, credential.UserName, credential.Password);
 }

 public async Task<TunesUser> VerifyUserCredentials()
 {
     TunesUser tunesUser = null;
     Windows.Security.Credentials.PasswordVault vault = new Windows.Security.Credentials.PasswordVault();
     try
     {
         await Task.Run(() =>
         {
             var userName = (string)Windows.Storage.ApplicationData.Current.RoamingSettings.Values["username"];
             if (!string.IsNullOrEmpty(userName))
             {
                 var passwordCredential = vault.Retrieve(PasswordVaultResourceName, userName);
                 if (passwordCredential != null)
                 {
                     tunesUser = this.User = new TunesUser
                     {
                         UserName = userName,
                         Password = vault.Retrieve(PasswordVaultResourceName, passwordCredential.UserName).Password
                     };
                 }
             }
         });
     }
     catch { }
     return tunesUser;
 }

        public string GetSecretFor(string name)
        {
            var vault = new PasswordVault();
            try
            {
                if (vault.RetrieveAll().Count == 0)
                {
                    return "";
                }

                var credentialList = vault.FindAllByResource(_key);

                return credentialList
                    .Where(x => x.UserName == name)
                    .Select(x =>
                    {
                        x.RetrievePassword();
                        return x.Password;
                    })
                    .FirstOrDefault();
            }
            catch (Exception)
            {
                // Exception is thrown if the vault isn't properly initialised
                return "";
            }
        }

        private void Save_Click(object sender, RoutedEventArgs e)
        {
            String result = "";
            if (InputResourceValue.Text == "" || InputUserNameValue.Text == "" || InputPasswordValue.Password == "")
            {
                rootPage.NotifyUser("Inputs are missing. Resource, User name and Password are required", NotifyType.ErrorMessage);
            }
            else
            {
                try
                {
                    //Add a credential to PasswordVault by supplying resource, username, and password
                    PasswordVault vault = new PasswordVault();
                    PasswordCredential cred = new PasswordCredential(InputResourceValue.Text, InputUserNameValue.Text, InputPasswordValue.Password);
                    vault.Add(cred);

                    //Output credential added to debug spew
                    rootPage.NotifyUser("Credential saved successfully. " + "Resource: " + cred.Resource.ToString() + " Username: " + cred.UserName.ToString() + " Password: " + cred.Password.ToString() + ".", NotifyType.StatusMessage);
                }
                catch (Exception Error) // No stored credentials, so none to delete
                {
                    rootPage.NotifyUser(Error.Message, NotifyType.ErrorMessage);
                }
            }

        }

        // Define a method that performs the authentication process
        // using a Facebook sign-in. 
        //private async System.Threading.Tasks.Task AuthenticateAsync()
        //{
        //    while (user == null)
        //    {
        //        string message;
        //        try
        //        {
        //            // Change 'MobileService' to the name of your MobileServiceClient instance.
        //            // Sign-in using Facebook authentication.
        //            user = await App.MobileService
        //                .LoginAsync(MobileServiceAuthenticationProvider.WindowsAzureActiveDirectory);
        //            message =
        //                string.Format("You are now signed in - {0}", user.UserId);
        //        }
        //        catch (InvalidOperationException)
        //        {
        //            message = "You must log in. Login Required";
        //        }

        //        var dialog = new MessageDialog(message);
        //        dialog.Commands.Add(new UICommand("OK"));
        //        await dialog.ShowAsync();
        //    }
        //}

        public override async void LogoutAsync()
        {
            App.MobileService.Logout();

            string message;
            // This sample uses the Facebook provider.
            var provider = "AAD";

            // Use the PasswordVault to securely store and access credentials.
            PasswordVault vault = new PasswordVault();
            PasswordCredential credential = null;
            try
            {
                // Try to get an existing credential from the vault.
                credential = vault.FindAllByResource(provider).FirstOrDefault();
                vault.Remove(credential);
            }
            catch (Exception)
            {
                // When there is no matching resource an error occurs, which we ignore.
            }
            message = string.Format("You are now logged out!");
            var dialog = new MessageDialog(message);
            dialog.Commands.Add(new UICommand("OK"));
            await dialog.ShowAsync();
            IsLoggedIn = false;

        }

        //Use your consumerKey and ConsumerSecret


        private async void ButtonBase_OnClick(object sender, RoutedEventArgs e)
        {
            if (string.IsNullOrEmpty(pinText.Text))
            {
                var msgDialog = new MessageDialog("Please Enter the pin showed below");
                await msgDialog.ShowAsync();
            }
            else
            {
                var pinCode = pinText.Text.Trim();
                var userCredentials = AuthFlow.CreateCredentialsFromVerifierCode(pinCode, authenticationContext);
                Auth.SetCredentials(userCredentials);

                var vault = new PasswordVault();
                vault.Add(new PasswordCredential("Friend", "TwitterAccessToken", userCredentials.AccessToken));
                vault.Add(new PasswordCredential("Friend", "TwitterAccessTokenSecret", userCredentials.AccessTokenSecret));
                var localSettings = ApplicationData.Current.LocalSettings;
                var frame = Window.Current.Content as Frame;

                if (localSettings.Values.ContainsKey("FirstTimeRunComplete"))
                {
                    frame?.Navigate(typeof(MainPage));
                }
                else
                {
                    frame?.Navigate(typeof(FirstTimeTutorial));
                }
            }
        }

		public void CheckPreviousAuthentication()
		{
			PasswordCredential credential = null;

			var settings = ApplicationData.Current.RoamingSettings;

			var lastUsedProvider = settings.Values[LastUsedProvider] as string;
			if (lastUsedProvider != null)
			{
				try
				{
					var passwordVault = new PasswordVault();

					// Try to get an existing credential from the vault.
					credential = passwordVault.FindAllByResource(lastUsedProvider).FirstOrDefault();
				}
				catch (Exception)
				{
					// When there is no matching resource an error occurs, which we ignore.
				}
			}

			if (credential != null)
			{
				this.MobileService.User = new MobileServiceUser(credential.UserName);
				credential.RetrievePassword();
				this.MobileService.User.MobileServiceAuthenticationToken = credential.Password;

				this.OnNavigate?.Invoke(Tasks, null);
			}
		}

		public void Save(string userName, string password)
		{
			Clear();

			PasswordVault vault = new PasswordVault();
			vault.Add(new PasswordCredential(AppResourceName, userName, password));
		}

        public static void SaveCredentialToLocker(MobileCredentials mobileCredentials)
        {
            // clean up
            var vault = new PasswordVault();
            try
            {
                var credentialList = vault.FindAllByResource(ResourceName);
                foreach (var passwordCredential in credentialList)
                {
                    vault.Remove(passwordCredential);
                }
            }
            // ReSharper disable once EmptyGeneralCatchClause
            catch (Exception)
            {
            }

            var credential = new PasswordCredential
            {
                Resource = ResourceName,
                UserName = mobileCredentials.MobileNumber,
                Password = mobileCredentials.Password
            };

            vault.Add(credential);
        }

        public async Task<bool> login()
        {
            Frame rootFrame = Window.Current.Content as Frame;

            PasswordVault vault = new PasswordVault();
            PasswordCredential cred = null;
            try
            {
                if (vault.FindAllByResource("email").ToString() != null)
                {
                    cred = vault.FindAllByResource("email")[0];
                    cred.RetrievePassword();
                    return await this.LoginWithEmail(cred.UserName.ToString(), cred.Password.ToString());
                }
            }
            catch (Exception)
            { }
            try
            {
                if (vault.FindAllByResource("facebook").ToString() != null)
                {
                    cred = vault.FindAllByResource("facebook")[0];
                    cred.RetrievePassword();
                    return await LoginWithFacebook();
                }
            }
            catch (Exception)
            {
                return false;
            }
            return false;

        }

        public async static void LoadSettings()
        {
            //PasswordCredential cred = new PasswordCredential("redditMetro", Settings["UserName"].ToString(), Settings["Password"].ToString());
            try
            {
                PasswordVault = new PasswordVault();
            }
            catch (Exception)
            {
                // wtf is going on here!
            }

            var localSettings = Windows.Storage.ApplicationData.Current.LocalSettings;
            var container = localSettings.CreateContainer(CONTAINER_NAME, ApplicationDataCreateDisposition.Always);
            Settings = container.Values;
            if (!Settings.ContainsKey("UserName"))
                Settings.Add("UserName", "");
            if (!Settings.ContainsKey("SavePassword"))
                Settings.Add("SavePassword", false);

            if (!String.IsNullOrEmpty(Settings["UserName"].ToString()) && (bool)Settings["SavePassword"])
            {
                LoginReddit();
            }
            else
            {
                isLoggedIn = false;
            }
        }

        public static void SaveCredential(string userName, string password)
        {
            PasswordVault passwordVault = new PasswordVault();
            PasswordCredential passwordCredential = new PasswordCredential(RESOURCE, userName, password);

            passwordVault.Add(passwordCredential);
        }

        /// <summary>
        /// Attempt to sign in to GitHub using the credentials supplied. 
        /// </summary>
        /// <param name="username">GitHub username</param>
        /// <param name="password">GitHub password</param>
        /// <param name="cached">Whether these credentials came from local storage</param>
        /// <returns>true if successful, false otherwise</returns>
        public async Task<string> Login(string username, string password, bool cached = false)
        {
            client.Credentials = new Credentials(username, password);
            try
            {
                //hacky way of determining whether the creds are correct
                await client.GitDatabase.Reference.Get("dhbrett", "Graffiti", "heads/master");
                //we haven't thrown so all good
                SignedIn = true;

                //these are new credentials, save them
                if (!cached)
                {
                    var pv = new PasswordVault();
                    pv.Add(new PasswordCredential { Resource = RESOURCE, UserName = username, Password = password });

                    localSettings.Values[USERNAME] = username;
                }

                return "pass";
            }
            catch(Exception e)
            {
                if (e.Message.Contains("two-factor"))
                {
                    return "tfa";
                }
                else if (cached)
                {
                    var pv = new PasswordVault();
                    pv.Remove(pv.Retrieve(RESOURCE, username));
                }
                return "fail";
            }
        }

 private void SecureSavePassword(string username, string password)
 {
     // 資格情報をCredential Lockerへ保存します
     var vault = new PasswordVault();
     var credential = new PasswordCredential(RESOURCE, username, password);
     vault.Add(credential);
 }

        protected override void OnNavigatedTo(NavigationEventArgs e)
        {
            base.OnNavigatedTo(e);
            PasswordVault vault = new PasswordVault();

            try
            {
                var credentials = vault.FindAllByResource("creds");
                if (credentials.Any())
                {
                    var credential = credentials.First();
                    Username.Text = credential.UserName;
                    credential.RetrievePassword();
                    Password.Password = credential.Password;
                    Login(null, null);
                }
            }
            catch
            {
                // no credentials present, just ignore
            }

            if (e.Parameter != null)
            {
                Username.Text = e.Parameter.ToString();
            }
        }

        /// <summary>
        /// Starts the authentication process.
        /// </summary>
        /// <param name="provider">The provider to authenticate with.</param>
        public async Task AuthenticateAsync(MobileServiceAuthenticationProvider provider)
        {
            try
            {
                var vault = new PasswordVault();

                // Login with the identity provider.
                var user = await AzureAppService.Current
                    .LoginAsync(provider);

                // Create and store the user credentials.
                var credential = new PasswordCredential(provider.ToString(),
                    user.UserId, user.MobileServiceAuthenticationToken);

                vault.Add(credential);
            }
            catch (InvalidOperationException invalidOperationException)
            {
                if (invalidOperationException.Message
                    .Contains("Authentication was cancelled by the user."))
                {
                    throw new AuthenticationCanceledException("Authentication canceled by user",
                        invalidOperationException);
                }

                throw new AuthenticationException("Authentication failed", invalidOperationException);
            }
            catch (Exception e)
            {
                throw new AuthenticationException("Authentication failed", e);
            }
        }

        public static bool TryGetToken(string resourceName, out TokenCredential tokenCredential)
        {
            var vault = new PasswordVault();
            tokenCredential = null;

            try
            {
                var creds = vault.FindAllByResource(resourceName);
                if (creds != null)
                {
                    var credential = creds.First();
                    credential.RetrievePassword();
                    var json = JsonObject.Parse(credential.Password);

                    tokenCredential = new TokenCredential
                    {
                        AccessToken = json["access_token"].GetString(),
                        TokenType = json["token_type"].GetString(),
                    };

                    double expiresIn = json["expires_in"].GetNumber();
                    var dt = ((long)expiresIn).ToDateTimeFromEpoch();

                    tokenCredential.Expires = dt;

                    return true;
                }
            }
            catch
            { }

            return false;
        }

        // Log the user in with specified provider (Microsoft Account or Facebook)
        private async Task AuthenticateAsync()
        {
            // Use the PasswordVault to securely store and access credentials.
            PasswordVault vault = new PasswordVault();
            PasswordCredential credential = null;

            try
            {
                // Try to get an existing credential from the vault.
                credential = vault.FindAllByResource(provider).FirstOrDefault();
            }
            catch (Exception)
            {
                // do nothing
            }

            if (credential != null)
            {
                // Create a user from the stored credentials.
                user = new MobileServiceUser(credential.UserName);
                credential.RetrievePassword();
                user.MobileServiceAuthenticationToken = credential.Password;

                // Set the user from the stored credentials.
                App.MobileService.CurrentUser = user;

                try
                {
                    // Try to return an item now to determine if the cached credential has expired.
                    await App.MobileService.GetTable<Event>().Take(1).ToListAsync();
                }
                catch (MobileServiceInvalidOperationException ex)
                {
                    if (ex.Response.StatusCode == System.Net.HttpStatusCode.Unauthorized)
                    {
                        // Remove the credential with the expired token.
                        vault.Remove(credential);
                        credential = null;
                    }
                }
            }
            else
            {
                try
                {
                    // Login with the identity provider.
                    user = await App.MobileService.LoginAsync(provider);

                    // Create and store the user credentials.
                    credential = new PasswordCredential(provider,
                        user.UserId, user.MobileServiceAuthenticationToken);
                    vault.Add(credential);
                }
                catch (MobileServiceInvalidOperationException ex)
                {
                    Debug.WriteLine(ex.StackTrace);
                }
            }
        }

        /// <summary>
        /// Adds a credential to the credential locker.
        /// </summary>
        /// <param name="credential">The credential to be added.</param>
        public static void AddCredential(Credential credential)
        {
            if (credential == null || string.IsNullOrEmpty(credential.ServiceUri))
                return;

            var serverInfo = IdentityManager.Current.FindServerInfo(credential.ServiceUri);
            var host = serverInfo == null ? credential.ServiceUri : serverInfo.ServerUri;

            string passwordValue = null;  // value stored as password in the password locker
            string userName = null;
            var oAuthTokenCredential = credential as OAuthTokenCredential;
            var arcGISTokenCredential = credential as ArcGISTokenCredential;
            var arcGISNetworkCredential = credential as ArcGISNetworkCredential;
            if (oAuthTokenCredential != null)
            {
                userName = oAuthTokenCredential.UserName;
                if (!string.IsNullOrEmpty(oAuthTokenCredential.OAuthRefreshToken)) // refreshable OAuth token --> we store it so we'll be able to generate a new token from it
                    passwordValue = OAuthRefreshTokenPrefix + oAuthTokenCredential.OAuthRefreshToken;
                else if (!string.IsNullOrEmpty(oAuthTokenCredential.Token))
                    passwordValue = OAuthAccessTokenPrefix + oAuthTokenCredential.Token;
            }
            else if (arcGISTokenCredential != null)
            {
                userName = arcGISTokenCredential.UserName;
                if (!string.IsNullOrEmpty(userName) && !string.IsNullOrEmpty(arcGISTokenCredential.Password)) // Token generated from an username/password --> store the password
                    passwordValue = PasswordPrefix + arcGISTokenCredential.Password;
            }
            else if (arcGISNetworkCredential != null)
            {
                // networkcredential: store the password
                if (arcGISNetworkCredential.Credentials != null)
                {
                    NetworkCredential networkCredential = arcGISNetworkCredential.Credentials.GetCredential(new Uri(host), "");
                    if (networkCredential != null && !string.IsNullOrEmpty(networkCredential.Password))
                    {
                        userName = networkCredential.UserName;
                        if (!string.IsNullOrEmpty(networkCredential.Domain))
                            userName = networkCredential.Domain + "\\" + userName;
                        passwordValue = NetworkCredentialPasswordPrefix + networkCredential.Password;
                    }
                }
            }

            // Store the value in the password locker
            if (passwordValue != null)
            {
                var passwordVault = new PasswordVault();
                var resource = ResourcePrefix + host;
                // remove previous resource stored for the same host
                try // FindAllByResource throws an exception when no pc are stored
                {
                    foreach (PasswordCredential pc in passwordVault.FindAllByResource(resource))
                        passwordVault.Remove(pc);
                }
                catch {}

                passwordVault.Add(new PasswordCredential(resource, userName, passwordValue));
            }
        }

        private dynamic SecureLoadPassword(string username)
        {
            // Credential Lockerから資格情報を取得する
            PasswordVault vault = new PasswordVault();
            PasswordCredential credential = vault.Retrieve(RESOURCE, username);

            return new { UserName = credential.UserName, Password = credential.Password };
        }