import 'reflect-metadata';
import { expect } from 'chai';
import {
	closeTestingConnections,
	createTestingConnections,
	reloadTestingDatabases,
} from '../../utils/test-utils';
import { DataSource } from '../../../src';
import { Address } from './entity/Address';
import { ActionDetails } from './entity/ActionDetails';
import { ActionLog } from './entity/ActionLog';
import { Person } from './entity/Person';

describe('github issues > #3120 Add relation option "createForeignKeyConstraints"', () => {
	let connections: DataSource[];
	before(
		async () =>
			(connections = await createTestingConnections({
				entities: [__dirname + '/entity/*{.js,.ts}'],
				subscribers: [__dirname + '/subscriber/*{.js,.ts}'],
				enabledDrivers: ['postgres'],
			})),
	);
	beforeEach(() => reloadTestingDatabases(connections));
	after(() => closeTestingConnections(connections));

	it('should create foreign key for relation without createForeignKeyConstraints option', () =>
		Promise.all(
			connections.map(async function (connection) {
				const queryRunner = connection.createQueryRunner();
				const mainTable = await queryRunner.getTable('person');
				const joinTable = await queryRunner.getTable('person_addresses_address');
				await queryRunner.release();

				expect(mainTable!.foreignKeys.length).to.be.equal(2);
				expect(joinTable!.foreignKeys.length).to.be.equal(2);
			}),
		));

	it('should not create foreign key for relation with createForeignKeyConstraints equal false', () =>
		Promise.all(
			connections.map(async function (connection) {
				const queryRunner = connection.createQueryRunner();
				const mainTable = await queryRunner.getTable('action_log');
				const joinTable = await queryRunner.getTable('action_log_addresses_address');
				await queryRunner.release();

				expect(mainTable!.foreignKeys.length).to.be.equal(0);
				expect(joinTable!.foreignKeys.length).to.be.equal(0);
			}),
		));

	describe('relation with createForeignKeyConstraints equal false', () => {
		it('should work perfectly', () =>
			Promise.all(
				connections.map(async (connection) => {
					const fakeAddresses: Address[] = [];
					for (let i = 0; i < 8; i++) {
						const fakeRecord = new Address();
						fakeRecord.country = 'Fake Address #' + i;
						fakeRecord.city = 'Fake Address #' + i;
						fakeRecord.street = 'Fake Address #' + i;
						fakeAddresses.push(fakeRecord);
					}
					await connection.manager.save(fakeAddresses);

					const fakePeople: Person[] = [];
					for (let i = 0; i < 8; i++) {
						const fakeRecord = new Person();
						fakeRecord.name = 'Fake Person #' + i;
						fakePeople.push(fakeRecord);
					}
					await connection.manager.save(fakePeople);

					const fakeDetails: ActionDetails[] = [];
					for (let i = 0; i < 8; i++) {
						const fakeRecord = new ActionDetails();
						fakeRecord.description = 'Fake Details #' + i;
						fakeDetails.push(fakeRecord);
					}
					await connection.manager.save(fakeDetails);

					const fakeLogs: ActionLog[] = [];
					for (let i = 0; i < 8; i++) {
						const fakeRecord = new ActionLog();
						fakeRecord.date = new Date();
						fakeRecord.action = 'Fake Log #' + i;
						fakeLogs.push(fakeRecord);
					}
					await connection.manager.save(fakeLogs);

					const testAddresses: Address[] = [];
					for (let i = 0; i < 3; i++) {
						const testRecord = new Address();
						testRecord.country = 'Test Address #' + i;
						testRecord.city = 'Test Address #' + i;
						testRecord.street = 'Test Address #' + i;
						testAddresses.push(testRecord);
					}
					await connection.manager.save(testAddresses);

					const testPerson = new Person();
					testPerson.name = 'Test Person #1';
					await connection.manager.save(testPerson);

					const testDetail = new ActionDetails();
					testDetail.description = 'Test Details #1';
					await connection.manager.save(testDetail);

					const testLog = new ActionLog();
					testLog.date = new Date();
					testLog.action = 'Test Log #1';
					testLog.person = testPerson;
					testLog.addresses = testAddresses;
					testLog.actionDetails = testDetail;
					await connection.manager.save(testLog);

					const loadedLog = await connection.manager.findOneOrFail(ActionLog, {
						where: { action: 'Test Log #1' },
						relations: {
							person: true,
							actionDetails: true,
							addresses: true,
						},
					});

					loadedLog.person.name.should.be.equal('Test Person #1');
					loadedLog.actionDetails.description.should.be.equal('Test Details #1');
					loadedLog.addresses.length.should.be.equal(3);
				}),
			));
	});
});