import { EntityMetadata } from "../metadata/EntityMetadata"
import { DataSource } from "../data-source/DataSource"
import { RelationMetadata } from "../metadata/RelationMetadata"
import { QueryBuilderUtils } from "./QueryBuilderUtils"
import { QueryExpressionMap } from "./QueryExpressionMap"
import { Alias } from "./Alias"
import { ObjectUtils } from "../util/ObjectUtils"
import { TypeORMError } from "../error"
import { DriverUtils } from "../driver/DriverUtils"

/**
 * Stores all join attributes which will be used to build a JOIN query.
 */
export class JoinAttribute {
    // -------------------------------------------------------------------------
    // Public Properties
    // -------------------------------------------------------------------------

    /**
     * Join direction.
     */
    direction: "LEFT" | "INNER"

    /**
     * Alias of the joined (destination) table.
     */
    alias: Alias

    /**
     * Joined table, entity target, or relation in "post.category" format.
     */
    entityOrProperty: Function | string

    /**
     * Extra condition applied to "ON" section of join.
     */
    condition?: string

    /**
     * Property + alias of the object where to joined data should be mapped.
     */
    mapToProperty?: string

    /**
     * Indicates if user maps one or many objects from the join.
     */
    isMappingMany?: boolean

    /**
     * Useful when the joined expression is a custom query to support mapping.
     */
    mapAsEntity?: Function | string

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

    constructor(
        private connection: DataSource,
        private queryExpressionMap: QueryExpressionMap,
        joinAttribute?: JoinAttribute,
    ) {
        if (joinAttribute) {
            ObjectUtils.assign(this, joinAttribute)
        }
    }

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

    get isMany(): boolean {
        if (this.isMappingMany !== undefined) return this.isMappingMany

        if (this.relation)
            return this.relation.isManyToMany || this.relation.isOneToMany

        return false
    }

    isSelectedCache: boolean
    isSelectedEvaluated: boolean = false
    /**
     * Indicates if this join is selected.
     */
    get isSelected(): boolean {
        if (!this.isSelectedEvaluated) {
            let getValue = () => {
                for (const select of this.queryExpressionMap.selects) {
                    if (select.selection === this.alias.name) return true

                    if (
                        this.metadata &&
                        !!this.metadata.columns.find(
                            (column) =>
                                select.selection ===
                                this.alias.name + "." + column.propertyPath,
                        )
                    )
                        return true
                }

                return false
            }
            this.isSelectedCache = getValue()
            this.isSelectedEvaluated = true
        }
        return this.isSelectedCache
    }

    /**
     * Name of the table which we should join.
     */
    get tablePath(): string {
        return this.metadata
            ? this.metadata.tablePath
            : (this.entityOrProperty as string)
    }

    /**
     * Alias of the parent of this join.
     * For example, if we join ("post.category", "categoryAlias") then "post" is a parent alias.
     * This value is extracted from entityOrProperty value.
     * This is available when join was made using "post.category" syntax.
     */
    get parentAlias(): string | undefined {
        if (!QueryBuilderUtils.isAliasProperty(this.entityOrProperty))
            return undefined

        return this.entityOrProperty.substr(
            0,
            this.entityOrProperty.indexOf("."),
        )
    }

    /**
     * Relation property name of the parent.
     * This is used to understand what is joined.
     * For example, if we join ("post.category", "categoryAlias") then "category" is a relation property.
     * This value is extracted from entityOrProperty value.
     * This is available when join was made using "post.category" syntax.
     */
    get relationPropertyPath(): string | undefined {
        if (!QueryBuilderUtils.isAliasProperty(this.entityOrProperty))
            return undefined

        return this.entityOrProperty.substr(
            this.entityOrProperty.indexOf(".") + 1,
        )
    }

    relationCache: RelationMetadata | undefined
    relationEvaluated: boolean = false
    /**
     * Relation of the parent.
     * This is used to understand what is joined.
     * This is available when join was made using "post.category" syntax.
     * Relation can be undefined if entityOrProperty is regular entity or custom table.
     */
    get relation(): RelationMetadata | undefined {
        if (!this.relationEvaluated) {
            let getValue = () => {
                if (!QueryBuilderUtils.isAliasProperty(this.entityOrProperty))
                    return undefined

                const relationOwnerSelection =
                    this.queryExpressionMap.findAliasByName(this.parentAlias!)
                let relation =
                    relationOwnerSelection.metadata.findRelationWithPropertyPath(
                        this.relationPropertyPath!,
                    )

                if (relation) {
                    return relation
                }

                if (relationOwnerSelection.metadata.parentEntityMetadata) {
                    relation =
                        relationOwnerSelection.metadata.parentEntityMetadata.findRelationWithPropertyPath(
                            this.relationPropertyPath!,
                        )
                    if (relation) {
                        return relation
                    }
                }

                throw new TypeORMError(
                    `Relation with property path ${this.relationPropertyPath} in entity was not found.`,
                )
            }
            this.relationCache = getValue.bind(this)()
            this.relationEvaluated = true
        }
        return this.relationCache
    }

    /**
     * Metadata of the joined entity.
     * If table without entity was joined, then it will return undefined.
     */
    get metadata(): EntityMetadata | undefined {
        // entityOrProperty is relation, e.g. "post.category"
        if (this.relation) return this.relation.inverseEntityMetadata

        // entityOrProperty is Entity class
        if (this.connection.hasMetadata(this.entityOrProperty))
            return this.connection.getMetadata(this.entityOrProperty)

        // Overriden mapping entity provided for leftJoinAndMapOne with custom query builder
        if (this.mapAsEntity && this.connection.hasMetadata(this.mapAsEntity)) {
            return this.connection.getMetadata(this.mapAsEntity)
        }

        return undefined

        /*if (typeof this.entityOrProperty === "string") { // entityOrProperty is a custom table

            // first try to find entity with such name, this is needed when entity does not have a target class,
            // and its target is a string name (scenario when plain old javascript is used or entity schema is loaded from files)
            const metadata = this.connection.entityMetadatas.find(metadata => metadata.name === this.entityOrProperty);
            if (metadata)
                return metadata;

            // check if we have entity with such table name, and use its metadata if found
            return this.connection.entityMetadatas.find(metadata => metadata.tableName === this.entityOrProperty);
        }*/
    }

    /**
     * Generates alias of junction table, whose ids we get.
     */
    get junctionAlias(): string {
        if (!this.relation) {
            throw new TypeORMError(
                `Cannot get junction table for join without relation.`,
            )
        }
        if (typeof this.entityOrProperty !== "string") {
            throw new TypeORMError(`Junction property is not defined.`)
        }

        const aliasProperty = this.entityOrProperty.substr(
            0,
            this.entityOrProperty.indexOf("."),
        )

        if (this.relation.isOwning) {
            return DriverUtils.buildAlias(
                this.connection.driver,
                undefined,
                aliasProperty,
                this.alias.name,
            )
        } else {
            return DriverUtils.buildAlias(
                this.connection.driver,
                undefined,
                this.alias.name,
                aliasProperty,
            )
        }
    }

    get mapToPropertyParentAlias(): string | undefined {
        if (!this.mapToProperty) return undefined

        return this.mapToProperty!.split(".")[0]
    }

    get mapToPropertyPropertyName(): string | undefined {
        if (!this.mapToProperty) return undefined

        return this.mapToProperty!.split(".")[1]
    }
}