1"""
2Validator for tracked changes in Word documents.
3"""
4 
5import subprocess
6import tempfile
7import zipfile
8from pathlib import Path
9 
10 
11class RedliningValidator:
12 
13    def __init__(self, unpacked_dir, original_docx, verbose=False, author="Claude"):
14        self.unpacked_dir = Path(unpacked_dir)
15        self.original_docx = Path(original_docx)
16        self.verbose = verbose
17        self.author = author
18        self.namespaces = {
19            "w": "http://schemas.openxmlformats.org/wordprocessingml/2006/main"
20        }
21 
22    def repair(self) -> int:
23        return 0
24 
25    def validate(self):
26        modified_file = self.unpacked_dir / "word" / "document.xml"
27        if not modified_file.exists():
28            print(f"FAILED - Modified document.xml not found at {modified_file}")
29            return False
30 
31        try:
32            import xml.etree.ElementTree as ET
33 
34            tree = ET.parse(modified_file)
35            root = tree.getroot()
36 
37            del_elements = root.findall(".//w:del", self.namespaces)
38            ins_elements = root.findall(".//w:ins", self.namespaces)
39 
40            author_del_elements = [
41                elem
42                for elem in del_elements
43                if elem.get(f"{{{self.namespaces['w']}}}author") == self.author
44            ]
45            author_ins_elements = [
46                elem
47                for elem in ins_elements
48                if elem.get(f"{{{self.namespaces['w']}}}author") == self.author
49            ]
50 
51            if not author_del_elements and not author_ins_elements:
52                if self.verbose:
53                    print(f"PASSED - No tracked changes by {self.author} found.")
54                return True
55 
56        except Exception:
57            pass
58 
59        with tempfile.TemporaryDirectory() as temp_dir:
60            temp_path = Path(temp_dir)
61 
62            try:
63                with zipfile.ZipFile(self.original_docx, "r") as zip_ref:
64                    zip_ref.extractall(temp_path)
65            except Exception as e:
66                print(f"FAILED - Error unpacking original docx: {e}")
67                return False
68 
69            original_file = temp_path / "word" / "document.xml"
70            if not original_file.exists():
71                print(
72                    f"FAILED - Original document.xml not found in {self.original_docx}"
73                )
74                return False
75 
76            try:
77                import xml.etree.ElementTree as ET
78 
79                modified_tree = ET.parse(modified_file)
80                modified_root = modified_tree.getroot()
81                original_tree = ET.parse(original_file)
82                original_root = original_tree.getroot()
83            except ET.ParseError as e:
84                print(f"FAILED - Error parsing XML files: {e}")
85                return False
86 
87            self._remove_author_tracked_changes(original_root)
88            self._remove_author_tracked_changes(modified_root)
89 
90            modified_text = self._extract_text_content(modified_root)
91            original_text = self._extract_text_content(original_root)
92 
93            if modified_text != original_text:
94                error_message = self._generate_detailed_diff(
95                    original_text, modified_text
96                )
97                print(error_message)
98                return False
99 
100            if self.verbose:
101                print(f"PASSED - All changes by {self.author} are properly tracked")
102            return True
103 
104    def _generate_detailed_diff(self, original_text, modified_text):
105        error_parts = [
106            f"FAILED - Document text doesn't match after removing {self.author}'s tracked changes",
107            "",
108            "Likely causes:",
109            "  1. Modified text inside another author's <w:ins> or <w:del> tags",
110            "  2. Made edits without proper tracked changes",
111            "  3. Didn't nest <w:del> inside <w:ins> when deleting another's insertion",
112            "",
113            "For pre-redlined documents, use correct patterns:",
114            "  - To reject another's INSERTION: Nest <w:del> inside their <w:ins>",
115            "  - To restore another's DELETION: Add new <w:ins> AFTER their <w:del>",
116            "",
117        ]
118 
119        git_diff = self._get_git_word_diff(original_text, modified_text)
120        if git_diff:
121            error_parts.extend(["Differences:", "============", git_diff])
122        else:
123            error_parts.append("Unable to generate word diff (git not available)")
124 
125        return "\n".join(error_parts)
126 
127    def _get_git_word_diff(self, original_text, modified_text):
128        try:
129            with tempfile.TemporaryDirectory() as temp_dir:
130                temp_path = Path(temp_dir)
131 
132                original_file = temp_path / "original.txt"
133                modified_file = temp_path / "modified.txt"
134 
135                original_file.write_text(original_text, encoding="utf-8")
136                modified_file.write_text(modified_text, encoding="utf-8")
137 
138                result = subprocess.run(
139                    [
140                        "git",
141                        "diff",
142                        "--word-diff=plain",
143                        "--word-diff-regex=.",  
144                        "-U0",  
145                        "--no-index",
146                        str(original_file),
147                        str(modified_file),
148                    ],
149                    capture_output=True,
150                    text=True,
151                )
152 
153                if result.stdout.strip():
154                    lines = result.stdout.split("\n")
155                    content_lines = []
156                    in_content = False
157                    for line in lines:
158                        if line.startswith("@@"):
159                            in_content = True
160                            continue
161                        if in_content and line.strip():
162                            content_lines.append(line)
163 
164                    if content_lines:
165                        return "\n".join(content_lines)
166 
167                result = subprocess.run(
168                    [
169                        "git",
170                        "diff",
171                        "--word-diff=plain",
172                        "-U0",  
173                        "--no-index",
174                        str(original_file),
175                        str(modified_file),
176                    ],
177                    capture_output=True,
178                    text=True,
179                )
180 
181                if result.stdout.strip():
182                    lines = result.stdout.split("\n")
183                    content_lines = []
184                    in_content = False
185                    for line in lines:
186                        if line.startswith("@@"):
187                            in_content = True
188                            continue
189                        if in_content and line.strip():
190                            content_lines.append(line)
191                    return "\n".join(content_lines)
192 
193        except (subprocess.CalledProcessError, FileNotFoundError, Exception):
194            pass
195 
196        return None
197 
198    def _remove_author_tracked_changes(self, root):
199        ins_tag = f"{{{self.namespaces['w']}}}ins"
200        del_tag = f"{{{self.namespaces['w']}}}del"
201        author_attr = f"{{{self.namespaces['w']}}}author"
202 
203        for parent in root.iter():
204            to_remove = []
205            for child in parent:
206                if child.tag == ins_tag and child.get(author_attr) == self.author:
207                    to_remove.append(child)
208            for elem in to_remove:
209                parent.remove(elem)
210 
211        deltext_tag = f"{{{self.namespaces['w']}}}delText"
212        t_tag = f"{{{self.namespaces['w']}}}t"
213 
214        for parent in root.iter():
215            to_process = []
216            for child in parent:
217                if child.tag == del_tag and child.get(author_attr) == self.author:
218                    to_process.append((child, list(parent).index(child)))
219 
220            for del_elem, del_index in reversed(to_process):
221                for elem in del_elem.iter():
222                    if elem.tag == deltext_tag:
223                        elem.tag = t_tag
224 
225                for child in reversed(list(del_elem)):
226                    parent.insert(del_index, child)
227                parent.remove(del_elem)
228 
229    def _extract_text_content(self, root):
230        p_tag = f"{{{self.namespaces['w']}}}p"
231        t_tag = f"{{{self.namespaces['w']}}}t"
232 
233        paragraphs = []
234        for p_elem in root.findall(f".//{p_tag}"):
235            text_parts = []
236            for t_elem in p_elem.findall(f".//{t_tag}"):
237                if t_elem.text:
238                    text_parts.append(t_elem.text)
239            paragraph_text = "".join(text_parts)
240            if paragraph_text:
241                paragraphs.append(paragraph_text)
242 
243        return "\n".join(paragraphs)
244 
245 
246if __name__ == "__main__":
247    raise RuntimeError("This module should not be run directly.")
248