import { message } from 'antd';
import _ from 'lodash-es';

// hot-formula-parser 处理公式
import { Parser } from 'hot-formula-parser';
import { FIELD_TYPE_PROPS, formatEnum } from '../constant';
const parser = new Parser();

// 数值类型字段 不可选函数
const unNumSelectArr = [
  'CONCAT',
  'NOW',
  'TODAY',
  'CONCATENATE',
  'REPLACE',
  'MID',
  'LEFT',
  'RIGHT',
  'TRIM',
  'CLEAN',
  'REPT',
  'LOWER',
  'UPPER',
  'FIND',
  'SPLIT',
  'IF',
  'OR',
  'AND',
  'NOT',
  'FALSE',
  'TRUE',
];

const mathCodeReg =
  /^(((\$\{((?![}+]).)+(\}))|(-?\d+(\.\d+)?))[+\-*/])+((\$\{((?![}+]).)+(\}))|(-?\d+(\.\d+)?))$/;
const boolCodeReg =
  /^(((\$\{((?![}+]).)+(\}))|(-?\d+(\.\d+)?))(==|===|!=|!==|=|<|>|<=|>=|&&|\|\|))+((\$\{((?![}+]).)+(\}))|(-?\d+(\.\d+)?))$/;
const singleField = /^\$\{((?![}+]).)+(\})$/; // 匹配单字段的正则

// 根据 fieldGroupType 赋 虚拟值
const getPseudoStr = (type: string) => {
  let _data: string | number = '测试';
  switch (type) {
    case FIELD_TYPE_PROPS.NUM:
    case FIELD_TYPE_PROPS.DOUBLE:
    case FIELD_TYPE_PROPS.INTEGER:
    case FIELD_TYPE_PROPS.DECIMAL:
    case FIELD_TYPE_PROPS.PERCENT:
    case FIELD_TYPE_PROPS.FORMULA:
      _data = 100;
      break;
    case FIELD_TYPE_PROPS.DATE:
    case FIELD_TYPE_PROPS.YEAR:
    case FIELD_TYPE_PROPS.YEAR_MONTH:
    case FIELD_TYPE_PROPS.YEAR_DATE:
    case FIELD_TYPE_PROPS.YEAR_MIN:
    case FIELD_TYPE_PROPS.YEAR_SEC:
      _data = '2022-12-23 11:22:33';
      break;
    case FIELD_TYPE_PROPS.TIME:
    case FIELD_TYPE_PROPS.HOUR_MIN:
    case FIELD_TYPE_PROPS.HOUR_SEC:
      _data = '11:22:33';
      break;
  }
  return _data;
};
// 获取公式函数数组
const getFunList = (_data: any, type?: string) => {
  let _target: any = [];
  (_data || []).forEach((_v: any) => {
    if (_v?.children && Array.isArray(_v?.children) && !!_v?.children.length) {
      _target = _target.concat(getFunList(_v?.children, _v.key));
    } else {
      if (type !== 'normal') {
        _target.push({
          type: type || '',
          value: _v.title,
        });
      }
    }
  });
  return _target;
};

// 公式 格式化
const getFormulaObj = (val: string, treeList: any[]) => {
  let _res: string = val;
  let _pseudoData: string = val;

  const _formula: any = [];
  if (val.indexOf('${') === -1) {
    return {
      codeList: [],
      formulaStr: val,
    };
  } else {
    const _val = val.replaceAll('${', ' ' + '${');
    const _matchs: string[] = [];
    const _strs: string[] = [];
    const _pseudoDataStrs: any[] = [];
    // @ts-ignore
    _val.replace(/(\$\{[^\s]*\})/g, function (match, p1) {
      _matchs.push(match);
      const _filter = treeList.filter(
        (item: { key: string }) => item.key === p1,
      );
      if (!_.isEmpty(_filter)) {
        _formula.push(_filter[0]);
        _strs.push(_filter[0]?.titleStr || '');
        _pseudoDataStrs.push(getPseudoStr(_filter[0]?.fieldGroupType || ''));
      }
    });
    _strs.forEach((str, index) => {
      _res = _res.replace(_matchs[index], str);
    });
    _pseudoDataStrs.forEach((str, index) => {
      _pseudoData = _pseudoData.replace(
        _matchs[index],
        str && typeof str === 'number' ? str.toString() : "'" + str + "'",
      );
    });

    return {
      codeList: _formula,
      formulaStr: _res,
      pseudoData: _pseudoData,
    };
  }
};
// 重置函数公式字符串 与hot-formula-parser 内部函数匹配
const replaceValue = (_v: string) => {
  let _currentVal = _v;
  _currentVal = _currentVal
    .replace(/CONCAT/g, 'CONCATENATE')
    .replace(/NETWORKDAY/g, 'NETWORKDAYS');
  _currentVal = _currentVal
    .replace(/CONCATENATEENATE/g, 'CONCATENATE')
    .replace(/NETWORKDAYSS/g, 'NETWORKDAYS');
  return _currentVal.replace(/,(?=\))/g, '');
};

