using System.IdentityModel.Tokens.Jwt;
using System.Security.Claims;
using System.Security.Cryptography;
using System.Text;
using Microsoft.IdentityModel.Tokens;

namespace FoodsharingSiegen.Shared.Helper
{
    /// <summary>
    /// The auth helper class (a. beging, 04.04.2022)
    /// </summary>
    public static class AuthHelper
    {
        #region Public Method CreateToken

        /// <summary>
        /// Creates the token using the specified user id (a. beging, 04.04.2022)
        /// </summary>
        /// <param name="userId">The user id</param>
        /// <returns>The string</returns>
        public static string CreateToken(Guid userId)
        {
            var tokenHandler = new JwtSecurityTokenHandler();
            var tokenDescriptor = new SecurityTokenDescriptor
            {
                Subject = new ClaimsIdentity(new[]
                {
                    new Claim(ClaimTypes.NameIdentifier, userId.ToString()),
                    new Claim("CanDoShit","yes")
                }),
                Expires = DateTime.UtcNow.AddDays(30),
                Issuer = Issuer,
                Audience = Audience,
                SigningCredentials = new SigningCredentials(GetSigningKey(), SecurityAlgorithms.HmacSha256Signature)
            };
            
            var token = tokenHandler.CreateToken(tokenDescriptor);
            return tokenHandler.WriteToken(token);
        }

        #endregion

        #region Public Method Decrypt

        /// <summary>
        /// Decrypts the crypted text (a. beging, 04.04.2022)
        /// </summary>
        /// <param name="cryptedText">The crypted text</param>
        /// <returns>The string</returns>
        public static string Decrypt(string cryptedText)
        {
            CreateAlgorithm(out var tripleDes);
            
            var toEncryptArray = Convert.FromBase64String(cryptedText);

            

            var cTransform = tripleDes.CreateDecryptor();
            var resultArray = cTransform.TransformFinalBlock(toEncryptArray, 0, toEncryptArray.Length);

            tripleDes.Clear();

            return Encoding.UTF8.GetString(resultArray);
        }

        #endregion

        #region Public Method Encrypt

        /// <summary>
        /// Encrypts the plain text (a. beging, 04.04.2022)
        /// </summary>
        /// <param name="plainText">The plain text</param>
        /// <returns>The string</returns>
        public static string Encrypt(string plainText)
        {
            CreateAlgorithm(out var tripleDes);
            
            var toEncryptArray = Encoding.UTF8.GetBytes(plainText );
            
            
 
            var cTransform = tripleDes.CreateEncryptor();

            var resultArray = cTransform.TransformFinalBlock(toEncryptArray, 0, toEncryptArray.Length);

            tripleDes.Clear();

            return Convert.ToBase64String(resultArray, 0, resultArray.Length);
        }

        #endregion

        #region Public Method ValidateToken

        /// <summary>
        /// Validates the token using the specified token (a. beging, 04.04.2022)
        /// </summary>
        /// <param name="token">The token</param>
        /// <returns>A task containing the bool</returns>
        public static async Task<bool> ValidateToken(string? token)
        {
            try
            {
                var tokenHandler = new JwtSecurityTokenHandler();
                var result = await tokenHandler.ValidateTokenAsync(token, new TokenValidationParameters
                {
                    ValidateIssuerSigningKey = true,
                    IssuerSigningKey = GetSigningKey(),

                    ValidateAudience = true,
                    ValidAudience = Audience,

                    ValidateIssuer = true,
                    ValidIssuer = Issuer
                });

                return result.IsValid;
            }
            catch (Exception e)
            {
                return false;
            }
        }

        #endregion

        #region Private Method CreateAlgorithm

        /// <summary>
        /// Creates the algorithm using the specified triple des (a. beging, 04.04.2022)
        /// </summary>
        /// <param name="tripleDes">The triple des</param>
        private static void CreateAlgorithm(out TripleDES tripleDes)
        {
            var md5 = MD5.Create();
            var keyArray = md5.ComputeHash(Encoding.UTF8.GetBytes(SigningKey));
            md5.Clear();
            
            tripleDes = TripleDES.Create();
            tripleDes.Key = keyArray;
            tripleDes.Mode = CipherMode.ECB;
            tripleDes.Padding = PaddingMode.PKCS7;
        }

        #endregion

        #region Private Method GetSigningKey

        /// <summary>
        /// Gets the signing key (a. beging, 04.04.2022)
        /// </summary>
        /// <returns>The security key</returns>
        private static SecurityKey GetSigningKey() => new SymmetricSecurityKey(Encoding.ASCII.GetBytes(SigningKey));

        #endregion

        /// <summary>
        /// The signing key
        /// </summary>
        private const string SigningKey = "2uasw2§$%1nd47n9s43&%Zs3529s23&/%AW";

        /// <summary>
        /// The audience
        /// </summary>
        private const string Audience = "FS-Siegen";

        /// <summary>
        /// The issuer
        /// </summary>
        private const string Issuer = "FS-Siegen";
    }
}