import { $CONSTRUCTOR, MetaContext, MetaObject } from '../../MetaContext';
import { $CONSTRUCT } from './$construct';

export const $RESTORE = '$restore';

export type Restore<T> = (value: T, state: any) => T;

export type $Restore<T> = { [$RESTORE]: Restore<T> };

export const $CREATE = '$create';

export type Create<T> = (state: any) => T;

export type $Create<T> = { [$CREATE]: Create<T> };

export const withRestore = <TMetaContextBase extends new (...args: any[]) => MetaContext>(MetaContextBase: TMetaContextBase) => class extends MetaContextBase {
    getState(state: any) {
        return [this.getValue(state), state] as [MetaObject, any];
    }

    resolveState(state: any) {
        const ret = this.getState(state);
        if (ret[0] === undefined)
            throw new TypeError(`MetaContext.resolveState(): ${state} is not found`);
        return ret;
    }

    [$RESTORE]<T>(value: T, state: any) {
        const [stateMetaObject, resolvedState] = this.resolveState(state);
        if (stateMetaObject !== this.getValue(value))
            return stateMetaObject[$CREATE](resolvedState, this) as T;
        return stateMetaObject[$RESTORE](value, resolvedState, this) as T;
    }

    [$CREATE]<T>(state: any) {
        const [stateMetaObject, resolvedState] = this.resolveState(state);
        return stateMetaObject[$CREATE](resolvedState, this) as T;
    }
};

export type GenericRestore<T, U> = (value: T, state: any, restorefn: Restore<U>, createfn: Create<U>, context: any) => T;

export function primitiveRestore<T>(_: T, state: any) {
    return primitiveCreate(state) as T;
}

export function primitiveWrapperRestore<T>(this: MetaObject, _: T, state: any) {
    return primitiveWrapperCreate.call(this, state) as T;
}

export function deepRestore<T, U = T>(genericRestore: GenericRestore<T, U>) {
    return function $restore(this: MetaObject, value: T, state: any, context: MetaContext & $Restore<U> & $Create<U>) {
        const restorefn = context[$RESTORE];
        const createfn = context[$CREATE];
        return (this[$RESTORE] = function $restore(value: T, state: any, context: MetaContext) {
            return genericRestore(value, state, restorefn, createfn, context);
        })(value, state, context);
    };
}

export function genericCreate<T>(this: MetaObject, state: any, context: any, ...args: any[]) {
    return this[$RESTORE](this[$CONSTRUCT](...args), state, context) as T;
}

export function primitiveCreate<T>(state: any) {
    return state as T;
}

export function primitiveWrapperCreate<T>(this: MetaObject, state: any) {
    return new this[$CONSTRUCTOR]!(state) as T;
}