var typeTags = make(map[reflect.Type]string)

// RegisterTypeTag registers a validator tag for a map or slice type. For example:
//     infra.RegisterMapTag(api.MyMap{}, "gt=3,dive")
// where api.MyMap is a map type, e.g.
//     type MyMap map[string]int
// If you register a tag, you have to include "dive" to validate map/slice elements.
func RegisterTypeTag(typ interface{}, tag string) {
	// TODO panic if the type is not one of: Slice, Array, Map
	typeTags[reflect.TypeOf(typ)] = tag
}

type defaultValidator struct {
	once     sync.Once
	validate *validator.Validate
}

var _ binding.StructValidator = &defaultValidator{}

func (v *defaultValidator) ValidateStruct(obj interface{}) error {
	if obj == nil {
		return nil
	}

	value := reflect.ValueOf(obj)
	switch value.Kind() {
	case reflect.Ptr:
		return v.ValidateStruct(value.Elem().Interface())
	case reflect.Struct:
		return v.validateStruct(obj)
	case reflect.Slice, reflect.Array, reflect.Map:
		if tag, ok := typeTags[value.Type()]; ok {
			return v.validateVar(obj, tag)
		} else {
			return v.validateVar(obj, "dive")
		}
	default:
		return nil
	}
}

func (v *defaultValidator) validateStruct(obj interface{}) error {
	v.lazyinit()
	return v.validate.Struct(obj)
}

func (v *defaultValidator) validateVar(obj interface{}, tag string) error {
	v.lazyinit()
	return v.validate.Var(obj, tag)
}

func (v *defaultValidator) Engine() interface{} {
	v.lazyinit()
	return v.validate
}

func (v *defaultValidator) lazyinit() {
	v.once.Do(func() {
		v.validate = validator.New()
		v.validate.SetTagName("binding")
	})
}

binding.RegisterTypeTag(MyMap{}, "dive,keys,gt=5,endkeys,dive")

binding.RegisterTypeTag(MySlice{}, "gt=4,dive")