pig-farm-controller/internal/infra/database/seeder.go

package database

import (
	"bytes"
	"context"
	"encoding/json"
	"errors"
	"fmt"
	"os"
	"path/filepath"
	"strings"

	"git.huangwc.com/pig/pig-farm-controller/internal/infra/logs"
	"git.huangwc.com/pig/pig-farm-controller/internal/infra/models"

	"github.com/tidwall/gjson"
	"gorm.io/gorm"
)

// SeederFunc 定义了处理一种特定类型预设数据文件的函数签名。
type SeederFunc func(ctx context.Context, tx *gorm.DB, jsonData []byte) error

// isTableEmpty 检查给定模型对应的数据库表是否为空。
func isTableEmpty(tx *gorm.DB, model interface{}) (bool, error) {
	var count int64
	if err := tx.Model(model).Count(&count).Error; err != nil {
		return false, fmt.Errorf("查询表记录数失败: %w", err)
	}
	return count == 0, nil
}

// SeedFromPreset 是一个通用的数据播种函数。
// 它会读取指定目录下的所有 .json 文件，并根据文件内容中的 "type" 字段进行分发。
// 同时，它会校验所有必需的预设类型是否都已成功加载。
func SeedFromPreset(ctx context.Context, db *gorm.DB, presetDir string) error {
	seedCtx, logger := logs.Trace(ctx, ctx, "SeedFromPreset")

	// 定义必须存在的预设数据类型及其处理顺序
	// 确保 "nutrient" 在 "pig_nutrient_requirements" 之前处理，因为后者依赖于前者。
	processingOrder := []string{"nutrient", "pig_nutrient_requirements"}
	requiredTypes := make(map[string]bool)
	for _, t := range processingOrder {
		requiredTypes[t] = true
	}

	processedTypes := make(map[string]bool)
	typeToFileMap := make(map[string]string)  // 用于检测重复的 type，并存储每个 type 对应的文件路径
	groupedFiles := make(map[string][][]byte) // 按 type 分组存储 jsonData

	files, err := os.ReadDir(presetDir)
	if err != nil {
		return fmt.Errorf("读取预设数据目录 '%s' 失败: %w", presetDir, err)
	}

	// 第一阶段：读取所有文件并按 type 分组
	for _, file := range files {
		if filepath.Ext(file.Name()) != ".json" {
			continue
		}

		filePath := filepath.Join(presetDir, file.Name())
		jsonData, err := os.ReadFile(filePath)
		if err != nil {
			return fmt.Errorf("读取文件 '%s' 失败: %w", filePath, err)
		}

		dataType := gjson.GetBytes(jsonData, "type")
		if !dataType.Exists() {
			logger.Warnf("警告: 文件 '%s' 中缺少 'type' 字段，已跳过", filePath)
			continue
		}
		dataTypeStr := dataType.String()

		// 检查是否存在重复的 type
		if existingFile, found := typeToFileMap[dataTypeStr]; found {
			return fmt.Errorf("预设数据校验失败: type '%s' 在文件 '%s' 和 '%s' 中重复定义", dataTypeStr, existingFile, filePath)
		}
		typeToFileMap[dataTypeStr] = filePath // 记录该 type 对应的文件路径

		groupedFiles[dataTypeStr] = append(groupedFiles[dataTypeStr], jsonData)
	}

	// 第二阶段：按照预定义顺序处理分组后的数据
	return db.Transaction(func(tx *gorm.DB) error {
		for _, dataTypeStr := range processingOrder {
			jsonDatas, ok := groupedFiles[dataTypeStr]
			if !ok {
				// 如果是必需类型但没有找到文件，则报错
				if requiredTypes[dataTypeStr] {
					return fmt.Errorf("预设数据校验失败: 缺少必需的预设文件类型: '%s'", dataTypeStr)
				}
				continue // 非必需类型，跳过
			}

			var seederFunc SeederFunc
			switch dataTypeStr {
			case "nutrient":
				seederFunc = seedNutrients
			case "pig_nutrient_requirements":
				seederFunc = seedPigNutrientRequirements
			default:
				logger.Warnf("警告: 存在未知的 type: '%s'，已跳过", dataTypeStr)
				continue
			}

			for _, jsonData := range jsonDatas {
				// 获取原始文件路径用于错误报告
				originalFilePath := typeToFileMap[dataTypeStr]
				if err := seederFunc(seedCtx, tx, jsonData); err != nil {
					return fmt.Errorf("处理文件 (type: %s, path: %s) 时发生错误: %w", dataTypeStr, originalFilePath, err)
				}
			}
			processedTypes[dataTypeStr] = true
		}

		// 校验所有必需的类型是否都已处理
		var missingTypes []string
		for reqType := range requiredTypes {
			if !processedTypes[reqType] {
				missingTypes = append(missingTypes, reqType)
			}
		}
		if len(missingTypes) > 0 {
			return fmt.Errorf("预设数据校验失败: 缺少必需的预设文件类型: [%s]", strings.Join(missingTypes, ", "))
		}

		return nil // 提交事务
	})
}

