import { RelationType } from './types/RelationTypes';
import { EntityMetadata } from './EntityMetadata';
import { ForeignKeyMetadata } from './ForeignKeyMetadata';
import { ObjectLiteral } from '../common/ObjectLiteral';
import { ColumnMetadata } from './ColumnMetadata';
import { EmbeddedMetadata } from './EmbeddedMetadata';
import { RelationMetadataArgs } from '../metadata-args/RelationMetadataArgs';
import { DeferrableType } from './types/DeferrableType';
import { OnUpdateType } from './types/OnUpdateType';
import { OnDeleteType } from './types/OnDeleteType';
import { PropertyTypeFactory } from './types/PropertyTypeInFunction';
import { TypeORMError } from '../error';
import { ObjectUtils } from '../util/ObjectUtils';
import { InstanceChecker } from '../util/InstanceChecker';

/**
 * Contains all information about some entity's relation.
 */
export class RelationMetadata {
	// ---------------------------------------------------------------------
	// Public Properties
	// ---------------------------------------------------------------------

	/**
	 * Entity metadata of the entity where this relation is placed.
	 *
	 * For example for @ManyToMany(type => Category) in Post, entityMetadata will be metadata of Post entity.
	 */
	entityMetadata: EntityMetadata;

	/**
	 * Entity metadata of the entity that is targeted by this relation.
	 *
	 * For example for @ManyToMany(type => Category) in Post, inverseEntityMetadata will be metadata of Category entity.
	 */
	inverseEntityMetadata: EntityMetadata;

	/**
	 * Entity metadata of the junction table.
	 * Junction tables have their own entity metadata objects.
	 * Defined only for many-to-many relations.
	 */
	junctionEntityMetadata?: EntityMetadata;

	/**
	 * Embedded metadata where this relation is.
	 * If this relation is not in embed then this property value is undefined.
	 */
	embeddedMetadata?: EmbeddedMetadata;

	/**
	 * Relation type, e.g. is it one-to-one, one-to-many, many-to-one or many-to-many.
	 */
	relationType: RelationType;

	/**
	 * Target entity to which this relation is applied.
	 * Target IS NOT equal to entityMetadata.target, because relation
	 *
	 * For example for @ManyToMany(type => Category) in Post, target will be Post.
	 * If @ManyToMany(type => Category) is in Counters which is embedded into Post, target will be Counters.
	 * If @ManyToMany(type => Category) is in abstract class BaseUser which Post extends, target will be BaseUser.
	 * Target can be string if its defined in entity schema instead of class.
	 */
	target: Function | string;

	/**
	 * Target's property name to which relation decorator is applied.
	 */
	propertyName: string;

	/**
	 * Gets full path to this column property (including relation name).
	 * Full path is relevant when column is used in embeds (one or multiple nested).
	 * For example it will return "counters.subcounters.likes".
	 * If property is not in embeds then it returns just property name of the column.
	 */
	propertyPath: string;

	/**
	 * Indicates if this is a parent (can be only many-to-one relation) relation in the tree tables.
	 */
	isTreeParent: boolean = false;

	/**
	 * Indicates if this is a children (can be only one-to-many relation) relation in the tree tables.
	 */
	isTreeChildren: boolean = false;

	/**
	 * Indicates if this relation's column is a primary key.
	 * Can be used only for many-to-one and owner one-to-one relations.
	 */
	isPrimary: boolean = false;

	/**
	 * Indicates if this relation is lazily loaded.
	 */
	isLazy: boolean = false;

	/**
	 * Indicates if this relation is eagerly loaded.
	 */
	isEager: boolean = false;

	/**
	 * Indicates if persistence is enabled for the relation.
	 * By default its enabled, but if you want to avoid any changes in the relation to be reflected in the database you can disable it.
	 * If its disabled you can only change a relation from inverse side of a relation or using relation query builder functionality.
	 * This is useful for performance optimization since its disabling avoid multiple extra queries during entity save.
	 */
	persistenceEnabled: boolean = true;

	/**
	 * When a parent is saved (with cascading but) without a child row that still exists in database, this will control what shall happen to them.
	 * delete will remove these rows from database. nullify will remove the relation key.
	 * skip will keep the relation intact. Removal of related item is only possible through its own repo.
	 */
	orphanedRowAction?: 'nullify' | 'delete' | 'soft-delete' | 'disable';

