/* eslint-disable @typescript-eslint/no-explicit-any */
import {
    observable as mobxObservable,
    computed as mobxComputed,
    IObservableValue as mobxIObservableValue,
    isComputed as mobxIsComputed,
    IComputedValueOptions as mobxIComputedValueOptions,
    isBoxedObservable as mobxIsObservableValue,
    isObservableArray as mobxIsObservableArray,
    isObservableMap as mobxIsObservableMap,
    isObservableSet as mobxIsObservableSet,
    runInAction as mobxRunInAction,
    reaction as mobxReaction,
    CreateObservableOptions as mobxCreateObservableOptions,
    IObservableSetInitialValues as mobxIObservableSetInitialValues,
    IReactionPublic as mobxIReactionPublic,
    IMapEntries as mobxIMapEntries
} from "mobx";

import { observable as jpfObservable, element } from "jpf";

function setDefaultOptions<TOptions>(target: TOptions, source: TOptions): TOptions {
    if (source) {
        target = target || {} as TOptions;
        Object.keys(source).forEach((key) => {
            if (!target.hasOwnProperty(key)) {
                target[key] = source[key];
            }
        });
    }

    return target;
}

export function runInAction<T>(fn: () => T): T {
    return mobxRunInAction<T>(fn);
}

export type IComputed<TValue> = jpfObservable.IComputed<TValue>;
export type ISubcription = jpfObservable.ISubscription;
export type IObservableArray<TItem = any, TSetter = TItem[]> = jpfObservable.IObservableArray<TItem, TSetter>;
export type IObservableMap<TKey = unknown, TItem = unknown> = jpfObservable.IObservableMap<TKey, TItem>;
export type IObservableSet<TItem = unknown> = jpfObservable.IObservableSet<TItem>;
export type IObservableValue<TValue, TSetter = TValue> = jpfObservable.IObservableValue<TValue, TSetter>;
export type ISubscribable<TValue> = jpfObservable.ISubscribable<TValue>;

export function unwrap<TValue>(value: TValue | jpfObservable.ISubscribable<TValue>): TValue {
    if (mobxIsComputed(value) || mobxIsObservableValue(value)) {
        return (value as mobxIObservableValue<TValue>).get();
    }

    if (mobxIsObservableArray(value)) {
        return value.slice() as unknown as TValue;
    }

    if (mobxIsObservableMap(value)) {
        return new Map(value) as unknown as TValue;
    }

    if (mobxIsObservableSet(value)) {
        return new Set(value) as unknown as TValue;
    }

    return value as TValue;
}

export function isComputed<TValue>(value: unknown): value is jpfObservable.IComputed<TValue> {
    return mobxIsComputed(value);
}

export function isObservableValue(value): value is jpfObservable.IObservableValue {
    return mobxIsObservableValue(value);
}

export function isObservableArray(value): value is jpfObservable.IObservableArray {
    return mobxIsObservableArray(value);
}

export function isObservableMap<TKey, TItem>(value): value is jpfObservable.IObservableMap<TKey, TItem> {
    return mobxIsObservableMap(value);
}

export function isObservableSet<TItem>(value): value is jpfObservable.IObservableSet<TItem> {
    return mobxIsObservableSet(value);
}

export function isSubscribable<TValue>(value: unknown): value is ISubscribable<TValue> {
    return isComputed(value) || isObservableValue(value) || isObservableArray(value) || isObservableMap(value) || isObservableSet(value);
}

export function computed<TComputed>(func: () => TComputed, options?: mobxIComputedValueOptions<TComputed>): jpfObservable.IComputed<TComputed> {
    const computed = mobxComputed(func, options);
    const iComputed = computed as unknown as jpfObservable.IComputed<TComputed>;

    iComputed.subscribe = (effect: (arg: TComputed, prev: TComputed, r: mobxIReactionPublic) => void) => {
        element.subscriptionCounterIncrement();

        const disposer = mobxReaction(
            () => {
                return unwrap(iComputed);
            },
            (value: TComputed, prev: TComputed, r) => {
                effect(value, prev, r);
            }
        );
        return {
            dispose: () => {
                disposer();
            }
        }
    }

    return iComputed;
}

