import polib
import re
import sys
import os
import glob

code_patterns = [
    # Basic patterns
    r"\([^)]*،[^)]*\)",  # foo(3.0، -4.5)
    r"\[[^]]*،[^]]*\]",  # ['a'، 'b'، 'c']
    r"\{[^}]*،[^}]*\}",  # {'Sjoerd': 4127، 'Jack': 4098}
    # Function and class definitions
    r"def\s+\w+\s*\([^)]*،[^)]*\)",  # def __init__(self، name)
    r"class\s+\w+\s*\([^)]*،[^)]*\)",  # class AsyncZip(threading.Thread، file)
    r"__init__\([^)]*،[^)]*\)",  # __init__(self، realpart، imagpart)
    # Method and function calls
    r"\w+\([^)]*،[^)]*\)",  # round(Decimal('0.70')، 2)
    r"__import__\([^،]*(?:،\s*[^،)]*){0,4}\)",  # __import__('spam.ham'، globals()، locals())
    r"(?:globals|locals)\(\)،\s*(?:globals|locals)\(\)",  # globals()، locals()
    # Variable assignments and operations
    r"for\s+\w+،\s*\w+\s+in\s+",  # for a، b in table.items()
    r"print\([^)]*،[^)]*\)",  # print(a، end=' ')
    # Variable and attribute access
    r"\w+\.\w+،\s*\w+\.\w+",  # x.r، x.i
    r"(?:\w+\([^)]*\)|'[^']*'|\"[^\"]*\"|[)\]])،\s*\w+",  # os.open('mydata.db'، 'rb')
    # Dictionary operations
    r"{\s*'[^']*':\s*\w+،",  # {'primary': یک، 'secondary': دو}
    r"for\s+\w+،\s*\w+\s+in\s+\w+\.items\(\)",  # for a، b in table.items()
    r">>>.*،.*",  # >>> a، b
]


def is_code_pattern(text: str) -> bool:
    """
    Check if the text matches common code patterns
    where virgules should be converted to commas.
    """

    return any(re.search(pattern, text) for pattern in code_patterns)


def fix_virgules_in_code(entry):
    """
    Fix virgules in code sections while preserving them in regular text.
    Returns True if any changes were made.
    """
    modified = False

    # Check if original message is complete Python code
    if is_complete_python_code(entry.msgid):
        if entry.msgid != entry.msgstr and entry.msgstr != "":
            entry.msgstr = entry.msgid
            modified = True
        return modified

    # If the text appears to be code, replace virgules
    if is_code_pattern(entry.msgstr):
        new_text = entry.msgstr

        # Handle matches
        def replace_virgules(match):
            return match.group().replace("،", ",")

        # Use the same patterns from is_code_pattern
        for pattern in code_patterns:
            new_text = re.sub(pattern, replace_virgules, new_text)

        if new_text != entry.msgstr:
            entry.msgstr = new_text
            modified = True

    return modified


def is_complete_python_code(text: str) -> bool:
    """
    Check if the text is complete, runnable Python code.
    """
    if (
        len(text.split()) == 1
        and "_" not in text
        and "(" not in text
        and ")" not in text
        and "," not in text
    ):
        return False

    try:
        compile(text, "<string>", "exec")
        return True
    except SyntaxError:
        pass

    try:
        # remove >>> and ... prompts
        text_without_prompts = re.sub(r"^>>> |^\.\.\. ", "", text, flags=re.MULTILINE)
        compile(text_without_prompts, "<string>", "exec")
        return True
    except SyntaxError:
        pass

    try:
        # remove >>> and ... prompts except the last one (might be the output)
        text_without_prompts = re.sub(r"^>>> |^\.\.\. ", "", text, flags=re.MULTILINE)
        text_without_prompts = re.sub(
            r"^>>> |^\.\.\. ", "", text_without_prompts, count=1, flags=re.MULTILINE
        )
        compile(text_without_prompts, "<string>", "exec")
        return True
    except SyntaxError:
        pass


def process_po_file(po_file):
    """Process a single PO file."""
    try:
        po = polib.pofile(po_file)
        fixed_entries = 0

        for entry in po:
            if fix_virgules_in_code(entry):
                fixed_entries += 1

        if fixed_entries > 0:
            po.save()
            print(f"Fixed {fixed_entries} entries in {po_file}")

    except Exception as e:
        print(f"Error processing {po_file}: {e}")


def collect_po_files(path):
    """
    Given a path (wildcard, file, or directory), return a list of .po files.
    """
    files = []
    if os.path.isfile(path) and path.endswith(".po"):
        files.append(path)
    elif os.path.isdir(path):
        for root, _, filenames in os.walk(path):
            for filename in filenames:
                if filename.endswith(".po"):
                    files.append(os.path.join(root, filename))
    else:
        # Handle wildcards
        for p in glob.glob(path, recursive=True):
            if os.path.isfile(p) and p.endswith(".po"):
                files.append(p)
    return files


def main(paths):
    processed_files = set()
    for path in paths:
        for po_file in collect_po_files(path):
            if po_file not in processed_files:
                process_po_file(po_file)
                processed_files.add(po_file)

    if not processed_files:
        print("No PO files found.")


if __name__ == "__main__":
    if len(sys.argv) < 2:
        print(
            "Usage: python fix_code_virgules.py "
            "<po-file|directory|glob-pattern> [additional paths...]"
        )
        sys.exit(1)
    main(sys.argv[1:])