// rawMaterialInfo 用于临时存储解析后的原料描述和价格信息。
type rawMaterialInfo struct {
	Description string
	UnitPrice   float32
}

// seedNutrients 先严格校验JSON源文件，然后以“有则跳过”的模式播种数据。
func seedNutrients(ctx context.Context, tx *gorm.DB, jsonData []byte) error {
	logger := logs.GetLogger(ctx)

	// 检查 Nutrient 表是否为空，如果非空则跳过播种
	isEmpty, err := isTableEmpty(tx, &models.Nutrient{})
	if err != nil {
		return fmt.Errorf("检查 Nutrient 表是否为空失败: %w", err)
	}
	if !isEmpty {
		logger.Info("已存在原料数据, 跳过数据播种")
		return nil
	}

	// 1. 严格校验JSON文件，检查内部重复键
	if err := validateAndParseNutrientJSON(jsonData); err != nil {
		return fmt.Errorf("JSON源文件校验失败: %w", err)
	}

	// 2. 解析简介信息
	descriptionsNode := gjson.GetBytes(jsonData, "descriptions")
	rawMaterialInfos := make(map[string]rawMaterialInfo)
	nutrientDescriptions := make(map[string]string)

	if descriptionsNode.Exists() {
		// 解析 raw_materials 描述和价格
		descriptionsNode.Get("raw_materials").ForEach(func(key, value gjson.Result) bool {
			rawMaterialInfos[key.String()] = rawMaterialInfo{
				Description: value.Get("descriptions").String(),
				UnitPrice:   float32(value.Get("unit_price").Float()),
			}
			return true
		})
		descriptionsNode.Get("nutrients").ForEach(func(key, value gjson.Result) bool {
			nutrientDescriptions[key.String()] = value.String()
			return true
		})
	}

	// 3. 将通过校验的、干净的数据写入数据库
	dataNode := gjson.GetBytes(jsonData, "data")
	dataNode.ForEach(func(rawMaterialKey, rawMaterialValue gjson.Result) bool {
		rawMaterialName := rawMaterialKey.String()
		var rawMaterial models.RawMaterial

		// 获取原料的描述和价格信息
		info := rawMaterialInfos[rawMaterialName]

		// 将 Description 和 ReferencePrice 放入 Create 对象中
		err = tx.Where(models.RawMaterial{Name: rawMaterialName}).
			FirstOrCreate(&rawMaterial, models.RawMaterial{
				Name:           rawMaterialName,
				Description:    info.Description,
				ReferencePrice: info.UnitPrice,
			}).Error
		if err != nil {
			// 返回 false 停止 ForEach 遍历
			return false
		}

		rawMaterialValue.ForEach(func(nutrientKey, nutrientValue gjson.Result) bool {
			nutrientName := nutrientKey.String()
			value := float32(nutrientValue.Float())

			var nutrient models.Nutrient
			// 将 Description 放入 Create 对象中
			err = tx.Where(models.Nutrient{Name: nutrientName}).
				FirstOrCreate(&nutrient, models.Nutrient{
					Name:        nutrientName,
					Description: nutrientDescriptions[nutrientName],
				}).Error
			if err != nil {
				// 返回 false 停止 ForEach 遍历
				return false
			}

			linkData := models.RawMaterialNutrient{
				RawMaterialID: rawMaterial.ID,
				NutrientID:    nutrient.ID,
			}
			// 使用 FirstOrCreate 确保关联的唯一性
			err = tx.Where(linkData).FirstOrCreate(&linkData, models.RawMaterialNutrient{
				RawMaterialID: linkData.RawMaterialID,
				NutrientID:    linkData.NutrientID,
				Value:         value,
			}).Error
			if err != nil {
				// 返回 false 停止 ForEach 遍历
				return false
			}
			return true
		})
		return err == nil // 如果内部遍历有错误，则停止外部遍历
	})

	return err // 返回捕获到的错误
}

