import { useRef, useEffect, useState, useCallback, useMemo } from "react";
import { history } from "umi";
import { Toast, Input, Tabs, Selector, Grid, Image, Button, Checkbox, Switch, Dialog } from "antd-mobile";
import { AddOutline, MinusOutline, EditFill } from "antd-mobile-icons";
import commonConfig from "@/utils/config";
import * as commonServices from "@/services/services";
import * as commonFunc from "@/components/Common/commonFunc";
import * as commonBusiness from "@/components/Common/commonBusiness";
import styles from "./quotationDetail.less";
import SelectInput from "../components/SelectInput";
import * as commonUtils from "@/utils/utils";
import Typesetting from "@/components/Common/Typesetting/typesetting";
import DynamicSVG from "@/components/Common/BoxDesignCompontent/svg";
import ShowImgM from "@/components/Common/BoxShowImgMaterial/indexNew";
import CommonBase from "@/components/Common/CommonBase";
import { cloneDeep } from "lodash";
import moment from "moment";
const QuickQuoteEvent = props => {
  const { location } = props;
  const selectedNode = JSON.parse(location.state).quotationData;
  const addState = {};
  const [masterConfig, setMasterConfig] = useState(null);
  const { sModelsId } = props;

  addState.onGetFilterState = (state, bInit) => {
    const result = Object.keys(state).reduce((pre, cur) => {
      if (cur.endsWith("Column") || cur.endsWith("Config") || ["formData", "treeData", "downAbleConfigs", "finishedConfigs"].includes(cur)) {
        return pre;
      }

      pre[cur] = state[cur];
      return pre;
    }, {});

    const { slaveData = [], manyData = [] } = result;
    const materialInfoFields = [
      "sMaterialsName",
      "sMaterialsNo",
      "sMaterialsId",
      "sAuxiliaryUnit",
      "sMaterialsUnit",
      "bReel",
      "dCoefficient",
      "bInverse",
      "sMaterialsStyle",
      "sComputeId",
      "sReComputeId",
      "dGramWeight",
      "sReConversionComputeId",
      "sConversionComputeId",
      "sMaterialsType",
      "bComMaterials",
      "dWlcd",
      "dWlkd",
    ];
    const slaveDataNew = bInit
      ? slaveData.map(item => {
          const { materialsInfo = [], sMaterialsName } = item;
          if (!materialsInfo.length && sMaterialsName) {
            return {
              ...item,
              materialsInfo: [
                materialInfoFields.reduce((pre, cur) => {
                  pre[cur] = item[cur];
                  return pre;
                }, {}),
              ],
            };
          } else {
            return item;
          }
        })
      : slaveData;

    const manyDataNew = manyData.map(item => {
      delete item.manyData;
      return item;
    });

    return { ...result, slaveData: slaveDataNew, manyData: manyDataNew };
  };

  const sQuoConfig = commonUtils.convertStrToObj(props.masterData.sQuoConfig, {});

  const [state, setState] = useState(addState.onGetFilterState(sQuoConfig, true));

  const { formData = [] } = state;
  const { bLinkFieledClick } = props;
  const [hideBackBtn, setHideBackBtn] = useState(false);
  const [enabled, setEnabled] = useState(props.enabled);

  useEffect(() => {
    const configUrl = `${commonConfig.server_host}business/getModelBysId/${sModelsId}?sModelsId=${sModelsId}`;
    commonServices
      .getService(props.token, configUrl)
      .then(async ({ data: masterReturn }) => {
        if (masterReturn.code === 1) {
          const formData = masterReturn.dataset.rows[0].formData;
          const masterConfig = formData.find(x => x.sTbName === "QuoQuotationmaster");
          const processConfig = formData.find(x => x.sTbName === "QuoQuotationprocess");
          const materialsConfig = formData.find(x => x.sTbName === "QuoQuotationmaterials");
          const slaveConfig = formData.find(x => x.sTbName === "QuoQuotationslave");
          const controlConfig = formData.find(x => x.sTbName === "QuoQuotationcontrol");
          let colorConfigGrdVisible;
          const colorConfigTrue = formData.find(item => item.sTbName === "quoquotationparam");
          if (commonUtils.isNotEmptyObject(colorConfigTrue)) {
            colorConfigGrdVisible = colorConfigTrue.bGrdVisible;
            if (colorConfigGrdVisible) {
              colorColumn = commonFunc.getHeaderConfig(colorConfigTrue, colorColumn);
            }
          }
          const colorConfig = colorConfigGrdVisible ? colorConfigTrue : "";
          /* 合版信息表 */
          const packConfig = formData.find(item => item.sTbName === "quoquotationcontrolcombine");
          let checkConfig = {};
          let checkColumn = {};
          if (commonUtils.isNotEmptyArr(formData.filter(item => item.bGrd && item.sTbName === "sysbillcheckresult"))) {
            checkConfig = formData.find(item => item.bGrd && item.sTbName === "sysbillcheckresult");
            checkColumn = commonFunc.getHeaderConfig(checkConfig);
          }
          props.onSaveState(pre => ({
            ...pre,
            formData,
            masterConfig,
            processConfig,
            materialsConfig,
            slaveConfig,
            controlConfig,
            colorConfig,
            packConfig,
            checkConfig,
          }));
          //setState(pre => ({ ...pre, selectedNode ,formData, masterConfig, processConfig, materialsConfig, slaveConfig}));
        }
      })
      .catch(error => {});
    setState(pre => ({ ...pre, selectedNode }));
  }, []);

  useEffect(() => {
    setHideBackBtn(!bLinkFieledClick);
    setEnabled(!bLinkFieledClick || props.enabled);
  }, [bLinkFieledClick, props.enabled]);
  useEffect(() => {
    // 获取 masterConfig

    const { masterConfig, token } = props;
    const quickQuoteConfig = masterConfig?.gdsconfigformslave.find(item => item.sControlName === "BtnQuickQuote") || {};
    const { sActiveId = "172129113112117428019179600" } = quickQuoteConfig;
    const configUrls = `${commonConfig.server_host}business/getModelBysId/${sActiveId}?sModelsId=${sActiveId}`;
    commonServices.getService(props.app.token, configUrls).then(async ({ data: configReturn }) => {
      if (configReturn.code === 1) {
        const formData = configReturn.dataset.rows[0].formData;
        setState(pre => ({ ...pre, formData, masterConfig: formData[0] }));
      }
    });
  }, []);
  // 获取盒型定义配置
  useEffect(() => {
    if (!formData.length) return;
    const sBoxActiveId = formData.find(item => item.sGrd === "slave")?.gdsconfigformslave?.find(item => item.sName === "sName")?.sActiveId;
    if (!sBoxActiveId) return;
    const { token } = props;
    const configUrl = `${commonConfig.server_host}business/getModelBysId/${sBoxActiveId}?sModelsId=${sBoxActiveId}`;
    commonServices.getService(token, configUrl).then(({ data: configReturn }) => {
      if (configReturn.code === 1) {
        const formData = configReturn.dataset.rows[0].formData;
        setState(pre => ({ ...pre, boxConfig: formData[0] }));
      }
    });
  }, [formData.length]);

  // 获取column
  useEffect(() => {
    if (!formData.length) return;

    let result = {};
    for (let i = 0; i < formData.length; i++) {
      const tableConfig = formData[i];
      const { sGrd } = tableConfig;
      if (!sGrd) continue;
      const column = commonFunc.getHeaderConfig(tableConfig);
      result = {
        ...result,
        [`${sGrd}Column`]: column,
        [`${sGrd}Config`]: tableConfig,
      };
    }
    setState(pre => ({ ...pre, ...result }));
  }, [formData.length]);

  addState.onBackClick = () => {
    props.onSaveState({ masterData: { ...props.masterData, sQuoConfig: JSON.stringify(addState.onGetFilterState(state)) }, quickQuoteModel: false });
  };

  addState.onDataChange = (name, sFieldName, changeValue, sId, dropDownData, isWait) => {
    const { masterData = {}, slaveData = [], selectedNode = {} } = state;
    const extraState = {
      calcPriceFinished: false,
      manyData: [],
    };

    if (name === "master") {
      let masterDataNew = { ...masterData, ...changeValue };
      masterDataNew.handleType = masterDataNew.handleType || "update";
      masterDataNew.sId = masterDataNew.sId || commonUtils.createSid();
      if (sFieldName === "dProductQty") {
        setState(pre => ({
          ...pre,
          dProductQty: changeValue.dProductQty,
        }));
      }
      if (sFieldName === "sCustomerName") {
        masterDataNew = { ...masterDataNew, sCustomerId: changeValue.sId };
      }
      setState(pre => ({ ...pre, masterData: masterDataNew, ...extraState }));
    } else if (name.includes("slave")) {
      const boxModel = name.replace("slaveUp", "").replace("slaveDown", "");
      if (sFieldName === "sName") {
        if (!changeValue.sName) return;
        const dropDownDataSelected = dropDownData.find(item => item.sName === changeValue.sName);
        const { sColumnNameConfig, sColumnNameConfigExclusion, sColumnNameConfigPic } = dropDownDataSelected;
        const upAbleConfigsExtra = commonUtils.convertStrToObj(sColumnNameConfig, []).map(item => ({
          ...item,
          iColValue: item.iColValue || 6,
        }));
        const defaultData = commonFunc.getDefaultData({ gdsconfigformslave: upAbleConfigsExtra });
        delete defaultData.sId;
        delete dropDownDataSelected.sId;
        changeValue = {
          ...changeValue,
          ...defaultData,
          ...dropDownDataSelected,
          upAbleConfigsExtra,
          calcMethodData: commonUtils.convertStrToObj(sColumnNameConfigExclusion, []),
          boxPicData: commonUtils.convertStrToObj(sColumnNameConfigPic, []),
        };
      }

      const { selectedNode = {}, slaveConfig } = state;
      const { showName: sTreeNodeName } = selectedNode;
      const iIndex = slaveData.findIndex(item => item.sTreeNodeName === sTreeNodeName && item.sBoxModel === boxModel);
      if (name.includes("slaveDown")) {
        const dropDownDataSelected = dropDownData.find(item => item.sId === changeValue.sId);
        dropDownDataSelected && (dropDownDataSelected[sFieldName] = dropDownDataSelected.sProcessName);
        const extraRowData = {};
        // if (dropDownDataSelected.sProcessName === "胶印") {
        //   extraRowData.sPrintProcessId = dropDownDataSelected.sId;
        // }
        if (iIndex === -1) {
          slaveData.push({
            sId: commonUtils.createSid(),
            handleType: "add",
            sBoxModel: boxModel,
            sTreeNodeName,
            sBackProcessData: dropDownDataSelected === undefined ? [] : [dropDownDataSelected],
            ...extraRowData,
          });
        } else {
          const sBackProcessData = slaveData[iIndex].sBackProcessData || [];
          const iIndex1 = sBackProcessData.findIndex(item => item.value === dropDownData[0].value);
          if (iIndex1 === -1) {
            dropDownDataSelected !== undefined && sBackProcessData.push(dropDownDataSelected);
          } else {
            if (dropDownDataSelected === undefined) {
              sBackProcessData.splice(iIndex1, 1);
            } else {
              sBackProcessData[iIndex1] = dropDownDataSelected;
            }
          }
          slaveData[iIndex].sBackProcessData = sBackProcessData;

          slaveData[iIndex] = {
            ...slaveData[iIndex],
            ...extraRowData,
            handleType: slaveData[iIndex].handleType || "update",
          };
        }
      } else {
        if (iIndex === -1) {
          slaveData.push({
            ...changeValue,
            sId: commonUtils.createSid(),
            handleType: "add",
            sBoxModel: boxModel,
            sTreeNodeName,
          });
        } else {
          slaveData[iIndex] = {
            ...(sFieldName === "sName"
              ? {
                  sId: slaveData[iIndex].sId,
                  sBoxModel: boxModel,
                  sTreeNodeName,
                  ...commonFunc.getDefaultData(slaveConfig),
                }
              : slaveData[iIndex]),
            ...changeValue,
            handleType: slaveData[iIndex].handleType || "update",
          };
        }
      }
      const saveIndex = slaveData.findIndex(item => item.sTreeNodeName === selectedNode.showName && item.sBoxModel === boxModel);
      const materialStyleLength = slaveData[saveIndex].materialLength || 0;
      const materialStyleWidth = slaveData[saveIndex].materialWidth || 0;
      slaveData[saveIndex] = {
        ...slaveData[saveIndex],
        sMachineStyle: materialStyleLength + "*" + materialStyleWidth,
        dMachineQty: slaveData[saveIndex].dProductQty ? slaveData[saveIndex].dProductQty : masterData.dProductQty,
      };
      if (sFieldName === "dWlcd" || sFieldName === "dWlkd") {
        const horizontalBoxes = Math.floor(slaveData[saveIndex]?.dWlkd / slaveData[saveIndex]?.materialWidth);
        const verticalBoxes = Math.floor(slaveData[saveIndex]?.dWlcd / slaveData[saveIndex]?.materialLength);
        const newDMaterialsKQty = horizontalBoxes * verticalBoxes;
        slaveData[saveIndex] = {
          ...slaveData[saveIndex],
          dMachineQty: Math.floor(slaveData[saveIndex].dMachineQty / slaveData[saveIndex].dSinglePQty),
          dMaterialsKQty: newDMaterialsKQty,
        };
      }

      if (sFieldName === "sName") {
        slaveData[saveIndex] = {
          ...slaveData[saveIndex],
          dMaxLength: Number(selectedNode.sMachineStyle.split("*")[0]),
          dMaxWidth: Number(selectedNode.sMachineStyle.split("*")[1]),
        };
      }
      if (sFieldName === "sPrint") {
        slaveData[saveIndex] = {
          ...slaveData[saveIndex],
          sProcessId: changeValue.sId,
          sPrintProcessId: changeValue.sId,
        };
      }
      if (sFieldName === "sPrint") {
        slaveData[saveIndex] = {
          ...slaveData[saveIndex],
          dMachineWidth: slaveData[saveIndex].dWlkd,
          dMachineLength: slaveData[saveIndex].dWlcd,
        };
      }
      setState(pre => ({ ...pre, slaveData, ...extraState }));
    } else if (name === "finished") {
      const { productProcessInfo = [] } = masterData;
      const dropDownDataSelected = dropDownData.find(item => item.sId === changeValue[sFieldName]);
      dropDownDataSelected && (dropDownDataSelected[sFieldName] = dropDownDataSelected.sProcessName);
      const iIndex = productProcessInfo.findIndex(item => item.sProductClassifyId === dropDownData[0].sProductClassifyId);
      if (iIndex === -1) {
        dropDownDataSelected !== undefined && productProcessInfo.push(dropDownDataSelected);
      } else {
        if (dropDownDataSelected === undefined) {
          productProcessInfo.splice(iIndex, 1);
        } else {
          productProcessInfo[iIndex] = dropDownDataSelected;
        }
      }
      const cpProcessName = productProcessInfo.map(item => item.sProcessName).join(",");
      const masterDataNew = { ...masterData, cpProcessName, productProcessInfo };
      masterDataNew.handleType = masterDataNew.handleType || "update";
      masterDataNew.sId = masterDataNew.sId || commonUtils.createSid();
      setState(pre => ({ ...pre, masterData: masterDataNew, ...extraState }));
    }
  };

  addState.onGetAllDelData = () => {
    const {
      slaveData = [],
      slaveDelData: slaveDelDataOld = [],
      controlData = [],
      controlDelData: controlDelDataOld = [],
      materialsData = [],
      materialsDelData: materialsDelDataOld = [],
      processData = [],
      processDelData: processDelDataOld = [],
      manyqtysData = [],
      manyqtysDelData: manyqtysDelDataOld = [],
      colorData = [],
      colorDelData: colorDelDataOld = [],
      packData = [],
      packDelData: packDelDataOld = [],
    } = props;
    const addState = {
      slaveDelData: [...slaveDelDataOld, ...slaveData.map(item => ({ ...item, handleType: "del" }))],
      controlDelData: [...controlDelDataOld, ...controlData.map(item => ({ ...item, handleType: "del" }))],
      materialsDelData: [...materialsDelDataOld, ...materialsData.map(item => ({ ...item, handleType: "del" }))],
      processDelData: [...processDelDataOld, ...processData.map(item => ({ ...item, handleType: "del" }))],
      manyqtysDelData: [...manyqtysDelDataOld, ...manyqtysData.map(item => ({ ...item, handleType: "del" }))],
      colorDelData: [...colorDelDataOld, ...colorData.map(item => ({ ...item, handleType: "del" }))],
      packDelData: [...packDelDataOld, ...packData.map(item => ({ ...item, handleType: "del" }))],
    };
    return addState;
  };

  // 存草稿
  const onSaveDraft = (nextState = state, nextProps = props) => {
    const { masterData = {} } = nextState;
    const { sProductName, sProductNo, sCustomerName, sCustomerId, sCustomerNo } = masterData;
    if (!sProductName || !sCustomerName) {
      // message.info("请先填写客户名称和产品名称");
      Toast.show({
        content: "请先填写客户名称和产品名称",
      });
      return;
    }

    props.onSaveState(
      {
        ...addState.onGetAllDelData(),
        masterData: { ...nextProps.masterData, sQuoConfig: JSON.stringify(addState.onGetFilterState(nextState)) },
        slaveData: nextProps.slaveData.map(item => {
          return {
            ...item,
            sProductName: sProductName,
            sProductNo: sProductNo,
            sCustomerName: sCustomerName,
            sCustomerId: sCustomerId,
            sCustomerNo: sCustomerNo,
            handleType: "add",
          };
        }),
        controlData: nextProps.controlData.map(item => {
          return {
            ...item,
            // sPartsName: sProductName,
            handleType: "add",
          };
        }),
        materialsData: nextProps.materialsData?.map(item => {
          return {
            ...item,
            handleType: "add",
          };
        }),
        processData: nextProps.processData?.map(item => {
          return {
            ...item,
            handleType: "add",
          };
        }),
        manyqtysData: nextProps.manyqtysData?.map(item => {
          return {
            ...item,
            handleType: "add",
          };
        }),
        colorData: nextProps.colorData?.map(item => {
          return {
            ...item,
            handleType: "add",
          };
        }),
        packData: nextProps.packData?.map(item => {
          return {
            ...item,
            handleType: "add",
          };
        }),
        loading: true,
      },
      () => {
        props.onButtonClick("BtnDraft", { ...props });
      }
    );
  };

  addState.onSaveDraft = onSaveDraft;

  // 核价按钮
  addState.handleCalcPrice = async () => {
    const { masterData = {}, slaveData = [], selectedNode = {}, extraParts = {} } = state;
    if (commonUtils.isEmptyObject(selectedNode)) {
      // message.error("请先选择产品");
      Toast.show({
        icon: "fail",
        content: "请先选择产品",
      });
      return;
    }
    const mustFieldsMap = {
      sCustomerName: "请先选择客户名称",
      sProductName: "请先输入产品名称",
      sProductUnit: "请先输入产品单位",
      dLength: "请先输入长度",
      dWidth: "请先输入宽度",
      dProductQty: "请先输入数量",
    };

    const checkResult = Object.keys(mustFieldsMap).find(item => masterData[item] === undefined);
    if (checkResult) {
      Toast.show({
        icon: "fail",
        content: mustFieldsMap[checkResult],
      });
      return;
    }

    const { bBox, showName, sId } = selectedNode;
    let { sAllPartsName } = selectedNode;
    if (!sAllPartsName) {
      sAllPartsName = showName;
    }

    const slaveRowDataList =
      slaveData
        .filter(item => item.sTreeNodeName === showName && item.materialsInfo && !item.materialsInfo.some(x => !x.sMaterialsName))
        .filter(item => (bBox ? item.sName : true))
        .filter(item => item.sPrint !== undefined && item.sColor !== undefined && item.iPrintModePo !== undefined) || [];
    if (!slaveRowDataList.length) {
      // message.error("请至少保证一个部件的材料信息填写完整");
      Toast.show({
        icon: "fail",
        content: "请至少保证一个部件的材料信息填写完整",
      });
      return;
    }

    setState(pre => ({ ...pre, calcPriceLoading: true, calcPriceFinished: false }));

    const { sModelsId, token, sBoxModel } = props;
    const extraPartsList = extraParts[showName] || [];
    const sAllPartsNameList = [...sAllPartsName.split(","), ...extraPartsList];

    const masterDataNew = {
      ...masterData,
      cpProcessName: masterData.cpProcessName || "",
      productProcessInfo: masterData.productProcessInfo?.map(item => ({ ...item, sProcessId: item.sId })) || [],
      sProductClassifyId: sId,
      sProductName1: masterData.sProductName,
      dProductWidth: masterData.dWidth,
      dProductLength: masterData.dLength,
      dProductHeight: masterData.dHeight,
      sConsigneeMobile: masterData.sMobile,
      sConsignee: masterData.sContacts,
      sProductStyle:
        masterData.dHeight !== undefined
          ? `${masterData.dLength}*${masterData.dWidth}*${masterData.dHeight}`
          : `${masterData.dLength}*${masterData.dWidth}`,
    };
    const paramMap = {
      bQuotation: true,
      ...masterDataNew,
      product: masterDataNew,
      sPartsStyle: "",
      partsInfo: sAllPartsNameList
        .map(partName => {
          const temp = {
            ...slaveData.find(item => item.sTreeNodeName === showName && item.sBoxModel === partName),
          };
          return temp;
        })
        .filter(item => commonUtils.isNotEmptyObject(item) && item.materialsInfo && item.materialsInfo.length)
        .map(item => {
          // slaveData里的sMaterialRate sMaterialsStyle

          return {
            ...Object.keys(item).reduce((pre, cur) => {
              if (typeof item[cur] !== "object") {
                pre[cur] = item[cur];
              }
              return pre;
            }, {}),
            dPartsQty: masterData.dProductQty,
            iPositiveColor: Number(item.sColor),
            sPartsName: item.sBoxModel,
            materialsInfo: item.materialsInfo?.filter(x => commonUtils.isNotEmptyObject(x)),
            iPrintModePo: Number(item.value),
            processInfo:
              item.sBackProcessData?.map(item => ({
                ...item,
                sProcessId: item.sId,
              })) || [],
          };
        }),
    };
    paramMap.sPartsStyle = (paramMap.partsInfo[0].dPartsLength || 0) + "*" + (paramMap.partsInfo[0].dPartsWidth || 0);
    if (paramMap.sPartsStyle === "0*0") {
      delete paramMap.sPartsStyle;
    }
    // 先用好的数据模拟后面在调整
    // const newParamMap = JsonData;
    const url = `${commonConfig.server_host}calculationStd/countMoney?sModelsId=${sModelsId}`;
    const dataReturn = (await commonServices.postValueService(token, paramMap, url)).data;

    if (dataReturn.code === 1) {
      // const { app, sModelsId } = props;
      // const { slaveConfig, masterData: masterData1, processConfig, materialsConfig } = state;

      const { slaveConfig, masterData: masterData1, materialsConfig, processConfig, sModelsId, app } = props;
      const { productClassify, partsNewInfo = [], productProcessInfo, partsInfo: partsOldInfo } = dataReturn.dataset.rows[0];

      const slaveData = [];
      const controlData = [];
      const materialsData = [];
      let processData = [];
      let tableDataRow = {};
      for (const item of slaveConfig.gdsconfigformslave) {
        tableDataRow[item.sName] = masterData[item.sName];
      }
      tableDataRow.sId = commonUtils.createSid();
      tableDataRow.handleType = "add";
      tableDataRow.iOrder = 1;
      tableDataRow.sParentId = masterData.sId;
      // const productIdDropDown = commonUtils.getStoreDropDownData(sModelsId, 'slave', 'sProductName');
      let productIdDropDown;
      const slaveIndex = slaveConfig.gdsconfigformslave.findIndex(item => item.sName === "sProductName");
      if (slaveIndex > -1) {
        const sqlDropDownData = await props.getSqlDropDownData(sModelsId, "slave", slaveConfig.gdsconfigformslave[slaveIndex], tableDataRow);
        productIdDropDown = sqlDropDownData.dropDownData;
      }
      const iProductIdIndex = commonUtils.isEmptyArr(productIdDropDown)
        ? -1
        : productIdDropDown.findIndex(item => item.sId === tableDataRow.sProductId);
      if (iProductIdIndex === -1) {
        tableDataRow.sProductId = tableDataRow.sProductName;
        const tableDataRowNew = { ...tableDataRow, ...masterDataNew };
        const extraProps = {
          sProductId: tableDataRowNew.sProductName,
          sProductName: tableDataRowNew.sProductName,
          sProductStyle: tableDataRowNew.sProductStyle,
          sProductUnit: tableDataRowNew.sProductUnit,
          sProductNo: tableDataRowNew.sProductNo,
          sCustomerProductNo: tableDataRowNew.sCustomerProductNo,
          sProductClassifyId: tableDataRowNew.sProductClassifyId,
          sProductClassifyName: tableDataRowNew.sProductClassifyName,
        };
        tableDataRow = { ...tableDataRow, ...extraProps };
        tableDataRow.sProductInfo = JSON.stringify(extraProps);
      } else {
        tableDataRow.sProductInfo = "";
      }
      slaveData.push(tableDataRow);
      const sInfoArr = [];
      let errorFlag = false;
      if (!commonUtils.isEmptyArr(partsOldInfo)) {
        partsOldInfo.forEach(item => {
          if (commonUtils.isNotEmptyObject(item) && !commonUtils.isEmpty(item.errorFlag)) {
            errorFlag = true;
            // props.getServiceError({ msg: `${item.sPartsName}  ${item.errorFlag}` });
            Toast.show({
              content: `${item.sPartsName}  ${item.errorFlag}`,
            });
          }
        });
      }
      if (errorFlag) {
        setState(pre => ({ ...pre, calcPriceLoading: false }));
        return;
      }

      // 返回数据赋值
      const { slaveData: stateSlaveData = [] } = state;
      partsNewInfo.forEach(item => {
        const slaveRowData = stateSlaveData.find(row => item.sTreeNodeName === row.sTreeNodeName && item.sBoxModel === row.sBoxModel);
        slaveRowData.dMachineQty = item.dMachineQty;
        slaveRowData.dAuxiliaryQty = item.materialsInfo?.[0]?.dAuxiliaryQty;
        slaveRowData.sPrint = item.sProcessName;
        setState(pre => ({ ...pre, slaveData: stateSlaveData }));
      });

      if (props.app.userinfo.sType === "sysadmin") {
        /* 超级管理员，弹窗显示接口返回的sInfo  */
        partsNewInfo.forEach(item => {
          const { sPartsName, sInfo } = item;
          const sInfoObj = {};
          sInfoObj.sPartsName = sPartsName;
          sInfoObj.sInfo = sInfo;
          sInfoArr.push(sInfoObj);
        });
      }

      const bProcessAssort = true;
      let returnProcessAssort = [];
      let processAssignAssort = "";
      let dropDownDataProcessName;
      if (bProcessAssort) {
        const dataUrl = `${commonConfig.server_host}salesorder/getProcessAssort?sModelsId=${sModelsId}`;
        const dataProcessAssort = (await commonServices.postValueService(token, {}, dataUrl)).data;
        if (dataProcessAssort.code === 1) {
          returnProcessAssort = dataProcessAssort.dataset.rows[0].processassort;
          const iIndex = processConfig.gdsconfigformslave.findIndex(item => item.sName === "sProcessName");
          if (iIndex > -1) {
            const sqlDropDownData = await props.getSqlDropDownData(sModelsId, "slave", processConfig.gdsconfigformslave[iIndex]);
            dropDownDataProcessName = sqlDropDownData.dropDownData;
            processAssignAssort = processConfig.gdsconfigformslave[iIndex].sAssignField;
          }
        }
      }
      const newCopyTo = {};
      newCopyTo.master = masterData;
      newCopyTo.slave = commonUtils.isEmptyArr(slaveData) ? {} : slaveData[0];
      for (let i = 0; i < partsNewInfo.length; i++) {
        const partInfo = partsNewInfo[i];
        const iIndex = i;
        const partsDataRow = {};
        for (const child of Object.keys(partInfo)) {
          partsDataRow[child] = partInfo[child];
        }
        partsDataRow.handleType = "add";
        partsDataRow.iOrder = iIndex + 1; /* 快速下单编号从1开始 */
        partsDataRow.sId = commonUtils.createSid();
        partsDataRow.sParentId = masterData.sId;
        // partsDataRow.sSlaveId = ' ';
        if (partsDataRow.iPrintMode !== 3) {
          partsDataRow.iOppositeColor = partsDataRow.iPositiveColor;
        }
        delete partsDataRow.dMaterialsKQty;
        delete partsDataRow.dMaterialsLength;
        delete partsDataRow.dMaterialsWidth;
        if (productClassify.bSpecialRules) {
          partsDataRow.dMachineLength = partsDataRow.dMaxMachineLength;
          partsDataRow.dMachineWidth = partsDataRow.dMaxMachineWidth;
        }
        controlData.push(partsDataRow);
        // 材料信息
        for (let i = 0; i < partInfo.materialsInfo.length; i++) {
          const materialInfo = partInfo.materialsInfo[i];
          const iOrder = i;
          let materialDataRow = {};
          for (const item of materialsConfig.gdsconfigformslave) {
            materialDataRow[item.sName] = materialInfo[item.sName];
          }
          materialDataRow.handleType = "add";
          materialDataRow.sType = "0";
          materialDataRow.iPartOrder = iIndex;
          materialDataRow.iOrder = iOrder + 1;
          materialDataRow.sPartsName = partsDataRow.sPartsName;
          materialDataRow.sId = commonUtils.createSid();
          materialDataRow.sParentId = masterData.sId;
          materialDataRow.sControlId = partsDataRow.sId;
          // materialDataRow.sSlaveId = ' ';
          materialDataRow.dMaterialsKQty = partsDataRow.iNumberofMaterial;
          const models = "Materials";
          materialDataRow = await props.onMaterialsChange(materialDataRow, sModelsId, masterData, [], "dAuxiliaryQty", app, token, models);
          materialDataRow = commonBusiness.getCalculateAllMoney(app, models, "dAuxiliaryQty", masterData, materialDataRow);
          materialsData.push(materialDataRow);
        }

        // 工序信息
        let processPrintDataRow = {};
        processPrintDataRow.handleType = "add";
        processPrintDataRow.sProcessId = partInfo.sProcessId;
        const iProcessPrintIndex = dropDownDataProcessName.findIndex(item => item.sId === processPrintDataRow.sProcessId);
        if (iProcessPrintIndex > -1) {
          processPrintDataRow = {
            ...processPrintDataRow,
            ...commonFunc.getAssignFieldValue(processAssignAssort, dropDownDataProcessName[iProcessPrintIndex], newCopyTo),
          }; // 取赋值字段
        }
        processPrintDataRow.sType = partInfo.sType;
        processPrintDataRow.iPartOrder = iIndex;
        processPrintDataRow.iOrder = 1;
        processPrintDataRow.sProcessName = partInfo.sProcessName;
        processPrintDataRow.sPartsName = partsDataRow.sPartsName;
        processPrintDataRow.dProcessInQty = partInfo.dProcessInQty;
        processPrintDataRow.dLossQty = partInfo.dLossQty;
        processPrintDataRow.dProcessOutQty = partInfo.dProcessOutQty;
        processPrintDataRow.sId = commonUtils.createSid();
        processPrintDataRow.sParentId = masterData.sId;
        processPrintDataRow.sControlId = partsDataRow.sId;
        // processPrintDataRow.sSlaveId = ' ';
        processData.push(processPrintDataRow);
        // 配套工序
        if (bProcessAssort) {
          returnProcessAssort
            .filter(item => item.sParentId === processPrintDataRow.sProcessId)
            .forEach(itemProcessAssort => {
              const iIndex = dropDownDataProcessName.findIndex(item => item.sId === itemProcessAssort.sProcessId);
              const iProcessIndex = -1;
              const iNewProcessIndex = processData.findIndex(
                item => item.sProcessId === itemProcessAssort.sProcessId && item.sControlId === partsDataRow.sId
              );
              if (iIndex > -1 && iProcessIndex < 0 && iNewProcessIndex < 0) {
                let processRow = commonFunc.getDefaultData(processConfig, newCopyTo); // 取默认值
                processRow = { ...processRow, ...commonFunc.getAssignFieldValue(processAssignAssort, dropDownDataProcessName[iIndex], newCopyTo) }; // 取赋值字段
                processRow.handleType = "add";
                processRow.sId = commonUtils.createSid();
                processRow.sParentId = masterData.sId;
                processRow.sControlId = partsDataRow.sId;
                processRow.sPartsName = partsDataRow.sPartsName;
                processRow.sType = dropDownDataProcessName[iIndex].sType;
                // processRow.sSlaveId = ' ';
                processData.push(processRow);
              }
            });
        }

        partInfo.processInfo.forEach((process, iOrder) => {
          let processAfterDataRow = {};
          for (const item of processConfig.gdsconfigformslave) {
            processAfterDataRow[item.sName] = process[item.sName];
          }
          for (const child of Object.keys(process)) {
            processAfterDataRow[child] = process[child];
          }
          processAfterDataRow.handleType = "add";
          processAfterDataRow.sProcessId = process.sProcessId;
          const iProcessAfterIndex = dropDownDataProcessName.findIndex(item => item.sId === processAfterDataRow.sProcessId);
          if (iProcessAfterIndex > -1) {
            processAfterDataRow = {
              ...processAfterDataRow,
              ...commonFunc.getAssignFieldValue(processAssignAssort, dropDownDataProcessName[iProcessAfterIndex], newCopyTo),
            }; // 取赋值字段
          }
          processAfterDataRow.sType = process.sType;
          processAfterDataRow.iPartOrder = iIndex;
          processAfterDataRow.iOrder = iOrder + 1;
          processAfterDataRow.sPartsName = partsDataRow.sPartsName;
          processAfterDataRow.sId = commonUtils.createSid();
          processAfterDataRow.sParentId = masterData.sId;
          processAfterDataRow.sControlId = partsDataRow.sId;
          // processAfterDataRow.sSlaveId = ' ';
          processData.push(processAfterDataRow);
          // 配套工序
          if (bProcessAssort) {
            returnProcessAssort
              .filter(item => item.sParentId === processPrintDataRow.sProcessId)
              .forEach(itemProcessAssort => {
                const iIndex = dropDownDataProcessName.findIndex(item => item.sId === itemProcessAssort.sProcessId);
                const iProcessIndex = -1;
                const iNewProcessIndex = processData.findIndex(
                  item => item.sProcessId === itemProcessAssort.sProcessId && item.sControlId === partsDataRow.sId
                );
                if (iIndex > -1 && iProcessIndex < 0 && iNewProcessIndex < 0) {
                  let processRow = commonFunc.getDefaultData(processConfig, newCopyTo); // 取默认值
                  processRow = { ...processRow, ...commonFunc.getAssignFieldValue(processAssignAssort, dropDownDataProcessName[iIndex], newCopyTo) }; // 取赋值字段
                  processRow.handleType = "add";
                  processRow.sId = commonUtils.createSid();
                  processRow.sParentId = masterData.sId;
                  processRow.sControlId = partsDataRow.sId;
                  processRow.sPartsName = partsDataRow.sPartsName;
                  processRow.sType = dropDownDataProcessName[iIndex].sType;
                  // processRow.sSlaveId = ' ';
                  processData.push(processRow);
                }
              });
          }
        });
      }
      productProcessInfo.forEach((process, iOrder) => {
        let processProductDataRow = {};
        for (const item of processConfig.gdsconfigformslave) {
          processProductDataRow[item.sName] = process[item.sName];
        }
        for (const child of Object.keys(process)) {
          processProductDataRow[child] = process[child];
        }
        const iProductProcessIndex = dropDownDataProcessName.findIndex(item => item.sId === processProductDataRow.sProcessId);
        if (iProductProcessIndex > -1) {
          processProductDataRow = {
            ...processProductDataRow,
            ...commonFunc.getAssignFieldValue(processAssignAssort, dropDownDataProcessName[iProductProcessIndex], newCopyTo),
          }; // 取赋值字段
        }
        processProductDataRow.handleType = "add";
        processProductDataRow.sType = "3";
        processProductDataRow.sPartsName = "";
        processProductDataRow.iPartOrder = 999;
        processProductDataRow.iOrder = iOrder + 1;
        processProductDataRow.sId = commonUtils.createSid();
        processProductDataRow.sParentId = masterData.sId;
        // processProductDataRow.sSlaveId = ' ';
        processData.push(processProductDataRow);
        // 配套工序
        if (bProcessAssort) {
          returnProcessAssort
            .filter(item => item.sParentId === processProductDataRow.sProcessId)
            .forEach(itemProcessAssort => {
              const iIndex = dropDownDataProcessName.findIndex(item => item.sId === itemProcessAssort.sProcessId);
              const iProcessIndex = -1;
              const iNewProcessIndex = processData.findIndex(item => item.sProcessId === itemProcessAssort.sProcessId);
              if (iIndex > -1 && iProcessIndex < 0 && iNewProcessIndex < 0) {
                let processRow = commonFunc.getDefaultData(processConfig, newCopyTo); // 取默认值
                processRow = { ...processRow, ...commonFunc.getAssignFieldValue(processAssignAssort, dropDownDataProcessName[iIndex], newCopyTo) }; // 取赋值字段
                processRow.handleType = "add";
                processRow.sId = commonUtils.createSid();
                processRow.sParentId = masterData.sId;
                processRow.sType = dropDownDataProcessName[iIndex].sType;
                // processRow.sSlaveId = ' ';
                processData.push(processRow);
              }
            });
        }
      });
      processData = props.sortData(controlData, processData);
      const addState = { controlSelectedRowKeys: ["0000000"] };
      if (!commonUtils.isEmptyArr(slaveData)) {
        addState.slaveSelectedRowKeys = [slaveData[0].sId];
      }

      const newState = {
        materialsConfig,
        masterData: { ...masterData1, ...masterData },
        slaveData,
        controlData,
        materialsData,
        processData,
        fastOrderModalVisible: false,
        quotationAllprogress: 0,
        materialsSelectedRowKeys: [],
        ...addState,
        sInfoArr,
        // bVisiblesInfo: !!commonUtils.isNotEmptyArr(sInfoArr),
        Loading: false,
        // quickQuoteModel: false,
      };
      delete newState.masterData.sQuoConfig;
      const masterProps = {
        ...props,
      };
      const result = await props.handleCalculation(
        false,
        { ...masterProps, ...newState, manyqtysConfig: state.manyConfig, manyqtysData: state.manyData },
        true,
        props
      );

      if (commonUtils.isEmptyObject(result)) {
        setState(pre => ({ ...pre, calcPriceLoading: false }));
        return;
      }

      const { manyqtysData = [] } = result;
      result.manyqtysData = manyqtysData.map(item => ({
        ...item,
        sParentId: newState.masterData.sId,
      }));
      setState(pre => {
        const preNew = { ...pre, manyData: result.manyqtysData, calcPriceLoading: false, calcPriceFinished: true };
        const stateNew = { ...newState, ...result };
        props.onSaveState(stateNew, () => {
          onSaveDraft(preNew, stateNew);
        });
        return preNew;
      });
    } else {
      // message.error(dataReturn.erroMsg || dataReturn.msg);
      Toast.show({
        icon: "fail",
        content: dataReturn.erroMsg || dataReturn.msg,
      });
      setState(pre => ({ ...pre, calcPriceLoading: false }));
    }
  };

  // 新报价
  addState.onAdd = () => {
    const restList = ["formData", "manyColumn", "manyConfig", "masterConfig", "slaveConfig", "slaveColumn", "treeData"];
    const stateNew = {
      ...restList.reduce((pre, cur) => {
        pre[cur] = state[cur];
        return pre;
      }, {}),
      masterData: {},
      slaveData: [],
      manyData: [],
    };
    setState(stateNew);
    props.onAdd();
  };

  // 选择盒型弹窗
  addState.onFieldPopupModal = (showConfig, name) => {
    if (showConfig.sName === "sName") {
      props.onSaveState({ boxModelSelectedModalVisible: true, currentBoxModel: name });
    }
  };

  return {
    ...props,
    onDataChange0: props.onDataChange,
    ...addState,
    hideBackBtn,
    enabled,
    state,
    setState,
    masterConfig: masterConfig && masterConfig.length ? masterConfig[0] : {},
  };
};
const handleMaterialsChange = async (tableDataRow, sModelsId, masterData, changeValue, sFieldName, app, token, models) => {
  const { sComputeId, sConversionComputeId, sReConversionComputeId } = tableDataRow;
  if (
    sFieldName === "sMaterialsNo" ||
    sFieldName === "sMaterialsName" ||
    sFieldName === "dAuxiliaryQty" ||
    sFieldName === "dReelAuxiliaryQty" ||
    sFieldName === "dConversionQty" ||
    sFieldName === "sMaterialsStyle" ||
    sFieldName === "dProductQty"
  ) {
    if (sFieldName === "dReelAuxiliaryQty") {
      if (tableDataRow.sMaterialsUnit === "吨" && tableDataRow.bReel && tableDataRow.dGramWeight > 0) {
        tableDataRow = commonBusiness.getMaterialsQty(
          app,
          { ...tableDataRow, sMaterialsStyle: tableDataRow.sReelMaterialsStyle },
          "dReelAuxiliaryQty",
          "dMaterialsQty"
        );
        tableDataRow.dAuxiliaryQty = tableDataRow.dMaterialsQty;
        tableDataRow.sMaterialsStyle =
          tableDataRow.sMaterialsStyle !== undefined && tableDataRow.sMaterialsStyle.split("*").length > 1
            ? tableDataRow.sMaterialsStyle.split("*")[0]
            : tableDataRow.sMaterialsStyle;
        tableDataRow.sAuxiliaryUnit = tableDataRow.sMaterialsUnit;
      } else if (tableDataRow.sMaterialsUnit.toUpper() === "M2" && tableDataRow.bReel) {
        tableDataRow = commonBusiness.getMaterialsQty(app, tableDataRow, "dReelAuxiliaryQty", "dMaterialsQty");
        tableDataRow.dAuxiliaryQty = tableDataRow.dReelAuxiliaryQty;
      } else {
        tableDataRow.dAuxiliaryQty = tableDataRow.dReelAuxiliaryQty;
      }
    }
    if (commonUtils.isEmpty(sComputeId) && sFieldName !== "dConversionQty") {
      if (sFieldName === "dProductQty") {
        tableDataRow = commonBusiness.getMaterialsQty(app, tableDataRow, "dProductQty", "dMaterialsQty");
      } else {
        tableDataRow = commonBusiness.getMaterialsQty(app, tableDataRow, "dAuxiliaryQty", "dMaterialsQty");
      }
    } else if (!commonUtils.isEmpty(sComputeId)) {
      tableDataRow.dMaterialsQty = await commonBusiness.getFormulaValue({
        token,
        sModelsId,
        masterData,
        tableDataRow,
        sComputeId,
      });
    }
    if (sFieldName !== "dConversionQty" && !commonUtils.isEmpty(sConversionComputeId)) {
      tableDataRow.dConversionQty = await commonBusiness.getFormulaValue({
        token,
        sModelsId,
        masterData,
        tableDataRow,
        sComputeId: sConversionComputeId,
      });
    }
  } else if (sFieldName === "dMaterialsQty") {
    const { sReComputeId } = tableDataRow;
    if (commonUtils.isEmpty(sReComputeId) && tableDataRow.bInverse) {
      tableDataRow = commonBusiness.getAuxiliaryQty(app, tableDataRow, sFieldName, "dAuxiliaryQty");
    } else if (tableDataRow.bInverse) {
      tableDataRow.dAuxiliaryQty = await commonBusiness.getFormulaValue({
        token,
        sModelsId,
        masterData,
        tableDataRow,
        sComputeId: sReComputeId,
      });
      if (commonUtils.isNotEmptyArr(tableDataRow.dAuxiliaryQty) && tableDataRow.dAuxiliaryQty !== 0) {
        tableDataRow.dProductQty = tableDataRow.dAuxiliaryQty;
      }
    }
    if (!commonUtils.isEmpty(sReConversionComputeId)) {
      tableDataRow.dConversionQty = await commonBusiness.getFormulaValue({
        token,
        sModelsId,
        masterData,
        tableDataRow,
        sComputeId: sReConversionComputeId,
      });
    }
  } else if (sFieldName === "dAuxiliaryLossQty") {
    if (commonUtils.isEmpty(sComputeId)) {
      tableDataRow = commonBusiness.getMaterialsQty(app, tableDataRow, sFieldName, "dLossQty");
    } else {
      tableDataRow.dLossQty = await commonBusiness.getFormulaValue({
        token,
        sModelsId,
        masterData,
        tableDataRow,
        sComputeId,
      });
    }
    if (!commonUtils.isEmpty(tableDataRow.dSrcSurplusAuxiliaryQty)) {
      tableDataRow.dAuxiliaryQty = tableDataRow.dSrcSurplusAuxiliaryQty - tableDataRow.dAuxiliaryLossQty;
      tableDataRow.dMaterialsQty = commonUtils.convertFixNum(tableDataRow.dSrcSurplusQty - tableDataRow.dLossQty, 6);
    }
  } else if (sFieldName === "dLossQty") {
    const { sReComputeId } = tableDataRow;
    if (commonUtils.isEmpty(sReComputeId)) {
      tableDataRow = commonBusiness.getAuxiliaryQty(app, tableDataRow, sFieldName, "dAuxiliaryLossQty");
    } else {
      tableDataRow.dAuxiliaryLossQty = await commonBusiness.getFormulaValue({
        token,
        sModelsId,
        masterData,
        tableDataRow,
        sComputeId: sReComputeId,
      });
    }
    if (!commonUtils.isEmpty(tableDataRow.dSrcSurplusAuxiliaryQty)) {
      tableDataRow.dAuxiliaryQty = tableDataRow.dSrcSurplusAuxiliaryQty - tableDataRow.dAuxiliaryLossQty;
      tableDataRow.dMaterialsQty = tableDataRow.dSrcSurplusQty - tableDataRow.dLossQty;
    }
  } else if (sFieldName === "sProcessId" || sFieldName === "sProcessNo" || sFieldName === "sProcessName") {
    const sProcessId = changeValue.sProcessId;
    const url = `${commonConfig.server_host}process/outsideprocess?sModelsId=${sModelsId}&sProcessId=${sProcessId}`;
    const dataReturn = (await commonServices.getService(token, url)).data;
    if (dataReturn.code === 1) {
      if (commonUtils.isNotEmptyArr(dataReturn.dataset.rows)) {
        tableDataRow.dMaterialsPrice = dataReturn.dataset.rows[0].dMaterialsPrice;
      }
      tableDataRow = commonBusiness.getCalculateAllMoney(app, models, "dMaterialsPrice", masterData, tableDataRow);
    }
  }
  return tableDataRow;
};
const sortData = (tableData, processData) => {
  processData.sort((g1, g2) => {
    const iIndex1 = tableData.findIndex(item => item.sId === g1.sControlId) === -1 ? 999 : tableData.findIndex(item => item.sId === g1.sControlId);
    let sPartOrder1 = `0000${iIndex1}`;
    sPartOrder1 = sPartOrder1.substring(sPartOrder1.length - 3);
    let sOrder1 = `000${g1.iOrder}`;
    sOrder1 = sOrder1.substring(sOrder1.length - 3);

    const iIndex2 = tableData.findIndex(item => item.sId === g2.sControlId) === -1 ? 999 : tableData.findIndex(item => item.sId === g2.sControlId);
    let sPartOrder2 = `0000${iIndex2}`;
    sPartOrder2 = sPartOrder2.substring(sPartOrder2.length - 3);
    let sOrder2 = `000${g2.iOrder}`;
    sOrder2 = sOrder2.substring(sOrder2.length - 3);
    return parseInt(sPartOrder1 + g1.sType + sOrder1, 10) - parseInt(sPartOrder2 + g2.sType + sOrder2, 10);
  });
  return processData;
};
// 计算数量
const handleCalculation = async (bSave, nextProps, isWait, props) => {
  const dataUrl = `${commonConfig.server_host}business/addQuotationsheet?sModelsId=${nextProps.sModelsId}`;
  const {
    masterConfig,
    slaveConfig,
    slaveDelData,
    controlConfig,
    controlDelData,
    colorConfig,
    colorData,
    colorDelData,
    materialsConfig,
    materialsDelData,
    processConfig,
    processDelData,
    app,
    manyqtysConfig,
    manyqtysDelData,
    packConfig,
    packDelData,
    manyDataCache = [],
    dQuickQuoteProductQty,
  } = nextProps;
  let { slaveData, controlData, materialsData, processData, masterData, manyqtysData, packData } = nextProps;
  const sMakePerson = masterData.sMakePerson;
  const data = [];
  data.push(commonBusiness.mergeData("master", `${masterConfig.sTbName.toLowerCase()}_Tmp`, [masterData], [], true));
  data.push(commonBusiness.mergeData("slave", `${slaveConfig.sTbName.toLowerCase()}_tmp`, slaveData, [], true));
  data.push(commonBusiness.mergeData("control", `${controlConfig.sTbName.toLowerCase()}_tmp`, controlData, [], true));
  data.push(commonBusiness.mergeData("materials", `${materialsConfig.sTbName.toLowerCase()}_tmp`, materialsData, [], true));
  data.push(commonBusiness.mergeData("process", `${processConfig.sTbName.toLowerCase()}_tmp`, processData, [], true));
  if (commonUtils.isNotEmptyObject(manyqtysConfig)) {
    data.push(
      commonBusiness.mergeData(
        "manyqtys",
        `${manyqtysConfig.sTbName.toLowerCase()}_tmp`,
        manyqtysData?.map(item => {
          delete item.manyData;
          return item;
        }),
        [],
        true
      )
    );
  }

  data.push(commonBusiness.mergeData("pack", `${packConfig.sTbName.toLowerCase()}_tmp`, packData, [], true));
  const value = { data, sClientType: "1", sGuid: masterData.sId };

  const cacheIndex = dQuickQuoteProductQty === undefined ? -1 : manyDataCache.findIndex(item => item.dManyQty === dQuickQuoteProductQty);
  if (cacheIndex === -1) {
    // message.warning("自动计算中，请稍后再试。");
    Toast.show({
      content: "自动计算中，请稍后再试。",
    });
  }
  const dataReturn = cacheIndex === -1 ? (await commonServices.postValueService(props.app.token, value, dataUrl)).data : manyDataCache[cacheIndex];
  if (dataReturn.code === 1) {
    /*   成功   */
    const valueReturn = dataReturn.dataset.rows[0];
    const masterDataArr = valueReturn[`${masterConfig.sTbName.toLowerCase()}_tmp`];
    if (commonUtils.isNotEmptyArr(masterDataArr)) {
      masterData = masterDataArr[0];
    }
    if (cacheIndex !== -1) {
      // masterData.handleType = nextProps.masterData.handleType || "update";
      masterData.sQuoConfig = nextProps.masterData.sQuoConfig;
      masterData.sFormId = nextProps.masterData.sFormId;
      masterData.sBillNo = nextProps.masterData.sBillNo;
    }
    masterData.handleType = masterData.sBillNo ? "update" : "add";
    if (masterData.handleType === "update" && !commonUtils.isEmpty(sMakePerson)) {
      masterData.sMakePerson = sMakePerson;
    }
    slaveData = valueReturn[`${slaveConfig.sTbName.toLowerCase()}_tmp`].map(item => {
      item.handleType = dQuickQuoteProductQty ? "add" : item.handleType;
      return item;
    });
    controlData = valueReturn[`${controlConfig.sTbName.toLowerCase()}_tmp`].map(item => {
      item.handleType = dQuickQuoteProductQty ? "add" : item.handleType;
      return item;
    });
    materialsData = valueReturn[`${materialsConfig.sTbName.toLowerCase()}_tmp`].map(item => {
      item.handleType = dQuickQuoteProductQty ? "add" : item.handleType;
      return item;
    });
    processData = valueReturn[`${processConfig.sTbName.toLowerCase()}_tmp`].map(item => {
      item.handleType = dQuickQuoteProductQty ? "add" : item.handleType;
      return item;
    });
    processData = props.sortData(controlData, processData);
    const addState = {};
    if (commonUtils.isNotEmptyObject(manyqtysConfig)) {
      manyqtysData = valueReturn[`${manyqtysConfig.sTbName.toLowerCase()}_tmp`]?.map((item, index) => {
        return {
          ...item,
          sId: manyqtysData[index] ? manyqtysData[index].sId : item.sId,
          handleType: dQuickQuoteProductQty ? "add" : item.handleType,
        };
      });
      if (cacheIndex === -1 && manyqtysData?.some(item => item.manyData)) {
        addState.manyDataCache = manyqtysData.map((item, index) => {
          let result = {};
          if (index === 0) {
            result = Object.keys(valueReturn).reduce((pre, cur) => {
              if (cur !== `${manyqtysConfig.sTbName.toLowerCase()}_tmp`) {
                pre[cur] = valueReturn[cur];
              }
              return pre;
            }, {});
          } else {
            result = commonUtils.convertStrToObj(item.manyData);
          }

          result[`${manyqtysConfig.sTbName.toLowerCase()}_tmp`] = cloneDeep(manyqtysData).map(item => {
            delete item.manyData;
            return item;
          });

          const { sId, sBillNo, sFormId } = masterData;
          const row = Object.keys(result).reduce((pre, cur) => {
            if (cur === `${masterConfig.sTbName.toLowerCase()}_tmp`) {
              pre[cur] = result[cur].map(item => ({
                ...item,
                sId,
                sBillNo: sBillNo || item.sBillNo,
                sFormId,
              }));
            } else if (cur.includes("_tmp")) {
              pre[cur] = result[cur].map(item => ({
                ...item,
                sParentId: sId,
                handleType: "add",
              }));
            } else {
              pre[cur] = result[cur];
            }
            return pre;
          }, {});

          return {
            code: 1,
            dManyQty: item.dManyQty,
            dataset: {
              rows: [row],
            },
          };
        });
      }
    }

    packData = valueReturn[`${packConfig.sTbName.toLowerCase()}_tmp`];
    /* 计算成功后自动调用保存 */
    if (bSave) {
      const data = [];
      data.push(commonBusiness.mergeData("master", masterConfig.sTbName, [masterData]));
      data.push(commonBusiness.mergeData("slave", slaveConfig.sTbName, slaveData, slaveDelData));
      data.push(commonBusiness.mergeData("control", controlConfig.sTbName, controlData, controlDelData));
      data.push(commonBusiness.mergeData("materials", materialsConfig.sTbName, materialsData, materialsDelData));
      data.push(commonBusiness.mergeData("process", processConfig.sTbName, processData, processDelData));

      if (commonUtils.isNotEmptyObject(manyqtysConfig)) {
        data.push(commonBusiness.mergeData("manyqtys", manyqtysConfig.sTbName, manyqtysData, manyqtysDelData));
      }

      data.push(commonBusiness.mergeData("color", colorConfig.sTbName, colorData, colorDelData));
      data.push(commonBusiness.mergeData("pack", packConfig.sTbName, packData, packDelData));
      props.onSaveData({
        data,
        sClientType: "1",
        loading: false,
        sSysLogSrcId: masterData.sId,
      },props);
      props.onSaveState({
        slaveData,
        packData,
        controlData,
        materialsData,
        processData,
        masterData,
        manyqtysData,
        ...addState,
      });
    } else {
      if (isWait) {
        return {
          slaveData,
          controlData,
          materialsData,
          processData,
          masterData,
          manyqtysData,
          loading: false,
          packData,
          ...addState,
        };
      } else {
        props.onSaveState({
          slaveData,
          controlData,
          materialsData,
          processData,
          masterData,
          manyqtysData,
          loading: false,
          packData,
          ...addState,
        });
      }
      // message.success(commonFunc.getConfigShowName(masterConfig, "BtnCalculation") + commonFunc.showMessage(app.commonConst, "handleSuccess"));
    }
  } else {
    /*   失败   */
    props.onSaveState({
      loading: false,
    });
    // this.props.getServiceError(dataReturn);
  }
};
/** 按钮操作事件 */
const handleButtonClick = async (name, props) => {
  console.log("🚀 ~ handleButtonClick ~ props:", props)
  if (name === "BtnDraft") {
    const {
      masterConfig,
      masterData,
      slaveConfig,
      slaveData,
      slaveDelData,
      controlConfig,
      controlData, // 需要
      controlDelData,
      materialsConfig,
      materialsData,
      materialsDelData,
      processConfig,
      processData,
      processDelData,
      colorConfig,
      colorData,
      colorDelData,
      packConfig,
      packData, // 需要
      packDelData,
    } = props;
    const data = [];
    slaveConfig.gdsconfigformslave.forEach(itemConfig => {
      slaveData
        .filter(itemData => itemData.handleType === "add" || itemData.handleType === "update")
        .forEach(itemData => {
          itemData.NoVerify = "NoVerify";
          const firstDataIndex = itemConfig.sName.substring(0, 1);
          if (commonUtils.isEmpty(itemData[itemConfig.sName])) {
            itemData[itemConfig.sName] =
              firstDataIndex === "s"
                ? ""
                : firstDataIndex === "d" || firstDataIndex === "i"
                ? 0
                : firstDataIndex === "b"
                ? false
                : firstDataIndex === "t"
                ? moment(new Date()).format(props.app.dateFormat)
                : undefined;
          }
        });
    });
    controlConfig.gdsconfigformslave.forEach(itemConfig => {
      controlData
        .filter(itemData => itemData.handleType === "add" || itemData.handleType === "update")
        .forEach(itemData => {
          itemData.NoVerify = "NoVerify";
          const firstDataIndex = itemConfig.sName.substring(0, 1);
          if (commonUtils.isEmpty(itemData[itemConfig.sName])) {
            itemData[itemConfig.sName] =
              firstDataIndex === "s"
                ? ""
                : firstDataIndex === "d" || firstDataIndex === "i"
                ? 0
                : firstDataIndex === "b"
                ? false
                : firstDataIndex === "t"
                ? moment(new Date()).format(props.app.dateFormat)
                : undefined;
          }
        });
    });

    materialsConfig.gdsconfigformslave.forEach(itemConfig => {
      materialsData
        .filter(itemData => itemData.handleType === "add" || itemData.handleType === "update")
        .forEach(itemData => {
          itemData.NoVerify = "NoVerify";
          const firstDataIndex = itemConfig.sName.substring(0, 1);
          if (commonUtils.isEmpty(itemData[itemConfig.sName])) {
            itemData[itemConfig.sName] =
              firstDataIndex === "s"
                ? ""
                : firstDataIndex === "d" || firstDataIndex === "i"
                ? 0
                : firstDataIndex === "b"
                ? false
                : firstDataIndex === "t"
                ? moment(new Date()).format(props.app.dateFormat)
                : undefined;
          }
        });
    });

    processConfig.gdsconfigformslave.forEach(itemConfig => {
      processData
        .filter(itemData => itemData.handleType === "add" || itemData.handleType === "update")
        .forEach(itemData => {
          itemData.NoVerify = "NoVerify";
          const firstDataIndex = itemConfig.sName.substring(0, 1);
          if (commonUtils.isEmpty(itemData[itemConfig.sName])) {
            itemData[itemConfig.sName] =
              firstDataIndex === "s"
                ? ""
                : firstDataIndex === "d" || firstDataIndex === "i"
                ? 0
                : firstDataIndex === "b"
                ? false
                : firstDataIndex === "t"
                ? moment(new Date()).format(props.app.dateFormat)
                : undefined;
          }
        });
    });

    if (commonUtils.isNotEmptyObject(packConfig)) {
      packConfig.gdsconfigformslave.forEach(itemConfig => {
        packData
          .filter(itemData => itemData.handleType === "add" || itemData.handleType === "update")
          .forEach(itemData => {
            itemData.NoVerify = "NoVerify";
            const firstDataIndex = itemConfig.sName.substring(0, 1);
            if (commonUtils.isEmpty(itemData[itemConfig.sName])) {
              itemData[itemConfig.sName] =
                firstDataIndex === "s"
                  ? ""
                  : firstDataIndex === "d" || firstDataIndex === "i"
                  ? 0
                  : firstDataIndex === "b"
                  ? false
                  : firstDataIndex === "t"
                  ? moment(new Date()).format(props.app.dateFormat)
                  : undefined;
            }
          });
      });
    }

    if (commonUtils.isNotEmptyObject(colorConfig)) {
      colorConfig.gdsconfigformslave.forEach(itemConfig => {
        colorData
          .filter(itemData => itemData.handleType === "add" || itemData.handleType === "update")
          .forEach(itemData => {
            itemData.NoVerify = "NoVerify";
            const firstDataIndex = itemConfig.sName.substring(0, 1);
            if (commonUtils.isEmpty(itemData[itemConfig.sName])) {
              itemData[itemConfig.sName] =
                firstDataIndex === "s"
                  ? ""
                  : firstDataIndex === "d" || firstDataIndex === "i"
                  ? 0
                  : firstDataIndex === "b"
                  ? false
                  : firstDataIndex === "t"
                  ? moment(new Date()).format(props.app.dateFormat)
                  : undefined;
            }
          });
      });
    }

    data.push(commonBusiness.mergeData("master", masterConfig.sTbName, [masterData]));
    data.push(commonBusiness.mergeData("slave", slaveConfig.sTbName, slaveData, slaveDelData));
    data.push(commonBusiness.mergeData("control", controlConfig.sTbName, controlData, controlDelData));
    data.push(commonBusiness.mergeData("materials", materialsConfig.sTbName, materialsData, materialsDelData));
    data.push(commonBusiness.mergeData("process", processConfig.sTbName, processData, processDelData));
    if (commonUtils.isNotEmptyObject(colorConfig)) {
      data.push(commonBusiness.mergeData("color", colorConfig.sTbName, colorData, colorDelData));
    }
    if (commonUtils.isNotEmptyObject(packConfig)) {
      data.push(commonBusiness.mergeData("pack", packConfig.sTbName, packData, packDelData));
    }
    // 核价后保存
    props.onSaveData({
      data,
      sClientType: "1",
      loading: false,
      sSysLogSrcId: masterData.sId,
      bIsUnCcg: false,
    },props);
  }
};
const handleSaveData = async (params, props) => {
  const {
    token,
    sModelsId,
    currentId,
    masterData,
    masterConfig,
    slaveConfig,
    checkConfig,
    billnosetting,
    app,
    sModelsType,
    controlConfig,
    materialsConfig,
    processConfig,
    colorConfig,
    packConfig,
    orderDetailConfig,
    dispatch,
    slaveChildConfig,
  } = props;
  const { userinfo } = app;
  const { copyTo } = app.currentPane;
  const onSendSocketMessage = props.handleSendSocketMessage;
  const BtnSave = commonFunc.showMessage(app.commonConst, "BtnSave"); /* 保存 */
  params.optName = BtnSave;
  const returnData = await commonBusiness.saveData({ token, value: params, sModelsId });
  if (commonUtils.isNotEmptyObject(returnData)) {
    if (commonUtils.isNotEmptyObject(copyTo)) {
      const { slaveData } = copyTo;
      const sIdArray = [];
      slaveData.forEach(item => {
        const redisKey = item.sSlaveId;
        sIdArray.push(redisKey);
      });
      const sId = sIdArray.toString();
      onSendSocketMessage("copyfinish", "noAction", sId, userinfo.sId, null, null);
    }
    onSendSocketMessage("release", "noAction", currentId, userinfo.sId, null, null);
    props.onSaveState({
      enabled: false,
      currentId: masterData.sId,
    });
    // 保存后更新panes,currentPane的checkedId，防止浏览器刷新时重新又变成新增。
    const iPaneIndex = app.panes.findIndex(item => item.key === app.currentPane.key);
    app.panes[iPaneIndex].checkedId = masterData.sId;
    app.currentPane.checkedId = masterData.sId;
   // dispatch({ type: "app/savePanesAndCurrentPane", payload: { panes: app.panes, currentPane: app.currentPane } });

    // if (billnosetting.bAutoCheck) {
    //   await this.handleAudit(1);
    // } else {
    //   await this.handleGetData(masterConfig, slaveConfig, checkConfig);
    //   if ((sModelsType.includes("sales/salesOrder") || sModelsType.includes("manufacture/workOrder")) && !commonUtils.isEmpty(controlConfig)) {
    //     await this.handleGetMemoData(controlConfig, materialsConfig, processConfig, colorConfig, packConfig);
    //   } else if (sModelsType === "purchase/purchaseOrder") {
    //     await this.handleGetOneMemoData("orderDetail", orderDetailConfig);
    //   } else if (sModelsType === "sales/salesSgoods" && !commonUtils.isEmpty(slaveChildConfig)) {
    //     await this.handleGetOneMemoData("slaveChild", slaveChildConfig);
    //   }
    //   if (this.props.app.currentPane.refresh !== undefined) {
    //     this.props.app.currentPane.refresh();
    //   }
    // }
    props.onSaveState({
      loading: false,
    });
    return true;
  } else {
    props.onSaveState({
      loading: false,
    });
    return false;
  }
};
const getProps = baseProps => {
  const { location, quotationData, app, sModelsId } = baseProps;
  const { token } = app;
  const [state, setState] = useState(null);
  const [isInitialized, setIsInitialized] = useState(false);
  const getSqlDropDownData = async (formId, name, showConfig, record, sKeyUpFilterName, pageNum) => {
    const url = `${commonConfig.server_host}business/getSelectLimit/${showConfig.sId}?sModelsId=${sModelsId}`;
    const body = {
      sSqlCondition: {
        sSqlCondition: "",
      },
      sKeyUpFilterName: "",
      pageNum: 1,
      pageSize: 20,
    };
    const retrunData = await commonServices.postValueService(token, body, url);
    if (retrunData.data.code === 1) {
      /*   获取数据集   */
      const { rows, totalPageCount, currentPageNo, totalCount } = retrunData.data.dataset;
      return {
        dropDownData: rows,
        totalPageCount,
        currentPageNo,
        totalCount,
      };
    }
  };
  // 定义 onSaveState 函数
  const onSaveState = (updateFunction, callback) => {
    setState(prevState => {
      let newState = prevState; // 初始状态下不修改状态
      // 确保 updateFunction 是一个函数
      if (typeof updateFunction === "function") {
        newState = updateFunction(prevState);
      }

      // 执行回调函数（如果存在）
      if (typeof callback === "function") {
        callback();
      }

      return newState; // 返回新的状态，可能未修改
    });
  };
  const { slaveData = [], packData = [], colorData = [], controlData = [], processData = [], materialsData = [] } = baseProps;

  // 在组件挂载时初始化数据
  useEffect(() => {
    if (!isInitialized) {
      const slaveRow = {
        handleType: "add",
        sId: commonUtils.createSid(),
        key: commonUtils.createSid(),
        sParentId: commonUtils.createSid(),
        sNodeId: commonUtils.createSid(),
        bDefault: false,
        iOrder: 1,
      };
      slaveData.push(slaveRow);

      const packRow = {
        sId: commonUtils.createSid(),
        handleType: "add",
        sSlaveId: commonUtils.createSid(),
        iOrder: 1,
        sParentId: commonUtils.createSid(),
        sControlId: commonUtils.createSid(),
        dProductQty: 0,
        dCombineQty: 1,
      };
      packData.push(packRow);
      const controlRow = {
        dSumPQty: 2,
        iPrintMode: 0,
        iPositiveColor: 4,
        iOppositeColor: 4,
        sSlaveId: " ",
        iPrintModePo: 2,
        handleType: "add",
        sId: commonUtils.createSid(),
        sParentId: commonUtils.createSid(),
        key: commonUtils.createSid(),
        bDefault: false,
        iOrder: 1,
        sCombinedMemo: "合版信息",
        sAllId: commonUtils.createSid(),
        dPartsQty: 0,
      };
      controlData.push(controlRow);
      setState(prevState => ({
        ...prevState,
        slaveData,
        packData,
        controlData,
        colorData,
        processData,
        materialsData,
      }));

      setIsInitialized(true);
    }
  }, [isInitialized]);
  return {
    ...baseProps,
    selectedNode: quotationData,
    manyDataCache: [],
    token: baseProps.app.token,
    getSqlDropDownData,
    onMaterialsChange: handleMaterialsChange,
    sortData,
    handleCalculation,
    onSaveState,
    onSaveData: handleSaveData,
    onButtonClick: handleButtonClick,
    ...state,
  };
};
const QuotationAllprogressDetail = baseProps => {
  const masterProps = getProps(baseProps);
  const props = QuickQuoteEvent(masterProps);
  const { selectedNode, location, quotationData, app, sModelsId } = props;
  const { showName, sUnit } = quotationData;
  const timeRef = useRef(0);

  useEffect(() => {
    const getDropDownData = async props => {
      props.setState(pre => {
        const { slaveData = [], slaveConfig } = pre;
        const addState = {};
        const defaultData = commonFunc.getDefaultData(slaveConfig);
        const slaveDataNew = slaveData.filter(item => item.sTreeNodeName === selectedNode.showName);
        if (!slaveDataNew.length) {
          const sAllPartsName = selectedNode.sAllPartsName || selectedNode.showName;
          sAllPartsName.split(",").forEach((item, index) => {
            const tempData = {
              sId: commonUtils.createSid(),
              handleType: "add",
              ...defaultData,
              sBoxModel: item,
              sTreeNodeName: selectedNode.showName,
            };
            if (selectedNode.sTypeKey === "huace") {
              if (index !== 0) {
                delete tempData.dSumPQty;
              } else {
                tempData.dSumPQty = 4;
              }
            }
            slaveDataNew.push(tempData);
          });
          addState.slaveData = slaveDataNew;
        }
        if (timeRef.current > 1) {
          addState.slaveData = slaveDataNew;
          addState.extraParts = {};
        }
        return {
          ...pre,
          ...addState,
          masterData: { ...quotationData, sProductName: showName, sProductUnit: sUnit },
          // downAbleConfigs: downAbleConfigs
          //   .filter(item => item.sType === "2")
          //   .map((item, index) => ({
          //     ...item,
          //     sName: `sParams${index}`,
          //     iColValue: item.iColValue || 4,
          //     sVisColumnName: "sProcessName",
          //   })),
          // finishedConfigs: downAbleConfigs
          //   .filter(item => item.sType === "3")
          //   .map((item, index) => ({
          //     ...item,
          //     sName: `sParams${index}`,
          //     iColValue: item.iColValue || 4,
          //     sVisColumnName: "sProcessName",
          //   })),
        };
      });
    };
    getDropDownData(props);
  }, []);
  const getSqlDropDownData = async ({ sId }) => {
    const url = `${commonConfig.server_host}business/getSelectLimit/${sId}`;
    const body = {
      sSqlCondition: {
        sProductClassifyId: selectedNode.sId,
      },
      sKeyUpFilterName: "",
      pageNum: 1,
      pageSize: 20,
    };
    const retrunData = await commonServices.postValueService(props.app.token, body, url);
    const sColumnNameConfigStr = retrunData.data?.dataset?.rows?.[0]?.sColumnNameConfig;
    // 取上机尺寸
    return commonUtils.convertStrToObj(sColumnNameConfigStr, []);
  };
  useEffect(() => {
    const getData = async props => {
      const showDownConfig = props.state.slaveConfig?.gdsconfigformslave.find(item => item.sControlName === "BtnDownConfig");
      const downAbleConfigs = await getSqlDropDownData({ ...showDownConfig });
      // downAbleConfigs.forEach((x, i) => {
      //   x.sName = "sParams" + i;
      // });
      props.setState(pre => ({
        ...pre,
        downAbleConfigs,
      }));
    };
    getData(props);
  }, [props.state.slaveConfig]);
  return (
    <div className={styles.quotationDetailBox}>
      <QuotationDetail {...props} />
    </div>
  );
};

