import requests
from datetime import datetime, timedelta

def create_jira_epic_with_timeline(epic_name, sprint_start, sprint_count):
    base_url = "https://your-domain.atlassian.net/rest/api/3"
    headers = {"Authorization": f"Bearer {JIRA_TOKEN}"}

    # Create epic
    epic_response = requests.post(
        f"{base_url}/epic",
        json={"name": epic_name, "project": "YOUR_PROJECT"},
        headers=headers
    )
    epic_id = epic_response.json()["id"]

    # Create child stories with timeline
    for i in range(sprint_count):
        story_data = {
            "fields": {
                "project": {"key": "YOUR_PROJECT"},
                "summary": f"Sprint {i + 1} deliverables",
                "issuetype": {"name": "Story"},
                "parent": {"key": epic_id},
                "duedate": (sprint_start + timedelta(weeks=i*2)).strftime("%Y-%m-%d")
            }
        }
        requests.post(f"{base_url}/issue", json=story_data, headers=headers)

    return epic_id

import asana
from datetime import datetime, timedelta

client = asana.Client.access_token(ASANA_TOKEN)

def schedule_release_milestones(project_id, release_date):
    milestones = [
        ("Code Freeze", -14),
        ("QA Complete", -7),
        ("Release Prep", -3),
        ("Production Deploy", 0)
    ]

    for name, days_offset in milestones:
        due_date = release_date + timedelta(days=days_offset)
        task = client.tasks.create_task({
            "name": name,
            "due_on": due_date.strftime("%Y-%m-%d"),
            "projects": [project_id],
            "custom_fields": {
                "milestone_type": "release"
            }
        })

# Python: Auto-update Gantt timelines based on GitHub events
import asyncio
from github import Github
from datetime import datetime, timedelta
import httpx

class GitHubTimelineSync:
    def __init__(self, github_token: str, gantt_api_key: str, gantt_tool: str):
        self.github = Github(github_token)
        self.gantt_api = gantt_api_key
        self.gantt_tool = gantt_tool  # 'clickup', 'linear', 'jira', etc.

    async def sync_issues_to_timeline(self, repo_name: str, milestone: str):
        """Sync GitHub milestone issues to Gantt timeline."""
        repo = self.github.get_repo(repo_name)
        issues = repo.get_issues(milestone=milestone, state='all')

        timeline_items = []
        for issue in issues:
            # Map GitHub issue to timeline task
            task = {
                'title': issue.title,
                'description': issue.body,
                'assignee': issue.assignee.login if issue.assignee else None,
                'status': self._map_github_state(issue.state),
                'priority': self._extract_priority(issue.labels),
                'start_date': issue.created_at.isoformat(),
                'due_date': issue.milestone.due_on.isoformat() if issue.milestone else None,
                'url': issue.html_url,
                'github_issue_id': issue.number
            }

            # Check if issue has related PRs (indicates progress)
            related_prs = repo.get_pulls(state='all')
            for pr in related_prs:
                if f'#{issue.number}' in pr.body or f'closes #{issue.number}' in pr.body:
                    task['pull_request'] = {
                        'number': pr.number,
                        'state': pr.state,
                        'merged': pr.merged
                    }
                    # If PR is merged, mark task complete
                    if pr.merged:
                        task['status'] = 'complete'
                        task['completion_date'] = pr.merged_at.isoformat()

            timeline_items.append(task)

        # Push to Gantt tool
        await self._push_to_gantt(timeline_items)

    async def watch_pr_merges(self, repo_name: str):
        """Watch for merged PRs and update timeline completion status."""
        repo = self.github.get_repo(repo_name)
        check_interval = 300  # Check every 5 minutes

        while True:
            prs = repo.get_pulls(state='closed', sort='updated')
            for pr in prs:
                if pr.merged:
                    # Find related issues
                    for issue_ref in self._extract_issue_refs(pr.body):
                        await self._mark_task_complete(repo_name, issue_ref)

            await asyncio.sleep(check_interval)

    def _map_github_state(self, state: str) -> str:
        """Map GitHub issue state to Gantt status."""
        if state == 'closed':
            return 'complete'
        elif state == 'open':
            return 'in_progress'
        return 'open'

    def _extract_priority(self, labels):
        """Extract priority from GitHub labels."""
        label_names = [label.name.lower() for label in labels]
        if 'p0' in label_names or 'critical' in label_names:
            return 'high'
        elif 'p2' in label_names or 'low' in label_names:
            return 'low'
        return 'medium'

    def _extract_issue_refs(self, text: str) -> list:
        """Extract issue references (e.g., #123) from PR body."""
        import re
        return re.findall(r'#(\d+)', text)

    async def _mark_task_complete(self, repo_name: str, issue_num: int):
        """Mark task as complete in Gantt tool."""
        # Implementation varies by tool
        if self.gantt_tool == 'clickup':
            await self._update_clickup_task(issue_num, 'complete')
        elif self.gantt_tool == 'linear':
            await self._update_linear_task(issue_num, 'Done')

    async def _update_clickup_task(self, issue_id: int, status: str):
        """Update ClickUp task status."""
        async with httpx.AsyncClient() as client:
            await client.put(
                f'https://api.clickup.com/api/v2/task/GITHUB-{issue_id}',
                headers={'Authorization': self.gantt_api},
                json={'status': status}
            )

    async def _push_to_gantt(self, tasks: list):
        """Push timeline items to Gantt tool."""
        for task in tasks:
            await self._create_or_update_gantt_task(task)

