# Example: Fetching Jira issues for stakeholder summary
import requests
from datetime import datetime, timedelta

JIRA_DOMAIN = "your-company.atlassian.net"
JIRA_EMAIL = "pm@company.com"
JIRA_API_TOKEN = os.environ.get("JIRA_API_TOKEN")

def get_sprint_issues(project_key, sprint_id):
    """Fetch completed issues for sprint summary."""
    jql = f"project = {project_key} AND sprint = {sprint_id} AND status = Done"
    url = f"https://{JIRA_DOMAIN}/rest/api/3/search"

    response = requests.get(
        url,
        params={"jql": jql, "maxResults": 100, "fields": "summary,status,assignee,resolutiondate"},
        auth=(JIRA_EMAIL, JIRA_API_TOKEN)
    )

    return response.json().get("issues", [])

from openai import OpenAI

client = OpenAI(api_key=os.environ.get("OPENAI_API_KEY"))

def generate_sprint_summary(issues, sprint_name):
    completed = [i["fields"]["summary"] for i in issues if i["fields"]["status"]["name"] == "Done"]

    prompt = f"""Generate a concise stakeholder update for sprint {sprint_name}.

Completed items ({len(completed)}):
{chr(10).join(f"- {item}" for item in completed[:10])}

Highlight: Key achievements, any blockers, and next priorities.
Keep under 150 words. Use plain language accessible to executive stakeholders."""

    response = client.chat.completions.create(
        model="gpt-4o",
        messages=[{"role": "user", "content": prompt}],
        temperature=0.7
    )

    return response.choices[0].message.content

def generate_analytical_summary(issues, previous_sprint_issues):
    """Generate summary with trend analysis."""

    prompt = """Analyze these sprint results and identify:
1. Velocity trend compared to previous sprint
2. Key blockers or challenges encountered
3. Team health indicators
4. Recommended focus areas for next sprint

Current sprint: {current}
Previous sprint: {previous}

Provide a 200-word executive summary with specific recommendations.""".format(
        current=format_issues(issues),
        previous=format_issues(previous_sprint_issues)
    )

    # Use reasoning model for analytical tasks
    response = client.chat.completions.create(
        model="o1-preview",
        messages=[{"role": "user", "content": prompt}]
    )

    return response.choices[0].message.content

from pptx import Presentation
from pptx.util import Inches, Pt

def create_stakeholder_deck(summary_data, metrics):
    """Generate PowerPoint deck from AI-generated content."""

    prs = Presentation()
    prs.slide_width = Inches(13.333)
    prs.slide_height = Inches(7.5)

    # Title slide
    title_slide = prs.slides.add_slide(prs.slide_layouts[0])
    title_slide.shapes.title.text = f"Sprint Update: {summary_data['sprint_name']}"
    title_slide.placeholders[1].text = datetime.now().strftime("%B %d, %Y")

    # Metrics slide
    metrics_slide = prs.slides.add_slide(prs.slide_layouts[1])
    metrics_slide.shapes.title.text = "Key Metrics"
    metrics_slide.placeholders[1].text = f"""
• Completed: {metrics['completed']} issues
• Velocity: {metrics['velocity']} story points
• Blockers: {metrics['blockers']} active
• Team capacity: {metrics['capacity']}%
"""

    # Summary slide
    summary_slide = prs.slides.add_slide(prs.slide_layouts[1])
    summary_slide.shapes.title.text = "Sprint Summary"
    summary_slide.placeholders[1].text = summary_data['narrative']

    prs.save(f"stakeholder-update-{summary_data['sprint_name']}.pptx")

import matplotlib.pyplot as plt

def generate_velocity_chart(current_sprint, previous_sprints):
    """Generate velocity trend visualization."""

    sprints = [s['name'] for s in previous_sprints] + [current_sprint['name']]
    velocities = [s['velocity'] for s in previous_sprints] + [current_sprint['velocity']]

    plt.figure(figsize=(10, 6))
    plt.plot(sprints, velocities, marker='o', linewidth=2)
    plt.title('Team Velocity Trend')
    plt.ylabel('Story Points Completed')
    plt.xlabel('Sprint')
    plt.xticks(rotation=45)
    plt.tight_layout()
    plt.savefig('velocity_trend.png')

    return 'velocity_trend.png'

def generate_audience_specific_summary(issues, audience='exec'):
    """Generate summaries tuned for different audiences."""

    prompts = {
        'exec': "Focus on business impact, blockers, and recommended next steps. Keep technical details minimal.",
        'engineering': "Include technical achievements, architectural decisions, and technical debt addressed.",
        'sales': "Highlight customer-facing features delivered, product capabilities improved, and customer-impacting fixes."
    }

    base_prompt = f"""Summarize this sprint's work for a {audience} audience.

{prompts[audience]}

Sprint data: {format_issues(issues)}"""

    return client.chat.completions.create(
        model="gpt-4o",
        messages=[{"role": "user", "content": base_prompt}],
        temperature=0.7
    ).choices[0].message.content