export function observableValue<TValue, TSetter = TValue>(value?: TValue | null, setter?: (value: TSetter, observableValue: jpfObservable.IObservableValue<TValue, TSetter>) => void, options?: mobxCreateObservableOptions): jpfObservable.IObservableValue<TValue, TSetter> {
    //Make sure deep is set to false if not provided
    setDefaultOptions(options, { deep: false });

    const observableValue = mobxObservable.box(value || null, options) as unknown as jpfObservable.IObservableValue<TValue, TSetter>;

    observableValue.setValue = (newValue: TSetter) => {
        if (newValue === undefined) {
            newValue = null;
        }
        if (setter) {
            setter(newValue, observableValue);
        } else {
            observableValue["set"](newValue);
        }
    };

    observableValue.setValueInAction = (newValue: TSetter | null) => {
        runInAction(() => {
            observableValue.setValue(newValue);
        });
    };

    observableValue.setInternal = (value: TValue | null) => {
        if (value === undefined) {
            value = null;
        }
        observableValue["set"](value);
    };

    observableValue.setInternalInAction = (value: TValue | null) => {
        runInAction(() => {
            observableValue.setInternal(value);
        });
    };

    observableValue.subscribe = (effect: (arg: TValue, prev: TValue, r: mobxIReactionPublic) => void) => {
        element.subscriptionCounterIncrement();

        const disposer = mobxReaction(
            () => {
                return unwrap(observableValue);
            },
            (value: TValue, prev: TValue, r) => {
                effect(value, prev, r);
            }
        );
        return {
            dispose: () => {
                disposer();
            }
        }
    };

    return observableValue;
}

export function observableArray<TItem = unknown, TSetter = Array<TItem>>(initialValues?: Array<TItem> | null, setter?: (value: TSetter, observableArray: jpfObservable.IObservableArray<TItem, TSetter>) => void, options?: mobxCreateObservableOptions): jpfObservable.IObservableArray<TItem, TSetter> {
    //Make sure deep is set to false if not provided
    options = setDefaultOptions(options, { deep: false });

    const observableArray = mobxObservable.array(initialValues || null, options) as unknown as jpfObservable.IObservableArray<TItem, TSetter>;

    observableArray.setItems = (newValue: TSetter) => {
        if (newValue === undefined) {
            newValue = [] as unknown as TSetter;
        }
        if (setter) {
            setter(newValue, observableArray);
        } else {
            observableArray["replace"](newValue);
        }
    };

    observableArray.setItemsInAction = (newValue: TSetter) => {
        runInAction(() => {
            observableArray.setItems(newValue);
        });
    };

    observableArray.setInternal = observableArray["replace"];

    observableArray.setInternalInAction = (items: Array<TItem>) => {
        runInAction(() => {
            observableArray.setInternal(items);
        });
    };

    observableArray.get = observableArray["toJSON"];

    observableArray.subscribe = (effect: (arg: Array<TItem>, prev: Array<TItem>, r: mobxIReactionPublic) => void) => {

        element.subscriptionCounterIncrement();

        const disposer = mobxReaction(
            () => {
                return unwrap(observableArray);
            },
            (value: Array<TItem>, prev: Array<TItem>, r) => {
                effect(value, prev, r);
            }
        );

        return{
            dispose: () => {
                disposer();
            }
        }
    };

    return observableArray;
}

export function observableMap<TKey = unknown, TItem = unknown>(initialValues?: mobxIMapEntries<TKey, TItem>, options?: mobxCreateObservableOptions): jpfObservable.IObservableMap<TKey, TItem> {
    //Add a deep property if the property does not already exist
    const defaultOptions = { deep: false };
    options = { ...defaultOptions, ...options };

    return mobxObservable.map<TKey, TItem>(initialValues, options);
}

export function observableSet<TItem = unknown>(initialValues?: mobxIObservableSetInitialValues<TItem>, options?: mobxCreateObservableOptions): jpfObservable.IObservableSet<TItem> {
    //Add a deep property if the property does not already exist
    const defaultOptions = { deep: false };
    options = { ...defaultOptions, ...options };

    return mobxObservable.set<TItem>(initialValues, options);
}




const observable = jpfObservable.observable;

//Overwrite jpf observable implementation with mobx implementation
observable.unwrap = unwrap;
observable.isComputed = isComputed;
observable.isObservableValue = isObservableValue;
observable.isObservableArray = isObservableArray;
observable.isObservableMap = isObservableMap;
observable.isObservableSet = isObservableSet;
observable.computed = computed
observable.observableValue = observableValue;
observable.observableArray = observableArray;
observable.observableMap = observableMap;
observable.observableSet = observableSet;