/*
 * 检验函数公式校验合法性
 * _val: 当前值
 * _obj: 公式格式化后的值
 * funArr: 公式函数数组
 */
const checkFormulaValue = (val: string) => {
  let _flag = false;
  const res = parser.parse(replaceValue(val));
  //for sass：追加 DATEDELTA 报错：'#NAME?'兼容
  if (res.error) {
    if (res.error === '#NAME?' && val.indexOf('DATEDELTA') === 0) {
      _flag = true;
    } else if (res.error === '#ERROR!') {
      try {
        eval(replaceValue(val));
        _flag = true;
      } catch (e) {
        console.log(e);
        _flag = false;
        message.warning('函数公式有语法或参数类型错误');
      }
    } else {
      _flag = false;
      message.warning('函数公式有语法或参数类型错误');
    }
  } else {
    _flag = true;
  }
  return _flag;
};
/*
 * 多字段 单独校验
 * _val: 当前值
 * _obj: 公式格式化后的值
 * funArr: 公式函数数组
 */
const checkFormulaList = (_val: string, _obj: any, funArr: any[]) => {
  let _flag = false;
  if (_obj.codeList.length > 1) {
    const _keyList = _obj.codeList.map((item: any) => {
      return item.key;
    });
    if (_keyList.join('') === _val && _val.indexOf(',') === -1) {
      _flag = false;
      message.warning('多个字段请用英文逗号分隔');
    } else {
      const _filterArr = funArr.filter(
        (_v: any) => _val.indexOf(_v.value) > -1,
      );
      if (_filterArr && !!_filterArr?.length) {
        _flag = checkFormulaValue(_obj.pseudoData);
      } else {
        _flag = false;
        message.warning('多个字段请使用函数运算');
      }
    }
  } else {
    _flag = checkFormulaValue(_obj.pseudoData);
  }
  return _flag;
};

/*
 * 默认值 当前字段 可匹配类型 判断 用于获取符合条件的字段 返回 true、false
 * a: 当前数据字段类型 b: 关联字段类型 c: 当前关联记录字段关联表单id
 */
export const getFiledSelectedFlag = (_item: any, b: string, c?: string) => {
  const allowWidget: Record<string, string[]> = {
    qxInput: [
      'qxInput',
      'qxMobile',
      'qxEmail',
      'qxNumber',
      'qxMoney',
      'qxPercent',
      'qxDatetime',
    ],
    qxNumber: ['qxNumber', 'qxMoney', 'qxPercent'],
    qxMoney: ['qxNumber', 'qxMoney', 'qxPercent'],
    qxPercent: ['qxNumber', 'qxMoney', 'qxPercent'],
    qxRichText: [
      'qxInput',
      'qxMobile',
      'qxEmail',
      'qxNumber',
      'qxMoney',
      'qxPercent',
      'qxDatetime',
    ],
  };
  const formatEnumList = Object.keys(formatEnum).map((key) => key);

  const _widget = _item?.extract?.widget || _item?.widget || '';
  const _relId = _item?.extract?.relId || _item?.relId || '';

  let _flag = false;
  if (allowWidget[b] && allowWidget[b]?.indexOf(_widget) > -1) {
    _flag = true;
  } else if (b === 'relSelector' && _widget === b && c === _relId) {
    _flag = true;
  } else if (b !== 'relSelector' && _widget === b) {
    _flag = true;
  } else if (
    ['qxNumber', 'qxMoney', 'qxPercent'].indexOf(b) > -1 &&
    _widget === 'qxFormula' &&
    _item?.extract?.fieldType === 'FORMULA'
  ) {
    _flag = true;
  } else if (
    'qxDatetime' === b &&
    _widget === 'qxFormula' &&
    formatEnumList.includes(_item?.extract?.fieldType || '')
  ) {
    // 日期格式 匹配 公式 日期增减类型
    _flag = true;
  } else {
    _flag = false;
  }
  return _flag;
};

/*
 *  校验 函数公式
 *  targetValue: 当前值
 *  treeList: 可选字段list
 *  defaultSetting: 默认值 过滤字段 传参
 */
