import argparse
import math
from docx import Document
import os
import argparse
import math
from docx import Document
import os
import spacy
import subprocess
import sys
import re




def process_word(word, ratio):
    # Calculate the number of characters to make bold
    num_chars = math.ceil(len(word) * ratio)
    
    # Split the word into the part that should be bold and the part that shouldn't
    bold_part = word[:num_chars]
    normal_part = word[num_chars:]
    
    # Create runs for the bold part and the normal part
    bold_run = (bold_part, True)
    normal_run = (normal_part, False)
    
    # Return the runs as a list
    return [bold_run, normal_run]




def process_document(doc_path, ratio):
    output_path = os.path.splitext(doc_path)[0] + '_modified.docx'

    # Check if the file path is for a .docx file
    if doc_path.endswith('.docx'):
        print("Already in docx format")
    elif doc_path.endswith('.pdf'):
        docx_path = doc_path.replace('.pdf', '.docx')
        try:
            # Run the conversion script as a subprocess
            subprocess.run([sys.executable, 'converter.py', '--pdf', doc_path, '--docx', docx_path])

            # Modify this command to run in the absolute path (with relation to this script) to converter.py
            subprocess.run([sys.executable, 'converter.py', '--pdf', doc_path, '--docx', docx_path])
            
            # Replace '.pdf' with '.docx' in the file path
            doc_path = docx_path
        except subprocess.CalledProcessError as e:
            print("Error converting PDF:", e)
            sys.exit(1)
    else:
        print("Files of this format are not supported yet")
        print("Please use either .pdf or .docx files")
        sys.exit()

    # Load the spacy model for word recognition (wrap in try-except)
    try:
        nlp = spacy.load('en_core_web_sm')
    except OSError as e:
        print("Error loading spaCy model:", e)
        sys.exit(1)

    try:
        # Open the .docx file
        word_doc = Document(doc_path)

        for paragraph in word_doc.paragraphs:
            for run in paragraph.runs:
                # Skip if the run is already bold
                if run.bold:
                    continue

                # Split the run text into words
                words = run.text.split(' ')
                words = [' ' + word if i != 0 else word for i, word in enumerate(words)]

                # Process each word
                new_runs = []
                for word in words:
                    # Use spacy to recognize the words
                    doc = nlp(word)
                    for token in doc:
                        # Bolden a ratio of the characters in the word
                        runs = process_word(token.text, ratio)
                        new_runs.extend(runs)

                # Clear the original run
                run.text = ''

                # Add new runs with the appropriate formatting
                for text, is_bold in new_runs:
                    new_run = paragraph.add_run(text)
                    new_run.bold = is_bold

        # Save the document (wrap in try-except)
        try:
            word_doc.save(output_path)
        except PermissionError as e:
            print("Error saving document:", e)
            sys.exit(1)

    except Exception as e:  # Catch any other unexpected errors
        print("Unexpected error processing document:", e)
        sys.exit(1)

    # Get the directory and filename from the input path
    dir_name, file_name = os.path.split(doc_path)

    # Prepend 'processed_' to the filename
    new_file_name = 'processed_' + file_name

    # Combine the directory and new filename to get the output path
    # output_path = os.path.splitext(doc_path)[0] + '_modified.docx'
    print(output_path)


def main():
    parser = argparse.ArgumentParser()
    parser.add_argument('doc_path', help='Path to the .docx file')
    parser.add_argument('--ratio', type=float, default=0.5, help='Ratio of characters to make bold')
    args = parser.parse_args()

    process_document(args.doc_path, args.ratio)

if __name__ == '__main__':
    main()

# def process_document(doc_path, ratio):
#     # Check if the file path is for a .docx file
#     if not doc_path.endswith('.docx'):
#         print("Invalid file format. Please provide a .docx file.")
#         return
    
#     # Load the spacy model for word recognition
#     nlp = spacy.load('en_core_web_sm')
    
#     # Open the .docx file
#     doc = Document(doc_path)

#     for paragraph in doc.paragraphs:
#         for run in paragraph.runs:
#             # Skip if the run is already bold
#             if run.bold:
#                 continue

#             # Split the run text into words
#             words = run.text.split()

#             # Process each word
#             new_runs = []
#             for word in words:
#                 # Use spacy to recognize the words
#                 doc = nlp(word)
#                 for token in doc:
#                     # Bolden a ratio of the characters in the word
#                     runs = process_word(token.text, ratio)
#                     new_runs.extend(runs)

#             # Clear the original run
#             run.text = ''

#             # Add new runs with the appropriate formatting
#             for text, is_bold in new_runs:
#                 new_run = paragraph.add_run(text)
#                 new_run.bold = is_bold


#     # Get the directory and filename from the input path
#     dir_name, file_name = os.path.split(doc_path)

#     # Prepend 'processed_' to the filename
#     new_file_name = 'processed_' + file_name

#     # Combine the directory and new filename to get the output path
#     output_path = os.path.join(dir_name, new_file_name)

#     doc.save(output_path)


# def process_word(word, ratio):
#     # Calculate the number of characters to make bold
#     num_chars = math.ceil(len(word) * ratio)
    
