import requests
from collections import Counter

def analyze_issue_labels(repo, token):
    """Fetch and analyze issue labels from a repository."""
    headers = {"Authorization": f"token {token}"}
    url = f"https://api.github.com/repos/{repo}/issues?state=open"

    response = requests.get(url, headers=headers)
    issues = response.json()

    label_analysis = Counter()
    good_first_issues = []

    for issue in issues:
        labels = issue.get("labels", [])
        label_names = [l["name"] for l in labels]

        # Track label frequency
        label_analysis.update(label_names)

        # Identify good first issues
        if "good first issue" in label_names:
            good_first_issues.append({
                "title": issue["title"],
                "url": issue["html_url"],
                "labels": label_names
            })

    return {
        "label_frequency": label_analysis.most_common(10),
        "good_first_issues": good_first_issues[:10]
    }

# Example usage
result = analyze_issue_labels("owner/repo", "your_token")
print(f"Most common labels: {result['label_frequency']}")
print(f"Good first issues found: {len(result['good_first_issues'])}")

from openai import OpenAI

client = OpenAI(api_key="your-api-key")

def match_issue_to_skills(issue_description, contributor_skills):
    """Use AI to match issue requirements to contributor skills."""

    prompt = f"""
    Analyze this open source issue and contributor profile.

    Issue Description:
    {issue_description}

    Contributor Skills: {contributor_skills}

    Provide:
    1. Relevance score (0-100) - how well the issue matches skills
    2. Required knowledge gaps - what the contributor would need to learn
    3. Estimated difficulty (beginner/intermediate/advanced)
    """

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

    return response.choices[0].message.content

# Example
issue = "We need to add OAuth2 support to the API gateway. This requires understanding of JWT tokens, refresh tokens, and security best practices."
skills = ["Python", "API development", "Authentication", "FastAPI"]

result = match_issue_to_skills(issue, skills)
print(result)

def predict_pr_success(repo, issue_number, historical_data):
    """Predict likelihood of PR acceptance based on historical patterns."""

    # Features to consider:
    features = {
        "has_code_of_conduct": check_coc(repo),
        "contributor_guidelines_exist": check_contributing_guide(repo),
        "issue_age_days": get_issue_age(issue_number),
        "maintainer_response_time_avg": get_avg_response_time(repo),
        "issue_has_labels": has_labels(issue_number),
        "similar_prs_accepted_ratio": get_acceptance_ratio(repo)
    }

    # Simple scoring model (would use ML in production)
    score = 0
    if features["has_code_of_conduct"]:
        score += 20
    if features["contributor_guidelines_exist"]:
        score += 15
    if features["issue_has_labels"]:
        score += 10
    if features["similar_prs_accepted_ratio"] > 0.7:
        score += 25

    return {
        "success_probability": min(score, 100),
        "factors": features,
        "recommendation": "highly likely" if score > 70 else "moderate" if score > 40 else "risky"
    }

def get_enriched_issues(repo, token):
    """Get issues with AI-generated insights."""
    headers = {"Authorization": f"token {token}"}

    # Fetch issues
    issues_url = f"https://api.github.com/repos/{repo}/issues?state=open&per_page=30"
    response = requests.get(issues_url, headers=headers)
    issues = response.json()

    enriched = []
    for issue in issues[:10]:  # Limit API calls
        # Add AI analysis
        analysis = analyze_issue_complexity(issue["body"] or issue["title"])
        enriched.append({
            "title": issue["title"],
            "url": issue["html_url"],
            "complexity": analysis["complexity"],
            "skills_needed": analysis["skills"],
            "priority_score": analysis["priority"]
        })

    return enriched

def assess_issue_engagement(issue):
    """Evaluate engagement signals on an issue."""
    signals = {
        "comments": issue.get("comments", 0),
        "has_assignee": issue.get("assignee") is not None,
        "linked_prs": issue.get("pull_request") is not None,
        "reactions": sum(r["count"] for r in issue.get("reactions", []))
    }

    # Weight the signals
    engagement_score = (
        signals["comments"] * 2 +
        signals["reactions"] * 3 +
        (20 if signals["has_assignee"] else 0)
    )

    return {
        "score": engagement_score,
        "signals": signals,
        "interpretation": "active" if engagement_score > 15 else "needs attention"
    }

def calculate_contribution_metrics(contributor_name, repo):
    """Calculate contribution success metrics."""
    # This would use GitHub API in production
    return {
        "total_prs": 15,
        "accepted_prs": 12,
        "acceptance_rate": 0.80,
        "avg_time_to_merge": "4.2 days",
        "best_issue_types": ["bug fixes", "documentation"],
        "recommended_focus": "Issues labeled 'good first issue' or 'help wanted'"
    }