export const checkFormulaFn = (
  targetValue: string,
  treeList: any[],
  defaultSetting?: any,
  funObjects?: any,
) => {
  let _flag = false;
  const _targetValue = targetValue.trim();
  if (!_targetValue) {
    message.warning('内容不能为空！');
    return false;
  }
  if (_.isEmpty(defaultSetting)) {
    return true;
  }
  const formulaObj = getFormulaObj(_targetValue, treeList); // 公式内容 字段处理
  const functionArr = getFunList(funObjects); // 函数list
  functionArr.push(
    ...[
      {
        type: 'text',
        value: 'CONCAT',
      },
      {
        type: 'date',
        value: 'NETWORKDAY',
      },
    ],
  );

  if (!formulaObj.codeList?.length) {
    // 校验 没有字段时
    _flag = checkFormulaValue(_targetValue);
  } else if (
    formulaObj.codeList?.length === 1 &&
    formulaObj.codeList[0].key === _targetValue
  ) {
    // 校验 有且只有一个字段 选择的字段类型匹配
    const _typeList = ['NUM', 'DATE'];
    if (
      defaultSetting?.fieldGroupType &&
      _typeList.includes(defaultSetting.fieldGroupType)
    ) {
      if (
        _typeList.includes(formulaObj.codeList[0].fieldGroupType) &&
        defaultSetting.fieldGroupType === formulaObj.codeList[0].fieldGroupType
      ) {
        _flag = true;
      } else {
        _flag = false;
        message.warning(
          `${formulaObj.codeList[0].titleStr}和${defaultSetting.fieldName}不匹配！`,
        );
      }
    } else {
      if (
        getFiledSelectedFlag(
          formulaObj.codeList[0],
          defaultSetting.widget,
          defaultSetting.currentRelId || '',
        )
      ) {
        _flag = true;
      } else {
        _flag = false;
        message.warning(
          `${formulaObj.codeList[0].titleStr}和${defaultSetting.fieldName}不匹配！`,
        );
      }
    }
  } else {
    _flag = checkFormulaList(_targetValue, formulaObj, functionArr);
    // _flag = checkFormulaValue(formulaObj.pseudoData || '');
  }
  if (_flag && defaultSetting?.fieldGroupType === 'NUM') {
    const _targetArr = _targetValue.split('(');
    const _filterArr = unNumSelectArr.filter(
      (_v: string) => _targetArr[0] === _v,
    );
    if (_filterArr && !!_filterArr?.length) {
      _flag = false;
      message.warning('函数公式返回值与当前字段类型不匹配');
    } else {
      _flag = true;
    }
  }
  return _flag;
};

const getAttrItem = (list: any[], param: string) => {
  let res: any;
  for (let i = 0; i < list.length; i++) {
    if (list[i].attrs?.length) {
      res = list[i].attrs?.find((item: { key: string }) => item.key === param);
      if (res) {
        break;
      }
    }
  }
  return res;
};

export enum ErrorCodeEnum {
  'CHAR_ILLEGA' = 'CHAR_ILLEGA', // ${char}字符错误
  'SYNTAX_ILLEGA' = 'SYNTAX_ILLEGA', // 语法错误，缺少标识符
  'LINES_OVERFLOW' = 'LINES_OVERFLOW', // 公式最多2000行
  'LINE_CHARS_OVERFLOW' = 'LINE_CHARS_OVERFLOW', // 单行最多10000个字符
  'PARAMS_NUM_ILLEGA' = 'PARAMS_NUM_ILLEGA', // ${name}函数参数的个数不符合要求
  'PARAM_TYPE_ILLEGA' = 'PARAM_TYPE_ILLEGA', // ${name}函数的第${n}个参数不符合类型要求
  'RT_TYPE_NEQ_FIELD_TYPE' = 'RT_TYPE_NEQ_FIELD_TYPE', // 返回值数据类型与当前字段类型不匹配 . 文本字段、开关字段对公式返回值的数据类型不做校验
  'FUNCTION_UNDEFINED' = 'FUNCTION_UNDEFINED', // 函数未定义
  'FUNC_PARAM_UNDEFINED' = 'FUNC_PARAM_UNDEFINED', // 函数公式参数未定义
  'FUNC_FORMAT_ILLEGA' = 'FUNC_FORMAT_ILLEGA', // 函数公式格式不正确（编辑时的异常状态）
}

interface StackProps {
  stack: string[];
}
class Stack implements StackProps {
  stack: string[];

  constructor() {
    this.stack = [];
  }
  push(char: string) {
    return this.stack.push(char);
  }
  pop() {
    return this.stack.pop();
  }
  getSize() {
    return this.stack.length;
  }
  peek() {
    return this.stack[this.getSize() - 1];
  }
  isEmpty() {
    return this.getSize() === 0;
  }
}

const matchBrackets = (code: string): boolean => {
  const Bracket: any = {
    '{': '}',
    '(': ')',
    '[': ']',
  };
  const bracketValues = Object.values(Bracket);
  const stack = new Stack();
  for (let char of code) {
    if (Bracket[char]) {
      stack.push(char); // 左括号,入栈
    } else if (bracketValues.includes(char)) {
      // 右括号,将当前的元素和栈顶的第一个元素进行匹配
      const lastChar = stack.pop() || '';
      if (char !== Bracket[lastChar]) return false;
    } else {
      // 这里排除的是空字符的情况，如果不是左右括号而是其他的空字符串或者非法字符的话，将终止本次循环，执行下一次循环
      continue;
    }
  }
  //遍历完成之后要保证栈内要为空
  return stack.getSize() === 0;
};

const jsTypeToQxType: any = {
  '[object String]': FIELD_TYPE_PROPS.TEXT,
  '[object Number]': FIELD_TYPE_PROPS.NUM,
  '[object Boolean]': FIELD_TYPE_PROPS.BOOL,
  '[object Array]': FIELD_TYPE_PROPS.ARRAY,
  '[object Object]': FIELD_TYPE_PROPS.OBJECT,
  '[object Date]': FIELD_TYPE_PROPS.DATE,
  '[object Null]': 'NULL',
  '[object Undefined]': 'UNDEFINED',
};