#     # Make the specified number of characters bold
#     bold_word = word[:num_chars] + word[num_chars:].bold()
    
#     return bold_word

# def process_document(doc_path, ratio):
#     # Check if the file path is for a .docx file
#     if not doc_path.endswith('.docx'):
#         print("Invalid file format. Please provide a .docx file.")
#         return
    
#     # Load the spacy model for word recognition
#     nlp = spacy.load('en_core_web_sm')
    
#     # Open the .docx file
#     doc = Document(doc_path)

#     for paragraph in doc.paragraphs:
#         for run in paragraph.runs:
#             # Skip if the run is already bold
#             if run.bold:
#                 continue

#             # Split the run text into words
#             words = run.text.split()

#             # Process each word
#             new_words = []
#             for word in words:
#                 # Use spacy to recognize the words
#                 doc = nlp(word)
#                 for token in doc:
#                     # Bolden a ratio of the characters in the word
#                     bold_word = process_word(token.text, ratio)
#                     new_words.append(bold_word)

#             # Replace the run text with the processed words
#             run.text = ' '.join(new_words)
#             print("processed another paragraph...")

#     # Get the directory and filename from the input path
#     dir_name, file_name = os.path.split(doc_path)

#     # Prepend 'processed_' to the filename
#     new_file_name = 'processed_' + file_name

#     # Combine the directory and new filename to get the output path
#     output_path = os.path.join(dir_name, new_file_name)

#     doc.save(output_path)


# def main():
#     parser = argparse.ArgumentParser()
#     parser.add_argument('doc_path', help='Path to the .docx file')
#     parser.add_argument('--ratio', type=float, default=0.5, help='Ratio of characters to make bold')
#     args = parser.parse_args()

#     process_document(args.doc_path, args.ratio)

# if __name__ == '__main__':
#     main()




# python bionic.py /path/to/your/document.docx 























# def process_word(word, ratio):
#     # Calculate the number of characters to make bold
#     num_bold_chars = math.ceil(len(word) * ratio)

#     # Create a new run for each part of the word
#     bold_run = word[:num_bold_chars]
#     normal_run = word[num_bold_chars:]

#     return bold_run, normal_run

# # def process_document(doc_path, ratio):
# #     doc = Document(doc_path)

# #     for paragraph in doc.paragraphs:
# #         for run in paragraph.runs:
# #             # Skip if the run is already bold
# #             if run.bold:
# #                 continue

# #             # Split the run text into words
# #             words = run.text.split()

# #             # Process each word
# #             new_words = []
# #             for word in words:
# #                 bold_run, normal_run = process_word(word, ratio)
# #                 new_words.append(bold_run)
# #                 new_words.append(normal_run)

# #             # Replace the run text with the processed words
# #             run.text = ' '.join(new_words)

# #     doc.save('processed_' + doc_path)

# # def process_document(doc_path, ratio):
# #     doc = Document(doc_path)

# #     for paragraph in doc.paragraphs:
# #         for run in paragraph.runs:
# #             # Skip if the run is already bold
# #             if run.bold:
# #                 continue

# #             # Split the run text into words
# #             words = run.text.split()

# #             # Process each word
# #             new_words = []
# #             for word in words:
# #                 bold_run, normal_run = process_word(word, ratio)
# #                 new_words.append(bold_run)
# #                 new_words.append(normal_run)

# #             # Replace the run text with the processed words
# #             run.text = ' '.join(new_words)

# #     # Get the directory and filename from the input path
# #     dir_name, file_name = os.path.split(doc_path)

# #     # Prepend 'processed_' to the filename
# #     new_file_name = 'processed_' + file_name

# #     # Combine the directory and new filename to get the output path
# #     output_path = os.path.join(dir_name, new_file_name)

# #     doc.save(output_path)

# def process_document(doc_path, ratio):
#     doc = Document(doc_path)
#     new_doc = Document()

#     for paragraph in doc.paragraphs:
#         new_paragraph = new_doc.add_paragraph()

#         for run in paragraph.runs:
#             # Skip if the run is already bold
#             if run.bold:
#                 continue

#             # Split the run text into words
#             words = run.text.split()

#             # Process each word
#             for word in words:
#                 bold_run_text, normal_run_text = process_word(word, ratio)

#                 # Add new runs to the new paragraph
#                 if bold_run_text:
#                     bold_run = new_paragraph.add_run(bold_run_text)
#                     bold_run.bold = True

#                 if normal_run_text:
#                     normal_run = new_paragraph.add_run(normal_run_text)

#     # Get the directory and filename from the input path
#     dir_name, file_name = os.path.split(doc_path)

#     # Prepend 'processed_' to the filename
#     new_file_name = 'processed_' + file_name

#     # Combine the directory and new filename to get the output path
#     output_path = os.path.join(dir_name, new_file_name)

#     new_doc.save(output_path)


# def main():
#     parser = argparse.ArgumentParser()
#     parser.add_argument('doc_path', help='Path to the .docx file')
#     parser.add_argument('--ratio', type=float, default=0.5, help='Ratio of characters to make bold')
#     args = parser.parse_args()

#     process_document(args.doc_path, args.ratio)

# if __name__ == '__main__':
#     main()