	/**
	 * If set to true then related objects are allowed to be inserted to the database.
	 */
	isCascadeInsert: boolean = false;

	/**
	 * If set to true then related objects are allowed to be updated in the database.
	 */
	isCascadeUpdate: boolean = false;

	/**
	 * If set to true then related objects are allowed to be remove from the database.
	 */
	isCascadeRemove: boolean = false;

	/**
	 * If set to true then related objects are allowed to be soft-removed from the database.
	 */
	isCascadeSoftRemove: boolean = false;

	/**
	 * If set to true then related objects are allowed to be recovered from the database.
	 */
	isCascadeRecover: boolean = false;

	/**
	 * Indicates if relation column value can be nullable or not.
	 */
	isNullable: boolean = true;

	/**
	 * 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;

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

	/**
	 * Indicates whether foreign key constraints will be created for join columns.
	 * Can be used only for many-to-one and owner one-to-one relations.
	 * Defaults to true.
	 */
	createForeignKeyConstraints: boolean = true;

	/**
	 * Gets the property's type to which this relation is applied.
	 *
	 * For example for @ManyToMany(type => Category) in Post, target will be Category.
	 */
	type: Function | string;

	/**
	 * Indicates if this side is an owner of this relation.
	 */
	isOwning: boolean = false;

	/**
	 * Checks if this relation's type is "one-to-one".
	 */
	isOneToOne: boolean = false;

	/**
	 * Checks if this relation is owner side of the "one-to-one" relation.
	 * Owner side means this side of relation has a join column in the table.
	 */
	isOneToOneOwner: boolean = false;

	/**
	 * Checks if this relation has a join column (e.g. is it many-to-one or one-to-one owner side).
	 */
	isWithJoinColumn: boolean = false;

	/**
	 * Checks if this relation is NOT owner side of the "one-to-one" relation.
	 * NOT owner side means this side of relation does not have a join column in the table.
	 */
	isOneToOneNotOwner: boolean = false;

	/**
	 * Checks if this relation's type is "one-to-many".
	 */
	isOneToMany: boolean = false;

	/**
	 * Checks if this relation's type is "many-to-one".
	 */
	isManyToOne: boolean = false;

	/**
	 * Checks if this relation's type is "many-to-many".
	 */
	isManyToMany: boolean = false;

	/**
	 * Checks if this relation's type is "many-to-many", and is owner side of the relationship.
	 * Owner side means this side of relation has a join table.
	 */
	isManyToManyOwner: boolean = false;

	/**
	 * Checks if this relation's type is "many-to-many", and is NOT owner side of the relationship.
	 * Not owner side means this side of relation does not have a join table.
	 */
	isManyToManyNotOwner: boolean = false;

	/**
	 * Gets the property path of the inverse side of the relation.
	 */
	inverseSidePropertyPath: string;

	/**
	 * Inverse side of the relation set by user.
	 *
	 * Inverse side set in the relation can be either string - property name of the column on inverse side,
	 * either can be a function that accepts a map of properties with the object and returns one of them.
	 * Second approach is used to achieve type-safety.
	 */
	givenInverseSidePropertyFactory: PropertyTypeFactory<any>;

	/**
	 * Gets the relation metadata of the inverse side of this relation.
	 */
	inverseRelation?: RelationMetadata;

	/**
	 * Join table name.
	 */
	joinTableName: string;

	/**
	 * Foreign keys created for this relation.
	 */
	foreignKeys: ForeignKeyMetadata[] = [];

	/**
	 * Join table columns.
	 * Join columns can be obtained only from owner side of the relation.
	 * From non-owner side of the relation join columns will be empty.
	 * If this relation is a many-to-one/one-to-one then it takes join columns from the current entity.
	 * If this relation is many-to-many then it takes all owner join columns from the junction entity.
	 */
	joinColumns: ColumnMetadata[] = [];

	/**
	 * Inverse join table columns.
	 * Inverse join columns are supported only for many-to-many relations
	 * and can be obtained only from owner side of the relation.
	 * From non-owner side of the relation join columns will be undefined.
	 */
	inverseJoinColumns: ColumnMetadata[] = [];

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

