#!/usr/bin/env python3
r"""
Genesis PRD Generator — Generates compliant PRD documents following GLOBAL_GENESIS_RULES.md Rule 4

Usage:
    python scripts/prd_generator.py \
        --task "voice_bridge_http" \
        --description "Build HTTP transport for genesis-voice-bridge MCP" \
        --acceptance "HTTP endpoint accepts voice commands" \
        --acceptance "WebSocket fallback implemented" \
        --category "Infrastructure"

Output: E:\genesis-system\docs\plans\{task_name}_PRD.md
"""

import argparse
import json
import os
from datetime import datetime
from pathlib import Path


# === TEMPLATES ===

PRD_TEMPLATE = """# PRD: {title}
## {project_code} | {category}

**Created**: {timestamp}
**Status**: Draft
**Owner**: Genesis AI

---

## Vision Statement

{vision}

---

## Success Metrics

| Metric | Target | Measurement |
|--------|--------|-------------|
{metrics}

---

## Clarifying Questions Asked

{questions}

---

## Architecture Overview

{architecture}

---

## Risk Assessment

| Risk | Impact | Mitigation |
|------|--------|------------|
{risks}

---

## Atomic Stories

{stories}

---

## Testing Protocol

After EVERY atomic story:

### Black Box Testing (MANDATORY)
- [ ] Input validation tests
- [ ] Output verification tests
- [ ] Boundary condition tests
- [ ] Error handling tests
- [ ] Integration point tests

### White Box Testing (MANDATORY)
- [ ] Code path coverage tests
- [ ] Branch coverage tests
- [ ] Function/method unit tests
- [ ] Internal state verification
- [ ] Exception handling paths

### Additional Required Tests
- [ ] Regression tests (existing functionality still works)
- [ ] Performance baseline (doesn't degrade system)
- [ ] Security scan (no vulnerabilities introduced)
- [ ] Documentation verification (docs match implementation)

---

## Verification Checklist

Before marking story complete:

- [ ] All tests pass (0 failures)
- [ ] Code review completed (self or peer)
- [ ] Documentation updated
- [ ] No security vulnerabilities
- [ ] Performance acceptable
- [ ] Integration verified
- [ ] Rollback plan exists

---

## Verification Stamp Format

```python
# VERIFICATION_STAMP
# Story: [STORY_ID]
# Verified By: [AGENT_ID]
# Verified At: [TIMESTAMP]
# Tests: [PASS_COUNT]/[TOTAL_COUNT]
# Coverage: [PERCENTAGE]%
```

---

## Notes

{notes}

---

*Generated by Genesis PRD Generator*
*Compliant with GLOBAL_GENESIS_RULES.md Rule 4*
"""


STORY_TEMPLATE = """#### Story {story_num}: {story_title}

- **As** {role}, **I need** {feature}, **So that** {benefit}
- **Acceptance Criteria**:
{acceptance_criteria}
- **Test Plan**:
  - Black box: {black_box_tests}
  - White box: {white_box_tests}
"""


# === GENERATOR ===

