import assert from "node:assert/strict";
import test from "node:test";

import { buildApp } from "../../src/app/build-app.js";

const saleResult = {
  sale: {
    id: "sale-1",
    sellerId: "seller-1",
    saleDate: "2026-09-09",
    soldPriceMinor: 2499,
    currency: "USD",
    platformFeesMinor: 0,
    paymentProcessingFeesMinor: 0,
    shippingCostMinor: 0,
    taxesMinor: 0,
    otherFeesMinor: 0,
  },
  saleItem: {
    id: "sale-item-1",
    inventoryItemId: "inventory-1",
    soldPriceMinor: 2499,
    costBasisMinor: 1200,
  },
  inventoryItem: { id: "inventory-1", status: "SOLD" },
};

function createTestApp({ authenticateAdmin, authorizeUnsafeRequest } = {}) {
  return buildApp({
    authenticateAdmin,
    authorizeUnsafeRequest,
    saleService: {
      async create(input) {
        assert.equal(input.sellerId, "seller-1");
        return saleResult;
      },
    },
  });
}

test("creates a sale for the authenticated seller with CSRF protection", async (testContext) => {
  let csrfChecks = 0;
  const app = createTestApp({
    authenticateAdmin: async () => ({ sellerId: "seller-1" }),
    authorizeUnsafeRequest: async () => {
      csrfChecks += 1;
    },
  });
  testContext.after(() => app.close());

  const response = await app.inject({
    method: "POST",
    url: "/api/v1/admin/sales",
    headers: { "x-csrf-token": "csrf-token" },
    payload: {
      inventoryItemId: "d2f67d74-9647-48d5-b3a4-74d3b16ea9f8",
      costBasisMinor: 1200,
      saleDate: "2026-09-09",
      soldPriceMinor: 2499,
    },
  });

  assert.equal(response.statusCode, 201);
  assert.equal(response.json().data.inventoryItem.status, "SOLD");
  assert.equal(csrfChecks, 1);
});

test("rejects invalid sale requests and unauthenticated requests", async (testContext) => {
  const app = createTestApp({
    authenticateAdmin: async () => ({ sellerId: "seller-1" }),
  });
  testContext.after(() => app.close());

  const invalidResponse = await app.inject({
    method: "POST",
    url: "/api/v1/admin/sales",
    payload: {
      inventoryItemId: "not-a-uuid",
      costBasisMinor: -1,
      saleDate: "tomorrow",
      soldPriceMinor: 0,
    },
  });
  assert.equal(invalidResponse.statusCode, 400);
  assert.equal(invalidResponse.json().error.code, "VALIDATION_ERROR");

  const unauthenticatedApp = createTestApp();
  testContext.after(() => unauthenticatedApp.close());
  const unauthenticatedResponse = await unauthenticatedApp.inject({
    method: "POST",
    url: "/api/v1/admin/sales",
    payload: {},
  });
  assert.equal(unauthenticatedResponse.statusCode, 401);
  assert.equal(unauthenticatedResponse.json().error.code, "UNAUTHORIZED");
});

test("voids a sale with CSRF protection and actor identity", async (testContext) => {
  let voidInput;
  const app = buildApp({
    authenticateAdmin: async () => ({ userId: "user-1", sellerId: "seller-1" }),
    authorizeUnsafeRequest: async () => {},
    saleService: {
      async void(input) {
        voidInput = input;
        return saleResult;
      },
    },
  });
  testContext.after(() => app.close());

  const response = await app.inject({
    method: "POST",
    url: "/api/v1/admin/sales/sale-1/void",
    headers: { "x-csrf-token": "csrf-token" },
    payload: { reason: "Duplicate entry" },
  });

  assert.equal(response.statusCode, 200);
  assert.equal(voidInput.actorUserId, "user-1");
  assert.equal(response.json().data.inventoryItem.status, "SOLD");
});