func setSettingsFromAPI()

in internal/elasticsearch/index/indices/models.go [254:417]
149 lines of code
24 McCabe index (conditional complexity)

func setSettingsFromAPI(ctx context.Context, model *indexTfModel, apiModel models.Index) diag.Diagnostics {
	modelType := reflect.TypeOf(*model)

	for _, key := range allSettingsKeys {
		settingsValue, ok := apiModel.Settings["index."+key]
		var tfValue attr.Value
		if !ok {
			continue
		}

		tfFieldKey := utils.ConvertSettingsKeyToTFFieldKey(key)
		value, ok := model.getFieldValueByTagValue(tfFieldKey, modelType)
		if !ok {
			return diag.Diagnostics{
				diag.NewErrorDiagnostic(
					"failed to find setting value",
					fmt.Sprintf("expected setting with key %s", tfFieldKey),
				),
			}
		}

		switch a := value.(type) {
		case types.String:
			settingStr, ok := settingsValue.(string)
			if !ok {
				return diag.Diagnostics{
					diag.NewErrorDiagnostic(
						"failed to convert setting to string",
						fmt.Sprintf("expected setting to be a string but got %t", settingsValue),
					)}
			}
			tfValue = basetypes.NewStringValue(settingStr)
		case types.Bool:
			if settingStr, ok := settingsValue.(string); ok {
				settingBool, err := strconv.ParseBool(settingStr)
				if err != nil {
					return diag.Diagnostics{
						diag.NewErrorDiagnostic(
							"failed to convert setting to bool",
							fmt.Sprintf("expected setting to be a bool but it was a string. Attempted to parse it but got %s", err.Error()),
						),
					}
				}

				settingsValue = settingBool
			}

			settingBool, ok := settingsValue.(bool)
			if !ok {
				return diag.Diagnostics{
					diag.NewErrorDiagnostic(
						"failed to convert setting to bool",
						fmt.Sprintf("expected setting to be a bool but got %t", settingsValue),
					)}
			}
			tfValue = basetypes.NewBoolValue(settingBool)
		case types.Int64:
			if settingStr, ok := settingsValue.(string); ok {
				settingInt, err := strconv.Atoi(settingStr)
				if err != nil {
					return diag.Diagnostics{
						diag.NewErrorDiagnostic(
							"failed to convert setting to int",
							fmt.Sprintf("expected setting to be an int but it was a string. Attempted to parse it but got %s", err.Error()),
						),
					}
				}

				settingsValue = int64(settingInt)
			}

			settingInt, ok := settingsValue.(int64)
			if !ok {
				return diag.Diagnostics{
					diag.NewErrorDiagnostic(
						"failed to convert setting to int",
						fmt.Sprintf("expected setting to be a int but got %t", settingsValue),
					)}
			}
			tfValue = basetypes.NewInt64Value(settingInt)
		case types.List:
			elemType := a.ElementType(ctx)
			if elemType != types.StringType {
				return diag.Diagnostics{
					diag.NewErrorDiagnostic(
						"expected list of string",
						fmt.Sprintf("expected list element type to be string but got %s", elemType),
					),
				}
			}

			elems, ok := settingsValue.([]interface{})
			if !ok {
				return diag.Diagnostics{
					diag.NewErrorDiagnostic(
						"failed to convert setting to []string",
						fmt.Sprintf("expected setting to be a []string but got %#v", settingsValue),
					)}
			}

			var diags diag.Diagnostics
			tfValue, diags = basetypes.NewListValueFrom(ctx, basetypes.StringType{}, elems)
			if diags.HasError() {
				return diags
			}
		case types.Set:
			elemType := a.ElementType(ctx)
			if elemType != types.StringType {
				return diag.Diagnostics{
					diag.NewErrorDiagnostic(
						"expected set of string",
						fmt.Sprintf("expected set element type to be string but got %s", elemType),
					),
				}
			}

			elems, ok := settingsValue.([]interface{})
			if !ok {
				return diag.Diagnostics{
					diag.NewErrorDiagnostic(
						"failed to convert setting to []string",
						fmt.Sprintf("expected setting to be a thing []string but got %#v", settingsValue),
					)}
			}

			var diags diag.Diagnostics
			tfValue, diags = basetypes.NewSetValueFrom(ctx, basetypes.StringType{}, elems)
			if diags.HasError() {
				return diags
			}
		default:
			return diag.Diagnostics{
				diag.NewErrorDiagnostic(
					"unknown value type",
					fmt.Sprintf("unknown index setting value type %s", a.Type(ctx)),
				),
			}
		}

		ok = model.setFieldValueByTagValue(tfFieldKey, modelType, tfValue)
		if !ok {
			return diag.Diagnostics{
				diag.NewErrorDiagnostic(
					"failed to find setting value",
					fmt.Sprintf("expected setting with key %s", tfFieldKey),
				),
			}
		}
	}

	settingsBytes, err := json.Marshal(apiModel.Settings)
	if err != nil {
		return diag.Diagnostics{
			diag.NewErrorDiagnostic(
				"failed to marshal raw settings",
				err.Error(),
			),
		}
	}

	model.SettingsRaw = jsontypes.NewNormalizedValue(string(settingsBytes))

	return nil
}