/**
   * 格式化表单数据
   * @param {Object} serverDataSource 自定义表单数据详情，json结构如下
   * {
      // 主表从表皆为数组
      // 根据mainObjType可知，TEST为主表
      TEST: [{
          T1: null, // key 对应元件 type， value 对应元件 value
          T1_DisplayValue: "" // 类型对应label元件value
          ...
      }],
      // BB为从表
      BB:[{
          B1: null,
          B1_DisplayValue: "",
          ...
      }],
      // 是否多表
      multi: ["true"],
      // 当前的主表表名
      mainObjType: [
        'TEST',
      ]
    }
   * @returns {Object} mainChildObj
   */
const formatFormData = serverDataSource => {
  // 判断当前表是否是多表
  const multiData = serverDataSource.multi !== undefined ? serverDataSource.multi : [''];

  // 是否是主从表关系
  if (serverDataSource && multiData[0]) {
    // 主从表数据对象
    const mainChildObj: any = {};
    // 遍历表单数据详情
    for (const [propValue, dataValue] of Object.entries(serverDataSource)) {
      // 过滤出主从表数据 - 属性名非mainObjType, multi, 以_StartPosition结尾的属性
      if (
        propValue !== 'mainObjType' &&
        !propValue.endsWith('_StartPosition') &&
        propValue != 'multi'
      ) {
        // 根据mainObjType判断主表类型是否存在
        if (
          serverDataSource['mainObjType'].length &&
          serverDataSource['mainObjType'].length !== 0
        ) {
          // 获取主表表名
          const mainTableKey = serverDataSource['mainObjType'][0];
          // 当前的属性名是否为主表表名
          if (propValue === mainTableKey) {
            // 设置主表类型
            mainChildObj['ObjectType'] = mainTableKey;
            // 组织主表数据
            for (const [mainProp, mainValue] of Object.entries(JSON.parse(dataValue[0]))) {
              mainChildObj[mainProp] = mainValue;
            }
          } else {
            // 是否存在从表项结构
            if (!mainChildObj.children) {
              mainChildObj.children = [];
            }
            // 当前从表项
            const curChildData: any = {
              option: {
                // 设置从表类型
                ChildObjType: propValue,
              },
            };
            // 获取当前从表的数据集Id
            if (serverDataSource[`${propValue}_StartPosition`]) {
              curChildData.option[`${propValue}_StartPosition`] =
                serverDataSource[`${propValue}_StartPosition`];
            }
            if (dataValue && dataValue.length && dataValue.length > 0) {
              // 当前从表行数据列表
              curChildData.line = [];
              // 遍历当前的从表数据, 每一行的 [{}, {}]
              for (const childIndex in dataValue) {
                // 获取每一行的从表数据
                curChildData.line.push(JSON.parse(dataValue[childIndex]));
              }
            }
            mainChildObj.children.push(curChildData);
          }
        }
      }
    }
    return mainChildObj;
  } else {
    return serverDataSource;
  }
};

/**
 * 获取从表对应的数据集的单元格顺序
 * @param {Object} formLayOutData 表单结构数据
 * @returns orderMap
 */
const getOrderMap = formLayOutData => {
  let rowOrderMap = new Map();
  // 遍历从表数据集
  for (const [templateId, templateConfig] of Object.entries(formLayOutData?.datasets.template)) {
    // 获取从表的数据集对应的单元格顺序map 数据集id => [InfoType，InfoType]
    rowOrderMap = templateConfig.reduce((pre, cur) => {
      if (cur.tag) {
        if (!pre.has(templateId)) {
          pre.set(templateId, [cur.tag.InfoType]);
        } else {
          pre.get(templateId).push(cur.tag.InfoType);
        }
      }
      return pre;
    }, new Map());
  }
  return rowOrderMap;
};
/**
 * 生成工具栏
 * @param {Object} formLayOutData 主从表数据
 * @returns Toolbox
 */
// function generateToolbox(formLayOutData) {
//   const tools = $.formbuilder.icpx.modelTypes;
//   return formLayOutData.controls.reduce((pre, cur) => {
//     if (cur.tag !== undefined) {
//       // 根据展示类型设置
//       pre[cur.type] = $.extend(true, {}, tools[cur.tag.DisposeType]);
//     }
//     return pre;
//   }, {});
// }
/**
 * 格式化主表数据
 * @param {Object} formDataSource 表单数据详情
 * @param {Object} formLayOutData 表单结构数据
 * @returns orderMap
 */