// seedPigNutrientRequirements 先严格校验JSON源文件，然后以“有则跳过”的模式播种数据。
func seedPigNutrientRequirements(ctx context.Context, tx *gorm.DB, jsonData []byte) error {
	logger := logs.GetLogger(ctx)

	// 检查 PigBreed 表是否为空，如果非空则跳过播种
	isEmpty, err := isTableEmpty(tx, &models.PigBreed{})
	if err != nil {
		return fmt.Errorf("检查 PigBreed 表是否为空失败: %w", err)
	}
	if !isEmpty {
		logger.Info("已存在猪种数据, 跳过数据播种")
		return nil
	}

	// 1. 严格校验JSON文件，检查内部重复键
	if err := validateAndParsePigNutrientRequirementJSON(jsonData); err != nil {
		return fmt.Errorf("JSON源文件校验失败: %w", err)
	}

	// 2. 解析简介信息
	descriptionsNode := gjson.GetBytes(jsonData, "descriptions")
	pigBreedDescriptions := make(map[string]models.PigBreed)
	pigAgeStageDescriptions := make(map[string]models.PigAgeStage)
	pigTypeDescriptions := make(map[string]map[string]models.PigType)

	if descriptionsNode.Exists() {
		// 解析 pig_breeds 描述
		descriptionsNode.Get("pig_breeds").ForEach(func(key, value gjson.Result) bool {
			var pb models.PigBreed
			pb.Name = key.String()
			pb.Description = value.Get("description").String()
			pb.ParentInfo = value.Get("parent_info").String()
			pb.AppearanceFeatures = value.Get("appearance_features").String()
			pb.BreedAdvantages = value.Get("breed_advantages").String()
			pb.BreedDisadvantages = value.Get("breed_disadvantages").String()
			pigBreedDescriptions[key.String()] = pb
			return true
		})

		// 解析 pig_age_stages 描述
		descriptionsNode.Get("pig_age_stages").ForEach(func(key, value gjson.Result) bool {
			var pas models.PigAgeStage
			pas.Name = key.String()
			pas.Description = value.String()
			pigAgeStageDescriptions[key.String()] = pas
			return true
		})

		// 解析 pig_breed_age_stages (PigType) 描述
		descriptionsNode.Get("pig_breed_age_stages").ForEach(func(breedKey, breedValue gjson.Result) bool {
			if _, ok := pigTypeDescriptions[breedKey.String()]; !ok {
				pigTypeDescriptions[breedKey.String()] = make(map[string]models.PigType)
			}
			breedValue.ForEach(func(ageStageKey, ageStageValue gjson.Result) bool {
				var pt models.PigType
				pt.Description = ageStageValue.Get("description").String()
				pt.DailyFeedIntake = float32(ageStageValue.Get("daily_feed_intake").Float())
				pt.DailyGainWeight = float32(ageStageValue.Get("daily_gain_weight").Float())
				pt.MinDays = uint32(ageStageValue.Get("min_days").Uint())
				pt.MaxDays = uint32(ageStageValue.Get("max_days").Uint())
				pt.MinWeight = float32(ageStageValue.Get("min_weight").Float())
				pt.MaxWeight = float32(ageStageValue.Get("max_weight").Float())
				pigTypeDescriptions[breedKey.String()][ageStageKey.String()] = pt
				return true
			})
			return true
		})
	}

	// 3. 将通过校验的、干净的数据写入数据库
	dataNode := gjson.GetBytes(jsonData, "data")
	dataNode.ForEach(func(breedKey, breedValue gjson.Result) bool {
		breedName := breedKey.String()
		var pigBreed models.PigBreed
		// 查找或创建 PigBreed
		pbDesc := pigBreedDescriptions[breedName]
		err = tx.Where(models.PigBreed{Name: breedName}).
			FirstOrCreate(&pigBreed, models.PigBreed{
				Name:               breedName,
				Description:        pbDesc.Description,
				ParentInfo:         pbDesc.ParentInfo,
				AppearanceFeatures: pbDesc.AppearanceFeatures,
				BreedAdvantages:    pbDesc.BreedAdvantages,
				BreedDisadvantages: pbDesc.BreedDisadvantages,
			}).Error
		if err != nil {
			return false
		}

		breedValue.ForEach(func(ageStageKey, ageStageValue gjson.Result) bool {
			ageStageName := ageStageKey.String()
			var pigAgeStage models.PigAgeStage
			// 查找或创建 PigAgeStage
			pasDesc := pigAgeStageDescriptions[ageStageName]
			err = tx.Where(models.PigAgeStage{Name: ageStageName}).
				FirstOrCreate(&pigAgeStage, models.PigAgeStage{
					Name:        ageStageName,
					Description: pasDesc.Description,
				}).Error

			if err != nil {
				return false
			}

			var pigType models.PigType
			// 查找或创建 PigType
			ptDesc := pigTypeDescriptions[breedName][ageStageName]
			err = tx.Where(models.PigType{BreedID: pigBreed.ID, AgeStageID: pigAgeStage.ID}).
				FirstOrCreate(&pigType, models.PigType{
					BreedID:         pigBreed.ID,
					AgeStageID:      pigAgeStage.ID,
					Description:     ptDesc.Description,
					DailyFeedIntake: ptDesc.DailyFeedIntake,
					DailyGainWeight: ptDesc.DailyGainWeight,
					MinDays:         ptDesc.MinDays,
					MaxDays:         ptDesc.MaxDays,
					MinWeight:       ptDesc.MinWeight,
					MaxWeight:       ptDesc.MaxWeight,
				}).Error
			if err != nil {
				return false
			}

			ageStageValue.ForEach(func(nutrientKey, nutrientValue gjson.Result) bool {
				nutrientName := nutrientKey.String()
				minReq := float32(nutrientValue.Get("min_requirement").Float())
				maxReq := float32(nutrientValue.Get("max_requirement").Float())

				var nutrient models.Nutrient
				// 查找或创建 Nutrient (这里假设 Nutrient 已经在 seedNutrients 中处理，但为了健壮性，再次 FirstOrCreate)
				err = tx.Where(models.Nutrient{Name: nutrientName}).
					FirstOrCreate(&nutrient, models.Nutrient{
						Name: nutrientName,
						// Description 字段在 nutrient seeder 中处理，这里不设置
					}).Error
				if err != nil {
					return false
				}

				linkData := models.PigNutrientRequirement{
					PigTypeID:      pigType.ID,
					NutrientID:     nutrient.ID,
					MinRequirement: minReq,
					MaxRequirement: maxReq,
				}
				// 使用 FirstOrCreate 确保关联的唯一性
				err = tx.Where(models.PigNutrientRequirement{
					PigTypeID:  pigType.ID,
					NutrientID: nutrient.ID,
				}).FirstOrCreate(&linkData, linkData).Error
				if err != nil {
					return false
				}
				return true
			})
			return err == nil // 如果内部遍历有错误，则停止外部遍历
		})
		return err == nil // 如果内部遍历有错误，则停止外部遍历
	})
	return err // 返回捕获到的错误
}

