package survey

import (
	"reflect"
	"strings"

	"golang.org/x/text/cases"
	"golang.org/x/text/language"
)

// TransformString returns a `Transformer` based on the "f"
// function which accepts a string representation of the answer
// and returns a new one, transformed, answer.
// Take for example the functions inside the std `strings` package,
// they can be converted to a compatible `Transformer` by using this function,
// i.e: `TransformString(strings.Title)`, `TransformString(strings.ToUpper)`.
//
// Note that `TransformString` is just a helper, `Transformer` can be used
// to transform any type of answer.
func TransformString(f func(s string) string) Transformer {
	return func(ans interface{}) interface{} {
		// if the answer value passed in is the zero value of the appropriate type
		if isZero(reflect.ValueOf(ans)) {
			// skip this `Transformer` by returning a zero value of string.
			// The original answer will be not affected,
			// see survey.go#L125.
			// A zero value of string should be returned to be handled by
			// next Transformer in a composed Tranformer,
			// see tranform.go#L75
			return ""
		}

		// "ans" is never nil here, so we don't have to check that
		// see survey.go#L338 for more.
		// Make sure that the the answer's value was a typeof string.
		s, ok := ans.(string)
		if !ok {
			return ""
		}

		return f(s)
	}
}

// ToLower is a `Transformer`.
// It receives an answer value
// and returns a copy of the "ans"
// with all Unicode letters mapped to their lower case.
//
// Note that if "ans" is not a string then it will
// return a nil value, meaning that the above answer
// will not be affected by this call at all.
func ToLower(ans interface{}) interface{} {
	transformer := TransformString(strings.ToLower)
	return transformer(ans)
}

// Title is a `Transformer`.
// It receives an answer value
// and returns a copy of the "ans"
// with all Unicode letters that begin words
// mapped to their title case.
//
// Note that if "ans" is not a string then it will
// return a nil value, meaning that the above answer
// will not be affected by this call at all.
func Title(ans interface{}) interface{} {
	transformer := TransformString(cases.Title(language.English).String)
	return transformer(ans)
}

// ComposeTransformers is a variadic function used to create one transformer from many.
func ComposeTransformers(transformers ...Transformer) Transformer {
	// return a transformer that calls each one sequentially
	return func(ans interface{}) interface{} {
		// execute each transformer
		for _, t := range transformers {
			ans = t(ans)
		}
		return ans
	}
}