import { ColumnMetadata } from '../../metadata/ColumnMetadata';
import { DataSource } from '../../data-source/DataSource';
import { RelationCountAttribute } from './RelationCountAttribute';
import { RelationCountLoadResult } from './RelationCountLoadResult';
import { QueryRunner } from '../../query-runner/QueryRunner';

export class RelationCountLoader {
	// -------------------------------------------------------------------------
	// Constructor
	// -------------------------------------------------------------------------

	constructor(
		protected connection: DataSource,
		protected queryRunner: QueryRunner | undefined,
		protected relationCountAttributes: RelationCountAttribute[],
	) {}

	// -------------------------------------------------------------------------
	// Public Methods
	// -------------------------------------------------------------------------

	async load(rawEntities: any[]): Promise<RelationCountLoadResult[]> {
		const onlyUnique = (value: any, index: number, self: any) => {
			return self.indexOf(value) === index;
		};

		const promises = this.relationCountAttributes.map(async (relationCountAttr) => {
			if (relationCountAttr.relation.isOneToMany) {
				// example: Post and Category
				// loadRelationCountAndMap("post.categoryCount", "post.categories")
				// we expect it to load array of post ids

				// todo(dima): fix issues wit multiple primary keys and remove joinColumns[0]
				const relation = relationCountAttr.relation; // "category.posts"
				const inverseRelation = relation.inverseRelation!; // "post.category"
				const referenceColumnName = inverseRelation.joinColumns[0].referencedColumn!.propertyName; // post id
				const inverseSideTable = relation.inverseEntityMetadata.target; // Post
				const inverseSideTableName = relation.inverseEntityMetadata.tableName; // post
				const inverseSideTableAlias = relationCountAttr.alias || inverseSideTableName; // if condition (custom query builder factory) is set then relationIdAttr.alias defined
				const inverseSidePropertyName = inverseRelation.propertyName; // "category" from "post.category"

				let referenceColumnValues = rawEntities
					.map((rawEntity) => rawEntity[relationCountAttr.parentAlias + '_' + referenceColumnName])
					.filter((value) => !!value);
				referenceColumnValues = referenceColumnValues.filter(onlyUnique);

				// ensure we won't perform redundant queries for joined data which was not found in selection
				// example: if post.category was not found in db then no need to execute query for category.imageIds
				if (referenceColumnValues.length === 0)
					return {
						relationCountAttribute: relationCountAttr,
						results: [],
					};

				// generate query:
				// SELECT category.post as parentId, COUNT(*) AS cnt FROM category category WHERE category.post IN (1, 2) GROUP BY category.post
				const qb = this.connection.createQueryBuilder(this.queryRunner);
				qb.select(inverseSideTableAlias + '.' + inverseSidePropertyName, 'parentId')
					.addSelect('COUNT(*)', 'cnt')
					.from(inverseSideTable, inverseSideTableAlias)
					.where(inverseSideTableAlias + '.' + inverseSidePropertyName + ' IN (:...ids)')
					.addGroupBy(inverseSideTableAlias + '.' + inverseSidePropertyName)
					.setParameter('ids', referenceColumnValues);

				// apply condition (custom query builder factory)
				if (relationCountAttr.queryBuilderFactory) relationCountAttr.queryBuilderFactory(qb);

				return {
					relationCountAttribute: relationCountAttr,
					results: await qb.getRawMany(),
				};
			} else {
				// example: Post and Category
				// owner side: loadRelationIdAndMap("post.categoryIds", "post.categories")
				// inverse side: loadRelationIdAndMap("category.postIds", "category.posts")
				// we expect it to load array of post ids

				let joinTableColumnName: string;
				let inverseJoinColumnName: string;
				let firstJunctionColumn: ColumnMetadata;
				let secondJunctionColumn: ColumnMetadata;

				if (relationCountAttr.relation.isOwning) {
					// todo fix joinColumns[0] and inverseJoinColumns[0].
					joinTableColumnName =
						relationCountAttr.relation.joinColumns[0].referencedColumn!.databaseName;
					inverseJoinColumnName =
						relationCountAttr.relation.inverseJoinColumns[0].referencedColumn!.databaseName;
					firstJunctionColumn = relationCountAttr.relation.junctionEntityMetadata!.columns[0];
					secondJunctionColumn = relationCountAttr.relation.junctionEntityMetadata!.columns[1];
				} else {
					joinTableColumnName =
						relationCountAttr.relation.inverseRelation!.inverseJoinColumns[0].referencedColumn!
							.databaseName;
					inverseJoinColumnName =
						relationCountAttr.relation.inverseRelation!.joinColumns[0].referencedColumn!
							.databaseName;
					firstJunctionColumn = relationCountAttr.relation.junctionEntityMetadata!.columns[1];
					secondJunctionColumn = relationCountAttr.relation.junctionEntityMetadata!.columns[0];
				}

				let referenceColumnValues = rawEntities
					.map((rawEntity) => rawEntity[relationCountAttr.parentAlias + '_' + joinTableColumnName])
					.filter((value) => !!value);
				referenceColumnValues = referenceColumnValues.filter(onlyUnique);

				// ensure we won't perform redundant queries for joined data which was not found in selection
				// example: if post.category was not found in db then no need to execute query for category.imageIds
				if (referenceColumnValues.length === 0)
					return {
						relationCountAttribute: relationCountAttr,
						results: [],
					};

				const junctionAlias = relationCountAttr.junctionAlias;
				const inverseSideTableName = relationCountAttr.joinInverseSideMetadata.tableName;
				const inverseSideTableAlias = relationCountAttr.alias || inverseSideTableName;
				const junctionTableName = relationCountAttr.relation.junctionEntityMetadata!.tableName;

				const condition =
					junctionAlias +
					'.' +
					firstJunctionColumn.propertyName +
					' IN (' +
					referenceColumnValues.map((vals) => (isNaN(vals) ? "'" + vals + "'" : vals)) +
					')' +
					' AND ' +
					junctionAlias +
					'.' +
					secondJunctionColumn.propertyName +
					' = ' +
					inverseSideTableAlias +
					'.' +
					inverseJoinColumnName;

				const qb = this.connection.createQueryBuilder(this.queryRunner);
				qb.select(junctionAlias + '.' + firstJunctionColumn.propertyName, 'parentId')
					.addSelect(
						'COUNT(' +
							qb.escape(inverseSideTableAlias) +
							'.' +
							qb.escape(inverseJoinColumnName) +
							')',
						'cnt',
					)
					.from(inverseSideTableName, inverseSideTableAlias)
					.innerJoin(junctionTableName, junctionAlias, condition)
					.addGroupBy(junctionAlias + '.' + firstJunctionColumn.propertyName);

				// apply condition (custom query builder factory)
				if (relationCountAttr.queryBuilderFactory) relationCountAttr.queryBuilderFactory(qb);

				return {
					relationCountAttribute: relationCountAttr,
					results: await qb.getRawMany(),
				};
			}
		});

		return Promise.all(promises);
	}
}