def ip_para_binario(ip: str) -> str:
    """Converte um endereço IP para sua representação binária de 32 bits."""
    return ''.join(format(int(x), '08b') for x in ip.split('.'))


def binario_para_ip(binario: str) -> str:
    """Converte uma representação binária de 32 bits para um endereço IP."""
    return '.'.join(str(int(binario[i:i + 8], 2)) for i in range(0, 32, 8))


def identificar_octeto_errado(mascara_str: str):
    """Identifica o octeto com mistura de 0s e 1s e conta o número de 1s."""
    octetos = mascara_str.split('.')

    if len(octetos) != 4:
        raise ValueError("A máscara de rede deve ter 4 octetos.")

    mascara_binaria = [format(int(octeto), '08b') for octeto in octetos]

    for i, binario in enumerate(mascara_binaria):
        if '0' in binario and '1' in binario:
            quantidade_1 = binario.count('1')
            return i, quantidade_1, mascara_binaria

    return None, 0, mascara_binaria


def calcular_subredes(ip: str, mascara: str):
    # Identificar octeto com mistura de 0s e 1s
    octeto_errado, quantidade_1, mascara_binaria = identificar_octeto_errado(mascara)

    if octeto_errado is None:
        raise ValueError("Nenhum octeto com mistura de 0s e 1s foi encontrado na máscara fornecida.")

    # Calcular o número de sub-redes com base na quantidade de 1s no octeto errado
    num_subredes = 2 ** quantidade_1

    # Converter o endereço IP e a máscara para binário
    ip_binario = ip_para_binario(ip)
    mascara_binaria = ''.join(mascara_binaria)

    # Calcular o número de bits de rede e host
    num_bits_rede = mascara_binaria.count('1')
    num_bits_host = 32 - num_bits_rede

    # Calcular o número de hosts por sub-rede
    num_hosts_por_subrede = (2 ** num_bits_host) - 2  # Descontando o endereço de rede e broadcast

    # Calcular o endereço base da sub-rede e o número de IPs por sub-rede
    endereco_base_binario = ip_binario[:num_bits_rede] + '0' * num_bits_host
    passo_subrede = 2 ** num_bits_host
    subredes = []

    for i in range(num_subredes):
        # Calcular o endereço da sub-rede
        endereco_subrede_binario = format(int(endereco_base_binario, 2) + i * passo_subrede, '032b')
        endereco_subrede = binario_para_ip(endereco_subrede_binario)

        # Calcular o endereço de broadcast
        endereco_broadcast_binario = endereco_subrede_binario[:-num_bits_host] + '1' * num_bits_host
        endereco_broadcast = binario_para_ip(endereco_broadcast_binario)

        # Listar todos os endereços IP válidos
        enderecos_usaveis = []
        for j in range(1, (2 ** num_bits_host) - 1):
            endereco_host_binario = format(int(endereco_subrede_binario, 2) + j, '032b')
            endereco_host = binario_para_ip(endereco_host_binario)
            enderecos_usaveis.append(endereco_host)

        subredes.append((endereco_subrede, endereco_broadcast, enderecos_usaveis))

    # Identificar a classe da rede
    mascaras_classe = {
        ('11111111', '11111111', '11111111', '11111110'): "Classe: Rede de Classe C",
        ('11111111', '11111111', '11111111', '11111100'): "Classe: Rede de Classe C",
        ('11111111', '11111111', '11111111', '11111000'): "Classe: Rede de Classe C",
        ('11111111', '11111111', '11111111', '11110000'): "Classe: Rede de Classe C",
        ('11111111', '11111111', '11111111', '11100000'): "Classe: Rede de Classe C",
        ('11111111', '11111111', '11111111', '11000000'): "Classe: Rede de Classe C",
        ('11111111', '11111111', '11111111', '10000000'): "Classe: Rede de Classe C",
        ('11111111', '11111110', '00000000', '00000000'): "Classe: Rede de Classe B",
        ('11111111', '11111100', '00000000', '00000000'): "Classe: Rede de Classe B",
        ('11111111', '11111000', '00000000', '00000000'): "Classe: Rede de Classe B",
        ('11111111', '11110000', '00000000', '00000000'): "Classe: Rede de Classe B",
        ('11111111', '11100000', '00000000', '00000000'): "Classe: Rede de Classe B",
        ('11111111', '11000000', '00000000', '00000000'): "Classe: Rede de Classe B",
        ('11111111', '10000000', '00000000', '00000000'): "Classe: Rede de Classe B",
        ('11111111', '11111110', '00000000', '00000000'): "Classe: Rede de Classe A",
        ('11111111', '11111100', '00000000', '00000000'): "Classe: Rede de Classe A",
        ('11111111', '11111000', '00000000', '00000000'): "Classe: Rede de Classe A",
        ('11111111', '11110000', '00000000', '00000000'): "Classe: Rede de Classe A",
        ('11111111', '11100000', '00000000', '00000000'): "Classe: Rede de Classe A",
        ('11111111', '11000000', '00000000', '00000000'): "Classe: Rede de Classe A",
        ('11111111', '10000000', '00000000', '00000000'): "Classe: Rede de Classe A"
    }

    mascara_binaria_tupla = tuple(mascara_binaria[i:i + 8] for i in range(0, 32, 8))
    classe_rede = mascaras_classe.get(mascara_binaria_tupla, "Classe não identificável pela máscara fornecida.")

    # Exibir resultados
    print(f"\033[1;42mEndereço IP: {ip}\033[m")
    print(f"\033[1;42mMáscara de sub-rede: {mascara}\033[m")
    print(f"\033[1;35mNúmero de sub-redes: {num_subredes}\033[m")
    print(f"\033[1;35mNúmero de IPs por sub-redes: {num_hosts_por_subrede + 2}\033[m")
    print(f"\033[1;35mNúmero de hosts por sub-rede: {num_hosts_por_subrede}\033[m")
    print(f"\033[1;36m{classe_rede}\033[m")
    print()

    for i, (subrede, broadcast, enderecos) in enumerate(subredes):
        print(f"Sub-rede {i + 1}: {subrede}")
        print(f"Endereço de Broadcast: {broadcast}")
        print("Endereços IP Utilizáveis:")
        for endereco in enderecos:
            print(f"  - {endereco}")
        print()


print('\033[1;43m**** Programa para calcular sub-redes ****\033[m')
# Solicita ao usuário o endereço IP e a máscara de rede
ip = input("\033[1;31mDigite o endereço IP (por exemplo, 192.168.1.1): \033[m")
mascara = input("\033[1;31mDigite a máscara de rede (por exemplo, 255.255.255.248): \033[m")
print()

# Exemplo de uso
calcular_subredes(ip, mascara)