import type { ShoppingListDraft } from "@commercetools/platform-sdk";
import { describe, expect, test } from "vitest";
import type { Config } from "#src/config.ts";
import { InMemoryStorage } from "#src/storage/index.ts";
import type { ApprovalFlowDraft } from "./approval-flow.ts";
import {
	AsAssociateApprovalFlowRepository,
	AsAssociateCartRepository,
	AsAssociateOrderRepository,
	AsAssociateQuoteRequestRepository,
	AsAssociateShoppingListRepository,
} from "./as-associate.ts";
import { CustomerRepository } from "./customer/index.ts";

describe("As Associate Repositories", () => {
	const storage = new InMemoryStorage();
	const config: Config = { storage, strict: false };

	test("AsAssociateCartRepository can create and retrieve carts", async () => {
		const repository = new AsAssociateCartRepository(config);
		const ctx = { projectKey: "test-project" };

		const cartDraft = {
			currency: "EUR",
			inventoryMode: "None" as const,
			taxMode: "Platform" as const,
			taxRoundingMode: "HalfEven" as const,
			taxCalculationMode: "UnitPriceLevel" as const,
		};

		const cart = await repository.create(ctx, cartDraft);
		expect(cart.id).toBeDefined();
		expect(cart.version).toBe(1);
		expect(cart.totalPrice.currencyCode).toBe("EUR");

		// Test query
		const result = await repository.query(ctx);
		expect(result.count).toBe(1);
		expect(result.results[0].id).toBe(cart.id);

		// Test get
		const retrieved = await repository.get(ctx, cart.id);
		expect(retrieved).toBeDefined();
		expect(retrieved?.id).toBe(cart.id);
	});

	test("AsAssociateOrderRepository can create and retrieve orders", async () => {
		const repository = new AsAssociateOrderRepository(config);
		const ctx = { projectKey: "test-project" };

		// First create a cart to create an order from
		const cartRepository = new AsAssociateCartRepository(config);
		const cartDraft = {
			currency: "EUR",
			inventoryMode: "None" as const,
			taxMode: "Platform" as const,
			taxRoundingMode: "HalfEven" as const,
			taxCalculationMode: "UnitPriceLevel" as const,
		};
		const cart = await cartRepository.create(ctx, cartDraft);

		const orderDraft = {
			cart: {
				id: cart.id,
				typeId: "cart" as const,
			},
			version: cart.version,
		};

		const order = await repository.create(ctx, orderDraft);
		expect(order.id).toBeDefined();
		expect(order.version).toBe(1);
		expect(order.cart?.id).toBe(cart.id);

		// Test query
		const result = await repository.query(ctx);
		expect(result.count).toBe(1);
		expect(result.results[0].id).toBe(order.id);

		// Test get
		const retrieved = await repository.get(ctx, order.id);
		expect(retrieved).toBeDefined();
		expect(retrieved?.id).toBe(order.id);
	});

	test("AsAssociateQuoteRequestRepository can create and retrieve quote requests", async () => {
		const repository = new AsAssociateQuoteRequestRepository(config);
		const ctx = { projectKey: "test-project" };

		// Create a customer using the customer repository
		const customerRepository = new CustomerRepository(config);
		const customer = await customerRepository.create(ctx, {
			email: "test@example.com",
			password: "password123",
			firstName: "John",
			lastName: "Doe",
		});

		// First create a cart to create a quote request from
		const cartRepository = new AsAssociateCartRepository(config);
		const cartDraft = {
			currency: "EUR",
			customerId: customer.id,
		};
		const cart = await cartRepository.create(ctx, cartDraft);

		const quoteRequestDraft = {
			cart: {
				id: cart.id,
				typeId: "cart" as const,
			},
			cartVersion: cart.version,
		};

		const quoteRequest = await repository.create(ctx, quoteRequestDraft);
		expect(quoteRequest.id).toBeDefined();
		expect(quoteRequest.version).toBe(1);
		expect(quoteRequest.cart?.id).toBe(cart.id);

		// Test query
		const result = await repository.query(ctx);
		expect(result.count).toBe(1);
		expect(result.results[0].id).toBe(quoteRequest.id);

		// Test get
		const retrieved = await repository.get(ctx, quoteRequest.id);
		expect(retrieved).toBeDefined();
		expect(retrieved?.id).toBe(quoteRequest.id);
	});

	test("AsAssociateApprovalFlowRepository can create and retrieve approval flows", async () => {
		const repository = new AsAssociateApprovalFlowRepository(config);
		const ctx = { projectKey: "test-project" };

		const approvalFlowDraft: ApprovalFlowDraft = {
			order: { typeId: "order", id: "order-1" },
			businessUnit: { typeId: "business-unit", key: "bu-1" },
		};

		const approvalFlow = await repository.create(ctx, approvalFlowDraft);
		expect(approvalFlow.id).toBeDefined();
		expect(approvalFlow.version).toBe(1);
		expect(approvalFlow.status).toBe("Pending");

		// Test query
		const result = await repository.query(ctx);
		expect(result.count).toBe(1);
		expect(result.results[0].id).toBe(approvalFlow.id);

		// Test get
		const retrieved = await repository.get(ctx, approvalFlow.id);
		expect(retrieved).toBeDefined();
		expect(retrieved?.id).toBe(approvalFlow.id);
	});

	test("AsAssociateShoppingListRepository can create and retrieve shopping lists", async () => {
		const repository = new AsAssociateShoppingListRepository(config);
		const ctx = { projectKey: "test-project" };

		const shoppingListDraft: ShoppingListDraft = {
			name: { "en-US": "My Shopping List" },
		};

		const shoppingList = await repository.create(ctx, shoppingListDraft);
		expect(shoppingList.id).toBeDefined();
		expect(shoppingList.version).toBe(1);

		// Test query
		const result = await repository.query(ctx);
		expect(result.count).toBe(1);
		expect(result.results[0].id).toBe(shoppingList.id);

		// Test get
		const retrieved = await repository.get(ctx, shoppingList.id);
		expect(retrieved).toBeDefined();
		expect(retrieved?.id).toBe(shoppingList.id);
	});
});