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

describe('github issues > #1997 enum type not working in postgres when defined in a custom schema', () => {
	let connections: DataSource[];
	before(
		async () =>
			(connections = await createTestingConnections({
				entities: [__dirname + '/entity/*{.js,.ts}'],
				enabledDrivers: ['postgres'],
			})),
	);
	beforeEach(() => {
		return Promise.all(
			connections.map(async (connection) => {
				const queryRunner = connection.createQueryRunner();
				await queryRunner.dropSchema('schema', true, true);
				await queryRunner.createSchema('schema');
				await queryRunner.release();
			}),
		);
	});
	afterEach(() => {
		return Promise.all(
			connections.map(async (connection) => {
				const queryRunner = connection.createQueryRunner();
				await queryRunner.dropSchema('schema', true, true);
				await queryRunner.release();
			}),
		);
	});
	after(() => closeTestingConnections(connections));

	it('should create table with ENUM column', () =>
		Promise.all(
			connections.map(async (connection) => {
				await connection.driver.createSchemaBuilder().build();
			}),
		));

	it('should be able to read table data with ENUM', () =>
		Promise.all(
			connections.map(async (connection) => {
				await connection.driver.createSchemaBuilder().build();
				const queryRunner = connection.createQueryRunner();
				const table = await queryRunner.getTable('schema.post');
				table!.should.not.be.undefined;
				await queryRunner.release();
			}),
		));

	it('should save data with ENUM', () =>
		Promise.all(
			connections.map(async (connection) => {
				await connection.driver.createSchemaBuilder().build();

				const postRepository = connection.getRepository(Post);
				const queryRunner = connection.createQueryRunner();
				const table = await queryRunner.getTable('schema.post');
				await queryRunner.release();

				const post = new Post();
				post.enum = 'A';
				post.name = 'Post #1';
				await postRepository.save(post);

				const loadedPost = (await postRepository.findOneBy({ id: 1 }))!;
				loadedPost.enum.should.be.equal(post.enum);

				table!.findColumnByName('enum')!.type.should.be.equal('enum');
			}),
		));

	it('should create ENUM column and revert creation', () =>
		Promise.all(
			connections.map(async (connection) => {
				await connection.driver.createSchemaBuilder().build();

				const queryRunner = connection.createQueryRunner();
				await queryRunner.addColumn(
					'schema.post',
					new TableColumn({
						name: 'newEnum',
						type: 'enum',
						enum: ['Apple', 'Pineapple'],
					}),
				);

				let table = await queryRunner.getTable('schema.post');
				table!.findColumnByName('newEnum')!.type.should.be.equal('enum');

				await queryRunner.executeMemoryDownSql();

				table = await queryRunner.getTable('schema.post');
				expect(table!.findColumnByName('newEnum')).to.be.undefined;

				await queryRunner.release();
			}),
		));

	it('should drop ENUM column and revert drop', () =>
		Promise.all(
			connections.map(async (connection) => {
				await connection.driver.createSchemaBuilder().build();

				const queryRunner = connection.createQueryRunner();
				let table = await queryRunner.getTable('schema.post');
				const enumColumn = table!.findColumnByName('enum')!;

				await queryRunner.dropColumn(table!, enumColumn);
				expect(table!.findColumnByName('enum')).to.be.undefined;

				await queryRunner.executeMemoryDownSql();

				table = await queryRunner.getTable('schema.post');
				table!.findColumnByName('enum')!.type.should.be.equal('enum');

				await queryRunner.release();
			}),
		));

	it('should create table with ENUM column and revert creation', () =>
		Promise.all(
			connections.map(async (connection) => {
				await connection.driver.createSchemaBuilder().build();

				const queryRunner = connection.createQueryRunner();
				await queryRunner.createTable(
					new Table({
						name: 'schema.question',
						columns: [
							{
								name: 'enum',
								type: 'enum',
								enum: ['Apple', 'Banana', 'Cherry'],
							},
						],
					}),
				);

				let table = await queryRunner.getTable('schema.question');
				const enumColumn = table!.findColumnByName('enum')!;
				enumColumn.type.should.be.equal('enum');
				enumColumn.enum!.should.be.eql(['Apple', 'Banana', 'Cherry']);

				await queryRunner.executeMemoryDownSql();

				table = await queryRunner.getTable('question');
				expect(table).to.be.undefined;

				await queryRunner.release();
			}),
		));

	it('should drop table with ENUM column and revert drop', () =>
		Promise.all(
			connections.map(async (connection) => {
				await connection.driver.createSchemaBuilder().build();

				const queryRunner = connection.createQueryRunner();
				await queryRunner.dropTable('schema.post');

				let table = await queryRunner.getTable('schema.post');
				expect(table).to.be.undefined;

				await queryRunner.executeMemoryDownSql();

				table = await queryRunner.getTable('schema.post');
				expect(table).to.be.not.undefined;

				await queryRunner.release();
			}),
		));

	it('should change non-enum column in to ENUM and revert change', () =>
		Promise.all(
			connections.map(async (connection) => {
				await connection.driver.createSchemaBuilder().build();

				const queryRunner = connection.createQueryRunner();
				let table = await queryRunner.getTable('schema.post');
				let nameColumn = table!.findColumnByName('name')!;
				let changedColumn = nameColumn.clone();
				changedColumn.type = 'enum';
				changedColumn.enum = ['Apple', 'Banana', 'Cherry'];

				await queryRunner.changeColumn(table!, nameColumn, changedColumn);

				table = await queryRunner.getTable('schema.post');
				changedColumn = table!.findColumnByName('name')!;
				changedColumn.type.should.be.equal('enum');
				changedColumn.enum!.should.be.eql(['Apple', 'Banana', 'Cherry']);

				await queryRunner.executeMemoryDownSql();

				table = await queryRunner.getTable('schema.post');
				nameColumn = table!.findColumnByName('name')!;
				nameColumn.type.should.be.equal('character varying');
				expect(nameColumn.enum).to.be.undefined;

				await queryRunner.release();
			}),
		));

	it('should change ENUM column in to non-enum and revert change', () =>
		Promise.all(
			connections.map(async (connection) => {
				await connection.driver.createSchemaBuilder().build();

				const queryRunner = connection.createQueryRunner();
				let table = await queryRunner.getTable('schema.post');
				let enumColumn = table!.findColumnByName('enum')!;
				let changedColumn = enumColumn.clone();
				changedColumn.type = 'character varying';
				changedColumn.enum = undefined;

				await queryRunner.changeColumn(table!, enumColumn, changedColumn);

				table = await queryRunner.getTable('schema.post');
				changedColumn = table!.findColumnByName('enum')!;
				changedColumn.type.should.be.equal('character varying');
				expect(changedColumn.enum).to.be.undefined;

				await queryRunner.executeMemoryDownSql();

				table = await queryRunner.getTable('schema.post');
				enumColumn = table!.findColumnByName('enum')!;
				enumColumn.type.should.be.equal('enum');
				enumColumn.enum!.should.be.eql(['A', 'B', 'C']);

				await queryRunner.release();
			}),
		));

	it('should change ENUM column and revert change', () =>
		Promise.all(
			connections.map(async (connection) => {
				await connection.driver.createSchemaBuilder().build();

				const queryRunner = connection.createQueryRunner();
				let table = await queryRunner.getTable('schema.post');
				const enumColumn = table!.findColumnByName('enum')!;
				const changedColumn = enumColumn.clone();
				changedColumn.enum = ['C', 'D', 'E'];

				await queryRunner.changeColumn(table!, enumColumn, changedColumn);

				table = await queryRunner.getTable('schema.post');
				table!.findColumnByName('enum')!.enum!.should.be.eql(['C', 'D', 'E']);

				await queryRunner.executeMemoryDownSql();

				table = await queryRunner.getTable('schema.post');
				table!.findColumnByName('enum')!.enum!.should.be.eql(['A', 'B', 'C']);

				await queryRunner.release();
			}),
		));

	it('should rename ENUM when column renamed and revert rename', () =>
		Promise.all(
			connections.map(async (connection) => {
				await connection.driver.createSchemaBuilder().build();

				const queryRunner = connection.createQueryRunner();
				const table = await queryRunner.getTable('schema.post');
				const enumColumn = table!.findColumnByName('enum')!;
				const changedColumn = enumColumn.clone();
				changedColumn.name = 'enumerable';

				await queryRunner.changeColumn(table!, enumColumn, changedColumn);

				let result = await queryRunner.query(
					`SELECT "n"."nspname", "t"."typname" FROM "pg_type" "t" ` +
						`INNER JOIN "pg_namespace" "n" ON "n"."oid" = "t"."typnamespace" ` +
						`WHERE "n"."nspname" = 'schema' AND "t"."typname" = 'post_enumerable_enum'`,
				);
				result.length.should.be.equal(1);

				await queryRunner.executeMemoryDownSql();

				result = await queryRunner.query(
					`SELECT "n"."nspname", "t"."typname" FROM "pg_type" "t" ` +
						`INNER JOIN "pg_namespace" "n" ON "n"."oid" = "t"."typnamespace" ` +
						`WHERE "n"."nspname" = 'schema' AND "t"."typname" = 'post_enum_enum'`,
				);
				result.length.should.be.equal(1);

				await queryRunner.release();
			}),
		));

	it('should rename ENUM when table renamed and revert rename', () =>
		Promise.all(
			connections.map(async (connection) => {
				await connection.driver.createSchemaBuilder().build();

				const queryRunner = connection.createQueryRunner();
				const table = await queryRunner.getTable('schema.post');

				await queryRunner.renameTable(table!, 'question');

				let result = await queryRunner.query(
					`SELECT "n"."nspname", "t"."typname" FROM "pg_type" "t" ` +
						`INNER JOIN "pg_namespace" "n" ON "n"."oid" = "t"."typnamespace" ` +
						`WHERE "n"."nspname" = 'schema' AND "t"."typname" = 'question_enum_enum'`,
				);
				result.length.should.be.equal(1);

				await queryRunner.executeMemoryDownSql();

				result = await queryRunner.query(
					`SELECT "n"."nspname", "t"."typname" FROM "pg_type" "t" ` +
						`INNER JOIN "pg_namespace" "n" ON "n"."oid" = "t"."typnamespace" ` +
						`WHERE "n"."nspname" = 'schema' AND "t"."typname" = 'post_enum_enum'`,
				);
				result.length.should.be.equal(1);

				await queryRunner.release();
			}),
		));
});