import 'reflect-metadata';
import {
	closeTestingConnections,
	createTestingConnections,
	reloadTestingDatabases,
} from '../../utils/test-utils';
import { DataSource } from '../../../src/data-source/DataSource';
import { Foo } from './entity/Foo';
import { FooMetadata } from './entity/FooMetadata';
import { FooChildMetadata } from './entity/FooChildMetadata';

describe('github issues > #762 Nullable @Embedded inside @Embedded', () => {
	let connections: DataSource[];
	before(
		async () =>
			(connections = await createTestingConnections({
				entities: [__dirname + '/entity/*{.js,.ts}'],
			})),
	);
	beforeEach(() => reloadTestingDatabases(connections));
	after(() => closeTestingConnections(connections));

	it('should work perfectly with all data set', () =>
		Promise.all(
			connections.map(async (connection) => {
				const foo = new Foo();
				foo.name = 'Apple';
				foo.metadata = new FooMetadata();
				foo.metadata.bar = 1;
				foo.metadata.child = new FooChildMetadata();
				foo.metadata.child.something = 2;
				foo.metadata.child.somethingElse = 3;
				await connection.manager.save(foo);

				const loadedFoo = await connection.getRepository(Foo).findOneBy({ name: 'Apple' });
				loadedFoo!.should.be.eql({
					id: 1,
					name: 'Apple',
					metadata: {
						bar: 1,
						child: {
							something: 2,
							somethingElse: 3,
						},
					},
				});
			}),
		));

	it('should work perfectly with some data not set', () =>
		Promise.all(
			connections.map(async (connection) => {
				const foo = new Foo();
				foo.name = 'Apple';
				foo.metadata = new FooMetadata();
				foo.metadata.bar = 1;
				foo.metadata.child = new FooChildMetadata();
				foo.metadata.child.somethingElse = 3;
				await connection.manager.save(foo);

				const loadedFoo = await connection.getRepository(Foo).findOneBy({ name: 'Apple' });
				loadedFoo!.should.be.eql({
					id: 1,
					name: 'Apple',
					metadata: {
						bar: 1,
						child: {
							something: null,
							somethingElse: 3,
						},
					},
				});

				const foo2 = new Foo();
				foo2.name = 'Apple2';
				foo2.metadata = new FooMetadata();
				foo2.metadata.child = new FooChildMetadata();
				foo2.metadata.child.something = 2;
				await connection.manager.save(foo2);

				const loadedFoo2 = await connection.getRepository(Foo).findOneBy({ name: 'Apple2' });
				loadedFoo2!.should.be.eql({
					id: 2,
					name: 'Apple2',
					metadata: {
						bar: null,
						child: {
							something: 2,
							somethingElse: null,
						},
					},
				});

				const foo3 = new Foo();
				foo3.name = 'Apple3';
				foo3.metadata = new FooMetadata();
				await connection.manager.save(foo3);

				const loadedFoo3 = await connection.getRepository(Foo).findOneBy({ name: 'Apple3' });
				loadedFoo3!.should.be.eql({
					id: 3,
					name: 'Apple3',
					metadata: {
						bar: null,
						child: {
							something: null,
							somethingElse: null,
						},
					},
				});
			}),
		));

	it('should work perfectly without any data set', () =>
		Promise.all(
			connections.map(async (connection) => {
				const foo = new Foo();
				foo.name = 'Orange';
				await connection.manager.save(foo);

				const loadedFoo = await connection.getRepository(Foo).findOneBy({ name: 'Orange' });
				loadedFoo!.should.be.eql({
					id: 1,
					name: 'Orange',
					metadata: {
						bar: null,
						child: {
							something: null,
							somethingElse: null,
						},
					},
				});
			}),
		));
});