import 'reflect-metadata';
import {
	createTestingConnections,
	closeTestingConnections,
	reloadTestingDatabases,
} from '../../utils/test-utils';
import { DataSource } from '../../../src/data-source/DataSource';
import { expect } from 'chai';
import { JSONBKeyTest } from './entity/test';

describe('github issues > #6833 Entities with JSON key columns are incorrectly grouped', () => {
	let connections: DataSource[];
	before(
		async () =>
			(connections = await createTestingConnections({
				entities: [JSONBKeyTest],
				dropSchema: true,
				schemaCreate: true,
				enabledDrivers: ['postgres'],
			})),
	);
	beforeEach(() => reloadTestingDatabases(connections));
	after(() => closeTestingConnections(connections));

	it('jsonB keys are correctly resolved', () =>
		Promise.all(
			connections.map(async (connection) => {
				await connection.transaction(async (manager) => {
					await manager.save(
						manager.create(JSONBKeyTest, {
							id: { first: 1, second: 2 },
						}),
					);
					await manager.save(
						manager.create(JSONBKeyTest, {
							id: { first: 1, second: 3 },
						}),
					);

					const entities = await manager
						.createQueryBuilder(JSONBKeyTest, 'json_test')
						.select()
						.getMany();
					expect(entities.length).to.equal(2);
				});
			}),
		));

	it('jsonB keys can be found', () =>
		Promise.all(
			connections.map(async (connection) => {
				await connection.transaction(async (manager) => {
					await manager.save(
						manager.create(JSONBKeyTest, {
							id: { first: 3, second: 3 },
						}),
					);
					await manager.save(
						manager.create(JSONBKeyTest, {
							id: { first: 4, second: 3 },
						}),
					);

					const entities = await manager.find(JSONBKeyTest, {
						where: { id: { first: 3, second: 3 } },
					});
					expect(entities.length).to.equal(1);
					expect(entities[0].id).to.deep.equal({
						first: 3,
						second: 3,
					});
				});
			}),
		));

	it('jsonB keys can be found with IN', () =>
		Promise.all(
			connections.map(async (connection) => {
				await connection.transaction(async (manager) => {
					await manager.save(
						manager.create(JSONBKeyTest, {
							id: { first: 3, second: 3 },
						}),
					);
					await manager.save(
						manager.create(JSONBKeyTest, {
							id: { first: 4, second: 3 },
						}),
					);
					await manager.save(
						manager.create(JSONBKeyTest, {
							id: { first: 5, second: 3 },
						}),
					);
					await manager.save(
						manager.create(JSONBKeyTest, {
							id: { first: 6, second: 4 },
						}),
					);

					const entities = await manager
						.createQueryBuilder(JSONBKeyTest, 'json_test')
						.select()
						.where('id IN (:...ids)', {
							ids: [
								{ first: 5, second: 3 },
								{ first: 6, second: 4 },
							],
						})
						.getMany();
					expect(entities.length).to.equal(2);
					expect(entities[0].id).to.deep.equal({
						first: 5,
						second: 3,
					});
					expect(entities[1].id).to.deep.equal({
						first: 6,
						second: 4,
					});
				});
			}),
		));

	it('jsonB keys can be found regardless of order', () =>
		Promise.all(
			connections.map(async (connection) => {
				await connection.transaction(async (manager) => {
					await manager.save(
						manager.create(JSONBKeyTest, {
							id: { first: 3, second: 3 },
						}),
					);
					await manager.save(
						manager.create(JSONBKeyTest, {
							id: { first: 4, second: 3 },
						}),
					);
					await manager.save(
						manager.create(JSONBKeyTest, {
							id: { first: 5, second: 3 },
						}),
					);
					await manager.save(
						manager.create(JSONBKeyTest, {
							id: { first: 6, second: 4 },
						}),
					);

					const payload = { second: 2, first: 1 };
					await manager.save(manager.create(JSONBKeyTest, { id: payload }));
					const entities = await manager.find(JSONBKeyTest, {
						where: { id: payload },
					});
					expect(entities.length).to.equal(1);
					expect(entities[0].id).to.deep.equal({
						first: 1,
						second: 2,
					});

					const entitiesOtherOrder = await manager.find(JSONBKeyTest, {
						where: { id: { first: 1, second: 2 } },
					});
					expect(entitiesOtherOrder.length).to.equal(1);
					expect(entitiesOtherOrder[0].id).to.deep.equal({
						first: 1,
						second: 2,
					});
				});
			}),
		));
});