import { MetaContext, MetaObject } from '../../MetaContext';

export const $EQUAL = '$equal';

export type Equal<T> = (lhs: T, rhs: T) => boolean;

export type $Equal<T> = { [$EQUAL]: Equal<T> };

export const withEqual = <TMetaContextBase extends new (...args: any[]) => MetaContext>(MetaContextBase: TMetaContextBase) => class extends MetaContextBase {
    [$EQUAL]<T>(lhs: T, rhs: T) {
        const $lhs = this.resolveValue(lhs);
        if ($lhs !== this.resolveValue(rhs))
            return false;
        return $lhs[$EQUAL](lhs, rhs, this) as boolean;
    }
};

export type GenericEqual<T, U = T> = (lhs: T, rhs: T, equalfn: Equal<U>, context: any) => boolean;

export function deepEqual<T, U = T>(genericEqual: GenericEqual<T, U>) {
    return function $equal(this: MetaObject, lhs: T, rhs: T, context: MetaContext & $Equal<U>) {
        const equalfn = context[$EQUAL];
        return (this[$EQUAL] = function $equal(lhs: T, rhs: T, context: MetaContext) {
            return genericEqual(lhs, rhs, equalfn, context);
        })(lhs, rhs, context);
    };
}

export function primitiveEqual<T>(lhs: T, rhs: T) {
    return lhs === rhs;
}

export function primitiveWrapperEqual<T>(lhs: T, rhs: T) {
    return lhs.valueOf() === rhs.valueOf();
}