import * as Effect from "effect/Effect";
import type {
  PullRequestActor,
  PullRequestCapabilities,
  PullRequestViewerPermissions,
} from "@t3tools/contracts";

import * as GitHubPullRequestCli from "./GitHubPullRequestCli.ts";
import {
  PullRequestProviderError,
  type ProviderChangeRequestActivity,
  type ProviderChangeRequestDetail,
  type PullRequestProviderApi,
} from "./PullRequestProvider.ts";
import type { GitHubViewerAccess } from "./gitHubPullRequestJson.ts";

const CAPABILITIES: PullRequestCapabilities = {
  diff: true,
  comment: true,
  actions: ["merge", "ready", "draft", "close", "reopen"],
  mergeMethods: ["merge", "squash", "rebase"],
  search: true,
  review: {
    inlineComment: true,
    reply: true,
    resolve: true,
    verdicts: ["comment", "approve", "request-changes"],
  },
  reviewers: { request: true, listCandidates: true },
};

/**
 * What the signed-in account may do here, from the three things GitHub says about it.
 *
 * Merging needs a role that can push, which is the one thing a stranger on an open-source
 * repository never has. The other four actions go by `viewerCanUpdate`, because the author of a
 * pull request may close it, reopen it and move it in and out of draft with no more than read
 * access on the repository it was opened against.
 *
 * Commenting and reviewing are not gated at all: read access is enough to say something and
 * enough to approve or ask for changes, which is what open-source review consists of. Resolving a
 * conversation is the exception — GitHub allows it to whoever can write, and to the author of the
 * pull request the conversation is on.
 *
 * Asking somebody else for a review needs write access, which is the one thing here an author
 * cannot do on their own pull request: GitHub shows an outside contributor the reviewer control
 * and refuses the request behind it.
 */
export function gitHubViewerPermissions(access: GitHubViewerAccess): PullRequestViewerPermissions {
  return {
    actions: [
      ...(access.canWrite ? (["merge"] as const) : []),
      ...(access.canUpdate ? (["ready", "draft", "close", "reopen"] as const) : []),
    ],
    comment: true,
    resolve: access.canWrite || access.didAuthor,
    // Anyone may review a pull request they can see, except their own: GitHub refuses an author's
    // approval and their request for changes ("Can not approve your own pull request"), and
    // leaves them commenting, which is what an author has to say about their own change anyway.
    verdicts: access.didAuthor ? (["comment"] as const) : CAPABILITIES.review.verdicts,
    requestReviewers: access.canWrite,
  };
}

/** The CLI tags that mean the tool itself is unusable, rather than one request failing. */
function reasonFor(
  error: GitHubPullRequestCli.GitHubPullRequestCliError,
): PullRequestProviderError["reason"] {
  if (error._tag === "GitHubCliUnavailableError") return "missing-tool";
  if (error._tag === "GitHubCliAuthenticationError") return "unauthenticated";
  return "failed";
}

/**
 * `gh pr view --json` reports no avatar for anyone, so the ones the GraphQL read collected are
 * applied here by login. An actor already carrying one keeps it.
 *
 * A login GitHub did not answer for falls back to the picture every GitHub install serves at
 * `/<login>.png`. The lookup is one more request per repository and can be refused — a rate
 * limit, a slow host — and a face that comes and goes between two loads of the same page reads
 * as a bug in the page rather than as a request that failed quietly.
 */
function withAvatar(
  actor: PullRequestActor | null,
  avatarsByLogin: ReadonlyMap<string, string>,
  host: string,
): PullRequestActor | null {
  if (actor === null || actor.avatarUrl !== null) return actor;
  const avatarUrl = avatarsByLogin.get(actor.login) ?? loginAvatarUrl(actor.login, host);
  return avatarUrl === null ? actor : { ...actor, avatarUrl };
}

/**
 * Null for anything that is not a plain user login: an app posts as `dependabot[bot]`, which
 * names no page, and a guessed URL that 404s is worse than the initials it would replace.
 */
export function loginAvatarUrl(login: string, host: string): string | null {
  return /^[a-z0-9][a-z0-9-]{0,38}$/iu.test(login) ? `https://${host}/${login}.png?size=80` : null;
}