export const handleFlattenList = (varList: any[], list: any[]) => {
  varList.forEach((item) => {
    if (item.fieldGroupType) {
      list.push({
        key: item.key,
        titleStr: item.titleStr,
        fieldGroupType: item.fieldGroupType,
      });
    }
    const children = item.children || item.attrs || [];
    children.forEach((it: any) => {
      const variable = {
        key: it.key,
        titleStr: it.titleStr,
        fieldGroupType: it.fieldGroupType,
      };
      list.push(variable);
      if (it.children || it.attrs) {
        handleFlattenList(it.children || it.attrs, list);
      }
    });
  });
};

const getTypeFromVar = (flattenVarList: any[], field: string) => {
  let type: string;
  if (field === '${SYS.CUR_USER}') {
    type = 'USER';
  } else if (field === '${SYS.CUR_ORG}') {
    type = 'ORG';
  } else {
    type =
      flattenVarList.find((item) => item.key === field)?.fieldGroupType || '';
  }
  return type;
};

/*
 *  函数参数校验
 * @param returnType 参数是函数时的返回类型
 * @param varItem 参数是变量时的值
 * @param param 用户输入的参数
 * @param funcParamItemType 当前参数需要的类型
 * @param errMap 错误
 * @param funcName 函数名称
 * @param i 当前参数index
 */

const handleParamCheck = (
  returnType: string,
  varItem: any,
  param: string,
  funcParamItemType: string,
  errMap: { errCode: string; errMsg: string },
  funcName: string,
  i: number,
  flattenVarList: any[],
) => {
  let _param = param;
  let mathCodeType: string = '';
  let isBool: boolean = false;
  if (mathCodeReg.test(_param)) {
    const matchs = _param.match(/\$\{((?![}]).)+(\})/g);
    if (matchs && matchs.length) {
      for (let i = 0; i < matchs.length; i++) {
        const type = flattenVarList.find(
          (item) => item.key === matchs[i],
        )?.fieldGroupType;
        if (type !== 'NUM') {
          Object.assign(errMap, {
            errCode: ErrorCodeEnum.PARAM_TYPE_ILLEGA,
            errMsg: '数学运算中包含非数字类型',
          });
          break;
        }
      }
    }
    if (errMap.errCode) {
      return errMap;
    }
    mathCodeType = 'NUM';
  } else if (boolCodeReg.test(_param)) {
    isBool = true;
  } else if (!returnType && !varItem?.fieldGroupType && param) {
    try {
      if (/^'|".'|"$/.test(_param)) {
        _param = _param.slice(1, -1);
      } else {
        _param = JSON.parse(_param);
      }
    } catch (e) {
      console.log(e);
    }
  }
  let varType =
    varItem?.fieldGroupType || // qx定义变量类型
    mathCodeType ||
    returnType || // 参数为函数返回值类型
    jsTypeToQxType[Object.prototype.toString.call(_param)]; // js变量类型
  if (isBool) {
    varType = 'BOOLEAN';
  }
  let requireType = funcParamItemType === 'STRING' ? 'TEXT' : funcParamItemType;
  varType = varType === 'STRING' ? 'TEXT' : varType;

  // 支持时间戳赋值动作数值类型
  // if (requireType === 'NUM' && varType === 'DATE') {
  //   varType = 'NUM';
  // }

  if (
    requireType !== varType &&
    requireType !== 'BOOLEAN' &&
    requireType !== 'OBJECT'
  ) {
    Object.assign(errMap, {
      errCode: ErrorCodeEnum.PARAM_TYPE_ILLEGA,
      errMsg: `${funcName}函数的第${i + 1}个参数不符合类型要求`,
    });
  }
  return errMap;
};

/*
 *  校验 函数公式
 */