const QuotationDetail = props => {
  const { masterConfig, masterData = {}, selectedNode = {} } = props.state;
  if (!masterConfig) return "";
  const ableConfigs = masterConfig.gdsconfigformslave.filter(item => item.sName && item.bVisible);
  // 处理长宽样式
  const viewConfigs = selectedNode?.bBox ? ableConfigs : ableConfigs.filter(x => x.sName !== "dHeight");
  const viewProps = {
    ...props,
    viewConfigs: viewConfigs,
    tableConfig: masterConfig,
    iColValueView: 24,
    viewRow: { ...masterData, sProductClassifyId: selectedNode.sId },
    tableName: "master",
  };
  return (
    <div className={styles.quotationBody}>
      <div className={styles.boxTitle}>
        {selectedNode?.showName || "Loading..."}
        <EditFill color="#BFBFBF" style={{ marginLeft: "1rem" }} />
      </div>
      <div>
        <MasterComponent {...viewProps} />
      </div>
      <div>
        <QuotationTabs {...props} quotationData={selectedNode} />
      </div>
    </div>
  );
};
const MasterComponent = props => {
  const { viewConfigs, masterData } = props;
  const customer = viewConfigs?.find(x => x.sName === "sCustomerName") || {};
  const customerProps = {
    ...props,
    itemDetail: customer,
  };
  const product = viewConfigs?.find(x => x.sName === "sProductName") || {};
  const productProps = {
    ...props,
    itemDetail: product,
  };
  const dLength = viewConfigs?.find(x => x.sName === "dLength") || {};

  const dLengthProps = {
    ...props,
    itemDetail: dLength,
  };
  const dWidth = viewConfigs?.find(x => x.sName === "dWidth") || {};
  const dWidthProps = {
    ...props,
    itemDetail: dWidth,
  };
  const dHeight = viewConfigs?.find(x => x.sName === "dHeight") || {};
  const dHeightProps = {
    ...props,
    itemDetail: dHeight,
  };
  const dProductQty = viewConfigs?.find(x => x.sName === "dProductQty") || {};
  const dProductQtyProps = {
    ...props,
    itemDetail: dProductQty,
  };
  const sProductUnit = viewConfigs?.find(x => x.sName === "sProductUnit") || {};
  const sProductUnitProps = {
    ...props,
    itemDetail: sProductUnit,
  };
  const sDeliverName = viewConfigs?.find(x => x.sName === "sDeliverName") || {};
  const sDeliverNameProps = {
    ...props,
    itemDetail: sDeliverName,
  };
  const baseProps = {
    ...props,
  };
  return (
    <div>
      <div className={styles.customer}>
        <div>{customerProps.itemDetail?.showName}</div>
        <SelectInput {...customerProps} />
      </div>
      <div className={styles.customer}>
        <div>{productProps.itemDetail?.showName}</div>
        <SelectInput {...productProps} />
      </div>
      <div className={styles.customer}>
        <div>尺寸(长*宽*高)</div>
        <div className={styles.sizeBox}>
          <div className={styles.sizeItem}>
            <div style={{ width: "70%" }}>
              <SelectInput {...dLengthProps} bCanInput={true} />
            </div>
            <div style={{ width: "30%", textAlign: "center" }}>X</div>
          </div>
          <div className={styles.sizeItem}>
            <div style={{ width: "70%" }}>
              <SelectInput {...dWidthProps} bCanInput={true} />
            </div>{" "}
            {Object.keys(dHeight).length > 0 ? (
              <div style={{ width: "30%", textAlign: "center" }}>X</div>
            ) : (
              <div style={{ width: "30%", textAlign: "center" }}>mm</div>
            )}
          </div>
          {Object.keys(dHeight).length > 0 ? (
            <div className={styles.sizeItem}>
              <div style={{ width: "70%" }}>
                <SelectInput {...dHeightProps} bCanInput={true} />
              </div>
              <div style={{ width: "30%", textAlign: "center" }}>mm</div>
            </div>
          ) : (
            ""
          )}
        </div>
      </div>
      <div className={styles.sizeBox}>
        <div className={styles.customer}>
          <div>数量</div>
          <SelectInput {...dProductQtyProps} bCanInput={true} />
        </div>
        <div className={styles.customer}>
          <div>单位</div>
          <SelectInput {...sProductUnitProps} />
        </div>
        <div className={styles.customer}>
          <div>收货方式</div>
          <SelectInput {...sDeliverNameProps} />
        </div>
      </div>
    </div>
  );
};
const QuotationTabs = props => {
  const { state } = props;
  const { selectedNode } = state;
  const sAllPartsName = selectedNode?.sAllPartsName;
  const sAllPartsNameList = sAllPartsName?.split(",");
  // sAllPartsNameList.push('+')
  const [activeKey, setActiveKey] = useState(sAllPartsNameList && sAllPartsNameList.length ? sAllPartsNameList[0] : null);

  useEffect(() => {
    // 更新父组件的状态
    props.setState(pre => ({ ...pre, boxModel: activeKey }));
  }, [activeKey]);

  const tabsProps = {
    ...props,
    boxModel: activeKey,
  };
  return (
    <Tabs
      activeKey={activeKey}
      onChange={key => {
        setActiveKey(key);
      }}
    >
      {sAllPartsNameList && sAllPartsNameList.length
        ? sAllPartsNameList.map((pane, index) => (
            <Tabs.Tab key={pane} title={pane}>
              <BoxComponent {...tabsProps} paneKey={pane} />
            </Tabs.Tab>
          ))
        : ""}
    </Tabs>
  );
};