class PRDGenerator:
    def __init__(self, task_name: str, description: str, acceptance_criteria: list, category: str):
        self.task_name = task_name
        self.description = description
        self.acceptance_criteria = acceptance_criteria
        self.category = category
        self.timestamp = datetime.now().isoformat()

    def generate_project_code(self) -> str:
        """Generate project code from task name (e.g., voice_bridge → VB)"""
        words = self.task_name.replace("_", " ").split()
        code = "".join(w[0].upper() for w in words[:2])
        return f"{code}-001"

    def generate_vision(self) -> str:
        """Generate 1-2 sentence vision statement"""
        return f"{self.description}. This enables Genesis to expand its capabilities with minimal friction."

    def generate_metrics(self) -> str:
        """Generate success metrics table"""
        metrics = [
            ("Completion Rate", "100%", "All acceptance criteria met"),
            ("Test Coverage", ">80%", "pytest coverage report"),
            ("Zero Regressions", "0 failures", "Full test suite pass"),
        ]
        return "\n".join(f"| {m[0]} | {m[1]} | {m[2]} |" for m in metrics)

    def generate_questions(self) -> str:
        """Generate clarifying questions section"""
        questions = [
            {
                "q": "What are the scope boundaries? What's explicitly out of scope?",
                "a": "In scope: Core functionality. Out of scope: Advanced optimizations for v2."
            },
            {
                "q": "What are the critical edge cases we need to handle?",
                "a": "Error handling, rate limiting, network failures, invalid inputs."
            },
            {
                "q": "What dependencies could block this work?",
                "a": "External APIs must be accessible. Credentials must be available."
            },
        ]
        return "\n".join(f"{i+1}. **Q**: {q['q']}\n   **A**: {q['a']}" for i, q in enumerate(questions))

    def generate_architecture(self) -> str:
        """Generate architecture description"""
        return f"""
### High-Level Design

```
User Request → {self.task_name} → Output
```

**Components**:
1. **Input Layer**: Validates incoming requests
2. **Processing Layer**: Core business logic
3. **Output Layer**: Returns results

**Data Flow**:
1. Receive request
2. Validate inputs
3. Execute logic
4. Return response

**Technology Stack**:
- Language: Python 3.11+
- Framework: (TBD based on requirements)
- Storage: E: drive (GLOBAL_GENESIS_RULES.md Rule 6)
"""

    def generate_risks(self) -> str:
        """Generate risk assessment table"""
        risks = [
            ("Rate Limits", "High", "Implement exponential backoff + retry logic"),
            ("API Changes", "Medium", "Version lock dependencies + monitor changelog"),
            ("C: Drive Usage", "Critical", "ENFORCE E: drive only (GLOBAL_GENESIS_RULES.md Rule 6)"),
        ]
        return "\n".join(f"| {r[0]} | {r[1]} | {r[2]} |" for r in risks)

    def generate_stories(self) -> str:
        """Generate atomic stories from acceptance criteria"""
        stories = []
        for i, ac in enumerate(self.acceptance_criteria, start=1):
            story = STORY_TEMPLATE.format(
                story_num=i,
                story_title=ac[:50],
                role="developer",
                feature=ac,
                benefit="the system meets acceptance criteria",
                acceptance_criteria=f"  - {ac}\n  - Tests pass\n  - Documentation updated",
                black_box_tests="Input validation, output verification, error handling",
                white_box_tests="Code coverage, branch coverage, unit tests"
            )
            stories.append(story)
        return "\n".join(stories)

    def generate_notes(self) -> str:
        """Generate notes section"""
        return f"""
- Follow GLOBAL_GENESIS_RULES.md at all times
- All work on E: drive (Rule 6)
- No SQLite (Rule 7) — use Elestio PostgreSQL/Qdrant/Redis
- Research-first protocol (Rule 8) — read existing docs before building
- Native-first protocol (Rule 9) — check for existing solutions first
- 100% verification required (Rule 3)
"""

    def generate(self) -> str:
        """Generate full PRD document"""
        return PRD_TEMPLATE.format(
            title=self.description,
            project_code=self.generate_project_code(),
            category=self.category,
            timestamp=self.timestamp,
            vision=self.generate_vision(),
            metrics=self.generate_metrics(),
            questions=self.generate_questions(),
            architecture=self.generate_architecture(),
            risks=self.generate_risks(),
            stories=self.generate_stories(),
            notes=self.generate_notes(),
        )

    def save(self, output_dir: str = "E:/genesis-system/docs/plans"):
        """Save PRD to file"""
        output_path = Path(output_dir) / f"{self.task_name}_PRD.md"
        output_path.parent.mkdir(parents=True, exist_ok=True)

        prd_content = self.generate()
        output_path.write_text(prd_content, encoding="utf-8")

        return output_path


# === CLI ===

def main():
    parser = argparse.ArgumentParser(
        description="Generate Genesis-compliant PRD documents",
        formatter_class=argparse.RawDescriptionHelpFormatter,
        epilog="""
Examples:
    python scripts/prd_generator.py \\
        --task voice_bridge_http \\
        --description "Build HTTP transport for genesis-voice-bridge MCP" \\
        --acceptance "HTTP endpoint accepts voice commands" \\
        --acceptance "WebSocket fallback implemented" \\
        --category Infrastructure

    python scripts/prd_generator.py \\
        --task plumber_aiva_kb \\
        --description "Build PlumberAIVA knowledge base" \\
        --acceptance "KB entities created" \\
        --acceptance "System prompt configured" \\
        --category AI
        """
    )

    parser.add_argument("--task", required=True, help="Task name (e.g., voice_bridge_http)")
    parser.add_argument("--description", required=True, help="Feature description")
    parser.add_argument("--acceptance", action="append", required=True, help="Acceptance criteria (repeat for multiple)")
    parser.add_argument("--category", default="Engineering", help="Category (default: Engineering)")
    parser.add_argument("--output", default="E:/genesis-system/docs/plans", help="Output directory")

    args = parser.parse_args()

    # Generate PRD
    generator = PRDGenerator(
        task_name=args.task,
        description=args.description,
        acceptance_criteria=args.acceptance,
        category=args.category
    )

    output_path = generator.save(args.output)
    print(f"[OK] PRD generated: {output_path}")
    print(f"     Task: {args.task}")
    print(f"     Category: {args.category}")
    print(f"     Stories: {len(args.acceptance)}")


if __name__ == "__main__":
    main()