import { Widget } from "@/shared/schema";
import { expect, test, mock } from "bun:test";
import {
  DeleteItemCommand,
  DynamoDBClient,
  GetItemCommand,
  PutItemCommand,
} from "@aws-sdk/client-dynamodb";
import { DynamoWidgetDAO } from "@/consumer/dao";
import { VoidLogger } from "@/shared/t";

const testTable = "widgets-t";
const testWidget = Widget.parse({
  id: "testWidgetId",
  owner: "simponic",
  label: "A Widget",
  description: "Nothing to see here!",
  otherAttributes: [{ name: "length", value: "20cm" }],
});

const mockGetItemSend = mock(async (req: GetItemCommand) => {
  if (req.input.Key!.id.S! === testWidget.id) {
    return {
      Item: {
        id: { S: testWidget.id },
        owner: { S: testWidget.owner },
        label: { S: testWidget.label },
        description: { S: testWidget.description },
        length: { S: "20cm" },
      },
    };
  }
  return {};
});

const expectMockPutItem = (field: string, value: string) =>
  mock(async (req: PutItemCommand) => {
    if (req.input.Item![field].S === value) {
      return { Attributes: true };
    }
    throw new Error("invalid field");
  });

const mockDeleteItemSuccessful = mock(async (req: DeleteItemCommand) => {
  if (req.input!.Key!.id.S === testWidget.id) {
    return { $metadata: true };
  }
});

test("when retrieve dynamo dao item then inflates and returns retrieved item", async () => {
  const mockClient = { send: mockGetItemSend };
  const logger = new VoidLogger();
  const dao = new DynamoWidgetDAO(
    testTable,
    mockClient as unknown as DynamoDBClient,
    logger,
  );

  const resp = await dao.retrieve(testWidget);
  expect(resp).toEqual(testWidget);
});

test("when retrieve dynamo dao item not exist then returns undefined", async () => {
  const mockClient = { send: mockGetItemSend };
  const logger = new VoidLogger();
  const dao = new DynamoWidgetDAO(
    testTable,
    mockClient as unknown as DynamoDBClient,
    logger,
  );

  const resp = await dao.retrieve({
    id: "this-widget-doesnt-exist",
    owner: "simponic",
  });

  expect(resp).toBeUndefined();
});

test("when dynamo dao save then inflates object and returns", async () => {
  const mockClient = {
    send: expectMockPutItem("new_attribute", "exists"),
  };
  const logger = new VoidLogger();
  const dao = new DynamoWidgetDAO(
    testTable,
    mockClient as unknown as DynamoDBClient,
    logger,
  );

  const newWidget = Widget.parse({
    ...testWidget,
    otherAttributes: [...testWidget.otherAttributes!],
  });
  newWidget.otherAttributes!.push({ name: "new_attribute", value: "exists" });

  const resp = await dao.save(newWidget);

  expect(resp).toEqual(newWidget);
});

test("when dynamo dao delete then returns deleted ", async () => {
  const mockClient = {
    send: mockDeleteItemSuccessful,
  };
  const logger = new VoidLogger();

  const dao = new DynamoWidgetDAO(
    testTable,
    mockClient as unknown as DynamoDBClient,
    logger,
  );

  const resp = await dao.delete(testWidget);

  expect(resp).toEqual(testWidget);
});