import { ColumnMetadata } from './ColumnMetadata';
import { EntityMetadata } from './EntityMetadata';
import { NamingStrategyInterface } from '../naming-strategy/NamingStrategyInterface';
import { DeferrableType } from './types/DeferrableType';
import { OnDeleteType } from './types/OnDeleteType';
import { OnUpdateType } from './types/OnUpdateType';

/**
 * Contains all information about entity's foreign key.
 */
export class ForeignKeyMetadata {
	// -------------------------------------------------------------------------
	// Public Properties
	// -------------------------------------------------------------------------

	/**
	 * Entity metadata where this foreign key is.
	 */
	entityMetadata: EntityMetadata;

	/**
	 * Entity metadata which this foreign key references.
	 */
	referencedEntityMetadata: EntityMetadata;

	/**
	 * Array of columns of this foreign key.
	 */
	columns: ColumnMetadata[] = [];

	/**
	 * Array of referenced columns.
	 */
	referencedColumns: ColumnMetadata[] = [];

	/**
	 * What to do with a relation on deletion of the row containing a foreign key.
	 */
	onDelete?: OnDeleteType;

	/**
	 * What to do with a relation on update of the row containing a foreign key.
	 */
	onUpdate?: OnUpdateType;

	/**
	 * When to check the constraints of a foreign key.
	 */
	deferrable?: DeferrableType;

	/**
	 * Gets the table name to which this foreign key is referenced.
	 */
	referencedTablePath: string;

	/**
	 * Gets foreign key name.
	 * If unique constraint name was given by a user then it stores givenName.
	 * If unique constraint name was not given then its generated.
	 */
	name: string;

	/**
	 * Gets array of column names.
	 */
	columnNames: string[] = [];

	/**
	 * Gets array of referenced column names.
	 */
	referencedColumnNames: string[] = [];

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

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

	constructor(options: {
		entityMetadata: EntityMetadata;
		referencedEntityMetadata: EntityMetadata;
		namingStrategy?: NamingStrategyInterface;
		columns: ColumnMetadata[];
		referencedColumns: ColumnMetadata[];
		onDelete?: OnDeleteType;
		onUpdate?: OnUpdateType;
		deferrable?: DeferrableType;
		name?: string;
	}) {
		this.entityMetadata = options.entityMetadata;
		this.referencedEntityMetadata = options.referencedEntityMetadata;
		this.columns = options.columns;
		this.referencedColumns = options.referencedColumns;
		this.onDelete = options.onDelete || 'NO ACTION';
		this.onUpdate = options.onUpdate || 'NO ACTION';
		this.deferrable = options.deferrable;
		this.givenName = options.name;
		if (options.namingStrategy) this.build(options.namingStrategy);
	}

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

	/**
	 * Builds some depend foreign key properties.
	 * Must be called after all entity metadatas and their columns are built.
	 */
	build(namingStrategy: NamingStrategyInterface) {
		this.columnNames = this.columns.map((column) => column.databaseName);
		this.referencedColumnNames = this.referencedColumns.map((column) => column.databaseName);
		this.referencedTablePath = this.referencedEntityMetadata.tablePath;
		this.name = this.givenName
			? this.givenName
			: namingStrategy.foreignKeyName(
					this.entityMetadata.tableName,
					this.columnNames,
					this.referencedEntityMetadata.tableName,
					this.referencedColumnNames,
				);
	}
}