Pptx Prep

manifest_version: "1.0"
project:
  title: "CloudBoard — Pitch Deck"
  slide_count: 10
  created: "2026-05-23"

materials:
  - field: company_logo
    type: photo
    description: "CloudBoard logo"
    used_in: [slide-1, slide-10]
    status: ready
    source: user
    confidence: verified
    path: "materials/logo.png"

  - field: product_screenshot_1
    type: photo
    description: "Main whiteboard interface"
    used_in: [slide-4]
    status: ready
    source: user
    confidence: verified
    path: "materials/screenshot-1.png"

  - field: product_screenshot_2
    type: photo
    description: "Collaboration feature"
    used_in: [slide-4]
    status: ready
    source: user
    confidence: verified
    path: "materials/screenshot-2.png"

  - field: product_screenshot_3
    type: photo
    description: "Template library"
    used_in: [slide-4]
    status: ready
    source: user
    confidence: verified
    path: "materials/screenshot-3.png"

  - field: q1_traction_data
    type: data
    description: "Q1 2026 traction metrics — users, revenue, retention"
    used_in: [slide-6]
    status: ready
    source: user
    confidence: verified
    path: "materials/traction.xlsx"
    format: currency_cny
    unit: "万元"

  - field: problem_statement
    type: text
    description: "Remote team collaboration pain points"
    used_in: [slide-2]
    status: ready
    source: ai
    confidence: needs-review

  - field: solution_description
    type: text
    description: "How CloudBoard solves the problem"
    used_in: [slide-3]
    status: ready
    source: ai
    confidence: needs-review

  - field: market_size_data
    type: data
    description: "TAM/SAM/SOM figures for collaborative tools market"
    used_in: [slide-5]
    status: ready
    source: ai
    confidence: needs-review

  - field: team_member_photos
    type: photo
    description: "Founding team headshots (3 members)"
    used_in: [slide-7]
    status: placeholder
    source: user
    confidence: placeholder
    slot:
      aspect_ratio: "1:1"

  - field: team_member_names_roles
    type: text
    description: "Founding team names and titles"
    used_in: [slide-7]
    status: placeholder
    source: user
    confidence: placeholder

  - field: competitor_logos
    type: photo
    description: "Competitor logos for comparison matrix"
    used_in: [slide-8]
    status: ready
    source: ai-search
    confidence: needs-review
    path: "materials/competitor_logos.png"

  - field: financial_projections
    type: data
    description: "3-year revenue forecast"
    used_in: [slide-9]
    status: placeholder
    source: user
    confidence: placeholder
    format: currency_cny
    unit: "万元"

  - field: ask_amount
    type: data
    description: "Funding ask amount and terms"
    used_in: [slide-10]
    status: placeholder
    source: user
    confidence: placeholder

  - field: customer_testimonials
    type: text
    description: "Quotes from beta users"
    used_in: [slide-6]
    status: placeholder
    source: user
    confidence: placeholder

summary:
  total: 14
  ready: 9
  missing: 0
  ai_fill: 0
  placeholder: 5
  needs_review: 4

manifest_version: "1.0"
project:
  title: "Lu Hong — English Group Presentation"
  slide_count: 7
  created: "2026-05-23"

materials:
  - field: group_member_names
    type: text
    description: "小组成员姓名"
    used_in: [slide-1]
    status: ready
    source: user
    confidence: verified
    path: "provided in conversation"

  - field: lu_hong_portrait
    type: photo
    description: "陆鸿本人肖像照"
    used_in: [slide-2]
    status: ready
    source: user
    confidence: verified
    path: "materials/lu_hong.jpg"
    slot:
      aspect_ratio: "4:3"
      width_inches: 6
      height_inches: 4.5
    warnings:
      - type: aspect_mismatch
        message: "Photo is 1:1. User chose 'cover' fill mode — top/bottom will crop."

  - field: lu_hong_award_photo
    type: photo
    description: "陆鸿获奖现场照片"
    used_in: [slide-5]
    status: placeholder
    source: user
    confidence: placeholder
    slot:
      aspect_ratio: "16:9"

  - field: lu_hong_story_text
    type: text
    description: "陆鸿生平故事 (from tips.txt)"
    used_in: [slide-2, slide-3, slide-4]
    status: ready
    source: user
    confidence: verified
    path: "tips.txt"

  - field: career_timeline_dates
    type: data
    description: "陆鸿职业生涯关键日期"
    used_in: [slide-3]
    status: ready
    source: user
    confidence: verified
    path: "extracted from tips.txt"

  - field: achievement_list
    type: text
    description: "陆鸿主要成就列表"
    used_in: [slide-4]
    status: ready
    source: ai
    confidence: needs-review
    warnings:
      - type: overflow
        message: "Content ~280 chars, slot capacity ~150. AI will auto-adjust font size."

  - field: group_project_details
    type: text
    description: "英语小组项目信息"
    used_in: [slide-7]
    status: ready
    source: ai
    confidence: needs-review

  - field: contact_info
    type: text
    description: "小组成员联系方式"
    used_in: [slide-7]
    status: placeholder
    source: user
    confidence: placeholder

