func replaceSSMParameters()

in agent/framework/docparser/parameterstore/parser.go [75:166]
77 lines of code
23 McCabe index (conditional complexity)

func replaceSSMParameters(log log.T, input interface{}, ssmParameters map[string]Parameter) (interface{}, error) {
	switch input := input.(type) {
	case string:
		// replace param names with actual values
		for paramName, paramObj := range ssmParameters {
			if paramObj.Type == ParamTypeStringList && strings.Contains(input, paramName) {
				return nil, fmt.Errorf("Parameter %v of type %v cannot be used as a %v", paramObj.Name, paramObj.Type, ParamTypeString)
			}

			input = strings.Replace(input, paramName, paramObj.Value, -1)
		}
		return input, nil

	case []string:
		out, err := parseStringList(log, input, ssmParameters)
		if err != nil {
			return nil, err
		}
		return out, nil

	case []interface{}:
		// return the original input if it is an empty array.
		if len(input) == 0 {
			return input, nil
		}

		switch input[0].(type) {
		case string:
			out, err := parseStringList(log, input, ssmParameters)
			if err != nil {
				return nil, err
			}
			return out, nil

		default:
			var err error
			// for slices, recursively replace parameters on each element of the slice
			out := make([]interface{}, len(input))
			for i, v := range input {
				out[i], err = replaceSSMParameters(log, v, ssmParameters)
				if err != nil {
					return nil, err
				}
			}
			return out, nil
		}

	case []map[string]interface{}:
		// this case is not caught by the one above because map cannot be converted to interface{}
		out := make([]map[string]interface{}, len(input))
		for i, v := range input {
			temp, err := replaceSSMParameters(log, v, ssmParameters)
			if err != nil {
				return nil, err
			}
			out[i] = temp.(map[string]interface{})
		}
		return out, nil

	case map[string]interface{}:
		var err error
		// for maps, recursively replace parameters on each value in the map
		out := make(map[string]interface{})
		for k, v := range input {
			out[k], err = replaceSSMParameters(log, v, ssmParameters)
			if err != nil {
				return nil, err
			}
		}
		return out, nil

	case map[interface{}]interface{}:
		var err error
		out := make(map[string]interface{})
		for k, v := range input {
			switch k := k.(type) {
			case string:
				out[k], err = replaceSSMParameters(log, v, ssmParameters)
				if err != nil {
					return nil, err
				}
			default:
				return nil, errors.New("Unrecognized parameter type")
			}
		}
		return out, nil

	default:
		// any other type, return as is
		return input, nil
	}
}