Create meta.py

meta.py

@@ -0,0 +1,1746 @@
+import os
+import re
+import html
+import pandas as pd
+from docx import Document
+from docx.shared import Pt, Cm, Inches, RGBColor
+from docx.enum.text import WD_ALIGN_PARAGRAPH, WD_TAB_ALIGNMENT, WD_TAB_LEADER
+from docx.enum.table import WD_ALIGN_VERTICAL, WD_TABLE_ALIGNMENT
+from docx.enum.style import WD_STYLE_TYPE
+from docx.enum.section import WD_SECTION
+from docx.oxml import parse_xml
+from docx.oxml.ns import nsdecls
+from docx.oxml.shared import OxmlElement, qn
+
+
+THEME_COLOR_HEX = "5FFFDF"  # color Hex version for XML elements
+THEME_COLOR = RGBColor.from_string(THEME_COLOR_HEX)
+
+
+def set_page_size(section, width_inches, height_inches):
+    """Set custom page size for a section"""
+    sectPr = section._sectPr
+
+    # Create or get pgSz element
+    pgSz = sectPr.find(qn('w:pgSz'))
+    if pgSz is None:
+        pgSz = OxmlElement('w:pgSz')
+        sectPr.insert(0, pgSz)
+
+    # Convert inches to twentieths of a point (1 inch = 1440 twips)
+    width_twips = int(width_inches * 1440)
+    height_twips = int(height_inches * 1440)
+
+    pgSz.set(qn('w:w'), str(width_twips))
+    pgSz.set(qn('w:h'), str(height_twips))
+
+
+# Common paper sizes (width x height in inches)
+PAPER_SIZES = {
+    'LETTER': (8.5, 11),  # US Letter
+    'A4': (8.27, 11.69),  # A4
+    'A4_WIDE': (8.77, 11.69),
+    'A3': (11.69, 16.54),  # A3
+    'A5': (5.83, 8.27),  # A5
+    'LEGAL': (8.5, 14),  # US Legal
+    'TABLOID': (11, 17),  # Tabloid
+    'LEDGER': (17, 11),  # Ledger
+}
+
+
+def set_two_column_layout(doc, add_separator_line=True, balance_columns=True):
+    """Set the document to use a two-column layout with optional separator line and column balancing"""
+    # Get the current section
+    section = doc.sections[0]
+
+    # Create sectPr element if it doesn't exist
+    sectPr = section._sectPr
+
+    # Create cols element for columns
+    cols = sectPr.find(qn('w:cols'))
+    if cols is None:
+        cols = OxmlElement('w:cols')
+        sectPr.append(cols)
+
+    # Set number of columns to 2
+    cols.set(qn('w:num'), '2')
+
+    # Set space between columns (reduced for better space utilization)
+    cols.set(qn('w:space'), '432')  # 0.3 inch in twentieths of a point (was 708)
+
+    # Add separator line between columns if requested
+    if add_separator_line:
+        cols.set(qn('w:sep'), '1')  # This adds the vertical separator line
+
+    # Enable column balancing if requested
+    if balance_columns:
+        cols.set(qn('w:equalWidth'), '1')  # Equal width columns
+
+    return doc
+
+
+def set_cell_borders(cell, top=False, bottom=False, left=False, right=False):
+    """Set specific borders for a table cell"""
+    from docx.oxml import parse_xml
+    from docx.oxml.ns import nsdecls
+
+    # Get the cell's table cell properties
+    tcPr = cell._tc.get_or_add_tcPr()
+
+    # Create borders element
+    tcBorders = tcPr.find(qn('w:tcBorders'))
+    if tcBorders is None:
+        tcBorders = parse_xml(f'<w:tcBorders {nsdecls("w")}></w:tcBorders>')
+        tcPr.append(tcBorders)
+
+    # Define border settings
+    border_settings = {
+        'top': top,
+        'bottom': bottom,
+        'left': left,
+        'right': right
+    }
+
+    for border_name, should_show in border_settings.items():
+        border_element = tcBorders.find(qn(f'w:{border_name}'))
+        if border_element is not None:
+            tcBorders.remove(border_element)
+
+        if should_show:
+            # Create visible border
+            border_xml = f'<w:{border_name} {nsdecls("w")} w:val="single" w:sz="4" w:space="0" w:color="000000"/>'
+            border_element = parse_xml(border_xml)
+            tcBorders.append(border_element)
+        # If should_show is False, don't add any border element (let table-level borders show through)
+
+
+def continue_two_column_layout(doc):
+    """Continue with the existing two-column layout for answer tables"""
+    # Add a column break to start fresh in the columns
+    add_column_break(doc)
+    return doc
+
+
+def add_column_break(doc):
+    """Add a column break to move to the next column"""
+    para = doc.add_paragraph()
+    run = para.runs[0] if para.runs else para.add_run()
+
+    # Create column break element
+    br = OxmlElement('w:br')
+    br.set(qn('w:type'), 'column')
+    run._element.append(br)
+
+
+def add_page_break(doc):
+    """Add a page break to the document"""
+    doc.add_page_break()
+
+
+def create_course_title(doc, course_number, course_title, theme_color=None):
+    """Create a course title section in the document and return the paragraph object"""
+    if theme_color is None:
+        theme_color = THEME_COLOR
+
+    # Add minimal space before course title
+    course_para = doc.add_paragraph()
+    course_para.alignment = WD_ALIGN_PARAGRAPH.CENTER
+
+    # Reduce spacing before and after
+    course_para.paragraph_format.space_before = Pt(6)
+    course_para.paragraph_format.space_after = Pt(3)
+    course_para.paragraph_format.keep_with_next = True  # Keep course title with first question
+    course_para.paragraph_format.keep_together = True  # Prevent splitting within paragraph
+
+    course_run = course_para.add_run(f"{course_number}. {course_title}")
+    course_run.font.name = 'Montserrat'
+    course_run.font.size = Pt(13)
+    course_run.font.bold = True
+    course_run.font.color.rgb = None
+    course_run.font.color.rgb = theme_color
+
+    return course_para
+
+
+def format_question_block(doc, question_num, question_text, choices, correct_answers, source, comment=None, theme_color=None):
+    """Format a single question block with reduced spacing and keep together formatting"""
+    if theme_color is None:
+        theme_color = THEME_COLOR
+
+    if 'TinySpace' not in doc.styles:
+        tiny_style = doc.styles.add_style('TinySpace', WD_STYLE_TYPE.PARAGRAPH)
+        tiny_style.font.name = 'SF Pro'
+        tiny_style.font.size = Pt(5)
+        tiny_style.paragraph_format.line_spacing = Pt(5)
+        tiny_style.paragraph_format.space_before = Pt(0)
+        tiny_style.paragraph_format.space_after = Pt(0)
+
+    # Question title with reduced spacing and keep-together formatting
+    question_para = doc.add_paragraph()
+    question_para.paragraph_format.space_before = Pt(1)
+    question_para.paragraph_format.space_after = Pt(0)
+    question_para.paragraph_format.keep_with_next = True  # Keep question with choices
+    question_para.paragraph_format.keep_together = True  # Prevent splitting within paragraph
+    question_para.alignment = WD_ALIGN_PARAGRAPH.JUSTIFY
+
+    # Question number in Axiforma Black
+    num_run = question_para.add_run(f"{question_num}. ")
+    num_run.font.name = 'Inter ExtraBold'
+    num_run.font.size = Pt(10)
+    num_run.font.bold = True
+    num_run.font.color.rgb = theme_color
+
+    # Question text in SF UI Display Med
+    text_run = question_para.add_run(question_text)
+    text_run.font.name = 'Inter ExtraBold'
+    text_run.font.size = Pt(10)
+
+    # Display ALL choices for this question with minimal spacing
+    choice_paragraphs = []
+    for i, (choice_letter, choice_text) in enumerate(choices):
+        choice_para = doc.add_paragraph()
+        choice_para.alignment = WD_ALIGN_PARAGRAPH.JUSTIFY
+        choice_para.paragraph_format.space_before = Pt(1)
+        choice_para.paragraph_format.space_after = Pt(1)
+        choice_para.paragraph_format.keep_together = True  # Prevent splitting within paragraph
+
+        # Keep all choices together, and keep the last choice with the source
+        if i < len(choices) - 1:
+            choice_para.paragraph_format.keep_with_next = True
+        else:
+            # Last choice should stay with source line
+            choice_para.paragraph_format.keep_with_next = True
+
+        # Ensure each choice ends with a dot
+        if not str(choice_text).strip().endswith('.'):
+            choice_text = str(choice_text).strip() + '.'
+
+        choice_run = choice_para.add_run(f"{choice_letter}- {choice_text}")
+        choice_run.font.name = 'Inter Display Medium'
+        choice_run.font.size = Pt(10)
+
+        choice_paragraphs.append(choice_para)
+
+    # Source and Answer line
+    source_para = doc.add_paragraph()
+    source_para.alignment = WD_ALIGN_PARAGRAPH.RIGHT
+    source_para.paragraph_format.space_before = Pt(2)
+    source_para.paragraph_format.space_after = Pt(2)
+    source_para.paragraph_format.keep_together = True  # Prevent splitting within paragraph
+
+    # If there's a comment, keep source with comment
+    if comment and str(comment).strip() and str(comment).lower() != 'nan':
+        source_para.paragraph_format.keep_with_next = True
+
+    # Source
+    source_run = source_para.add_run(f"Source:")
+    source_run.font.name = 'Inter SemiBold'
+    source_run.font.size = Pt(8)
+    source_run.font.bold = True
+    source_run.font.underline = True
+
+    source_value_run = source_para.add_run(f" {source}")
+    source_value_run.font.name = 'Inter Display Medium'
+    source_value_run.font.size = Pt(8)
+    source_value_run.font.color.rgb = None
+    source_value_run.font.color.rgb = theme_color
+
+    empty_para = doc.add_paragraph(' ', style='TinySpace')
+    empty_para.paragraph_format.space_before = Pt(0)
+    empty_para.paragraph_format.space_after = Pt(0)
+    empty_para.paragraph_format.line_spacing = Pt(5)
+    empty_run = empty_para.add_run(' ')
+    empty_run.font.size = Pt(5)
+
+    # Add comment if exists
+    if comment and str(comment).strip() and str(comment).lower() != 'nan':
+        comment_para = doc.add_paragraph()
+        comment_para.paragraph_format.left_indent = Inches(0.2)
+        comment_para.paragraph_format.space_before = Pt(1)
+        comment_para.paragraph_format.space_after = Pt(2)
+        comment_para.paragraph_format.keep_together = True  # Prevent splitting within paragraph
+        # Comment is the last element, so no keep_with_next needed
+
+        comment_run = comment_para.add_run(f"Commentaire : {comment}")
+        comment_run.font.name = 'Inter Display'
+        comment_run.font.size = Pt(6)
+        comment_run.font.italic = True
+
+
+def add_page_numbers(doc, theme_hex=None):
+    """Add page numbers to the footer of all pages (keeps existing module headers), starting from page 1 after TOC."""
+    if theme_hex is None:
+        theme_hex = THEME_COLOR_HEX
+
+    for section_idx, section in enumerate(doc.sections):
+        # ===== HEADER (keep existing text like module name) =====
+        header = section.header
+        header.is_linked_to_previous = False
+        section.header_distance = Cm(0.6)
+
+        # If header is empty, add a blank paragraph
+        if not header.paragraphs:
+            header.add_paragraph()
+
+        # ===== FOOTER (page numbers + TOC link) =====
+        footer = section.footer
+        footer.is_linked_to_previous = False
+        section.footer_distance = Cm(0.5)  # Distance from bottom of page to footer
+
+        # Clear existing text in footer
+        if footer.paragraphs:
+            footer.paragraphs[0].clear()
+        else:
+            footer.add_paragraph()
+
+        # Skip page numbers for the first section (TOC)
+        if section_idx == 0:
+            continue
+
+        # For the second section (first content page), restart numbering at 1
+        if section_idx == 1:
+            sectPr = section._sectPr
+            pgNumType = sectPr.find(qn('w:pgNumType'))
+            if pgNumType is None:
+                pgNumType = OxmlElement('w:pgNumType')
+                sectPr.append(pgNumType)
+            pgNumType.set(qn('w:start'), '1')  # Start at page 1
+
+        # Add an empty line above the page number
+        empty_para = footer.paragraphs[0]
+        empty_para.paragraph_format.space_before = Pt(0)
+        empty_para.paragraph_format.space_after = Pt(0)
+        empty_para.paragraph_format.line_spacing = 1.0
+
+        # Add the page number paragraph
+        paragraph = footer.add_paragraph()
+        paragraph.alignment = WD_ALIGN_PARAGRAPH.CENTER
+
+        # Set vertical alignment to center
+        paragraph.paragraph_format.space_before = Pt(0)
+        paragraph.paragraph_format.space_after = Pt(0)
+
+        # Add page number in center
+        run = paragraph.add_run()
+
+        # Create the PAGE field
+        fldChar1 = OxmlElement('w:fldChar')
+        fldChar1.set(qn('w:fldCharType'), 'begin')
+
+        instrText = OxmlElement('w:instrText')
+        instrText.set(qn('xml:space'), 'preserve')
+        instrText.text = "PAGE"
+
+        fldChar2 = OxmlElement('w:fldChar')
+        fldChar2.set(qn('w:fldCharType'), 'end')
+
+        run._r.append(fldChar1)
+        run._r.append(instrText)
+        run._r.append(fldChar2)
+
+        run.font.name = 'Montserrat'
+        run.font.size = Pt(12)
+        run.font.bold = True
+        run.font.color.rgb = RGBColor(0, 0, 0)
+
+        # ===== ADD TOC LINK IN TEXT BOX (BOTTOM RIGHT) =====
+        # Create TOC link text box similar to header style
+        toc_textbox_xml = f'''
+        <w:r xmlns:w="http://schemas.openxmlformats.org/wordprocessingml/2006/main"
+             xmlns:v="urn:schemas-microsoft-com:vml"
+             xmlns:w10="urn:schemas-microsoft-com:office:word">
+            <w:pict>
+                <v:shape style="position:absolute;margin-left:0in;margin-top:0;width:60pt;height:20pt;z-index:1;mso-position-horizontal:right;mso-position-horizontal-relative:margin;mso-position-vertical-relative:line" fillcolor="#FFFFFF" filled="f" stroked="f">
+                    <v:textbox inset="5pt,0pt,5pt,0pt" style="mso-fit-shape-to-text:t">
+                        <w:txbxContent>
+                            <w:p>
+                                <w:pPr>
+                                    <w:jc w:val="right"/>
+                                    <w:spacing w:before="0" w:after="0"/>
+                                </w:pPr>
+                                <w:hyperlink w:anchor="TOC_BOOKMARK">
+                                    <w:r>
+                                        <w:rPr>
+                                            <w:rFonts w:ascii="Aptos" w:hAnsi="Aptos"/>
+                                            <w:sz w:val="28"/>
+                                            <w:color w:val="{theme_hex}"/>
+                                            <w:u w:val="single"/>
+                                        </w:rPr>
+                                        <w:t>↗️</w:t>
+                                    </w:r>
+                                    <w:r>
+                                        <w:rPr>
+                                            <w:rFonts w:ascii="Montserrat" w:hAnsi="Montserrat"/>
+                                            <w:b/>
+                                            <w:sz w:val="18"/>
+                                            <w:color w:val="{theme_hex}"/>
+                                            <w:u w:val="single"/>
+                                        </w:rPr>
+                                        <w:t> SOM</w:t>
+                                    </w:r>
+                                </w:hyperlink>
+                            </w:p>
+                        </w:txbxContent>
+                    </v:textbox>
+                </v:shape>
+            </w:pict>
+        </w:r>
+        '''
+
+        toc_textbox_element = parse_xml(toc_textbox_xml)
+        paragraph._p.append(toc_textbox_element)
+
+
+def add_toc_bookmark(doc, toc_title_para):
+    """Add a bookmark to the TOC title paragraph"""
+    bookmark_start = OxmlElement('w:bookmarkStart')
+    bookmark_start.set(qn('w:id'), '0')
+    bookmark_start.set(qn('w:name'), 'TOC_BOOKMARK')
+    toc_title_para._p.insert(0, bookmark_start)
+
+    bookmark_end = OxmlElement('w:bookmarkEnd')
+    bookmark_end.set(qn('w:id'), '0')
+    toc_title_para._p.append(bookmark_end)
+
+
+def set_module_header(doc, module_name):
+    """Update the top-left header text with the current module name."""
+    for section in doc.sections:
+        header = section.header
+        header.is_linked_to_previous = False
+
+        if not header.paragraphs:
+            header.add_paragraph()
+        header.paragraphs[0].clear()
+
+        para = header.paragraphs[0]
+        para.alignment = WD_ALIGN_PARAGRAPH.LEFT
+
+        run = para.add_run(f"{module_name.upper()}")
+        run.font.name = 'Montserrat'
+        run.font.size = Pt(10)
+        run.font.bold = True
+        run.font.color.rgb = RGBColor(0, 0, 0)
+
+
+def set_zero_spacing(paragraph):
+    """Force paragraph spacing to 0 before and after."""
+    paragraph.paragraph_format.space_before = Pt(0)
+    paragraph.paragraph_format.space_after = Pt(0)
+
+
+def is_valid_cours_number(cours_value):
+    """Check if cours value is valid (numeric and not 'S2')"""
+    if pd.isna(cours_value):
+        return False
+
+    cours_str = str(cours_value).strip().upper()
+
+    # Skip S2 courses and other specific invalid values
+    if cours_str in ['S2', 'NAN', '']:
+        return False
+
+    # Try to convert to numeric - if it works and is positive, it's valid
+    try:
+        numeric_value = float(cours_str)
+        # Check if it's a positive number (courses should be positive integers)
+        return numeric_value > 0 and numeric_value == int(numeric_value)
+    except (ValueError, TypeError, OverflowError):
+        return False
+
+
+def check_if_course_has_e_choices(course_questions):
+    """Check if any question in the course has an E choice"""
+    for q_data in course_questions:
+        for choice in q_data['choices']:
+            if choice['letter'].upper() == 'E':
+                return True
+    return False
+
+
+def create_answer_tables(doc, questions_by_course, cours_titles, module_name, bookmark_id, theme_color=None, theme_hex=None):
+    """Create multiple choice answer tables organized by course in two-column layout
+    Each course table is split in half with two tables side by side
+
+    Args:
+        doc: Document object
+        questions_by_course: Dictionary of questions organized by course
+        cours_titles: Dictionary of course titles
+        module_name: Name of the current module (for unique bookmarks)
+        bookmark_id: Current bookmark ID counter
+
+    Returns:
+        tuple: (updated bookmark_id, toc_entry dict)
+    """
+    if theme_color is None:
+        theme_color = THEME_COLOR
+    if theme_hex is None:
+        theme_hex = THEME_COLOR_HEX
+
+    # Continue with two-column layout for answer tables
+    continue_two_column_layout(doc)
+
+    # Add title for answer section with rounded frame
+    title_para = doc.add_paragraph()
+    title_para.alignment = WD_ALIGN_PARAGRAPH.CENTER
+    title_para.paragraph_format.space_before = Pt(12)
+    title_para.paragraph_format.space_after = Pt(8)
+
+    # Calculate width based on text length
+    response_text = "RÉPONSES"
+    text_length = len(response_text)
+    estimated_width = (text_length * 12) + 60  # Same padding as module
+
+    # Create rounded rectangle shape for RÉPONSES
+    shape_xml = f'''
+    <w:r xmlns:w="http://schemas.openxmlformats.org/wordprocessingml/2006/main"
+         xmlns:v="urn:schemas-microsoft-com:vml">
+        <w:pict>
+            <v:roundrect style="width:{estimated_width}pt;height:31pt" 
+                         arcsize="50%" fillcolor="#{theme_hex}" stroked="f">
+                <v:textbox inset="10pt,0pt,10pt,0pt" style="v-text-anchor:middle">
+                    <w:txbxContent>
+                        <w:p>
+                            <w:pPr>
+                                <w:jc w:val="center"/>
+                                <w:spacing w:before="0" w:after="0"/>
+                            </w:pPr>
+                            <w:r>
+                                <w:rPr>
+                                    <w:rFonts w:ascii="Montserrat" w:hAnsi="Montserrat"/>
+                                    <w:b/>
+                                    <w:sz w:val="35"/>
+                                    <w:color w:val="FFFFFF"/>
+                                </w:rPr>
+                                <w:t>{response_text}</w:t>
+                            </w:r>
+                        </w:p>
+                    </w:txbxContent>
+                </v:textbox>
+            </v:roundrect>
+        </w:pict>
+    </w:r>
+    '''
+
+    shape_element = parse_xml(shape_xml)
+    title_para._p.append(shape_element)
+
+    # Add bookmark to the responses section with module name
+    bm_responses_name = sanitize_bookmark_name(f"RESPONSES_{module_name}")
+    add_bookmark_to_paragraph(title_para, bm_responses_name, bookmark_id)
+
+    # Create the TOC entry information
+    toc_entry = {'level': 'responses', 'text': f"RÉPONSES - {module_name}", 'bm': bm_responses_name}
+    bookmark_id += 1
+
+    # Process each course (only valid numeric courses)
+    overall_question_number = 1
+
+    for cours_num in sorted(questions_by_course.keys()):
+        course_questions = questions_by_course[cours_num]
+        course_title = cours_titles.get(cours_num, f"COURSE {cours_num}")
+
+        # Add course title with keep_with_next
+        course_title_para = doc.add_paragraph()
+        course_title_para.alignment = WD_ALIGN_PARAGRAPH.CENTER
+        course_title_para.paragraph_format.space_before = Pt(8)
+        course_title_para.paragraph_format.space_after = Pt(4)
+        course_title_para.paragraph_format.keep_with_next = True
+        course_title_para.paragraph_format.keep_together = True
+        course_title_para.paragraph_format.page_break_before = False
+
+        # Add widow/orphan control
+        pPr = course_title_para._element.get_or_add_pPr()
+        widowControl = OxmlElement('w:widowControl')
+        widowControl.set(qn('w:val'), '1')
+        pPr.append(widowControl)
+
+        course_title_run = course_title_para.add_run(f"{cours_num}. {course_title}")
+        course_title_run.font.name = 'Montserrat'
+        course_title_run.font.size = Pt(13)
+        course_title_run.font.bold = True
+        course_title_run.font.color.rgb = theme_color
+
+        num_questions = len(course_questions)
+        if num_questions == 0:
+            continue
+
+        # Check if this course has E choices
+        has_e_choices = check_if_course_has_e_choices(course_questions)
+
+        # Determine number of columns and headers
+        if has_e_choices:
+            num_cols = 6
+            headers = ['', 'A', 'B', 'C', 'D', 'E']
+            choice_letters = ['A', 'B', 'C', 'D', 'E']
+        else:
+            num_cols = 5
+            headers = ['', 'A', 'B', 'C', 'D']
+            choice_letters = ['A', 'B', 'C', 'D']
+
+        # Split questions in half
+        mid_point = (num_questions + 1) // 2
+        first_half = course_questions[:mid_point]
+        second_half = course_questions[mid_point:]
+
+        print(f"DEBUG: Course {cours_num} - Total questions: {num_questions}, Split: {len(first_half)} + {len(second_half)}")
+
+        # Create container table
+        container_table = doc.add_table(rows=1, cols=2)
+        container_table.alignment = WD_TABLE_ALIGNMENT.CENTER
+        container_table.allow_autofit = False
+
+        # Set table properties to prevent splitting
+        tblPr = container_table._tbl.tblPr
+        if tblPr is None:
+            tblPr = OxmlElement('w:tblPr')
+            container_table._tbl.insert(0, tblPr)
+
+        cantSplit = OxmlElement('w:cantSplit')
+        tblPr.append(cantSplit)
+
+        tblPr_keepNext = parse_xml(f'<w:keepNext {nsdecls("w")} w:val="1"/>')
+
+        for row in container_table.rows:
+            for cell in row.cells:
+                tcPr = cell._tc.get_or_add_tcPr()
+                for para in cell.paragraphs:
+                    para.paragraph_format.keep_together = True
+                    para.paragraph_format.keep_with_next = True
+
+        # Set container borders to none
+        tblBorders = parse_xml(f'''
+            <w:tblBorders {nsdecls("w")}>
+                <w:top w:val="none"/>
+                <w:left w:val="none"/>
+                <w:bottom w:val="none"/>
+                <w:right w:val="none"/>
+                <w:insideH w:val="none"/>
+                <w:insideV w:val="none"/>
+            </w:tblBorders>
+        ''')
+        tblPr.append(tblBorders)
+
+        # Create tables
+        left_cell = container_table.rows[0].cells[0]
+        create_half_answer_table(left_cell, first_half, num_cols, headers, choice_letters, 1, has_e_choices)
+
+        right_cell = container_table.rows[0].cells[1]
+        create_half_answer_table(right_cell, second_half, num_cols, headers, choice_letters, mid_point + 1, has_e_choices)
+
+        # Add spacing after the container table
+        spacing_para = doc.add_paragraph()
+        spacing_para.paragraph_format.space_after = Pt(12)
+        spacing_para.paragraph_format.keep_together = True
+
+        overall_question_number += num_questions
+
+    # Return both bookmark_id and toc_entry
+    return bookmark_id, toc_entry
+
+
+def create_half_answer_table(cell, questions, num_cols, headers, choice_letters, start_q_num, has_e_choices):
+    """Create one half of an answer table inside a cell"""
+
+    if len(questions) == 0:
+        return
+
+    num_questions = len(questions)
+
+    # Fixed Q column width to match the exact measurements from the document
+    q_col_width = Inches(0.75)  # Fixed width for Q column to fit all numbers
+
+    # Create table inside the cell
+    table = cell.add_table(rows=num_questions + 1, cols=num_cols)
+    table.alignment = WD_TABLE_ALIGNMENT.CENTER
+    table.style = None
+    table.allow_autofit = False
+
+    # CRITICAL: Apply cantSplit to inner table as well
+    tblPr = table._tbl.tblPr
+    if tblPr is None:
+        tblPr = OxmlElement('w:tblPr')
+        table._tbl.insert(0, tblPr)
+
+    # Prevent table from splitting across pages
+    cantSplit = OxmlElement('w:cantSplit')
+    tblPr.append(cantSplit)
+
+    tbl = table._tbl
+    tblRows = tbl.xpath(".//w:tr")
+    if tblRows:
+        first_row = tblRows[0]
+        trPr = first_row.get_or_add_trPr()
+        tblHeader = OxmlElement('w:tblHeader')
+        trPr.append(tblHeader)
+
+        # CRITICAL: Make header row not splittable
+        cantSplit_row = OxmlElement('w:cantSplit')
+        trPr.append(cantSplit_row)
+
+    # Add table-level border
+    tblBorders = parse_xml(f'''
+        <w:tblBorders {nsdecls("w")}>
+            <w:bottom w:val="single" w:sz="4" w:space="0" w:color="000000"/>
+        </w:tblBorders>
+    ''')
+    tblPr.append(tblBorders)
+
+    # CRITICAL: Apply keep-together to all rows
+    for row_idx, row in enumerate(table.rows):
+        # Get or create row properties
+        trPr = row._tr.get_or_add_trPr()
+
+        # Add cantSplit to each row to prevent it from breaking
+        cantSplit_row = OxmlElement('w:cantSplit')
+        trPr.append(cantSplit_row)
+
+        for cell_item in row.cells:
+            for paragraph in cell_item.paragraphs:
+                paragraph.paragraph_format.keep_together = True
+                # Keep all rows together by keeping each with next
+                if row_idx < len(table.rows) - 1:
+                    paragraph.paragraph_format.keep_with_next = True
+                else:
+                    paragraph.paragraph_format.keep_with_next = False
+
+    # Set exact column widths matching the document measurements
+    choice_col_width = Inches(0.1)  # Equal width for all choice columns (A, B, C, D, E)
+
+    for row in table.rows:
+        for col_idx, cell_item in enumerate(row.cells):
+            if col_idx == 0:
+                cell_item.width = q_col_width
+            else:
+                cell_item.width = choice_col_width
+
+    # Header row
+    header_cells = table.rows[0].cells
+    for i, header in enumerate(headers):
+        header_cells[i].text = header
+        paragraph = header_cells[i].paragraphs[0]
+        set_zero_spacing(paragraph)
+        paragraph.alignment = WD_ALIGN_PARAGRAPH.CENTER
+        run = paragraph.runs[0] if paragraph.runs else paragraph.add_run(header)
+        run.font.name = 'Inter SemiBold'
+        run.font.size = Pt(11)
+        header_cells[i].vertical_alignment = WD_ALIGN_VERTICAL.CENTER
+
+        # Borders
+        if i == 0:
+            set_cell_borders(header_cells[i], top=True, bottom=True, left=True, right=False)
+        elif i == len(headers) - 1:
+            set_cell_borders(header_cells[i], top=True, bottom=True, left=False, right=True)
+        else:
+            set_cell_borders(header_cells[i], top=True, bottom=True, left=False, right=False)
+
+        # Gray shading
+        shading_elm = OxmlElement('w:shd')
+        shading_elm.set(qn('w:val'), 'clear')
+        shading_elm.set(qn('w:color'), 'auto')
+        shading_elm.set(qn('w:fill'), 'D9D9D9')
+        header_cells[i]._tc.get_or_add_tcPr().append(shading_elm)
+
+    # Fill data rows
+    for row_idx, q_data in enumerate(questions, 1):
+        row_cells = table.rows[row_idx].cells
+        is_last_row = (row_idx == num_questions)
+
+        # Question number
+        q_num = start_q_num + row_idx - 1
+        paragraph = row_cells[0].paragraphs[0]
+        paragraph.clear()
+        set_zero_spacing(paragraph)
+        paragraph.alignment = WD_ALIGN_PARAGRAPH.CENTER
+
+        run = paragraph.add_run(f"Q{q_num}")
+        run.font.name = 'Inter ExtraBold'
+        run.font.size = Pt(8)
+        run.font.bold = True
+
+        row_cells[0].vertical_alignment = WD_ALIGN_VERTICAL.CENTER
+        set_cell_borders(row_cells[0], top=False, bottom=is_last_row, left=True, right=False)
+
+        # Get correct answers and available choices
+        correct_answers = [choice['letter'] for choice in q_data['choices'] if choice['is_correct']]
+        available_choices = [choice['letter'].upper() for choice in q_data['choices']]
+        has_no_answers = len(correct_answers) == 0
+
+        # Fill choice columns
+        for i, letter in enumerate(choice_letters, 1):
+            if letter not in available_choices:
+                row_cells[i].text = ''
+            elif has_no_answers:
+                row_cells[i].text = '▨'
+            elif letter in correct_answers:
+                row_cells[i].text = '☒'
+            else:
+                row_cells[i].text = '☐'
+
+            paragraph = row_cells[i].paragraphs[0]
+            set_zero_spacing(paragraph)
+            paragraph.alignment = WD_ALIGN_PARAGRAPH.CENTER
+            if row_cells[i].text:
+                run = paragraph.runs[0] if paragraph.runs else paragraph.add_run(row_cells[i].text)
+                run.font.name = 'Calibri'
+                run.font.size = Pt(11)
+                run.font.bold = True
+            row_cells[i].vertical_alignment = WD_ALIGN_VERTICAL.CENTER
+
+            # Borders
+            if i == len(choice_letters):
+                set_cell_borders(row_cells[i], top=False, bottom=is_last_row, left=False, right=True)
+            else:
+                set_cell_borders(row_cells[i], top=False, bottom=is_last_row, left=False, right=False)
+
+
+def sanitize_bookmark_name(text):
+    """Create a safe bookmark name (letters, numbers, underscores)."""
+    name = re.sub(r'[^A-Za-z0-9_]', '_', str(text))
+    # Word has bookmark name length limits — keep it short
+    return name[:40]
+
+
+def add_bookmark_to_paragraph(paragraph, bookmark_name, bm_id):
+    """Wrap the paragraph with a Word bookmark (start & end)."""
+    # bookmarkStart: should be before the paragraph text
+    bookmark_start = OxmlElement('w:bookmarkStart')
+    bookmark_start.set(qn('w:id'), str(bm_id))
+    bookmark_start.set(qn('w:name'), bookmark_name)
+    paragraph._p.insert(0, bookmark_start)
+
+    # bookmarkEnd: appended after paragraph content
+    bookmark_end = OxmlElement('w:bookmarkEnd')
+    bookmark_end.set(qn('w:id'), str(bm_id))
+    paragraph._p.append(bookmark_end)
+
+
+def add_pagenumber_field_in_paragraph(paragraph, bookmark_name, right_inch=Inches(6.5)):
+    """
+    Insert a PAGEREF field pointing to bookmark_name.
+    This function also adds a right tab stop with dotted leader and a tab character
+    so the page number appears at the right edge with dot leaders.
+    """
+    # add a right aligned tab stop with dots
+    try:
+        paragraph.paragraph_format.tab_stops.add_tab_stop(right_inch, WD_TAB_ALIGNMENT.RIGHT, WD_TAB_LEADER.DOTS)
+    except Exception:
+        # If the tab_stop API differs, ignore and still try to insert the field
+        pass
+
+    # Add a tab character so the PAGEREF sits at the right tab stop
+    tab_run = paragraph.add_run('\t')
+
+    # Create field: begin -> instrText -> end
+    fldChar1 = OxmlElement('w:fldChar'); fldChar1.set(qn('w:fldCharType'), 'begin')
+    instrText = OxmlElement('w:instrText'); instrText.set(qn('xml:space'), 'preserve')
+    instrText.text = f"PAGEREF {bookmark_name} \\h"
+    fldChar2 = OxmlElement('w:fldChar'); fldChar2.set(qn('w:fldCharType'), 'end')
+
+    tab_run._r.append(fldChar1)
+    tab_run._r.append(instrText)
+    tab_run._r.append(fldChar2)
+
+
+
+
+def estimate_content_length(questions_by_course, cours_titles):
+    """Estimate relative content length for each question to better balance columns"""
+    question_lengths = []
+    total_estimated_lines = 0
+
+    for cours_num in sorted(questions_by_course.keys()):
+        course_questions = questions_by_course[cours_num]
+        course_title = cours_titles.get(cours_num, f"COURSE {cours_num}")
+
+        # Add course title weight (approximately 2-3 lines)
+        course_weight = 3
+        total_estimated_lines += course_weight
+
+        for q_data in course_questions:
+            # Estimate lines for this question
+            question_lines = 2  # Question line + spacing
+            question_lines += len(q_data['choices'])  # Choice lines
+            question_lines += 2  # Source/answer line + spacing
+
+            if q_data.get('comment') and str(q_data['comment']).strip() and str(q_data['comment']).lower() != 'nan':
+                question_lines += 2  # Comment lines
+
+            question_lengths.append({
+                'cours': cours_num,
+                'question': q_data,
+                'estimated_lines': question_lines
+            })
+            total_estimated_lines += question_lines
+
+    return question_lengths, total_estimated_lines
+
+
+def read_course_titles_from_module_sheet(excel_file_path, module_name):
+    """Read course titles from a module-specific sheet (case-insensitive)"""
+    cours_titles = {}
+
+    print(f"  DEBUG: Looking for sheet matching module '{module_name}'")
+
+    # Get all sheet names from the Excel file
+    xls = pd.ExcelFile(excel_file_path)
+    sheet_names = xls.sheet_names
+
+    # Find matching sheet (case-insensitive)
+    target_sheet = None
+    module_name_lower = str(module_name).strip().lower()
+
+    print(f"  DEBUG: Module name (lowercase): '{module_name_lower}'")
+    print(f"  DEBUG: Available sheets: {sheet_names}")
+
+    for sheet in sheet_names:
+        sheet_lower = sheet.strip().lower()
+        print(f"  DEBUG: Comparing '{module_name_lower}' with '{sheet_lower}'")
+        if sheet_lower == module_name_lower:
+            target_sheet = sheet
+            print(f"  DEBUG: MATCH FOUND! Using sheet '{target_sheet}'")
+            break
+
+    if target_sheet is None:
+        print(f"  DEBUG: No sheet found matching module '{module_name}'")
+        return cours_titles
+
+    # Read the matching sheet
+    cours_df = pd.read_excel(excel_file_path, sheet_name=target_sheet)
+    print(f"  DEBUG: Sheet '{target_sheet}' has {len(cours_df)} rows")
+    print(f"  DEBUG: Sheet columns: {list(cours_df.columns)}")
+
+    if not cours_df.empty and 'cours' in cours_df.columns and 'titre' in cours_df.columns:
+        for idx, row in cours_df.iterrows():
+            print(f"  DEBUG: Row {idx}: cours={row['cours']}, titre={row.get('titre', 'N/A')}")
+            if pd.notna(row['cours']) and pd.notna(row['titre']):
+                # Only store valid numeric courses
+                if is_valid_cours_number(row['cours']):
+                    cours_num = int(float(str(row['cours']).strip()))
+                    cours_titles[cours_num] = row['titre']
+                    print(f"  DEBUG: Added cours {cours_num}: {row['titre']}")
+                else:
+                    print(f"  DEBUG: Skipped invalid cours: {row['cours']}")
+        print(f"  DEBUG: Final count: {len(cours_titles)} course titles from sheet '{target_sheet}'")
+    else:
+        print(f"  DEBUG: Sheet '{target_sheet}' doesn't have expected structure")
+        print(f"  DEBUG: Has 'cours' column: {'cours' in cours_df.columns}")
+        print(f"  DEBUG: Has 'titre' column: {'titre' in cours_df.columns}")
+
+    return cours_titles
+
+
+def create_flexible_header(section, module_name, sheet_name, display_name=None, left_margin_inches=0, right_margin_inches=0, theme_hex=None):
+    """Create flexible header text boxes that adapt to content size"""
+    if theme_hex is None:
+        theme_hex = THEME_COLOR_HEX
+
+    header = section.header
+    header.is_linked_to_previous = False
+    section.header_distance = Cm(0.6)
+
+    if not header.paragraphs:
+        header.add_paragraph()
+
+    # Clear the first paragraph
+    header_para = header.paragraphs[0]
+    header_para.clear()
+
+    module_name_str = str(module_name).upper()
+
+    # Use display_name if provided, otherwise use sheet_name
+    if display_name:
+        sheet_name_str = str(display_name).upper()
+    else:
+        sheet_name_str = str(sheet_name).upper()
+
+    module_name_str = html.escape(module_name_str)
+    sheet_name_str = html.escape(sheet_name_str)
+
+    # Calculate approximate widths based on text length
+    # Rough estimate: ~7pt per character for Montserrat Bold size 10
+    module_width = max(len(module_name_str) * 9, 100)  # Minimum 60pt
+    sheet_width = max(len(sheet_name_str) * 9, 100)  # Minimum 60pt
+
+    # LEFT text box (module name) - flexible width
+    left_textbox_xml = f'''
+        <w:r xmlns:w="http://schemas.openxmlformats.org/wordprocessingml/2006/main"
+             xmlns:v="urn:schemas-microsoft-com:vml"
+             xmlns:w10="urn:schemas-microsoft-com:office:word">
+            <w:pict>
+                <v:shape style="position:absolute;margin-left:{left_margin_inches}in;margin-top:0;width:{module_width}pt;height:25pt;z-index:1;mso-position-horizontal:left;mso-position-horizontal-relative:margin;mso-position-vertical-relative:line" fillcolor="#FFFFFF" filled="f" stroked="f">
+                    <v:textbox inset="5pt,0pt,5pt,0pt" style="mso-fit-shape-to-text:t">
+                        <w:txbxContent>
+                            <w:p>
+                                <w:pPr>
+                                    <w:jc w:val="left"/>
+                                    <w:spacing w:before="0" w:after="0"/>
+                                </w:pPr>
+                                <w:r>
+                                    <w:rPr>
+                                        <w:rFonts w:ascii="Montserrat" w:hAnsi="Montserrat"/>
+                                        <w:b/>
+                                        <w:sz w:val="20"/>
+                                        <w:color w:val="{theme_hex}"/>
+                                    </w:rPr>
+                                    <w:t>{module_name_str}</w:t>
+                                </w:r>
+                            </w:p>
+                        </w:txbxContent>
+                    </v:textbox>
+                </v:shape>
+            </w:pict>
+        </w:r>
+        '''
+
+    # RIGHT text box (sheet name) - flexible width
+    right_textbox_xml = f'''
+        <w:r xmlns:w="http://schemas.openxmlformats.org/wordprocessingml/2006/main"
+             xmlns:v="urn:schemas-microsoft-com:vml"
+             xmlns:w10="urn:schemas-microsoft-com:office:word">
+            <w:pict>
+                <v:shape style="position:absolute;margin-left:{right_margin_inches}in;margin-top:0;width:{sheet_width}pt;height:25pt;z-index:1;mso-position-horizontal:right;mso-position-horizontal-relative:margin;mso-position-vertical-relative:line" fillcolor="#FFFFFF" filled="f" stroked="f">
+                    <v:textbox inset="5pt,0pt,5pt,0pt" style="mso-fit-shape-to-text:t">
+                        <w:txbxContent>
+                            <w:p>
+                                <w:pPr>
+                                    <w:jc w:val="right"/>
+                                    <w:spacing w:before="0" w:after="0"/>
+                                </w:pPr>
+                                <w:r>
+                                    <w:rPr>
+                                        <w:rFonts w:ascii="Montserrat" w:hAnsi="Montserrat"/>
+                                        <w:b/>
+                                        <w:sz w:val="20"/>
+                                        <w:color w:val="{theme_hex}"/>
+                                    </w:rPr>
+                                    <w:t>{sheet_name_str}</w:t>
+                                </w:r>
+                            </w:p>
+                        </w:txbxContent>
+                    </v:textbox>
+                </v:shape>
+            </w:pict>
+        </w:r>
+        '''
+
+    # Parse both XML elements
+    left_textbox_element = parse_xml(left_textbox_xml)
+    right_textbox_element = parse_xml(right_textbox_xml)
+
+    # Append BOTH text boxes to the SAME paragraph
+    header_para._p.append(left_textbox_element)
+    header_para._p.append(right_textbox_element)
+
+
+def extract_display_name_from_excel(excel_file_path):
+    """Extract display name from Excel file - checks multiple locations"""
+    try:
+        xls = pd.ExcelFile(excel_file_path)
+        first_sheet_name = xls.sheet_names[0]
+        df = pd.read_excel(excel_file_path, sheet_name=first_sheet_name, nrows=5)
+
+        # Strategy 1: Look for a cell with "Name:", "Display Name:", etc.
+        for col in df.columns:
+            for idx, val in df[col].items():
+                if pd.notna(val):
+                    val_str = str(val).strip().lower()
+                    if any(keyword in val_str for keyword in ['name:', 'nom:', 'display name:', 'titre:']):
+                        # Get the value from next cell or same row
+                        try:
+                            if ':' in str(val):
+                                return str(val).split(':', 1)[1].strip()
+                            elif idx + 1 < len(df):
+                                next_val = df[col].iloc[idx + 1]
+                                if pd.notna(next_val):
+                                    return str(next_val).strip()
+                        except:
+                            pass
+
+        # Strategy 2: Check for a dedicated "Info" or "Metadata" sheet
+        for sheet_name in xls.sheet_names:
+            if any(keyword in sheet_name.lower() for keyword in ['info', 'metadata', 'details', 'nom']):
+                info_df = pd.read_excel(excel_file_path, sheet_name=sheet_name, nrows=10)
+                for col in info_df.columns:
+                    for idx, val in info_df[col].items():
+                        if pd.notna(val) and 'name' in str(val).lower():
+                            if idx + 1 < len(info_df):
+                                next_val = info_df[col].iloc[idx + 1]
+                                if pd.notna(next_val):
+                                    return str(next_val).strip()
+
+        # Strategy 3: Check first cell of first sheet
+        if not df.empty and pd.notna(df.iloc[0, 0]):
+            first_cell = str(df.iloc[0, 0]).strip()
+            if len(first_cell) < 50 and not any(char.isdigit() for char in first_cell[:10]):
+                return first_cell
+
+        # Fallback: Use filename without extension
+        return os.path.splitext(os.path.basename(excel_file_path))[0]
+
+    except Exception as e:
+        print(f"Error extracting display name: {e}")
+        # Ultimate fallback
+        return os.path.splitext(os.path.basename(excel_file_path))[0]
+
+
+def process_excel_to_word(excel_file_path, output_word_path, display_name=None, use_two_columns=True, add_separator_line=True, balance_method="dynamic", theme_hex=None):
+    """Main function to process Excel and create a Word document with TOC on the first page"""
+
+    if theme_hex is None:
+        theme_hex = THEME_COLOR_HEX
+    theme_color = RGBColor.from_string(theme_hex)
+
+    # Read the Excel file
+    xls = pd.ExcelFile(excel_file_path)
+    first_sheet_name = xls.sheet_names[0]  # Get the first sheet name
+    questions_df = pd.read_excel(excel_file_path, sheet_name=first_sheet_name)
+
+    # Extract display name if not provided
+    if display_name is None:
+        display_name = extract_display_name_from_excel(excel_file_path)
+        print(f"Extracted display name: {display_name}")
+
+    # Get unique modules from Questions sheet (case-insensitive)
+    module_col = None
+    for col in questions_df.columns:
+        if col.lower().strip() == 'module':
+            module_col = col
+            break
+
+    if module_col:
+        xls_temp = pd.ExcelFile(excel_file_path)
+        all_sheets = xls_temp.sheet_names
+
+        modules_in_questions = questions_df[module_col].dropna().unique()
+
+        # Create a mapping from lowercase module name to actual sheet name
+        module_to_sheet = {}
+        for module in modules_in_questions:
+            module_lower = str(module).strip().lower()
+            for sheet in all_sheets:
+                if sheet.strip().lower() == module_lower:
+                    module_to_sheet[module] = sheet
+                    break
+
+        # Normalize all module names in the dataframe
+        questions_df[module_col] = questions_df[module_col].apply(
+            lambda x: module_to_sheet.get(x, x) if pd.notna(x) else x
+        )
+
+        # Get unique modules in sheet order
+        modules = []
+        seen = set()
+        for sheet in all_sheets:
+            sheet_lower = sheet.strip().lower()
+            for module in modules_in_questions:
+                if str(module).strip().lower() == sheet_lower and sheet not in seen:
+                    modules.append(sheet)
+                    seen.add(sheet)
+                    break
+    else:
+        modules = []
+
+    # Read course titles from module-specific sheets
+    modules_data = {}
+    xls = pd.ExcelFile(excel_file_path)
+
+    for module in modules:
+        try:
+            cours_titles_for_module = read_course_titles_from_module_sheet(excel_file_path, module)
+            modules_data[module] = cours_titles_for_module
+        except Exception as e:
+            print(f"DEBUG: Error reading module '{module}': {e}")
+
+    # Clean column names
+    questions_df.columns = questions_df.columns.str.strip()
+
+    # Create Word document
+    doc = Document()
+
+    core_props = doc.core_properties
+    core_props.author = "Natural Killer"
+    core_props.title = "Manhattan Project"
+    core_props.subject = "QCM"
+    core_props.comments = "Created By NK"
+    core_props.last_modified_by = "NK"
+    core_props.generator = "Microsoft Word"
+
+    set_page_size(doc.sections[0], PAPER_SIZES['A4_WIDE'][0], PAPER_SIZES['A4'][1])
+
+    # ========================================
+    # ADD THREE EMPTY PAGES AT THE BEGINNING
+    # ========================================
+    for i in range(4):
+        doc.add_paragraph()  # Add empty paragraph
+        if i < 3:  # Add page breaks for first 2 pages (3rd page leads to TOC)
+            doc.add_page_break()
+
+    # TOC helpers
+    toc_entries = []
+    bookmark_id = 1
+
+    # Set page margins
+    for section in doc.sections:
+        section.top_margin = Inches(0.5)
+        section.bottom_margin = Inches(0.5)
+        section.left_margin = Cm(1.27)
+        section.right_margin = Cm(1.27)
+
+    # ========================================
+    # CREATE TOC SECTION FIRST (SINGLE COLUMN)
+    # ========================================
+    toc_section = doc.sections[0]
+    sectPr = toc_section._sectPr
+    cols = sectPr.find(qn('w:cols'))
+    if cols is None:
+        cols = OxmlElement('w:cols')
+        sectPr.append(cols)
+    cols.set(qn('w:num'), '1')
+
+    # Add TOC title
+    toc_title = doc.add_paragraph()
+    toc_title.alignment = WD_ALIGN_PARAGRAPH.CENTER
+    toc_title.paragraph_format.space_after = Pt(12)
+    toc_title_run = toc_title.add_run("Sommaire")
+    toc_title_run.font.name = 'Montserrat'
+    toc_title_run.font.size = Pt(16)
+    toc_title_run.font.bold = True
+    toc_title_run.font.color.rgb = theme_color
+
+    # Add bookmark to TOC title
+    add_toc_bookmark(doc, toc_title)
+
+    # Remember position to insert TOC entries later
+    toc_insert_index = len(doc.paragraphs)
+
+    # ========================================
+    # START NEW SECTION FOR CONTENT (TWO COLUMNS)
+    # ========================================
+    doc.add_section(WD_SECTION.NEW_PAGE)
+
+    # Process questions
+    processed_questions = []
+    current_question = None
+    current_choices = []
+    skipped_s2_questions = 0
+
+    for idx, row in questions_df.iterrows():
+        numero = row['Numero']
+
+        if pd.notna(numero):
+            if current_question is not None and current_choices and is_valid_cours_number(current_cours):
+                processed_questions.append({
+                    'numero': current_question,
+                    'question_text': current_question_text,
+                    'source': current_source,
+                    'comment': current_comment,
+                    'cours': int(float(str(current_cours).strip())),
+                    'module': current_module,
+                    'choices': current_choices.copy()
+                })
+            elif current_question is not None and not is_valid_cours_number(current_cours):
+                skipped_s2_questions += 1
+
+            current_question = numero
+            current_question_text = str(row['Question']).strip()
+            current_source = str(row['Source']).strip() if pd.notna(row['Source']) else ""
+            current_comment = str(row['Comment']).strip() if pd.notna(row['Comment']) and str(
+                row['Comment']).lower() != 'nan' else None
+            current_cours = row['Cours'] if pd.notna(row['Cours']) else 1
+            current_module = row[module_col] if module_col and pd.notna(row[module_col]) else None
+            current_choices = []
+
+        if is_valid_cours_number(current_cours):
+            choice_letter = str(row['Order']).strip().upper()
+            choice_text = str(row['ChoiceText']).strip()
+            ct_value = str(row['CT']).strip().upper() if pd.notna(row['CT']) else ""
+            is_correct = ct_value == 'X'
+
+            if choice_text and choice_text.lower() != 'nan' and choice_text != '':
+                current_choices.append({
+                    'letter': choice_letter,
+                    'text': choice_text,
+                    'is_correct': is_correct
+                })
+
+    if current_question is not None and current_choices and is_valid_cours_number(current_cours):
+        processed_questions.append({
+            'numero': current_question,
+            'question_text': current_question_text,
+            'source': current_source,
+            'comment': current_comment,
+            'cours': int(float(str(current_cours).strip())),
+            'module': current_module,
+            'choices': current_choices.copy()
+        })
+    elif current_question is not None and not is_valid_cours_number(current_cours):
+        skipped_s2_questions += 1
+
+    # Group questions by module and course
+    questions_by_module = {}
+    for q_data in processed_questions:
+        module_name = q_data['module']
+        cours_num = q_data['cours']
+
+        if module_name not in questions_by_module:
+            questions_by_module[module_name] = {}
+
+        if cours_num not in questions_by_module[module_name]:
+            questions_by_module[module_name][cours_num] = []
+
+        questions_by_module[module_name][cours_num].append(q_data)
+
+    # Check for E choices
+    total_e_choices = 0
+    for module_name, questions_by_course in questions_by_module.items():
+        for cours_num, course_questions in questions_by_course.items():
+            course_e_count = sum(1 for q_data in course_questions
+                                 for choice in q_data['choices']
+                                 if choice['letter'].upper() == 'E')
+            if course_e_count > 0:
+                total_e_choices += course_e_count
+
+    # Column balancing
+    column_break_after_question = 0
+    if use_two_columns and balance_method == "dynamic":
+        total_estimated_lines = 0
+        all_question_lengths = []
+
+        for module_name in modules:
+            if module_name not in questions_by_module:
+                continue
+
+            questions_by_course = questions_by_module[module_name]
+            cours_titles = modules_data.get(module_name, {})
+
+            total_estimated_lines += 5
+            question_lengths, module_lines = estimate_content_length(questions_by_course, cours_titles)
+            total_estimated_lines += module_lines
+            all_question_lengths.extend(question_lengths)
+
+        target_lines_first_column = total_estimated_lines * 0.52
+        cumulative_lines = 0
+        global_question_counter = 0
+
+        for module_name in modules:
+            if module_name not in questions_by_module:
+                continue
+
+            cumulative_lines += 5
+            questions_by_course = questions_by_module[module_name]
+
+            for cours_num in sorted(questions_by_course.keys()):
+                cumulative_lines += 3
+                course_questions = questions_by_course[cours_num]
+
+                for q_data in course_questions:
+                    global_question_counter += 1
+
+                    for q_length in all_question_lengths:
+                        if q_length['question'] == q_data:
+                            cumulative_lines += q_length['estimated_lines']
+                            break
+
+                    if cumulative_lines >= target_lines_first_column and column_break_after_question == 0:
+                        column_break_after_question = global_question_counter
+                        break
+
+                if column_break_after_question > 0:
+                    break
+
+            if column_break_after_question > 0:
+                break
+
+    # Format questions grouped by module
+    overall_question_count = 1
+    global_question_counter = 0
+    column_break_added = False
+
+    for module_index, module_name in enumerate(modules):
+        if module_name not in questions_by_module:
+            continue
+
+        if module_index == 0:
+            section = doc.sections[-1]
+        else:
+            section = doc.add_section(WD_SECTION.NEW_PAGE)
+
+        if use_two_columns:
+            sectPr = section._sectPr
+            cols = sectPr.find(qn('w:cols'))
+            if cols is None:
+                cols = OxmlElement('w:cols')
+                sectPr.append(cols)
+            cols.set(qn('w:num'), '2')
+            cols.set(qn('w:space'), '432')
+            if add_separator_line:
+                cols.set(qn('w:sep'), '1')
+            cols.set(qn('w:equalWidth'), '1')
+
+            if use_two_columns:
+                sectPr = section._sectPr
+                cols = sectPr.find(qn('w:cols'))
+                if cols is None:
+                    cols = OxmlElement('w:cols')
+                    sectPr.append(cols)
+                cols.set(qn('w:num'), '2')
+                cols.set(qn('w:space'), '432')
+                if add_separator_line:
+                    cols.set(qn('w:sep'), '1')
+                cols.set(qn('w:equalWidth'), '1')
+
+                # Use the new flexible header function
+                create_flexible_header(section, module_name, first_sheet_name, display_name, theme_hex=theme_hex)
+
+        # ========== CUSTOMIZE MODULE TITLE APPEARANCE HERE ==========
+        MODULE_HEIGHT = 31  # Frame height in points
+        MODULE_ROUNDNESS = 50  # Corner roundness % (0=square, 50=pill)
+        MODULE_FONT_SIZE = 35  # Font size in half-points (28=14pt, 24=12pt, 32=16pt)
+        MODULE_BG_COLOR = theme_hex
+        MODULE_TEXT_COLOR = "FFFFFF"  # White text color
+        MODULE_PADDING = 60  # Extra width padding
+        # ============================================================
+
+        # Add module title as rounded shape
+        shape_para = doc.add_paragraph()
+        shape_para.alignment = WD_ALIGN_PARAGRAPH.CENTER
+        shape_para.paragraph_format.space_before = Pt(12)
+        shape_para.paragraph_format.space_after = Pt(8)
+
+        # Calculate width based on text length
+        text_length = len(module_name.upper())
+        estimated_width = (text_length * 12) + MODULE_PADDING
+        module_name_escaped = html.escape(module_name.upper())
+
+        # Create rounded rectangle shape
+        shape_xml = f'''
+        <w:r xmlns:w="http://schemas.openxmlformats.org/wordprocessingml/2006/main"
+             xmlns:v="urn:schemas-microsoft-com:vml">
+            <w:pict>
+                <v:roundrect style="width:{estimated_width}pt;height:{MODULE_HEIGHT}pt" 
+                             arcsize="{MODULE_ROUNDNESS}%" fillcolor="#{MODULE_BG_COLOR}" stroked="f">
+                    <v:textbox inset="10pt,0pt,10pt,0pt" style="v-text-anchor:middle">
+                        <w:txbxContent>
+                            <w:p>
+                                <w:pPr>
+                                    <w:jc w:val="center"/>
+                                    <w:spacing w:before="0" w:after="0"/>
+                                </w:pPr>
+                                <w:r>
+                                    <w:rPr>
+                                        <w:rFonts w:ascii="Montserrat" w:hAnsi="Montserrat"/>
+                                        <w:b/>
+                                        <w:sz w:val="{MODULE_FONT_SIZE}"/>
+                                        <w:color w:val="{MODULE_TEXT_COLOR}"/>
+                                    </w:rPr>
+                                    <w:t>{module_name_escaped}</w:t>
+                                </w:r>
+                            </w:p>
+                        </w:txbxContent>
+                    </v:textbox>
+                </v:roundrect>
+            </w:pict>
+        </w:r>
+        '''
+
+        shape_element = parse_xml(shape_xml)
+        shape_para._p.append(shape_element)
+
+        # Add bookmark
+        bm_name = sanitize_bookmark_name(f"MOD_{module_name}")
+        add_bookmark_to_paragraph(shape_para, bm_name, bookmark_id)
+        toc_entries.append({'level': 'module', 'text': f"MODULE: {module_name}", 'bm': bm_name})
+        bookmark_id += 1
+
+        questions_by_course = questions_by_module[module_name]
+        cours_titles = modules_data.get(module_name, {})
+
+        for natural_num, cours_num in enumerate(sorted(questions_by_course.keys()), start=1):
+            course_questions = questions_by_course[cours_num]
+            course_question_count = 1
+
+            course_title = cours_titles.get(cours_num, f"COURSE {cours_num}")
+            course_para = create_course_title(doc, natural_num, course_title, theme_color)
+
+            bm_course_name = sanitize_bookmark_name(f"COURSE_{module_name}_{cours_num}")
+            add_bookmark_to_paragraph(course_para, bm_course_name, bookmark_id)
+            toc_entries.append({'level': 'course', 'text': f"{natural_num}. {course_title}", 'bm': bm_course_name})
+            bookmark_id += 1
+
+            for q_data in course_questions:
+                global_question_counter += 1
+
+                if (use_two_columns and balance_method == "dynamic" and
+                        not column_break_added and global_question_counter == column_break_after_question):
+                    add_column_break(doc)
+                    column_break_added = True
+
+                choices = [(choice['letter'], choice['text']) for choice in q_data['choices']]
+                choices.sort(key=lambda x: x[0])
+
+                correct_answers = [choice['letter'] for choice in q_data['choices'] if choice['is_correct']]
+                correct_answers_str = ''.join(sorted(correct_answers))
+
+                if choices:
+                    format_question_block(
+                        doc,
+                        course_question_count,
+                        q_data['question_text'],
+                        choices,
+                        correct_answers_str,
+                        q_data['source'],
+                        q_data['comment'],
+                        theme_color
+                    )
+
+                    course_question_count += 1
+                    overall_question_count += 1
+
+        bookmark_id, responses_toc_entry = create_answer_tables(doc, questions_by_course, cours_titles, module_name, bookmark_id, theme_color, theme_hex)
+        toc_entries.append(responses_toc_entry)
+
+    # ========================================
+    # INSERT TOC ENTRIES IN THE FIRST SECTION
+    # ========================================
+    # We need to insert TOC entries in the FIRST section, before the section break
+    # Get the body element
+    body = doc._element.body
+
+    # Find where to insert - right after toc_title, before the section break
+    toc_title_element = toc_title._element
+    insert_index = list(body).index(toc_title_element) + 1
+
+    # In the TOC generation section, update the formatting code:
+
+    # Generate the TOC entries and insert them at the correct position
+    for entry in toc_entries:
+        # Create a new paragraph element
+        new_p = body.makeelement(qn('w:p'), nsmap=body.nsmap)
+
+        # Set paragraph properties
+        pPr = new_p.makeelement(qn('w:pPr'), nsmap=new_p.nsmap)
+
+        # Alignment - CENTER
+        jc = pPr.makeelement(qn('w:jc'), nsmap=pPr.nsmap)
+        jc.set(qn('w:val'), 'center')
+        pPr.append(jc)
+
+        # Set spacing
+        spacing = pPr.makeelement(qn('w:spacing'), nsmap=pPr.nsmap)
+        spacing.set(qn('w:before'), '0')
+        spacing.set(qn('w:after'), '0')
+        pPr.append(spacing)
+
+        # Add tab stops with dotted leader
+        tabs = pPr.makeelement(qn('w:tabs'), nsmap=pPr.nsmap)
+        tab = tabs.makeelement(qn('w:tab'), nsmap=tabs.nsmap)
+        tab.set(qn('w:val'), 'right')
+        tab.set(qn('w:leader'), 'dot')  # This adds the dots!
+        tab.set(qn('w:pos'), '9360')  # 6.5 inches in twentieths of a point
+        tabs.append(tab)
+        pPr.append(tabs)
+
+        # Indent course entries and responses entries
+        if entry['level'] == 'course':
+            ind = pPr.makeelement(qn('w:ind'), nsmap=pPr.nsmap)
+            ind.set(qn('w:left'), '360')  # 0.25 inches
+            pPr.append(ind)
+        elif entry['level'] == 'responses':
+            ind = pPr.makeelement(qn('w:ind'), nsmap=pPr.nsmap)
+            ind.set(qn('w:left'), '360')  # 0.25 inches - same as course
+            pPr.append(ind)
+
+        new_p.append(pPr)
+
+        # Add text run with font formatting
+        r = new_p.makeelement(qn('w:r'), nsmap=new_p.nsmap)
+
+        # Add run properties (font)
+        rPr = r.makeelement(qn('w:rPr'), nsmap=r.nsmap)
+
+        # Font family
+        rFonts = rPr.makeelement(qn('w:rFonts'), nsmap=rPr.nsmap)
+        rFonts.set(qn('w:ascii'), 'Montserrat')
+        rFonts.set(qn('w:hAnsi'), 'Montserrat')
+        rPr.append(rFonts)
+
+        # Font size and styling based on level
+        sz = rPr.makeelement(qn('w:sz'), nsmap=rPr.nsmap)
+        if entry['level'] == 'module':
+            sz.set(qn('w:val'), '22')  # 11pt
+            # Bold for module
+            b = rPr.makeelement(qn('w:b'), nsmap=rPr.nsmap)
+            rPr.append(b)
+            # Color for module
+            color = rPr.makeelement(qn('w:color'), nsmap=rPr.nsmap)
+            color.set(qn('w:val'), theme_hex)
+            rPr.append(color)
+        elif entry['level'] == 'responses':
+            sz.set(qn('w:val'), '20')  # 10pt
+            # Bold and italic for responses
+            b = rPr.makeelement(qn('w:b'), nsmap=rPr.nsmap)
+            rPr.append(b)
+            i = rPr.makeelement(qn('w:i'), nsmap=rPr.nsmap)
+            rPr.append(i)
+            # Purple color for responses to match the box
+            color = rPr.makeelement(qn('w:color'), nsmap=rPr.nsmap)
+            color.set(qn('w:val'), theme_hex)
+            rPr.append(color)
+        else:  # course level
+            sz.set(qn('w:val'), '20')  # 10pt
+        rPr.append(sz)
+
+        r.append(rPr)
+
+        # Add text
+        t = r.makeelement(qn('w:t'), nsmap=r.nsmap)
+        t.set(qn('xml:space'), 'preserve')
+        t.text = entry['text']
+        r.append(t)
+        new_p.append(r)
+
+        # Add tab run (this triggers the dotted leader)
+        r_tab = new_p.makeelement(qn('w:r'), nsmap=new_p.nsmap)
+        tab_char = r_tab.makeelement(qn('w:tab'), nsmap=r_tab.nsmap)
+        r_tab.append(tab_char)
+        new_p.append(r_tab)
+
+        # Add PAGEREF field runs
+        r_field_begin = new_p.makeelement(qn('w:r'), nsmap=new_p.nsmap)
+        fldChar1 = r_field_begin.makeelement(qn('w:fldChar'), nsmap=r_field_begin.nsmap)
+        fldChar1.set(qn('w:fldCharType'), 'begin')
+        r_field_begin.append(fldChar1)
+        new_p.append(r_field_begin)
+
+        r_instr = new_p.makeelement(qn('w:r'), nsmap=new_p.nsmap)
+        instrText = r_instr.makeelement(qn('w:instrText'), nsmap=r_instr.nsmap)
+        instrText.set(qn('xml:space'), 'preserve')
+        instrText.text = f"PAGEREF {entry['bm']} \\h"
+        r_instr.append(instrText)
+        new_p.append(r_instr)
+
+        r_field_end = new_p.makeelement(qn('w:r'), nsmap=new_p.nsmap)
+        fldChar2 = r_field_end.makeelement(qn('w:fldChar'), nsmap=r_field_end.nsmap)
+        fldChar2.set(qn('w:fldCharType'), 'end')
+        r_field_end.append(fldChar2)
+        new_p.append(r_field_end)
+
+        # Insert the paragraph at the correct position
+        body.insert(insert_index, new_p)
+        insert_index += 1  # Increment for next insertion
+
+    # Add page numbers
+    add_page_numbers(doc, theme_hex)
+
+    # Save document
+    doc.save(output_word_path)
+    print(f"\n🎉 SUCCESS: Document saved as: {output_word_path}")
+    print(f"📊 Total questions processed: {overall_question_count - 1}")
+    print(f"🚫 Total S2/invalid questions skipped: {skipped_s2_questions}")
+    if total_e_choices > 0:
+        print(f"✨ Dynamic E columns added for courses with 5-choice questions")
+
+
+def debug_excel_structure(excel_file_path):
+    """Debug function to analyze Excel structure"""
+    print("=== DEBUGGING EXCEL STRUCTURE ===")
+
+    xls = pd.ExcelFile(excel_file_path)
+    first_sheet_name = xls.sheet_names[0]  # Get the first sheet name
+    questions_df = pd.read_excel(excel_file_path, sheet_name=first_sheet_name)
+
+    print(f"Total rows: {len(questions_df)}")
+    print(f"Columns: {list(questions_df.columns)}")
+
+    # Check unique values in key columns
+    if 'Numero' in questions_df.columns:
+        try:
+            print(f"Unique Numero values: {sorted(questions_df['Numero'].dropna().unique())}")
+        except Exception as e:
+            print(f"Unique Numero values: {list(questions_df['Numero'].dropna().unique())} (couldn't sort: {e})")
+
+    if 'Order' in questions_df.columns:
+        try:
+            unique_orders = sorted(questions_df['Order'].dropna().unique())
+            print(f"Unique Order values: {unique_orders}")
+            # Check specifically for E choices
+            e_count = sum(1 for order in questions_df['Order'].dropna() if str(order).strip().upper() == 'E')
+            print(f"Total E choices found: {e_count}")
+        except Exception as e:
+            print(f"Unique Order values: {list(questions_df['Order'].dropna().unique())} (couldn't sort: {e})")
+
+    if 'Cours' in questions_df.columns:
+        unique_cours = questions_df['Cours'].dropna().unique()
+
+        # Convert all to strings first for display, then separate by validity
+        unique_cours_str = [str(c) for c in unique_cours]
+        print(f"Unique Cours values: {unique_cours_str}")
+
+        # Check which cours values are valid vs invalid
+        valid_cours = []
+        invalid_cours = []
+
+        for c in unique_cours:
+            if is_valid_cours_number(c):
+                valid_cours.append(c)
+            else:
+                invalid_cours.append(str(c))
+
+        # Sort valid ones (numeric) and invalid ones (as strings) separately
+        try:
+            valid_cours_sorted = sorted([float(c) for c in valid_cours])
+            print(f"Valid cours values: {valid_cours_sorted}")
+        except Exception:
+            print(f"Valid cours values: {valid_cours}")
+
+        try:
+            invalid_cours_sorted = sorted(invalid_cours)
+            print(f"Invalid/S2 cours values: {invalid_cours_sorted}")
+        except Exception:
+            print(f"Invalid/S2 cours values: {invalid_cours}")
+
+    # Check module column and corresponding sheets
+    if 'module' in questions_df.columns:
+        unique_modules = questions_df['module'].dropna().unique()
+        print(f"\nUnique Module values: {list(unique_modules)}")
+
+        # Check if sheets exist for each module
+        xls = pd.ExcelFile(excel_file_path)
+        sheet_names = xls.sheet_names
+        sheet_names_lower = [s.lower() for s in sheet_names]
+
+        print("\nModule sheet availability:")
+        for module in unique_modules:
+            module_lower = str(module).strip().lower()
+            if module_lower in sheet_names_lower:
+                actual_sheet = sheet_names[sheet_names_lower.index(module_lower)]
+                print(f"  ✓ Module '{module}' -> Sheet '{actual_sheet}' found")
+
+                # Try to read and show course info from this sheet
+                try:
+                    module_df = pd.read_excel(excel_file_path, sheet_name=actual_sheet)
+                    if 'cours' in module_df.columns and 'titre' in module_df.columns:
+                        print(f"    Courses in this module:")
+                        for _, row in module_df.iterrows():
+                            if pd.notna(row['cours']):
+                                print(f"      - {row['cours']}: {row.get('titre', 'N/A')}")
+                except Exception as e:
+                    print(f"    Error reading sheet: {e}")
+            else:
+                print(f"  ✗ Module '{module}' -> No matching sheet found")
+
+    # Check Cours sheet
+    try:
+        cours_df = pd.read_excel(excel_file_path, sheet_name='Cours')
+        print(f"\nCours sheet - Total rows: {len(cours_df)}")
+        print(f"Cours sheet columns: {list(cours_df.columns)}")
+        if not cours_df.empty:
+            print("Course titles:")
+            for _, row in cours_df.iterrows():
+                cours_val = row.get('cours', 'N/A')
+                is_valid = is_valid_cours_number(cours_val)
+                status = "✓" if is_valid else "✗ (SKIPPED)"
+                print(f"  Course {cours_val}: {row.get('titre', 'N/A')} {status}")
+    except Exception as e:
+        print(f"Error reading Cours sheet: {e}")