func GetLabels(s storage.Storage) func(c *gin.Context) {
	return func(c *gin.Context) {

		name := c.Param("appname")

		lbls := s.GetLabels(name)

		labels := &Labels{lbls}

		c.IndentedJSON(http.StatusOK, labels)
	}
}

// ReplacePlaceholders generated a config file using the base config file for appname by replacing the possible placeholders
// that the config fiel might have given a group of labels. These labels are used to retrieve the placeholders stored values
func ReplacePlaceholders(s storage.Storage) func(c *gin.Context) {
	return func(c *gin.Context) {
		name := c.Param("appname")
		labels := c.DefaultQuery("labels", "default")
		renderType := c.Param("format")

		list := make(map[string]*placeholders.Placeholder)

		myViper, err := readTemplate(name)
		if err != nil {
			c.String(http.StatusNotFound, "")
		} else {
			properties := placeholders.GetPlaceHolders(myViper)
			for _, v := range properties.Placeholders {
				list[v.PlaceHolder] = v
			}

			lbls := strings.Split(labels, ",")
			// MERGE values of different labels, last overrides current value
			for _, label := range lbls {
				l := s.GetOptions(name, label)
				for k, v := range l {
					if list[k] != nil {
						list[k].PropertyValue = v
					}
				}
			}

			template := replaceTemplatePlaceHolders(myViper, list)

			extension := getFileExtension(myViper)

			replacedViper := viper.New()
			replacedViper.SetConfigType(extension)
			replacedViper.ReadConfig(bytes.NewBuffer([]byte(template)))

			b, err := render(replacedViper, renderType)

			if err == nil {
				c.Data(http.StatusOK, "text/plain", b)
			}

			if err != nil {

				c.String(http.StatusInternalServerError, "Could not render %s", err)
			}
		}

	}
}

// SetValues set the placeholders values for a given appname and concrete namespace represented as labels
// If no labels are provided the "default" label is used
func SetValues(s storage.Storage) func(c *gin.Context) {
	return func(c *gin.Context) {
		name := c.Param("appname")
		labels := c.DefaultQuery("labels", "default")

		body := c.Request.Body
		x, err := ioutil.ReadAll(body)

		if err != nil {
			c.String(http.StatusBadRequest, "Bad request")
		} else {

			data := map[string]interface{}{}
			json.Unmarshal(x, &data)

			lbls := strings.Split(labels, ",")
			if len(data) > 0 { //it's a JSON
				for _, label := range lbls {
					for k, v := range data {
						s.SetOption(name, label, k, fmt.Sprint(v))
					}
				}
				c.String(http.StatusOK, "Ok")
			} else if strings.Contains(string(x), "=") {
				pairs := strings.Split(string(x), ",")
				for _, label := range lbls {
					for _, v := range pairs {
						vv := strings.Split(v, "=")
						s.SetOption(name, label, vv[0], strings.Join(vv[1:], "="))
					}
				}
				c.String(http.StatusOK, "Ok")
			} else {
				c.String(http.StatusBadRequest, "Properties not well-formed")
			}

		}

	}
}

// GetValues return the placeholders values for a given appname and concrete namespace represented as labels.
// If no labels are provided the "default" label is used
func GetValues(s storage.Storage) func(c *gin.Context) {
	return func(c *gin.Context) {
		name := c.Param("appname")
		labels := c.DefaultQuery("labels", "default")

		list := make(map[string]string)
		if strings.Contains(labels, ",") {
			lbls := strings.Split(labels, ",")
			// MERGE values of different labels, last overrides current value
			for _, label := range lbls {
				l := s.GetOptions(name, label)
				for k, v := range l {
					list[k] = v
				}
			}
		} else {
			list = s.GetOptions(name, labels)
		}

		vs := placeholders.CreateValues(list)

		c.IndentedJSON(http.StatusOK, vs)
	}
}