Modern day cracking of the "Multiplication code"

def process_keyword(keyword):
    """
    Assigns numerical values to the keyword based on alphabetical order.
    Returns the combined integer.
    """
    # Sanitize keyword to uppercase letters only
    keyword = "".join(c for c in keyword.upper() if c.isalpha())

    # Create a list of tuples: (character, original_index)
    indexed_chars = [(char, i) for i, char in enumerate(keyword)]

    # Sort alphabetically. Python's sort is stable, meaning duplicates
    # automatically stay in their original left-to-right order.
    sorted_chars = sorted(indexed_chars)

    # Reconstruct the sequence based on the original positions
    base_seq = [0] * len(keyword)
    for rank, (char, orig_index) in enumerate(sorted_chars, start=1):
        base_seq[orig_index] = str(rank)

    return int("".join(base_seq))

def generate_shift_key(keyword, day):
    """
    Multiplies the base sequence by the day of the month.
    """
    base_int = process_keyword(keyword)
    shift_key_int = base_int * day
    return str(shift_key_int)

def agent_zigzag_decrypt(keyword, day, ciphertext):
    """
    Decrypts the message by reversing the shift.
    """
    shift_key_str = generate_shift_key(keyword, day)

    # Remove any spaces from transmission blocks
    ciphertext = ciphertext.replace(" ", "")
    plaintext = ""
    key_len = len(shift_key_str)

    # Decrypt by shifting backward
    for i, char in enumerate(ciphertext):
        shift = int(shift_key_str[i % key_len])
        # Calculate original character wrapping around the alphabet
        orig_char = chr(((ord(char) - ord('A') - shift) % 26) + ord('A'))
        plaintext += orig_char

    return plaintext

def score_fitness(text):
    """
    Checks for common bigrams and trigrams,
    but also rewards the presence of common vowels.
    """
    common_patterns = [
        "TH", "HE", "IN", "ER", "AN", "RE", "ON", "AT", "EN",
        "THE", "AND", "ING", "ENT", "ION", "HER", "FOR", "THA"
    ]
    score = 0
    for pattern in common_patterns:
        score += text.count(pattern) * (len(pattern) ** 2) # Reward longer patterns more

    # Bonus for common English vowels appearing frequently
    vowels = "AEIOU"
    vowel_count = sum(text.count(v) for v in vowels)
    if vowel_count > (len(text) * 0.3): # English is usually ~38% vowels
        score += 5

    return score

def crack_zigzag(ciphertext, word_list, top_n=5):
    """
    Brute-forces the cipher and returns the top N unique results.
    """

    total_permutations = len(word_list) * 31
    print(f"Cracking... Analyzing {total_permutations:,} possible combinations.\n")

    all_results = []

    for word in word_list:
        for day in range(1, 32):
            decrypted = agent_zigzag_decrypt(word, day, ciphertext)
            score = score_fitness(decrypted)
            all_results.append({
                "keyword": word,
                "day": day,
                "text": decrypted,
                "score": score
            })

    # Sort by highest score first
    all_results.sort(key=lambda x: x['score'], reverse=True)

    # Filter for unique plaintext results (different keys can result in the same text)
    unique_results = []
    seen_texts = set()
    for res in all_results:
        if res['text'] not in seen_texts:
            unique_results.append(res)
            seen_texts.add(res['text'])
        if len(unique_results) >= top_n:
            break

    return unique_results


if __name__ == "__main__":
    # 1. We start with an intercepted message (Ciphertext)
    # This says "THE INVASION WILL HAPPEN AT DAWN" padded with "X"s
    # Encrypted with keyword: "PARIS", Day: 6
    intercepted_ciphertext = "UPMNS VBAQT SWJTT MFPQM VFYDB EVCCX"

    # 2a. We load a small dictionary
    # In a real scenario, you would load a text file with 100,000+ words here.
    dictionary = [
        "APPLE", "TRAIN", "BERLIN", "PARIS", "RADIO",
        "LONDON", "CHURCHILL", "SPY", "ZIGZAG", "SECRET"
    ]

    # 2b. Full dictionary loading example (commented out for this test)
    # with open("english_words.txt", "r") as file:
    #     dictionary = [line.strip().upper() for line in file]

    top_hits = crack_zigzag(intercepted_ciphertext, dictionary, top_n=5)

    print(f"{'Rank':<5} | {'Score':<6} | {'Day':<3} | {'Keyword':<16} | {'Decrypted Message'}")

    for i, hit in enumerate(top_hits, 1):
        print(f"{i:<5} | {hit['score']:<6} | {hit['day']:<3} | {hit['keyword']:<16} | {hit['text']}")