import { beforeEach, describe, expect, it, vi } from "vitest";
import * as db from "./db";
import { cancelAlgorithmJob } from "./algorithmJob";
import { cancelLegacyAnalysisJob } from "./analysisJobControl";
import { cleanupAnalysisArtifacts } from "./analysisArtifacts";
import { deleteAnalysisResult } from "./analysisResultDeletion";

vi.mock("./db", () => ({
  getTaskAnalysisResultById: vi.fn(),
  deleteTaskAnalysisResultWithDerivedPointclouds: vi.fn(),
}));
vi.mock("./algorithmJob", () => ({ cancelAlgorithmJob: vi.fn() }));
vi.mock("./analysisJobControl", () => ({ cancelLegacyAnalysisJob: vi.fn() }));
vi.mock("./analysisArtifacts", () => ({ cleanupAnalysisArtifacts: vi.fn() }));

const row = { id: 57, taskId: 7 } as Awaited<ReturnType<typeof db.getTaskAnalysisResultById>>;

describe("deleteAnalysisResult", () => {
  beforeEach(() => {
    vi.clearAllMocks();
    vi.mocked(db.getTaskAnalysisResultById).mockResolvedValue(row);
    vi.mocked(cleanupAnalysisArtifacts).mockResolvedValue(undefined);
    vi.mocked(db.deleteTaskAnalysisResultWithDerivedPointclouds).mockResolvedValue(undefined);
  });

  it("cancels jobs, removes files, then transactionally cascades derived pointcloud rows", async () => {
    await expect(deleteAnalysisResult(57)).resolves.toEqual({ success: true });
    expect(cancelAlgorithmJob).toHaveBeenCalledWith(57);
    expect(cancelLegacyAnalysisJob).toHaveBeenCalledWith(57);
    expect(cleanupAnalysisArtifacts).toHaveBeenCalledWith(7, 57);
    expect(db.deleteTaskAnalysisResultWithDerivedPointclouds).toHaveBeenCalledWith(57);
    expect(vi.mocked(cleanupAnalysisArtifacts).mock.invocationCallOrder[0]).toBeLessThan(
      vi.mocked(db.deleteTaskAnalysisResultWithDerivedPointclouds).mock.invocationCallOrder[0],
    );
  });

  it("keeps database rows when filesystem cleanup fails", async () => {
    vi.mocked(cleanupAnalysisArtifacts).mockRejectedValueOnce(new Error("permission denied"));
    await expect(deleteAnalysisResult(57)).rejects.toThrow("permission denied");
    expect(db.deleteTaskAnalysisResultWithDerivedPointclouds).not.toHaveBeenCalled();
  });

  it("treats deletion of an already missing result as success", async () => {
    vi.mocked(db.getTaskAnalysisResultById).mockResolvedValueOnce(undefined);
    await expect(deleteAnalysisResult(57)).resolves.toEqual({ success: true });
    expect(cleanupAnalysisArtifacts).not.toHaveBeenCalled();
    expect(db.deleteTaskAnalysisResultWithDerivedPointclouds).not.toHaveBeenCalled();
  });
});