public class OAuth2PasswordGrantManager : IDisposable
    {
        private readonly string authUrl;
        private readonly string clientId;
        private readonly string clientSecret;
        private HttpClient client;

        public OAuth2PasswordGrantManager(string authUrl, string clientId, string clientSecret) :
            this(authUrl, clientId, clientSecret, new HttpClientHandler() { UseProxy = false })
        { }

        internal OAuth2PasswordGrantManager(string authUrl, string clientId, string clientSecret, HttpMessageHandler handler)
        {
            this.authUrl = authUrl;
            this.clientId = clientId;
            this.clientSecret = clientSecret;
            client = new HttpClient(handler);
        }

        public async Task<TokenResponse> GetToken(string username, string password)
        {
            //Build the payload
            Dictionary<string, string> payload = new Dictionary<string, string>
        {
            { "grant_type", "password" },
            { "username", username },
            { "password", password },
            { "client_id", clientId },
            { "client_secret", clientSecret }
        };

            return await Post(payload);
        }

        public async Task<TokenResponse> Refresh(string refreshToken)
        {
            //Build the payload
            Dictionary<string, string> payload = new Dictionary<string, string>
        {
            { "grant_type", "refresh_token" },
            { "refresh_token", refreshToken },
            { "client_id", clientId },
            { "client_secret", clientSecret }
        };

            return await Post(payload);
        }

        private async Task<TokenResponse> Post(Dictionary<string, string> payload)
        {
            HttpResponseMessage response = await client.PostAsync(authUrl, new FormUrlEncodedContent(payload));
            response.EnsureSuccessStatusCode();
            var jsonResponse = await response.Content.ReadAsStringAsync();

            return JsonUtility.FromJson<TokenResponse>(jsonResponse);
        }

        public void Dispose()
        {
            client.Dispose();
        }
    } 

    public class TokenResponse
    {
        public string AccessToken => access_token;
        public int ExpiresIn => expires_in;
        public string TokenType => token_type;
        public string RefreshToken => refresh_token;
        public string Scope => scope;

        [SerializeField]
        internal string access_token;

        [SerializeField]
        internal int expires_in;

        [SerializeField]
        internal string token_type;

        [SerializeField]
        internal string refresh_token;

        [SerializeField]
        internal string scope;
    } 

        public static Dictionary<string, string> ToDictionary(object obj)
        {
            var dictionary = new Dictionary<string, string>();

            if (obj is AuthorizationCodeRequest authorizationCodeRequest)
            {
                dictionary["response_type"] = authorizationCodeRequest.responseType;
                dictionary["client_id"] = authorizationCodeRequest.clientId;
                dictionary["redirect_uri"] = authorizationCodeRequest.redirectUri;
                dictionary["scope"] = authorizationCodeRequest.scope;
                dictionary["state"] = authorizationCodeRequest.state;
            }
            else if (obj is AccessTokenRequest accessTokenRequest)
            {
                dictionary["grant_type"] = "authorization_code";
                dictionary["code"] = accessTokenRequest.code;
                dictionary["client_id"] = accessTokenRequest.clientId;
                dictionary["client_secret"] = accessTokenRequest.clientSecret;
                dictionary["redirect_uri"] = accessTokenRequest.redirectUri;
            }
            else if (obj is RefreshTokenRequest refreshToken)
            {
                dictionary["grant_type"] = "refresh_token";
                dictionary["refresh_token"] = refreshToken.refreshToken;
                dictionary["scope"] = refreshToken.scope;
            }
            else
            {
                dictionary = JObject.FromObject(obj).ToObject<Dictionary<string, string>>();
            }

            if (dictionary != null)
            {
                // Remove empty parameters.
                var keys = dictionary.Keys.Where(key => string.IsNullOrEmpty(dictionary[key])).ToArray();
                foreach (var key in keys)
                {
                    dictionary.Remove(key);
                }
            }

            return dictionary;
        }

using Newtonsoft.Json.Linq;
using System.Collections.Generic;
using System.Linq;
using System.Runtime.Serialization;
using System.Text;
using UnityEngine;
using UnityEngine.Assertions;
using UnityEngine.UI;

public class TestDataContract : MonoBehaviour
{
    public InputField inputField;
    private void Start()
    {
        var request = new AuthorizationCodeRequest()
        {
            clientId = "john doe",
            redirectUri  = "http://localhost"
        };

        var dictionary = ToDictionary(request);

        StringBuilder builder = new StringBuilder();
        builder.AppendLine($"Dictionary Count: {dictionary.Count}");

        foreach (var kvp in dictionary)
        {
            builder.AppendLine($"Key: {kvp.Key} Value: {kvp.Value}");
        }

        inputField.text = builder.ToString();
    }

    public static Dictionary<string, string> ToDictionary(object obj)
    {
        var dictionary = JObject.FromObject(obj).ToObject<Dictionary<string, string>>();

        if (dictionary != null)
        {
            // Remove empty parameters.
            var keys = dictionary.Keys.Where(key => string.IsNullOrEmpty(dictionary[key])).ToArray();
            foreach (var key in keys)
            {
                dictionary.Remove(key);
            }
        }

        return dictionary;
    }
}

using System;
using System.Net;
using System.Threading;
using System.Threading.Tasks;
using UnityEngine;

