github_api.py

"""
Service for interacting with GitHub API with rate limiting and error handling.
"""

from typing import List, Optional, Dict, Any, AsyncIterator, Callable
import datetime
import asyncio
import httpx
from github import Github, GithubException
# from github.Repository import Repository as GithubRepository

# from ..infrastructure.rate_limiter import RateLimiter
# from ..infrastructure.retry_manager import RetryManager
from ..infrastructure import (
    handle_api_error,
    RateLimitError,
    RepositoryNotFoundError,
    DownloadError,
    RateLimiter,
    RetryManager,
    CacheManager,
    RateLimitInfo
)
# from ..infrastructure.cache_manager import CacheManager
from ..models import RepositoryInfo, GitReference, RepositoryType, GitHubFile
from ..models.constants import USER_AGENT

from forklet.infrastructure.logger import logger


####
##      GITHUB API SERVICE
#####
class GitHubAPIService:
    """
    Async service for interacting with GitHub API with comprehensive error handling.
    Focused solely on GitHub API interactions - no file system operations.
    """

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

    def __init__(
        self,
        rate_limiter: RateLimiter,
        retry_manager: RetryManager,
        auth_token: Optional[str] = None,
        timeout: int = 30,
    ):
        self.rate_limiter = rate_limiter
        self.retry_manager = retry_manager
        self.auth_token = auth_token
        self.timeout = timeout
        self._concurrency_adjustment_callback: Optional[
            Callable[[RateLimitInfo], None]
        ] = None
        # Set up rate limit callback to adjust concurrency
        self.rate_limiter.set_rate_limit_callback(self._on_rate_limit_update)

    def set_external_rate_limit_callback(
        self, callback: Callable[[RateLimitInfo], None]
    ) -> None:
        """Set an external callback to be invoked when rate limit information is updated."""
        self._external_rate_limit_callback = callback

    def _on_rate_limit_update(self, rate_limit_info: RateLimitInfo) -> None:
        """Internal callback for rate limit updates - adjusts download concurrency based on rate limit status."""
        # This is a placeholder - in a full implementation, this would adjust the
        # concurrency settings in the DownloadOrchestrator based on rate limit status
        # For now, we just log when we're getting low on rate limits
        if rate_limit_info.remaining < 100:
            logger.warning(
                f"GitHub API rate limit low: {rate_limit_info.remaining}/{rate_limit_info.limit} remaining"
            )
        elif rate_limit_info.is_exhausted:
            logger.warning(
                f"GitHub API rate limit exhausted: {rate_limit_info.remaining}/{rate_limit_info.limit} remaining"
            )

        # Configure HTTP client
        headers = {"Accept": "application/vnd.github.v3+json", "User-Agent": USER_AGENT}

        if self.auth_token:
            headers["Authorization"] = f"token {self.auth_token}"

        self.http_client = httpx.AsyncClient(
            headers=headers, timeout=httpx.Timeout(self.timeout)
        )

        # Sync client for PyGithub (used only for metadata)
        self.github_client = (
            Github(
                self.auth_token, retry=self.retry_manager.max_retries, user_agent=USER_AGENT
            )
            if self.auth_token
            else Github(retry=self.retry_manager.max_retries, user_agent=USER_AGENT)
        )

    async def update_rate_limit_info(self, headers: Dict[str, str]) -> None:
        """Update rate limit information from API response headers."""

        async with self._lock:
            try:
                self._rate_limit_info.limit = int(
                    headers.get("x-ratelimit-limit", 5000)
                )
                self._rate_limit_info.remaining = int(
                    headers.get("x-ratelimit-remaining", 5000)
                )
                self._rate_limit_info.used = int(headers.get("x-ratelimit-used", 0))

                reset_timestamp = headers.get("x-ratelimit-reset")
                if reset_timestamp:
                    self._rate_limit_info.reset_time = datetime.fromtimestamp(
                        int(reset_timestamp)
                    )

                # Track consecutive rate limit hits
                if self._rate_limit_info.is_exhausted:
                    self._consecutive_limits += 1
                else:
                    self._consecutive_limits = 0

                # Invoke internal callback if set
                if self._rate_limit_callback:
                    self._rate_limit_callback(self._rate_limit_info)
                # Invoke external callback if set
                if self._external_rate_limit_callback:
                    self._external_rate_limit_callback(self._rate_limit_info)

            except (ValueError, KeyError) as e:
                logger.warning(f"Failed to parse rate limit headers: {e}")

        # Configure HTTP client
        headers = {"Accept": "application/vnd.github.v3+json", "User-Agent": USER_AGENT}

        if self.auth_token:
            headers["Authorization"] = f"token {self.auth_token}"

        self.http_client = httpx.AsyncClient(
            headers=headers, timeout=httpx.Timeout(self.timeout)
        )

        # Sync client for PyGithub (used only for metadata)
        self.github_client = (
            Github(
                self.auth_token, retry=self.retry_manager.max_retries, user_agent=USER_AGENT
            )
            if self.auth_token
            else Github(retry=self.retry_manager.max_retries, user_agent=USER_AGENT)
        )

    async def __aenter__(self):
        """Async context manager entry."""

        return self

    async def __aexit__(self, exc_type, exc_val, exc_tb):
        """Async context manager exit."""

        await self.close()

    async def close(self):
        """Close the HTTP client."""
        await self.http_client.aclose()

    @handle_api_error
    async def get_repository_info(self, owner: str, repo: str) -> RepositoryInfo:
        """
        Get comprehensive information about a repository.

        Args:
            owner: Repository owner
            repo: Repository name

        Returns:
            RepositoryInfo object with repository metadata

        Raises:
            RepositoryNotFoundError: If repository doesn't exist
            AuthenticationError: If authentication fails
        """

        try:
            # Use sync client for this operation as it's metadata-focused
            await self.rate_limiter.acquire()
            github_repo = await asyncio.to_thread(
                lambda: self.github_client.get_repo(f"{owner}/{repo}")
            )

            return RepositoryInfo(
                owner=owner,
                name=repo,
                full_name=github_repo.full_name,
                url=github_repo.html_url,
                default_branch=github_repo.default_branch,
                repo_type=RepositoryType.PRIVATE
                if github_repo.private
                else RepositoryType.PUBLIC,
                size=github_repo.size,
                is_private=github_repo.private,
                is_fork=github_repo.fork,
                created_at=github_repo.created_at,
                updated_at=github_repo.updated_at,
                language=github_repo.language,
                description=github_repo.description,
                topics=github_repo.get_topics(),
            )

        except GithubException as e:
            if e.status == 404:
                raise RepositoryNotFoundError(f"Repository {owner}/{repo} not found")
            raise

    @handle_api_error
    async def resolve_reference(self, owner: str, repo: str, ref: str) -> GitReference:
        """
        Resolve a Git reference (branch, tag, or commit) to a specific commit SHA.

        Args:
            owner: Repository owner
            repo: Repository name
            ref: Branch name, tag name, or commit SHA

        Returns:
            GitReference object with resolved SHA

        Raises:
            ValueError: If reference cannot be resolved
        """

        # Define reference types to try in order
        reference_types = [
            (
                "branch",
                lambda: self.github_client.get_repo(f"{owner}/{repo}").get_branch(ref),
            ),
            ("tag", lambda: self._get_tag(ref, owner, repo)),
            (
                "commit",
                lambda: self.github_client.get_repo(f"{owner}/{repo}").get_commit(ref),
            ),
        ]

        for ref_type, getter_func in reference_types:
            try:
                await self.rate_limiter.acquire()
                github_obj = await asyncio.to_thread(getter_func)
                return GitReference(
                    name=ref, ref_type=ref_type, sha=github_obj.commit.sha
                )
            except GithubException:
                continue  # Try next reference type

        raise ValueError(
            f"Could not resolve reference '{ref}' for repository {owner}/{repo}"
        )

    async def _get_tag(self, tag_name: str, owner: str, repo: str):
        """Helper to get a tag by name - needed because get_tags() returns a list."""
        tags = await asyncio.to_thread(
            lambda: list(self.github_client.get_repo(f"{owner}/{repo}").get_tags())
        )
        for tag in tags:
            if tag.name == tag_name:
                return tag
        raise GithubException(status=404, data={"message": f"Tag {tag_name} not found"})

    @handle_api_error
    async def get_repository_tree(
        self, owner: str, repo: str, ref: GitReference, recursive: bool = True
    ) -> List[GitHubFile]:
        """
        Get the complete file tree for a repository at a specific reference.

        Args:
            owner: Repository owner
            repo: Repository name
            ref: GitReference object
            recursive: Whether to get recursive tree

        Returns:
            List of GitHubFile objects

        Raises:
            RateLimitError: If rate limits are exceeded
        """

        url = f"{self.BASE_URL}/repos/{owner}/{repo}/git/trees/{ref.sha}"
        params = {"recursive": "1"} if recursive else {}

        try:
            await self.rate_limiter.acquire()
            response = await self.retry_manager.execute(
                lambda: self.http_client.get(url, params=params)
            )

            # Update rate limit info
            await self.rate_limiter.update_rate_limit_info(response.headers)

            response.raise_for_status()
            tree_data = response.json()

            files = []
            for item in tree_data.get("tree", []):
                # Only include files (blobs), not directories
                if item["type"] == "blob":
                    files.append(
                        GitHubFile(
                            path=item["path"],
                            type=item["type"],
                            size=item.get("size", 0),
                            download_url=item.get("url"),
                            sha=item.get("sha"),
                            html_url=item.get("html_url"),
                        )
                    )

            return files

        except httpx.HTTPStatusError as e:
            if e.response.status_code == 403:
                raise RateLimitError("GitHub API rate limit exceeded")
            raise

    @handle_api_error
    async def get_file_content(
        self, download_url: str, stream: bool = False
    ) -> bytes | AsyncIterator[bytes]:
        """
        Download file content from GitHub API.

        Args:
            download_url: GitHub API URL for the file content

        Returns:
            File content as bytes (already decoded from base64)

        Raises:
            DownloadError: If download fails
        """

        try:
            await self.rate_limiter.acquire()
            response = await self.retry_manager.execute(
                lambda: self.http_client.get(download_url)
            )

            response.raise_for_status()

            # GitHub API returns base64 encoded content
            content_data = response.json()
            if "content" in content_data:
                import base64

                return base64.b64decode(content_data["content"])
            else:
                raise DownloadError(
                    f"No content found in API response for {download_url}"
                )

        except httpx.RequestError as e:
            raise DownloadError(f"Failed to download file from {download_url}: {e}")

    @handle_api_error
    async def get_directory_content(
        self, owner: str, repo: str, path: str, ref: GitReference
    ) -> List[GitHubFile]:
        """
        Get content of a specific directory.

        Args:
            owner: Repository owner
            repo: Repository name
            path: Directory path
            ref: GitReference object

        Returns:
            List of GitHubFile objects in the directory
        """

        url = f"{self.BASE_URL}/repos/{owner}/{repo}/contents/{path}"
        params = {"ref": ref.sha}

        await self.rate_limiter.acquire()
        response = await self.retry_manager.execute(
            lambda: self.http_client.get(url, params=params)
        )

        response.raise_for_status()
        contents = response.json()

        files = []
        for item in contents:
            if item["type"] == "file":  # Only include files
                files.append(
                    GitHubFile(
                        path=item["path"],
                        type=item["type"],
                        size=item.get("size", 0),
                        download_url=item.get("download_url"),
                        sha=item.get("sha"),
                        html_url=item.get("html_url"),
                    )
                )

        return files

    async def get_rate_limit_info(self) -> Dict[str, Any]:
        """
        Get current rate limit information.

        Returns:
            Dictionary with rate limit information
        """

        url = f"{self.BASE_URL}/rate_limit"

        await self.rate_limiter.acquire()
        response = await self.retry_manager.execute(lambda: self.http_client.get(url))

        response.raise_for_status()
        return response.json()

    async def test_connection(self) -> bool:
        """
        Test connection to GitHub API.

        Returns:
            True if connection is successful, False otherwise
        """

        try:
            await self.get_rate_limit_info()
            return True
        except Exception as e:
            logger.error(f"GitHub API connection test failed: {e}")
            return False