summary:
  total: 8
  ready: 6
  missing: 0
  ai_fill: 0
  placeholder: 2
  needs_review: 2

{
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "$id": "https://github.com/pptx-prep/manifest.schema.json",
  "title": "PPTx Material Manifest",
  "description": "Schema for the pptx-prep material manifest. Records all materials needed for a presentation, their sources, status, and slot constraints.",
  "type": "object",
  "required": ["manifest_version", "project", "materials", "summary"],
  "properties": {
    "manifest_version": {
      "type": "string",
      "description": "Version of the manifest format",
      "enum": ["1.0"]
    },
    "project": {
      "type": "object",
      "required": ["title", "slide_count"],
      "properties": {
        "title": {
          "type": "string",
          "description": "Presentation title"
        },
        "slide_count": {
          "type": "integer",
          "minimum": 1
        },
        "created": {
          "type": "string",
          "format": "date",
          "description": "ISO date when manifest was created"
        }
      }
    },
    "materials": {
      "type": "array",
      "items": {
        "type": "object",
        "required": ["field", "type", "description", "used_in", "status", "source", "confidence"],
        "properties": {
          "field": {
            "type": "string",
            "description": "Unique key for this material — also used as filename (without extension) when user provides a file"
          },
          "type": {
            "type": "string",
            "enum": ["photo", "text", "data", "branding", "reference"],
            "description": "Material type"
          },
          "description": {
            "type": "string",
            "description": "Human-readable description of what this material is. Used for auto-matching user files."
          },
          "used_in": {
            "type": "array",
            "minItems": 1,
            "items": {
              "type": "string",
              "pattern": "^slide-\\d+$"
            },
            "description": "Which slides this material appears on"
          },
          "status": {
            "type": "string",
            "enum": ["ready", "placeholder"],
            "description": "ready = material resolved; placeholder = user chose to leave empty. Note: ai-fill and missing are intermediate workflow states, resolved before final manifest."
          },
          "source": {
            "type": "string",
            "enum": ["ai", "ai-search", "ai-generated", "user"],
            "description": "Who provided the content. ai=text generated by LLM, ai-search=image found by web search, ai-generated=image created by AI generation tool, user=provided by user"
          },
          "confidence": {
            "type": "string",
            "enum": ["verified", "needs-review", "placeholder"],
            "description": "verified = confirmed correct; needs-review = AI-generated, user should check; placeholder = empty slot"
          },
          "path": {
            "type": "string",
            "description": "File path relative to project root, when status is 'ready'"
          },
          "format": {
            "type": "string",
            "description": "For data type: currency_cny, percentage, integer, plain_text",
            "enum": ["currency_cny", "percentage", "integer", "plain_text"]
          },
          "unit": {
            "type": "string",
            "description": "Unit label for data values (e.g., '万元', '%')"
          },
          "slot": {
            "type": "object",
            "description": "Layout slot constraints — present when the slide design imposes specific dimensions",
            "properties": {
              "aspect_ratio": {
                "type": "string",
                "pattern": "^\\d+:\\d+$",
                "examples": ["16:9", "4:3", "1:1"]
              },
              "width_inches": {
                "type": "number"
              },
              "height_inches": {
                "type": "number"
              },
              "fill_mode": {
                "type": "string",
                "enum": ["contain", "cover"],
                "description": "User's choice for fitting photo to slot"
              },
              "estimated_capacity": {
                "type": "integer",
                "description": "Rough character capacity for text slots"
              }
            }
          },
          "warnings": {
            "type": "array",
            "items": {
              "type": "object",
              "properties": {
                "type": {
                  "type": "string",
                  "enum": ["overflow", "low_quality", "aspect_mismatch", "wrong_type"]
                },
                "message": {
                  "type": "string"
                }
              }
            }
          }
        }
      }
    },
    "summary": {
      "type": "object",
      "required": ["total", "ready", "placeholder", "needs_review"],
      "properties": {
        "total": { "type": "integer" },
        "ready": { "type": "integer" },
        "placeholder": { "type": "integer" },
        "needs_review": { "type": "integer" }
      }
    }
  }
}