const formatMainTableData = (formDataSource, formLayOutData) => {
  formLayOutData?.controls.map(mainItem => {
    if (typeof mainItem.tag === 'object') {
      // 主表字段非label，设置value和text的值
      if (mainItem.tag.DisposeType !== 'LabelValue' && mainItem.tag.Master) {
        mainItem.value = formDataSource[mainItem.tag.InfoType] || '';
        mainItem.text = formDataSource[`${mainItem.tag.InfoType}_DisplayValue`];
      }
    }
  });
};

/**
 * 格式化从表数据
 * @param {Object} formDataSource 表单数据详情
 * @param {Object} formLayOutData 表单结构数据
 * @param {Map} rowOrderMap 行单元格排序Map
 * @returns orderMap
 */
const formatChildTableData = (formDataSource, formLayOutData, rowOrderMap) => {
  // 从表结构是否存在
  if (formDataSource.children) {
    // 遍历所有从表数据
    formDataSource.children.forEach(item => {
      // 当前从表配置项，当前从表行数据, line: [{}, {}]
      const { option, line } = item;
      const { ChildObjType } = option;
      // 获取当前从表数据集行id 例：['awsId', 'abcId']
      const childPositionData = option[`${ChildObjType}_StartPosition`];
      // 从表数据集id 对应的当前数据集id的所有行Map 例：awsId => {id: 'awsId', rows: [{...行数据},{...行数据}]}
      const childPositionMap = new Map();
      // 数据集id集合存在
      if (childPositionData !== undefined) {
        childPositionData.forEach((positionId, pIdx) => {
          if (!childPositionMap.has(positionId)) {
            /* 组织从表数据集map id => {id, rows: []}， 
                此处的rows不含分页，rows中表示的是当前数据集的所有行数据, 不含分页
                此处的cildPositionData对应的下标与line中的每一行对应
              */
            childPositionMap.set(positionId, { id: positionId, rows: [line[pIdx]] });
          } else {
            // 若是当前数据集，
            childPositionMap.get(positionId).rows.push(line[pIdx]);
          }
        });

        for (const [dataSetKey, currentDataSetValue] of childPositionMap.entries()) {
          // 获取当前数据集单元格顺序
          const orderArr = rowOrderMap.get(dataSetKey);

          // 当前数据集
          const dataSetDatas = [],
            pageMap = new Map();

          // 遍历当前数据集对应的所有行数据 [{...行数据},{...行数据}]
          currentDataSetValue.rows.forEach((row, rowIdx) => {
            // 若分页不存在
            if (row.PAGENUMEBR === undefined) {
              // 设置第一页，第一行
              if (dataSetDatas.length !== 1) {
                // 设置第一页，第一行
                dataSetDatas.push([[]]);
                // 遍历当前数据集单元格顺序, 设置第一页，rowIdx行的单元格的数据
                orderArr?.forEach(formKey => {
                  dataSetDatas[0][rowIdx].push({ value: row[formKey] || '' });
                });
              } else {
                // 设置第一页，第rowIdx行的单元格数据
                orderArr?.forEach(formKey => {
                  dataSetDatas[0][rowIdx].push({ value: row[formKey] || '' });
                });
              }
            } else {
              // 组织分页map 当前页数 -> [{...行数据}, {...行数据}]
              if (!pageMap.has(row.PAGENUMEBR)) {
                pageMap.set(row.PAGENUMEBR, [row]);
              } else {
                // 同一页的数据，对应的行加入当前页的map中
                pageMap.get(row.PAGENUMEBR).push(row);
              }
            }
          });

          // 是否存在分页数据，遍历分页map  页 -> 所有行
          if ([...pageMap.values()].length !== 0) {
            for (const [key, row] of pageMap.entries()) {
              // 插入页
              dataSetDatas.push([]);
              // 遍历当前页对应的所有行数据，0
              row.forEach((item, rowIdx) => {
                // 在当前页插入行
                dataSetDatas[parseInt(key) - 1].push([]);
                // 当前行插入单元格数据
                orderArr.forEach(formKey => {
                  dataSetDatas[parseInt(key) - 1][rowIdx].push({ value: item[formKey] || '' });
                });
              });
            }
          }
          // 替换当前数据集的rows数据， 设置当前数据集的行数据，若分页存在，此时的dataSetDatas是包含分页的数据
          currentDataSetValue.rows = dataSetDatas;
        }

        // childPositionMap的rows外层又套了一层数据集
        formLayOutData.datasets.data = [...childPositionMap.values()];
      }
    });
  }
};
/**
 * 格式化加载数据
 * @param {Object} serverDataObj 表单数据详情
 * @param {Object} formLayOutData 表单结构书画家
 * @returns dataSource
 */
