import { EmbeddedMetadata } from './EmbeddedMetadata';
import { EntityMetadata } from './EntityMetadata';
import { NamingStrategyInterface } from '../naming-strategy/NamingStrategyInterface';
import { ColumnMetadata } from './ColumnMetadata';
import { UniqueMetadataArgs } from '../metadata-args/UniqueMetadataArgs';
import { TypeORMError } from '../error';
import { DeferrableType } from './types/DeferrableType';

/**
 * Unique metadata contains all information about table's unique constraints.
 */
export class UniqueMetadata {
	// ---------------------------------------------------------------------
	// Public Properties
	// ---------------------------------------------------------------------

	/**
	 * Entity metadata of the class to which this unique constraint is applied.
	 */
	entityMetadata: EntityMetadata;

	/**
	 * Embedded metadata if this unique was applied on embedded.
	 */
	embeddedMetadata?: EmbeddedMetadata;

	/**
	 * Target class to which metadata is applied.
	 */
	target?: Function | string;

	/**
	 * Unique columns.
	 */
	columns: ColumnMetadata[] = [];

	/**
	 * Indicate if unique constraints can be deferred.
	 */
	deferrable?: DeferrableType;

	/**
	 * User specified unique constraint name.
	 */
	givenName?: string;

	/**
	 * User specified column names.
	 */
	givenColumnNames?: ((object?: any) => any[] | { [key: string]: number }) | string[];

	/**
	 * Final unique constraint name.
	 * If unique constraint name was given by a user then it stores normalized (by naming strategy) givenName.
	 * If unique constraint name was not given then its generated.
	 */
	name: string;

	/**
	 * Map of column names with order set.
	 * Used only by MongoDB driver.
	 */
	columnNamesWithOrderingMap: { [key: string]: number } = {};

	// ---------------------------------------------------------------------
	// Constructor
	// ---------------------------------------------------------------------

	constructor(options: {
		entityMetadata: EntityMetadata;
		embeddedMetadata?: EmbeddedMetadata;
		columns?: ColumnMetadata[];
		args?: UniqueMetadataArgs;
	}) {
		this.entityMetadata = options.entityMetadata;
		this.embeddedMetadata = options.embeddedMetadata;
		if (options.columns) this.columns = options.columns;

		if (options.args) {
			this.target = options.args.target;
			this.givenName = options.args.name;
			this.givenColumnNames = options.args.columns;
			this.deferrable = options.args.deferrable;
		}
	}

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

	/**
	 * Builds some depend unique constraint properties.
	 * Must be called after all entity metadata's properties map, columns and relations are built.
	 */
	build(namingStrategy: NamingStrategyInterface): this {
		const map: { [key: string]: number } = {};

		// if columns already an array of string then simply return it
		if (this.givenColumnNames) {
			let columnPropertyPaths: string[] = [];
			if (Array.isArray(this.givenColumnNames)) {
				columnPropertyPaths = this.givenColumnNames.map((columnName) => {
					if (this.embeddedMetadata) return this.embeddedMetadata.propertyPath + '.' + columnName;

					return columnName.trim();
				});
				columnPropertyPaths.forEach((propertyPath) => (map[propertyPath] = 1));
			} else {
				// if columns is a function that returns array of field names then execute it and get columns names from it
				const columnsFnResult = this.givenColumnNames(this.entityMetadata.propertiesMap);
				if (Array.isArray(columnsFnResult)) {
					columnPropertyPaths = columnsFnResult.map((i: any) => String(i));
					columnPropertyPaths.forEach((name) => (map[name] = 1));
				} else {
					columnPropertyPaths = Object.keys(columnsFnResult).map((i: any) => String(i));
					Object.keys(columnsFnResult).forEach(
						(columnName) => (map[columnName] = columnsFnResult[columnName]),
					);
				}
			}

			this.columns = columnPropertyPaths
				.map((propertyName) => {
					const columnWithSameName = this.entityMetadata.columns.find(
						(column) => column.propertyPath === propertyName,
					);
					if (columnWithSameName) {
						return [columnWithSameName];
					}
					const relationWithSameName = this.entityMetadata.relations.find(
						(relation) => relation.isWithJoinColumn && relation.propertyName === propertyName,
					);
					if (relationWithSameName) {
						return relationWithSameName.joinColumns;
					}
					const indexName = this.givenName ? '"' + this.givenName + '" ' : '';
					const entityName = this.entityMetadata.targetName;
					throw new TypeORMError(
						`Unique constraint ${indexName}contains column that is missing in the entity (${entityName}): ` +
							propertyName,
					);
				})
				.reduce((a, b) => a.concat(b));
		}

		this.columnNamesWithOrderingMap = Object.keys(map).reduce(
			(updatedMap, key) => {
				const column = this.entityMetadata.columns.find((column) => column.propertyPath === key);
				if (column) updatedMap[column.databasePath] = map[key];

				return updatedMap;
			},
			{} as { [key: string]: number },
		);

		this.name = this.givenName
			? this.givenName
			: namingStrategy.uniqueConstraintName(
					this.entityMetadata.tableName,
					this.columns.map((column) => column.databaseName),
				);
		return this;
	}
}