/* eslint-disable no-param-reassign */
import { IFieldUI, IRule } from '@wowpic/xform-types';
import expr from 'expression-eval';

export const clone = (values: any): any => {
    if (Array.isArray(values)) {
        return values.map((item) => clone(item));
    }
    if (values && typeof values === 'object') {
        if (values.constructor !== Object) {
            return values;
        }
        const result: any = {};
        for (const key in values) {
            if (Object.hasOwnProperty.call(values, key)) {
                result[key] = clone(values[key]);
            }
        }
        return result;
    }
    return values;
};

export const isEqual = (a: any, b: any): boolean => {
    if (a && b) {
        return JSON.stringify(a) === JSON.stringify(b);
    }
    return a === b;
};

export const strEval = (str: string, obj: any): string => {
    let replacedStr = str;
    const match = str.match(/\$\{.*?\}/g);
    if (match && match.length > 0) {
        match.forEach((matchStr) => {
            const variableStr = matchStr.substring(2, matchStr.length - 1);
            const replacement = `${expr.compile(variableStr)(obj) || ''}`;
            replacedStr = replacedStr.replace(
                new RegExp(`\\$\\{${variableStr}\\}`, 'g'),
                replacement
            );
        });
    }
    return replacedStr;
};

export const groupBy = (arr: any[], key: string, defaultValue: string): any => {
    return arr.reduce((result, item) => {
        const value = item[key] || defaultValue;
        result[value] = [...(result[value] || []), item];
        return result;
    }, {});
};

export const filterByKeys = (obj: any, keys: string[]): any => {
    return keys.reduce((result: any, key: any) => {
        result[key] = obj[key];
        return result;
    }, {});
};

export const isUndefined = (value: any) => {
    return typeof value === 'undefined';
};

export const isNull = (value: any) => {
    return Object.prototype.toString.call(value).slice(8, -1) === 'Null';
};

export const computeRules2UI = ({
    rules: aRules = [],
    ui: aUI = {}
}: {
    rules: IRule[];
    ui: IFieldUI;
}): IFieldUI => {
    let ui: IFieldUI = clone(aUI) || {};
    const rules: IRule[] = clone(aRules) || [];
    const hasRequiredRules = rules?.some((rule: IRule) => rule.required);

    if (hasRequiredRules && !ui.required) {
        ui = Object.assign(ui, { required: true });
    }

    return ui;
};

export const computeUI2Rules = ({
    rules: aRules = [],
    ui: aUI = {}
}: {
    rules: IRule[];
    ui: IFieldUI;
}): IRule[] => {
    const ui: IFieldUI = clone(aUI) || {};
    const rules: IRule[] = clone(aRules) || [];
    const hasRequiredRules = rules?.some((rule: IRule) => rule.required);

    if (!hasRequiredRules && ui.required) {
        rules?.push({
            required: true,
            message: '该参数必填'
        });
    }

    return rules;
};