// 内容
const BoxComponent = props => {
  const { state, boxModel } = props;
  const { activeKey, slaveConfig, masterData, selectedNode, boxConfig, downAbleConfigs = [], slaveData } = state || {};
  const slaveRowData = slaveData.find(item => item.sTreeNodeName === selectedNode.showName && item.sBoxModel === boxModel) || {};
  const { sModelsId } = props;
  const [selectList, setSelectList] = useState([]);
  const [boxTypeList, setBoxTypeList] = useState([]);
  const [searchValue, setSearchValue] = useState("");
  const [boxPopup, setBoxPopup] = useState(false);
  const [boxsList, setBoxsList] = useState([]);
  const [selected, setSelected] = useState(null);
  // 获取盒型信息
  useEffect(() => {
    const sId = "17428091410008594700322758474000";
    const url = `${commonConfig.server_host}business/getSelectLimit/${sId}?sModelsId=${sModelsId}&sName=${""}`;
    const body = {
      sSqlCondition: "",
      sKeyUpFilterName: searchValue,
      pageNum: 1,
      pageSize: 20,
    };

    commonServices.postValueService(props.app.token, body, url).then(res => {
      if (res.data.code === 1) {
        const list = res.data.dataset.rows.map(x => {
          return {
            ...x,
            label: x.sName,
            value: x.sId,
          };
        });
        const boxTypeLists = Array.from(
          new Set(
            list.map(item => {
              return {
                ...item,
                label: item.sBoxType,
                value: item.sBoxType,
              };
            })
          )
        );
        // 去重
        const uniqueArray = boxTypeLists.filter((item, index, self) => index === self.findIndex(i => i.sBoxType === item.sBoxType));
        setBoxTypeList(uniqueArray);
        setSelectList(list);
      }
    });
    // 获取盒型
  }, []);

  const { sColumnNameConfig } = slaveRowData || {};
  const upAbleConfigsExtra = commonUtils.convertStrToObj(sColumnNameConfig, []).map(item => ({
    ...item,
    sValue: item.sDefault,
    iColValue: item.iColValue || 6,
  }));
  const showUpAbleConfigsExtra = upAbleConfigsExtra.filter(x => x.bVisible === 1);
  let boxList = [];
  // if(!masterData) return
  if (slaveRowData && slaveRowData.sColumnNameConfig && masterData?.dLength && masterData?.dWidth && masterData?.dHeight) {
    const slaveNewData = JSON.parse(slaveRowData.sColumnNameConfig);
    const tables = [
      { name: "盒型类别", value: slaveRowData.sBoxType, type: null },
      { name: "盒身", value: slaveRowData.sBoxBody, type: slaveRowData.sTypes },
      { name: "盒长", value: masterData.dLength ? Number(masterData.dLength) : 0, type: null },
      { name: "盒宽", value: masterData.dWidth ? Number(masterData.dWidth) : 0, type: null },
      { name: "盒高", value: masterData.dHeight ? Number(masterData.dHeight) : 0, type: null },
    ];
    const titleList1 = [
      { name: "上方盒舌", value: "dSFHS" },
      { name: "盒底组件", value: "dHDC" },
      { name: "下方盒舌", value: "dXFHS" },
      { name: "左(上)插位组件", value: "dZSCW" },
      { name: "左贴边位", value: "dZTBW" },
      { name: "左(下)插位组件", value: "dZXCW" },
      { name: "右(上)插位组件", value: "dYSCW" },
      { name: "右贴边位", value: "dYTBW" },
      { name: "右(下)插位组件", value: "dYXCW" },
    ];
    const evaluateFormula = (formula, variables) => {
      if (!formula) return 0; // 如果公式为空，返回0
      try {
        // 提取公式中的变量名
        const variableNames = formula.match(/\b[a-zA-Z_][a-zA-Z0-9_]*\b/g) || [];
        // 构建函数参数
        const params = variableNames.join(",");
        // 替换公式中的变量为实际值
        const func = new Function(params, `return ${formula}`);
        // 提取变量值
        const args = variableNames.map(name => Number(variables[name]) || 0);
        // 执行函数并返回结果
        return func(...args);
      } catch (error) {
        return 0;
      }
    };

    // 确认是竖向排列还是横向排列
    const L = masterData?.dLength;
    const W = masterData?.dWidth;
    const H = masterData?.dWidth;
    const D = masterData?.dHeight;
    const variables = {
      L,
      W,
      H,
      D,
      ...slaveRowData,
    };
    slaveNewData.forEach(x => {
      let key = 0;
      if (x.sAssignFormula) {
        key = evaluateFormula(x.sAssignFormula, variables);
      } else {
        key = slaveRowData[x.sName];
      }

      boxList.push({
        value: key,
        sName: titleList1.find(item => item.value === x.sName)?.name || "",
        isEditable: true,
        isSelect: false,
        selectValue: null,
        selectLabel: "",
        selectImage: null,
        type: x.sTypes || null,
        show: true,
        showName: x.showName, // 参数名称
      });
    });
    tables.forEach(x => {
      boxList.push({
        value: x.value,
        sName: x.name,
        isEditable: true,
        isSelect: false,
        selectValue: null,
        selectLabel: "",
        selectImage: null,
        type: x.type || null,
        show: true,
        showName: x.name, // 参数名称
      });
    });
  }

  const svgProps = {
    ...props,
    boxList,
    dSvgBoxWidth: 125,
    dSvgBoxHeight: 125,
    showNew: 1,
    isMobile: true,
  };
  // 印刷参数
  const getUpViewPropsByITag = iTag => {
    if (!slaveConfig) return;
    const config = slaveConfig.gdsconfigformslave.filter(item => {
      if (item.sName === "dSumPQty" && selectedNode.sTypeKey !== "huace") {
        return false;
      }

      return item.iTag === iTag;
    });
    let boxConfigList = [];
    if (iTag === 20) {
      const showNameKeyList = ["dZBLB", "dSBLB", "dYBLB", "dXBLB", "dZBJJ", "dYBJJ", "dSBJJ", "dXBJJ"];
      boxConfigList = boxConfig?.gdsconfigformslave?.filter(item => item.bVisible && showNameKeyList.includes(item.sName)) || [];
    }
    const newConfig = [...boxConfigList, ...config];
    return {
      ...props,
      viewConfigs: newConfig,
      tableConfig: { ...slaveConfig, gdsconfigformslave: newConfig },
      iColValueView: 24,
      viewRow: slaveRowData,
      tableName: `slaveUp${boxModel}`,
    };
  };

  // 印刷参数表单
  const upViewProps12 = getUpViewPropsByITag(12);
  // 拼板信息表单
  const upViewProps20 = getUpViewPropsByITag(20);
  const { bBox } = selectedNode;

  const upAbleConfig =
    slaveConfig?.gdsconfigformslave?.filter(item => item.iTag === 10)?.filter(item => (bBox ? true : item.sName !== "sName")) || [];
  const upViewProps = {
    ...props,
    viewConfigs: [...(Array.isArray(showUpAbleConfigsExtra) ? showUpAbleConfigsExtra : [])],
    tableConfig: {
      ...slaveConfig,
      gdsconfigformslave: [...(Array.isArray(showUpAbleConfigsExtra) ? showUpAbleConfigsExtra : [])],
    },
    iColValueView: 24,
    viewRow: slaveRowData,
    tableName: `slaveUp${boxModel}`,
  };

  // 后道参数
  const { sBackProcessData } = slaveRowData || [];
  const [downAbleConfigsNew, setDownAbleConfigsNew] = useState([]);
  useEffect(() => {
    setDownAbleConfigsNew(downAbleConfigs);
  }, [downAbleConfigs]);
  // 初始化状态，存储每个 Switch 的状态
  const [switchStates, setSwitchStates] = useState(null);
  useEffect(() => {
    if (!sBackProcessData) return;
    const newSwitchStates = downAbleConfigsNew
      .filter(item => item.sPartsName === boxModel || !item.sPartsName)
      .reduce((acc, item, index) => {
        acc[item.sName] = sBackProcessData ? sBackProcessData[index][item.sName] !== "" : false;
        return acc;
      }, {});

    setSwitchStates(newSwitchStates);
  }, [downAbleConfigsNew, boxModel]); // 依赖数组

  // 处理 Switch 变化的函数
  const handleSwitchChange = (item, val) => {
    // const dropDownData = JSON.parse(item.sChineseDropDown)
    // console.log("🚀 ~ handleSwitchChange ~ dropDownData:", dropDownData)
    // const dropDownDataSelected = dropDownData.find(item => item.sId === changeValue[sFieldName]);
    setSwitchStates({
      ...switchStates,
      [item.sName]: val,
    });
  };
  // 过滤后的数据
  const downViewConfigs = downAbleConfigsNew
    .filter(item => item.sPartsName === boxModel || !item.sPartsName)
    .map((item, i) => ({
      ...item,
      isSelect: switchStates ? switchStates[item.sName] : false,
      sName: "sParams" + i,
      sProductClassifyId: item.sId,
    }));

  const downViewProps = {
    ...props,
    viewConfigs: downViewConfigs,
    tableConfig: { ...slaveConfig, gdsconfigformslave: downAbleConfigs },
    iColValueView: 24,
    viewRow: slaveRowData,
    tableName: `slaveDown${boxModel}`,
  };

  const calcMethodData = commonUtils.convertStrToObj(slaveRowData?.sColumnNameConfigExclusion, []);
  const radioValue = calcMethodData[0]?.sCode;
  const [materialLength, setMaterialLength] = useState(0);
  const [materialWidth, setMaterialWidth] = useState(0);
  // 使用 useCallback 确保回调函数的稳定性
  const handleSaveState = useCallback(
    (length, width, slaveData, masterData, dSinglePQty, dMaterialsKQty, dProductQty, scale, dWlcd, dWlkd, innerWidth, innerHeight) => {
      // 查找符合条件的索引
      const { selectedNode } = props.state;

      const index = slaveData?.findIndex(x => x.sTreeNodeName === selectedNode.showName && x.sBoxModel === props.boxModel);
      // 判断展长展宽是否可以放下原纸
      const isDPartsLength =
        slaveData[index]?.dPartsLength < slaveData[index]?.dMaxLength && slaveData[index]?.dPartsWidth < slaveData[index]?.dMaxWidth;

      if (index !== undefined && index !== -1) {
        // 计算开数

        // 获取原始对象并创建一个新的对象进行更新
        const updatedProduct = {
          ...slaveData[index],
          materialLength: length,
          materialWidth: width,
          dMachineLength: length, // 上机长
          dMachineWidth: width, // 上机宽
          sMaterialsStyle: `${slaveData[index]?.dWlcd || 0}*${slaveData[index]?.dWlkd || 0}`, // 原纸尺寸
          sMachineStyle: `${length || slaveData[index].materialLength}*${width || slaveData[index].materialWidth}`, // 开料尺寸为计算的排版尺寸
          sMaterialRate: (((length * width) / (dWlcd * dWlkd)) * 100).toFixed(2),
          newMaterialLength: length,
          newMaterialWidth: width,
          sLayoutRate: Number(
            (
              (((length || slaveData[index].materialLength) * (width || slaveData[index].materialWidth)) /
                (slaveData[index].dMaxLength * slaveData[index].dMaxWidth)) *
              100
            ).toFixed(2)
          ),
          dWlcd: dWlcd,
          dWlkd: dWlkd,
          dMachineQty: Math.floor(dProductQty / dSinglePQty),
          dSinglePQty: dSinglePQty,
          dMaterialsKQty: dMaterialsKQty,
          scale: scale,
          dPartsLength: innerWidth,
          dPartsWidth: innerHeight,
        };
        // 更新状态
        props.setState(prevState => ({
          ...prevState,
          slaveData: slaveData.map((item, i) => (i === index ? updatedProduct : item)),
        }));
      }

      setMaterialLength(length);
      setMaterialWidth(width);
    },
    []
  );
  const onSaveDPartsLength = useCallback((innerWidth, innerHeight, slaveData) => {
    const { selectedNode } = props.state;
    const index = slaveData?.findIndex(x => x.sTreeNodeName === selectedNode.showName && x.sBoxModel === props.boxModel);
    if (index !== undefined && index !== -1) {
      const updatedProduct = {
        ...slaveData[index],
        dPartsLength: innerWidth,
        dPartsWidth: innerHeight,
        materialLength: 0,
        materialWidth: 0,
        dMachineLength: 0, // 上机长
        dMachineWidth: 0, // 上机宽
        newMaterialLength: 0,
        newMaterialWidth: 0,
        sLayoutRate: 0,
        dWlcd: 0,
        dWlkd: 0,
        dMachineQty: 0,
        dSinglePQty: 0,
        dMaterialsKQty: 0,
        scale: 1,
      };
      props.setState(prevState => ({
        ...prevState,
        slaveData: slaveData.map((item, i) => (i === index ? updatedProduct : item)),
      }));
    }
  }, []);
  const boxProps = {
    ...props,
    slaveRowData,
    dSBJJ: slaveRowData?.dXBJJ,
    dZBJJ: slaveRowData?.dYBJJ,
    radioValue: calcMethodData?.find(item => item.sCode === radioValue),
    boxWidth: 190,
    boxHeight: 150,
    textSize: 9,
    // boxPicData,
  };
  const showImgMProps = {
    ...props,
    materialLength,
    materialWidth,
    bBox: true, // 快速报价盒型展示
    width: 200,
    height: 150,
    size: 9,
  };

  const handleChange = v => {
    if (v.length) {
      const newValue = v[0];
      if (newValue === selected) {
        // 如果是再次点击已选中的项，则不取消选中
        return;
      }
      setSelected(newValue);
      const list = selectList.filter(x => x.sBoxType === newValue);
      setBoxsList(list);
      setBoxPopup(true);
    } else {
      const list = selectList.filter(x => x.sBoxType === selected);
      setBoxsList(list);
      setBoxPopup(true);
    }
  };

  const getTableCloum = (i, child) => {
    if (!sBackProcessData) return;
    const value = sBackProcessData.find(item => item[child.sName]) || {};
    if (!value) return;
    const { bSetArea, bSetQty, sName, sSetQtyUnt } = value;
    const viewConfigs = [];
    if (bSetArea) {
      viewConfigs.push({
        sName: "dManualLength",
        showName: "x",
        iColValue: bSetQty ? 8 : 12,
        placeholder: "长",
        value: value.dManualLength ? value.dManualLength + "" : "",
      });
      viewConfigs.push({
        sName: "dManualWidth",
        showName: "mm",
        iColValue: bSetQty ? 8 : 12,
        placeholder: "宽",
        value: value.dManualWidth ? value.dManualWidth + "" : "",
      });
    }
    if (bSetQty) {
      viewConfigs.push({
        sName: "dManualQty",
        showName: sSetQtyUnt || "",
        iColValue: bSetArea ? 8 : 24,
        placeholder: "数量",
        value: value.dManualQty ? value.dManualQty + "" : "",
      });
    }
    const viewProps = {
      ...props,
      viewConfigs: viewConfigs,
      tableConfig: { ...slaveConfig, gdsconfigformslave: viewConfigs },
      iColValueView: 24,
      viewRow: value,
      tableName: `slaveDown${boxModel}${sName}`,
    };
    const onDataChange = (name, sFieldName, changeValue) => {
      const iIndex = slaveData.findIndex(item => item.sId === slaveRowData.sId);
      const iIndex1 = slaveData[iIndex].sBackProcessData.findIndex(item => item[child.sName]);

      slaveData[iIndex].sBackProcessData[iIndex1][sFieldName] = changeValue;
      const { dManualLength, dManualWidth } = slaveData[iIndex].sBackProcessData[iIndex1];
      if (dManualLength !== undefined && dManualWidth !== undefined) {
        slaveData[iIndex].sBackProcessData[iIndex1].dManualValue = dManualLength * dManualWidth;
      }
      props.setState(pre => ({ ...pre, slaveData }));
    };
    return viewConfigs.length ? (
      <Grid columns={3} gap={8}>
        {viewProps.viewConfigs.map(x => (
          <Grid.Item>
            <div className={styles.customer} key={x.id || x.showName} style={{ marginTop: "0", display: "flex", alignItems: "center" }}>
              <Input
                placeholder=""
                onChange={e => {
                  onDataChange(viewProps.tableName, x.sName, e, x);
                }}
              ></Input>
              <div style={{ width: "30%", textAlign: "center" }}>{x.showName}</div>
            </div>
          </Grid.Item>
        ))}
      </Grid>
    ) : (
      ""
    );
  };
  const { loading } = props;
  // 核价事件
  const onCalcPrice = () => {
    const addState = {
      ...props.onGetAllDelData(),
      manyDataCache: [],
    };
    const data = {
      masterData: { ...props.masterData, handleType: props.masterData.handleType || "update" },
      ...addState,
    };
    props.onSaveState(
      pre => ({ ...pre, ...data }),
      () => {
        props.handleCalcPrice();
      }
    );
    // props.onSaveState(
    //   {
    //     masterData: { ...props.masterData, handleType: props.masterData.handleType || "update" },
    //     ...addState,
    //   },
    //   () => {
    //     props.handleCalcPrice();
    //   }
    // );
  };
  return (
    <div>
      <Selector
        columns={4}
        options={boxTypeList}
        style={{ "--padding": "0.8rem 0" }}
        value={selected ? [selected] : []}
        onChange={v => handleChange(v)}
      />
      <div className={styles.line}></div>
      <div>
        <Grid columns={4} gap={8}>
          {upViewProps
            ? upViewProps.viewConfigs.map(x => (
                <Grid.Item>
                  <div className={styles.customer} key={x.id || x.sBig5}>
                    <div>{x.sBig5}</div>
                    <SelectInput {...upViewProps} itemDetail={x} bCanInput={true} />
                  </div>
                </Grid.Item>
              ))
            : ""}
        </Grid>
      </div>
      <div className={styles.svgBox}>
        <div style={{ width: "9.375rem", height: "9.375rem" }}>
          <DynamicSVG {...svgProps} />
        </div>
        {slaveRowData && slaveRowData.sPackPath ? <Image src={slaveRowData.sPackPath} width={125} height={125} fit="fill" /> : ""}
      </div>
      <div>
        <div className={styles.boxTitle}>
          印刷信息
          <EditFill color="#BFBFBF" style={{ marginLeft: "1rem" }} />
        </div>
        <Grid columns={3} gap={8}>
          {upViewProps12
            ? upViewProps12.viewConfigs.map(x => (
                <Grid.Item>
                  <div className={styles.customer} key={x.id || x.showName}>
                    <div>{x.showName}</div>
                    <SelectInput {...upViewProps12} itemDetail={x} bCanInput={false} />
                  </div>
                </Grid.Item>
              ))
            : ""}
        </Grid>
      </div>
      <div>
        <div className={styles.boxTitle}>
          拼版信息
          <EditFill color="#BFBFBF" style={{ marginLeft: "1rem" }} />
        </div>

        <Grid columns={3} gap={8}>
          {upViewProps20
            ? upViewProps20.viewConfigs.map(x => (
                <Grid.Item>
                  <div className={styles.customer} key={x.id || x.showName}>
                    <div>{x.showName}</div>
                    <SelectInput {...upViewProps20} itemDetail={x} bCanInput={true} />
                  </div>
                </Grid.Item>
              ))
            : ""}
        </Grid>
      </div>
      <div className={styles.svgBox1}>
        <div style={{ width: "49%", height: "49%", position: "relative" }}>
          <Typesetting {...boxProps} onSaveStates={handleSaveState} onSaveDPartsLength={onSaveDPartsLength} />
        </div>
        <div style={{ width: "47%", height: "47%", position: "relative" }}>
          <ShowImgM {...showImgMProps} />
        </div>
      </div>
      <div>
        <MaterialsComponent {...props} slaveRowData={slaveRowData} boxModel={boxModel} />
      </div>
      <div>
        <div className={styles.boxTitle}>
          后道参数
          <EditFill color="#BFBFBF" style={{ marginLeft: "1rem" }} />
        </div>

        {downViewProps.viewConfigs.map((x, i) => (
          <div>
            <div className={styles.backBox}>
              <div className={styles.backEnd}>{x.showName}</div>
              <Switch checked={switchStates ? switchStates[x.sName] : ""} onChange={val => handleSwitchChange(x, val)} />
              <div className={styles.customer} style={{ marginTop: "0", marginLeft: "2rem", width: "40%" }}>
                {switchStates && switchStates[x.sName] ? (
                  <SelectInput {...downViewProps} itemDetail={{ ...x, sVisColumnName: "sProcessName", sDropDownType: "sql" }} downIndex={i} />
                ) : (
                  ""
                )}
              </div>
            </div>
            {getTableCloum(i, x)}
          </div>
        ))}
      </div>
      <div>
        <div className={styles.projectBtn}>
          <div className={styles.boxTitle} style={{ marginTop: "2rem" }}>
            多数量报价
            <EditFill color="#BFBFBF" style={{ marginLeft: "1rem" }} />
          </div>

          {/* <Button color="primary" fill="solid" loading={loading} onClick={props.onAdd}>
            新报价
          </Button>
          <Button
            color="primary"
            fill="solid"
            loading={loading}
            onClick={() => {
              props.onSaveDraft();
            }}
          >
            存草稿
          </Button> */}
          <div>
            <Button color="primary" fill="solid" onClick={onCalcPrice} size="small" style={{ marginRight: "1rem" }}>
              核价
            </Button>
            <Button color="success" size="small">
              确认下单数量
            </Button>
          </div>
        </div>
        <ManyComponent {...props}></ManyComponent>
      </div>
      <Dialog
        visible={boxPopup}
        closeOnAction
        onClose={() => {
          setBoxPopup(false);
        }}
        actions={[
          {
            key: "close",
            text: "关闭",
          },
        ]}
        content={
          <div>
            {boxsList.map(item => {
              return (
                <div className={styles.boxListBody}>
                  <div>
                    {item.sName}
                    <Image src={item.sPackPath} width={100} height={100}></Image>
                  </div>
                  <Button
                    color="primary"
                    fill="outline"
                    size="small"
                    onClick={val => {
                      const currentBoxModel = "slaveUp" + props.boxModel;
                      props.onDataChange(currentBoxModel, "sName", { sName: item.sName }, item.sId, boxsList);
                      setBoxPopup(false);
                    }}
                  >
                    选择
                  </Button>
                </div>
              );
            })}
          </div>
        }
      ></Dialog>
    </div>
  );
};

