import { QueryBuilder } from './QueryBuilder';
import { RelationUpdater } from './RelationUpdater';
import { RelationRemover } from './RelationRemover';
import { TypeORMError } from '../error';
import { ObjectUtils } from '../util/ObjectUtils';
import { ObjectLiteral } from '../common/ObjectLiteral';

/**
 * Allows to work with entity relations and perform specific operations with those relations.
 *
 * todo: add transactions everywhere
 */
export class RelationQueryBuilder<Entity extends ObjectLiteral> extends QueryBuilder<Entity> {
	readonly '@instanceof' = Symbol.for('RelationQueryBuilder');

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

	/**
	 * Gets generated SQL query without parameters being replaced.
	 */
	getQuery(): string {
		return '';
	}

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

	/**
	 * Sets entity (target) which relations will be updated.
	 */
	of(entity: any | any[]): this {
		this.expressionMap.of = entity;
		return this;
	}

	/**
	 * Sets entity relation's value.
	 * Value can be entity, entity id or entity id map (if entity has composite ids).
	 * Works only for many-to-one and one-to-one relations.
	 * For many-to-many and one-to-many relations use #add and #remove methods instead.
	 */
	async set(value: any): Promise<void> {
		const relation = this.expressionMap.relationMetadata;

		if (!this.expressionMap.of)
			// todo: move this check before relation query builder creation?
			throw new TypeORMError(
				`Entity whose relation needs to be set is not set. Use .of method to define whose relation you want to set.`,
			);

		if (relation.isManyToMany || relation.isOneToMany)
			throw new TypeORMError(
				`Set operation is only supported for many-to-one and one-to-one relations. ` +
					`However given "${relation.propertyPath}" has ${relation.relationType} relation. ` +
					`Use .add() method instead.`,
			);

		// if there are multiple join columns then user must send id map as "value" argument. check if he really did it
		if (
			relation.joinColumns &&
			relation.joinColumns.length > 1 &&
			(!ObjectUtils.isObject(value) || Object.keys(value).length < relation.joinColumns.length)
		)
			throw new TypeORMError(
				`Value to be set into the relation must be a map of relation ids, for example: .set({ firstName: "...", lastName: "..." })`,
			);

		const updater = new RelationUpdater(this, this.expressionMap);
		return updater.update(value);
	}

	/**
	 * Adds (binds) given value to entity relation.
	 * Value can be entity, entity id or entity id map (if entity has composite ids).
	 * Value also can be array of entities, array of entity ids or array of entity id maps (if entity has composite ids).
	 * Works only for many-to-many and one-to-many relations.
	 * For many-to-one and one-to-one use #set method instead.
	 */
	async add(value: any | any[]): Promise<void> {
		if (Array.isArray(value) && value.length === 0) return;

		const relation = this.expressionMap.relationMetadata;

		if (!this.expressionMap.of)
			// todo: move this check before relation query builder creation?
			throw new TypeORMError(
				`Entity whose relation needs to be set is not set. Use .of method to define whose relation you want to set.`,
			);

		if (relation.isManyToOne || relation.isOneToOne)
			throw new TypeORMError(
				`Add operation is only supported for many-to-many and one-to-many relations. ` +
					`However given "${relation.propertyPath}" has ${relation.relationType} relation. ` +
					`Use .set() method instead.`,
			);

		// if there are multiple join columns then user must send id map as "value" argument. check if he really did it
		if (
			relation.joinColumns &&
			relation.joinColumns.length > 1 &&
			(!ObjectUtils.isObject(value) || Object.keys(value).length < relation.joinColumns.length)
		)
			throw new TypeORMError(
				`Value to be set into the relation must be a map of relation ids, for example: .set({ firstName: "...", lastName: "..." })`,
			);

		const updater = new RelationUpdater(this, this.expressionMap);
		return updater.update(value);
	}

	/**
	 * Removes (unbinds) given value from entity relation.
	 * Value can be entity, entity id or entity id map (if entity has composite ids).
	 * Value also can be array of entities, array of entity ids or array of entity id maps (if entity has composite ids).
	 * Works only for many-to-many and one-to-many relations.
	 * For many-to-one and one-to-one use #set method instead.
	 */
	async remove(value: any | any[]): Promise<void> {
		if (Array.isArray(value) && value.length === 0) return;

		const relation = this.expressionMap.relationMetadata;

		if (!this.expressionMap.of)
			// todo: move this check before relation query builder creation?
			throw new TypeORMError(
				`Entity whose relation needs to be set is not set. Use .of method to define whose relation you want to set.`,
			);

		if (relation.isManyToOne || relation.isOneToOne)
			throw new TypeORMError(
				`Add operation is only supported for many-to-many and one-to-many relations. ` +
					`However given "${relation.propertyPath}" has ${relation.relationType} relation. ` +
					`Use .set(null) method instead.`,
			);

		const remover = new RelationRemover(this, this.expressionMap);
		return remover.remove(value);
	}

	/**
	 * Adds (binds) and removes (unbinds) given values to/from entity relation.
	 * Value can be entity, entity id or entity id map (if entity has composite ids).
	 * Value also can be array of entities, array of entity ids or array of entity id maps (if entity has composite ids).
	 * Works only for many-to-many and one-to-many relations.
	 * For many-to-one and one-to-one use #set method instead.
	 */
	async addAndRemove(added: any | any[], removed: any | any[]): Promise<void> {
		await this.remove(removed);
		await this.add(added);
	}

	/**
     * Gets entity's relation id.
    async getId(): Promise<any> {

    }*/

	/**
     * Gets entity's relation ids.
    async getIds(): Promise<any[]> {
        return [];
    }*/

	/**
	 * Loads a single entity (relational) from the relation.
	 * You can also provide id of relational entity to filter by.
	 */
	async loadOne<T = any>(): Promise<T | undefined> {
		return this.loadMany<T>().then((results) => results[0]);
	}

	/**
	 * Loads many entities (relational) from the relation.
	 * You can also provide ids of relational entities to filter by.
	 */
	async loadMany<T = any>(): Promise<T[]> {
		let of = this.expressionMap.of;
		if (!ObjectUtils.isObject(of)) {
			const metadata = this.expressionMap.mainAlias!.metadata;
			if (metadata.hasMultiplePrimaryKeys)
				throw new TypeORMError(
					`Cannot load entity because only one primary key was specified, however entity contains multiple primary keys`,
				);

			of = metadata.primaryColumns[0].createValueMap(of);
		}

		return this.connection.relationLoader.load(
			this.expressionMap.relationMetadata,
			of,
			this.queryRunner,
		);
	}
}