import * as Schema from "effect/Schema";
import { describe, expect, it } from "vite-plus/test";

import {
  PullRequestActionInput,
  PullRequestCapabilities,
  PullRequestListInput,
  PullRequestListResult,
  PullRequestReviewerRequestInput,
  resolvePullRequestAuthorFilter,
} from "./pullRequest.ts";

const decodeListResult = Schema.decodeUnknownSync(PullRequestListResult);
const decodeListInput = Schema.decodeUnknownSync(PullRequestListInput);
const decodeReviewerRequest = Schema.decodeUnknownSync(PullRequestReviewerRequestInput);
const decodeAction = Schema.decodeUnknownSync(PullRequestActionInput);

const LIST_RESULT: PullRequestListResult = {
  viewers: { "github.com": "bilal", "gitlab.com": "bilal.hassan" },
  providers: [
    {
      host: "github.com",
      kind: "github",
      searchesOnHost: true,
      projectCount: 1,
      configured: true,
      detail: null,
    },
    {
      host: "gitlab.com",
      kind: "gitlab",
      searchesOnHost: true,
      projectCount: 1,
      configured: false,
      detail: "glab is not installed.",
    },
  ],
  entries: [
    {
      provider: "github",
      host: "github.com",
      projectId: "project-1" as PullRequestListResult["entries"][number]["projectId"],
      projectTitle: "t3code",
      repository: "pingdotgg/t3code",
      number: 1,
      title: "Add a pull requests page",
      url: "https://github.com/pingdotgg/t3code/pull/1",
      author: { login: "octocat", name: null, avatarUrl: null },
      headBranch: "feat/page",
      baseBranch: "main",
      state: "open",
      isDraft: false,
      mergeability: "mergeable",
      additions: 1,
      deletions: 0,
      createdAt: "2026-07-01T00:00:00Z",
      updatedAt: "2026-07-02T00:00:00Z",
      viewerReviewRequested: false,
      labels: [{ name: "backend", color: null }],
    },
  ],
  errors: [],
  truncated: false,
  nextCursors: { "github.com pingdotgg/t3code": "2026-07-02T00:00:00Z|1|1" },
};

describe("PullRequestListResult", () => {
  /**
   * The RPC builds this codec at call time, so a shape it cannot lower — an open-keyed record
   * with an optional value, for one — fails as an interrupted request rather than as a schema
   * error. Building it here turns that into a test failure instead.
   */
  it("round-trips through the JSON codec the RPC serializes with", () => {
    const codec = Schema.toCodecJson(PullRequestListResult);

    const decoded = Schema.decodeUnknownSync(codec)(Schema.encodeUnknownSync(codec)(LIST_RESULT));

    expect(decoded).toStrictEqual(LIST_RESULT);
  });

  it("keys a viewer by host, so two hosts of one kind stay separate accounts", () => {
    const decoded = decodeListResult({
      ...LIST_RESULT,
      viewers: { "github.com": "bilal", "github.acme.dev": "b.hassan" },
    });

    expect(decoded.viewers["github.com"]).toBe("bilal");
    expect(decoded.viewers["github.acme.dev"]).toBe("b.hassan");
  });
});

describe("PullRequestListInput", () => {
  it("trims a search, so what is sent is what was typed", () => {
    expect(decodeListInput({ state: "open", query: "  page  " }).query).toBe("page");
  });

  it("has no search when none was asked for", () => {
    expect(decodeListInput({ state: "open" }).query).toBeUndefined();
  });

  it("bounds a search, because it travels into a command and a query string", () => {
    expect(decodeListInput({ state: "open", query: "p".repeat(200) }).query).toHaveLength(200);
    expect(() => decodeListInput({ state: "open", query: "p".repeat(201) })).toThrow();
  });

  it("takes back the continuation a result handed out, keyed the way it arrived", () => {
    const cursors = { "github.com pingdotgg/t3code": "2026-07-02T00:00:00Z|99|1,2" };

    expect(decodeListInput({ state: "open", cursors }).cursors).toStrictEqual(cursors);
  });

  it("has no continuation when the listing is being read from the top", () => {
    expect(decodeListInput({ state: "open" }).cursors).toBeUndefined();
  });

  it("bounds a continuation, because it comes back from the page and goes into a filter", () => {
    const long = (length: number) => ({ "github.com acme/web": "c".repeat(length) });
    expect(decodeListInput({ state: "open", cursors: long(4096) })).toBeDefined();
    expect(() => decodeListInput({ state: "open", cursors: long(4097) })).toThrow();
  });
});

