utils.py

import pandas as pd
from datetime import datetime, timedelta
import streamlit as st
import json
import os
from concurrent.futures import ThreadPoolExecutor, as_completed

def filter_repos_by_date(repos, start_date, end_date):
    """Filter repositories by creation date."""
    filtered = []
    for repo in repos:
        created_at = datetime.strptime(repo['created_at'], '%Y-%m-%dT%H:%M:%SZ')
        if start_date <= created_at.date() <= end_date:
            filtered.append(repo)
    return filtered

def filter_repos_by_size(repos, min_size, max_size):
    """Filter repositories by size (in KB)."""
    return [repo for repo in repos if min_size <= repo['size'] <= max_size]

def calculate_total_languages(repos, api):
    """Calculate total language distribution across all repos."""
    total_languages = {}
    
    for repo in repos:
        languages = api.get_repo_languages(repo['owner']['login'], repo['name'])
        for lang, bytes_count in languages.items():
            total_languages[lang] = total_languages.get(lang, 0) + bytes_count
    
    return total_languages

def export_to_csv(data, filename):
    """Export data to CSV file."""
    df = pd.DataFrame(data)
    csv = df.to_csv(index=False)
    return csv

@st.cache_data(ttl=3600)  # Cache for 1 hour
def get_cached_repo_data(username, token):
    """Cache repository data to reduce API calls."""
    cache_dir = ".cache"
    if not os.path.exists(cache_dir):
        os.makedirs(cache_dir)
    cache_file = os.path.join(cache_dir, f".cache_{username}.json")
    
    # Check if cache exists and is recent
    if os.path.exists(cache_file):
        try:
            with open(cache_file, 'r') as f:
                cache_data = json.load(f)
                cache_time = datetime.fromisoformat(cache_data['timestamp'])
                if datetime.now() - cache_time < timedelta(hours=1):
                    return cache_data['data']
        except Exception:
            pass # fallback to fetching fresh data if cache read/parse fails
    
    # Fetch fresh data
    from github_api import GitHubAPI
    api = GitHubAPI(token)
    repos = api.get_user_repos(username)
    
    # Save to cache
    cache_data = {
        'timestamp': datetime.now().isoformat(),
        'data': repos
    }
    try:
        with open(cache_file, 'w') as f:
            json.dump(cache_data, f)
    except Exception:
        pass
    
    return repos

def fetch_single_repo_details(api, repo):
    """Fetch details for a single repository."""
    owner = repo['owner']['login']
    name = repo['name']
    try:
        issues_count = api.get_repo_issues(owner, name)
        pulls_count = api.get_repo_pulls(owner, name)
        contributors = api.get_repo_contributors(owner, name, limit=5)
        contributors_count = len(contributors)
    except Exception:
        issues_count = 0
        pulls_count = 0
        contributors_count = 0
        
    return {
        'Repository': name,
        'Stars': repo['stargazers_count'],
        'Forks': repo['forks_count'],
        'Issues': issues_count,
        'Pull Requests': pulls_count,
        'Contributors': contributors_count,
        'Language': repo['language'] or 'None',
        'Size (KB)': repo['size'],
        'Created': repo['created_at'][:10],
        'Updated': repo['updated_at'][:10],
        'URL': repo['html_url'],
        'owner_login': owner
    }

def fetch_repos_details_concurrently(repos, api, max_workers=10):
    """Fetch details for multiple repositories concurrently."""
    results = []
    if not repos:
        return results
        
    with ThreadPoolExecutor(max_workers=max_workers) as executor:
        # Submit tasks
        future_to_repo = {
            executor.submit(fetch_single_repo_details, api, repo): repo 
            for repo in repos
        }
        # Collect results
        for future in as_completed(future_to_repo):
            try:
                repo_details = future.result()
                results.append(repo_details)
            except Exception:
                pass
                
    # Sort results to match original ordering or stars descending
    results.sort(key=lambda x: x['Stars'], reverse=True)
    return results

def format_number(num):
    """Format large numbers with K/M suffix."""
    if num >= 1_000_000:
        return f"{num/1_000_000:.1f}M"
    elif num >= 1_000:
        return f"{num/1_000:.1f}K"
    return str(num)