// validateAndParsePigNutrientRequirementJSON 严格校验猪营养需求JSON文件
func validateAndParsePigNutrientRequirementJSON(jsonData []byte) error {
	dataNode := gjson.GetBytes(jsonData, "data")
	if !dataNode.Exists() {
		return errors.New("JSON文件中缺少 'data' 字段")
	}
	if !dataNode.IsObject() {
		return errors.New("'data' 字段必须是一个JSON对象")
	}

	decoder := json.NewDecoder(bytes.NewReader([]byte(dataNode.Raw)))
	decoder.UseNumber()

	if t, err := decoder.Token(); err != nil || t != json.Delim('{') {
		return fmt.Errorf("'data' 字段解析起始符失败: %v", err)
	}

	seenBreeds := make(map[string]bool)

	for decoder.More() {
		// 解析 PigBreed 名称
		t, err := decoder.Token()
		if err != nil {
			return fmt.Errorf("解析猪品种名称失败: %w", err)
		}
		breedName := t.(string)
		if seenBreeds[breedName] {
			return fmt.Errorf("猪品种名称 '%s' 重复", breedName)
		}
		seenBreeds[breedName] = true

		// 解析该品种的年龄阶段对象
		if t, err := decoder.Token(); err != nil || t != json.Delim('{') {
			return fmt.Errorf("期望猪品种 '%s' 的值是一个JSON对象", breedName)
		}

		seenAgeStages := make(map[string]bool)

		for decoder.More() {
			// 解析 PigAgeStage 名称
			t, err := decoder.Token()
			if err != nil {
				return fmt.Errorf("在猪品种 '%s' 中解析年龄阶段名称失败: %w", breedName, err)
			}
			ageStageName := t.(string)
			if seenAgeStages[ageStageName] {
				return fmt.Errorf("在猪品种 '%s' 中, 年龄阶段名称 '%s' 重复", breedName, ageStageName)
			}
			seenAgeStages[ageStageName] = true

			// 解析该年龄阶段的营养成分对象
			if t, err := decoder.Token(); err != nil || t != json.Delim('{') {
				return fmt.Errorf("期望年龄阶段 '%s' 的值是一个JSON对象", ageStageName)
			}

			seenNutrients := make(map[string]bool)

			for decoder.More() {
				// 解析 Nutrient 名称
				t, err := decoder.Token()
				if err != nil {
					return fmt.Errorf("在年龄阶段 '%s' 中解析营养素名称失败: %w", ageStageName, err)
				}
				nutrientName := t.(string)
				if seenNutrients[nutrientName] {
					return fmt.Errorf("在年龄阶段 '%s' 中, 营养素名称 '%s' 重复", ageStageName, nutrientName)
				}
				seenNutrients[nutrientName] = true

				// 解析 min_requirement 和 max_requirement 对象
				if t, err := decoder.Token(); err != nil || t != json.Delim('{') {
					return fmt.Errorf("期望营养素 '%s' 的值是一个JSON对象", nutrientName)
				}

				for decoder.More() {
					t, err := decoder.Token()
					if err != nil {
						return fmt.Errorf("解析营养素 '%s' 的需求键失败: %w", nutrientName, err)
					}
					// key := t.(string) // 校验时不需要使用 key 的值

					t, err = decoder.Token()
					if err != nil {
						return fmt.Errorf("解析营养素 '%s' 的需求值失败: %w", nutrientName, err)
					}
					if _, ok := t.(json.Number); !ok {
						return fmt.Errorf("期望营养素 '%s' 的需求值是数字, 但实际得到的类型是 %T, 值为 '%v'", nutrientName, t, t)
					}
				}
				if t, err := decoder.Token(); err != nil || t != json.Delim('}') {
					return fmt.Errorf("解析营养素 '%s' 的值结束符 '}' 失败", nutrientName)
				}
			}
			if t, err := decoder.Token(); err != nil || t != json.Delim('}') {
				return fmt.Errorf("解析年龄阶段 '%s' 的值结束符 '}' 失败", ageStageName)
			}
		}
		if t, err := decoder.Token(); err != nil || t != json.Delim('}') {
			return fmt.Errorf("解析猪品种 '%s' 的值结束符 '}' 失败", breedName)
		}
	}
	return nil
}

