import { EntityManager } from '../entity-manager/EntityManager';
import { EntityMetadata } from '../metadata/EntityMetadata';
import { FindTreesOptions } from '../repository/FindTreesOptions';

/**
 * Provides utilities for manipulating tree structures.
 *
 */
export class TreeRepositoryUtils {
	// -------------------------------------------------------------------------
	// Public Methods
	// -------------------------------------------------------------------------

	static createRelationMaps(
		manager: EntityManager,
		metadata: EntityMetadata,
		alias: string,
		rawResults: any[],
	): { id: any; parentId: any }[] {
		return rawResults.map((rawResult) => {
			const joinColumn = metadata.treeParentRelation!.joinColumns[0];
			const referencedColumn = joinColumn.referencedColumn ?? metadata.primaryColumns[0];
			// fixes issue #2518, default to databaseName property when givenDatabaseName is not set
			const joinColumnName = joinColumn.givenDatabaseName || joinColumn.databaseName;
			const referencedColumnName =
				referencedColumn.givenDatabaseName || referencedColumn.databaseName;
			const id = rawResult[alias + '_' + referencedColumnName];
			const parentId = rawResult[alias + '_' + joinColumnName];
			return {
				id: manager.connection.driver.prepareHydratedValue(id, referencedColumn),
				parentId: manager.connection.driver.prepareHydratedValue(parentId, joinColumn),
			};
		});
	}

	static buildChildrenEntityTree(
		metadata: EntityMetadata,
		entity: any,
		entities: any[],
		relationMaps: { id: any; parentId: any }[],
		options: FindTreesOptions & { depth: number },
	): void {
		const childProperty = metadata.treeChildrenRelation!.propertyName;
		if (options.depth === 0) {
			entity[childProperty] = [];
			return;
		}
		const joinColumn = metadata.treeParentRelation!.joinColumns[0];
		const referencedColumn = joinColumn.referencedColumn ?? metadata.primaryColumns[0];
		const parentEntityId = referencedColumn.getEntityValue(entity);
		const childRelationMaps = relationMaps.filter(
			(relationMap) => relationMap.parentId === parentEntityId,
		);
		const childIds = new Set(childRelationMaps.map((relationMap) => relationMap.id));
		entity[childProperty] = entities.filter((entity) =>
			childIds.has(referencedColumn.getEntityValue(entity)),
		);
		entity[childProperty].forEach((childEntity: any) => {
			TreeRepositoryUtils.buildChildrenEntityTree(metadata, childEntity, entities, relationMaps, {
				...options,
				depth: options.depth - 1,
			});
		});
	}

	static buildParentEntityTree(
		metadata: EntityMetadata,
		entity: any,
		entities: any[],
		relationMaps: { id: any; parentId: any }[],
	): void {
		const parentProperty = metadata.treeParentRelation!.propertyName;
		const joinColumn = metadata.treeParentRelation!.joinColumns[0];
		const referencedColumn = joinColumn.referencedColumn ?? metadata.primaryColumns[0];
		const entityId = referencedColumn.getEntityValue(entity);
		const parentRelationMap = relationMaps.find((relationMap) => relationMap.id === entityId);
		const parentEntity = entities.find((entity) => {
			if (!parentRelationMap) return false;

			return referencedColumn.getEntityValue(entity) === parentRelationMap.parentId;
		});
		if (parentEntity) {
			entity[parentProperty] = parentEntity;
			TreeRepositoryUtils.buildParentEntityTree(
				metadata,
				entity[parentProperty],
				entities,
				relationMaps,
			);
		}
	}
}