export const checkFormulaExpress = (
  code: string,
  funcDataList: any[] = [],
  varDataList: any[] = [],
  usedFuncList: any[] = [],
  fieldType: FIELD_TYPE_PROPS,
  flattenVarList: any[],
): any => {
  const funcDataListFlatten: any[] = [];
  const varDataListFlatten: any[] = [];
  flatten(funcDataList, funcDataListFlatten);
  flatten(varDataList, varDataListFlatten);
  const errMap = {
    errCode: '',
    errMsg: '',
  };

  const codeArr = code?.split('\n') || [];
  const charErr =
    /[\u3002|\uff1f|\uff01|\uff0c|\u3001|\uff1b|\uff1a|\u201c|\u201d|\u2018|\u2019|\uff08|\uff09|\u300a|\u300b|\u3010|\u3011|\u007e]/.exec(
      code,
    ); // 匹配中文符号
  // \b\d+(\.\d+)?\b
  // 匹配直接使用算数运算符的情况， 如数值1 + 数值2、数值 + 4 // TODO

  if (code.trim() === '') {
  } else if (singleField.test(code.trim())) {
    const type = getTypeFromVar(flattenVarList, code.trim());
    // 支持时间戳赋值给数值
    // const timeStamp = type === 'DATE' && fieldType === 'NUM';
    if (
      type !== fieldType &&
      fieldType !== FIELD_TYPE_PROPS.TEXT &&
      fieldType !== FIELD_TYPE_PROPS.BOOL
      // && !timeStamp
    ) {
      Object.assign(errMap, {
        errCode: ErrorCodeEnum.RT_TYPE_NEQ_FIELD_TYPE,
        errMsg: `所选字段类型与当前字段类型不匹配`,
      });
    }
  } else if (fieldType === 'NUM' && mathCodeReg.test(code.replace(/\s/g, ''))) {
    const matchs = code.match(/\$\{((?![}]).)+(\})/g);
    if (matchs && matchs.length) {
      for (let i = 0; i < matchs.length; i++) {
        const type = flattenVarList.find(
          (item) => item.key === matchs[i],
        )?.fieldGroupType;
        // DATE类型转为时间戳，视为数字
        if (
          type !== 'NUM'
          // && type !== 'DATE'
        ) {
          Object.assign(errMap, {
            errCode: ErrorCodeEnum.PARAM_TYPE_ILLEGA,
            errMsg: `第${i + 1}个参数不符合类型要求`,
          });
          break;
        }
      }
    }
  } else if (charErr) {
    Object.assign(errMap, {
      errCode: ErrorCodeEnum.CHAR_ILLEGA,
      errMsg: `${charErr[0]}字符错误`,
    });
  } else if (!matchBrackets(code)) {
    Object.assign(errMap, {
      errCode: ErrorCodeEnum.SYNTAX_ILLEGA,
      errMsg: `语法错误，缺少标识符`,
    });
  } else if (codeArr.length > 2000) {
    Object.assign(errMap, {
      errCode: ErrorCodeEnum.LINES_OVERFLOW,
      errMsg: `公式最多2000行`,
    });
  } else if (codeArr.find((line: string) => line.length > 10000)) {
    Object.assign(errMap, {
      errCode: ErrorCodeEnum.LINE_CHARS_OVERFLOW,
      errMsg: `单行最多10000个字符`,
    });
  } else {
    let lineStr = code.replace(/\s/g, '');
    let reverseLineStr = reverseStr(code).replace(/\s/g, '');
    const usedFuncName: string[] = usedFuncList.map((item) => {
      return funcDataListFlatten.find((it) => it.id === item)?.funcNameEg;
    });
    const regexp = new RegExp(
      `\\(\\s*(${reverseStr(usedFuncName.join('|'))})`,
      'g',
    );
    let match: any;
    const funcReturnType: any = [];
    while ((match = regexp.exec(reverseLineStr)) !== null) {
      console.log(match, '-------');
      const funcName = reverseStr(match[1]);
      const funcItem = funcDataListFlatten.find(
        (item) => item.funcNameEg === funcName,
      );
      if (!funcItem) return errMap;
      const startIndex = lineStr.length - match.index;
      const endIndex = lineStr.indexOf(')', startIndex);
      const paramStr = lineStr.substring(startIndex, endIndex);
      let paramList: string[] = [];
      if (paramStr?.length) {
        paramList = paramStr.split(',');
      }

      // ----------------------------------------------------
      // const returnType = funcReturnType.pop();
      if (funcItem.paramsList) {
        // 校验可变参数的情况，如SUM(1,2,3,4)，参数个数不固定，只校验参数类型
        if (
          funcItem.paramsList.length === 1 &&
          funcItem.paramsList[0]?.varargs
        ) {
          if (!paramList.length) {
            Object.assign(errMap, {
              errCode: ErrorCodeEnum.PARAM_TYPE_ILLEGA,
              errMsg: `${funcName}函数的参数个数不符合类型要求`,
            });
          }
          const type = funcItem.paramsList[0]?.type;
          for (let i = 0; i < paramList.length; i++) {
            let _param = paramList[i];
            let varItem = varDataListFlatten.find(
              (item) => item.key === _param,
            );
            if (!varItem && _param.split('.').length > 2) {
              varItem = getAttrItem(varDataListFlatten, _param);
            }
            const isFunc =
              _param.split('').filter((it) => it === '0')?.length ===
              _param.length;
            const err = handleParamCheck(
              isFunc ? funcReturnType.pop() : undefined,
              varItem,
              _param,
              type,
              errMap,
              funcName,
              i,
              flattenVarList,
            );
            if (err.errCode) {
              break;
            }
          }
        } else if (funcItem.paramsList.length !== paramList.length) {
          // 过滤出必填参数
          const requiredLength = funcItem.paramsList.filter(
            (item: { required?: boolean }) => item.required,
          )?.length;
          if (requiredLength !== paramList.length) {
            Object.assign(errMap, {
              errCode: ErrorCodeEnum.PARAMS_NUM_ILLEGA,
              errMsg: `${funcName}函数参数的个数不符合要求`,
            });
          }
        } else {
          for (let i = 0; i < funcItem.paramsList.length; i++) {
            let funcParamItemType = funcItem.paramsList[i]?.type;
            if (funcParamItemType === 'STRING') {
              funcParamItemType = 'TEXT';
            }
            let _param = paramList[i];
            let varItem = varDataListFlatten.find(
              (item) => item.key === paramList[i],
            );
            if (!varItem && _param.split('.').length > 2) {
              varItem = getAttrItem(varDataListFlatten, _param);
            }
            const isFunc =
              _param.split('').filter((it) => it === '0')?.length ===
              _param.length;
            const err = handleParamCheck(
              isFunc ? funcReturnType.pop() : undefined,
              varItem,
              _param,
              funcParamItemType,
              errMap,
              funcName,
              i,
              flattenVarList,
            );
            if (err.errCode) {
              break;
            }
          }
        }
      }
      funcReturnType.push(funcItem.returnType);
      // ----------------------------------------------------
      const funcExpress = `${funcName}(${paramStr})`;
      lineStr = reverseStr(lineStr).replace(
        reverseStr(funcExpress),
        strFill(0, funcExpress.length, 0),
      );
      lineStr = reverseStr(lineStr);
      console.log(paramStr, '----++++++---', funcExpress);
      console.log(lineStr, '----=======---');
    }
    const _funcReturnType = funcReturnType.pop();
    if (
      _funcReturnType !== fieldType &&
      _funcReturnType !== 'OBJECT' &&
      fieldType !== FIELD_TYPE_PROPS.TEXT &&
      fieldType !== FIELD_TYPE_PROPS.BOOL
    ) {
      Object.assign(errMap, {
        errCode: ErrorCodeEnum.RT_TYPE_NEQ_FIELD_TYPE,
        errMsg: `公式返回值数据类型与当前字段类型不匹配`,
      });
    }
  }
  return errMap;
};

