import * as asserts from '@std/assert';
import * as fsdb from '../fsdb.ts';
import { FSDB_INDEXER_SYMLINKS } from '../indexers.ts';
import { get_data_dir, random_email_address, random_phone_number } from './helpers.ts';
import lurid from '@andyburke/lurid';
import by_email from '../organizers/by_email.ts';
import by_character from '../organizers/by_character.ts';
import by_phone from '../organizers/by_phone.ts';
import { sentence } from 'jsr:@ndaidong/txtgen';

Deno.test({
	name: 'iterate over all items',
	permissions: {
		env: true,

		// https://github.com/denoland/deno/discussions/17258
		read: true,
		write: true
	},
	fn: async () => {
		type ITEM = {
			id: string;
			email: string;
			phone: string;
			value: string;
		};

		const item_collection: fsdb.FSDB_COLLECTION<ITEM> = new fsdb.FSDB_COLLECTION<ITEM>({
			name: 'test-05-items',
			root: get_data_dir() + '/test-05-items',
			indexers: {
				email: new FSDB_INDEXER_SYMLINKS<ITEM>({
					name: 'email',
					field: 'email',
					organize: by_email
				}),
				phone: new FSDB_INDEXER_SYMLINKS<ITEM>({
					name: 'phone',
					field: 'phone',
					organize: by_phone
				}),
				by_character_test: new FSDB_INDEXER_SYMLINKS<ITEM>({
					name: 'by_character_test',
					organize: by_character,
					get_values_to_index: (item: ITEM) => item.value.split(/\W/).filter((word) => word.length > 3),
					to_many: true
				})
			}
		});

		asserts.assert(item_collection);

		const items: ITEM[] = [];
		for (let i = 0; i < 500; ++i) {
			const item = {
				id: lurid(),
				email: random_email_address(),
				phone: random_phone_number(),
				value: sentence()
			};

			items.push(item);

			const stored_item: ITEM = await item_collection.create(item);

			asserts.assertObjectMatch(stored_item, item);
		}

		const LIMIT_MIN = 11;
		const LIMIT_MAX = 333;

		let offset = 0;
		const fetched = [];
		let more_to_fetch = true;
		do {
			// fuzz the limit
			const limit = Math.floor(Math.random() * (LIMIT_MAX - LIMIT_MIN + 1)) + LIMIT_MIN;

			const fetched_items = await item_collection.all({
				limit,
				offset
			});

			fetched.push(...fetched_items);
			offset += fetched_items.length;
			more_to_fetch = fetched_items.length === limit;
		} while (more_to_fetch);

		const sorted_items = items.sort((lhs, rhs) => lhs.id.localeCompare(rhs.id));
		const sorted_fetched = fetched.sort((lhs, rhs) => lhs.id.localeCompare(rhs.id));

		asserts.assertEquals(sorted_fetched, sorted_items);
	}
});