import "dotenv/config";
import { strict as assert } from "node:assert";
import crypto from "node:crypto";
import { after, before, test } from "node:test";
import { closeDb, db, runMigrations, schema } from "@superlog/db";
import { and, eq } from "drizzle-orm";
import { Hono } from "hono";
import { mountGithubPublic } from "./github.js";

const GH_WEBHOOK_SECRET = "github-test-secret";
process.env.GITHUB_APP_WEBHOOK_SECRET = GH_WEBHOOK_SECRET;

const orgIds: string[] = [];

before(async () => {
  await runMigrations();
});

after(async () => {
  try {
    for (const orgId of orgIds.reverse()) {
      await db.delete(schema.orgs).where(eq(schema.orgs.id, orgId));
    }
  } finally {
    await closeDb();
  }
});

test("merged agent PR resolves incident, cascades linked issues, and writes timeline events", async () => {
  const fixture = await seedAgentPrFixture("merged");
  const app = new Hono();
  mountGithubPublic(app);

  const mergedAt = new Date().toISOString();
  const res = await postGithub(app, "pull_request", `gh-${fixture.tag}-merged`, {
    action: "closed",
    repository: { full_name: fixture.repoFullName },
    pull_request: {
      number: fixture.prNumber,
      merged: true,
      merged_at: mergedAt,
      closed_at: mergedAt,
      merged_by: { login: "alice", id: 100 },
      user: { login: "superlog-bot", id: 999 },
      head: { sha: "cafebabe", ref: fixture.branchName },
    },
    sender: { login: "alice", id: 100 },
    installation: { id: fixture.installationId },
  });

  assert.equal(res.status, 200);

  const pr = await db.query.agentPullRequests.findFirst({
    where: eq(schema.agentPullRequests.id, fixture.agentPrId),
  });
  assert.equal(pr?.state, "merged");
  assert.equal(pr?.mergedByLogin, "alice");
  assert.ok(pr?.mergedAt);

  const incident = await db.query.incidents.findFirst({
    where: eq(schema.incidents.id, fixture.incidentId),
  });
  assert.equal(incident?.status, "resolved");

  const issue = await db.query.issues.findFirst({
    where: eq(schema.issues.id, fixture.issueId),
  });
  assert.ok(issue);

  const resolvedEvents = await db.query.incidentEvents.findMany({
    where: and(
      eq(schema.incidentEvents.agentRunId, fixture.agentRunId),
      eq(schema.incidentEvents.kind, "incident_resolved"),
    ),
  });
  assert.equal(resolvedEvents.length, 1);
  assert.equal(
    resolvedEvents[0]?.summary,
    `Incident resolved because PR #${fixture.prNumber} was merged.`,
  );
  assert.equal(resolvedEvents[0]?.detail?.reason, "agent_pr_merged");

  const prMergedEvent = await db.query.agentPrEvents.findFirst({
    where: and(
      eq(schema.agentPrEvents.agentPrId, fixture.agentPrId),
      eq(schema.agentPrEvents.kind, "pr_merged"),
    ),
  });
  assert.ok(prMergedEvent);

  const duplicate = await postGithub(app, "pull_request", `gh-${fixture.tag}-merged`, {
    action: "closed",
    repository: { full_name: fixture.repoFullName },
    pull_request: {
      number: fixture.prNumber,
      merged: true,
      merged_at: mergedAt,
      closed_at: mergedAt,
      merged_by: { login: "alice", id: 100 },
    },
    sender: { login: "alice", id: 100 },
    installation: { id: fixture.installationId },
  });
  assert.equal(duplicate.status, 200);

  const resolvedEventsAfterDuplicate = await db.query.incidentEvents.findMany({
    where: and(
      eq(schema.incidentEvents.agentRunId, fixture.agentRunId),
      eq(schema.incidentEvents.kind, "incident_resolved"),
    ),
  });
  assert.equal(resolvedEventsAfterDuplicate.length, 1);
});