	constructor(options: {
		entityMetadata: EntityMetadata;
		embeddedMetadata?: EmbeddedMetadata;
		args: RelationMetadataArgs;
	}) {
		this.entityMetadata = options.entityMetadata;
		this.embeddedMetadata = options.embeddedMetadata!;
		const args = options.args;
		this.target = args.target;
		this.propertyName = args.propertyName;
		this.relationType = args.relationType;

		if (args.inverseSideProperty) this.givenInverseSidePropertyFactory = args.inverseSideProperty;

		this.isLazy = args.isLazy || false;
		// this.isCascadeInsert = args.options.cascade === true || (args.options.cascade instanceof Array && args.options.cascade.indexOf("insert") !== -1);
		// this.isCascadeUpdate = args.options.cascade === true || (args.options.cascade instanceof Array && args.options.cascade.indexOf("update") !== -1);
		// this.isCascadeRemove = args.options.cascade === true || (args.options.cascade instanceof Array && args.options.cascade.indexOf("remove") !== -1);
		// this.isCascadeSoftRemove = args.options.cascade === true || (args.options.cascade instanceof Array && args.options.cascade.indexOf("soft-remove") !== -1);
		// this.isCascadeRecover = args.options.cascade === true || (args.options.cascade instanceof Array && args.options.cascade.indexOf("recover") !== -1);
		this.isCascadeInsert =
			args.options.cascade === true ||
			(Array.isArray(args.options.cascade) && args.options.cascade.indexOf('insert') !== -1);
		this.isCascadeUpdate =
			args.options.cascade === true ||
			(Array.isArray(args.options.cascade) && args.options.cascade.indexOf('update') !== -1);
		this.isCascadeRemove =
			args.options.cascade === true ||
			(Array.isArray(args.options.cascade) && args.options.cascade.indexOf('remove') !== -1);
		this.isCascadeSoftRemove =
			args.options.cascade === true ||
			(Array.isArray(args.options.cascade) && args.options.cascade.indexOf('soft-remove') !== -1);
		this.isCascadeRecover =
			args.options.cascade === true ||
			(Array.isArray(args.options.cascade) && args.options.cascade.indexOf('recover') !== -1);
		// this.isPrimary = args.options.primary || false;
		this.isNullable = args.options.nullable === false || this.isPrimary ? false : true;
		this.onDelete = args.options.onDelete;
		this.onUpdate = args.options.onUpdate;
		this.deferrable = args.options.deferrable;
		this.createForeignKeyConstraints =
			args.options.createForeignKeyConstraints === false ? false : true;
		this.isEager = args.options.eager || false;
		this.persistenceEnabled = args.options.persistence === false ? false : true;
		this.orphanedRowAction = args.options.orphanedRowAction || 'nullify';
		this.isTreeParent = args.isTreeParent || false;
		this.isTreeChildren = args.isTreeChildren || false;

		if (typeof args.type === 'function') {
			this.type = typeof args.type === 'function' ? (args.type as () => any)() : args.type;
		} else if (InstanceChecker.isEntitySchema(args.type)) {
			this.type = args.type.options.name;
		} else if (ObjectUtils.isObject(args.type) && typeof (args.type as any).name === 'string') {
			this.type = (args.type as any).name;
		} else {
			this.type = args.type as string | Function;
		}

		this.isOneToOne = this.relationType === 'one-to-one';
		this.isOneToMany = this.relationType === 'one-to-many';
		this.isManyToOne = this.relationType === 'many-to-one';
		this.isManyToMany = this.relationType === 'many-to-many';
		this.isOneToOneNotOwner = this.isOneToOne ? true : false;
		this.isManyToManyNotOwner = this.isManyToMany ? true : false;
	}

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

	/**
	 * Creates join column ids map from the given related entity ids array.
	 */
	getRelationIdMap(entity: ObjectLiteral): ObjectLiteral | undefined {
		const joinColumns = this.isOwning ? this.joinColumns : this.inverseRelation!.joinColumns;
		const referencedColumns = joinColumns.map((joinColumn) => joinColumn.referencedColumn!);
		// console.log("entity", entity);
		// console.log("referencedColumns", referencedColumns);
		return EntityMetadata.getValueMap(entity, referencedColumns);
	}

