helpers

var ProtoHelpersFuncMap = tmpl.FuncMap{
	"string": func(i interface {
		String() string
	}) string {
		return i.String()
	},
	"json": func(v interface{}) string {
		a, err := json.Marshal(v)
		if err != nil {
			return err.Error()
		}
		return string(a)
	},
	"prettyjson": func(v interface{}) string {
		a, err := json.MarshalIndent(v, "", "  ")
		if err != nil {
			return err.Error()
		}
		return string(a)
	},
	"makeimport": func(imp ...string) string {
		prefix := ""
		i := ""
		if len(imp) > 0 {
			i = imp[0]
		}
		if len(imp) > 1 {
			prefix = imp[1]
		}
		if len(prefix) == 0 {
			return fmt.Sprintf("\"%s\"", i)
		}
		return fmt.Sprintf("%s \"%s\"", prefix, i)
	},
	"makeimports": func(dependencies []string, imps []interface{}) string {
		impmap := make(map[string]string, len(imps)*2)
		for _, dep := range dependencies {
			gopkg := getProtoFile(dep).GoPkg
			key := gopkg.Path
			val := gopkg.Alias
			wrap := ""
			if !strings.Contains(key, "\"") {
				wrap = "\""
			}
			key = fmt.Sprintf("%s%s%s", wrap, key, wrap)
			impmap[key] = val
		}
		for _, itimp := range imps {
			timp := fmt.Sprintf("%s", itimp)
			imp := []string{"", timp}
			if strings.Contains(timp, " ") {
				imp = strings.Split(timp, " ")
			}
			wrap := ""
			if !strings.Contains(imp[1], "\"") {
				wrap = "\""
			}
			imp[1] = fmt.Sprintf("%s%s%s", wrap, imp[1], wrap)
			impmap[imp[1]] = imp[0]
		}

		r := make([]string, 0, len(impmap))
		for k := range impmap {
			r = append(r, k)
		}
		sort.Strings(r)
		var i string
		for _, ir := range r {
			prefix := impmap[ir]
			line := fmt.Sprintf("%s %s", prefix, ir)
			if len(prefix) == 0 {
				line = fmt.Sprintf("%s", ir)
			}
			if len(i) == 0 {
				i = fmt.Sprintf("%s", line)
			} else {
				i = fmt.Sprintf("%s%s%s", i, "\n\t", line)
			}

		}

		return i
	},
	"splitArray": func(sep string, s string) []interface{} {
		var r []interface{}
		t := strings.Split(s, sep)
		for i := range t {
			if t[i] != "" {
				r = append(r, t[i])
			}
		}
		return r
	},
	"joinSort": func(sep string, s ...string) string {
		res := ""

		sort.Strings(s)
		for _, str := range s {
			if len(res) == 0 {
				res = fmt.Sprintf("%s", str)
			} else {
				res = fmt.Sprintf("%s%s%s", res, sep, str)
			}
		}
		return res
	},
	"first": func(a []string) string {
		return a[0]
	},
	"last": func(a []string) string {
		return a[len(a)-1]
	},
	"concat": func(a string, b ...string) string {
		return strings.Join(append([]string{a}, b...), "")
	},
	"join": func(sep string, a ...string) string {
		return strings.Join(a, sep)
	},
	"upperFirst": func(s string) string {
		return strings.ToUpper(s[:1]) + s[1:]
	},
	"lowerFirst": func(s string) string {
		return strings.ToLower(s[:1]) + s[1:]
	},
	"camelCase": func(s string) string {
		if len(s) > 1 {
			return xstrings.ToCamelCase(s)
		}

		return strings.ToUpper(s[:1])
	},
	"lowerCamelCase": func(s string) string {
		if len(s) > 1 {
			s = xstrings.ToCamelCase(s)
		}

		return strings.ToLower(s[:1]) + s[1:]
	},
	"upperCase": func(s string) string {
		return strings.ToUpper(s)
	},
	"kebabCase": func(s string) string {
		return strings.Replace(xstrings.ToSnakeCase(s), "_", "-", -1)
	},
	"contains": func(sub, s string) bool {
		return strings.Contains(s, sub)
	},
	"trimstr": func(cutset, s string) string {
		return strings.Trim(s, cutset)
	},
	"index": func(array interface{}, i int) interface{} {
		slice := reflect.ValueOf(array)
		if slice.Kind() != reflect.Slice {
			panic("Error in index(): given a non-slice type")
		}
		if i < 0 || i >= slice.Len() {
			panic("Error in index(): index out of bounds")
		}
		return slice.Index(i).Interface()
	},
	"add": func(a int, b int) int {
		return a + b
	},
	"subtract": func(a int, b int) int {
		return a - b
	},
	"multiply": func(a int, b int) int {
		return a * b
	},
	"divide": func(a int, b int) int {
		if b == 0 {
			panic("psssst ... little help here ... you cannot divide by 0")
		}
		return a / b
	},

	"snakeCase":                    xstrings.ToSnakeCase,
	"getProtoFile":                 getProtoFile,
	"getMessageType":               getMessageType,
	"getMessageTypeWithPackage":    getMessageTypeWithPackage,
	"getEnumValue":                 getEnumValue,
	"isFieldMessage":               isFieldMessage,
	"isFieldMessageTimeStamp":      isFieldMessageTimeStamp,
	"isFieldRepeated":              isFieldRepeated,
	"haskellType":                  haskellType,
	"goType":                       goType,
	"goZeroValue":                  goZeroValue,
	"goTypeWithPackage":            goTypeWithPackage,
	"goTypeWithGoPackage":          goTypeWithGoPackage,
	"jsType":                       jsType,
	"jsSuffixReserved":             jsSuffixReservedKeyword,
	"namespacedFlowType":           namespacedFlowType,
	"httpVerb":                     httpVerb,
	"httpPath":                     httpPath,
	"httpPathsAdditionalBindings":  httpPathsAdditionalBindings,
	"httpBody":                     httpBody,
	"shortType":                    shortType,
	"urlHasVarsFromMessage":        urlHasVarsFromMessage,
	"lowerGoNormalize":             lowerGoNormalize,
	"goNormalize":                  goNormalize,
	"leadingComment":               leadingComment,
	"trailingComment":              trailingComment,
	"leadingDetachedComments":      leadingDetachedComments,
	"stringFileOptionsExtension":   stringFileOptionsExtension,
	"stringMessageExtension":       stringMessageExtension,
	"stringFieldExtension":         stringFieldExtension,
	"int64FieldExtension":          int64FieldExtension,
	"int64MessageExtension":        int64MessageExtension,
	"stringMethodOptionsExtension": stringMethodOptionsExtension,
	"boolMethodOptionsExtension":   boolMethodOptionsExtension,
	"boolMessageExtension":         boolMessageExtension,
	"boolFieldExtension":           boolFieldExtension,
	"isFieldMap":                   isFieldMap,
	"fieldMapKeyType":              fieldMapKeyType,
	"fieldMapValueType":            fieldMapValueType,
	"replaceDict":                  replaceDict,
	"setStore":                     setStore,
	"getStore":                     getStore,
	"goPkg":                        goPkg,
	"goPkgLastElement":             goPkgLastElement,
	"cppType":                      cppType,
	"cppTypeWithPackage":           cppTypeWithPackage,
	"rustType":                     rustType,
	"rustTypeWithPackage":          rustTypeWithPackage,
}