{
  "schema_version": "2.0",
  "meta": {
    "generated_at": "2026-05-23T09:19:41.763Z",
    "slug": "xiaomengbi520-pptx-prep",
    "source_url": "https://github.com/xiaomengbi520/pptx-prep/tree/main/",
    "source_ref": "main",
    "model": "claude",
    "analysis_version": "3.0.0",
    "source_type": "community",
    "content_hash": "89533b7f9e6601066e19e4b37109717e5c0a10a958c762c112dbbc300c5c0568",
    "tree_hash": "a784020e6cebd7d867fec2e1a53d1eaeebbd9eb473dd1bae03df65ed5f4eee75"
  },
  "skill": {
    "name": "pptx-prep",
    "description": "Materials pre-check before any PPTX generation. Analyzes presentation requirements to identify human-dependent materials such as names, photos, logos, data, and statistics that AI cannot invent. Collects all materials upfront or confirms skip decisions, eliminating rework.",
    "summary": "Pre-checks presentation requirements and collects missing materials before PPTX generation to prevent AI from inventing false content.",
    "icon": "📦",
    "version": "1.0.0",
    "author": "xiaomengbi520",
    "license": "MIT",
    "category": "office",
    "tags": [
      "presentation",
      "ppt",
      "slides",
      "material-check",
      "workflow"
    ],
    "supported_tools": [
      "claude",
      "codex",
      "claude-code"
    ],
    "risk_factors": [
      "external_commands",
      "network",
      "filesystem"
    ]
  },
  "security_audit": {
    "risk_level": "low",
    "is_blocked": false,
    "safe_to_publish": true,
    "summary": "All 199 static analysis findings are false positives. The skill is a documentation-based workflow for PPTX material pre-check with no runtime code execution. The 'weak cryptographic algorithm' flags match normal JSON/YAML keys, URLs, and markdown text. 'external_commands' findings are shell command examples in README documentation. 'network' findings are documentation URLs and JSON Schema references. No malicious intent, obfuscation, or prompt injection detected. The validate.py is a standard file format validator with no dangerous operations.",
    "risk_factor_evidence": [
      {
        "factor": "external_commands",
        "evidence": [
          {
            "file": "README.md",
            "line_start": 46,
            "line_end": 48
          },
          {
            "file": "README.md",
            "line_start": 109,
            "line_end": 112
          }
        ]
      },
      {
        "factor": "network",
        "evidence": [
          {
            "file": "manifest.schema.json",
            "line_start": 2,
            "line_end": 3
          },
          {
            "file": "README.md",
            "line_start": 7,
            "line_end": 9
          }
        ]
      },
      {
        "factor": "filesystem",
        "evidence": [
          {
            "file": "README.md",
            "line_start": 48,
            "line_end": 48
          }
        ]
      }
    ],
    "critical_findings": [],
    "high_findings": [],
    "medium_findings": [],
    "low_findings": [
      {
        "title": "Documentation Shell Command Examples",
        "description": "README files contain shell command examples (git clone, cp, python) used for installation instructions. These are documentation code blocks, not executable code. The skill has no runtime that executes external commands.",
        "locations": [
          {
            "file": "README.md",
            "line_start": 46,
            "line_end": 48
          },
          {
            "file": "SKILL.md",
            "line_start": 28,
            "line_end": 35
          },
          {
            "file": "validate.py",
            "line_start": 3,
            "line_end": 3
          }
        ],
        "confidence": 0.15,
        "confidence_reasoning": "Shell commands only appear in markdown code blocks and documentation, not in any executable script. The skill's only executable file (validate.py) does not call any shell commands."
      },
      {
        "title": "Documentation URLs in README and Schema",
        "description": "URLs found in README badge links, repository references, and JSON Schema $schema/$id fields. These are documentation references, not runtime network calls.",
        "locations": [
          {
            "file": "manifest.schema.json",
            "line_start": 2,
            "line_end": 3
          },
          {
            "file": "README.md",
            "line_start": 7,
            "line_end": 9
          }
        ],
        "confidence": 0.1,
        "confidence_reasoning": "All URLs are README badge links (shields.io), GitHub repository links, and JSON Schema identifiers. No runtime network requests are made."
      },
      {
        "title": "Hidden File Path in Installation Instructions",
        "description": "README shows installation path ~/.claude/skills/pptx-prep in a code example. This documents the standard Claude Code skills installation directory.",
        "locations": [
          {
            "file": "README.md",
            "line_start": 48,
            "line_end": 48
          }
        ],
        "confidence": 0.05,
        "confidence_reasoning": "Path appears in a markdown code block as installation documentation. The skill does not read or write to hidden directories at runtime."
      },
      {
        "title": "Static Analyzer Cryptographic False Positives",
        "description": "Static analyzer flagged 87+ locations for 'weak cryptographic algorithm' on normal JSON keys, YAML values, URLs, markdown text, and Python identifiers. Examples include 'manifest_version', 'photo', 'text', logo.png, '1:1', GitHub URLs, and Python constant names like 'VALID_STATUSES'. None of these are cryptographic content.",
        "locations": [
          {
            "file": "manifest.schema.json",
            "line_start": 5,
            "line_end": 5
          },
          {
            "file": "SKILL.md",
            "line_start": 3,
            "line_end": 3
          },
          {
            "file": "validate.py",
            "line_start": 24,
            "line_end": 24
          }
        ],
        "confidence": 0.02,
        "confidence_reasoning": "The scanner shows systematic false positives by flagging normal JSON/YAML schema property names, enum values, documentation URLs, file paths, and Python identifiers as 'cryptographic content'. This is a known scanner limitation with schema/documentation files."
      },
      {
        "title": "Entropy-based Obfuscation False Positives",
        "description": "Static analyzer flagged high file entropy on README.md, README_CN.md, and SKILL.md due to mixed Chinese/English content, YAML front matter, and HTML tags. The 'DANGEROUS COMBINATION' meta-finding aggregates these false positives. No actual obfuscation or encoded payloads exist.",
        "locations": [
          {
            "file": "README.md",
            "line_start": 1,
            "line_end": 1
          },
          {
            "file": "SKILL.md",
            "line_start": 1,
            "line_end": 1
          }
        ],
        "confidence": 0.05,
        "confidence_reasoning": "High entropy is caused by bilingual markdown content (Chinese + English), HTML alignment tags, and YAML front matter delimiters. This is normal for well-documented multilingual skills, not obfuscation."
      }
    ],
    "dangerous_patterns": [],
    "files_scanned": 16,
    "total_lines": 1789,
    "audit_model": "claude",
    "audited_at": "2026-05-23T09:19:41.763Z"
  },
  "content": {
    "user_title": "Run a materials pre-check before making any presentation",
    "value_statement": "Presentations fail when AI invents fake names, photos, and data. This skill scans your slide requirements and identifies every material that needs real human input before generation starts.",
    "seo_keywords": [
      "PPT pre-check",
      "presentation materials",
      "slide preparation",
      "Claude",
      "Codex",
      "Claude Code",
      "PPTX workflow",
      "content validation",
      "presentation skill",
      "AI presentation prep"
    ],
    "actual_capabilities": [
      "Analyzes slide structure by asking targeted questions when no outline is provided",
      "Scans each slide against 5 material categories: personal info, visuals, data, branding, and external references",
      "Marks each material as ready, needs-supplement, or needs-verification with clear icons",
      "Collects user-provided files into a materials folder and auto-matches them to slide slots by content analysis",
      "Performs quality checks on photos (minimum resolution, aspect ratio matching) with instant A/B/C resolution options",
      "Outputs a structured manifest.yml for downstream PPTX generation tools"
    ],
    "limitations": [
      "Does not generate or edit PowerPoint files. A separate PPTX generation skill or tool is required.",
      "Cannot verify the accuracy of user-provided data or detect factual errors in supplied materials.",
      "Aspect ratio and overflow checks apply only to materials the user provides during the workflow.",
      "Requires the user to actively supply missing materials or make skip decisions for each gap."
    ],
    "use_cases": [
      {
        "title": "Team presentation preparation",
        "description": "A manager needs a 7-page team introduction PPT. This skill identifies all missing materials like team photos, member names, and achievement data before the first slide is generated.",
        "target_user": "Business users preparing team or department presentations"
      },
      {
        "title": "Investor pitch deck creation",
        "description": "A founder preparing a fundraising deck uses this skill to list required materials: logo, product screenshots, financial projections, and market data. The skill flags what the founder must provide versus what AI can draft.",
        "target_user": "Startup founders and entrepreneurs"
      },
      {
        "title": "Educational slide production",
        "description": "A teacher creating tutorial slides runs this skill to verify all diagrams, examples, and reference materials are ready before asking AI to generate the presentation.",
        "target_user": "Educators and instructional designers"
      }
    ],
    "prompt_templates": [
      {
        "title": "Basic slide material check",
        "prompt": "I need to create a presentation about [topic]. Please run a material pre-check to identify what information and files I need to provide before the slides can be generated.",
        "scenario": "Starting a new presentation project with no prior preparation"
      },
      {
        "title": "Detailed outline with materials",
        "prompt": "Here is my 10-page outline for a presentation on [topic]. I have my company logo and some product screenshots ready. Please check each slide and tell me exactly what materials are still missing.",
        "scenario": "User has a clear outline and some materials ready"
      },
      {
        "title": "Missing material resolution",
        "prompt": "I do not have a team photo for slide 3 or revenue data for slide 7. Please help me find alternatives: search for a suitable image and let me know what placeholder to use for the data.",
        "scenario": "User has gaps and needs AI-assisted resolution like image search or placeholder options"
      },
      {
        "title": "Pre-flight check before handoff",
        "prompt": "I have placed all my files in the materials folder. Please scan the directory, match each file to the correct slide slot, run quality checks, and prepare the manifest for the PPTX generation tool.",
        "scenario": "All materials collected, ready for final quality check and handoff"
      }
    ],
    "output_examples": [
      {
        "input": "Create a 5-page company overview presentation about our product launch.",
        "output": [
          "## Material Scan",
          "",
          "| Slide | Material | Type | Status |",
          "|-------|----------|------|--------|",
          "| 1 Cover | Title text | Text | Ready |",
          "| 1 Cover | Cover photo | Photo | Needs supplement |",
          "| 2 About | Company description | Text | Needs verification |",
          "| 3 Product | Product screenshot | Photo | Needs supplement |",
          "| 4 Data | Launch metrics | Data | Needs supplement |",
          "| 5 Contact | Contact info | Text | Ready |",
          "",
          "Warning: Over 50% of materials are missing. AI will need to invent significant content. Recommend providing core materials first."
        ]
      },
      {
        "input": "I have placed my logo.png and team-photo.jpg in the materials folder. Please check and prepare the manifest.",
        "output": [
          "Auto-matching results:",
          "| Slot | File | Reason |",
          "|------|------|--------|",
          "| Slide 1 Logo | logo.png | Graphic with company colors |",
          "| Slide 3 Team | team-photo.jpg | Group portrait, landscape |",
          "",
          "All matches successful. Manifest ready for handoff."
        ]
      }
    ],
    "best_practices": [
      "Place all presentation materials in a single materials folder before running the pre-check to speed up the matching process.",
      "Review AI-generated content marked as needs-verification carefully, especially names, dates, and numerical data.",
      "Run the pre-check at the start of each new presentation project, even if you think you have all materials ready."
    ],
    "anti_patterns": [
      "Skipping the pre-check and asking AI to generate slides directly, which leads to invented names, fake photos, and incorrect data.",
      "Providing vague descriptions like 'some pictures' instead of specific file names, which prevents accurate auto-matching.",
      "Ignoring aspect ratio warnings for photos, resulting in distorted or cropped images in the final output."
    ],
    "faq": [
      {
        "question": "Does this skill generate PowerPoint files?",
        "answer": "No. This skill only performs materials pre-check. A separate PPTX generation skill or tool is needed to create the actual slides."
      },
      {
        "question": "Can I use this skill with ChatGPT or other AI tools?",
        "answer": "Yes. Copy the prompt from the prompts/universal.md file and paste it at the start of your conversation with any AI chat tool."
      },
      {
        "question": "What happens if I do not have all the materials?",
        "answer": "You can choose to skip missing items (placeholders), let AI search for real images, let AI generate illustrations, or provide files later."
      },
      {
        "question": "How does the skill match my files to slide slots?",
        "answer": "It analyzes file content, reads filenames for signals, and compares against material descriptions to auto-match. You can correct any wrong matches."
      },
      {
        "question": "What is the manifest.yml file?",
        "answer": "It is a structured list of all materials with their status, source, and slot constraints. Downstream PPTX tools read this file to generate slides correctly."
      },
      {
        "question": "Do I need to provide all materials before the skill works?",
        "answer": "No. Start with just your idea or outline. The skill will guide you through identifying and collecting each missing piece step by step."
      }
    ]
  },
  "file_structure": [
    {
      "name": "examples",
      "type": "dir",
      "path": "examples",
      "children": [
        {
          "name": "scenario-pitch",
          "type": "dir",
          "path": "examples/scenario-pitch",
          "children": [
            {
              "name": "manifest.yml",
              "type": "file",
              "path": "examples/scenario-pitch/manifest.yml",
              "lines": 139
            },
            {
              "name": "request.md",
              "type": "file",
              "path": "examples/scenario-pitch/request.md",
              "lines": 26
            }
          ]
        },
        {
          "name": "scenario-team",
          "type": "dir",
          "path": "examples/scenario-team",
          "children": [
            {
              "name": "bad-output.md",
              "type": "file",
              "path": "examples/scenario-team/bad-output.md",
              "lines": 36
            },
            {
              "name": "manifest.yml",
              "type": "file",
              "path": "examples/scenario-team/manifest.yml",
              "lines": 95
            },
            {
              "name": "README.md",
              "type": "file",
              "path": "examples/scenario-team/README.md",
              "lines": 24
            },
            {
              "name": "request.md",
              "type": "file",
              "path": "examples/scenario-team/request.md",
              "lines": 13
            }
          ]
        }
      ]
    },
    {
      "name": "prompts",
      "type": "dir",
      "path": "prompts",
      "children": [
        {
          "name": "chatgpt.md",
          "type": "file",
          "path": "prompts/chatgpt.md",
          "lines": 71
        },
        {
          "name": "system-prompt.md",
          "type": "file",
          "path": "prompts/system-prompt.md",
          "lines": 54
        },
        {
          "name": "universal.md",
          "type": "file",
          "path": "prompts/universal.md",
          "lines": 88
        }
      ]
    },
    {
      "name": "manifest.schema.json",
      "type": "file",
      "path": "manifest.schema.json",
      "lines": 145
    },
    {
      "name": "PLACEHOLDER_SPEC.md",
      "type": "file",
      "path": "PLACEHOLDER_SPEC.md",
      "lines": 72
    },
    {
      "name": "README_CN.md",
      "type": "file",
      "path": "README_CN.md",
      "lines": 156
    },
    {
      "name": "README.md",
      "type": "file",
      "path": "README.md",
      "lines": 157
    },
    {
      "name": "SKILL.md",
      "type": "file",
      "path": "SKILL.md",
      "lines": 313
    },
    {
      "name": "validate.py",
      "type": "file",
      "path": "validate.py",
      "lines": 394
    }
  ]
}

