func bindDoubleWithReturn()

in pkg/genlib/generator_interface.go [1118:1232]
88 lines of code
19 McCabe index (conditional complexity)

func bindDoubleWithReturn(fieldCfg ConfigField, field Field, fieldMap map[string]any) error {
	if err := fieldCfg.ValidCounter(); err != nil {
		return err
	}

	if err := fieldCfg.ValidateCounterResetStrategy(); err != nil {
		return err
	}

	if err := fieldCfg.ValidateCounterResetAfterN(); err != nil {
		return err
	}

	if err := fieldCfg.ValidateCounterResetProbabilistic(); err != nil {
		return err
	}

	if len(fieldCfg.Enum) > 0 {
		var emitF emitF
		idx := customRand.Intn(len(fieldCfg.Enum))
		f, err := strconv.ParseFloat(fieldCfg.Enum[idx], 64)
		if err != nil {
			return fmt.Errorf("field %s enum value is not a double: %w", fieldCfg.Name, err)
		}

		emitF = func(state *genState) any {
			return f
		}

		fieldMap[field.Name] = emitF

		return nil
	}

	if fieldCfg.Counter {
		var emitF emitF

		emitF = func(state *genState) any {
			previous := float64(1)
			var dummyFloat float64
			var dummyFunc func() float64

			if previousDummyFloat, ok := state.prevCache[field.Name].(float64); ok {
				previous = previousDummyFloat
			}

			if fieldCfg.Fuzziness <= 0 {
				dummyFunc = makeFloatCounterFunc(previous, field)

				dummyFloat = dummyFunc()
			} else {
				dummyFloat = fuzzyFloatCounter(previous, fieldCfg.Fuzziness)
			}

			if fieldCfg.CounterReset != nil {
				switch fieldCfg.CounterReset.Strategy {
				case config.CounterResetStrategyRandom:
					// 50% chance to reset
					if customRand.Intn(2) == 0 {
						dummyFloat = 0
					}
				case config.CounterResetStrategyProbabilistic:
					// Probability% chance to reset
					if customRand.Intn(100) < int(*fieldCfg.CounterReset.Probability) {
						dummyFloat = 0
					}
				case config.CounterResetStrategyAfterN:
					// Reset after N
					if state.counter%*fieldCfg.CounterReset.ResetAfterN == 0 {
						dummyFloat = 0
					}
				}
			}

			state.prevCache[field.Name] = dummyFloat
			return dummyFloat
		}

		fieldMap[field.Name] = emitF

		return nil
	}

	dummyFunc := makeFloatFunc(fieldCfg, field)

	if fieldCfg.Fuzziness <= 0 {
		var emitF emitF
		emitF = func(state *genState) any {
			return dummyFunc()
		}

		fieldMap[field.Name] = emitF

		return nil
	}

	min, _ := fieldCfg.Range.MinAsFloat64()
	max, _ := fieldCfg.Range.MaxAsFloat64()

	var emitF emitF
	emitF = func(state *genState) any {
		var dummyFloat float64
		if previousDummyFloat, ok := state.prevCache[field.Name].(float64); ok {
			dummyFloat = fuzzyFloat(previousDummyFloat, fieldCfg.Fuzziness, min, max)
		} else {
			dummyFloat = dummyFunc()
		}
		state.prevCache[field.Name] = dummyFloat
		return dummyFloat
	}

	fieldMap[field.Name] = emitF

	return nil
}