/**
 * Fetches public metadata for a GitHub repository.
 *
 * No authentication needed; GitHub allows 60 requests per hour from
 * an anonymous client (rate-limit headers are returned in the response).
 *
 * On 404, returns { found: false, owner, repo } instead of throwing.
 */

const url = 'https://api.github.com/repos/'
  + encodeURIComponent(owner) + '/' + encodeURIComponent(repo);

const resp = await fetch(url, {
  headers: {
    'Accept': 'application/vnd.github+json',
    'User-Agent': 'spring-ai-playground',
  },
  maxLength: 1_000_000,
});

if (resp.status === 404) return { found: false, owner, repo };
if (!resp.ok) return { success: false, status: resp.status, message: resp.text() };

const data = resp.json();
return {
  fullName:      data.full_name,
  description:   data.description,
  stars:         data.stargazers_count,
  forks:         data.forks_count,
  openIssues:    data.open_issues_count,
  language:      data.language,
  license:       data.license && data.license.spdx_id,
  defaultBranch: data.default_branch,
  lastPush:      data.pushed_at,
  topics:        data.topics || [],
  homepage:      data.homepage,
  htmlUrl:       data.html_url,
};

/**
 * Fetches GitHub public user / organisation profile.
 * Endpoint: GET https://api.github.com/users/{login}
 */

if (login == null || login === '') throw new Error('login required');
const resp = await fetch('https://api.github.com/users/' + encodeURIComponent(login), {
  headers: { 'Accept': 'application/vnd.github+json', 'User-Agent': 'spring-ai-playground' },
  maxLength: 1_000_000,
});
if (resp.status === 404) return { found: false, login };
if (!resp.ok) return { success: false, status: resp.status, message: resp.text() };
const d = resp.json();
return {
  login:       d.login,
  type:        d.type,
  name:        d.name,
  company:     d.company,
  blog:        d.blog,
  location:    d.location,
  bio:         d.bio,
  publicRepos: d.public_repos,
  publicGists: d.public_gists,
  followers:   d.followers,
  following:   d.following,
  createdAt:   d.created_at,
  htmlUrl:     d.html_url,
  avatarUrl:   d.avatar_url,
};

/**
 * Lists issues on a public GitHub repository.
 * Endpoint: GET https://api.github.com/repos/{owner}/{repo}/issues
 *
 * Pull requests are filtered out client-side (the API includes them in /issues
 * by default and they're indistinguishable except for the `pull_request` key).
 */

if (owner == null || owner === '') throw new Error('owner required');
if (repo  == null || repo  === '') throw new Error('repo required');
const n  = (Number.isInteger(perPage) && perPage > 0 && perPage <= 100) ? perPage : 10;
const pg = (Number.isInteger(page) && page > 0) ? page : 1;
const st = (state === 'closed' || state === 'all') ? state : 'open';

const url = 'https://api.github.com/repos/' + encodeURIComponent(owner) + '/' + encodeURIComponent(repo)
  + '/issues?state=' + st + '&per_page=' + n + '&page=' + pg;
const resp = await fetch(url, {
  headers: { 'Accept': 'application/vnd.github+json', 'User-Agent': 'spring-ai-playground' },
  maxLength: 5_000_000,
});
if (!resp.ok) return { success: false, status: resp.status, message: resp.text() };
const issues = resp.json();
return (issues || []).filter(i => !i.pull_request).map(i => ({
  number:       i.number,
  title:        i.title,
  state:        i.state,
  author:       i.user && i.user.login,
  labels:       (i.labels || []).map(l => typeof l === 'string' ? l : l.name),
  commentCount: i.comments,
  createdAt:    i.created_at,
  updatedAt:    i.updated_at,
  htmlUrl:      i.html_url,
}));

/**
 * Lists releases on a public GitHub repository.
 * Endpoint: GET https://api.github.com/repos/{owner}/{repo}/releases
 */

if (owner == null || owner === '') throw new Error('owner required');
if (repo  == null || repo  === '') throw new Error('repo required');
const n = (Number.isInteger(perPage) && perPage > 0 && perPage <= 30) ? perPage : 5;

const url = 'https://api.github.com/repos/' + encodeURIComponent(owner) + '/' + encodeURIComponent(repo)
  + '/releases?per_page=' + n;
const resp = await fetch(url, {
  headers: { 'Accept': 'application/vnd.github+json', 'User-Agent': 'spring-ai-playground' },
  maxLength: 5_000_000,
});
if (!resp.ok) return { success: false, status: resp.status, message: resp.text() };
return (resp.json() || []).map(r => ({
  tag:         r.tag_name,
  name:        r.name,
  draft:       r.draft,
  prerelease:  r.prerelease,
  publishedAt: r.published_at,
  htmlUrl:     r.html_url,
  body:        r.body,
}));

/**
 * Fetches the latest stable release of a public GitHub repository.
 * Endpoint: GET https://api.github.com/repos/{owner}/{repo}/releases/latest
 */

if (owner == null || owner === '') throw new Error('owner required');
if (repo  == null || repo  === '') throw new Error('repo required');