// validateAndParseNutrientJSON 严格校验JSON文件
func validateAndParseNutrientJSON(jsonData []byte) error {
	descriptionsNode := gjson.GetBytes(jsonData, "descriptions")
	if !descriptionsNode.Exists() {
		return errors.New("JSON文件中缺少 'descriptions' 字段")
	}
	if !descriptionsNode.IsObject() {
		return errors.New("'descriptions' 字段必须是一个JSON对象")
	}

	rawMaterialsNode := descriptionsNode.Get("raw_materials")
	if !rawMaterialsNode.Exists() {
		return errors.New("JSON文件中缺少 'descriptions.raw_materials' 字段")
	}
	if !rawMaterialsNode.IsObject() {
		return errors.New("'descriptions.raw_materials' 字段必须是一个JSON对象")
	}

	// 使用 json.Decoder 严格校验 raw_materials 的结构
	decoder := json.NewDecoder(bytes.NewReader([]byte(rawMaterialsNode.Raw)))
	decoder.UseNumber()

	if t, err := decoder.Token(); err != nil || t != json.Delim('{') {
		return fmt.Errorf("'descriptions.raw_materials' 字段解析起始符失败: %v", err)
	}

	seenRawMaterials := make(map[string]bool)

	for decoder.More() {
		// 1. 解析原料名称
		t, err := decoder.Token()
		if err != nil {
			return fmt.Errorf("解析原料名称失败: %w", err)
		}
		rawMaterialName := t.(string)
		if seenRawMaterials[rawMaterialName] {
			return fmt.Errorf("原料名称 '%s' 重复", rawMaterialName)
		}
		seenRawMaterials[rawMaterialName] = true

		// 2. 解析该原料的描述和价格对象
		if t, err := decoder.Token(); err != nil || t != json.Delim('{') {
			return fmt.Errorf("期望原料 '%s' 的值是一个JSON对象", rawMaterialName)
		}

		for decoder.More() {
			t, err := decoder.Token()
			if err != nil {
				return fmt.Errorf("解析原料 '%s' 内部键失败: %w", rawMaterialName, err)
			}
			key := t.(string)

			switch key {
			case "descriptions":
				t, err = decoder.Token()
				if err != nil {
					return fmt.Errorf("解析原料 '%s' 的 'descriptions' 值失败: %w", rawMaterialName, err)
				}
				if _, ok := t.(string); !ok {
					return fmt.Errorf("期望原料 '%s' 的 'descriptions' 值是字符串, 但实际得到的类型是 %T, 值为 '%v'", rawMaterialName, t, t)
				}
			case "unit_price":
				t, err = decoder.Token()
				if err != nil {
					return fmt.Errorf("解析原料 '%s' 的 'unit_price' 值失败: %w", rawMaterialName, err)
				}
				if _, ok := t.(json.Number); !ok {
					return fmt.Errorf("期望原料 '%s' 的 'unit_price' 值是数字, 但实际得到的类型是 %T, 值为 '%v'", rawMaterialName, t, t)
				}
			default:
				// 忽略其他未知字段，但仍需读取其值以继续解析
				if _, err := decoder.Token(); err != nil {
					return fmt.Errorf("解析原料 '%s' 的未知键 '%s' 的值失败: %w", rawMaterialName, key, err)
				}
			}
		}

		// 读取原料描述和价格对象的 "}"
		if t, err := decoder.Token(); err != nil || t != json.Delim('}') {
			return fmt.Errorf("解析原料 '%s' 的值结束符 '}' 失败", rawMaterialName)
		}
	}

	// 校验 data 节点
	dataNode := gjson.GetBytes(jsonData, "data")
	if !dataNode.Exists() {
		return errors.New("JSON文件中缺少 'data' 字段")
	}
	if !dataNode.IsObject() {
		return errors.New("'data' 字段必须是一个JSON对象")
	}

	// 重新初始化 decoder 用于 data 节点的校验
	decoder = json.NewDecoder(bytes.NewReader([]byte(dataNode.Raw)))
	decoder.UseNumber()
	if t, err := decoder.Token(); err != nil || t != json.Delim('{') {
		return errors.New("'data' 字段解析起始符失败")
	}

	seenRawMaterials = make(map[string]bool) // 重置 seenRawMaterials 用于 data 节点校验

	for decoder.More() {
		// 1. 解析原料名称
		t, err := decoder.Token()
		if err != nil {
			return fmt.Errorf("解析原料名称失败: %w", err)
		}
		rawMaterialName := t.(string)
		if seenRawMaterials[rawMaterialName] {
			return fmt.Errorf("原料名称 '%s' 重复", rawMaterialName)
		}
		seenRawMaterials[rawMaterialName] = true

		// 2. 解析该原料的营养成分对象
		if t, err := decoder.Token(); err != nil || t != json.Delim('{') {
			return fmt.Errorf("期望原料 '%s' 的值是一个JSON对象", rawMaterialName)
		}

		seenNutrients := make(map[string]bool)
		for decoder.More() {
			// 解析营养素名称
			t, err := decoder.Token()
			if err != nil {
				return fmt.Errorf("在原料 '%s' 中解析营养素名称失败: %w", rawMaterialName, err)
			}
			nutrientName := t.(string)
			if seenNutrients[nutrientName] {
				return fmt.Errorf("在原料 '%s' 中, 营养素名称 '%s' 重复", rawMaterialName, nutrientName)
			}
			seenNutrients[nutrientName] = true

			// 解析营养素含量
			t, err = decoder.Token()
			if err != nil {
				return fmt.Errorf("在原料 '%s' 中解析营养素 '%s' 的含量值失败: %w", rawMaterialName, nutrientName, err)
			}
			if _, ok := t.(json.Number); !ok {
				return fmt.Errorf("期望营养素 '%s' 的含量值是数字, 但实际得到的类型是 %T, 值为 '%v'", nutrientName, t, t)
			}
		}

		// 读取营养成分对象的 "}"
		if t, err := decoder.Token(); err != nil || t != json.Delim('}') {
			return fmt.Errorf("解析原料 '%s' 的值结束符 '}' 失败", rawMaterialName)
		}
	}
	return nil
}