// 判断是Android 或 iOS
const platform = (function checkPlatForm() {
    let u = navigator.userAgent;
    let isAndroid = u.indexOf('Android') > -1 || u.indexOf('Adr') > -1; //android终端
    let isiOS = !!u.match(/\(i[^;]+;( U;)? CPU.+Mac OS X/); //ios终端
    if (isAndroid) {
        return 'android';
    }
    if (isiOS) {
        return 'ios';
    }
    return 'PC';
})();
const presetValueMap = {
    userId: 'userId',
    userName: 'userName',
    departmentId: 'departmentId',
    departmentName: 'departmentName',
}
const getLocalData = async ({getLocalDataMethod}) => {
    let localData = {};
    if (platform === 'PC') {
        if (typeof getLocalDataMethod === 'function') {
            localData = getLocalDataMethod();
        } else {
            alert('没有找到获取本地数据的方法getLocalDataMethod')
        }
    } else {
        if (window.mtBridge) {
            if (typeof getLocalDataMethod === 'string') {
                await window.mtBridge.$sendMessage(getLocalDataMethod, (data) => {
                    localData = data;
                })
            } else {
                alert('没有找到获取本地数据的方法getLocalDataMethod')
            }
        } else {
            alert('没有找到native交互桥mtBridge')
        }
    }
    return localData;
}
/**
 * 获取附加属性得到最终值状态
 * @param list                  全部数据
 * @param changedKey            修改的键
 * @param changedValue          修改的值
 * @param originValue           修改的原始值
 * @param initType              初始化类型：'add'|'edit'
 * @param getLocalDataMethod    获取本地数据的方法名
 * @returns {*}                 根据组件行为，添加附加属性后返回
 */
const getFormData = async ({list, changedKey, changedValue, originValue, initType, getLocalDataMethod = 'getClientUserInfo'}) => {
    //没有修改键时默认走初始化
    if (!changedKey) {
        return await initData({list, initType, getLocalDataMethod});
    }
    return changeData({list, changedKey, changedValue, originValue});
}
/**
 * 初始化
 * @param list                  原始数据
 * @param initType              初始化类型：'add'|'edit'
 * @param getLocalDataMethod    获取本地数据的方法名
 * @returns {*}                 根据子组件行为，添加附加属性后返回
 */
const initData = async ({list, initType, getLocalDataMethod}) => {
    for await (let item of list) {
        item = await initPresetValue({item, initType, getLocalDataMethod});
        item = initEvents({item, list});
        item = initFlag({item});
    }
    return list;
}
/**
 * 根据默认值处理数据属性
 * @param item                      原始数据
 * @param initType                  原始数据
 * @param getLocalDataMethod        获取本地数据的方法名
 * @returns {*}                     添加附加属性后返回
 */
const initPresetValue = async ({item, initType, getLocalDataMethod}) => {
    const {presetValue} = item.columnAttrObj || {};
    if (presetValue) {
        const {type, value} = presetValue;
        if (initType === 'add') {
            switch (type) {
                case '1':
                    item.value = value;
                    break;
                case '2':
                    let localData = await getLocalData({getLocalDataMethod});
                    let textKey = presetValueMap[value[0].text];
                    let valueKey = presetValueMap[value[0].value];
                    item.value = [{text: localData[textKey], value: localData[valueKey]}];
                    break;
                default:
                    break;
            }
        }
    }
    return item;
}
/**
 * 根据events处理数据属性
 * @param item                      原始数据
 * @param list                      原始数据
 * @returns {*}                     添加附加属性后返回
 */
const initEvents = ({item, list}) => {
    const {events} = item.columnAttrObj || {};
    events && events.map(e => {
        const {behaviors} = e;
        behaviors && behaviors.map(behavior => {
            const {behaviorValue} = behavior;
            switch (behaviorValue) {
                case 'changDynamicParams':
                    item = changDynamicParams({item, list, behavior});
                    break;
                default:
                    break;
            }
        })
    })
    return item;
}
/**
 * 根据flag处理数据属性
 * @param item                      原始数据
 * @returns {*}      添加附加属性后返回
 */
const initFlag = ({item}) => {
    item.columnAttrObj = item.columnAttrObj || {};
    //只读属性
    if (item.readOnlyFlag) {
        item.columnAttrObj.disabled = true;
    }
    return item;
}
/**
 * 受控子组件更新
 * @param item          子组件数据
 * @param list          全部数据
 * @param behavior      子组件行为
 * @returns {*}         添加附加属性后返回子组件
 */
const changDynamicParams = ({item, list, behavior}) => {
    const {paramsJsonCols, paramsJsonColsLogic, paramsJsonRequired, fieldValueName} = behavior;
    item.columnAttrObj.type = fieldValueName || item.columnAttrObj.type;
    if (paramsJsonRequired) {
        let sources = paramsJsonCols.split(',');
        let len = 0;
        sources.map(s => {
            let sourceArr = list.filter(temp => temp.columnName === s);
            let source = sourceArr[0];
            if (source && source.value && source.value[0] && source.value[0].value) {
                item.columnAttrObj.paramsJson = item.columnAttrObj.paramsJson || {};
                item.columnAttrObj.paramsJson[s] = source.value[0].value;
                len++;
            }
        })
        //根据条件判断子组件是否可编辑
        switch (paramsJsonColsLogic) {
            case 'and':
                item.columnAttrObj.disabled = sources.length !== len;
                break;
            case 'or':
                item.columnAttrObj.disabled = len === 0;
                break;
            default:
                break;
        }
    }
    return item;
}
/**
 * 控制组件赋值（父组件调接口）更新
 * @param item          父组件数据
 * @param list          全部数据
 * @param behavior      父组件行为
 * @param key           修改的键
 * @param originValue   修改的原始值
 * @returns {*}         添加附加属性后返回父组件
 */
const changDynamicValue = ({item, list, behavior, key, originValue}) => {
    const {targets} = behavior;
    if (targets) {
        let targetsArr = targets.split(',');
        targetsArr && targetsArr.map(t => {
            let targetArr = list.filter(temp => temp.columnName === t);
            let target = targetArr[0];
            if (target) {
                const {extraData} = Array.isArray(originValue) ? originValue[0] || {} : originValue || {};
                if (!extraData) {
                    target.value = [];
                } else {
                    target.value = Array.isArray(extraData[t]) ? extraData[t] : [extraData[t]];
                }
            }
        })
    }
    return item;
}
/**
 * 控制组件赋值（直接值）更新
 * @param item          父组件数据
 * @param list          全部数据
 * @param behavior      父组件行为
 * @returns {*}         添加附加属性后返回父组件
 */
const changParams = ({item, list, behavior}) => {
    const {targetText, targetValue, targets} = behavior;
    if (targets) {
        let targetsArr = targets.split(',');
        targetsArr && targetsArr.map(t => {
            let targetArr = list.filter(temp => temp.columnName === t);
            let target = targetArr[0];
            if (target) {
                target.value = [{text: targetText, value: targetValue}]
            }
        })
    }
    return item;
}
/**
 * 获取附加属性得到最终值状态
 * @param list              全部数据
 * @param changedKey        修改的键
 * @param changedValue      修改的值
 * @param originValue       修改的原始值
 * @returns {*}             根据组件行为，添加附加属性后返回
 */
const changeData = ({list, changedKey, changedValue, originValue}) => {
    let key = changedKey;
    let value = changedValue;
    return list.map(item => {
        if (item.columnName === key) {
            item.value = value;
            if (item.columnAttrObj) {
                const {events} = item.columnAttrObj;
                events && events.map(e => {
                    const {behaviors} = e;
                    behaviors && behaviors.map(behavior => {
                        const {behaviorValue} = behavior;
                        switch (behaviorValue) {
                            case 'changDynamicValue':
                                item = changDynamicValue({item, list, behavior, key, originValue});
                                break;
                            case 'changParams':
                                item = changParams({item, list, behavior});
                                break;
                            default:
                                break;
                        }
                    })
                })
            }
        } else {
            if (item.columnAttrObj) {
                const {events} = item.columnAttrObj;
                events && events.map(e => {
                    const {behaviors} = e;
                    behaviors && behaviors.map(behavior => {
                        const {behaviorValue} = behavior;
                        if (behaviorValue === 'changDynamicParams') {
                            item = changDynamicParams({item, list, behavior});
                        }
                    })
                })
            }
        }
        return item;
    })
}

//-------------------------------------table----------------------------------------
/**
 * 控制组件赋值（父组件调接口）更新
 * @param behavior          父组件行为
 * @param key               修改的键
 * @param originValue       修改的原始值
 * @returns {[]}            返回改变的数据列表
 */
const changTableDynamicValue = ({behavior, key, originValue}) => {
    const {targets} = behavior;
    let result = [];
    if (targets) {
        let targetsArr = targets.split(',');
        targetsArr && targetsArr.map(t => {
            const {extraData} = Array.isArray(originValue) ? originValue[0] || {} : originValue || {};
            if (!extraData) {
                result.push({
                    columnCode: t,
                    cellValueList: []
                })
            } else {
                result.push({
                    columnCode: t,
                    cellValueList: Array.isArray(extraData[t]) ? extraData[t] : [extraData[t]]
                })
            }
        })
    }
    return result;
}
/**
 * 控制组件赋值（直接值）更新
 * @param behavior      父组件行为
 * @returns {[]}        返回改变的数据列表
 */
const changTableParams = ({behavior}) => {
    const {targetText, targetValue, targets} = behavior;
    let result = [];
    if (targets) {
        let targetsArr = targets.split(',');
        targetsArr && targetsArr.map(t => {
            result.push({
                columnCode: t,
                cellValueList: [{text: targetText, value: targetValue}]
            })
        })
    }
    return result;
}
/**
 * 获取附加属性得到最终值状态
 * @param item              修改的数据属性
 * @param changedKey        修改的键
 * @param changedValue      修改的值
 * @param originValue       修改的原始值
 * @returns {[]}            返回改变的数据列表
 */
const changeTableData = ({item, changedKey, changedValue, originValue}) => {
    let result = [];
    if (item.columnAttrObj) {
        const {events} = item.columnAttrObj;
        events && events.map(e => {
            const {behaviors} = e;
            behaviors && behaviors.map(behavior => {
                const {behaviorValue} = behavior;
                switch (behaviorValue) {
                    case 'changDynamicValue':
                        result = result.concat(changTableDynamicValue({behavior, changedKey, originValue}));
                        break;
                    case 'changParams':
                        result = result.concat(changTableParams({behavior}));
                        break;
                    default:
                        break;
                }
            })
        })
    }
    return result;
}
export default {
    getFormData, changeTableData
}