describe("PullRequestReviewerRequestInput", () => {
  const ref = { projectId: "p1", repository: "acme/web", number: 1 };
  const reviewer = { id: "octocat", kind: "user" };

  it("carries the same shape whichever direction the request goes", () => {
    // One operation, turned around: `requested` is the whole difference between asking somebody
    // for a review and taking the request back.
    for (const requested of [true, false]) {
      expect(decodeReviewerRequest({ ...ref, reviewers: [reviewer], requested }).requested).toBe(
        requested,
      );
    }
  });

  it("refuses a request that names nobody, which no host would do anything with", () => {
    expect(() => decodeReviewerRequest({ ...ref, reviewers: [], requested: true })).toThrow();
  });

  it("bounds the reviewers, because they travel into a body the page composed", () => {
    const many = (count: number) =>
      Array.from({ length: count }, (_, index) => ({ id: `user${index}`, kind: "user" }));
    expect(
      decodeReviewerRequest({ ...ref, reviewers: many(25), requested: true }).reviewers,
    ).toHaveLength(25);
    expect(() => decodeReviewerRequest({ ...ref, reviewers: many(26), requested: true })).toThrow();
  });

  it("keeps a team apart from a person, which is a different thing to ask", () => {
    expect(
      decodeReviewerRequest({
        ...ref,
        reviewers: [reviewer, { id: "web-platform", kind: "team" }],
        requested: true,
      }).reviewers.map((entry) => entry.kind),
    ).toEqual(["user", "team"]);
  });
});

describe("updating a branch that has fallen behind its base", () => {
  const ref = { projectId: "project-1", repository: "acme/web", number: 7 };

  it("carries the way the branch should be brought up to date", () => {
    expect(decodeAction({ ...ref, action: "update-branch", updateMethod: "rebase" })).toMatchObject(
      {
        action: "update-branch",
        updateMethod: "rebase",
      },
    );
  });

  it("takes the action without a method, which is the host's own default", () => {
    expect(decodeAction({ ...ref, action: "update-branch" }).updateMethod).toBeUndefined();
  });

  it("refuses a way no host offers", () => {
    expect(() =>
      decodeAction({ ...ref, action: "update-branch", updateMethod: "squash" }),
    ).toThrow();
  });
});

describe("leaving a merge for the host to make once it is ready", () => {
  const ref = { projectId: "project-1", repository: "acme/web", number: 7 };

  it("carries the strategy the deferred merge should use, as merging now does", () => {
    expect(
      decodeAction({ ...ref, action: "enable-auto-merge", mergeMethod: "squash" }),
    ).toMatchObject({ action: "enable-auto-merge", mergeMethod: "squash" });
  });

  it("takes the arming back without a strategy, because there is nothing to choose", () => {
    expect(decodeAction({ ...ref, action: "disable-auto-merge" }).mergeMethod).toBeUndefined();
  });
});

describe("reverting a merged pull request", () => {
  it("carries the revert action without merge options", () => {
    const action = decodeAction({
      projectId: "project-1",
      repository: "acme/web",
      number: 7,
      action: "revert",
    });

    expect(action.action).toBe("revert");
    expect(action.mergeMethod).toBeUndefined();
  });
});

describe("approving fork workflows", () => {
  it("carries workflow approval as its own action", () => {
    const action = decodeAction({
      projectId: "project-1",
      repository: "acme/web",
      number: 7,
      action: "approve-workflows",
    });

    expect(action.action).toBe("approve-workflows");
  });
});

describe("PullRequestCapabilities", () => {
  const decodeCapabilities = Schema.decodeUnknownSync(PullRequestCapabilities);
  const base = {
    diff: true,
    comment: true,
    actions: [],
    mergeMethods: [],
    search: true,
    review: { inlineComment: true, reply: true, resolve: true, verdicts: [] },
    reviewers: { request: true, listCandidates: true },
  };

  it("decodes a server that says nothing about reactions as a server with none", () => {
    expect(decodeCapabilities(base).reactions).toBeUndefined();
  });
});

describe("naming the reader as the author to narrow by", () => {
  it("reads me as whoever is signed in, however it is written", () => {
    expect(resolvePullRequestAuthorFilter("me", "octocat")).toBe("octocat");
    expect(resolvePullRequestAuthorFilter("@me", "octocat")).toBe("octocat");
    expect(resolvePullRequestAuthorFilter("  ME  ", "octocat")).toBe("octocat");
  });

  it("leaves any other name as it was typed", () => {
    expect(resolvePullRequestAuthorFilter(" mercedes ", "octocat")).toBe("mercedes");
    expect(resolvePullRequestAuthorFilter("me-too", "octocat")).toBe("me-too");
  });

  it("stands as typed where the host has not said who the reader is", () => {
    expect(resolvePullRequestAuthorFilter("me", null)).toBe("me");
    expect(resolvePullRequestAuthorFilter("me", "  ")).toBe("me");
  });
});