export const make = Effect.gen(function* () {
  const cli = yield* GitHubPullRequestCli.GitHubPullRequestCli;

  const fail = (operation: string) => (error: GitHubPullRequestCli.GitHubPullRequestCliError) =>
    new PullRequestProviderError({
      provider: "github",
      operation,
      reason: reasonFor(error),
      detail: error.detail,
      cause: error,
    });

  const provider: PullRequestProviderApi = {
    kind: "github",
    capabilities: CAPABILITIES,

    getViewer: (input) =>
      cli.getViewerLogin({ cwd: input.cwd }).pipe(Effect.mapError(fail("getViewer"))),

    listChangeRequests: (input) =>
      cli
        .listPullRequests({
          cwd: input.cwd,
          repository: input.repository,
          host: input.host,
          state: input.state,
          involvement: input.involvement,
          viewer: input.viewer,
          limit: input.limit,
          query: input.query,
          cursor: input.cursor,
        })
        .pipe(
          Effect.mapError(fail("listChangeRequests")),
          Effect.flatMap((page) =>
            cli
              .listActorAvatars({
                cwd: input.cwd,
                repository: input.repository,
                host: input.host,
                ids: [...new Set(page.items.flatMap((item) => item.authorId ?? []))],
              })
              // A listing without faces is still a listing, so a failed lookup falls back to
              // the initials rather than taking the rows down with it.
              .pipe(
                Effect.orElseSucceed(() => new Map<string, string>()),
                Effect.map((avatarsByLogin) => ({
                  ...page,
                  items: page.items.map((item) => ({
                    ...item,
                    author: withAvatar(item.author, avatarsByLogin, input.host),
                  })),
                })),
              ),
          ),
        ),

    /**
     * The same listing for a whole host in one search. The avatar lookup the per-repository read
     * needs is not here: a search reports an author's picture itself, so a face costs no request
     * of its own — `withAvatar` still stands behind it for the login GitHub answered nothing for.
     */
    listChangeRequestsAcross: (input) =>
      cli
        .searchPullRequests({
          cwd: input.cwd,
          host: input.host,
          repositories: input.repositories,
          state: input.state,
          involvement: input.involvement,
          viewer: input.viewer,
          limit: input.limit,
          query: input.query,
          cursor: input.cursor,
        })
        .pipe(
          Effect.mapError(fail("listChangeRequestsAcross")),
          Effect.map((batch) => ({
            truncated: batch.truncated,
            items: batch.items.map((item) => ({
              ...item,
              author: withAvatar(item.author, new Map<string, string>(), input.host),
            })),
          })),
        ),

    listChangeRequestStats: (input) =>
      cli
        .listPullRequestStats({
          cwd: input.cwd,
          host: input.host,
          changeRequests: input.changeRequests,
        })
        .pipe(Effect.mapError(fail("listChangeRequestStats"))),

    getChangeRequest: (input) =>
      Effect.all(
        [
          cli.getPullRequestDetail(input),
          cli.getRepositoryAccess({
            cwd: input.cwd,
            repository: input.repository,
            host: input.host,
          }),
          // A small permissions query replaces the deeply paginated review-thread walk on the
          // core path. Writes ask again immediately before mutating, so this is presentation.
          cli.getViewerAccess(input),
        ],
        { concurrency: 3 },
      ).pipe(
        Effect.mapError(fail("getChangeRequest")),
        Effect.map(
          ([pullRequest, repository, viewerAccess]): ProviderChangeRequestDetail => ({
            ...pullRequest,
            reviewers: pullRequest.reviewRequestLogins.map((login) => ({
              login,
              name: null,
              avatarUrl: null,
            })),
            mergeCapabilities: repository.mergeCapabilities,
            viewerPermissions: gitHubViewerPermissions(viewerAccess),
          }),
        ),
      ),

    getChangeRequestActivity: (input) =>
      Effect.all(
        [
          cli.getPullRequestActivity(input),
          // Line comments live on review threads, which `gh pr view --json` cannot reach. A
          // GraphQL hiccup degrades to a truncated conversation rather than blanking activity.
          cli.listReviewThreadComments(input).pipe(
            Effect.orElseSucceed(() => ({
              comments: [],
              reviewThreads: [],
              commentCount: 0,
              truncated: true,
              reviewers: [],
              avatarsByLogin: new Map<string, string>(),
              commitStats: new Map<
                string,
                { readonly additions: number; readonly deletions: number }
              >(),
              commits: [],
              viewer: { canUpdate: true, didAuthor: false },
            })),
          ),
        ],
        { concurrency: 2 },
      ).pipe(
        Effect.mapError(fail("getChangeRequestActivity")),
        Effect.map(
          ([pullRequest, reviewThreads]): ProviderChangeRequestActivity => ({
            author: withAvatar(pullRequest.author, reviewThreads.avatarsByLogin, input.host),
            reviewers: reviewThreads.reviewers,
            commits: (reviewThreads.commits.length > 0
              ? reviewThreads.commits
              : pullRequest.commits
            ).map((commit) => ({
              ...commit,
              ...reviewThreads.commitStats.get(commit.oid),
              authors: commit.authors?.map(
                (author) => withAvatar(author, reviewThreads.avatarsByLogin, input.host) ?? author,
              ),
            })),
            comments: [...pullRequest.comments, ...reviewThreads.comments]
              .map((comment) => ({
                ...comment,
                author: withAvatar(comment.author, reviewThreads.avatarsByLogin, input.host),
              }))
              .toSorted((left, right) => left.createdAt.localeCompare(right.createdAt)),
            // `gh pr view --json comments,reviews` follows GitHub's cursors itself, so those two
            // are always whole and only the thread walk can stop short of the host.
            commentCount: pullRequest.comments.length + reviewThreads.commentCount,
            commentsTruncated: reviewThreads.truncated,
            reviewThreads: reviewThreads.reviewThreads.map((thread) => ({
              ...thread,
              comments: thread.comments.map((comment) => ({
                ...comment,
                author: withAvatar(comment.author, reviewThreads.avatarsByLogin, input.host),
              })),
            })),
          }),
        ),
      ),

    getViewerPermissions: (input) =>
      cli
        .getViewerAccess(input)
        .pipe(Effect.mapError(fail("getViewerPermissions")), Effect.map(gitHubViewerPermissions)),

    getDiff: (input) => cli.getPullRequestDiff(input).pipe(Effect.mapError(fail("getDiff"))),

    getDiffFileContents: (input) =>
      cli.getPullRequestDiffFileContents(input).pipe(Effect.mapError(fail("getDiffFileContents"))),

    listReviewerCandidates: (input) =>
      cli.listReviewerCandidates(input).pipe(Effect.mapError(fail("listReviewerCandidates"))),

    setReviewerRequest: (input) =>
      cli
        .setReviewerRequest({
          cwd: input.cwd,
          repository: input.repository,
          host: input.host,
          number: input.number,
          reviewers: input.reviewers,
          requested: input.requested,
        })
        .pipe(Effect.mapError(fail("setReviewerRequest"))),

    runAction: (input) =>
      cli
        .runPullRequestAction({
          cwd: input.cwd,
          repository: input.repository,
          host: input.host,
          number: input.number,
          action: input.action,
          ...(input.mergeMethod === undefined ? {} : { mergeMethod: input.mergeMethod }),
        })
        .pipe(Effect.mapError(fail("runAction"))),

    comment: (input) => cli.commentOnPullRequest(input).pipe(Effect.mapError(fail("comment"))),

    submitReview: (input) => cli.submitReview(input).pipe(Effect.mapError(fail("submitReview"))),

    replyToThread: (input) =>
      cli
        .replyToReviewThread({
          cwd: input.cwd,
          repository: input.repository,
          host: input.host,
          threadId: input.threadId,
          body: input.body,
        })
        .pipe(Effect.mapError(fail("replyToThread"))),

    setThreadResolution: (input) =>
      cli
        .setReviewThreadResolution({
          cwd: input.cwd,
          repository: input.repository,
          host: input.host,
          threadId: input.threadId,
          resolved: input.resolved,
        })
        .pipe(Effect.mapError(fail("setThreadResolution"))),
  };

  return provider;
});