const url = 'https://api.github.com/repos/' + encodeURIComponent(owner) + '/' + encodeURIComponent(repo)
  + '/releases/latest';
const resp = await fetch(url, {
  headers: { 'Accept': 'application/vnd.github+json', 'User-Agent': 'spring-ai-playground' },
  maxLength: 2_000_000,
});
if (resp.status === 404) return { found: false, owner, repo };
if (!resp.ok) return { success: false, status: resp.status, message: resp.text() };
const r = resp.json();
return {
  tag:         r.tag_name,
  name:        r.name,
  publishedAt: r.published_at,
  htmlUrl:     r.html_url,
  body:        r.body,
  assets:      (r.assets || []).map(a => ({
    name: a.name, downloadUrl: a.browser_download_url, size: a.size,
  })),
};

/**
 * Fetches a file (or directory listing) from a public GitHub repository.
 * Endpoint: GET https://api.github.com/repos/{owner}/{repo}/contents/{path}?ref={ref}
 *
 * File response: base64-encoded content + sha + size. We decode to UTF-8 text.
 * Directory response: array of entries; we return a slimmed listing.
 */

if (owner == null || owner === '') throw new Error('owner required');
if (repo  == null || repo  === '') throw new Error('repo required');
if (path  == null || path  === '') throw new Error('path required');

const refQs = (ref && ref !== '') ? ('?ref=' + encodeURIComponent(ref)) : '';
const segments = String(path).split('/').filter(Boolean).map(encodeURIComponent).join('/');
const url = 'https://api.github.com/repos/' + encodeURIComponent(owner) + '/' + encodeURIComponent(repo)
  + '/contents/' + segments + refQs;
const resp = await fetch(url, {
  headers: { 'Accept': 'application/vnd.github+json', 'User-Agent': 'spring-ai-playground' },
  maxLength: 5_000_000,
});
if (resp.status === 404) return { found: false, owner, repo, path };
if (!resp.ok) return { success: false, status: resp.status, message: resp.text() };
const data = resp.json();
if (Array.isArray(data)) {
  // Directory listing
  return data.map(e => ({ name: e.name, type: e.type, path: e.path, size: e.size }));
}
// File - decode base64 content. GitHub wraps lines every 60 chars; strip whitespace first.
if (data.encoding !== 'base64' || data.type !== 'file') {
  return { found: true, type: data.type, name: data.name, path: data.path, size: data.size,
           note: 'unsupported content; use a smaller file or different endpoint' };
}
const b64 = String(data.content || '').replace(/\s+/g, '');
const bin = atob(b64);
const bytes = new Uint8Array(bin.length);
for (let i = 0; i < bin.length; i++) bytes[i] = bin.charCodeAt(i);
const text = new TextDecoder('utf-8', { fatal: false }).decode(bytes);
return { name: data.name, path: data.path, size: data.size, sha: data.sha,
         encoding: 'utf-8', content: text };

/**
 * Searches public GitHub repositories.
 * Endpoint: GET https://api.github.com/search/repositories?q=...&sort=...&per_page=...
 *
 * Anonymous rate limit: 10 requests / minute / IP.
 */

if (query == null || query === '') throw new Error('query required');
const n = (Number.isInteger(perPage) && perPage > 0 && perPage <= 30) ? perPage : 5;
const sortValid = (sort === 'stars' || sort === 'forks' || sort === 'updated');
const sortQs = sortValid ? ('&sort=' + sort + '&order=desc') : '';

const url = 'https://api.github.com/search/repositories?q=' + encodeURIComponent(query)
  + '&per_page=' + n + sortQs;
const resp = await fetch(url, {
  headers: { 'Accept': 'application/vnd.github+json', 'User-Agent': 'spring-ai-playground' },
  maxLength: 5_000_000,
});
if (!resp.ok) return { success: false, status: resp.status, message: resp.text() };
const data = resp.json();
return (data.items || []).map(r => ({
  fullName:    r.full_name,
  description: r.description,
  stars:       r.stargazers_count,
  forks:       r.forks_count,
  language:    r.language,
  htmlUrl:     r.html_url,
  updatedAt:   r.updated_at,
}));

/**
 * Lists top contributors to a public GitHub repository.
 * Endpoint: GET https://api.github.com/repos/{owner}/{repo}/contributors
 */

if (owner == null || owner === '') throw new Error('owner required');
if (repo  == null || repo  === '') throw new Error('repo required');
const n = (Number.isInteger(perPage) && perPage > 0 && perPage <= 100) ? perPage : 10;

const url = 'https://api.github.com/repos/' + encodeURIComponent(owner) + '/' + encodeURIComponent(repo)
  + '/contributors?per_page=' + n;
const resp = await fetch(url, {
  headers: { 'Accept': 'application/vnd.github+json', 'User-Agent': 'spring-ai-playground' },
  maxLength: 2_000_000,
});
if (!resp.ok) return { success: false, status: resp.status, message: resp.text() };
return (resp.json() || []).map(c => ({
  login:         c.login,
  contributions: c.contributions,
  htmlUrl:       c.html_url,
  avatarUrl:     c.avatar_url,
}));