<!-- 生物样品内标工作液制备表 -->
<template>
	<div>
		<div class="detail-container">
			<div class="detail-title"><img src="@/assets/images/detail-title.png">{{ formData.bdmc }}<img
					src="@/assets/images/detail-title.png" /></div>
			<div class="detail-content">
				<div class="content">
					<BaseInfoFormPackage fieldItemLabel="template.common.baseInfo" label="template.common.baseInfo"
						ref="baseInfoRef" :formConfig="baseInfoFormConfig" :formData="formData" />
					<TableList label="template.common.sjInfo" :columns="sjColumns" :dataSource="resourceSj" />
					<TableList label="template.common.instrumentInfo" :columns="yqColumns" :dataSource="yqResource" />
					<BaseInfoFormPackage fieldItemLabel="template.common.storageCondition"
						label="template.common.storageCondition" ref="storageConditionRef"
						:formConfig="storageFormConfig" :formData="formData" />
					<LineLabel label="template.common.operationSteps" />
					<div v-if="fillType === 'preFill'" class="mt-20">
						<el-button type="primary" @click="handleAddParalle">{{ $t('template.common.xzpxpz')
							}}</el-button>
						<el-button type="primary" @click="handleAddLadder">{{ $t('template.common.xzjtpz')
							}}</el-button>
					</div>

					<!-- 阶梯配制区域 -->
			<div v-for="(ladderConfig, ladderIndex) in formData.ladderConfigs" :key="'ladder_' + ladderConfig.id">

						<div class="template-form-item">
							<div class="config-header">
								<div>{{ $t('template.common.jtpz') }}</div>
								<el-button v-if="fillType === 'preFill'" type="text" icon="el-icon-delete"
						@click="deleteConfig('ladderConfigs', ladderConfig)">{{ $t('template.common.deleteBtn')
						}}</el-button>
							</div>
							<BaseInfoFormPackage @onRegentSubmit="(e) => onRegentSubmit('ladder', ladderIndex, e)"
								@beforeReagentSubmit="(data) => onBeforeReagentSubmit(data,ladderIndex, ladderConfig)"
								:ref="`ladderStepFormPackageRef_${ladderIndex}`" :formConfig="ladderStepFormConfig"
								:formData="ladderConfig" :fieldItemLabel="$t('template.common.jtpz')"
								@blur="(e) => onHandleBlur(e,'ladder', ladderIndex)"
								@select = "(e) => onHandleBlur(e,'ladder', ladderIndex)"
								:prefixKey="'ladder_' + ladderIndex" />
							<CustomTable @blur="(e) => onHandleTableBlur('ladder', ladderIndex, e)"
								:ref="`ladderStepTableRef_${ladderIndex}`" :showOperation="fillType === 'actFill' || fillType === 'preFill'"
								:columns="ladderStepColumns" :formData="ladderConfig"
								@beforeSaveRecord = "(data) => onBeforeSaveRecord(data,'ladder',ladderIndex)"
								@headerSelectChange="(data)=>onHeaderSelectChange(data,'ladder',ladderIndex)"
								:prefixKey="'ladder_' + ladderIndex" :fieldItemLabel="$t('template.common.jtpz')">
								<template slot="operation" slot-scope="{ row, rowIndex, columns }">
									<TableOpertaion @printTag="(e) => printTag(e, 'ladderConfigs', ladderIndex)"
										@startConfig="(val) => startConfig(val, 'ladderConfigs', ladderIndex)"
										@configComplete="(val) => configComplete(val, 'ladderConfigs', ladderIndex)"
										@subPackageSubmit="(val) => subPackageSubmit(val, 'ladderConfigs', ladderIndex)"
										:fillType="fillType" :row="row" :rowIndex="rowIndex" :columns="columns"
										@deleteRow="(rowIndex) => deleteRow(rowIndex, 'ladder', ladderIndex)">
									</TableOpertaion>
								</template>
							</CustomTable>

							<Step class="mt-0 s-container" :ref="`ladderStepRef_${ladderIndex}`"
								:formData="ladderConfig.ladderStepData" :fieldItemLabel="$t('template.common.jtpz')"
								:prefixKey="'ladder_' + ladderIndex"></Step>
						</div>
					</div>

					<!-- 平行配制区域 -->
			<div :label="$t('template.common.pxpz')"
				v-for="(paralleConfig, paralleIndex) in formData.paralleConfigs"
				:key="'paralle_' + paralleConfig.id">

						<div class="template-form-item">
							<div class="config-header">
								<div>{{ $t('template.common.pxpz') }}</div>
								<el-button v-if="fillType === 'preFill'" type="text" icon="el-icon-delete"
						@click="deleteConfig('paralleConfigs', paralleConfig)">{{ $t('template.common.deleteBtn')
						}}</el-button>
							</div>
							<BaseInfoFormPackage @clickable="(e) => handleClickable('paralle', paralleIndex, e)"
								:ref="`paralleStepFormPackageRef_${paralleIndex}`" :formConfig="paralleStepFormConfig"
								:formData="paralleConfig" :prefixKey="'paralle' + paralleIndex"
								:fieldItemLabel="$t('template.common.pxpz')" />
							<CustomTable @blur="(e) => onHandleTableBlur('paralle', paralleIndex, e)"
								:ref="`paralleStepTableRef_${paralleIndex}`" :showOperation="fillType === 'actFill' || fillType === 'preFill'"
								:columns="paralleStepColumns"
								@bodySelectChange = "bodySelectChange"
								@headerSelectChange="(data)=>onHeaderSelectChange(data,'paralle',paralleIndex)"
								@beforeReagentSubmit="(data) => onTableBeforeReagentSubmit(data, paralleIndex, paralleConfig)"
								@onRegentSubmit="(data) => onTableRegentSubmit('paralle', paralleIndex, data)"
								:formData="paralleConfig" :prefixKey="'paralle' + paralleIndex"
								:fieldItemLabel="$t('template.common.pxpz')">
								<template slot="operation" slot-scope="{ row, rowIndex, columns }">
									<TableOpertaion @printTag="(e) => printTag(e, 'paralleConfigs', paralleIndex)"
										@startConfig="(val) => startConfig(val, 'paralleConfigs', paralleIndex)"
										@configComplete="(val) => configComplete(val, 'paralleConfigs', paralleIndex)"
										@subPackageSubmit="(val) => subPackageSubmit(val, 'paralleConfigs', paralleIndex)"
										:fillType="fillType" :row="row" :rowIndex="rowIndex" :columns="columns"
										@deleteRow="(rowIndex) => deleteRow(rowIndex, 'paralle', paralleIndex)">
									</TableOpertaion>
								</template>
							</CustomTable>

							<Step class="mt-0 s-container" :ref="`paralleStepRef_${paralleIndex}`"
								:formData="paralleConfig.paralleStepData" :fieldItemLabel="$t('template.common.pxpz')"
								:prefixKey="'paralle' + paralleIndex"></Step>
						</div>
					</div>
					<BaseInfoFormPackage fieldItemLabel="template.common.remark" label="template.common.remark"
						ref="remarkRef" :formConfig="remarkConig" :formData="formData" />

				</div>
			</div>
			<!-- <button @click="onSave">保存</button> -->
		</div>
	</div>
