"""
llm‑github‑issues fragment plug‑in
=================================

Fragment notation
-----------------
{issue:owner/repo/NUMBER}

Example
-------
{issue:pallets/flask/5481}
"""
from __future__ import annotations

import os
from typing import Tuple, List

import httpx
import llm


# ----------------------------------------------------------------------
# Public hook
# ----------------------------------------------------------------------
@llm.hookimpl
def register_fragment_loaders(register):
    # Anything that starts with   issue:…   is routed to github_issue_loader
    register("issue", github_issue_loader)


# ----------------------------------------------------------------------
# Loader implementation
# ----------------------------------------------------------------------
def github_issue_loader(argument: str) -> llm.Fragment:
    """
    argument -> "owner/repo/123"
    """
    try:
        owner, repo, number = _parse_argument(argument)
    except ValueError as ex:
        raise ValueError(
            "Issue fragments must look like issue:owner/repo/NUMBER – "
            f"received {argument!r}"
        ) from ex

    client = _make_github_client()

    # 1. Fetch the issue itself
    issue_url = f"https://api.github.com/repos/{owner}/{repo}/issues/{number}"
    issue_resp = client.get(issue_url)
    _raise_for_status(issue_resp, issue_url)
    issue = issue_resp.json()

    # 2. Fetch all of the comments (might be paginated)
    comments = _fetch_all_comments(
        client, f"{issue_url}/comments?per_page=100"
    )

    # 3. Convert to Markdown
    markdown = _build_markdown(issue, comments)

    return llm.Fragment(
        markdown,
        # Visible link shown by llm
        source=f"https://github.com/{owner}/{repo}/issues/{number}",
    )


# ----------------------------------------------------------------------
# Helper functions
# ----------------------------------------------------------------------
def _parse_argument(argument: str) -> Tuple[str, str, int]:
    owner, repo, number = argument.split("/", 2)
    return owner, repo, int(number)


def _make_github_client() -> httpx.Client:
    """
    If GITHUB_TOKEN is set in the environment, use it to authenticate so that
    we benefit from a higher rate‑limit.  Otherwise fall back to anonymous.
    """
    headers = {
        "Accept": "application/vnd.github+json",
    }
    token = os.getenv("GITHUB_TOKEN")
    if token:
        headers["Authorization"] = f"Bearer {token}"

    return httpx.Client(headers=headers, timeout=30.0)


def _raise_for_status(resp: httpx.Response, url: str) -> None:
    try:
        resp.raise_for_status()
    except httpx.HTTPStatusError as ex:
        raise ValueError(f"GitHub request failed [{resp.status_code}] for {url}") from ex


def _fetch_all_comments(client: httpx.Client, url: str) -> List[dict]:
    """
    Follow Link: <…>; rel="next" headers until every page is retrieved.
    """
    all_comments: List[dict] = []

    while url:
        resp = client.get(url)
        _raise_for_status(resp, url)
        all_comments.extend(resp.json())

        # Parse Link header, look for rel="next"
        link = resp.headers.get("Link")
        url = None
        if link:
            for part in link.split(","):
                part = part.strip()
                if part.endswith('rel="next"'):
                    url = part[part.find("<") + 1 : part.find(">")]
                    break

    return all_comments


def _build_markdown(issue: dict, comments: List[dict]) -> str:
    """
    Re‑implements the convertToMarkdown() logic from the HTML page.
    """
    md_parts: List[str] = []

    md_parts.append(f"# {issue['title']}\n")
    md_parts.append(f"*Posted by @{issue['user']['login']}*\n")
    if issue.get("body"):
        md_parts.append(f"{issue['body']}\n")

    if comments:
        md_parts.append("---\n")
        for comment in comments:
            md_parts.append(f"### Comment by @{comment['user']['login']}\n")
            if comment.get("body"):
                md_parts.append(comment["body"] + "\n")
            md_parts.append("---\n")

    # A final newline keeps the fragment pleasant to read
    return "\n".join(md_parts).rstrip() + "\n"

