// 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`);
  }

  commentProposal(owner: string, name: string, number: number, body: string): Promise<api.Comment> {
    return this.request("POST", `/repos/${owner}/${name}/proposals/${number}/comments`, { body });
  }

  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;
}