import { describe, it, expect, beforeEach } from 'vitest';
import { groceries, references } from '$lib/server/db/schema';
import { eq } from 'drizzle-orm';
import { createTestDb, type TestDb } from '$lib/server/db/test-helper';
import { loadForGrocery, add, deleteReference } from './references';

describe('references service', () => {
	let db: TestDb['db'];

	beforeEach(async () => {
		db = (await createTestDb()).db;
	});

	it('loadForGrocery returns refs for the given grocery', async () => {
		const now = Temporal.Now.instant().toString({
			smallestUnit: 'millisecond',
		});
		const [g1] = await db
			.insert(groceries)
			.values({ name: 'coffee', checked: false, createdAt: now })
			.returning();
		const [g2] = await db
			.insert(groceries)
			.values({ name: 'tea', checked: false, createdAt: now })
			.returning();

		await db.insert(references).values([
			{ groceryId: g1.id, reference: 'Brand A' },
			{ groceryId: g2.id, reference: 'Brand B' },
		]);

		const refs = await loadForGrocery(g1.id, db);
		expect(refs).toHaveLength(1);
		expect(refs[0].reference).toBe('Brand A');
	});

	it('loadForGrocery orders refs by score desc, then insertion', async () => {
		const now = Temporal.Now.instant().toString({
			smallestUnit: 'millisecond',
		});
		const [g] = await db
			.insert(groceries)
			.values({ name: 'coffee', checked: false, createdAt: now })
			.returning();
		await db.insert(references).values([
			{ groceryId: g.id, reference: 'A' },
			{ groceryId: g.id, reference: 'B', qualityScore: 50 },
			{ groceryId: g.id, reference: 'C' },
			{ groceryId: g.id, reference: 'D', qualityScore: 50 },
		]);

		const refs = await loadForGrocery(g.id, db);
		expect(refs.map((r) => r.reference)).toEqual(['B', 'D', 'A', 'C']);
	});

	it('add creates a reference', async () => {
		const now = Temporal.Now.instant().toString({
			smallestUnit: 'millisecond',
		});
		const [g] = await db
			.insert(groceries)
			.values({ name: 'pasta', checked: false, createdAt: now })
			.returning();

		const ref = await add(g.id, 'Barilla', 2.5, '€/kg', 85, db);
		expect(ref.reference).toBe('Barilla');
		expect(ref.price).toBe(2.5);

		const rows = await db
			.select()
			.from(references)
			.where(eq(references.groceryId, g.id));
		expect(rows).toHaveLength(1);
	});

	it('deleteReference removes the ref', async () => {
		const now = Temporal.Now.instant().toString({
			smallestUnit: 'millisecond',
		});
		const [g] = await db
			.insert(groceries)
			.values({ name: 'rice', checked: false, createdAt: now })
			.returning();
		const [ref] = await db
			.insert(references)
			.values({ groceryId: g.id, reference: 'Brand X' })
			.returning();

		await deleteReference(ref.id, db);

		const rows = await db.select().from(references);
		expect(rows).toHaveLength(0);
	});
});