"""
HireSense AI — GitHub Analyzer Service
Fetches developer activity from GitHub REST API and computes scores.
"""

import requests
import base64
from datetime import datetime, timezone, timedelta
from typing import Optional
import statistics


class GitHubAnalyzer:
    """Analyzes a GitHub profile and computes activity-based scores."""

    BASE_URL = "https://api.github.com"

    # Files to fetch for deep context (README + dependency manifests)
    CONTEXT_FILES = [
        "README.md", "readme.md", "README.rst",
        "requirements.txt", "setup.py", "pyproject.toml",
        "package.json", "pom.xml", "build.gradle",
        "Cargo.toml", "go.mod",
    ]

    def __init__(self, token: Optional[str] = None):
        self.headers = {
            "Accept": "application/vnd.github.v3+json",
        }
        if token:
            self.headers["Authorization"] = f"Bearer {token}"
        self.has_token = bool(token)

    def analyze(self, username: str) -> dict:
        """
        Analyze a GitHub user profile.

        Returns dict with: username, profile, scores, details, explanations
        """
        # Fetch profile
        profile = self._fetch_profile(username)
        if profile.get("error"):
            return {
                "username": username,
                "user_not_found": True,
                "error": profile["error"],
                "scores": {"consistency": 0, "project_depth": 0, "tech_breadth": 0, "recency": 0, "overall": 0},
                "explanations": {"consistency": "User not found on GitHub", "project_depth": "N/A", "tech_breadth": "N/A", "recency": "N/A"},
            }

        # Fetch repos (excluding forks)
        repos = self._fetch_repos(username)
        original_repos = [r for r in repos if not r.get("fork", False)]

        # Fetch languages from top repos
        languages = self._fetch_languages(username, original_repos[:10])

        # Fetch commit activity from top repos
        commit_data = self._fetch_commit_activity(username, original_repos[:5])

        # Calculate scores
        consistency_score, consistency_expl = self._calculate_consistency_score(commit_data)
        depth_score, depth_expl = self._calculate_project_depth_score(original_repos)
        breadth_score, breadth_expl = self._calculate_tech_breadth_score(languages)
        recency_score, recency_expl = self._calculate_recency_score(original_repos, commit_data)

        # Overall = weighted average
        overall = (
            consistency_score * 0.30
            + depth_score * 0.25
            + breadth_score * 0.20
            + recency_score * 0.25
        )

        # Top repos for display
        top_repos = sorted(original_repos, key=lambda r: r.get("stargazers_count", 0), reverse=True)[:5]
        top_repos_display = [
            {
                "name": r["name"],
                "stars": r.get("stargazers_count", 0),
                "forks": r.get("forks_count", 0),
                "language": r.get("language"),
                "updated_at": r.get("pushed_at"),
            }
            for r in top_repos
        ]

        warnings = []
        if not self.has_token:
            warnings.append("No GitHub token — using unauthenticated requests (60 req/hour limit)")

        return {
            "username": username,
            "profile": {
                "name": profile.get("name") or username,
                "bio": profile.get("bio"),
                "public_repos": profile.get("public_repos", 0),
                "followers": profile.get("followers", 0),
                "following": profile.get("following", 0),
                "created_at": profile.get("created_at"),
                "avatar_url": profile.get("avatar_url"),
            },
            "scores": {
                "consistency": round(consistency_score, 1),
                "project_depth": round(depth_score, 1),
                "tech_breadth": round(breadth_score, 1),
                "recency": round(recency_score, 1),
                "overall": round(overall, 1),
            },
            "details": {
                "total_repos": len(original_repos),
                "total_stars": sum(r.get("stargazers_count", 0) for r in original_repos),
                "total_commits_sampled": sum(len(commits) for commits in commit_data.values()),
                "languages": languages,
                "top_repos": top_repos_display,
                "commit_months": self._get_monthly_counts(commit_data),
                "active_days": self._count_active_days(commit_data),
            },
            "repo_context": self._fetch_repo_context(username, original_repos[:5]),
            "explanations": {
                "consistency": consistency_expl,
                "project_depth": depth_expl,
                "tech_breadth": breadth_expl,
                "recency": recency_expl,
            },
            "warnings": warnings,
        }

    def _fetch_profile(self, username: str) -> dict:
        """Fetch GitHub user profile."""
        try:
            resp = requests.get(f"{self.BASE_URL}/users/{username}", headers=self.headers, timeout=10)
            if resp.status_code == 404:
                return {"error": f"GitHub user '{username}' not found"}
            if resp.status_code == 403:
                return {"error": "GitHub API rate limit exceeded"}
            resp.raise_for_status()
            return resp.json()
        except requests.RequestException as e:
            return {"error": f"GitHub API error: {str(e)}"}

    def _fetch_repos(self, username: str) -> list:
        """Fetch user repositories sorted by last pushed."""
        try:
            resp = requests.get(
                f"{self.BASE_URL}/users/{username}/repos",
                params={"per_page": 100, "sort": "pushed", "type": "owner"},
                headers=self.headers,
                timeout=15,
            )
            if resp.status_code != 200:
                return []
            return resp.json()
        except requests.RequestException:
            return []

    def _fetch_languages(self, username: str, repos: list) -> dict:
        """Aggregate languages across top repos."""
        languages = {}
        for repo in repos:
            try:
                resp = requests.get(
                    f"{self.BASE_URL}/repos/{username}/{repo['name']}/languages",
                    headers=self.headers,
                    timeout=10,
                )
                if resp.status_code == 200:
                    for lang, bytes_count in resp.json().items():
                        languages[lang] = languages.get(lang, 0) + bytes_count
            except requests.RequestException:
                continue
        return languages

    def _fetch_commit_activity(self, username: str, repos: list) -> dict:
        """Fetch recent commit dates from top repos."""
        commit_data = {}
        for repo in repos:
            try:
                resp = requests.get(
                    f"{self.BASE_URL}/repos/{username}/{repo['name']}/commits",
                    params={"per_page": 100, "author": username},
                    headers=self.headers,
                    timeout=10,
                )
                if resp.status_code == 200:
                    commits = resp.json()
                    dates = []
                    for c in commits:
                        if isinstance(c, dict) and "commit" in c:
                            date_str = c["commit"].get("author", {}).get("date", "")
                            if date_str:
                                dates.append(date_str)
                    commit_data[repo["name"]] = dates
            except requests.RequestException:
                continue
        return commit_data

    def _fetch_repo_context(self, username: str, repos: list) -> list:
        """
        Fetch README and dependency file contents from top repos.
        Returns lightweight text snippets for LLM context (not full codebase).
        """
        context_items = []
        seen_files = set()  # Avoid duplicates (e.g. README.md vs readme.md)

        for repo in repos[:3]:  # Limit to top 3 repos to keep payload small
            repo_name = repo.get("name", "")
            for filename in self.CONTEXT_FILES:
                # Skip if we already fetched a variant (readme.md vs README.md)
                file_key = f"{repo_name}:{filename.lower()}"
                if file_key in seen_files:
                    continue

                try:
                    resp = requests.get(
                        f"{self.BASE_URL}/repos/{username}/{repo_name}/contents/{filename}",
                        headers=self.headers,
                        timeout=8,
                    )
                    if resp.status_code == 200:
                        data = resp.json()
                        if data.get("encoding") == "base64" and data.get("content"):
                            raw = base64.b64decode(data["content"]).decode("utf-8", errors="replace")
                            # Truncate to 4000 chars per file to avoid bloat
                            truncated = raw[:4000]
                            context_items.append({
                                "repo": repo_name,
                                "file": filename,
                                "content": truncated,
                            })
                            seen_files.add(file_key)
                except (requests.RequestException, Exception):
                    continue

        return context_items

    def _get_monthly_counts(self, commit_data: dict) -> dict:
        """Bucket commit dates by month."""
        monthly = {}
        for repo_dates in commit_data.values():
            for date_str in repo_dates:
                try:
                    dt = datetime.fromisoformat(date_str.replace("Z", "+00:00"))
                    key = dt.strftime("%Y-%m")
                    monthly[key] = monthly.get(key, 0) + 1
                except (ValueError, AttributeError):
                    continue
        return dict(sorted(monthly.items()))

    def _count_active_days(self, commit_data: dict) -> int:
        """Count unique days with at least one commit."""
        days = set()
        for repo_dates in commit_data.values():
            for date_str in repo_dates:
                try:
                    dt = datetime.fromisoformat(date_str.replace("Z", "+00:00"))
                    days.add(dt.date())
                except (ValueError, AttributeError):
                    continue
        return len(days)

    def _calculate_consistency_score(self, commit_data: dict) -> tuple:
        """Score based on how evenly distributed commits are over time."""
        monthly = self._get_monthly_counts(commit_data)
        if not monthly:
            return 0.0, "No commit data available"

        counts = list(monthly.values())
        if len(counts) < 2:
            return 30.0, f"Only {len(counts)} month(s) of activity — insufficient data for consistency analysis"

        mean = statistics.mean(counts)
        stdev = statistics.stdev(counts)

        if mean == 0:
            return 0.0, "No commits found"

        cv = stdev / mean  # Coefficient of variation

        if cv < 0.3:
            score = 85 + min(15, len(counts) * 2)
            explanation = f"Very consistent activity across {len(counts)} months (CV={cv:.2f}). Commits are evenly distributed."
        elif cv < 0.6:
            score = 60 + min(20, len(counts))
            explanation = f"Moderately consistent across {len(counts)} months (CV={cv:.2f}). Some variation in activity levels."
        elif cv < 1.0:
            score = 35 + min(15, len(counts))
            explanation = f"Irregular activity pattern across {len(counts)} months (CV={cv:.2f}). Bursts of activity followed by quiet periods."
        else:
            score = max(10, 25 - int(cv * 5))
            explanation = f"Highly irregular activity (CV={cv:.2f}). Sporadic bursts with long gaps between contributions."

        return min(score, 100), explanation

    def _calculate_project_depth_score(self, repos: list) -> tuple:
        """Score based on project impact (stars, forks)."""
        if not repos:
            return 0.0, "No repositories found"

        total_stars = sum(r.get("stargazers_count", 0) for r in repos)
        total_forks = sum(r.get("forks_count", 0) for r in repos)
        max_stars = max((r.get("stargazers_count", 0) for r in repos), default=0)

        # Weighted impact score
        impact = total_stars * 3 + total_forks * 2

        if impact > 1000:
            score = 90 + min(10, impact // 500)
            explanation = f"High-impact projects: {total_stars} total stars, {total_forks} forks across {len(repos)} repos. Top repo has {max_stars} stars."
        elif impact > 200:
            score = 70 + min(20, impact // 50)
            explanation = f"Solid project portfolio: {total_stars} stars, {total_forks} forks. Shows meaningful community engagement."
        elif impact > 50:
            score = 45 + min(25, impact // 10)
            explanation = f"Growing portfolio: {total_stars} stars across {len(repos)} repos. Projects are gaining traction."
        elif impact > 10:
            score = 25 + min(20, impact)
            explanation = f"Early-stage projects: {total_stars} stars, {total_forks} forks. Building up a portfolio."
        else:
            score = max(10, len(repos) * 3)
            explanation = f"{len(repos)} repos with minimal community engagement. Focus on building public, impactful projects."

        return min(score, 100), explanation

    def _calculate_tech_breadth_score(self, languages: dict) -> tuple:
        """Score based on diversity of programming languages."""
        if not languages:
            return 0.0, "No language data available"

        lang_count = len(languages)

        # Filter out very minor languages (< 1% of total bytes)
        total_bytes = sum(languages.values())
        significant_langs = {
            lang: bytes_count
            for lang, bytes_count in languages.items()
            if bytes_count > total_bytes * 0.01
        }
        sig_count = len(significant_langs)

        if sig_count >= 7:
            score = 85 + min(15, sig_count - 7)
            explanation = f"Excellent breadth: {sig_count} significant languages ({', '.join(list(significant_langs.keys())[:6])}...). Versatile developer."
        elif sig_count >= 5:
            score = 65 + min(20, sig_count * 3)
            explanation = f"Good breadth: {sig_count} languages ({', '.join(significant_langs.keys())}). Comfortable across multiple tech stacks."
        elif sig_count >= 3:
            score = 45 + min(20, sig_count * 5)
            explanation = f"Moderate breadth: {sig_count} languages ({', '.join(significant_langs.keys())}). Room to explore more technologies."
        elif sig_count >= 1:
            score = 20 + sig_count * 10
            explanation = f"Narrow focus: {sig_count} language(s) ({', '.join(significant_langs.keys())}). Consider diversifying."
        else:
            score = 5
            explanation = "No significant language usage detected."

        return min(score, 100), explanation

    def _calculate_recency_score(self, repos: list, commit_data: dict) -> tuple:
        """Score based on how recently the user has been active."""
        now = datetime.now(timezone.utc)
        most_recent = None

        # Check commit dates
        for repo_dates in commit_data.values():
            for date_str in repo_dates:
                try:
                    dt = datetime.fromisoformat(date_str.replace("Z", "+00:00"))
                    if most_recent is None or dt > most_recent:
                        most_recent = dt
                except (ValueError, AttributeError):
                    continue

        # Also check repo pushed_at dates
        for repo in repos:
            pushed_at = repo.get("pushed_at")
            if pushed_at:
                try:
                    dt = datetime.fromisoformat(pushed_at.replace("Z", "+00:00"))
                    if most_recent is None or dt > most_recent:
                        most_recent = dt
                except (ValueError, AttributeError):
                    continue

        if most_recent is None:
            return 0.0, "No activity timestamps found"

        days_ago = (now - most_recent).days

        if days_ago <= 7:
            score = 95
            explanation = f"Very active — last contribution {days_ago} day(s) ago. Currently engaged."
        elif days_ago <= 30:
            score = 80
            explanation = f"Recently active — last contribution {days_ago} days ago. Regular contributor."
        elif days_ago <= 90:
            score = 60
            explanation = f"Moderately recent — last active {days_ago} days ago. Some gap in activity."
        elif days_ago <= 180:
            score = 40
            explanation = f"Declining activity — last active {days_ago} days ago ({days_ago // 30} months). May be focused elsewhere."
        elif days_ago <= 365:
            score = 25
            explanation = f"Inactive for {days_ago // 30} months. Limited recent contribution evidence."
        else:
            score = 10
            explanation = f"Inactive for {days_ago // 365}+ years. GitHub may not reflect current abilities."

        return score, explanation