import * as asserts from '@std/assert';
import * as fsdb from '../fsdb.ts';
import { get_data_dir } from './helpers.ts';
import lurid from '@andyburke/lurid';
import { FSDB_INDEXER_SYMLINKS } from '../indexers/symlinks.ts';

type ITEM = {
	id: string;
	value: string;
	created: 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: 'created',
			field: 'created',
			organize: (value) => {
				const date = new Date(value);
				return [`${date.getFullYear()}`, `${date.getMonth()}`, `${date.getDate()}`, `${value}.json`];
			}
		})
	}
});

Deno.test({
	name: 'events - create',
	permissions: {
		env: true,
		// https://github.com/denoland/deno/discussions/17258
		read: true,
		write: true
	},
	fn: async () => {
		asserts.assert(item_collection);

		let create_event: any = null;
		item_collection.on('create', (event) => {
			create_event = event;
		});

		const now = new Date().toISOString();
		const item = {
			id: lurid(),
			value: 'test',
			created: now
		};

		await item_collection.create(item);

		asserts.assert(create_event);
		asserts.assertEquals(create_event?.item, item);
		asserts.assert(create_event?.item_path);
	}
});

Deno.test({
	name: 'events - delete',
	permissions: {
		env: true,
		// https://github.com/denoland/deno/discussions/17258
		read: true,
		write: true
	},
	fn: async () => {
		asserts.assert(item_collection);

		let delete_event: any = null;
		item_collection.on('delete', (event) => {
			delete_event = event;
		});

		const now = new Date().toISOString();
		const item = {
			id: lurid(),
			value: 'test',
			created: now
		};

		await item_collection.create(item);
		await item_collection.delete(item);

		asserts.assert(delete_event);
		asserts.assertEquals(delete_event?.item, item);
	}
});

Deno.test({
	name: 'events - write',
	permissions: {
		env: true,
		// https://github.com/denoland/deno/discussions/17258
		read: true,
		write: true
	},
	fn: async () => {
		asserts.assert(item_collection);

		let create_write_event: any = null;
		function set_create_event(event: any): void {
			create_write_event = event;
		}
		item_collection.on('write', set_create_event);

		const now = new Date().toISOString();
		const item = {
			id: lurid(),
			value: 'test',
			created: now
		};

		await item_collection.create(item);

		item_collection.off('write', set_create_event);

		asserts.assert(create_write_event);
		asserts.assertEquals(create_write_event?.item, item);
		asserts.assert(create_write_event.item_path);

		const updated_item = { ...item };
		updated_item.value = 'different';

		let update_write_event: any = null;
		function set_update_event(event: any): void {
			update_write_event = event;
		}
		item_collection.on('write', set_update_event);

		await item_collection.update(updated_item);

		item_collection.off('write', set_update_event);

		asserts.assert(update_write_event);
		asserts.assertEquals(update_write_event?.item, updated_item);
		asserts.assert(update_write_event.item_path);
	}
});

Deno.test({
	name: 'events - get',
	permissions: {
		env: true,
		// https://github.com/denoland/deno/discussions/17258
		read: true,
		write: true
	},
	fn: async () => {
		asserts.assert(item_collection);

		let get_event: any = null;
		item_collection.on('get', (event) => {
			get_event = event;
		});

		const now = new Date().toISOString();
		const item = {
			id: lurid(),
			value: 'test',
			created: now
		};

		await item_collection.create(item);
		const fetched_item: ITEM | null = await item_collection.get(item.id);

		asserts.assertEquals(fetched_item, item);

		asserts.assert(get_event);
		asserts.assertEquals(get_event?.item, fetched_item);
		asserts.assert(get_event?.item_path);
	}
});

Deno.test({
	name: 'events - index',
	permissions: {
		env: true,
		// https://github.com/denoland/deno/discussions/17258
		read: true,
		write: true
	},
	fn: async () => {
		asserts.assert(item_collection);

		let index_event: any = null;
		item_collection.on('index', (event) => {
			index_event = event;
		});

		const now = new Date().toISOString();
		const item = {
			id: lurid(),
			value: 'test',
			created: now
		};

		await item_collection.create(item);

		asserts.assert(index_event);
		asserts.assertEquals(index_event?.item, item);
		asserts.assert(index_event?.indexer);
	}
});

Deno.test({
	name: 'events - update',
	permissions: {
		env: true,
		// https://github.com/denoland/deno/discussions/17258
		read: true,
		write: true
	},
	fn: async () => {
		asserts.assert(item_collection);

		let update_event: any = null;
		item_collection.on('update', (event) => {
			update_event = event;
		});

		const now = new Date().toISOString();
		const item = {
			id: lurid(),
			value: 'test',
			created: now
		};

		await item_collection.create(item);

		const updated_item = { ...item };
		updated_item.created = new Date().toISOString();

		await item_collection.update(updated_item);

		asserts.assert(update_event);
		asserts.assertEquals(update_event?.item, updated_item);
		asserts.assertEquals(update_event.previous, item);
	}
});

Deno.test({
	name: 'events - find',
	permissions: {
		env: true,
		// https://github.com/denoland/deno/discussions/17258
		read: true,
		write: true
	},
	fn: async () => {
		asserts.assert(item_collection);

		let find_event: any = null;
		item_collection.on('find', (event) => {
			find_event = event;
		});

		const now = new Date().toISOString();
		const item = {
			id: lurid(),
			value: 'test',
			created: now
		};

		await item_collection.create(item);

		const criteria = {
			created: now
		};

		const options = {
			limit: 3
		};
		const results = await item_collection.find(criteria, options);

		asserts.assert(find_event);
		asserts.assertEquals(find_event.criteria, criteria);
		asserts.assertEquals(find_event.options?.limit, options.limit);
		asserts.assertEquals(find_event.results, results);
	}
});

Deno.test({
	name: 'events - all',
	permissions: {
		env: true,
		// https://github.com/denoland/deno/discussions/17258
		read: true,
		write: true
	},
	fn: async () => {
		asserts.assert(item_collection);

		let all_event: any = null;
		item_collection.on('all', (event) => {
			all_event = event;
		});

		for (let i = 0; i < 5; ++i) {
			const item = {
				id: lurid(),
				value: 'test ' + i,
				created: new Date().toISOString()
			};

			await item_collection.create(item);
		}

		const options = {
			limit: 2
		};
		const results = await item_collection.all(options);

		asserts.assert(all_event);
		asserts.assertEquals(results.length, options.limit);
		asserts.assertEquals(all_event.options?.limit, options.limit);
		asserts.assertEquals(all_event.results, results);
	}
});