// 字符串取反
export const reverseStr = (str: string) => {
  if (typeof str !== 'string') return '';
  return str.split('').reverse().join('');
};

// 平铺树结构数据，只取的叶子结点
export const flatten = (dataList: any[] = [], flattenList: any[]) => {
  for (let i = 0; i < dataList.length; i++) {
    const data = dataList[i];
    if (data.children) {
      flatten(data.children, flattenList);
    } else {
      flattenList.push(data);
    }
  }
};

// 根据索引值，匹配光标所在位置周围符合语法语义规则的变量名
export const getLegalVaribleNameFromIndex = (
  lineStr: string,
  index: number,
) => {
  if (typeof lineStr !== 'string') return '';
  const regExp = /(.*?)[\;\:\=\?\~\,\.\<\>\{\}\(\)\s]|(.*)$/;
  const leftStr = lineStr.substring(0, index);
  const rightStr = lineStr.substring(index, lineStr.length);
  const matchLeftStr = reverseStr(leftStr).match(regExp);
  const matchRightStr = rightStr.match(regExp);
  const leftPart = reverseStr(
    matchLeftStr ? matchLeftStr[1] || matchLeftStr[2] || '' : '',
  );
  const rightPart = matchRightStr
    ? matchRightStr[1] || matchRightStr[2] || ''
    : '';
  return leftPart + rightPart;
};

export const domTagGen = (
  variable: string,
  text: string,
  color?: string,
  type?: string,
) => {
  const dom = document.createElement('span');
  dom.style.margin = '0 1px';
  if (!type) {
    dom.style.background = '#c9dffc';
    dom.style.borderRadius = '2px';
    dom.style.padding = '1px 3px';
    dom.style.fontSize = '96%';
    if (color) {
      dom.style.color = color;
    }
  } else if (type === 'function') {
    dom.style.color = '#00A870';
    dom.style.cursor = 'default';
    dom.className = 'funcName';
  }
  dom.setAttribute('data-widget', variable);
  dom.innerHTML = text;
  return dom;
};

/**
 * 填充到指定位数
 * eg：000000000
 *
 * @param val     原始值
 * @param length  填充后长度
 * @param fill    填充值
 */
export const strFill = (
  val: string | number,
  length: number,
  fill: string | number,
) => {
  return val.toString().padStart(length, fill.toString());
};

//复制文本
export const copyText = (text: string) => {
  var element = createElement(text);
  element.select();
  element.setSelectionRange(0, element.value.length);
  document.execCommand('copy');
  element.remove();
  message.success('复制成功');
};

//创建临时的输入框元素
export const createElement = (text: string) => {
  var isRTL = document.documentElement.getAttribute('dir') === 'rtl';
  var element = document.createElement('textarea');
  // 防止在ios中产生缩放效果
  element.style.fontSize = '12pt';
  // 重置盒模型
  element.style.border = '0';
  element.style.padding = '0';
  element.style.margin = '0';
  // 将元素移到屏幕外
  element.style.position = 'absolute';
  element.style[isRTL ? 'right' : 'left'] = '-9999px';
  // 移动元素到页面底部
  let yPosition = window.pageYOffset || document.documentElement.scrollTop;
  element.style.top = `${yPosition}px`;
  //设置元素只读
  element.setAttribute('readonly', '');
  element.value = text;
  document.body.appendChild(element);
  return element;
};

