1"""
2Validator for PowerPoint presentation XML files against XSD schemas.
3"""
4 
5import re
6 
7from .base import BaseSchemaValidator
8 
9 
10class PPTXSchemaValidator(BaseSchemaValidator):
11 
12    PRESENTATIONML_NAMESPACE = (
13        "http://schemas.openxmlformats.org/presentationml/2006/main"
14    )
15 
16    ELEMENT_RELATIONSHIP_TYPES = {
17        "sldid": "slide",
18        "sldmasterid": "slidemaster",
19        "notesmasterid": "notesmaster",
20        "sldlayoutid": "slidelayout",
21        "themeid": "theme",
22        "tablestyleid": "tablestyles",
23    }
24 
25    def validate(self):
26        if not self.validate_xml():
27            return False
28 
29        all_valid = True
30        if not self.validate_namespaces():
31            all_valid = False
32 
33        if not self.validate_unique_ids():
34            all_valid = False
35 
36        if not self.validate_uuid_ids():
37            all_valid = False
38 
39        if not self.validate_file_references():
40            all_valid = False
41 
42        if not self.validate_slide_layout_ids():
43            all_valid = False
44 
45        if not self.validate_content_types():
46            all_valid = False
47 
48        if not self.validate_against_xsd():
49            all_valid = False
50 
51        if not self.validate_notes_slide_references():
52            all_valid = False
53 
54        if not self.validate_all_relationship_ids():
55            all_valid = False
56 
57        if not self.validate_no_duplicate_slide_layouts():
58            all_valid = False
59 
60        return all_valid
61 
62    def validate_uuid_ids(self):
63        import lxml.etree
64 
65        errors = []
66        uuid_pattern = re.compile(
67            r"^[\{\(]?[0-9A-Fa-f]{8}-?[0-9A-Fa-f]{4}-?[0-9A-Fa-f]{4}-?[0-9A-Fa-f]{4}-?[0-9A-Fa-f]{12}[\}\)]?$"
68        )
69 
70        for xml_file in self.xml_files:
71            try:
72                root = lxml.etree.parse(str(xml_file)).getroot()
73 
74                for elem in root.iter():
75                    for attr, value in elem.attrib.items():
76                        attr_name = attr.split("}")[-1].lower()
77                        if attr_name == "id" or attr_name.endswith("id"):
78                            if self._looks_like_uuid(value):
79                                if not uuid_pattern.match(value):
80                                    errors.append(
81                                        f"  {xml_file.relative_to(self.unpacked_dir)}: "
82                                        f"Line {elem.sourceline}: ID '{value}' appears to be a UUID but contains invalid hex characters"
83                                    )
84 
85            except (lxml.etree.XMLSyntaxError, Exception) as e:
86                errors.append(
87                    f"  {xml_file.relative_to(self.unpacked_dir)}: Error: {e}"
88                )
89 
90        if errors:
91            print(f"FAILED - Found {len(errors)} UUID ID validation errors:")
92            for error in errors:
93                print(error)
94            return False
95        else:
96            if self.verbose:
97                print("PASSED - All UUID-like IDs contain valid hex values")
98            return True
99 
100    def _looks_like_uuid(self, value):
101        clean_value = value.strip("{}()").replace("-", "")
102        return len(clean_value) == 32 and all(c.isalnum() for c in clean_value)
103 
104    def validate_slide_layout_ids(self):
105        import lxml.etree
106 
107        errors = []
108 
109        slide_masters = list(self.unpacked_dir.glob("ppt/slideMasters/*.xml"))
110 
111        if not slide_masters:
112            if self.verbose:
113                print("PASSED - No slide masters found")
114            return True
115 
116        for slide_master in slide_masters:
117            try:
118                root = lxml.etree.parse(str(slide_master)).getroot()
119 
120                rels_file = slide_master.parent / "_rels" / f"{slide_master.name}.rels"
121 
122                if not rels_file.exists():
123                    errors.append(
124                        f"  {slide_master.relative_to(self.unpacked_dir)}: "
125                        f"Missing relationships file: {rels_file.relative_to(self.unpacked_dir)}"
126                    )
127                    continue
128 
129                rels_root = lxml.etree.parse(str(rels_file)).getroot()
130 
131                valid_layout_rids = set()
132                for rel in rels_root.findall(
133                    f".//{{{self.PACKAGE_RELATIONSHIPS_NAMESPACE}}}Relationship"
134                ):
135                    rel_type = rel.get("Type", "")
136                    if "slideLayout" in rel_type:
137                        valid_layout_rids.add(rel.get("Id"))
138 
139                for sld_layout_id in root.findall(
140                    f".//{{{self.PRESENTATIONML_NAMESPACE}}}sldLayoutId"
141                ):
142                    r_id = sld_layout_id.get(
143                        f"{{{self.OFFICE_RELATIONSHIPS_NAMESPACE}}}id"
144                    )
145                    layout_id = sld_layout_id.get("id")
146 
147                    if r_id and r_id not in valid_layout_rids:
148                        errors.append(
149                            f"  {slide_master.relative_to(self.unpacked_dir)}: "
150                            f"Line {sld_layout_id.sourceline}: sldLayoutId with id='{layout_id}' "
151                            f"references r:id='{r_id}' which is not found in slide layout relationships"
152                        )
153 
154            except (lxml.etree.XMLSyntaxError, Exception) as e:
155                errors.append(
156                    f"  {slide_master.relative_to(self.unpacked_dir)}: Error: {e}"
157                )
158 
159        if errors:
160            print(f"FAILED - Found {len(errors)} slide layout ID validation errors:")
161            for error in errors:
162                print(error)
163            print(
164                "Remove invalid references or add missing slide layouts to the relationships file."
165            )
166            return False
167        else:
168            if self.verbose:
169                print("PASSED - All slide layout IDs reference valid slide layouts")
170            return True
171 
172    def validate_no_duplicate_slide_layouts(self):
173        import lxml.etree
174 
175        errors = []
176        slide_rels_files = list(self.unpacked_dir.glob("ppt/slides/_rels/*.xml.rels"))
177 
178        for rels_file in slide_rels_files:
179            try:
180                root = lxml.etree.parse(str(rels_file)).getroot()
181 
182                layout_rels = [
183                    rel
184                    for rel in root.findall(
185                        f".//{{{self.PACKAGE_RELATIONSHIPS_NAMESPACE}}}Relationship"
186                    )
187                    if "slideLayout" in rel.get("Type", "")
188                ]
189 
190                if len(layout_rels) > 1:
191                    errors.append(
192                        f"  {rels_file.relative_to(self.unpacked_dir)}: has {len(layout_rels)} slideLayout references"
193                    )
194 
195            except Exception as e:
196                errors.append(
197                    f"  {rels_file.relative_to(self.unpacked_dir)}: Error: {e}"
198                )
199 
200        if errors:
201            print("FAILED - Found slides with duplicate slideLayout references:")
202            for error in errors:
203                print(error)
204            return False
205        else:
206            if self.verbose:
207                print("PASSED - All slides have exactly one slideLayout reference")
208            return True
209 
210    def validate_notes_slide_references(self):
211        import lxml.etree
212 
213        errors = []
214        notes_slide_references = {}  
215 
216        slide_rels_files = list(self.unpacked_dir.glob("ppt/slides/_rels/*.xml.rels"))
217 
218        if not slide_rels_files:
219            if self.verbose:
220                print("PASSED - No slide relationship files found")
221            return True
222 
223        for rels_file in slide_rels_files:
224            try:
225                root = lxml.etree.parse(str(rels_file)).getroot()
226 
227                for rel in root.findall(
228                    f".//{{{self.PACKAGE_RELATIONSHIPS_NAMESPACE}}}Relationship"
229                ):
230                    rel_type = rel.get("Type", "")
231                    if "notesSlide" in rel_type:
232                        target = rel.get("Target", "")
233                        if target:
234                            normalized_target = target.replace("../", "")
235 
236                            slide_name = rels_file.stem.replace(
237                                ".xml", ""
238                            )  
239 
240                            if normalized_target not in notes_slide_references:
241                                notes_slide_references[normalized_target] = []
242                            notes_slide_references[normalized_target].append(
243                                (slide_name, rels_file)
244                            )
245 
246            except (lxml.etree.XMLSyntaxError, Exception) as e:
247                errors.append(
248                    f"  {rels_file.relative_to(self.unpacked_dir)}: Error: {e}"
249                )
250 
251        for target, references in notes_slide_references.items():
252            if len(references) > 1:
253                slide_names = [ref[0] for ref in references]
254                errors.append(
255                    f"  Notes slide '{target}' is referenced by multiple slides: {', '.join(slide_names)}"
256                )
257                for slide_name, rels_file in references:
258                    errors.append(f"    - {rels_file.relative_to(self.unpacked_dir)}")
259 
260        if errors:
261            print(
262                f"FAILED - Found {len([e for e in errors if not e.startswith('    ')])} notes slide reference validation errors:"
263            )
264            for error in errors:
265                print(error)
266            print("Each slide may optionally have its own slide file.")
267            return False
268        else:
269            if self.verbose:
270                print("PASSED - All notes slide references are unique")
271            return True
272 
273 
274if __name__ == "__main__":
275    raise RuntimeError("This module should not be run directly.")
276