from collections import deque
from typing_extensions import Self


class BasicRegister:
    """
    The BasicRegister represents a hardware register capable of manipulating multiple bits at a time.

    :param deque[bool] memory: The bits stored inside the register.
    """

    def __init__(self, memory: list[bool]):
        self.memory: deque[bool] = deque(memory)

    def __repr__(self) -> str:
        return f"Memory: {[int(value) for value in  self.memory]}"

    def __str__(self) -> str:
        return f"Memory: {[int(value) for value in  self.memory]}"

    def __len__(self) -> int:
        return len(self.memory)

    def adjusted_by_size(self, resulting_size: int) -> Self:
        """
        Adjusts a register to a given size.

        :param int resulting_size: The size of the resulting register.

        :return: A register of a specified size.
        :rtype: BasicRegister
        """
        current_memory_size: int = len(self.memory)
        return BasicRegister(
            [False] * max(resulting_size - current_memory_size, 0) + list(self.memory)[-resulting_size:]
        )

    def reverse(self):
        self.memory = deque([not value for value in self.memory])

    def left_shift(self, digit_to_fill: bool = False, steps_shifted: int = 1) -> deque[bool]:
        self.memory.extend([digit_to_fill] * steps_shifted)
        shifted_radices: deque[bool] = deque([self.memory.popleft() for _i in range(steps_shifted)])
        return shifted_radices

    def right_shift(self, digit_to_fill: bool = False, steps_shifted: int = 1) -> deque[bool]:
        self.memory.extendleft([digit_to_fill] * steps_shifted)
        shifted_radices: deque[bool] = deque([self.memory.pop() for _i in range(steps_shifted)])
        return shifted_radices


def get_memory(variable_name: str) -> list[bool]:
    """
    Reads user input to be used as a memory array.

    :param str variable_name: The name to be displayed in the input line.

    :return: A list of boolean values read from user.
    :rtype: list[bool]
    """
    while True:
        input_chars: list[str] = list(input(f"Enter {variable_name}: "))

        if all(character in ["0", "1"] for character in input_chars):
            return [True if character == "1" else False for character in input_chars]
        else:
            print(f"[ERROR] The {variable_name} may contain only 1-s and 0-s!")


def binary_sum(first_term: BasicRegister, second_term: BasicRegister, return_remainder: bool = False)\
        -> BasicRegister | tuple[BasicRegister, int]:
    """
    Sums two registers' values.

    :param BasicRegister first_term: First register.
    :param BasicRegister second_term: Second register.
    :param bool return_remainder: True to return the tuple, False to return just the register.

    :return: Register containing the sum or the tuple containing the register and carried radix.
    :rtype: BasicRegister | tuple[BasicRegister, int]
    """
    size_a = len(first_term)
    size_b = len(second_term)

    required_size = max(size_a, size_b)

    a = first_term
    b = second_term

    if size_a != size_b:
        a = a.adjusted_by_size(required_size)
        b = b.adjusted_by_size(required_size)

    c = BasicRegister([False] * required_size)

    carry = False
    for i in range(required_size - 1, 0, -1):
        current_bit_sum = a.memory[i] + b.memory[i] + carry
        carry = bool(current_bit_sum & 2)
        c.memory[i] = bool(current_bit_sum & 1)

    final_bit_sum = a.memory[0] + b.memory[0] + carry
    carry = bool(final_bit_sum & 2)
    c.memory[0] = bool(final_bit_sum & 1)

    if return_remainder:
        return c, carry
    else:
        return c