Translation using googletranslate

import os
import re
import time
from deep_translator import GoogleTranslator
from polib import pofile

# Define a regex pattern to match `&` only if it's adjacent to a letter or number
mnemonic_pattern = re.compile(r"(?<=\w)&|&(?=\w)")

# Function to remove mnemonics
def remove_mnemonics(text):
    """Remove `&` if it is adjacent to a letter or number."""
    return re.sub(mnemonic_pattern, "", text)

# Function to fetch supported languages from Google Translator
def get_supported_languages():
    try:
        translator = GoogleTranslator()
        return translator.get_supported_languages(as_dict=True)
    except Exception as e:
        print(f"Error fetching languages: {e}")
        return {}

# Function to map msgid to line numbers in the original file
def get_msgid_line_numbers(file_path):
    """Map each msgid to its corresponding line number."""
    line_number_mapping = {}
    with open(file_path, 'r', encoding='utf-8') as f:
        lines = f.readlines()

    current_msgid = None
    for line_num, line in enumerate(lines, start=1):
        if line.startswith('msgid "'):
            current_msgid = line.strip()[7:-1]  # Remove `msgid "` prefix and trailing `"`
            line_number_mapping[current_msgid] = line_num
    return line_number_mapping

# Function to translate a .po file
def translate_po_file(file_path, target_language):
    try:
        po_file = pofile(file_path)
    except Exception as e:
        print(f"Error loading file: {e}")
        return

    po_file.metadata['Content-Type'] = 'text/plain; charset=UTF-8'
    po_file.metadata['Language'] = target_language

    try:
        translator = GoogleTranslator(source='auto', target=target_language)
    except Exception as e:
        print(f"Error initializing translator: {e}")
        return

    line_number_mapping = get_msgid_line_numbers(file_path)
    total_entries = len(po_file)
    translated_count = 0
    failed_count = 0
    failed_translations = []
    start_time = time.time()

    for i, entry in enumerate(po_file):
        print(f"Translating {i + 1}/{total_entries}: {entry.msgid}")

        if not entry.msgstr:
            try:
                translated_text = translator.translate(entry.msgid)
                entry.msgstr = remove_mnemonics(translated_text)
                print(f"Translated: {entry.msgstr}")
                translated_count += 1
            except Exception as e:
                entry.msgstr = "Translation Failed"
                failed_count += 1
                line_number = line_number_mapping.get(entry.msgid, 'Unknown')
                failed_translations.append((entry.msgid, line_number))
                print(f"Failed to translate: {entry.msgid} (Line {line_number}) - Error: {e}")

    #    progress = int((i + 1) / total_entries * 100)
    #    print(f"Progress: {progress}%")

    # Output file logic
    output_filename = f"translated_{target_language}.po"
    output_filename = os.path.abspath(output_filename)  # Normalize for cross-platform compatibility

    if os.path.exists(output_filename):
        choice = input(f"The file '{output_filename}' already exists. Overwrite? (y/n): ").strip().lower()
        if choice != 'y':
            new_filename = input("Enter a new filename: ").strip()
            if not new_filename:
                print("Translation Cancelled.")
                return
            output_filename = os.path.abspath(new_filename)

    try:
        po_content = po_file.__unicode__()
        with open(output_filename, 'w', encoding='utf-8') as f:
            f.write(po_content)
    except Exception as e:
        print(f"Error saving file: {e}")
        return

    end_time = time.time()
    elapsed_time = end_time - start_time
    hours, rem = divmod(elapsed_time, 3600)
    minutes, seconds = divmod(rem, 60)

    print("\nTranslation Complete!")
    print(f"Total entries: {total_entries}")
    print(f"Successfully translated: {translated_count}")
    print(f"Failed translations: {failed_count}")
    print(f"Elapsed time: {int(hours)}h {int(minutes)}m {int(seconds)}s")
    print(f"File saved as: {output_filename}")
    if failed_translations:
        print("\nFailed Translations:")
        for msgid, line_number in failed_translations:
            print(f"  Line {line_number}: {msgid}")

# Function to validate and get file path
def get_file_path():
    while True:
        file_path = input("Enter the path to the .po file (or type 'cancel' to exit): ").strip()
        if file_path.lower() == 'cancel':
            print("Operation cancelled by user.")
            return None
        if os.path.exists(file_path):
            return file_path
        print("Error: File does not exist. Please try again.")

# Function to validate and get target language
def get_target_language(languages_dict):
    while True:
        target_input = input("\nEnter the target language name or code: ").strip().lower()
        
        # Check if it's a valid language code
        if target_input in languages_dict.keys():
            return target_input
        
        # Check if it's a valid language name
        for code, name in languages_dict.items():
            if target_input == name.lower():
                return code
        
        print("Invalid language input. Please enter a valid language name or code.")

# Main function for CLI
def main():
    print("PO File Translator (CLI Version)")
    
    # Get file path
    file_path = get_file_path()
    if not file_path:
        return  # User chose to cancel

    # Get supported languages
    languages_dict = get_supported_languages()
    if not languages_dict:
        print("Error: Could not fetch supported languages.")
        return

    # Display supported languages
    print("\nSupported Languages:")
    for code, lang in languages_dict.items():
        print(f"{code}: {lang}")
    
    # Get target language
    target_language = get_target_language(languages_dict)

    # Translate the file
    translate_po_file(file_path, target_language)

if __name__ == "__main__":
    main()