using ElectronicSignature.Certification;
using Org.BouncyCastle.Crypto.Parameters;
using Org.BouncyCastle.Security;
using System.Security.Cryptography.X509Certificates;
using System.Security.Cryptography;
using System.Security;
using System.Text;
using Org.BouncyCastle.Cms;
using Org.BouncyCastle.Crypto;
using Org.BouncyCastle.X509;

public static class Engine
{
	private static readonly string keyPairPath = @"G:\tests\rsaKeyPair.pem";
	private static readonly string privateKeyPath = @"G:\tests\rsaPrivateKey.pem";
	private static readonly string publicKeyPath = @"G:\tests\rsaPublicKey.pem";
	private static readonly string csrPath = @"G:\tests\rsaCSR.pem";
	private static readonly string signedCertPath = @"G:\tests\rsaSignedCert.pem";
	private static readonly string selfSignedCertPath = @"G:\tests\selfSignedCert.pem";
	private static readonly string privateCertPath = @"G:\tests\privateCert.pfx";
	private static readonly string privateCertPass = "1234";

	/// <summary>
	/// Эта тестовая функция может генерировать пару открытых и закрытых ключей с использованием алгоритма шифрования RSA.
	/// Это широко используемый алгоритм для генерации защищенных ключей, который часто используется для защищенной связи.
	/// </summary>
	public static void GenerateRSAKeyPair()
	{
		var keyPair = Cryptography.GenerateRSAKeyPair();
		keyPair.ToPemFile(keyPairPath);

		MessageBox.Show("OK");
	}

	/// <summary>
	/// Эта тестовая функция может генерировать пару открытых и закрытых ключей с использованием алгоритма шифрования ECDSA.
	/// Это широко используемый алгоритм для генерации защищенных ключей, который часто используется для защищенной связи.s
	/// </summary>
	public static void GenerateECDSAKeyPair()
	{
		var keyPair = Cryptography.GenerateECDSAKeyPair();
		keyPair.ToPemFile(keyPairPath);
	}

	/// <summary>
	/// Этой тестовой функцией может быть запись пары ключей в файл или создание закрытого и открытого ключей.
	/// Закрытые ключи используются в асимметричном шифровании, где один ключ используется для шифрования, а другой - для дешифрования.
	/// </summary>
	public static void WriteKeyPairInPemFile()
	{
		var keyPair = keyPairPath.GetKeyPairFromPem();
		keyPair.Private.ToPemFile(privateKeyPath);
		keyPair.Public.ToPemFile(publicKeyPath);
	}

	/// <summary>
	/// Эта тестовая функция может генерировать запрос на подпись сертификата (CSR), который представляет собой сообщение, отправляемое в центр сертификации для запроса цифрового сертификата.
	/// </summary>
	public static void GenerateCSR()
	{
		var keyPair = keyPairPath.GetKeyPairFromPem();
		var csr = Cryptography.GenerateCSR("Russia", "Ulyanovsk region", "Ulyanovsk", "UISTU", "Student", "Seliaev_D.A", CryptographyAlgorithm.SHA256withRSA, keyPair);
		csr.ToPemFile(csrPath);
	}

	/// <summary>
	/// Эта тестовая функция может генерировать самозаверяющий сертификат.
	/// Самозаверяющие сертификаты - это цифровые сертификаты, подписанные тем же лицом, которое выдает сертификат.
	/// </summary>
	public static void GenerateSelfSignedCert()
	{
		var selfSignedCert = Cryptography.GenerateSelfSignedCert(csrPath.GetCSRPemFile(),
																 keyPairPath.GetPrivateKeyFromPem(),
																 DateTime.UtcNow,
																 DateTime.UtcNow.AddYears(1));
		selfSignedCert.ToPemFile(selfSignedCertPath);
	}

	/// <summary>
	/// Этой тестовой функцией может быть создание файла PFX, который представляет собой формат файла, используемый для безопасного хранения закрытых ключей и сертификатов.
	/// </summary>
	public static void CreatePfx()
	{
		var certificate = new X509Certificate2(selfSignedCertPath);
		var keyPair = keyPairPath.GetKeyPairFromPem();

		var bcRsaPrivateKey = (RsaPrivateCrtKeyParameters)keyPair.Private;
		var rsaParameters = DotNetUtilities.ToRSAParameters(bcRsaPrivateKey);
		var rsaKey = RSA.Create(rsaParameters);

		// Assuming you have an X509Certificate2 named certificate
		var exportableCertificate = certificate.CopyWithPrivateKey(rsaKey);

		// Create password for certificate protection
		var passwordForCertificateProtection = new SecureString();

		foreach (var @char in "1234")
			passwordForCertificateProtection.AppendChar(@char);

		// Export certificate to a file.
		File.WriteAllBytes(privateCertPath, exportableCertificate.Export(X509ContentType.Pfx, passwordForCertificateProtection));
	}

