import { MetaContext, MetaObject } from '../../MetaContext';
import { $CLONE, $Clone, Clone } from './$clone';

export const $ASSIGN = '$assign';

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

export type $Assign<T> = { [$ASSIGN]: Assign<T> };

export const withAssign = <TMetaContextBase extends new (...args: any[]) => MetaContext & $Clone<any>>(MetaContextBase: TMetaContextBase) => class extends MetaContextBase {
    [$ASSIGN]<T>(lhs: T, rhs: T) {
        const $rhs = this.resolveValue(rhs);
        if (this.resolveValue(lhs) !== $rhs)
            return $rhs[$CLONE](rhs, this) as T;
        return $rhs[$ASSIGN](lhs, rhs, this) as T;
    }
};

export type GenericAssign<T, U> = (lhs: T, rhs: T, assignfn: Assign<U>, clonefn: Clone<U>, context: any) => T;

export function deepAssign<T, U = T>(genericAssign: GenericAssign<T, U>) {
    return function $assign(this: MetaObject, lhs: T, rhs: T, context: MetaContext & $Assign<U> & $Clone<U>) {
        const assignfn = context[$ASSIGN];
        const clonefn = context[$CLONE];
        return (this[$ASSIGN] = function $assign(lhs: T, rhs: T, context: MetaContext) {
            return genericAssign(lhs, rhs, assignfn, clonefn, context);
        })(lhs, rhs, context);
    };
}

export function primitiveAssign<T>(_: T, rhs: T) {
    return rhs;
}