import os 
from dotenv import load_dotenv 

load_dotenv()

def menu():
    opc = 0
    print("===SELECTOR===")
    print("1) Crypt Word")
    print("2) Decrypt Word")
    print("3) Exit")
    opc = int(input("Select Option: "))
    if opc == 1:
        crypt_word()
    elif opc == 2:
        pass 
    else:
        os._exit(1)

def load_rotors(rotor_opc):
    alfabeto = os.getenv("ALFABETO")
    rotor_I = os.getenv("ROTOR_I")
    rotor_II = os.getenv("ROTOR_II")
    rotor_III = os.getenv("ROTOR_III")
    reflector = os.getenv("REFLECTOR")

    if rotor_opc == 1: 
        return rotor_I 
    elif rotor_opc == 2:
        return rotor_II 
    elif rotor_opc == 3:
        return rotor_III
    elif rotor_opc == "alfabeto":
        return alfabeto
    elif rotor_opc == "reflector":
        return reflector
       
def map_key(rotor_opc, char_key):
    rotor = load_rotors(rotor_opc)
    print(f"Rotor {rotor_opc} cargado...")
    print(f"Buscando valor de {char_key} en rotor {rotor_opc}")
    obj = char_key.upper()
    for index, char_key_upper in enumerate(rotor): 
        if char_key_upper == obj:
            print(f"{char_key} tiene la posicion de {index}")
            return index



def map_char(rotor_opc, char):
    rotor = load_rotors(rotor_opc)
    print(f"Rotor {rotor_opc} cargado...")
    print(f"Buscando valor de {char} en rotor {rotor_opc}")
    obj = char.upper()
    for index, char_upper in enumerate(rotor): 
        if char_upper == obj:
            char_pos = index
            print(f"{char} tiene la posicion de {char_pos}")
            return char_pos

def find_char(rotor_opc, index):
    rotor = load_rotors(rotor_opc)
    print(f"Rotor {rotor_opc} cargado...")
    print(f"Buscando el valor de la posicion {index} en rotor {rotor_opc}")
    index_seguro = index % 26
    value = rotor[index_seguro]
    return value
    
def compare_value_notch(value_char, notch_value, key_pos):
    if value_char != notch_value: 
        return key_pos
    else:
        key_pos = (key_pos + 1) % 26
        print(f"VALOR DEL KEY MODIFICADO A {key_pos}")
        return key_pos 



def main_cipher_logic(word, key):
    palabra_cifrada = [0] * len(word)
    print(f"Mapeando key {key} en alfabeto")
    key_positions = [0] * len(key)
    for i, char_key in enumerate(key):
        char_key_pos = map_key("alfabeto", char_key)
        key_positions[i] = char_key_pos
    

    for i, char in enumerate(word):
        char_pos = map_char("alfabeto", char)
        x = ((char_pos + key_positions[0]) % 26)
        value_char = find_char(1, x) 
        key_positions[0] = compare_value_notch(value_char, "Q", key_positions[0])
        
        x = ((map_char("alfabeto", value_char) + key_positions[1]) % 26)
        value_char = find_char(2, x)
        key_positions[1] = compare_value_notch(value_char, "E", key_positions[1])
        
        x = ((map_char("alfabeto", value_char) + key_positions[2]) % 26 )
        value_char = find_char(3, x)
        key_positions[2] = compare_value_notch(value_char, "V", key_positions[2])
        
        # buscamos en el referector
        index = map_char("alfabeto", value_char)
        char_from_reflector = find_char("reflector", index)

        #index = map_char("alfabeto", value_char)
        #print(index)
        #x = find_char("reflector", index)

        x = map_char(3, char_from_reflector)
        key_positions[2] = compare_value_notch(value_char, "V", key_positions[2])
        x = (((x) - key_positions[2]) % 26)

        value_char = find_char("alfabeto", x)
        x = map_char(2, value_char)
        key_positions[1] = compare_value_notch(value_char, "E", key_positions[1])
        x = (((x) - key_positions[1]) % 26)

        value_char = find_char("alfabeto", x)
        x = map_char(1, value_char)
        key_positions[0] = compare_value_notch(value_char, "Q", key_positions[0])
        final = (((x) - key_positions[0]) % 26)

        char_cipher=find_char("alfabeto", final)
        
        print(f"Letra {char}\nCifrado {char_cipher}")

        palabra_cifrada[i] = char_cipher

    return "".join(palabra_cifrada)

def crypt_word():
    word=input("Word to crypt: ")
    key=input("Key Word (the key length must be 3 letters): ")
    if len(key) != 3:
        print("THE KEY LENGHT MUST BE 3 LETTERS")
        os._exit(1) 
    crypted_word=main_cipher_logic(word, key)
    print(f"Word in plain text: {word}")
    print(f"Crypted word: {crypted_word}")




## main 

menu()