import Parser, { parser } from './parser';
import { FormInstance } from 'rc-field-form/es/interface';
// BCMC表单
const bcmcDFormState = (props: any) => {
  return {
    type: 'general',
    formStateKey: 'initBCMCDFormState',
    bottom: !!props.footer,
    isEdit: props.isEdit,
    ...props,
  };
};

// bcmc默认环节处理
const bcmcDefaultLinkInfo = (props: any) => {
  return {
    title: '环节处理',
    type: 'general',
    formStateKey: 'initLinkInfoFormState',
    bottom: !!props.footer,
    isEdit: props.isEdit,
  };
};

// bcmc产品列表
const bcmcProjectInfo = (props: any) => {
  return {
    type: 'bcmcProjectInfo',
    bottom: !!props.footer,
    componentProps: { ...props },
  };
};

// bcmc底部按钮
const bcmcFooterBtn = (props: any) => {
  return {
    type: 'bcmcFooterBtn',
    bottom: !!props.footer,
    componentProps: { ...props },
  };
};

// bcmc附件信息
const bcmcEnclosure = (props: any) => {
  return {
    type: 'bcmcEnclosure',
    bottom: !!props.footer,
    componentProps: { ...props },
  };
};

// bcmc模块
const bcmcBlock = {
  bcmcDFormState,
  bcmcProjectInfo,
  bcmcFooterBtn,
  bcmcEnclosure,
  bcmcDefaultLinkInfo,
} as any;

// 初始化bcmc数据
const initBcmcData = (props: any) => {
  const {
    bcmcData = {},
    isEdit = false, // 详情：false，代办和新增：true
    flowNodeCode = '', // 环节编码
    isEditFlowBlockObj = {}, // 可编辑的区块对象
    blockObj = {}, // 模块映射
    renderSpecialBlock, // 区块渲染
    bcmcFooterBtnProps = {},
    ...otherProps
  } = props;
  console.log('bcmcData', bcmcData);
  const { elementList = [] as any[], needSave, needSubmit } = bcmcData;
  const pageContent: any[] = [];

  // 模块是否可编辑
  let mIsEdit = isEdit;
  elementList.forEach((row: any, index: number) => {
    const {
      componentType,
      elementCode,
      componentCode,
      disabled = false,
      editable = true,
      visible = true,
      label,
      properties = [],
    } = row;
    if (!visible) return;

    const code = componentCode || elementCode;

    // 是否是可编辑模块
    if (mIsEdit && editable) {
      mIsEdit = true;
    }
    // 是否映射内嵌组件
    if (blockObj[code]) {
      const { blockKey, blockProps = {} } = blockObj[code];
      if (bcmcBlock[blockKey]) {
        pageContent.push(
          bcmcBlock[blockKey]({
            ...otherProps,
            ...blockProps,
            isEdit: mIsEdit,
          }),
        );
        return;
      }
    }
    try {
      switch (componentType) {
        case 'Async':
        case 'Table':
          if (renderSpecialBlock) {
            pageContent.push(
              renderSpecialBlock({ ...props, isEdit: mIsEdit }, row),
            );
          }
          break;
        case 'Card':
          pageContent.push(
            bcmcDFormState({
              isEdit: mIsEdit,
              title: label,
              properties,
            }),
          );
          break;
        default:
          break;
      }
    } catch (error) {
      console.log('initBCMCDFormState.error', error);
    }
  });
  // 底部按钮处理
  if (mIsEdit && (needSave || needSubmit)) {
    let fbtProps = {} as any;
    if (needSubmit && needSave) {
      fbtProps = {
        leftBtLabel: '保存',
        rightBtLabel: '提交',
        footer: true,
      };
    } else if (needSubmit) {
      fbtProps = {
        rightBtLabel: '提交',
        footer: true,
      };
    } else if (needSave) {
      fbtProps = {
        rightBtLabel: '保存',
        footer: true,
      };
    }
    fbtProps = { ...fbtProps, ...bcmcFooterBtnProps };
    pageContent.push(bcmcFooterBtn(fbtProps));
  }
  console.log('pageContent', pageContent);
  return pageContent;
};