namespace Cdm.Authentication.Browser
{
    /// <summary>
    /// OAuth 2.0 verification browser that runs a local server and waits for a call with
    /// the authorization verification code.
    /// </summary>
    public class StandaloneBrowser : IBrowser
    {
        private TaskCompletionSource<BrowserResult> _taskCompletionSource;

        /// <summary>
        /// Gets or sets the close page response. This HTML response is shown to the user after redirection is done.
        /// </summary>
        public string closePageResponse { get; set; } = 
            "<html><body><b>DONE!</b><br>(You can close this tab/window now)</body></html>";

        public async Task<BrowserResult> StartAsync(
            string loginUrl, string redirectUrl, CancellationToken cancellationToken = default)
        {
            _taskCompletionSource = new TaskCompletionSource<BrowserResult>();

            cancellationToken.Register(() =>
            {
                _taskCompletionSource?.TrySetCanceled();
            });

            using var httpListener = new HttpListener();
            
            try
            {
                char forwardSlash = '/';
                if (!redirectUrl.EndsWith(forwardSlash))
                {
                    redirectUrl += forwardSlash;
                }
                
                httpListener.Prefixes.Add(redirectUrl);
                httpListener.Start();
                httpListener.BeginGetContext(IncomingHttpRequest, httpListener);

                Application.OpenURL(loginUrl);
                
                return await _taskCompletionSource.Task;
            }
            finally
            {
                httpListener.Stop();
            }
        }

        private void IncomingHttpRequest(IAsyncResult result)
        {
            var httpListener = (HttpListener)result.AsyncState;
            var httpContext = httpListener.EndGetContext(result);
            var httpRequest = httpContext.Request;
            
            // Build a response to send an "ok" back to the browser for the user to see.
            var httpResponse = httpContext.Response;
            var buffer = System.Text.Encoding.UTF8.GetBytes(closePageResponse);

            // Send the output to the client browser.
            httpResponse.ContentLength64 = buffer.Length;
            var output = httpResponse.OutputStream;
            output.Write(buffer, 0, buffer.Length);
            output.Close();

            _taskCompletionSource.SetResult(
                new BrowserResult(BrowserStatus.Success, httpRequest.Url.ToString()));
        }
    }
}

        public string GetAuthorizationUrl()
        {
            // Generate new state.
            state = Guid.NewGuid().ToString("D");

            codeVerifier = GenerateRandomDataBase64url(32);
            string codeChallenge = Base64UrlEncodeNoPadding(Sha256Ascii(codeVerifier));
            const string codeChallengeMethod = "S256";

            var parameters = JsonHelper.ToDictionary(new AuthorizationCodeRequest()
            {
                clientId = configuration.clientId,
                redirectUri = configuration.redirectUri,
                scope = configuration.scope,
                state = state,
                codeChallenge = codeChallenge,
                codeChallengeMethod = codeChallengeMethod
            });

            return UrlBuilder.New(authorizationUrl).SetQueryParameters(parameters).ToString();
        }

public virtual async Task<AccessTokenResponse> ExchangeCodeForAccessTokenAsync(string redirectUrl,
            CancellationToken cancellationToken = default)
        {
            var authorizationResponseUri = new Uri(redirectUrl);
            var query = HttpUtility.ParseQueryString(authorizationResponseUri.Query);

            // Is there any error?
            if (JsonHelper.TryGetFromNameValueCollection<AuthorizationCodeRequestError>(query, out var authorizationError))
                throw new AuthorizationCodeRequestException(authorizationError);

            if (!JsonHelper.TryGetFromNameValueCollection<AuthorizationCodeResponse>(query, out var authorizationResponse))
                throw new Exception("Authorization code could not get.");

            // Validate authorization response state.
            if (!string.IsNullOrEmpty(state) && state != authorizationResponse.state)
                throw new SecurityException($"Invalid state got: {authorizationResponse.state}");

            var parameters = JsonHelper.ToDictionary(new AccessTokenRequest()
            {
                code = authorizationResponse.code,
                clientId = configuration.clientId,
                clientSecret = configuration.clientSecret,
                redirectUri = configuration.redirectUri,
                codeVerifier = codeVerifier
            });

            UnityEngine.Debug.Assert(parameters != null);

            accessTokenResponse = 
                await GetAccessTokenInternalAsync(new FormUrlEncodedContent(parameters), cancellationToken);
            return accessTokenResponse;
        }

        public string GetAuthorizationUrl()
        {
            // Generate new state.
            state = Guid.NewGuid().ToString("D");

            codeVerifier = GenerateRandomDataBase64url(32);
            string codeChallenge = Base64UrlEncodeNoPadding(Sha256Ascii(codeVerifier));
            const string codeChallengeMethod = "S256";

            var parameters = GetAuthorizationUrlParameters ();


            return UrlBuilder.New(authorizationUrl).SetQueryParameters(parameters).ToString();
        }

protected virtual Dictionary<string, string> GetAuthorizationUrlParameters ()
{
return JsonHelper.ToDictionary(new AuthorizationCodeRequest()
            {
                clientId = configuration.clientId,
                redirectUri = configuration.redirectUri,
                scope = configuration.scope,
                state = state,
                codeChallenge = codeChallenge,
                codeChallengeMethod = codeChallengeMethod
            });
}