"""
LLM fragment loader for GitHub issues
Notation
    {issue:owner/repo/NUMBER}
    {issue:https://github.com/owner/repo/issues/NUMBER}
"""
from __future__ import annotations

import os
import re
from typing import Tuple, List
from urllib.parse import urlparse

import httpx
import llm


# ----------------------------------------------------------------------
# Fragment registration
# ----------------------------------------------------------------------
@llm.hookimpl
def register_fragment_loaders(register):
    register("issue", github_issue_loader)


# ----------------------------------------------------------------------
# Loader
# ----------------------------------------------------------------------
def github_issue_loader(argument: str) -> llm.Fragment:
    """
    argument is either
        "owner/repo/NUMBER"
    or  "https://github.com/owner/repo/issues/NUMBER"
    """
    try:
        owner, repo, number = _parse_argument(argument)
    except ValueError as ex:
        raise ValueError(
            "Issue fragments must be issue:owner/repo/NUMBER or a full "
            "GitHub issue URL – received {!r}".format(argument)
        ) from ex

    client = _github_client()

    issue_api = f"https://api.github.com/repos/{owner}/{repo}/issues/{number}"

    # 1. The issue itself -------------------------------------------------
    issue_resp = client.get(issue_api)
    _raise_for_status(issue_resp, issue_api)
    issue = issue_resp.json()

    # 2. All comments (pagination) ---------------------------------------
    comments = _get_all_pages(client, f"{issue_api}/comments?per_page=100")

    # 3. Markdown ---------------------------------------------------------
    markdown = _to_markdown(issue, comments)

    return llm.Fragment(
        markdown,
        source=f"https://github.com/{owner}/{repo}/issues/{number}",
    )


# ----------------------------------------------------------------------
# Helpers
# ----------------------------------------------------------------------
def _parse_argument(arg: str) -> Tuple[str, str, int]:
    """
    Returns (owner, repo, number) or raises ValueError
    """
    # Form 1: full URL ----------------------------------------------------
    if arg.startswith("https://") or arg.startswith("https://"):
        parsed = urlparse(arg)
        parts = parsed.path.strip("/").split("/")
        # /owner/repo/issues/123
        if len(parts) >= 4 and parts[2] == "issues":
            owner, repo, _, number = parts[:4]
            return owner, repo, int(number)

    # Form 2: owner/repo/number ------------------------------------------
    m = re.match(r"([^/]+)/([^/]+)/(\d+)$", arg)
    if m:
        owner, repo, number = m.groups()
        return owner, repo, int(number)

    raise ValueError("Unrecognised issue reference")


def _github_client() -> httpx.Client:
    headers = {"Accept": "application/vnd.github+json"}
    token = os.getenv("GITHUB_TOKEN")
    if token:
        headers["Authorization"] = f"Bearer {token}"
    return httpx.Client(headers=headers, timeout=30.0, follow_redirects=True)


def _raise_for_status(resp: httpx.Response, url: str) -> None:
    try:
        resp.raise_for_status()
    except httpx.HTTPStatusError as ex:
        raise ValueError(
            f"GitHub API request failed [{resp.status_code}] for {url}"
        ) from ex


def _get_all_pages(client: httpx.Client, url: str) -> List[dict]:
    items: List[dict] = []
    while url:
        resp = client.get(url)
        _raise_for_status(resp, url)
        items.extend(resp.json())

        # Link header pagination
        url = None
        link = resp.headers.get("Link")
        if link:
            for part in link.split(","):
                if part.endswith('rel="next"'):
                    url = part[part.find("<") + 1 : part.find(">")]
                    break
    return items


def _to_markdown(issue: dict, comments: List[dict]) -> str:
    md: List[str] = []
    md.append(f"# {issue['title']}\n")
    md.append(f"*Posted by @{issue['user']['login']}*\n")
    if issue.get("body"):
        md.append(issue["body"] + "\n")

    if comments:
        md.append("---\n")
        for c in comments:
            md.append(f"### Comment by @{c['user']['login']}\n")
            if c.get("body"):
                md.append(c["body"] + "\n")
            md.append("---\n")

    return "\n".join(md).rstrip() + "\n"