/**
 *
 * @param param0
 */
const bcmcRuleChange = ({
  form,
  formsValues = {},
  changeForm = {},
  ruleItem = {},
  UnableAssignValue = [],
}: {
  form?: FormInstance;
  formsValues: any;
  changeForm: any;
  ruleItem: any;
  UnableAssignValue?: string[];
}) => {
  let mChangeForm = changeForm;
  let mChangeValues = {} as any;
  let isChangeForm = false;
  let isChangeValue = false;
  const {
    driveType = '',
    triggerEleRuleExpr = '',
    targetEleCode = [],
    targetEleRuleExpr = '',
  } = ruleItem;
  let triggerEleRuleExprChange = triggerEleRuleExpr;
  // 环节处理的内容都放在orderObjRel.下面，由于pc端的数据存在，但是app不存在
  if (triggerEleRuleExprChange.indexOf('orderObjRel.') !== -1) {
    triggerEleRuleExprChange = triggerEleRuleExprChange.replace(
      /orderObjRel./g,
      '',
    );
  }
  // 规则是否生效
  let passed = false;
  try {
    // 计算规则是否生效
    passed = !!parser.evaluate(triggerEleRuleExprChange, formsValues);
  } catch (e) {
    console.log('规则处理错误：', e);
  }

  const result = parser.evaluate(targetEleRuleExpr, formsValues);
  // 表单联动
  let mChange = {} as any;
  // 数据联动
  let mValueChangeObj = {} as any;
  switch (driveType) {
    case 'show': // 显示
    case 'notRequired': // 非必填
      mChange.required = !passed;
      break;
    case 'hide': // 隐藏
    case 'required': // 必填
      mChange.hidden = passed;
      break;
    case 'setState':
      //是否禁用
      if (
        result.name &&
        (result.name === 'editable' || result.name === 'props.disabled')
      ) {
        // 表单变更属性编码
        const changeFormKey =
          result.name === 'editable' ? result.name : 'disabled';
        if (passed) {
          if (result.flag) {
            mChangeForm[Parser.parse(targetEleRuleExpr).tokens[2].value] = {
              ...(mChangeForm[
                Parser.parse(targetEleRuleExpr).tokens[2].value
              ] || {}),
              [changeFormKey]: !!result.value,
            };
          } else {
            mChangeForm[targetEleCode] = {
              ...(mChangeForm[targetEleCode] || {}),
              [changeFormKey]: !!result.value,
            };
          }
        } else {
          if (mChangeForm[targetEleCode]) delete mChangeForm[targetEleCode];
        }
      } else if (result.name && result.name === 'value') {
        // 设值
        if (passed) {
          if (result.flag) {
            mValueChangeObj[Parser.parse(targetEleRuleExpr).tokens[2].value] =
              result.value;
          } else {
            mValueChangeObj[targetEleCode] = result.value;
          }
          if (!!form) {
            form.setFieldsValue(mValueChangeObj);
          } else {
            //复值
            mChangeValues = {
              ...mChangeValues,
              ...mValueChangeObj,
            };
          }
        } else {
          if (!!form) {
            form.setFieldsValue({
              [targetEleCode]: '',
            });
          } else {
            mChangeValues[targetEleCode] = '';
          }
        }
      }
      break;
    case 'calc':
      if (passed) {
        try {
          // 【设置值】表达式中不允许使用post或get请求,请求行
          if (
            triggerEleRuleExprChange.indexOf('post(') === -1 &&
            triggerEleRuleExprChange.indexOf('get(') === -1
          ) {
            if (form) {
              form.setFieldsValue({
                [targetEleCode]: result,
              });
            } else {
              mChangeValues[targetEleCode] = result;
            }
          }
        } catch (e) {
          console.log('calc.error', e);
        }
      }
      break;
    default:
      break;
  }
  // 修改表单
  if (Object.keys(mChange)) {
    targetEleCode.map((targetKey: string) => {
      let changeTargetForm = { ...mChange } as any;
      if (mChangeForm[targetKey]) {
        changeTargetForm = {
          ...mChangeForm[targetKey],
          ...mChange,
        };
      }
      mChangeForm[targetKey] = changeTargetForm;
      if (driveType === 'hide' && form) {
        //隐藏删除值
        form.setFieldsValue({
          [targetKey]: '',
        });
      } else {
        mChangeValues[targetKey] = '';
      }
    });
  }

  // 无法赋值字段处理，需要研发人员单独处理
  UnableAssignValue.forEach((key) => {
    if (!!mChangeValues[key]) delete mChangeValues[key];
  });

  // 是否需要变更赋值
  if (!!Object.keys(mChangeValues)) isChangeValue = true;
  if (!!Object.keys(mChangeForm)) isChangeForm = true;
  return {
    isChangeForm,
    isChangeValue,
    changeForm: mChangeForm,
    changeValues: mChangeValues,
  };
};