	/**
	 * Ensures that given object is an entity id map.
	 * If given id is an object then it means its already id map.
	 * If given id isn't an object then it means its a value of the id column
	 * and it creates a new id map with this value and name of the primary column.
	 */
	ensureRelationIdMap(id: any): ObjectLiteral {
		if (ObjectUtils.isObject(id)) return id;

		const joinColumns = this.isOwning ? this.joinColumns : this.inverseRelation!.joinColumns;
		const referencedColumns = joinColumns.map((joinColumn) => joinColumn.referencedColumn!);

		if (referencedColumns.length > 1)
			throw new TypeORMError(
				`Cannot create relation id map for a single value because relation contains multiple referenced columns.`,
			);

		return referencedColumns[0].createValueMap(id);
	}

	/**
	 * Extracts column value from the given entity.
	 * If column is in embedded (or recursive embedded) it extracts its value from there.
	 */
	getEntityValue(
		entity: ObjectLiteral,
		getLazyRelationsPromiseValue: boolean = false,
	): any | undefined {
		if (entity === null || entity === undefined) return undefined;
		// extract column value from embeddeds of entity if column is in embedded
		if (this.embeddedMetadata) {
			// example: post[data][information][counters].id where "data", "information" and "counters" are embeddeds
			// we need to get value of "id" column from the post real entity object

			// first step - we extract all parent properties of the entity relative to this column, e.g. [data, information, counters]
			const propertyNames = [...this.embeddedMetadata.parentPropertyNames];

			// next we need to access post[data][information][counters][this.propertyName] to get column value from the counters
			// this recursive function takes array of generated property names and gets the post[data][information][counters] embed
			const extractEmbeddedColumnValue = (propertyNames: string[], value: ObjectLiteral): any => {
				const propertyName = propertyNames.shift();
				if (propertyName) {
					if (value[propertyName]) {
						return extractEmbeddedColumnValue(propertyNames, value[propertyName]);
					}
					return undefined;
				}
				return value;
			};

			// once we get nested embed object we get its column, e.g. post[data][information][counters][this.propertyName]
			const embeddedObject = extractEmbeddedColumnValue(propertyNames, entity);

			if (this.isLazy) {
				if (embeddedObject['__' + this.propertyName + '__'] !== undefined)
					return embeddedObject['__' + this.propertyName + '__'];

				if (getLazyRelationsPromiseValue === true) return embeddedObject[this.propertyName];

				return undefined;
			}
			return embeddedObject
				? embeddedObject[this.isLazy ? '__' + this.propertyName + '__' : this.propertyName]
				: undefined;
		} else {
			// no embeds - no problems. Simply return column name by property name of the entity
			if (this.isLazy) {
				if (entity['__' + this.propertyName + '__'] !== undefined)
					return entity['__' + this.propertyName + '__'];

				if (getLazyRelationsPromiseValue === true) return entity[this.propertyName];

				return undefined;
			}
			return entity[this.propertyName];
		}
	}

	/**
	 * Sets given entity's relation's value.
	 * Using of this method helps to set entity relation's value of the lazy and non-lazy relations.
	 *
	 * If merge is set to true, it merges given value into currently
	 */
	setEntityValue(entity: ObjectLiteral, value: any): void {
		const propertyName = this.isLazy ? '__' + this.propertyName + '__' : this.propertyName;

		if (this.embeddedMetadata) {
			// first step - we extract all parent properties of the entity relative to this column, e.g. [data, information, counters]
			const extractEmbeddedColumnValue = (
				embeddedMetadatas: EmbeddedMetadata[],
				map: ObjectLiteral,
			): any => {
				// if (!object[embeddedMetadata.propertyName])
				//     object[embeddedMetadata.propertyName] = embeddedMetadata.create();

				const embeddedMetadata = embeddedMetadatas.shift();
				if (embeddedMetadata) {
					if (!map[embeddedMetadata.propertyName])
						map[embeddedMetadata.propertyName] = embeddedMetadata.create();

					extractEmbeddedColumnValue(embeddedMetadatas, map[embeddedMetadata.propertyName]);
					return map;
				}
				map[propertyName] = value;
				return map;
			};
			return extractEmbeddedColumnValue([...this.embeddedMetadata.embeddedMetadataTree], entity);
		} else {
			entity[propertyName] = value;
		}
	}

