Untitled

using DAL;
using DAL.UnitOfWork;
using Serilog;
using System;
using System.Security.Cryptography;
using System.Security.Cryptography.X509Certificates;
using System.Text;
using System.Text.RegularExpressions;

namespace mPaymentsAPI.Services
{
    public partial class GeneralServices : IGeneralServices
    {
        public IConfiguration _Configuration;
        public ICachingProvider _CachingProvider;

        public GeneralServices(IConfiguration configuration, ICachingProvider cachingProvider)
        {
            _Configuration = configuration;
            _CachingProvider = cachingProvider;
        }

        public dynamic ParseErrors(string Message)
        {
            List<string> LstErrors = new List<string>();
            foreach (string error in Message.Split(','))
            {
                LstErrors.Add(error);
            }
            return new { errors = LstErrors };
        }

        public string SignMessage(string strMessage)
        {
            try
            {
                bool bSignatureEnable = _Configuration.GetValue<bool>("Certificates:SignatureEnable");
                string sCertificateSerial = _Configuration.GetValue<string>("Certificates:CertificateSerial");
                string sMessage = string.Empty;
                if (bSignatureEnable)
                {
                    string ConnecotrCertificateSerialNumber = sCertificateSerial;
                    if (!string.IsNullOrEmpty(ConnecotrCertificateSerialNumber))
                    {
                        RSACryptoServiceProvider rsaCryptoServiceProvider = new RSACryptoServiceProvider();
                        rsaCryptoServiceProvider.FromXmlString(GetCertificates(ConnecotrCertificateSerialNumber).PublicKey.Key.ToXmlString(true));
                        RSACryptoServiceProvider.UseMachineKeyStore = true;
                        rsaCryptoServiceProvider.ExportParameters(false);
                        rsaCryptoServiceProvider.KeySize = 2048;
                        sMessage = Convert.ToBase64String(rsaCryptoServiceProvider.SignData(Encoding.Unicode.GetBytes(strMessage), CryptoConfig.MapNameToOID("SHA256")));
                    }
                }
                return sMessage;
            }
            catch (Exception ex)
            {
                throw ex;
            }
        }

        public X509Certificate2 GetCertificates(string certificateSerialNumber)
        {
            X509Store store = null;
            try
            {
                if (certificateSerialNumber == null)
                {
                    throw new ArgumentNullException("certificateSerialNumber");
                }
                store = new X509Store(StoreName.My, StoreLocation.LocalMachine);
                store.Open(OpenFlags.ReadOnly);
                X509Certificate2Collection foundCertificates = store.Certificates;
                foreach (X509Certificate2 foundCertificate in foundCertificates)
                {
                    if (string.Compare(foundCertificate.SerialNumber, certificateSerialNumber.Replace(" ", string.Empty), true) == 0)
                    {
                        X509Certificate2 selectedCertificate = foundCertificate;
                        store.Close();
                        return selectedCertificate;
                    }
                }
                throw new Exception("Certificate not found");
            }
            finally
            {
                if (store != null)
                {
                    store.Close();
                }
            }
        }

        public bool VerifyMessageSignature(string Message, string signature)
        {
            try
            {
                bool bSignatureEnable = _Configuration.GetValue<bool>("Certificates:SignatureEnable");
                string sCertificateSerial = _Configuration.GetValue<string>("Certificates:CertificateSerial");

                bool matched = true;
                if (bSignatureEnable)
                {
                    string sChannelCertificateSerialNumber = sCertificateSerial;
                    if (!string.IsNullOrEmpty(sChannelCertificateSerialNumber))
                    {
                        RSACryptoServiceProvider rsaCryptoServiceProvider = (RSACryptoServiceProvider)GetCertificates(sChannelCertificateSerialNumber).PublicKey.Key;
                        RSACryptoServiceProvider.UseMachineKeyStore = true;
                        rsaCryptoServiceProvider.ExportParameters(false);
                        rsaCryptoServiceProvider.KeySize = 2048;
                        matched = rsaCryptoServiceProvider.VerifyData(Encoding.Unicode.GetBytes(Message),
                            CryptoConfig.MapNameToOID("SHA256"), Convert.FromBase64String(signature));
                    }
                }
                return matched;
            }
            catch (Exception ex)
            {
                dynamic Res = this.ParseErrors(ex.Message);
                return false;//StatusCodes.Status500InternalServerError(StatusCodes.Status500InternalServerError, Res);

            }

        }


        /************************************************************************************************************/


