import { ObjectLiteral } from "../common/ObjectLiteral"
import { FindOperatorType } from "./FindOperatorType"
import { InstanceChecker } from "../util/InstanceChecker"
import { ValueTransformer } from "../decorator/options/ValueTransformer"
import { ApplyValueTransformers } from "../util/ApplyValueTransformers"

type SqlGeneratorType = (aliasPath: string) => string

/**
 * Find Operator used in Find Conditions.
 */
export class FindOperator<T> {
    readonly "@instanceof" = Symbol.for("FindOperator")

    // -------------------------------------------------------------------------
    // Private Properties
    // -------------------------------------------------------------------------

    /**
     * Operator type.
     */
    private _type: FindOperatorType

    /**
     * Parameter value.
     */
    private _value: T | FindOperator<T>

    /**
     * ObjectLiteral parameters.
     */
    private _objectLiteralParameters: ObjectLiteral | undefined

    /**
     * Indicates if parameter is used or not for this operator.
     */
    private _useParameter: boolean

    /**
     * Indicates if multiple parameters must be used for this operator.
     */
    private _multipleParameters: boolean

    /**
     * SQL generator
     */
    private _getSql: SqlGeneratorType | undefined

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

    constructor(
        type: FindOperatorType,
        value: T | FindOperator<T>,
        useParameter: boolean = true,
        multipleParameters: boolean = false,
        getSql?: SqlGeneratorType,
        objectLiteralParameters?: ObjectLiteral,
    ) {
        this._type = type
        this._value = value
        this._useParameter = useParameter
        this._multipleParameters = multipleParameters
        this._getSql = getSql
        this._objectLiteralParameters = objectLiteralParameters
    }

    // -------------------------------------------------------------------------
    // Accessors
    // -------------------------------------------------------------------------

    /**
     * Indicates if parameter is used or not for this operator.
     * Extracts final value if value is another find operator.
     */
    get useParameter(): boolean {
        if (InstanceChecker.isFindOperator(this._value))
            return this._value.useParameter

        return this._useParameter
    }

    /**
     * Indicates if multiple parameters must be used for this operator.
     * Extracts final value if value is another find operator.
     */
    get multipleParameters(): boolean {
        if (InstanceChecker.isFindOperator(this._value))
            return this._value.multipleParameters

        return this._multipleParameters
    }

    /**
     * Gets the Type of this FindOperator
     */
    get type(): FindOperatorType {
        return this._type
    }

    /**
     * Gets the final value needs to be used as parameter value.
     */
    get value(): T {
        if (InstanceChecker.isFindOperator(this._value))
            return this._value.value

        return this._value
    }

    /**
     * Gets ObjectLiteral parameters.
     */
    get objectLiteralParameters(): ObjectLiteral | undefined {
        if (InstanceChecker.isFindOperator(this._value))
            return this._value.objectLiteralParameters

        return this._objectLiteralParameters
    }

    /**
     * Gets the child FindOperator if it exists
     */
    get child(): FindOperator<T> | undefined {
        if (InstanceChecker.isFindOperator(this._value)) return this._value

        return undefined
    }

    /**
     * Gets the SQL generator
     */
    get getSql(): SqlGeneratorType | undefined {
        if (InstanceChecker.isFindOperator(this._value))
            return this._value.getSql

        return this._getSql
    }

    transformValue(transformer: ValueTransformer | ValueTransformer[]) {
        if (this._value instanceof FindOperator) {
            this._value.transformValue(transformer)
        } else {
            this._value =
                Array.isArray(this._value) && this._multipleParameters
                    ? this._value.map(
                          (v: any) =>
                              transformer &&
                              ApplyValueTransformers.transformTo(
                                  transformer,
                                  v,
                              ),
                      )
                    : ApplyValueTransformers.transformTo(
                          transformer,
                          this._value,
                      )
        }
    }
}