// 材料组件
const MaterialsComponent = props => {
  const { state, boxModel } = props;
  const { slaveConfig, slaveData = [], selectedNode = {} } = state;
  let { slaveRowData } = props;
  if (!slaveRowData) return;
  const { sParam = "" } = selectedNode;
  const sParamList = sParam.split(",");
  let materialsInfoDefaultData = sParam ? new Array(sParamList.length).fill({}).map((_, index) => ({ showName: sParamList[index] })) : [{}];
  let { materialsInfo = materialsInfoDefaultData } = slaveRowData;
  const materialsConfig = slaveConfig?.gdsconfigformslave
    .filter(item => item.iTag === 11)
    .map(item => {
      const { sName } = item;
      if (sName === "sMaterialsName") {
        return {
          ...item,
          sVisColumnName: "sMaterialsName",
          iColValue: 20,
        };
      } else if (sName === "sComMaterials") {
        return {
          ...item,
          sName: "bComMaterials",
          iColValue: 4,
        };
      } else {
        return item;
      }
    });
  const extraState = {
    calcPriceFinished: false,
    manyData: [],
  };
  return materialsInfo.map((item, index) => {
    let viewRow = { ...materialsInfo[index], sProductClassifyId: selectedNode.sId };
    viewRow = { ...viewRow, sMaterialsName0: viewRow.showName || "" };
    if (!materialsConfig) return;
    let materialsConfigNew = JSON.parse(JSON.stringify(materialsConfig));
    if (viewRow.showName) {
      const iIndex = materialsConfigNew.findIndex(item => item.sName === "sMaterialsName");
      if (iIndex !== -1) {
        materialsConfigNew[iIndex].showName = viewRow.showName;
      }
    }
    const viewProps = {
      ...props,
      viewConfigs: materialsConfigNew,
      tableConfig: { ...slaveConfig, gdsconfigformslave: materialsConfigNew },
      iColValueView: 24,
      viewRow,
      tableName: `slaveUp${boxModel}`,
      onDataChange: (name, sFieldName, changeValue, sId, dropDownData, isWait) => {
        const iIndex = slaveData.findIndex(item => item.sId === slaveRowData.sId);
        const { sMaterialsName, sMaterialsNo, sAuxiliaryUnit, sMaterialsUnit, dGramWeight, sMaterialsType, dWlkd, dWlcd } = changeValue;
        const masterials = {
          sMaterialsName,
          sMaterialsNo,
          sMaterialsId: changeValue.sId,
          sAuxiliaryUnit,
          sMaterialsUnit,
          dGramWeight,
          sMaterialsType,
          dWlkd,
          dWlcd,
        };
        if (iIndex !== -1) {
          slaveData[iIndex].materialsInfo = materialsInfo.map((item, i) => (i === index ? { ...item, ...masterials } : item));
          slaveRowData = slaveData[iIndex];
        } else {
          const { selectedNode = {} } = state;
          const { showName: sTreeNodeName } = selectedNode;

          slaveData.push({
            sId: commonUtils.createSid(),
            handleType: "add",
            sBoxModel: boxModel,
            sTreeNodeName,
            materialsInfo: materialsInfo.map((item, i) => (i === index ? { ...item, ...masterials } : item)),
          });
        }
        props.setState(pre => ({ ...pre, slaveData, slaveRowData, ...extraState }));
      },
    };

    return (
      <div>
        材料信息
        <div className={styles.materialsLine}>
          <div className={styles.selectInput} style={{ width: "50%" }}>
            <SelectInput {...viewProps} itemDetail={materialsConfigNew[0]} />
          </div>
          <div className={styles.materialBtns}>
            <div className={styles.materialBtns}>
              <span>来料</span>
              <Checkbox />
            </div>
            <Button
              color="primary"
              fill="solid"
              size="small"
              style={{ width: "1.93rem", height: "1.93rem", display: "flex", justifyContent: "center", alignItems: "center", textAlign: "center" }}
              onClick={() => {
                const iIndex = slaveData.findIndex(item => item.sId === slaveRowData.sId);
                const rowIndex = materialsInfo.findIndex((item, i) => i === index);
                const materialsInfoNew = [...materialsInfo];
                materialsInfoNew.splice(rowIndex + 1, 0, {});
                if (iIndex !== -1) {
                  slaveData[iIndex].materialsInfo = materialsInfoNew;
                } else {
                  const { selectedNode = {} } = state;
                  const { showName: sTreeNodeName } = selectedNode;
                  slaveData.push({
                    sId: commonUtils.createSid(),
                    handleType: "add",
                    sBoxModel: boxModel,
                    sTreeNodeName,
                    materialsInfo: materialsInfoNew,
                  });
                }
                slaveRowData.materialsInfo = materialsInfoNew;
                props.setState(pre => ({ ...pre, slaveData, slaveRowData, ...extraState }));
              }}
            >
              <AddOutline />
            </Button>
            <Button
              style={
                index === 0 || viewRow.showName
                  ? {
                      visibility: "hidden",
                      width: "1.93rem",
                      height: "1.93rem",
                      display: "flex",
                      justifyContent: "center",
                      alignItems: "center",
                      textAlign: "center",
                    }
                  : { width: "1.93rem", height: "1.93rem", display: "flex", justifyContent: "center", alignItems: "center", textAlign: "center" }
              }
              onClick={() => {
                const iIndex = slaveData.findIndex(item => item.sId === slaveRowData.sId);
                const rowIndex = materialsInfo.findIndex((item, i) => i === index);
                const materialsInfoNew = [...materialsInfo];
                materialsInfoNew.splice(rowIndex, 1);
                slaveData[iIndex].materialsInfo = materialsInfoNew;
                slaveRowData.materialsInfo = materialsInfoNew;
                props.setState(pre => ({ ...pre, slaveData, slaveRowData, ...extraState }));
              }}
            >
              <MinusOutline />
            </Button>
          </div>
        </div>
      </div>
    );
  });
};
// 多数量组件
const ManyComponent = props => {
  const { state, setState, enabled, loading } = props;
  const { masterData = {}, calcPriceLoading, calcPriceFinished, manyData = [] } = state;
  const [submitLoading, setSubmitLoading] = useState(false);
  const [processPercent, setProcessPercent] = useState(0);
  // 根据主表数量更改多数量表
  useEffect(() => {
    const baseCount = masterData.dProductQty || 1000;
    if (manyData[0]?.dManyQty === baseCount) return;

    const manyDataNew = Array(5)
      .fill("")
      .map((item, index) => ({
        sId: commonUtils.createSid(),
        handleType: "add",
        dManyQty: baseCount * (index + 1),
      }));
    setState(pre => ({
      ...pre,
      manyData: manyDataNew,
      manySelectedRowKeys: [manyDataNew[0].sId],
      dProductQty: baseCount,
      dQuickQuoteProductQty: baseCount,
    }));
    props.onSaveState({
      manyDataCache: [],
    });
  }, [masterData.dProductQty, manyData.length]);
  const tableProps = {
    ...commonBusiness.getTableTypes("many", { ...props, ...state }),
    fixedHeight: 185,
    enabled: false,
  };
  const { headerColumn, data } = tableProps;
  return (
    <div>
      <div className={styles.tableBox}>
        {headerColumn.map(item => {
          return <div className={styles.tableHeader}>{item.title}</div>;
        })}
      </div>
      <div>
        {data && data.length
          ? data.map(item => {
              return (
                <div className={styles.tableBox}>
                  <div className={styles.tableBody}>{item.dManyQty}</div>
                  <div className={styles.tableBody}>{item.dPrintMoney}</div>
                  <div className={styles.tableBody}>{item.dAfterProcessMoney}</div>
                  <div className={styles.tableBody}>{item.dMaterialsMoney}</div>
                  <div className={styles.tableBody}>{item.dManyPrice}</div>
                  <div className={styles.tableBody}> {item.dDiscountMoney}</div>
                </div>
              );
            })
          : ""}
      </div>
    </div>
  );
};
export default QuotationAllprogressDetail;