"""Validate a pptx-prep manifest file.

Usage: python validate.py <manifest_file>

Supports both YAML (.yml/.yaml) and JSON (.json) files.
YAML parsing is built in — no external dependencies required.
For YAML: uses full-featured pyyaml if available; otherwise falls back to
the built-in minimal parser which handles the pptx-prep manifest subset.

Exit code: 0 = valid, 1 = validation errors found.
"""

import json
import re
import sys
from pathlib import Path


VALID_STATUSES = {"ready", "placeholder"}
VALID_SOURCES = {"ai", "ai-search", "ai-generated", "user"}
VALID_CONFIDENCES = {"verified", "needs-review", "placeholder"}
VALID_TYPES = {"photo", "text", "data", "branding", "reference"}
VALID_FORMATS = {"currency_cny", "percentage", "integer", "plain_text"}
VALID_FILL_MODES = {"contain", "cover"}
VALID_WARNING_TYPES = {"overflow", "low_quality", "aspect_mismatch", "wrong_type"}


def load_manifest(path: Path) -> dict | None:
    """Load manifest from YAML or JSON file."""
    suffix = path.suffix.lower()

    if suffix in (".yml", ".yaml"):
        try:
            import yaml
            with open(path, encoding="utf-8") as f:
                return yaml.safe_load(f)
        except ImportError:
            pass

        with open(path, encoding="utf-8") as f:
            content = f.read()

        manifest = _parse_yaml(content)
        if manifest is None:
            print("Error: YAML parsing failed. Try installing pyyaml: pip install pyyaml")
        return manifest

    if suffix == ".json":
        return _load_json(path)

    print(f"Error: Unknown file extension '{suffix}'. Use .yml, .yaml, or .json.")
    return None