	/// <summary>
	/// Эта тестовая функция может генерировать подписанный сертификат.
	/// Подписанный сертификат - это цифровой сертификат, который был подписан доверенной третьей стороной, известной как центр сертификации.
	/// </summary>
	public static void GenerateSignedCert()
	{
		var signedCert = Cryptography.GenerateSignedCertificate(csrPath.GetCSRPemFile(),
																	privateCertPath.GetPrivateCert(privateCertPass),
																	privateCertPath,
																	DateTime.UtcNow,
																	DateTime.UtcNow.AddYears(1));
		signedCert.ToPemFile(signedCertPath);
	}

	/// <summary>
	/// Эта тестовая функция может проверять, что сертификат был подписан закрытым ключом.
	/// </summary>
	public static void VerifySignedByPrivateKey()
	{
		var message = "Hello world";
		var signature = Cryptography.SignDataByPrivateKey(message, privateKeyPath.GetPrivateKeyFromPem());

		if (Cryptography.VerifySignedByPublicKey(message, signature, publicKeyPath.GetPublicKeyFromPem()))
			MessageBox.Show("Сертификат был подписан закрытым ключом.");
		else
			MessageBox.Show("Сертификат был подписан не закрытым ключом.");
	}


	//Эта тестовая функция может расшифровывать данные с использованием закрытого ключа.
	public static void TestDecryptWithKey()
	{
		var message = "Hello world";
		var keyPair = keyPairPath.GetKeyPairFromPem();
		var encoded = Cryptography.EncryptDataWithPublicKey(message, keyPair.Public);
		var data = Cryptography.DecryptDataWithPrivateKey(encoded, keyPair.Private);
		if(message == data) MessageBox.Show("Проверка успешна");
	}

	/// <summary>
	/// Эта тестовая функция может проверять, что подписанным данным можно доверять, используя тот же сертификат.
	/// </summary>
	public static void TestVerifySignedDataBySameCert()
	{
		var message = "Hello world";
		var signature = Cryptography.SignDataByPrivateCert(message, privateCertPath.GetPrivateCert(privateCertPass));

		if (Cryptography.VerifySignedDataBySameCert(signature, privateCertPath.GetPrivateCert(privateCertPass), out var data))
		{
			if (data != null)
				MessageBox.Show("подписанным данным можно доверять");
		}
		else
		{
			MessageBox.Show("подписанным данным нельзя доверять");
		}
	}

	/// <summary>
	///Эта тестовая функция может проверять соответствие открытого ключа и закрытого ключа.
	/// </summary>
	public static void VerifyMatchBetweenPublicAndPrivateKeys()
	{
		var isValid = Cryptography.VerifyMatchBetweenPublicAndPrivateKeys(signedCertPath.GetPublicCert(), privateCertPath.GetPrivateCert(privateCertPass));
		if(isValid) MessageBox.Show("Ключи совпадают");
	}
	// шифровка разшифровка
	public static void check()
	{
		var message = "Hello world";
		var encoded = Cryptography.EncryptDataByPublicCert(message, signedCertPath.GetPublicCert());
		var data = Cryptography.DecryptDataWithPrivateCert(encoded, privateCertPath.GetPrivateCert(privateCertPass), privateCertPass);

		MessageBox.Show(Encoding.UTF8.GetString(data));
	}
	/// <summary>
	/// Проверяет метод Get Compressed ECDSA PublicKey FromBase64, предоставляя сжатый открытый ключ ECDSA в кодировке Base64
	/// и проверяем, не является ли полученный ключ закрытым.
	/// </summary>
	public static void TestGetCompressedECDSAPublicKeyFromBase64()
	{
		var key = "A2srIPKCMgOVyXq/fhK5Wnr3A/w9cfDv7dEepWZAKglw".GetCompressedECDSAPublicKeyFromBase64();

		Console.WriteLine(!key.IsPrivate);
	}

	/// <summary>
	/// Проверяет, получают ли они метод compressedecdsapublickeyfrompem, предоставляя сжатый открытый ключ ECDSA в формате PEM
	/// и проверяем, не является ли импортированный ключ закрытым..
	/// </summary>
	public static void TestImportCompressedECDSAPublicKeyFromPem()
	{
		var compressedKeyAsPem = @"-----BEGIN EC PUBLIC KEY-----A2srIPKCMgOVyXq/fhK5Wnr3A/w9cfDv7dEepWZAKglw-----END EC PUBLIC KEY-----";

		var key = compressedKeyAsPem.GetCompressedECDSAPublicKeyFromPem();

		Console.WriteLine(!key.IsPrivate);
	}
}