        public async Task<mPaymentResponse<T>> SetErrorMessage<T>(string BankCode, string ErrorCode, bool IsError = true,string eMsg="", string aMsg = "")
        {
            if (string.IsNullOrWhiteSpace(BankCode))
                BankCode = _Configuration.GetValue<string>("PortalAdmin:DefaultBank");
            
            mPaymentResponse<T> mPaymentResponse = new();
            int Max = 10000;
            Log.Information("Error Message {0} >> {1}  ", ErrorCode, IsError);
            var objErrorMessages = _CachingProvider.GetUserMessages().Result.FirstOrDefault(a => a.code.ToLower() == ErrorCode.ToLower() && a.bankCode == BankCode);
            if (objErrorMessages == null)
            {
                mPaymentResponse.result.errorCode = 999;
                mPaymentResponse.result.errorEDesc = string.IsNullOrWhiteSpace(eMsg) ? SplitMsg(string.IsNullOrWhiteSpace(ErrorCode) ? "General Error " : ErrorCode) : eMsg;
                mPaymentResponse.result.errorADesc = string.IsNullOrWhiteSpace(aMsg) ? "خطأ عام " : aMsg;
                mPaymentResponse.result.errorDetails = "General Error >> " + SplitMsg(string.IsNullOrWhiteSpace(ErrorCode) ? "General Error " : ErrorCode);
            }
            else
            {
                mPaymentResponse.result.errorCode = objErrorMessages.errorCode.ToInteger();
                mPaymentResponse.result.errorEDesc = objErrorMessages.edesc;
                mPaymentResponse.result.errorADesc = objErrorMessages.adesc;
            }
            if (!IsError)
                mPaymentResponse.result.errorCode = 0;
            return mPaymentResponse;
             
        }
		 
		public string SplitMsg(string input)//Split uppercase letter and inserts a space between them
        {
            if (string.IsNullOrWhiteSpace(input))
                return "";
            string output = Regex.Replace(input, "([a-z])([A-Z])", "$1 $2");
            return output;

        }
        public async Task<mPaymentResponse<T>> SetErrorMessageWithReplace<T>(string BankCode, string ErrorCode, string oldChar, string newChar, bool IsError = true)
        {
            mPaymentResponse<T> mPaymentResponse = new();
            int Max = 10000;
            Log.Information("Error Message {0} >> {1} >> {2} >> {3} ", ErrorCode, oldChar, newChar, IsError);
            var objErrorMessages = _CachingProvider.GetUserMessages().Result.FirstOrDefault(a => a.code.ToLower() == ErrorCode.ToLower() && a.bankCode == BankCode);
            if (objErrorMessages == null)
            {
                mPaymentResponse.result.errorCode = 999;
                mPaymentResponse.result.errorEDesc = "General Error";
                mPaymentResponse.result.errorADesc = "خطأ عام";
            }
            else
            {
                mPaymentResponse.result.errorCode = objErrorMessages.errorCode.ToInteger();
                mPaymentResponse.result.errorEDesc = objErrorMessages.edesc.Replace(oldChar, newChar);
                mPaymentResponse.result.errorADesc = objErrorMessages.adesc.Replace(oldChar, newChar);
            }
            if (!IsError)
                mPaymentResponse.result.errorCode = 0;

            return mPaymentResponse;
             
        }

        public async Task<mPaymentResponse<T>> SetConnectorErrorMessage<T>(string ErrorCode, string ErrorEDesc, string ErrorADesc, string errorDetails = "")
        {
            mPaymentResponse<T> mPaymentResponse = new();
            mPaymentResponse.result.errorCode = ErrorCode.ToInteger();
            mPaymentResponse.result.errorEDesc = ErrorEDesc;
            mPaymentResponse.result.errorADesc = ErrorADesc;
            mPaymentResponse.result.errorDetails = errorDetails;
            return mPaymentResponse;
        }



        public Result GetErroMessage(string ErrorCode)
        {
            Result oresult = new();  
            var objErrorMessages = _CachingProvider.GetUserMessages().Result.FirstOrDefault(a => a.code.ToLower() == ErrorCode.ToLower()); 
            if (objErrorMessages == null)
            {
                oresult.errorCode = 999;
                oresult.errorEDesc = "General Error";
                oresult.errorADesc = "خطأ عام";
            }
            else
            {
                oresult.errorCode = objErrorMessages.errorCode.ToInteger();
                oresult.errorEDesc = objErrorMessages.edesc;
                oresult.errorADesc = objErrorMessages.adesc;
            }

            return oresult;
        }




        public string StringfyHttpHeader(IHeaderDictionary header)
        {
            var builder = new StringBuilder(Environment.NewLine);
            foreach (var key in header.Keys)
            {
                if (key != "Authorization")
                {
                    builder.AppendLine($"{key}: {header[key]}");
                }
                else
                {
                    builder.AppendLine($"{key}: Bearer XXXXXXXXXXXXXXXXXXXX");
                }
            }
            return builder.ToString();
        }



    }
}