test("closed unmerged agent PR does not resolve incident or linked issue", async () => {
  const fixture = await seedAgentPrFixture("closed");
  const app = new Hono();
  mountGithubPublic(app);

  const closedAt = new Date().toISOString();
  const res = await postGithub(app, "pull_request", `gh-${fixture.tag}-closed`, {
    action: "closed",
    repository: { full_name: fixture.repoFullName },
    pull_request: {
      number: fixture.prNumber,
      merged: false,
      closed_at: closedAt,
      user: { login: "superlog-bot", id: 999 },
    },
    sender: { login: "alice", id: 100 },
    installation: { id: fixture.installationId },
  });

  assert.equal(res.status, 200);

  const pr = await db.query.agentPullRequests.findFirst({
    where: eq(schema.agentPullRequests.id, fixture.agentPrId),
  });
  assert.equal(pr?.state, "closed");

  const incident = await db.query.incidents.findFirst({
    where: eq(schema.incidents.id, fixture.incidentId),
  });
  assert.equal(incident?.status, "open");

  const issue = await db.query.issues.findFirst({
    where: eq(schema.issues.id, fixture.issueId),
  });
  assert.ok(issue);

  const resolvedEvent = await db.query.incidentEvents.findFirst({
    where: and(
      eq(schema.incidentEvents.agentRunId, fixture.agentRunId),
      eq(schema.incidentEvents.kind, "incident_resolved"),
    ),
  });
  assert.equal(resolvedEvent, undefined);
});

async function seedAgentPrFixture(label: string): Promise<{
  tag: string;
  repoFullName: string;
  branchName: string;
  installationId: number;
  incidentId: string;
  issueId: string;
  agentRunId: string;
  agentPrId: string;
  prNumber: number;
}> {
  const tag = `test-${label}-${Date.now()}-${Math.floor(Math.random() * 1_000_000)}`;
  const repoFullName = `acme/${tag}`;
  const branchName = `superlog/${tag}`;
  const installationId = Math.floor(Date.now() / 1000) + Math.floor(Math.random() * 1_000_000);
  const prNumber = Math.floor(Math.random() * 10_000) + 1;

  const [org] = await db
    .insert(schema.orgs)
    .values({ name: tag, slug: tag })
    .returning();
  if (!org) throw new Error("failed to seed org");
  orgIds.push(org.id);

  const [project] = await db
    .insert(schema.projects)
    .values({ orgId: org.id, name: "test", slug: tag })
    .returning();
  if (!project) throw new Error("failed to seed project");

  const now = new Date();
  const [incident] = await db
    .insert(schema.incidents)
    .values({
      projectId: project.id,
      title: "Test incident",
      service: "api",
      firstSeen: now,
      lastSeen: now,
    })
    .returning();
  if (!incident) throw new Error("failed to seed incident");

  const [issue] = await db
    .insert(schema.issues)
    .values({
      projectId: project.id,
      fingerprint: `fp-${tag}`,
      kind: "span",
      service: "api",
      exceptionType: "Error",
      title: "Test issue",
      message: "boom",
      firstSeen: now,
      lastSeen: now,
    })
    .returning();
  if (!issue) throw new Error("failed to seed issue");

  await db.insert(schema.incidentIssues).values({
    incidentId: incident.id,
    issueId: issue.id,
  });

  const [agentRun] = await db
    .insert(schema.agentRuns)
    .values({ incidentId: incident.id, runtime: "anthropic", state: "running" })
    .returning();
  if (!agentRun) throw new Error("failed to seed agent run");

  const [installation] = await db
    .insert(schema.githubInstallations)
    .values({
      orgId: org.id,
      projectId: project.id,
      installationId,
      accountLogin: "acme-bot",
      accountType: "Organization",
      repos: [{ id: 1, fullName: repoFullName, private: false }],
    })
    .returning();
  if (!installation) throw new Error("failed to seed GitHub installation");

  const [agentPr] = await db
    .insert(schema.agentPullRequests)
    .values({
      incidentId: incident.id,
      agentRunId: agentRun.id,
      installationId: installation.id,
      repoFullName,
      prNumber,
      prNodeId: `PR_${tag}`,
      url: `https://github.com/${repoFullName}/pull/${prNumber}`,
      branchName,
      baseBranch: "main",
      headSha: "deadbeef",
      title: "[superlog] Fix bug",
      state: "open",
      lastSyncedAt: now,
    })
    .returning();
  if (!agentPr) throw new Error("failed to seed agent PR");

  return {
    tag,
    repoFullName,
    branchName,
    installationId,
    incidentId: incident.id,
    issueId: issue.id,
    agentRunId: agentRun.id,
    agentPrId: agentPr.id,
    prNumber,
  };
}

async function postGithub(
  app: Hono,
  event: string,
  delivery: string,
  payload: unknown,
): Promise<Response> {
  const body = JSON.stringify(payload);
  return app.request("/github/webhook", {
    method: "POST",
    headers: {
      "content-type": "application/json",
      "x-github-event": event,
      "x-github-delivery": delivery,
      "x-hub-signature-256": ghSign(body),
    },
    body,
  });
}

function ghSign(body: string): string {
  return `sha256=${crypto.createHmac("sha256", GH_WEBHOOK_SECRET).update(body).digest("hex")}`;
}