import { QueryBuilder } from "./QueryBuilder"
import { ObjectLiteral } from "../common/ObjectLiteral"
import { QueryExpressionMap } from "./QueryExpressionMap"
import { ObjectUtils } from "../util/ObjectUtils"

/**
 * Allows to work with entity relations and perform specific operations with those relations.
 *
 * todo: add transactions everywhere
 */
export class RelationRemover {
    // -------------------------------------------------------------------------
    // Constructor
    // -------------------------------------------------------------------------

    constructor(
        protected queryBuilder: QueryBuilder<any>,
        protected expressionMap: QueryExpressionMap,
    ) {}

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

    /**
     * Performs remove operation on a relation.
     */
    async remove(value: any | any[]): Promise<void> {
        const relation = this.expressionMap.relationMetadata

        if (relation.isOneToMany) {
            // if (this.expressionMap.of instanceof Array)
            //     throw new TypeORMError(`You cannot update relations of multiple entities with the same related object. Provide a single entity into .of method.`);

            // DELETE FROM post WHERE post.categoryId = of AND post.id = id
            const ofs = Array.isArray(this.expressionMap.of)
                ? this.expressionMap.of
                : [this.expressionMap.of]
            const values = Array.isArray(value) ? value : [value]

            const updateSet: ObjectLiteral = {}
            relation.inverseRelation!.joinColumns.forEach((column) => {
                updateSet[column.propertyName] = null
            })

            const parameters: ObjectLiteral = {}
            const conditions: string[] = []
            ofs.forEach((of, ofIndex) => {
                conditions.push(
                    ...values.map((value, valueIndex) => {
                        return [
                            ...relation.inverseRelation!.joinColumns.map(
                                (column, columnIndex) => {
                                    const parameterName =
                                        "joinColumn_" +
                                        ofIndex +
                                        "_" +
                                        valueIndex +
                                        "_" +
                                        columnIndex
                                    parameters[parameterName] =
                                        ObjectUtils.isObject(of)
                                            ? column.referencedColumn!.getEntityValue(
                                                  of,
                                              )
                                            : of
                                    return `${column.propertyPath} = :${parameterName}`
                                },
                            ),
                            ...relation.inverseRelation!.entityMetadata.primaryColumns.map(
                                (column, columnIndex) => {
                                    const parameterName =
                                        "primaryColumn_" +
                                        valueIndex +
                                        "_" +
                                        valueIndex +
                                        "_" +
                                        columnIndex
                                    parameters[parameterName] =
                                        ObjectUtils.isObject(value)
                                            ? column.getEntityValue(value)
                                            : value
                                    return `${column.propertyPath} = :${parameterName}`
                                },
                            ),
                        ].join(" AND ")
                    }),
                )
            })
            const condition = conditions
                .map((str) => "(" + str + ")")
                .join(" OR ")
            if (!condition) return

            await this.queryBuilder
                .createQueryBuilder()
                .update(relation.inverseEntityMetadata.target)
                .set(updateSet)
                .where(condition)
                .setParameters(parameters)
                .execute()
        } else {
            // many to many

            const junctionMetadata = relation.junctionEntityMetadata!
            const ofs = Array.isArray(this.expressionMap.of)
                ? this.expressionMap.of
                : [this.expressionMap.of]
            const values = Array.isArray(value) ? value : [value]
            const firstColumnValues = relation.isManyToManyOwner ? ofs : values
            const secondColumnValues = relation.isManyToManyOwner ? values : ofs

            const parameters: ObjectLiteral = {}
            const conditions: string[] = []
            firstColumnValues.forEach((firstColumnVal, firstColumnValIndex) => {
                conditions.push(
                    ...secondColumnValues.map(
                        (secondColumnVal, secondColumnValIndex) => {
                            return [
                                ...junctionMetadata.ownerColumns.map(
                                    (column, columnIndex) => {
                                        const parameterName =
                                            "firstValue_" +
                                            firstColumnValIndex +
                                            "_" +
                                            secondColumnValIndex +
                                            "_" +
                                            columnIndex
                                        parameters[parameterName] =
                                            ObjectUtils.isObject(firstColumnVal)
                                                ? column.referencedColumn!.getEntityValue(
                                                      firstColumnVal,
                                                  )
                                                : firstColumnVal
                                        return `${column.databaseName} = :${parameterName}`
                                    },
                                ),
                                ...junctionMetadata.inverseColumns.map(
                                    (column, columnIndex) => {
                                        const parameterName =
                                            "secondValue_" +
                                            firstColumnValIndex +
                                            "_" +
                                            secondColumnValIndex +
                                            "_" +
                                            columnIndex
                                        parameters[parameterName] =
                                            ObjectUtils.isObject(
                                                secondColumnVal,
                                            )
                                                ? column.referencedColumn!.getEntityValue(
                                                      secondColumnVal,
                                                  )
                                                : secondColumnVal
                                        return `${column.databaseName} = :${parameterName}`
                                    },
                                ),
                            ].join(" AND ")
                        },
                    ),
                )
            })
            const condition = conditions
                .map((str) => "(" + str + ")")
                .join(" OR ")

            await this.queryBuilder
                .createQueryBuilder()
                .delete()
                .from(junctionMetadata.tableName)
                .where(condition)
                .setParameters(parameters)
                .execute()
        }
    }
}