function formatLoadData(serverDataObj, formLayOutData) {
  // 格式化表单数据源
  const formDataSource = formatFormData(JSON.parse(serverDataObj));

  // 行单元格排序Map
  const rowOrderMap = getOrderMap(formLayOutData);
  // 格式化表单主表数据
  formatMainTableData(formDataSource, formLayOutData);
  // 格式化从表数据
  formatChildTableData(formDataSource, formLayOutData, rowOrderMap);
}

/**
 * 格式化保存数据
 * @param {Object} formData 自定义表单调用getData返回的数据
 */
// function formatSaveData(formData) {
//   if (formData.controls.lenth !== 0) {
//     // 主表key
//     let mainTableKey = '';
//     // 主表数据
//     const mainTableData = {};
//     // 从表数据
//     let childTableData = {};
//     // 从表位置
//     const childStartPosition = {};
//     // 遍历主从表对应的组件列表
//     formData.controls.forEach(item => {
//       const { tag } = item;
//       // 过滤主从表数据, 根据数据有无tag属性
//       if (typeof tag === 'object') {
//         // 当前是主表，过滤类型非LabelValue类型的
//         if (tag.Master && tag.DisposeType !== 'LabelValue') {
//           mainTableKey = tag.ObjTypeName;
//           mainTableData[item.tag.InfoType] = item?.value || '';
//         }
//       }
//     });

//     // 从表数据是否存在
//     if (formData.datasets?.data) {
//       // 从表名称key Map
//       const tableNameMap = new Map();
//       // 数据集id => 从表的表名
//       for (const [templateId, templateConfig] of Object.entries(formData.datasets.template)) {
//         templateConfig.forEach(item => {
//           if (item.tag) {
//             tableNameMap.set(templateId, item.tag.ObjTypeName);
//           }
//         });
//       }

//       // 所有行数据 数据集id => [{...行数据}, {...行数据}]
//       const childTableMap = new Map();
//       formData.datasets.data.forEach(itemData => {
//         // 此处的rows代表一个数据集
//         const { id, rows } = itemData;
//         // 子项为一行
//         // 叶子子项为每一个单元格
//         childStartPosition[`${tableNameMap.get(id)}_StartPosition`] = [];
//         // 遍历数据集中的每页
//         rows.forEach((page, pageNum) => {
//           // 遍历当前页中的每行， 一行设置一个startPosition的id
//           page.forEach(line => {
//             // 获取每一行的单元格值
//             const lineObj = {
//               // 设置分页
//               PAGENUMBER: pageNum + 1,
//             };
//             line.forEach(cell => {
//               lineObj[cell.tag.InfoType] = cell.value;
//             });
//             if (!childTableMap.has(id)) {
//               childTableMap.set(id, [lineObj]);
//             } else {
//               childTableMap.get(id).push(lineObj);
//             }
//             childStartPosition[`${tableNameMap.get(id)}_StartPosition`].push(id);
//           });
//         });
//       });

//       // 数据集id => [{...行数据}, {...行数据}]
//       for (const [key, value] of childTableMap.entries()) {
//         if (tableNameMap.has(key)) {
//           childTableData = { [tableNameMap.get(key)]: value, ...childTableData };
//         }
//       }
//     }
//     // 保存数据项
//     return {
//       [mainTableKey]: mainTableData,
//       ...childTableData,
//       ...childStartPosition,
//     };
//   }
// }

export { formatLoadData };
