import {
    isObservable,
    isArrayLike,
    has as mobxHas,
    get as mobxGet,
    set as mobxSet,
    remove as mobxDelete,
    keys as mobxKeys,
} from 'mobx';

import { PathTo, Path, PathValue } from './deep_common';

/** @deprecated */
export const deep_get = <T, L extends Path<T, L>>(o: T, p: L, defaultValue: PathValue<T, L> = null): PathValue<T, L> => {
    let obj: any = o;
    for (let key of p as Array<any>) {
        if (obj == null) return defaultValue;
        // if (obj == null || (isObservable(obj) && !mobxHas(obj, key)) || !(key in obj)) return defaultValue;
        if (isObservable(obj) && mobxHas(obj, key)) {
            obj = mobxGet(obj, key);
        } else if (key in obj) {
            obj = obj[key];
        } else {
            return defaultValue;
        }
    }
    return obj;
}

/** @deprecated */
export const deep_set = <T, L extends Path<T, L>>(o: T, p: L, v: PathValue<T, L>) => {
    const lastPath = (p as Array<any>).pop();
    const obj = deep_get(o, p);
    if (isObservable(obj)) {
        mobxSet(obj, lastPath, v)
    } else {
        obj[lastPath] = v;
    }
}

/** @deprecated */
export function deep_sync(target: any, obj: any, exclude: string[] = []) {
    const exclusions = exclude.map((exc) => exc.split('.'));
    const shouldExclude = (key: string) => !!exclusions.find((exc) => exc.length == 1 && exc[0] == key)
    const subExclusions = (key: string) => exclusions.filter((exc) => exc[0] == key).map((exc) => exc.slice(1).join('.'));

    const isMobx = isObservable(target);
    const set = isMobx ? mobxSet : (o, k, v) => o[k] = v;
    for (let [k, v] of Object.entries(obj)) {
        if (shouldExclude(k)) continue;
        if (typeof v != typeof target[k] || typeof v != 'object')
            set(target, k, v);
        else if (isArrayLike(v) && isArrayLike(target[k])) {
            deep_sync(target[k], v, subExclusions(k));
        } else if (v == null || target[k] == null)
            set(target, k, v);
        else if ((Object.getPrototypeOf(v) != Object.prototype) || (Object.getPrototypeOf(target[k]) != Object.prototype))
            set(target, k, v);
        else {
            deep_sync(target[k], v, subExclusions(k));
        }
    }
    const keys = isMobx ? mobxKeys(target) : Object.keys(target);
    for (let k of keys) {
        if (shouldExclude(k as string)) continue;
        if (!(k in obj)) {
            if (isMobx) mobxDelete(target, k);
            else if (isArrayLike(target)) target.splice(k as any, 1);
            else delete target[k]
        }
    }
}

/** @deprecated */
export const deep_call = <T, F extends (() => any), L extends PathTo<T, F, L>>(o: T, p: L, params: Parameters<F>, defaultValue: ReturnType<F> = null): ReturnType<F> => {
    if (o == null) return defaultValue;
    let ctx: any = o;
    let f: F = ctx;
    for (let key of p as Array<any>) {
        ctx = f;
        f = ctx[key];
        if (f == null) return defaultValue;
    }
    return f.apply(ctx, params);
}