</template>

<script>
import { EventBus } from "@/utils/eventBus";
import BaseInfoFormPackage from "@/components/Template/BaseInfoFormPackage";
import LineLabel from "@/components/Template/LineLabel";
import TableList from "@/components/Template/Table";
import Step from "@/components/Template/Step";
import templateMixin from "../../mixins/templateMixin.js";
import CustomTable from '@/components/Template/CustomTable.vue';
import SelectReagentDialog from '../../dialog/SelectReagentDialog.vue';
import TableOpertaion from "@/components/Template/operation/TableOpertaion.vue";
import { getExpireDate, duplicateResource } from "@/utils/index.js";
import { getuuid } from "@/utils/index.js";
import { isCommonUnit } from "@/utils/conTools";
import moment from "moment";
import { addTj, uniqeResource, uniqeResourceOne, addDecimals } from "@/utils/calUnitTools";
import { getLadderColumnsConfig, getParallelColumnsConfig, getLadderFormConfig, getBaseInfoFormConfig, getRemarkFormConfig, getStorageConditionFormConfig, getParalleStepFormConfig } from "../../formConfig/paralleAndLadderConfig.js";
export default {
	name: "SP00456",
	components: { BaseInfoFormPackage, LineLabel, TableList, Step, CustomTable, SelectReagentDialog, TableOpertaion },
	mixins: [templateMixin],
	props: {
		fillType: {
			type: String,
			default: 'preFill',
		},
		sn: {
			type: String,
			default: '',
		},
	},
	watch: {
		fillType: {
			immediate: true,
			handler(v) {
				console.log(v, "fillType")
			}
		},
	},
	computed: {
		// 存储条件表单配置
		storageFormConfig() {
			return getStorageConditionFormConfig(this);
		},
		// 备注表单配置
		remarkConig() {
			return getRemarkFormConfig();
		},
		// 试验基本信息表单配置
		baseInfoFormConfig() {
			return getBaseInfoFormConfig(this);
		},
		paralleStepFormConfig() {
			return getParalleStepFormConfig(this);
		},
		// 操作步骤表单配置
		ladderStepFormConfig() {
			return getLadderFormConfig(this);
		},
		paralleStepColumns() {
			return getParallelColumnsConfig(this);
		},
		// 阶梯配置表格列配置
		ladderStepColumns() {
			return getLadderColumnsConfig(this);
		},
	},
	data() {
		return {
			subSolutionVisible: false,
			currentSubKey: "",//当前点击的子项key
			currentType: "",//当前点击的类型
			currentRowIndex: "",//当前点击的行索引
			dataSource: [],
			currentTableIndex: "",//当前点击的表格索引
			currentTableKey: "",//当前点击的表格key
			targetAcSolutionFromTable: true,//是否从表格中获取实际原始溶液浓度
			currentRowData: {},//当前点击的行数据
		};
	},
	mounted() {
		const formData = this.getFormDataByTemplateData();
		if (this.fillType === "actFill") {
			setTimeout(() => {
				this.handleUpdateCode(formData);
			}, 0);
		}
	},
	methods: {
		onBeforeSaveRecord(data,type,configIndex){
			if(type === "ladder"){
				const formFields = this.$refs[`ladderStepFormPackageRef_${configIndex}`][0]?.getFilledFormData();
				this.onCommonVerifyNdException(formFields,data);
			}
		},
		bodySelectChange(data){
			this.paralleUpdateTargetStartSolutionVolume(data.item,data.headerSelectFields);
		},
		//平行配置更新体积
		paralleUpdateTargetStartSolutionVolume(item,headerSelectFields){
			const volumne = item.targetStartSolutionConcentration;
			const subTargetStartSolution = item.targetStartSolutionConcentrationPrecision;
			const params = {
				headerSelectFields,
				subTargetStartSolution
			}
			if (volumne) {
				this.updateTargetStartSolutionVolume(item, volumne,params);
			}
		},
		onHandleBlur(e,type,configIndex){
			const {targetStartSolution,subTargetStartSolution} = e;
			const {stepTableFormData,headerSelectFields} = this.$refs[`ladderStepTableRef_${configIndex}`][0]?.getFilledFormData();
			const params = {
				subTargetStartSolution,
				headerSelectFields
			}
			this.batchUpdateTargetStartSolutionVolume(stepTableFormData,targetStartSolution,params)
		},
		//选择table header下拉框也要更新体积
		onHeaderSelectChange(data,type,configIndex){
			const {key, headerSelectFields,dataSource=[]} = data;
			const keys = [
				'targetStartSolutionVolumeUnit',
				'targetDiluentVolumeUnit',
				'targetSolutionConcentrationUnit',
				'targetSolutionVolumeUnit',
			]
			console.log(key,"key")
			if(keys.includes(key)){
				if(type === 'ladder'){
					const {targetStartSolution,subTargetStartSolution} = this.$refs[`ladderStepFormPackageRef_${configIndex}`][0]?.getFilledFormData();
					const params = {
						subTargetStartSolution,
						headerSelectFields
					}
					this.batchUpdateTargetStartSolutionVolume(dataSource,targetStartSolution,params)
				}else{
					dataSource.forEach(item => {
						this.paralleUpdateTargetStartSolutionVolume(item,headerSelectFields);
					})
				}
				
			}
		},
		//分装
		subPackageSubmit(data, configType, index) {
			const { fzsj, rowData, headerSelectFields } = data;
			const { fzList = [], dw = "", mybh } = fzsj;
			if (fzList && fzList.length > 0) {
				const list = fzList.map((item) => {
					return {
						bh: mybh +item.preCode + item.subCode,
						kc: item.num,
						kcdw: dw,
					}
				})
				let postData = {
					studyId: this.formData.studyId,
					studyFormId: this.formData.id,
					bh: mybh,
					nd: rowData.actSolutionConcentration || 0,
					nddw: headerSelectFields.actSolutionConcentrationUnit,
					studySubjectId: this.formData.studySubjectId,
					studyId: this.formData.studyId,
					studyFormId: this.formData.id,
					list: list
				}
				this.subPackageRequest(postData);
			}
		},
		startConfig(val) {
			const { rowData } = val;
			console.log(rowData, "rowData")
			let postData = {
				bh: rowData.targetSolutionCode + rowData.subTargetSolutionCode,
				studySubjectId: this.formData.studySubjectId,
				studyId: this.formData.studyId,
				studyFormId: this.formData.id,
			}
			this.startConfigRequest(postData);
		},
		configComplete(val) {
			const { rowData, headerSelectFields } = val;
			//计算实际目标溶液体积(实际起始溶液体积+实际稀释液体积)
			const { total, unit } = addTj([rowData.actStartSolutionVolume, rowData.actDiluentVolume], [headerSelectFields.actStartSolutionVolumeUnit, headerSelectFields.actDiluentVolumeUnit])
			debugger
			let postData = {
				mc: null,
				bh: rowData.targetSolutionCode + rowData.subTargetSolutionCode,
				nd: rowData.actSolutionConcentration,//实际目标溶液浓度
				nddw: headerSelectFields.actSolutionConcentrationUnit,
				studySubjectId: this.formData.studySubjectId,
				studyId: this.formData.studyId,
				studyFormId: this.formData.id,
				kc: total,
				kcdw: unit,
			}
			this.configCompleteRequest(postData);
		},
		//标签打印
		printTag(e, configType, index) {
			const { nickName, name } = this.$store.getters;
			const { printCode, row, type } = e;
			const currentForm = this.formData[configType][index];
			const { stepStorageCondition, startDate, expireDate, paralleStepStorageCondition } = currentForm;
			const targetSolutionExpirationDate = row.targetSolutionExpirationDate;
			const lang = this.$i18n.locale;
			const printConfig = {
				"品名": "暂时还不知道品名是哪个字段",
				"存储条件": stepStorageCondition || paralleStepStorageCondition,
				"配制日期": moment(startDate).format("YYYY-MM-DD"),
				"有效期至": moment(targetSolutionExpirationDate || expireDate).format("YYYY-MM-DD HH:mm"),
				"配置者": lang === "zh_CN" ? nickName : name,
				//type==="subPackage"从分装打印过来的，
				//type==="row" 从列表上点过来的
				"编号": type === "subPackage" ? printCode : (row.targetSolutionCode + row.subTargetSolutionCode),
			}
			console.log(printConfig, "printConfig")
			EventBus.$emit('showTagPrintDialog', { printConfig })
		},
		// 为指定的表单数据数组分配编号
		async assignNumbersToTableData(config) {
			return new Promise(async (resolve, reject) => {
				const configs = this.formData[config]
				const { startDate } = this.formData;
				// 检查paralleConfigs中的paralleTableFormData数组
				if (configs && configs.length > 0) {
					for (let i = 0; i < configs.length; i++) {
						const ref = config === "paralleConfigs" ? `paralleStepTableRef_${i}` : `ladderStepTableRef_${i}`;
						const { stepTableFormData = [], effectivePeriod, effectivePeriodUnit, expireDate } = configs[i];
						if (!expireDate && config === "ladderConfigs") {
							const date = getExpireDate(startDate, effectivePeriod, effectivePeriodUnit);
							configs[i].expireDate = date;
						}
						if (stepTableFormData && stepTableFormData.length > 0) {
							const tableDataArray = stepTableFormData;
							// 检查表单数据中是否有任何一行的subTargetSolutionCode有值
							const hasAnyWithValue = tableDataArray.some(row =>
								row.subTargetSolutionCode && row.subTargetSolutionCode.trim() !== '');
							// 如果没有任何一行有值，则为所有行分配编号
							if (!hasAnyWithValue) {
								const codes = stepTableFormData.map((item) => ({ pre: item.targetSolutionCode, type: 1 }));
								const snList = await this.getLatestSnArr(codes);
								tableDataArray.forEach((row, idx) => {
									let expDate = {};
									if (config === "paralleConfigs" && !row.targetSolutionExpirationDate) {
										let date = getExpireDate(startDate, row.targetSolutionCycle, row.targetSolutionCyclePrecision);
										expDate = {
											targetSolutionExpirationDate: date
										}
									}
									this.$refs[ref][0]?.updateDataSourceByRowIndex(idx, { subTargetSolutionCode: snList[idx], ...expDate });
								});
								resolve()
							} else {
								reject()
							}

						}
					}
				}
			})

		},

		async handleUpdateCode() {
			Promise.all([this.assignNumbersToTableData("ladderConfigs"), this.assignNumbersToTableData("paralleConfigs")
			]).then(() => {
				//通知后端保存数据
				const params = {
					type: "fieldChanged",
					newRecord: null,
					resourceList: null,
				}
				EventBus.$emit('onModifyRecord', params,)
			})
		},
		//新增平行配制
		handleAddParalle() {
			// 初始化平行配制配置列表
			if (!this.formData.paralleConfigs) {
				this.$set(this.formData, 'paralleConfigs', []);
			}
			// 添加新的平行配制配置
			this.formData.paralleConfigs.push({
				id: getuuid(),
				paralleStepData: [],
				paralleTableFormData: [],
				showParalleConfig: true
			});
		},
		//新增阶梯配制
		handleAddLadder() {
			// 初始化阶梯配制配置列表
			if (!this.formData.ladderConfigs) {
				this.$set(this.formData, 'ladderConfigs', []);
			}

			// 添加新的阶梯配制配置
			this.formData.ladderConfigs.push({
				id: getuuid(),
				ladderStepData: [],
				ladderTableFormData: [],
				showLadderConfig: true
			});
		},
		// 删除阶梯配制配置
		deleteConfig(type, config) {
			const configIndex = this.formData[type].findIndex(config => config.id === config.id);
			if (configIndex !== -1) {
				// 创建新数组，确保响应式更新
				const newConfigs = [...this.formData[type]];
				newConfigs.splice(configIndex, 1);
				this.$set(this.formData, type, newConfigs);
				this.$nextTick(() => {
					//通知后端保存数据
					const params = {
						type: "fieldChanged",
						newRecord: null,
						resourceList: null,
					}
					EventBus.$emit('onModifyRecord', params,)
				})
			}
		},
		// 添加表格行
		handleAddRow(type, rowIndex, configIndex = 0) {
			const tableRef = type === 'ladder' ?
				this.$refs[`ladderStepTableRef_${configIndex}`] :
				this.$refs[`paralleStepTableRef_${configIndex}`];
			if (tableRef && tableRef[0].addRow) {
				tableRef[0].addRow({});
			}
		},
		// 删除表格行
		deleteRow(rowIndex, type, configIndex = 0) {
			// 根据类型删除对应的表格行
			if (type === 'ladder') {
				const tableRef = this.$refs[`ladderStepTableRef_${configIndex}`];
				if (tableRef) {
					tableRef[0].deleteRow(rowIndex);
				}
			} else if (type === 'paralle') {
				const tableRef = this.$refs[`paralleStepTableRef_${configIndex}`];
				if (tableRef) {
					tableRef[0].deleteRow(rowIndex);
				}
			}
		},
		getLadderNdParamsByIndex(configIndex){
			const { headerSelectFields = [] } = this.$refs[`ladderStepTableRef_${configIndex}`][0].getFilledFormData();
			const subTargetAcSolutionUnit = this.$refs[`ladderStepFormPackageRef_${configIndex}`][0]?.getFormDataByKey("subTargetAcSolutionUnit");//获取实际起始溶液浓度
			return {
				targetStartSolutionUnit:subTargetAcSolutionUnit,
				headerSelectFields
			}
		},
		getParalleNdParamsByIndex(item,configIndex){
			const { headerSelectFields = [] } = this.$refs[`paralleStepTableRef_${configIndex}`][0].getFilledFormData();
			const subTargetAcSolutionUnit = item.subTargetAcSolutionUnit || "";//获取实际起始溶液浓度单位
			return {
				targetStartSolutionUnit:subTargetAcSolutionUnit,
				headerSelectFields
			}
		},

		// 表格失去焦点事件
		onHandleTableBlur(type, configIndex, e) {
			const { colKey = "", item, rowIndex,headerSelectFields } = e;
			if (colKey === "targetStartSolutionConcentration" || colKey === "targetSolutionVolume" || colKey === "targetSolutionConcentration" || colKey === "targetStartSolutionVolumePrecision" || colKey === "targetDiluentVolumePrecision") {
				if (type === "ladder") {
					const {targetStartSolution,subTargetStartSolution} = this.$refs[`ladderStepFormPackageRef_${configIndex}`][0]?.getFilledFormData();
					const params = {
						subTargetStartSolution,
						headerSelectFields
					}
					if (targetStartSolution) {
						this.updateTargetStartSolutionVolume(item, targetStartSolution,params);
					}
				} else if (type === "paralle") {
					this.paralleUpdateTargetStartSolutionVolume(item,headerSelectFields);
				}
			} else if (colKey === "actStartSolutionVolume" || colKey === "actDiluentVolume") {//实际起始溶液体积和实际目标溶液体积
				if (type === "ladder") {
					const targetAcSolution = this.$refs[`ladderStepFormPackageRef_${configIndex}`][0]?.getFormDataByKey("targetAcSolution");//获取实际起始溶液浓度
					const params = this.getLadderNdParamsByIndex(configIndex);
					if (targetAcSolution) {
						const volResult = this.updateSjmbrynd(item, targetAcSolution,params);
						if (!volResult) {
							return
						}
						this.$refs[`ladderStepTableRef_${configIndex}`][0]?.updateDataSourceByRowIndex(rowIndex, {
							actSolutionVolume: volResult.actVol,
							actSolutionConcentration: volResult.actNd,
						});
					}
				} else if (type === "paralle") {
					const targetAcSolution = item.targetAcSolution || 0;//获取实际起始溶液浓度
					const params = this.getParalleNdParamsByIndex(item,configIndex);
					if (targetAcSolution) {
						const volResult = this.updateSjmbrynd(item, targetAcSolution,params);
						if (!volResult) {
							return
						}
						this.$refs[`paralleStepTableRef_${configIndex}`][0]?.updateDataSourceByRowIndex(rowIndex, {
							actSolutionVolume: volResult.actVol,
							actSolutionConcentration: volResult.actNd,
						});
					}
				}

			}
		},

		onTableBeforeReagentSubmit(data){
			const {selectData, callback, key, rowData} = data;
			if(key === "actStartSolutionCode" && !isCommonUnit(selectData.row.nddw,[rowData.targetStartSolutionConcentrationPrecision])){//选择起始源溶液需要同步更新table的变更记录。
				callback.prevent('浓度单位与预制不符，请重新选择或申请废止并重新预制。');
			}
		},
		//平行配置 table选择试剂确定弹窗
		onTableRegentSubmit(type, configIndex, data) {
			const { selectInfo, rowIndex, key, rowData } = data;
			const { row, selectedId } = selectInfo;
			if (key === "actStartSolutionCode") {//实际原始溶液编号点击事件
				const tableRef = this.$refs[`paralleStepTableRef_${configIndex}`][0];
				const params = this.getParalleNdParamsByIndex(rowData,configIndex);
				if (tableRef) {
					const volResult = this.updateSjmbrynd(rowData, row.nd,params);
					//第一次选择溶液的时候，可能其他值没填入，就需要先把浓度和code一起更新
					tableRef.updateDataSourceByRowIndex(rowIndex, {
						actStartSolutionCode: selectedId,
						targetAcSolution: row.nd,
						subTargetAcSolutionUnit: row.nddw,
					})
					if (!volResult) {
						return
					}
					tableRef.updateDataSourceByRowIndex(rowIndex, {
						actSolutionVolume: volResult.actVol,
						actSolutionConcentration: volResult.actNd,
					})
				}
			}
		},

		//选择试剂提交事件
		onRegentSubmit(type, rowIndex, data) {
			const { selectInfo, key } = data;
			const { row } = selectInfo;
			if (key) {
				const ref = type === "ladder" ? "ladderStepFormPackageRef_" : "paralleStepFormPackageRef_"
				const packageRef = this.$refs[`${ref}${rowIndex}`][0];
				if (key === "subStartSolution") {
					packageRef.updateFormData("targetAcSolution", row.nd);
					packageRef.updateFormData("subTargetAcSolutionUnit", row.nddw);
					packageRef.onValueChangeCompareTo("targetAcSolution", row.nd, "targetStartSolution");
					packageRef.onValueChangeCompareTo("subTargetAcSolutionUnit", row.nddw, "subTargetStartSolution");
					this.updateTableNd(row, rowIndex);
				}
			}
		},
		updateRecord() {
			this.$nextTick(() => {
				EventBus.$emit('onModifyRecord', {
					type: "fieldChanged",
					newRecord: null,
					resourceList: null,
				},)
			})
		},
		//选择实际的时候更新table的浓度
		updateTableNd(row, rowIndex) {
			const { stepTableFormData = [], headerSelectFields = [] } = this.$refs[`ladderStepTableRef_${rowIndex}`][0].getFilledFormData();
			const newData = JSON.parse(JSON.stringify(stepTableFormData));
			const params = this.getLadderNdParamsByIndex(rowIndex);
			// 遍历数据，按要求更新起始溶液编号
			newData.forEach((item, index) => {
				let initNd = row.nd;//起始浓度是上一条记录的实际目标溶液浓度
				if (index === 0) {
					item.startSolutionCode = row.bh;
				} else {
					item.startSolutionCode = newData[index - 1].targetSolutionCode + newData[index - 1].subTargetSolutionCode;
					initNd = newData[index - 1].actSolutionConcentration;
				}
				const volResult = this.updateSjmbrynd(item, initNd,params);
				if (!volResult) {
					return
				}

				item.actSolutionVolume = volResult.actVol;
				item.actSolutionConcentration = volResult.actNd;
				// 更新stepTableRef组件的数据
			})
			this.$refs[`ladderStepTableRef_${rowIndex}`][0].updateDataSource(newData);

		},
		//只做校验
		async validFields() {
			// 构建需要验证的引用数组
			let refsToValidate = ["baseInfoRef", "storageConditionRef", "remarkRef"];

			// 添加阶梯配制相关的引用
			if (this.formData.ladderConfigs && this.formData.ladderConfigs.length > 0) {
				for (let i = 0; i < this.formData.ladderConfigs.length; i++) {
					refsToValidate.push(`ladderStepFormPackageRef_${i}`);
					refsToValidate.push(`ladderStepTableRef_${i}`);
					refsToValidate.push(`ladderStepRef_${i}`);
				}
			}

			// 添加平行配制相关的引用
			if (this.formData.paralleConfigs && this.formData.paralleConfigs.length > 0) {
				for (let i = 0; i < this.formData.paralleConfigs.length; i++) {
					refsToValidate.push(`paralleStepFormPackageRef_${i}`);
					refsToValidate.push(`paralleStepTableRef_${i}`);
					refsToValidate.push(`paralleStepRef_${i}`);
				}
			}
			return await this.validFormFields(refsToValidate);
		},
		getFilledFormData() {
			const baseData = this.$refs.baseInfoRef.getFilledFormData();
			const conditionData = this.$refs.storageConditionRef.getFilledFormData();

			// 获取所有阶梯配制数据
			const ladderConfigsData = [];
			if (this.formData.ladderConfigs && this.formData.ladderConfigs.length > 0) {
				for (let i = 0; i < this.formData.ladderConfigs.length; i++) {
					const id = this.formData.ladderConfigs[i].id;
					const ladderFormData = this.$refs[`ladderStepFormPackageRef_${i}`][0].getFilledFormData();
					const ladderTableFormData = this.$refs[`ladderStepTableRef_${i}`][0].getFilledFormData();
					const ladderStepData = this.$refs[`ladderStepRef_${i}`][0].getFilledFormData();

					ladderConfigsData.push({
						...ladderFormData,
						...ladderTableFormData,
						ladderStepData: ladderStepData.stepData,
						showLadderConfig: true,
						id
					});
				}
			}

			// 获取所有平行配制数据
			const paralleConfigsData = [];
			if (this.formData.paralleConfigs && this.formData.paralleConfigs.length > 0) {
				for (let i = 0; i < this.formData.paralleConfigs.length; i++) {
					const id = this.formData.paralleConfigs[i].id;
					const paralleFormData = this.$refs[`paralleStepFormPackageRef_${i}`][0].getFilledFormData();
					const paralleTableFormData = this.$refs[`paralleStepTableRef_${i}`][0].getFilledFormData();
					const paralleStepData = this.$refs[`paralleStepRef_${i}`][0].getFilledFormData();

					paralleConfigsData.push({
						...paralleFormData,
						...paralleTableFormData,
						paralleStepData: paralleStepData.stepData,
						showParalleConfig: true,
						id
					});
				}
			}

			const remarkData = this.$refs.remarkRef.getFilledFormData();
			return {
				...baseData,
				...conditionData,
				ladderConfigs: ladderConfigsData,
				paralleConfigs: paralleConfigsData,
				...remarkData
			}
		},
		async getFormData() {
			//先校验再获取值
			const validFlag = await this.validFields();
			if (!validFlag) {
				return false;
			}
			let content = this.getFilledFormData();
			if(content){
				const {ladderConfigs = [], paralleConfigs = []} = content;
				if(ladderConfigs.length > 0){
					const ladderConUnitDiff = ladderConfigs.every(item => isCommonUnit(item.subTargetStartSolution,[item.headerSelectFields.actSolutionConcentrationUnit, item.headerSelectFields.targetSolutionConcentrationUnit]));
					if(!ladderConUnitDiff){
						this.$message.error("起始浓度单位与目标浓度单位不符，请重新选择！");
						return false;
					}
				}
				if(paralleConfigs.length > 0){
					const paralleConUnitDiff = paralleConfigs.every(item => {
						const {stepTableFormData = [],headerSelectFields = {}} =item;
						const conUnits = stepTableFormData.map(item => item.targetStartSolutionConcentrationPrecision);
						const {actSolutionConcentrationUnit,targetSolutionConcentrationUnit} = headerSelectFields;
						return isCommonUnit(actSolutionConcentrationUnit,[...conUnits,targetSolutionConcentrationUnit]);
					});
					if(!paralleConUnitDiff){
						this.$message.error("起始浓度单位与目标浓度单位不符，请重新选择！");
						return false;
					}
				}
			}
			return content;
		},
		getResource() {
			let content = this.getFilledFormData();
			//生成resource
			let tmpResource = []
			if (this.fillType === "actFill") {
				debugger
				//阶梯配置
				if (content.ladderConfigs && content.ladderConfigs.length > 0) {
					for (let i = 0; i < content.ladderConfigs.length; i++) {
						let ladderConfigs = content.ladderConfigs[i]
						let stepTableFormData = ladderConfigs.stepTableFormData
						for (let j = 0; j < stepTableFormData.length; j++) {

							//分装
							let fzTotal = 0//分装总量
							let fzsj = stepTableFormData[j].fzsj
							if (fzsj && fzsj.fzList) {
								for (let k = 0; k < fzsj.fzList.length; k++) {
									let fzItem = fzsj.fzList[k]
									tmpResource.push({
										mc: null,
										bh: fzsj.mybh + fzItem.preCode + fzItem.subCode,
										ph: null,
										nd: stepTableFormData[j].actSolutionConcentration,
										nddw: ladderConfigs.headerSelectFields.actSolutionConcentrationUnit,
										ndz: stepTableFormData[j].actSolutionConcentration + ladderConfigs.headerSelectFields.actSolutionConcentrationUnit,
										ly: 'ELN配制',
										sxrq: ladderConfigs.expireDate,
										kc: fzItem.num,
										kcdw: fzsj.dw,
										type: null,
										elnType: this.product,
										syl: null,
										syldw: ladderConfigs.headerSelectFields.actSolutionVolumeUnit,
										yxzq: ladderConfigs.effectivePeriod,
										yxzqdw: ladderConfigs.effectivePeriodUnit,
									})
									fzTotal = addDecimals(fzTotal, fzItem.num)
								}
							}
							//生成
							//计算实际目标溶液体积(实际起始溶液体积+实际稀释液体积)
							const { total, unit } = addTj([stepTableFormData[j].actStartSolutionVolume, stepTableFormData[j].actDiluentVolume], [ladderConfigs.headerSelectFields.actStartSolutionVolumeUnit, ladderConfigs.headerSelectFields.actDiluentVolumeUnit])
							tmpResource.push({
								mc: null,
								bh: stepTableFormData[j].targetSolutionCode + stepTableFormData[j].subTargetSolutionCode,
								ph: null,
								ndz: stepTableFormData[j].actSolutionConcentration + ladderConfigs.headerSelectFields.actSolutionConcentrationUnit,
								nd: stepTableFormData[j].actSolutionConcentration,
								nddw: ladderConfigs.headerSelectFields.actSolutionConcentrationUnit,
								ly: 'ELN配制',
								sxrq: ladderConfigs.expireDate,
								kc: total,
								kcdw: unit,
								type: null,
								elnType: this.product,
								syl: fzTotal > 0 ? fzTotal : null,
								syldw: fzTotal > 0 ? fzsj.dw : unit,
								yxzq: ladderConfigs.effectivePeriod,
								yxzqdw: ladderConfigs.effectivePeriodUnit,
							})
							//起始源溶液 
							tmpResource.push({
								mc: null,
								bh: ladderConfigs.subStartSolution,
								ph: null,
								nd: null,
								nddw: null,
								ndz: null,
								ly: null,
								sxrq: null,
								kc: null,
								kcdw: null,
								type: 1,
								syl: stepTableFormData[j].actStartSolutionVolume,
								syldw: ladderConfigs.headerSelectFields.actStartSolutionVolumeUnit,
								yxzq: null,
								yxzqdw: null,
							})
							//稀释液 
							tmpResource.push({
								mc: null,
								bh: ladderConfigs.subSolution,
								ph: null,
								nd: null,
								nddw: null,
								ndz: null,
								ly: null,
								sxrq: null,
								kc: null,
								kcdw: null,
								type: 1,
								syl: stepTableFormData[j].actDiluentVolume,
								syldw: ladderConfigs.headerSelectFields.actDiluentVolumeUnit,
								yxzq: null,
								yxzqdw: null,
							})
						}
					}
				}
				//平行配置
				if (content.paralleConfigs && content.paralleConfigs.length > 0) {
					for (let i = 0; i < content.paralleConfigs.length; i++) {
						let paralleConfigs = content.paralleConfigs[i]
						let stepTableFormData = paralleConfigs.stepTableFormData
						for (let j = 0; j < stepTableFormData.length; j++) {
							//分装
							let fzTotal = 0//分装总量
							let fzsj = stepTableFormData[j].fzsj
							if (fzsj && fzsj.fzList) {
								for (let k = 0; k < fzsj.fzList.length; k++) {
									let fzItem = fzsj.fzList[k]
									tmpResource.push({
										mc: null,
										bh: fzsj.mybh + fzItem.preCode + fzItem.subCode,
										ph: null,
										ndz: stepTableFormData[j].actSolutionConcentration + paralleConfigs.headerSelectFields.actSolutionConcentrationUnit,
										nd: stepTableFormData[j].actSolutionConcentration,
										nddw: paralleConfigs.headerSelectFields.actSolutionConcentrationUnit,
										ly: 'ELN配制',
										sxrq: paralleConfigs.expireDate,
										kc: fzItem.num,
										kcdw: fzsj.dw,
										type: null,
										elnType: this.product,
										syl: null,
										syldw: paralleConfigs.headerSelectFields.actSolutionVolumeUnit,
										yxzq: paralleConfigs.effectivePeriod,
										yxzqdw: paralleConfigs.effectivePeriodUnit,
									})
									fzTotal = addDecimals(fzTotal, fzItem.num)
								}
							}
							//生成
							const { total, unit } = addTj([stepTableFormData[j].actSolutionVolume, stepTableFormData[j].actDiluentVolume], [paralleConfigs.headerSelectFields.actSolutionVolumeUnit, paralleConfigs.headerSelectFields.actDiluentVolumeUnit])
							tmpResource.push({
								mc: null,
								bh: stepTableFormData[j].targetSolutionCode + stepTableFormData[j].subTargetSolutionCode,
								ph: null,
								nd: stepTableFormData[j].actSolutionConcentration,
								ndz: stepTableFormData[j].actSolutionConcentration + paralleConfigs.headerSelectFields.actSolutionConcentrationUnit,
								nddw: paralleConfigs.headerSelectFields.actSolutionConcentrationUnit,
								ly: 'ELN配制',
								sxrq: stepTableFormData[j].targetSolutionExpirationDate,
								kc: total,
								kcdw: unit,
								type: null,
								elnType: this.product,
								syl: fzTotal > 0 ? fzTotal : null,
								syldw: fzTotal > 0 ? fzsj.dw : unit,
								yxzq: stepTableFormData[j].targetSolutionCycle,
								yxzqdw: stepTableFormData[j].targetSolutionCyclePrecision,
							})
							//稀释液 
							tmpResource.push({
								mc: null,
								bh: paralleConfigs.subSolution,
								ph: null,
								nd: null,
								nddw: null,
								ndz: null,
								ly: null,
								sxrq: null,
								kc: null,
								kcdw: null,
								type: 1,
								syl: stepTableFormData[j].actDiluentVolume,
								syldw: paralleConfigs.headerSelectFields.actDiluentVolumeUnit,
								yxzq: null,
								yxzqdw: null,
							})
						}
					}
				}
			}
			if (tmpResource.length > 0) {
				tmpResource = uniqeResourceOne(tmpResource)
			}
			//使用的试剂、仪器
			const stepResource = this.getStepResource()
			this.resourceTmp = uniqeResource(tmpResource, stepResource.sjResource || [])
			this.yqResourceTmp = stepResource.yqResource || []
			return this.resourceTmp;
		},
		getStepResource() {
			const sjResource = [], yqResource = [];
			if (this.formData.paralleConfigs && this.formData.paralleConfigs.length > 0) {
				for (let i = 0; i < this.formData.paralleConfigs.length; i++) {
					const paralleResource = this.$refs[`paralleStepRef_${i}`][0].getStepResource();
					sjResource.push(...paralleResource.sjResource);
					yqResource.push(...paralleResource.yqResource);
				}
			}
			if (this.formData.ladderConfigs && this.formData.ladderConfigs.length > 0) {
				for (let i = 0; i < this.formData.ladderConfigs.length; i++) {
					const ladderResource = this.$refs[`ladderStepRef_${i}`][0].getStepResource();
					sjResource.push(...ladderResource.sjResource);
					yqResource.push(...ladderResource.yqResource);
				}
			}
			//去重
			const { sj, yq } = duplicateResource(sjResource, yqResource)
			return { sjResource: sj, yqResource: yq };
		},
		async onSave() {
			const formData = this.getStepResource();
			console.log(formData, "formData")
		}
	}
};
</script>
<style rel="stylesheet/scss" lang="scss">
.mt-20 {
	margin-top: 20px;
}

.config-section {
	margin-bottom: 20px;
	padding: 15px;
	border: 1px solid #ebeef5;
	border-radius: 4px;
	background-color: #fafafa;
}

.config-header {
	display: flex;
	justify-content: space-between;
	align-items: center;
	margin-bottom: 15px;
	font-weight: bold;
	font-size: 16px;
	color: #303133;
}

.config-header .el-button {
	color: #f56c6c;
	font-size: 14px;
}

.config-header .el-button:hover {
	color: #f78989;
}

.mt-0 {
	margin-top: 0;
}

.s-container {
	box-shadow: none !important;
	padding: 24px 0 !important;
}
</style>