import random
from math import gcd
from sympy import mod_inverse, isprime

class SimpleRSA:
    def __init__(self):
        self.public_key = None
        self.private_key = None

    def generate_keypair(self):
        if self.public_key is not None and self.private_key is not None:
            return

        p = self.generate_large_prime()
        q = self.generate_large_prime()

        n = p * q
        phi = (p - 1) * (q - 1)

        e = random.randint(2, phi - 1)
        while gcd(e, phi) != 1:
            e = random.randint(2, phi - 1)

        d = mod_inverse(e, phi)

        self.public_key = (n, e)
        self.private_key = (n, d)

        return self.public_key, self.private_key

    def generate_large_prime(self):
        lower_limit = 10 ** 12
        upper_limit = 10 ** 13
        potential_prime = random.randint(lower_limit, upper_limit)
        while not isprime(potential_prime):
            potential_prime = random.randint(lower_limit, upper_limit)
        return potential_prime

    def encrypt(self, message):
        n, e = self.public_key
        binary_blocks = self.text_to_numeric_binary_blocks(message)

        print(f"binary_blocks: {binary_blocks}")

        encrypted_blocks = [pow(int(block, 2), e, n) for block in binary_blocks]

        print(f"encrypted_blocks: {encrypted_blocks}")

        return encrypted_blocks

    def decrypt(self, encrypted_blocks):
        n, d = self.private_key

        decrypted_blocks = [format(pow(block, d, n), '0b') for block in encrypted_blocks]

        print(f"decrypted_blocks: {decrypted_blocks}")

        decrypted_message = self.numeric_to_text_binary_blocks(decrypted_blocks)

        print(f"decrypted_message: {decrypted_message}")

        return decrypted_message


    def text_to_numeric_binary_blocks(self, text, block_size=10):
        binary_blocks = [
            ''.join(format(ord(char), '08b') for char in text[i:i + block_size]).rjust(block_size * 8, '0')
            for i in range(0, len(text), block_size)
        ]
        return binary_blocks

    def numeric_to_text_binary_blocks(self, binary_blocks):
        bytes_list = [int(block, 2).to_bytes((len(block) + 7) // 8, 'big') for block in binary_blocks]
        text = b''.join(bytes_list).decode(errors='replace')
        return text


def test_encryption_decryption(message):
    rsa = SimpleRSA()
    public_key, private_key = rsa.generate_keypair()

    print(f"Public key (n): {public_key[0]}")

    print(f"Original message: {message}")

    # Encryption
    encrypted_blocks = rsa.encrypt(message)
    print(f"Encrypted blocks: {encrypted_blocks}")

    # Decryption
    decrypted_message = rsa.decrypt(encrypted_blocks)
    print(f"Decrypted message: {decrypted_message}")



if __name__ == "__main__":

    test_encryption_decryption("hello")

import random
from sympy import isprime, gcd, mod_inverse


def text_to_numeric_binary_blocks(text):
    block_size = 10  # Set block size to 10 bits
    numeric_decimal_blocks = []

    for i in range(0, len(text), block_size):
        block = text[i:i + block_size]
        numeric_decimal_block = int(''.join(format(ord(char), '010b') for char in block), 2)
        numeric_decimal_blocks.append(numeric_decimal_block)

    numeric_binary_blocks = [format(block, '010b') for block in numeric_decimal_blocks]

    return numeric_decimal_blocks, numeric_binary_blocks


def numeric_to_text_binary_blocks(numeric_decimal_blocks):
    # Convert each numeric block to a string and then concatenate them
    numeric_representation = ''.join(map(str, numeric_decimal_blocks))
    # Convert the combined string to an integer
    numeric_representation = int(numeric_representation)
    # Convert the integer to binary representation
    binary_representation = format(numeric_representation, 'b')

    # Pad the binary representation to ensure a multiple of 10 for ASCII conversion
    binary_representation = binary_representation.rjust(((len(binary_representation) + 9) // 10) * 10, '0')

    # Convert each 10-bit chunk back to an integer and then to its ASCII character
    text = ''.join(chr(int(binary_representation[i:i + 10], 2)) for i in range(0, len(binary_representation), 10))

    return text, numeric_decimal_blocks


def generate_keypair():
    p = generate_large_prime()
    q = generate_large_prime()

    n = p * q
    phi = (p - 1) * (q - 1)

    e = random.randint(2, phi - 1)
    while gcd(e, phi) != 1:
        e = random.randint(2, phi - 1)

    d = mod_inverse(e, phi)

    global public_key, private_key
    public_key = (n, e)
    private_key = (n, d)

    private_key_str = f"{private_key[0]} {private_key[1]}"
    public_key_str = f"{public_key[0]} {public_key[1]}"


def generate_large_prime():
    lower_limit = 10 ** 11
    upper_limit = 10 ** 12
    potential_prime = random.randint(lower_limit, upper_limit)
    while not isprime(potential_prime):
        potential_prime = random.randint(lower_limit, upper_limit)
    return potential_prime


def encrypt(message, public_key):
    n, e = public_key
    numeric_decimal_blocks, _ = text_to_numeric_binary_blocks(message)

    # Encrypt each block using the public key
    encrypted_blocks = [pow(block, e, n) for block in numeric_decimal_blocks]

    return encrypted_blocks


def decrypt(encrypted_blocks, private_key):
    n, d = private_key

    # Decrypt each block using the private key
    decrypted_blocks = [pow(block, d, n) for block in encrypted_blocks]

    # Convert the numeric blocks back to text
    decrypted_message, _ = numeric_to_text_binary_blocks(decrypted_blocks)

    return decrypted_message

generate_keypair()

# Example usage:
message_to_encrypt = "hello"
encrypted_blocks = encrypt(message_to_encrypt, public_key)
decrypted_message = decrypt(encrypted_blocks, private_key)

print("Original Message:", message_to_encrypt)
print("Encrypted Blocks:", encrypted_blocks)
print("Decrypted Message:", decrypted_message)