filename = 'nonlin-fn-easy' # place in txt/ directory!

import re
import os
import requests
import pandas as pd

def read(file_path):
    with open(file_path, 'r', encoding='utf-8') as file:
        content = file.read()
    return content

def no_rationale(text):
    # This pattern looks for '\section*{Rationale}' and removes everything until the next '\section*{' or end of string
    text = re.sub(r'\\section\*\{Rationale\}.*?(?=\\section\*|\Z)', '', text, flags=re.DOTALL)
    return text

def fetch_ans(text):
    # Capture everything after 'Correct Answer:' until an invalid character is encountered, including whitespaces
    match = re.search(r'Correct\s*Answer:\s*([A-D0-9/.,\s-]+)', text, re.IGNORECASE)
    return match.group(1).strip() if match else None

def fetch_id(text):
    # Look for the question ID in both formats: section command and plain text
    match = re.search(r'\\section\*\{Question ID\s+(\w+)\}|ID:\s*(\w+)', text)
    if match:
        return match.group(1) or match.group(2)  # Return the matched ID from either format
    return None

def fetch_body(text, question_id):
    # Pattern to capture everything between \section*{ID: <question-id>} or ID: <question-id>
    # and the start of the choices (A., B., C., D.) or the start of the section for the answer
    pattern = rf'(\\section\*\{{ID: {question_id}\}}|ID: {question_id})\s*(.*?)(?=\s*[A-D]\.\s|\s*\\section\*\{{ID: {question_id} Answer\}}|ID: {question_id} Answer)'
    match = re.search(pattern, text, flags=re.DOTALL)
    
    if match:
        body = match.group(2).strip()  # Group 2 contains the body content
        if body.startswith('$') and not body.startswith('$$'):
            body = re.sub(r'^\$(.*?)\$', r'$$\1$$', body, count=1)            
        return body

    return None

def fetch_qtype(answer):
    # Determine if the question is a short answer or multiple-choice based on the answer format
    if re.search(r'\s*\b[a-dA-D]\b\s*', answer):  # Checks for isolated A, B, C, or D with optional surrounding spaces
        return "multi"
    else:
        return "shortanswer"  # If not, it's immediately a shortanswer

def shortanswer(question_id, question_body, answer):
    # Split answer on comma to handle multiple answers if present
    answers = answer.split(",")  # This will give a list of answers

    # Initialize the formatted string for shortanswer
    formatted = f"\\begin{{shortanswer}}[fraction=100]{{{question_id}}}\n{question_body}\n"
    
    # Add each answer as a separate item with fraction=100
    for ans in answers:
        formatted += f"\\item[fraction=100] {ans.strip()}\n"
    
    # Close the shortanswer environment and add \newpage at the end
    formatted += "\\end{shortanswer}\n\\newpage"
    
    return formatted

def choice(text):
    # Adjusted pattern to capture choices starting with A., B., C., D., without look-behind
    pattern = r'(?:^|\s)([A-D]\.\s)(.*?)(?=(?:\s[A-D]\.\s)|(?:\\section\*\{ID:)|$)'

    # Find all matches for choices
    matches = re.findall(pattern, text, flags=re.DOTALL)

    choices = []
    for _, match in matches:
        # Clean up line breaks within each choice text and strip whitespace
        choice_text = match.replace('\n', ' ').strip()
        choices.append(choice_text)
    
    return choices if choices else None

def multi(question_id, question_body, answer, choices):
    # Map answer to corresponding choice and format multiple-choice question
    answer_index = ord(answer) - ord('A')
    items = [f"\\item * {choice}" if i == answer_index else f"\\item {choice}" for i, choice in enumerate(choices)]
    formatted_items = "\n".join(items)
    
    formatted = f"""\\begin{{multi}}{{{question_id}}}
{question_body}

{formatted_items}
\\end{{multi}}
\\newpage"""  # Add \newpage at the end
    
    return formatted

def parse(text):
    text = no_rationale(text)
    question_id = fetch_id(text)
    answer = fetch_ans(text)
    question_body = fetch_body(text, question_id)
    
    # Check which part is missing and provide detailed feedback
    if not question_id:
        print("question_id"+str(question_id))
        return "Error: Unable to parse question ID."
    elif not question_body:
        return "Error: Unable to parse question body."
    elif not answer:
        return "Error: Unable to parse answer."

    question_type = fetch_qtype(answer)
    if question_type == "shortanswer":
        return shortanswer(question_id, question_body, answer)
    elif question_type == "multi":
        choices = choice(text)
        if choices and len(choices) == 4:
            return multi(question_id, question_body, answer, choices)
        else:
            return "Error: Multiple-choice question lacks choices or has an incorrect format."
    else:
        return "Error: Unknown question type or unrecognized answer format."

with open("txt/" + filename + ".txt", 'r', encoding='latin-1') as file:
    txt = file.read()   

def q_split(text):
    # Split the text by lines and initialize a list for questions
    lines = text.splitlines()
    questions = []
    current_question = []

    # Insert a marker line to handle the first question correctly
    lines.insert(0, "START")

    # Regular expression to detect "\section*{Question ID" with possible line breaks or spaces
    question_start_pattern = re.compile(r'\\section\*\{\s*Question\s+ID', re.IGNORECASE)

    for line in lines:
        # Check if the line matches the start of a question with flexible spacing/newlines
        if question_start_pattern.search(line):
            # If current_question has content, save it as a complete question
            if current_question:
                questions.append("\n".join(current_question).strip())
                current_question = []  # Reset for the next question
        # Add line to the current question content
        current_question.append(line)

    # Add any remaining question content after the loop finishes
    if current_question:
        questions.append("\n".join(current_question).strip())

    # Return all questions except the first marker
    return questions[1:]  # Skip the initial marker question