	/**
	 * Creates entity id map from the given entity ids array.
	 */
	createValueMap(value: any) {
		// extract column value from embeds of entity if column is in embedded
		if (this.embeddedMetadata) {
			// example: post[data][information][counters].id where "data", "information" and "counters" are embeddeds
			// we need to get value of "id" column from the post real entity object and return it in a
			// { data: { information: { counters: { id: ... } } } } format

			// first step - we extract all parent properties of the entity relative to this column, e.g. [data, information, counters]
			const propertyNames = [...this.embeddedMetadata.parentPropertyNames];

			// now need to access post[data][information][counters] to get column value from the counters
			// and on each step we need to create complex literal object, e.g. first { data },
			// then { data: { information } }, then { data: { information: { counters } } },
			// then { data: { information: { counters: [this.propertyName]: entity[data][information][counters][this.propertyName] } } }
			// this recursive function helps doing that
			const extractEmbeddedColumnValue = (propertyNames: string[], map: ObjectLiteral): any => {
				const propertyName = propertyNames.shift();
				if (propertyName) {
					map[propertyName] = {};
					extractEmbeddedColumnValue(propertyNames, map[propertyName]);
					return map;
				}
				map[this.propertyName] = value;
				return map;
			};
			return extractEmbeddedColumnValue(propertyNames, {});
		} else {
			// no embeds - no problems. Simply return column property name and its value of the entity
			return { [this.propertyName]: value };
		}
	}

	// ---------------------------------------------------------------------
	// Builder Methods
	// ---------------------------------------------------------------------

	/**
	 * Builds some depend relation metadata properties.
	 * This builder method should be used only after embedded metadata tree was build.
	 */
	build() {
		this.propertyPath = this.buildPropertyPath();
	}

	/**
	 * Registers given foreign keys in the relation.
	 * This builder method should be used to register foreign key in the relation.
	 */
	registerForeignKeys(...foreignKeys: ForeignKeyMetadata[]) {
		this.foreignKeys.push(...foreignKeys);
	}

	/**
	 * Registers given join columns in the relation.
	 * This builder method should be used to register join column in the relation.
	 */
	registerJoinColumns(
		joinColumns: ColumnMetadata[] = [],
		inverseJoinColumns: ColumnMetadata[] = [],
	) {
		this.joinColumns = joinColumns;
		this.inverseJoinColumns = inverseJoinColumns;
		this.isOwning =
			this.isManyToOne || ((this.isManyToMany || this.isOneToOne) && this.joinColumns.length > 0);
		this.isOneToOneOwner = this.isOneToOne && this.isOwning;
		this.isOneToOneNotOwner = this.isOneToOne && !this.isOwning;
		this.isManyToManyOwner = this.isManyToMany && this.isOwning;
		this.isManyToManyNotOwner = this.isManyToMany && !this.isOwning;
		this.isWithJoinColumn = this.isManyToOne || this.isOneToOneOwner;
	}

	/**
	 * Registers a given junction entity metadata.
	 * This builder method can be called after junction entity metadata for the many-to-many relation was created.
	 */
	registerJunctionEntityMetadata(junctionEntityMetadata: EntityMetadata) {
		this.junctionEntityMetadata = junctionEntityMetadata;
		this.joinTableName = junctionEntityMetadata.tableName;
		if (this.inverseRelation) {
			this.inverseRelation.junctionEntityMetadata = junctionEntityMetadata;
			this.joinTableName = junctionEntityMetadata.tableName;
		}
	}

	/**
	 * Builds inverse side property path based on given inverse side property factory.
	 * This builder method should be used only after properties map of the inverse entity metadata was build.
	 */
	buildInverseSidePropertyPath(): string {
		if (this.givenInverseSidePropertyFactory) {
			const ownerEntityPropertiesMap = this.inverseEntityMetadata.propertiesMap;
			if (typeof this.givenInverseSidePropertyFactory === 'function')
				return this.givenInverseSidePropertyFactory(ownerEntityPropertiesMap);

			if (typeof this.givenInverseSidePropertyFactory === 'string')
				return this.givenInverseSidePropertyFactory;
		} else if (this.isTreeParent && this.entityMetadata.treeChildrenRelation) {
			return this.entityMetadata.treeChildrenRelation.propertyName;
		} else if (this.isTreeChildren && this.entityMetadata.treeParentRelation) {
			return this.entityMetadata.treeParentRelation.propertyName;
		}

		return '';
	}

	/**
	 * Builds relation's property path based on its embedded tree.
	 */
	buildPropertyPath(): string {
		if (!this.embeddedMetadata || !this.embeddedMetadata.parentPropertyNames.length)
			return this.propertyName;

		return this.embeddedMetadata.parentPropertyNames.join('.') + '.' + this.propertyName;
	}
}