'''simple docstring'''




from __future__ import annotations






def __lowerCAmelCase			(							UpperCamelCase__    ,  UpperCamelCase__ = None    ,  UpperCamelCase__ = None    ,  UpperCamelCase__ = False    ,  )     ->   tuple[int, float, str]:
    __lowerCamelCase          =  cipher_alphabet or [chr(UpperCamelCase__    ) for i in range(97    ,  1_23    )]

    # If the argument is None or the user provided an empty dictionary
    if not frequencies_dict:
        # Frequencies of letters in the english language (how much they show up)
        __lowerCamelCase          =  {
            '''a''': 0.0_8_4_9_7,
            '''b''': 0.0_1_4_9_2,
            '''c''': 0.0_2_2_0_2,
            '''d''': 0.0_4_2_5_3,
            '''e''': 0.1_1_1_6_2,
            '''f''': 0.0_2_2_2_8,
            '''g''': 0.0_2_0_1_5,
            '''h''': 0.0_6_0_9_4,
            '''i''': 0.0_7_5_4_6,
            '''j''': 0.0_0_1_5_3,
            '''k''': 0.0_1_2_9_2,
            '''l''': 0.0_4_0_2_5,
            '''m''': 0.0_2_4_0_6,
            '''n''': 0.0_6_7_4_9,
            '''o''': 0.0_7_5_0_7,
            '''p''': 0.0_1_9_2_9,
            '''q''': 0.0_0_0_9_5,
            '''r''': 0.0_7_5_8_7,
            '''s''': 0.0_6_3_2_7,
            '''t''': 0.0_9_3_5_6,
            '''u''': 0.0_2_7_5_8,
            '''v''': 0.0_0_9_7_8,
            '''w''': 0.0_2_5_6_0,
            '''x''': 0.0_0_1_5_0,
            '''y''': 0.0_1_9_9_4,
            '''z''': 0.0_0_0_7_7,
        }
    else:
        # Custom frequencies dictionary
        __lowerCamelCase          =  frequencies_dict

    if not case_sensitive:
        __lowerCamelCase          =  ciphertext.lower()

    # Chi squared statistic values
    __lowerCamelCase          =  {}

    # cycle through all of the shifts
    for shift in range(len(UpperCamelCase__    )    ):
        __lowerCamelCase          =  ''''''

        # decrypt the message with the shift
        for letter in ciphertext:
            try:
                # Try to index the letter in the alphabet
                __lowerCamelCase          =  (alphabet_letters.index(letter.lower()    ) - shift) % len(
                    UpperCamelCase__    )
                decrypted_with_shift += (
                    alphabet_letters[new_key].upper()
                    if case_sensitive and letter.isupper()
                    else alphabet_letters[new_key]
                )
            except ValueError:
                # Append the character if it isn't in the alphabet
                decrypted_with_shift += letter

        __lowerCamelCase          =  0.0

        # Loop through each letter in the decoded message with the shift
        for letter in decrypted_with_shift:
            if case_sensitive:
                __lowerCamelCase          =  letter.lower()
                if letter in frequencies:
                    # Get the amount of times the letter occurs in the message
                    __lowerCamelCase          =  decrypted_with_shift.lower().count(UpperCamelCase__    )

                    # Get the excepcted amount of times the letter should appear based
                    # on letter frequencies
                    __lowerCamelCase          =  frequencies[letter] * occurrences

                    # Complete the chi squared statistic formula
                    __lowerCamelCase          =  ((occurrences - expected) ** 2) / expected

                    # Add the margin of error to the total chi squared statistic
                    chi_squared_statistic += chi_letter_value
            else:
                if letter.lower() in frequencies:
                    # Get the amount of times the letter occurs in the message
                    __lowerCamelCase          =  decrypted_with_shift.count(UpperCamelCase__    )

                    # Get the excepcted amount of times the letter should appear based
                    # on letter frequencies
                    __lowerCamelCase          =  frequencies[letter] * occurrences

                    # Complete the chi squared statistic formula
                    __lowerCamelCase          =  ((occurrences - expected) ** 2) / expected

                    # Add the margin of error to the total chi squared statistic
                    chi_squared_statistic += chi_letter_value

        # Add the data to the chi_squared_statistic_values dictionary
        __lowerCamelCase          =  (
            chi_squared_statistic,
            decrypted_with_shift,
        )

    # Get the most likely cipher by finding the cipher with the smallest chi squared
    # statistic
    def chi_squared_statistic_values_sorting_key(UpperCamelCase__    ) -> tuple[float, str]:
        return chi_squared_statistic_values[key]

    __lowerCamelCase          =  min(
        UpperCamelCase__    ,  key=UpperCamelCase__    ,  )

    # Get all the data from the most likely cipher (key, decoded message)
    (
        (
        __lowerCamelCase
    )     ,  (
        __lowerCamelCase
    )     ,  
    )          =  chi_squared_statistic_values[most_likely_cipher]

    # Return the data on the most likely shift
    return (
        most_likely_cipher,
        most_likely_cipher_chi_squared_value,
        decoded_most_likely_cipher,
    )

'''simple docstring'''




__UpperCAmelCase												="ABCDEFGHIJKLMNOPQRSTUVWXYZ"






def __lowerCAmelCase			(							)     ->   None:
    __lowerCamelCase          =  input('''Enter message: '''    )
    __lowerCamelCase          =  input('''Enter key [alphanumeric]: '''    )
    __lowerCamelCase          =  input('''Encrypt/Decrypt [e/d]: '''    )

    if mode.lower().startswith('''e'''    ):
        __lowerCamelCase          =  '''encrypt'''
        __lowerCamelCase          =  encrypt_message(UpperCamelCase__    ,  UpperCamelCase__    )
    elif mode.lower().startswith('''d'''    ):
        __lowerCamelCase          =  '''decrypt'''
        __lowerCamelCase          =  decrypt_message(UpperCamelCase__    ,  UpperCamelCase__    )

    print(f"""\n{mode.title()}ed message:"""    )
    print(UpperCamelCase__    )






def __lowerCAmelCase			(							UpperCamelCase__    ,  UpperCamelCase__    )     ->   str:
    return translate_message(UpperCamelCase__    ,  UpperCamelCase__    ,  '''encrypt'''    )






def __lowerCAmelCase			(							UpperCamelCase__    ,  UpperCamelCase__    )     ->   str:
    return translate_message(UpperCamelCase__    ,  UpperCamelCase__    ,  '''decrypt'''    )






def __lowerCAmelCase			(							UpperCamelCase__    ,  UpperCamelCase__    ,  UpperCamelCase__    )     ->   str:
    __lowerCamelCase          =  []
    __lowerCamelCase          =  0
    __lowerCamelCase          =  key.upper()

    for symbol in message:
        __lowerCamelCase          =  LETTERS.find(symbol.upper()    )
        if num != -1:
            if mode == "encrypt":
                num += LETTERS.find(key[key_index]    )
            elif mode == "decrypt":
                num -= LETTERS.find(key[key_index]    )

            num %= len(UpperCamelCase__    )

            if symbol.isupper():
                translated.append(LETTERS[num]    )
            elif symbol.islower():
                translated.append(LETTERS[num].lower()    )

            key_index += 1
            if key_index == len(UpperCamelCase__    ):
                __lowerCamelCase          =  0
        else:
            translated.append(UpperCamelCase__    )
    return "".join(UpperCamelCase__    )


if __name__ == "__main__":
  main()
