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

export const $COMPARE = '$compare';

export type Compare<T> = (lhs: T, rhs: T) => number;

export type $Compare<T> = { [$COMPARE]: Compare<T> };

export const withCompare = <TMetaContextBase extends new (...args: any[]) => MetaContext>(MetaContextBase: TMetaContextBase) => class extends MetaContextBase {
    [$COMPARE]<T>(lhs: T, rhs: T) {
        const $lhs = this.resolveValue(lhs);
        const $rhs = this.resolveValue(rhs);
        if ($lhs !== $rhs)
            throw new TypeError(`MetaContext.${$COMPARE}(): type missmatch '${$lhs[$NAME]}' !== '${$rhs[$NAME]}'`);
        return $lhs[$COMPARE](lhs, rhs, this) as number;
    }
};

export type GenericCompare<T, U = T> = (lhs: T, rhs: T, comparefn: Compare<U>, context: any) => number;

export function deepCompare<T, U = T>(genericCompare: GenericCompare<T, U>) {
    return function $compare(this: MetaObject, lhs: T, rhs: T, context: MetaContext & $Compare<U>) {
        const comparefn = context[$COMPARE];
        return (this[$COMPARE] = function $compare(lhs: T, rhs: T, context: MetaContext) {
            return genericCompare(lhs, rhs, comparefn, context);
        })(lhs, rhs, context);
    };
}

export function primitiveWrapperCompare<T>(lhs: T, rhs: T, context: MetaContext & $Compare<any>) {
    return context[$COMPARE](lhs.valueOf(), rhs.valueOf());
}