def _load_json(path: Path) -> dict | None:
    try:
        with open(path, encoding="utf-8") as f:
            return json.load(f)
    except json.JSONDecodeError as e:
        print(f"Error: Invalid JSON: {e}")
        return None


def _parse_yaml(text: str):
    """Minimal YAML parser for pptx-prep manifest format.

    Handles: key: value, nested objects (indentation), lists (- item),
    quoted strings, integers, floats, comments (#). Does NOT handle:
    multi-line strings, anchors, tags, flow collections, complex edge cases.
    """
    lines = text.split("\n")
    return _parse_block([l for l in lines if l.strip() and not l.strip().startswith("#")])


def _parse_block(lines: list[str], indent: int = 0) -> dict | list | str | int | float | None:
    """Parse a block of YAML lines at the given indentation level."""
    if not lines:
        return None

    # Check if this is a list (first non-empty line starts with "- ")
    first_stripped = lines[0].lstrip()
    is_list = first_stripped.startswith("- ")

    if is_list:
        return _parse_list(lines, indent)

    return _parse_dict(lines, indent)


def _parse_list(lines: list[str], indent: int) -> list:
    """Parse a YAML list."""
    result = []
    i = 0

    while i < len(lines):
        stripped = lines[i].lstrip()
        line_indent = len(lines[i]) - len(stripped)

        if line_indent < indent:
            break

        if not stripped.startswith("- "):
            i += 1
            continue

        value_part = stripped[2:]

        # Check if the next lines are more indented (nested block)
        nested_lines = []
        j = i + 1
        while j < len(lines):
            ns = lines[j].lstrip()
            n_indent = len(lines[j]) - len(ns)
            if n_indent <= line_indent or (n_indent == line_indent and not ns.startswith("- ")):
                break
            nested_lines.append(lines[j])
            j += 1

        if nested_lines and nested_lines[0].lstrip().startswith("- "):
            # Sublist
            result.append(_parse_list(nested_lines, line_indent + 2))
        elif nested_lines:
            # Nested dict — combine with the "- key: value" prefix
            nested = _parse_dict(nested_lines, line_indent + 2)
            if ":" in value_part and _is_inline_dict(value_part):
                prefix = _parse_inline_dict(value_part)
                prefix.update(nested)
                result.append(prefix)
            else:
                result.append(nested)
        elif ":" in value_part and _is_inline_dict(value_part):
            # Inline key: value after "- "
            result.append(_parse_inline_dict(value_part))
        else:
            result.append(_parse_value(value_part))

        i = j
        if not nested_lines:
            i += 1

    return result