const bcmcFormDataObj = ({
  blockList = [],
  filesObj = {},
  optionObjs = {},
  formsValues = {},
  changeForm = {},
}: {
  blockList: any[];
  filesObj: any;
  optionObjs: any;
  formsValues: any;
  changeForm: any;
}) => {
  const formValue = {} as any;

  blockList.map((item: any) => {
    const { properties = [], componentType = '', elementCode } = item;
    //附件数据初始化
    if (componentType === 'Table') {
      filesObj[elementCode] = formValue[elementCode] || [];
    }
    properties.map((cardItem: any) => {
      const {
        elementCode = '',
        initialValue = '',
        componentType = '',
      } = cardItem;

      //如果初始化没有该值， 将表单默认值赋值给mFormsValues， 关联规则需要使用
      let initValue = formValue[elementCode] || initialValue;
      formValue[elementCode] = initValue;
      switch (componentType) {
        case 'RadioGroup':
          cardItem.initialValue = initValue;
          break;
        case 'Select':
          optionObjs = {
            ...optionObjs,
            [elementCode]: cardItem.dataSource,
          };
          break;
        case 'TreeSelect':
          {
            const valueList = formsValues[elementCode] || [];
            const dataSource = cardItem.dataSource || [];
            optionObjs[elementCode] = dataSource;
            changeForm = {
              ...changeForm,
              [elementCode]: {
                data: [],
              },
            };
            if (valueList.length > 0) {
              let companyValueList = [] as any;
              let companyDataSource = [] as any;
              const comapnyValue = valueList[0];
              for (let index = 0; index < dataSource.length; index++) {
                const companyItem = dataSource[index];
                console.log('companyItem', companyItem);
                if (comapnyValue === companyItem.value) {
                  companyValueList = {
                    label: [companyItem.title],
                    value: [comapnyValue],
                  };
                  companyDataSource = companyItem.children || dataSource || [];
                  break;
                } else {
                  if (companyDataSource.length > 0) {
                    break;
                  }
                  if (companyItem.children) {
                    for (
                      let index2 = 0;
                      index2 < companyItem.children.length;
                      index2++
                    ) {
                      const childItem = companyItem.children[index2];
                      if (comapnyValue === childItem.value) {
                        companyValueList = {
                          label: [companyItem.title, childItem.title],
                          value: [companyItem.value, comapnyValue],
                        };
                        companyDataSource = companyItem.children;
                        break;
                      }
                    }
                  }
                }
              }
              formValue[elementCode] = companyValueList;
            } else {
              formValue[elementCode] = '';
            }
          }
          break;
        default:
          break;
      }
    });
  });
  return {
    filesObj,
    optionObjs,
    formsValues,
    changeForm,
  };
};

export const bcmcUtils = {
  initBcmcData,
  bcmcRuleChange,
  bcmcFormDataObj,
};