main.py

import requests
from dotenv import load_dotenv
from datetime import datetime, timedelta
from typing import Dict, List, Optional
import json
import os
from collections import defaultdict
import time

class GitHubActivityFetcher:
    def __init__(self, token: str):
        """
        Initialize the GitHub Activity Fetcher.
        
        Args:
            token: GitHub personal access token with appropriate permissions
        """
        self.token = token
        self.api_url = "https://api.github.com/graphql"
        self.headers = {
            "Authorization": f"Bearer {token}",
            "Content-Type": "application/json"
        }
    
    def test_connection(self) -> Dict:
        """
        Test the connection and token validity.
        
        Returns:
            User information if successful
        """
        query = """
        query {
          viewer {
            login
            name
            email
          }
        }
        """
        
        response = requests.post(
            self.api_url,
            headers=self.headers,
            json={"query": query}
        )
        
        if response.status_code != 200:
            raise Exception(f"API request failed: {response.status_code} - {response.text}")
        
        data = response.json()
        
        if "errors" in data:
            raise Exception(f"GraphQL errors: {data['errors']}")
        
        return data["data"]["viewer"]
    
    def _make_graphql_request(self, query: str, variables: Dict, max_retries: int = 3) -> Dict:
        """
        Make a GraphQL request with retry logic for timeouts.
        
        Args:
            query: GraphQL query string
            variables: Query variables
            max_retries: Maximum number of retry attempts
        
        Returns:
            Response data
        """
        for attempt in range(max_retries):
            try:
                response = requests.post(
                    self.api_url,
                    headers=self.headers,
                    json={"query": query, "variables": variables},
                    timeout=30  # 30 second timeout
                )
                
                if response.status_code == 504:  # Gateway Timeout
                    if attempt < max_retries - 1:
                        wait_time = (attempt + 1) * 2  # Exponential backoff
                        print(f"  Request timed out. Retrying in {wait_time} seconds...")
                        time.sleep(wait_time)
                        continue
                    else:
                        raise Exception("GitHub API timeout after multiple retries")
                
                if response.status_code != 200:
                    # Check if it's an HTML error page
                    if response.headers.get('content-type', '').startswith('text/html'):
                        raise Exception(f"API request failed with status {response.status_code}: Gateway/Server Error")
                    raise Exception(f"API request failed: {response.status_code} - {response.text[:500]}")
                
                data = response.json()
                
                if "errors" in data:
                    raise Exception(f"GraphQL errors: {data['errors']}")
                
                return data
                
            except requests.exceptions.Timeout:
                if attempt < max_retries - 1:
                    wait_time = (attempt + 1) * 2
                    print(f"  Request timed out. Retrying in {wait_time} seconds...")
                    time.sleep(wait_time)
                    continue
                else:
                    raise Exception("Request timeout after multiple retries")
            except requests.exceptions.ConnectionError:
                if attempt < max_retries - 1:
                    wait_time = (attempt + 1) * 2
                    print(f"  Connection error. Retrying in {wait_time} seconds...")
                    time.sleep(wait_time)
                    continue
                else:
                    raise Exception("Connection error after multiple retries")
    
    def fetch_daily_activity(self, username: str, date: str) -> Dict:
        """
        Fetch all GitHub activity for a user on a specific date.
        
        Args:
            username: GitHub username
            date: Date in YYYY-MM-DD format
        
        Returns:
            Dictionary containing all activity data
        """
        # Parse date and create date range for the day
        target_date = datetime.strptime(date, "%Y-%m-%d")
        start_date = target_date.strftime("%Y-%m-%dT00:00:00Z")
        end_date = (target_date + timedelta(days=1)).strftime("%Y-%m-%dT00:00:00Z")
        
        print(f"Fetching activity for {username} on {date}...")
        
        # Try full query first, if it fails, use simplified version
        try:
            return self._fetch_full_activity(username, start_date, end_date, date)
        except Exception as e:
            if "timeout" in str(e).lower() or "504" in str(e):
                print("  Full query timed out. Trying simplified query...")
                return self._fetch_simplified_activity(username, start_date, end_date, date)
            else:
                raise e
    
    def _fetch_full_activity(self, username: str, start_date: str, end_date: str, date: str) -> Dict:
        """
        Fetch full activity data with all details.
        """
        
        # First, get basic user info and contribution summary
        query = """
        query($username: String!, $from: DateTime!, $to: DateTime!) {
          user(login: $username) {
            login
            name
            email
            
            contributionsCollection(from: $from, to: $to) {
              totalCommitContributions
              totalPullRequestContributions
              totalPullRequestReviewContributions
              totalIssueContributions
              
              # Commit contributions by repository
              commitContributionsByRepository(maxRepositories: 100) {
                repository {
                  nameWithOwner
                  url
                }
                contributions(first: 100) {
                  totalCount
                  nodes {
                    commitCount
                    occurredAt
                  }
                }
              }
              
              # Pull request contributions
              pullRequestContributions(first: 100) {
                totalCount
                nodes {
                  occurredAt
                  pullRequest {
                    title
                    url
                    number
                    state
                    createdAt
                    repository {
                      nameWithOwner
                    }
                  }
                }
              }
              
              # Pull request review contributions
              pullRequestReviewContributions(first: 100) {
                totalCount
                nodes {
                  occurredAt
                  pullRequestReview {
                    state
                    createdAt
                    bodyText
                  }
                  pullRequest {
                    title
                    url
                    number
                    state
                    author {
                      login
                    }
                    repository {
                      nameWithOwner
                    }
                  }
                }
              }
              
              # Issue contributions
              issueContributions(first: 100) {
                totalCount
                nodes {
                  occurredAt
                  issue {
                    title
                    url
                    number
                    state
                    repository {
                      nameWithOwner
                    }
                  }
                }
              }
            }
          }
        }
        """
        
        variables = {
            "username": username,
            "from": start_date,
            "to": end_date
        }
        
        data = self._make_graphql_request(query, variables)
        
        variables = {
            "username": username,
            "from": start_date,
            "to": end_date
        }
        
        data = self._make_graphql_request(query, variables)
        
        if not data.get("data") or not data["data"].get("user"):
            raise Exception(f"User '{username}' not found")
        
        # Process with simplified data structure
        user_data = data["data"]["user"]
        contributions = user_data.get("contributionsCollection", {})
        
        activity = {
            "date": date,
            "user": {
                "login": user_data.get("login", "Unknown"),
                "name": user_data.get("name", user_data.get("login", "Unknown")),
                "email": user_data.get("email", "")
            },
            "summary": {
                "total_commits": contributions.get("totalCommitContributions", 0),
                "total_prs_authored": contributions.get("totalPullRequestContributions", 0),
                "total_prs_reviewed": contributions.get("totalPullRequestReviewContributions", 0),
                "total_issues": contributions.get("totalIssueContributions", 0)
            },
            "authored_prs": [],
            "reviewed_prs": [],
            "commits_by_repo": {},
            "issues": []
        }
        
        # Process simplified PR data
        pr_contribs = contributions.get("pullRequestContributions", {}).get("nodes", [])
        for pr_contrib in pr_contribs:
            pr = pr_contrib.get("pullRequest", {})
            if pr:
                activity["authored_prs"].append({
                    "title": pr.get("title", ""),
                    "url": f"https://github.com/{pr.get('repository', {}).get('nameWithOwner', '')}/pull/{pr.get('number', '')}",
                    "number": pr.get("number", 0),
                    "repository": pr.get("repository", {}).get("nameWithOwner", ""),
                    "state": pr.get("state", ""),
                    "created_at": "",
                    "occurred_at": ""
                })
        
        # Process simplified review data
        review_contribs = contributions.get("pullRequestReviewContributions", {}).get("nodes", [])
        for review_contrib in review_contribs:
            pr = review_contrib.get("pullRequest", {})
            review = review_contrib.get("pullRequestReview", {})
            if pr and review:
                activity["reviewed_prs"].append({
                    "pr_title": pr.get("title", ""),
                    "pr_url": f"https://github.com/{pr.get('repository', {}).get('nameWithOwner', '')}/pull/{pr.get('number', '')}",
                    "pr_number": pr.get("number", 0),
                    "pr_author": "Unknown",
                    "repository": pr.get("repository", {}).get("nameWithOwner", ""),
                    "review_state": review.get("state", ""),
                    "review_body": "",
                    "occurred_at": ""
                })
        
        # Process simplified issue data
        issue_contribs = contributions.get("issueContributions", {}).get("nodes", [])
        for issue_contrib in issue_contribs:
            issue = issue_contrib.get("issue", {})
            if issue:
                activity["issues"].append({
                    "title": issue.get("title", ""),
                    "url": f"https://github.com/{issue.get('repository', {}).get('nameWithOwner', '')}/issues/{issue.get('number', '')}",
                    "number": issue.get("number", 0),
                    "repository": issue.get("repository", {}).get("nameWithOwner", ""),
                    "state": "",
                    "occurred_at": ""
                })
        
        print("  Note: Using simplified data due to API limitations")
        return activity
    
    def _fetch_simplified_activity(self, username: str, start_date: str, end_date: str, date: str) -> Dict:
        """
        Fetch simplified activity data with fewer details to avoid timeouts.
        """
        # Simplified query with just the essentials
        query = """
        query($username: String!, $from: DateTime!, $to: DateTime!) {
          user(login: $username) {
            login
            name
            email
            
            contributionsCollection(from: $from, to: $to) {
              totalCommitContributions
              totalPullRequestContributions
              totalPullRequestReviewContributions
              totalIssueContributions
              
              # Pull request contributions (simplified)
              pullRequestContributions(first: 50) {
                nodes {
                  pullRequest {
                    title
                    number
                    state
                    repository {
                      nameWithOwner
                    }
                  }
                }
              }
              
              # Pull request review contributions (simplified)
              pullRequestReviewContributions(first: 50) {
                nodes {
                  pullRequestReview {
                    state
                  }
                  pullRequest {
                    title
                    number
                    repository {
                      nameWithOwner
                    }
                  }
                }
              }
              
              # Issue contributions (simplified)
              issueContributions(first: 50) {
                nodes {
                  issue {
                    title
                    number
                    repository {
                      nameWithOwner
                    }
                  }
                }
              }
            }
          }
        }
        """
        
        if not data.get("data") or not data["data"].get("user"):
            raise Exception(f"User '{username}' not found")
        
        return self._process_activity_data(data["data"]["user"], date)
    
    def _process_activity_data(self, user_data: Dict, date: str) -> Dict:
        """
        Process and organize the raw activity data.
        
        Args:
            user_data: Raw user data from GraphQL query
            date: Target date
        
        Returns:
            Organized activity dictionary
        """
        contributions = user_data.get("contributionsCollection", {})
        
        activity = {
            "date": date,
            "user": {
                "login": user_data.get("login", "Unknown"),
                "name": user_data.get("name", user_data.get("login", "Unknown")),
                "email": user_data.get("email", "")
            },
            "summary": {
                "total_commits": contributions.get("totalCommitContributions", 0),
                "total_prs_authored": contributions.get("totalPullRequestContributions", 0),
                "total_prs_reviewed": contributions.get("totalPullRequestReviewContributions", 0),
                "total_issues": contributions.get("totalIssueContributions", 0)
            },
            "authored_prs": [],
            "reviewed_prs": [],
            "commits_by_repo": {},
            "issues": []
        }
        
        # Process authored PRs
        pr_contribs = contributions.get("pullRequestContributions", {}).get("nodes", [])
        for pr_contrib in pr_contribs:
            pr = pr_contrib.get("pullRequest", {})
            if pr:
                activity["authored_prs"].append({
                    "title": pr.get("title", ""),
                    "url": pr.get("url", ""),
                    "number": pr.get("number", 0),
                    "repository": pr.get("repository", {}).get("nameWithOwner", ""),
                    "state": pr.get("state", ""),
                    "created_at": pr.get("createdAt", ""),
                    "occurred_at": pr_contrib.get("occurredAt", "")
                })
        
        # Process reviewed PRs
        review_contribs = contributions.get("pullRequestReviewContributions", {}).get("nodes", [])
        for review_contrib in review_contribs:
            pr = review_contrib.get("pullRequest", {})
            review = review_contrib.get("pullRequestReview", {})
            if pr and review:
                activity["reviewed_prs"].append({
                    "pr_title": pr.get("title", ""),
                    "pr_url": pr.get("url", ""),
                    "pr_number": pr.get("number", 0),
                    "pr_author": pr.get("author", {}).get("login", "Unknown") if pr.get("author") else "Unknown",
                    "repository": pr.get("repository", {}).get("nameWithOwner", ""),
                    "review_state": review.get("state", ""),
                    "review_body": (review.get("bodyText", "") or "")[:100],
                    "occurred_at": review_contrib.get("occurredAt", "")
                })
        
        # Process commits by repository
        repo_commits = contributions.get("commitContributionsByRepository", [])
        for repo_commit in repo_commits:
            repo = repo_commit.get("repository", {})
            repo_name = repo.get("nameWithOwner", "")
            contrib_nodes = repo_commit.get("contributions", {}).get("nodes", [])
            
            total_commits = sum(
                node.get("commitCount", 0) 
                for node in contrib_nodes
            )
            
            if total_commits > 0 and repo_name:
                activity["commits_by_repo"][repo_name] = {
                    "count": total_commits,
                    "url": repo.get("url", "")
                }
        
        # Process issues
        issue_contribs = contributions.get("issueContributions", {}).get("nodes", [])
        for issue_contrib in issue_contribs:
            issue = issue_contrib.get("issue", {})
            if issue:
                activity["issues"].append({
                    "title": issue.get("title", ""),
                    "url": issue.get("url", ""),
                    "number": issue.get("number", 0),
                    "repository": issue.get("repository", {}).get("nameWithOwner", ""),
                    "state": issue.get("state", ""),
                    "occurred_at": issue_contrib.get("occurredAt", "")
                })
        
        return activity
    
    def fetch_recent_commits(self, username: str, date: str, repo_owner: str, repo_name: str) -> List[Dict]:
        """
        Fetch commits for a specific repository on a given date.
        
        Args:
            username: GitHub username
            date: Date in YYYY-MM-DD format
            repo_owner: Repository owner
            repo_name: Repository name
        
        Returns:
            List of commits
        """
        target_date = datetime.strptime(date, "%Y-%m-%d")
        since = target_date.strftime("%Y-%m-%dT00:00:00Z")
        until = (target_date + timedelta(days=1)).strftime("%Y-%m-%dT00:00:00Z")
        
        query = """
        query($owner: String!, $name: String!, $since: GitTimestamp!, $until: GitTimestamp!) {
          repository(owner: $owner, name: $name) {
            defaultBranchRef {
              target {
                ... on Commit {
                  history(first: 100, since: $since, until: $until) {
                    nodes {
                      oid
                      message
                      committedDate
                      additions
                      deletions
                      changedFilesIfAvailable
                      url
                      author {
                        name
                        email
                        user {
                          login
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
        """
        
        variables = {
            "owner": repo_owner,
            "name": repo_name,
            "since": since,
            "until": until
        }
        
        response = requests.post(
            self.api_url,
            headers=self.headers,
            json={"query": query, "variables": variables}
        )
        
        if response.status_code != 200:
            return []
        
        data = response.json()
        
        if "errors" in data or not data.get("data"):
            return []
        
        commits = []
        repo_data = data["data"].get("repository", {})
        if repo_data and repo_data.get("defaultBranchRef"):
            target = repo_data["defaultBranchRef"].get("target", {})
            history = target.get("history", {})
            nodes = history.get("nodes", [])
            
            for commit in nodes:
                author_user = commit.get("author", {}).get("user", {})
                if author_user and author_user.get("login") == username:
                    commits.append({
                        "sha": commit.get("oid", "")[:7],
                        "message": commit.get("message", "").split('\n')[0],
                        "url": commit.get("url", ""),
                        "additions": commit.get("additions", 0),
                        "deletions": commit.get("deletions", 0),
                        "changed_files": commit.get("changedFilesIfAvailable", 0),
                        "committed_at": commit.get("committedDate", "")
                    })
        
        return commits
    
    def print_activity_summary(self, activity: Dict):
        """
        Print a formatted summary of the daily activity.
        
        Args:
            activity: Activity dictionary from fetch_daily_activity
        """
        print(f"\n{'='*60}")
        print(f"GitHub Activity Report for {activity['user']['name']} ({activity['user']['login']})")
        print(f"Date: {activity['date']}")
        print(f"{'='*60}\n")
        
        # Summary
        print("📊 SUMMARY")
        print(f"  • Total Commits: {activity['summary']['total_commits']}")
        print(f"  • PRs Authored: {activity['summary']['total_prs_authored']}")
        print(f"  • PRs Reviewed: {activity['summary']['total_prs_reviewed']}")
        print(f"  • Issues Created/Updated: {activity['summary']['total_issues']}")
        print()
        
        # Authored PRs
        if activity['authored_prs']:
            print("✍️  AUTHORED PULL REQUESTS")
            for pr in activity['authored_prs']:
                print(f"  • [{pr['repository']}#{pr['number']}] {pr['title']}")
                print(f"    Status: {pr['state']} | URL: {pr['url']}")
            print()
        
        # Reviewed PRs
        if activity['reviewed_prs']:
            print("👀 REVIEWED PULL REQUESTS")
            for review in activity['reviewed_prs']:
                print(f"  • [{review['repository']}#{review['pr_number']}] {review['pr_title']}")
                print(f"    Author: {review['pr_author']} | Review: {review['review_state']}")
                if review['review_body']:
                    print(f"    Comment: {review['review_body']}...")
            print()
        
        # Commits by repository
        if activity['commits_by_repo']:
            print("💻 COMMITS BY REPOSITORY")
            for repo, info in activity['commits_by_repo'].items():
                count = info['count'] if isinstance(info, dict) else info
                print(f"  • {repo}: {count} commit{'s' if count > 1 else ''}")
            print()
        
        # Issues
        if activity['issues']:
            print("🐛 ISSUES CREATED/UPDATED")
            for issue in activity['issues']:
                print(f"  • [{issue['repository']}#{issue['number']}] {issue['title']}")
                print(f"    Status: {issue['state']} | URL: {issue['url']}")
            print()
        
        # If no activity
        if not any([
            activity['summary']['total_commits'],
            activity['summary']['total_prs_authored'],
            activity['summary']['total_prs_reviewed'],
            activity['summary']['total_issues']
        ]):
            print("No activity found for this date.")
    
    def print_compact_summary(self, activity: Dict):
        """
        Print a compact grouped summary of activity.
        Groups PRs and issues by repository, with reviewed PRs at the bottom.
        
        Args:
            activity: Activity dictionary from fetch_daily_activity
        """
        print(f"\n{'='*60}")
        print("COMPACT ACTIVITY SUMMARY")
        print(f"Date: {activity['date']}")
        print(f"{'='*60}\n")
        
        # Group authored PRs and issues by repository
        repos_with_activity = defaultdict(lambda: {"prs": [], "issues": []})
        
        # Add authored PRs
        for pr in activity['authored_prs']:
            repo = pr['repository']
            if repo:
                repos_with_activity[repo]["prs"].append(f"#{pr['number']}")
        
        # Add issues
        for issue in activity['issues']:
            repo = issue['repository']
            if repo:
                repos_with_activity[repo]["issues"].append(f"#{issue['number']}")
        
        # Print PRs and Issues grouped by repository
        if repos_with_activity:
            print("PRs AUTHORED / WORKED ON & ISSUES:")
            for repo in sorted(repos_with_activity.keys()):
                items = repos_with_activity[repo]
                all_items = []
                
                # Add PR numbers
                all_items.extend(items["prs"])
                
                # Add issue numbers with (issue) marker
                all_items.extend([f"{num}(issue)" for num in items["issues"]])
                
                if all_items:
                    print(f"{repo} {' '.join(all_items)}")
            print()
        
        # Group reviewed PRs by repository
        reviewed_by_repo = defaultdict(list)
        for review in activity['reviewed_prs']:
            repo = review['repository']
            if repo:
                reviewed_by_repo[repo].append(f"#{review['pr_number']}")
        
        # Print reviewed PRs
        if reviewed_by_repo:
            print("REVIEWED PRs:")
            for repo in sorted(reviewed_by_repo.keys()):
                pr_numbers = ' '.join(reviewed_by_repo[repo])
                print(f"{repo} {pr_numbers}")
            print()
        
        # If no activity
        if not repos_with_activity and not reviewed_by_repo:
            print("No PR or Issue activity found for this date.")
            print()