def _parse_dict(lines: list[str], indent: int) -> dict:
    """Parse a YAML dict."""
    result = {}
    i = 0

    while i < len(lines):
        line = lines[i]
        stripped = line.lstrip()
        line_indent = len(line) - len(stripped)

        if line_indent < indent or stripped.startswith("- "):
            break

        if ":" not in stripped and not stripped.startswith("#"):
            i += 1
            continue

        key_end = stripped.index(":") if ":" in stripped else len(stripped)
        key = stripped[:key_end].strip()
        value_part = stripped[key_end + 1:].lstrip()

        if value_part == "" or value_part == "|" or value_part == ">":
            # Nested block (next indented lines)
            nested_lines = []
            j = i + 1
            while j < len(lines):
                ns = lines[j].lstrip()
                n_indent = len(lines[j]) - len(ns)
                if n_indent <= line_indent:
                    break
                nested_lines.append(lines[j])
                j += 1

            if nested_lines:
                result[key] = _parse_block(nested_lines, line_indent + 2)
            i = j
        else:
            result[key] = _parse_value(value_part)
            i += 1

    return result


def _is_inline_dict(value: str) -> bool:
    """Check if a value looks like an inline dict: key1: val1, key2: val2"""
    return ":" in value and not value.startswith('"') and not value.startswith("'") and len(value) < 120