question = q_split(txt)
n = len(question)
print(n)

def section_string(text):
    # Look for standalone "ID:" not already in \section*{...}
    # Using a negative lookbehind to ensure it’s not preceded by "\section*{"
    s = re.sub(r'(?<!\\section\*\{)ID:', r'\\section*{ID:', text)
    
    return s

for i in range(n):
    question[i] = section_string(question[i])

def tabular_handling(text):
    # Define the regex pattern to match the entire tabular environment
    pattern = r'\\begin\{tabular\}.*?\\end\{tabular\}'

    # Use re.findall to get all instances of tabular environments
    tabular_instances = re.findall(pattern, text, flags=re.DOTALL)

    # Check each instance and remove it if it contains the specified string
    for tabular in tabular_instances:
        if "Assessment & Test & Domain & Skill & Difficulty" in tabular:
            text = text.replace(tabular, '')
        else:
            # Wrap tabular in \begin{center} \end{center} and \embedaspict{...}
            wrapped_tabular = f"\\begin{{center}}\n\\embedaspict{{\n{tabular}\n}}\\end{{center}}"
            text = text.replace(tabular, wrapped_tabular)
    return text.strip()

for i in range(n):
    question[i]= tabular_handling(question[i])

def bad_parse(questions):
    bad_index = []

    for i in range(n):
        # parse every question
        result = parse(questions[i])  
        # if error 
        if "Error:" in result:  
            # append the bad index i
            bad_index.append(i) 
    return bad_index

bad_questions = bad_parse(question)
print(bad_questions)

q = question[0] #debug here by question, default = 0 

q_type = fetch_qtype(q); 
q_id = fetch_id(q); 
q_parse = parse(q);  
q_ans = fetch_ans(q)
q_choices = choice(q)
q_body = fetch_body(q, q_id)

# multi only
q_format = multi(q_id, q_body, q_ans, q_choices)


### COMMENT OUT WHAT YOU DON'T NEED

print(
      "id: " + str(q_id) + "\n" + 
      "type: " + str(q_type)+ "\n" +
      "ans: "+ str(q_ans) + "\n" +
      "choices: "+ str(q_choices) + "\n---\n" +
      "body: " + "\n\n"+ str(q_body) + "\n---\n" +    
      "parse result:" + "\n\n" +str(q_parse)+ "\n==="
)

import os
import requests
import re
import shutil

directory = "TeX"+"-"+filename

if os.path.exists(directory):
    shutil.rmtree(directory)
    print(f"{directory} directory and its contents have been deleted.")
else:
    print(f"{directory} directory does not exist. Creating...")
    os.makedirs(directory) 

# Full path to the .tex file inside the "TeX" folder
tex_path = os.path.join(directory, filename + ".tex")

directory = directory +"/assets"

# Create the nested directories if they don't already exist
if not os.path.exists(directory):
    os.makedirs(directory)

def media(question, directory=directory):
    # Ensure 'question' is a string. If it's a list, process each item in the list.
    if isinstance(question, list):
        return [media(q, directory) for q in question]  # Recursively apply the function to each item
    
    # Find the image URL in the question
    matches = re.findall(r"(https://cdn\.mathpix\.com/[^\s]+?\.jpg(\?[^)]*)?)", question)
    
    result = question  # Start with the original question text
    
    for match in matches:
        url = match[0]
        
        # Extract the filename from the URL (without the date part and without underscores)
        filename = url.split('/')[-1].split('?')[0]  # e.g., "2024_11_04_a374deafc4bc3bc8f639g-10.jpg"

        # Remove the date part (everything before the first underscore)
        filename = re.sub(r'^\d{4}_\d{2}_\d{2}_', '', filename)  # Remove "2024_11_04_"
        
        # Remove underscores for LaTeX
        filename = filename.replace("_", "")
        
        # Use the directory as is (no replacement of backslashes here)
        path = directory
        
        # Escape underscores in the directory part
        path = path.replace("_", r"\_")
        
        # Combine the path and filename
        file_path = os.path.join(path, filename)
        
        # Create the directory if it does not exist
        os.makedirs(path, exist_ok=True)
        
        # Extract dimensions from the URL query parameters if they exist
        dimensions = {}
        if '?' in url:
            query_params = url.split('?')[-1]
            params = dict(re.findall(r"(\w+)=([\d]+)", query_params))
            dimensions = {
                "height": int(params.get("height", 0)),
                "width": int(params.get("width", 0)),
            }
        
        # Download and save the image
        try:
            response = requests.get(url)
            response.raise_for_status()
            
            # Save the image to the correct directory
            with open(file_path, "wb") as img_file:
                img_file.write(response.content)
            print(f"Downloaded and saved: {file_path}")
            
            # Prepare LaTeX includegraphics line
            if dimensions.get("height") and dimensions.get("width"):
                # Divide width and height by f
                f = 3
                width = dimensions['width'] / f
                height = dimensions['height'] / f

                # Replace backslashes and clean up the path format
                file_path = file_path.replace("\\", "/")  # Use forward slashes in LaTeX path
                #file_path = file_path.split('assets/', 1)[-1]
                #file_path = 'assets/' + file_path
                latex_command = f"\\includegraphics[width={width}px, height={height}px]{{{file_path}}}"
                
                # Replace the URL in the question with LaTeX command
                result = result.replace(f"![]({url})", latex_command)
            
        except requests.exceptions.RequestException as e:
            print(f"Failed to download {url}: {e}")
    
    return result

for i in range(n):
    question[i] = media(question[i])

latex = ""
for i in range(n):
    temp = parse(question[i])
    latex += temp + "\n\n"

with open(tex_path, "a") as file:
    file.write(latex)