# Example usage
if __name__ == "__main__":
    load_dotenv()

    TOKEN = os.getenv("GITHUB_TOKEN") 
    USERNAME = os.getenv("GITHUB_USERNAME")  # Replace with the GitHub username to track
    DATE = datetime.now().strftime("%Y-%m-%d")  # Today - Format: YYYY-MM-DD
    
    try:
        # Initialize fetcher
        fetcher = GitHubActivityFetcher(TOKEN)
        
        # Test connection first
        print("Testing connection...")
        viewer = fetcher.test_connection()
        print(f"✅ Connected as: {viewer['login']}")
        print()
        
        # Fetch daily activity
        activity = fetcher.fetch_daily_activity(USERNAME, DATE)
        
        # Print the new compact summary
        fetcher.print_compact_summary(activity)
        
        # Print the detailed summary
        fetcher.print_activity_summary(activity)
        
        # Save to JSON
        filename = f"github_activity_{USERNAME}_{DATE}.json"
        with open(filename, "w") as f:
            json.dump(activity, f, indent=2)
        
        print(f"\n✅ Activity data saved to {filename}")
        
        # Optional: Fetch detailed commits for specific repos
        if activity['commits_by_repo']:
            print("\n📝 Fetching detailed commits...")
            for repo_name in list(activity['commits_by_repo'].keys())[:3]:  # Limit to first 3 repos
                parts = repo_name.split('/')
                if len(parts) == 2:
                    owner, name = parts
                    commits = fetcher.fetch_recent_commits(USERNAME, DATE, owner, name)
                    if commits:
                        print(f"\nCommits in {repo_name}:")
                        for commit in commits:
                            print(f"  • {commit['sha']}: {commit['message']}")
                            print(f"    +{commit['additions']} -{commit['deletions']} files: {commit['changed_files']}")
        
    except Exception as e:
        print(f"❌ Error: {e}")
        print("\nTroubleshooting tips:")
        print("1. Make sure your token has the correct permissions (repo, read:user)")
        print("2. Verify the username is correct")
        print("3. Check that the date format is YYYY-MM-DD")
        print("4. Ensure your token is not expired")