def _parse_inline_dict(value: str) -> dict:
    """Parse a simple inline dict like 'key1: val1, key2: val2'."""
    result = {}
    # Split by comma, but be careful
    parts = value.split(", ")
    for part in parts:
        if ":" in part:
            k, v = part.split(":", 1)
            result[k.strip()] = _parse_value(v.strip())
    return result


def _parse_value(value: str):
    """Parse a scalar YAML value or inline array."""
    value = value.strip()

    # Remove inline comment
    if " #" in value:
        value = value[: value.index(" #")]

    # Inline arrays: [item1, item2] or [slide-1]
    if value.startswith("[") and value.endswith("]"):
        inner = value[1:-1].strip()
        if not inner:
            return []
        items = []
        for item in inner.split(","):
            items.append(_parse_value(item.strip()))
        return items

    # Booleans
    if value.lower() in ("true", "yes", "on"):
        return True
    if value.lower() in ("false", "no", "off"):
        return False
    if value.lower() in ("null", "~", ""):
        return None

    # Quoted strings
    if (value.startswith('"') and value.endswith('"')) or \
       (value.startswith("'") and value.endswith("'")):
        return value[1:-1]

    # Integers
    if re.match(r"^-?\d+$", value):
        return int(value)

    # Floats
    if re.match(r"^-?\d+\.\d+$", value):
        return float(value)

    return value


