// The hub client: typed fetch over /api/v1 (hub spec §12.1) using the

// generated types in hubapi.d.ts, plus URL helpers. No vscode imports,

// so it is tested with plain Node against a real hub.

import type * as api from "./hubapi";

export class HubError extends Error {

  constructor(

    readonly status: number,

    readonly title: string,

    readonly detail: string,

  ) {

    super(`${status} ${title}: ${detail}`);

  }

}

/** `https://hub/owner/name` → { base, owner, name }; undefined for anything else. */

export function parseRepoUrl(url: string): { base: string; owner: string; name: string } | undefined {

  const m = /^(https?:\/\/[^/]+)\/([A-Za-z0-9][A-Za-z0-9._-]*)\/([A-Za-z0-9][A-Za-z0-9._-]*)\/?$/.exec(url.trim());

  if (!m || m[2] === "api") {

    return undefined;

  }

  return { base: m[1], owner: m[2], name: m[3] };

}

export interface Session {

  base: string;

  token: string;

  username?: string;

}

export class HubClient {

  constructor(

    readonly base: string,

    private readonly token: string | undefined,

    private readonly fetchImpl: typeof fetch = fetch,

  ) {}

  private async request<T>(method: string, path: string, body?: unknown): Promise<T> {

    const headers: Record<string, string> = { accept: "application/json" };

    if (this.token) {

      headers.authorization = `Bearer ${this.token}`;

    }

    if (body !== undefined) {

      headers["content-type"] = "application/json";

    }

    const res = await this.fetchImpl(`${this.base}/api/v1${path}`, { method, headers, body: body === undefined ? undefined : JSON.stringify(body) });

    if (res.status === 204) {

      return undefined as T;

    }

    const text = await res.text();

    if (!res.ok) {

      try {

        const p = JSON.parse(text) as api.Problem;

        throw new HubError(p.status, p.title, p.detail);

      } catch (e) {

        if (e instanceof HubError) {

          throw e;

        }

        throw new HubError(res.status, res.statusText, text);

      }

    }

    return (text ? JSON.parse(text) : undefined) as T;

  }

  me(): Promise<api.User> {

    return this.request("GET", "/user");

  }

  repositories(): Promise<api.Repository[]> {

    return this.request("GET", "/repos");

  }

  repository(owner: string, name: string): Promise<api.Repository> {

    return this.request("GET", `/repos/${owner}/${name}`);

  }

  proposals(owner: string, name: string): Promise<api.Proposal[]> {

    return this.request("GET", `/repos/${owner}/${name}/proposals`);

  }

  proposal(owner: string, name: string, number: number): Promise<api.Proposal> {

    return this.request("GET", `/repos/${owner}/${name}/proposals/${number}`);

  }

  createProposal(owner: string, name: string, p: api.NewProposal): Promise<api.Proposal> {

    return this.request("POST", `/repos/${owner}/${name}/proposals`, p);

  }

  proposalComments(owner: string, name: string, number: number): Promise<api.Comment[]> {

    return this.request("GET", `/repos/${owner}/${name}/proposals/${number}/comments`);

  }

  /** A comment; with `path` and `line` it is anchored to that line's atom in the projected state. */

  commentProposal(owner: string, name: string, number: number, body: string, path?: string, line?: number): Promise<api.Comment> {

    return this.request("POST", `/repos/${owner}/${name}/proposals/${number}/comments`, { body, path: path ?? null, line: line ?? null });

  }

  reviews(owner: string, name: string, number: number): Promise<api.Review[]> {

    return this.request("GET", `/repos/${owner}/${name}/proposals/${number}/reviews`);

  }

  review(owner: string, name: string, number: number, verdict: "comment" | "changes" | "approve", body = ""): Promise<api.Review> {

    return this.request("POST", `/repos/${owner}/${name}/proposals/${number}/reviews`, { verdict, body });

  }

  proposalChecks(owner: string, name: string, number: number): Promise<api.Check[]> {

    return this.request("GET", `/repos/${owner}/${name}/proposals/${number}/checks`);

  }

  issues(owner: string, name: string, state: "open" | "closed" | "all" = "open"): Promise<api.Issue[]> {

    return this.request("GET", `/repos/${owner}/${name}/issues?state=${state}`);

  }

  issue(owner: string, name: string, number: number): Promise<api.Issue> {

    return this.request("GET", `/repos/${owner}/${name}/issues/${number}`);

  }

  createIssue(owner: string, name: string, title: string, body = ""): Promise<api.Issue> {

    return this.request("POST", `/repos/${owner}/${name}/issues`, { title, body });

  }

  issueComments(owner: string, name: string, number: number): Promise<api.Comment[]> {

    return this.request("GET", `/repos/${owner}/${name}/issues/${number}/comments`);

  }

  commentIssue(owner: string, name: string, number: number, body: string): Promise<api.Comment> {

    return this.request("POST", `/repos/${owner}/${name}/issues/${number}/comments`, { body });

  }

  setIssueState(owner: string, name: string, number: number, state: "open" | "closed", reason = ""): Promise<api.Issue> {

    return this.request("POST", `/repos/${owner}/${name}/issues/${number}`, { state, reason });

  }

  history(owner: string, name: string, reference: string, limit = 50): Promise<api.History> {

    return this.request("GET", `/repos/${owner}/${name}/history/${encodeURIComponent(reference)}?limit=${limit}`);

  }

  bookmarks(owner: string, name: string): Promise<api.Bookmark[]> {

    return this.request("GET", `/repos/${owner}/${name}/bookmarks`);

  }

  search(q: string): Promise<{ kind: string; repository: string; number: number; title: string }[]> {

    return this.request("GET", `/search?q=${encodeURIComponent(q)}`);

  }

}

/** Web URLs on the hub for things the remote provider is asked about. */

export function hubUrl(base: string, owner: string, name: string, target: { kind: string; [k: string]: unknown }): string {

  const repo = `${base}/${owner}/${name}`;

  switch (target.kind) {

    case "repository":

      return repo;

    case "bookmark":

      return `${repo}/tree/${encodeURIComponent(String(target.name))}`;

    case "change":

      return `${repo}/change/${target.hash}`;

    case "file": {

      const line = typeof target.line === "number" ? `#L${target.line}` : "";

      return `${repo}/file/${encodeURIComponent(String(target.reference))}/${String(target.path)}${line}`;

    }

    case "proposals":

      return `${repo}/proposals`;

    case "issues":

      return `${repo}/issues`;

    case "proposal":

      return `${repo}/proposal/${target.number}`;

    case "issue":

      return `${repo}/issue/${target.number}`;

    default:

      return repo;

  }

}

/** Which of the proposals need the signed-in user: not theirs, and not yet sealed by them. */

export function needsMe(p: import("./hubapi").Proposal, username: string | undefined): boolean {

  if (!username || p.author === username) {

    return false;

  }

  if (p.state !== "open") {

    return false;

  }

  const mine = p.approvals.find((a) => a.account === username);

  return !mine || !mine.sealed;

}