import { expect } from 'chai';
import 'reflect-metadata';
import { DataSource } from '../../../src';
import { closeTestingConnections, createTestingConnections } from '../../utils/test-utils';
import { User } from './entity/User';
import { Setting } from './entity/Setting';
import { SettingSubscriber } from './entity/SettingSubscriber';

/**
 *  Using OneToMany relation with composed primary key should not error and work correctly
 */
describe('github issues > #8221', () => {
	let connections: DataSource[];

	before(
		async () =>
			(connections = await createTestingConnections({
				entities: [User, Setting],
				subscribers: [SettingSubscriber],
				schemaCreate: true,
				dropSchema: true,
			})),
	);

	after(() => closeTestingConnections(connections));

	function insertSimpleTestData(connection: DataSource) {
		const userRepo = connection.getRepository(User);
		// const settingRepo = connection.getRepository(Setting);

		const user = new User(1, 'FooGuy');
		const settingA = new Setting(1, 'A', 'foo');
		const settingB = new Setting(1, 'B', 'bar');
		user.settings = [settingA, settingB];

		return userRepo.save(user);
	}

	// important: must not use Promise.all! parallel execution against different drivers would mess up the counter within the SettingSubscriber!

	it('afterLoad entity modifier must not make relation key matching fail', async () => {
		for (const connection of connections) {
			const userRepo = connection.getRepository(User);
			const subscriber = connection.subscribers.find(
				(s) => s instanceof SettingSubscriber,
			) as SettingSubscriber;
			if (!subscriber) throw new Error(`Subscriber not found`);

			subscriber.reset();

			await insertSimpleTestData(connection);
			subscriber.reset();

			await userRepo.save([
				{
					id: 1,
					settings: [
						{ assertId: 1, name: 'A', value: 'foobar' },
						{ assertId: 1, name: 'B', value: 'testvalue' },
					],
				},
			]);

			// we use a subscriber to count generated Subjects based on how often beforeInsert/beforeRemove/beforeUpdate has been called.
			// the save query should only update settings, so only beforeUpdate should have been called.
			// if beforeInsert/beforeUpdate has been called, this would indicate that key matching has failed.
			// the resulting state would be the same, but settings entities would be deleted and inserted instead.

			expect(subscriber.counter.deletes).to.equal(0);
			expect(subscriber.counter.inserts).to.equal(0);
			expect(subscriber.counter.updates).to.equal(2);
		}
	});
});