const TEXT_CONFIG = {
  name: '文本',
  color: '#1764FF',
  bgColor: '#E7EFFF',
};

const NUM_CONFIG = {
  name: '数值',
  color: '#FF7D00',
  bgColor: '#FFF7E8',
};

const DATE_CONFIG = {
  name: '日期',
  color: '#722ED1',
  bgColor: '#F5E8FF',
};

export const widgetMapping: any = {
  qxInput: TEXT_CONFIG,
  qxNumber: NUM_CONFIG,
  dateTime: DATE_CONFIG,
  qxDatetime: DATE_CONFIG,
  qxTime: {
    name: '时间',
    color: '#722ED1',
    bgColor: '#F5E8FF',
  },
  qxSwitch: {
    name: '布尔',
    color: '#3491FA',
    bgColor: '#E8F7FF',
  },
  qxSelect: {
    name: '单选',
    color: '#3491FA',
    bgColor: '#E8F7FF',
  },
  qxMultiSelect: {
    name: '多选',
    color: '#3491FA',
    bgColor: '#E8F7FF',
  },
  qxMobile: TEXT_CONFIG,
  qxMoney: NUM_CONFIG,
  qxEmail: TEXT_CONFIG,
  qxPercent: NUM_CONFIG,
  qxUpload: {
    name: '附件',
    color: '#3491FA',
    bgColor: '#E8F7FF',
  },
  qxUploadImage: {
    name: '图片',
    color: '#3491FA',
    bgColor: '#E8F7FF',
  },
  qxAddress: TEXT_CONFIG,
  qxRichText: {
    name: '富文本',
    color: '#F7BA1E',
    bgColor: '#FFFCE8',
  },
  qxLocation: {
    name: '对象',
    color: '#3491FA',
    bgColor: '#E8F7FF',
  },

  orgSelector: {
    name: '部门',
    color: '#3491FA',
    bgColor: '#E8F7FF',
  },
  userSelector: {
    name: '人员',
    color: '#3491FA',
    bgColor: '#E8F7FF',
  },
  createdBy: {
    name: '人员',
    color: '#3491FA',
    bgColor: '#E8F7FF',
  },
  created_by: {
    name: '人员',
    color: '#3491FA',
    bgColor: '#E8F7FF',
  },
  createdAt: DATE_CONFIG,
  created_at: DATE_CONFIG,
  updatedBy: {
    name: '人员',
    color: '#3491FA',
    bgColor: '#E8F7FF',
  },
  updated_by: {
    name: '人员',
    color: '#3491FA',
    bgColor: '#E8F7FF',
  },
  updatedAt: DATE_CONFIG,
  updated_at: DATE_CONFIG,
  qxBizNo: TEXT_CONFIG,

  relSelector: {
    name: '关联记录',
    color: '#3491FA',
    bgColor: '#E8F7FF',
  },
  relField: {
    name: '关联属性',
    color: '#3491FA',
    bgColor: '#E8F7FF',
  },
  subform: {
    name: '子表',
    color: '#3491FA',
    bgColor: '#E8F7FF',
  },
  table: {
    name: '子表',
    color: '#3491FA',
    bgColor: '#E8F7FF',
  },
  qxTree: {
    name: '树形关联',
    color: '#3491FA',
    bgColor: '#E8F7FF',
  },
  qxFormula: {
    name: '公式',
    color: '#3491FA',
    bgColor: '#E8F7FF',
  },
  qxDivider: {
    name: '分割线',
    color: '#3491FA',
    bgColor: '#E8F7FF',
  },
  qxRemark: {
    name: '标题备注',
    color: '#3491FA',
    bgColor: '#E8F7FF',
  },
  qxEmbed: {
    name: '嵌入',
    color: '#3491FA',
    bgColor: '#E8F7FF',
  },

  qxTabs: {
    name: '页签',
    color: '#3491FA',
    bgColor: '#E8F7FF',
  },
  qxLayout: {
    name: '布局',
    color: '#3491FA',
    bgColor: '#E8F7FF',
  },
  qxObject: {
    name: '对象',
    color: '#F5319D',
    bgColor: '#FFE8F1',
  },
};