# Initialize syncer
syncer = GitHubTimelineSync(
    github_token='ghp_xxxxx',
    gantt_api_key='api_key_xxxxx',
    gantt_tool='clickup'
)

# Sync on startup
asyncio.run(syncer.sync_issues_to_timeline('myorg/myrepo', 'v2.0'))

# Watch for updates continuously
asyncio.run(syncer.watch_pr_merges('myorg/myrepo'))

# Python: Analyze team workload distribution using Gantt data
import pandas as pd
from datetime import datetime, timedelta

class WorkloadAnalysis:
    def __init__(self, gantt_data: list):
        """gantt_data is list of tasks with assignee and duration."""
        self.tasks = gantt_data
        self.df = pd.DataFrame(gantt_data)

    def identify_overallocation(self, max_hours_per_week: int = 40):
        """Find team members with too much assigned work."""
        self.df['start'] = pd.to_datetime(self.df['start'])
        self.df['end'] = pd.to_datetime(self.df['end'])
        self.df['duration_hours'] = (self.df['end'] - self.df['start']).dt.total_seconds() / 3600

        # Group by assignee and week
        self.df['week'] = self.df['start'].dt.isocalendar().week
        workload = self.df.groupby(['assignee', 'week'])['duration_hours'].sum()

        overallocated = workload[workload > max_hours_per_week]

        return {
            'overallocated_people': overallocated.index.unique(0).tolist(),
            'by_week': overallocated.to_dict()
        }

    def identify_critical_path_blockers(self):
        """Find tasks that block the most downstream work."""
        blockers = {}

        for task in self.tasks:
            if task.get('dependencies'):
                for dep_task_id in task['dependencies']:
                    if dep_task_id not in blockers:
                        blockers[dep_task_id] = []
                    blockers[dep_task_id].append(task['id'])

        # Rank blockers by number of downstream tasks
        ranked = sorted(
            blockers.items(),
            key=lambda x: len(x[1]),
            reverse=True
        )

        return {
            'critical_blockers': ranked[:10],
            'total_dependent_tasks': sum(len(v) for v in blockers.values())
        }

    def forecast_completion_date(self, project_id: str):
        """Use task history to forecast project completion."""
        project_tasks = [t for t in self.tasks if t.get('project') == project_id]

        total_duration = sum(
            (pd.Timestamp(t['end']) - pd.Timestamp(t['start'])).days
            for t in project_tasks if 'end' in t
        )

        avg_task_days = total_duration / len(project_tasks) if project_tasks else 0

        incomplete = [t for t in project_tasks if t.get('status') != 'complete']
        estimated_remaining_days = len(incomplete) * avg_task_days

        return {
            'estimated_days_remaining': estimated_remaining_days,
            'forecasted_completion': (
                datetime.now() + timedelta(days=estimated_remaining_days)
            ).isoformat(),
            'confidence': 'medium' if len(project_tasks) > 10 else 'low'
        }

    def generate_report(self):
        """Generate executive summary of project health."""
        return {
            'overallocation': self.identify_overallocation(),
            'critical_blockers': self.identify_critical_path_blockers(),
            'completion_forecast': self.forecast_completion_date('current'),
            'generated_at': datetime.now().isoformat()
        }