def validate(manifest: dict) -> list[str]:
    """Validate manifest structure. Returns list of error messages (empty = valid)."""
    errors = []

    # Top-level required keys
    for key in ("manifest_version", "project", "materials", "summary"):
        if key not in manifest:
            errors.append(f"Missing required top-level key: '{key}'")

    if "manifest_version" in manifest and manifest["manifest_version"] != "1.0":
        errors.append(f"Unknown manifest_version: '{manifest['manifest_version']}'. Expected '1.0'.")

    # Project
    project = manifest.get("project", {})
    if not isinstance(project, dict):
        errors.append("'project' must be an object.")
    else:
        if "title" not in project:
            errors.append("Missing 'project.title'.")
        if "slide_count" not in project:
            errors.append("Missing 'project.slide_count'.")
        elif not isinstance(project["slide_count"], int) or project["slide_count"] < 1:
            errors.append(f"'project.slide_count' must be a positive integer, got: {project['slide_count']}")

    # Materials
    materials = manifest.get("materials", [])
    if not isinstance(materials, list):
        errors.append("'materials' must be an array.")
    else:
        seen_fields = set()
        for i, mat in enumerate(materials):
            prefix = f"materials[{i}]"
            if not isinstance(mat, dict):
                errors.append(f"{prefix}: must be an object.")
                continue

            for key in ("field", "type", "description", "used_in", "status", "source", "confidence"):
                if key not in mat:
                    errors.append(f"{prefix}: missing required key '{key}'.")

            field = mat.get("field", "")
            if field in seen_fields:
                errors.append(f"{prefix}: duplicate 'field' value '{field}'.")
            seen_fields.add(field)

            if mat.get("type") not in VALID_TYPES:
                errors.append(f"{prefix}: invalid type '{mat.get('type')}'. Must be one of: {VALID_TYPES}")

            if mat.get("status") not in VALID_STATUSES:
                errors.append(f"{prefix}: invalid status '{mat.get('status')}'. Must be one of: {VALID_STATUSES}")

            if mat.get("source") not in VALID_SOURCES:
                errors.append(f"{prefix}: invalid source '{mat.get('source')}'. Must be one of: {VALID_SOURCES}")

            if mat.get("confidence") not in VALID_CONFIDENCES:
                errors.append(f"{prefix}: invalid confidence '{mat.get('confidence')}'. Must be one of: {VALID_CONFIDENCES}")

            used_in = mat.get("used_in", [])
            if isinstance(used_in, list):
                for j, slide_ref in enumerate(used_in):
                    if not isinstance(slide_ref, str) or not slide_ref.startswith("slide-"):
                        errors.append(f"{prefix}.used_in[{j}]: must be 'slide-N' format, got '{slide_ref}'.")
            else:
                errors.append(f"{prefix}: 'used_in' must be an array.")

            if mat.get("status") == "ready" and mat.get("type") == "photo" and "path" not in mat:
                errors.append(f"{prefix}: status is 'ready' and type is 'photo' but no 'path' provided.")

            slot = mat.get("slot")
            if slot and isinstance(slot, dict):
                fm = slot.get("fill_mode")
                if fm and fm not in VALID_FILL_MODES:
                    errors.append(f"{prefix}.slot.fill_mode: must be 'contain' or 'cover', got '{fm}'.")

                capacity = slot.get("estimated_capacity")
                if capacity is not None and (not isinstance(capacity, int) or capacity < 0):
                    errors.append(f"{prefix}.slot.estimated_capacity: must be a non-negative integer, got '{capacity}'.")

            fmt = mat.get("format")
            if fmt and fmt not in VALID_FORMATS:
                errors.append(f"{prefix}: invalid format '{fmt}'. Must be one of: {VALID_FORMATS}")

            warnings = mat.get("warnings")
            if warnings:
                if not isinstance(warnings, list):
                    errors.append(f"{prefix}: 'warnings' must be an array.")
                else:
                    for j, w in enumerate(warnings):
                        if isinstance(w, dict) and w.get("type") not in VALID_WARNING_TYPES:
                            errors.append(f"{prefix}.warnings[{j}]: invalid warning type '{w.get('type')}'.")

    # Summary
    summary = manifest.get("summary", {})
    if not isinstance(summary, dict):
        errors.append("'summary' must be an object.")
    else:
        for key in ("total", "ready", "placeholder", "needs_review"):
            if key not in summary:
                errors.append(f"Missing 'summary.{key}'.")
            elif not isinstance(summary[key], int):
                errors.append(f"'summary.{key}' must be an integer, got: {summary[key]}")

        # Cross-validate summary vs materials
        if materials and all(isinstance(m, dict) for m in materials):
            actual = {
                "total": len(materials),
                "ready": sum(1 for m in materials if m.get("status") == "ready"),
                "placeholder": sum(1 for m in materials if m.get("status") == "placeholder"),
                "needs_review": sum(1 for m in materials if m.get("confidence") == "needs-review"),
            }
            for k, expected in actual.items():
                reported = summary.get(k)
                if reported is not None and reported != expected:
                    errors.append(f"summary.{k}: reported {reported}, but materials count is {expected}.")

    return errors


def main():
    if len(sys.argv) != 2:
        print("Usage: python validate.py <manifest_file>")
        print("  manifest_file: .yml, .yaml, or .json")
        sys.exit(1)

    path = Path(sys.argv[1])
    if not path.exists():
        print(f"Error: File not found: {path}")
        sys.exit(1)

    manifest = load_manifest(path)
    if manifest is None:
        sys.exit(1)

    errors = validate(manifest)

    if errors:
        print(f"\nValidation FAILED — {len(errors)} error(s):\n")
        for e in errors:
            print(f"  - {e}")
        print()
        sys.exit(1)
    else:
        print(f"\nValidation PASSED — {len(manifest.get('materials', []))} materials, all checks passed.\n")
        sys.exit(0)


if __name__ == "__main__":
    main()