export const SYSVariable = [
  {
    key: '${SYS.CUR_USER}',
    titleStr: '当前人员',
    widget: 'qxObject',
    fieldGroupType: FIELD_TYPE_PROPS.OBJECT,
    attrs: [
      {
        key: '${SYS.CUR_USER.id}',
        titleStr: '用户ID',
        fieldGroupType: FIELD_TYPE_PROPS.TEXT,
      },
      {
        key: '${SYS.CUR_USER.name}',
        titleStr: '用户名',
        fieldGroupType: FIELD_TYPE_PROPS.TEXT,
      },
      {
        key: '${SYS.CUR_USER.code}',
        titleStr: '工号',
        fieldGroupType: FIELD_TYPE_PROPS.TEXT,
      },
      {
        key: '${SYS.CUR_USER.mobile}',
        titleStr: '手机号',
        fieldGroupType: FIELD_TYPE_PROPS.TEXT,
      },
      {
        key: '${SYS.CUR_USER.email}',
        titleStr: '邮箱',
        fieldGroupType: FIELD_TYPE_PROPS.TEXT,
      },
      // {
      //   key: '${SYS.CUR_USER.role}',
      //   titleStr: '角色',
      //   fieldGroupType: FIELD_TYPE_PROPS.TEXT,
      // },
    ],
  },
  {
    key: '${SYS.CUR_ORG}',
    titleStr: '当前部门',
    widget: 'qxObject',
    fieldGroupType: FIELD_TYPE_PROPS.OBJECT,
    attrs: [
      {
        key: '${SYS.CUR_ORG.id}',
        titleStr: '部门ID',
        fieldGroupType: FIELD_TYPE_PROPS.TEXT,
      },
      {
        key: '${SYS.CUR_ORG.code}',
        titleStr: '部门编号',
        fieldGroupType: FIELD_TYPE_PROPS.TEXT,
      },
      {
        key: '${SYS.CUR_ORG.name}',
        titleStr: '部门名称',
        fieldGroupType: FIELD_TYPE_PROPS.TEXT,
      },
      {
        key: '${SYS.CUR_ORG.orgLevel}',
        titleStr: '部门层级',
        fieldGroupType: FIELD_TYPE_PROPS.TEXT,
      },
    ],
  },
  {
    key: '${SYS.CUR_CORP}',
    titleStr: '当前公司',
    widget: 'qxObject',
    fieldGroupType: FIELD_TYPE_PROPS.OBJECT,
    attrs: [
      {
        key: '${SYS.CUR_CORP.corpCode}',
        titleStr: '公司编号',
        fieldGroupType: FIELD_TYPE_PROPS.TEXT,
      },
      {
        key: '${SYS.CUR_CORP.corpName}',
        titleStr: '公司名称',
        fieldGroupType: FIELD_TYPE_PROPS.TEXT,
      },
    ],
  },
  {
    key: '${SYS.CUR_DATE}',
    titleStr: '当前时间',
    widget: 'qxDatetime',
    fieldGroupType: FIELD_TYPE_PROPS.DATE,
  },
  {
    key: '${SYS.LOGIN_INFO}',
    titleStr: '登录信息',
    widget: 'qxObject',
    fieldGroupType: FIELD_TYPE_PROPS.OBJECT,
    attrs: [
      {
        key: '${SYS.LOGIN_INFO.ipAddr}',
        titleStr: 'IP地址',
        fieldGroupType: FIELD_TYPE_PROPS.TEXT,
      },
      {
        key: '${SYS.LOGIN_INFO.terminal}',
        titleStr: '终端类型',
        fieldGroupType: FIELD_TYPE_PROPS.TEXT,
      },
      {
        key: '${SYS.LOGIN_INFO.browser}',
        titleStr: '浏览器信息',
        fieldGroupType: FIELD_TYPE_PROPS.TEXT,
      },
      {
        key: '${SYS.LOGIN_INFO.browserRoute}',
        titleStr: '当前浏览器路由信息',
        fieldGroupType: FIELD_TYPE_PROPS.TEXT,
      },
      {
        key: '${SYS.LOGIN_INFO.session}',
        titleStr: 'session信息',
        fieldGroupType: FIELD_TYPE_PROPS.TEXT,
      },
    ],
  },
  // {
  //   key: '${SYS.CUR_SERVER}',
  //   titleStr: '服务器信息',
  //   widget: 'qxObject',
  //   fieldGroupType: FIELD_TYPE_PROPS.OBJECT,
  //   attrs: [
  //     {
  //       key: '${SYS.CUR_SERVER.ipAddr}',
  //       titleStr: 'IP地址',
  //       fieldGroupType: FIELD_TYPE_PROPS.TEXT,
  //     },
  //     {
  //       key: '${SYS.CUR_SERVER.macAddr}',
  //       titleStr: 'MAC地址',
  //       fieldGroupType: FIELD_TYPE_PROPS.TEXT,
  //     },
  //     {
  //       key: '${SYS.CUR_SERVER.serverName}',
  //       titleStr: '服务器名称',
  //       fieldGroupType: FIELD_TYPE_PROPS.TEXT,
  //     },
  //   ],
  // },
];

export const flattenVariable = (_list: any[], parent: any, newList: any[]) => {
  _list.forEach((o) => {
    const item = _.cloneDeep(o);
    const parentTitle = parent?.titleStr || '';
    item.titleStr = `${parentTitle ? parentTitle + '.' : ''}${item.titleStr}`;
    newList.push(item);
    if (item.attrs) {
      flattenVariable(item.attrs, item, newList);
    }
  });
};