// Copyright 2015 go-swagger maintainers
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
//    http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.

package validate

import (
	"fmt"
	"reflect"

	"github.com/go-openapi/errors"
	"github.com/go-openapi/spec"
	"github.com/go-openapi/strfmt"
)

// An EntityValidator is an interface for things that can validate entities
type EntityValidator interface {
	Validate(interface{}) *Result
}

type valueValidator interface {
	SetPath(path string)
	Applies(interface{}, reflect.Kind) bool
	Validate(interface{}) *Result
}

type itemsValidator struct {
	items        *spec.Items
	root         interface{}
	path         string
	in           string
	validators   [6]valueValidator
	KnownFormats strfmt.Registry
	Options      *SchemaValidatorOptions
}

func newItemsValidator(path, in string, items *spec.Items, root interface{}, formats strfmt.Registry, opts *SchemaValidatorOptions) *itemsValidator {
	if opts == nil {
		opts = new(SchemaValidatorOptions)
	}

	var iv *itemsValidator
	if opts.recycleValidators {
		iv = poolOfItemsValidators.BorrowValidator()
	} else {
		iv = new(itemsValidator)
	}

	iv.path = path
	iv.in = in
	iv.items = items
	iv.root = root
	iv.KnownFormats = formats
	iv.Options = opts
	iv.validators = [6]valueValidator{
		iv.typeValidator(),
		iv.stringValidator(),
		iv.formatValidator(),
		iv.numberValidator(),
		iv.sliceValidator(),
		iv.commonValidator(),
	}
	return iv
}

func (i *itemsValidator) Validate(index int, data interface{}) *Result {
	if i.Options.recycleValidators {
		defer func() {
			i.redeemChildren()
			i.redeem()
		}()
	}

	tpe := reflect.TypeOf(data)
	kind := tpe.Kind()
	var mainResult *Result
	if i.Options.recycleResult {
		mainResult = poolOfResults.BorrowResult()
	} else {
		mainResult = new(Result)
	}

	path := fmt.Sprintf("%s.%d", i.path, index)

	for idx, validator := range i.validators {
		if !validator.Applies(i.root, kind) {
			if i.Options.recycleValidators {
				// Validate won't be called, so relinquish this validator
				if redeemableChildren, ok := validator.(interface{ redeemChildren() }); ok {
					redeemableChildren.redeemChildren()
				}
				if redeemable, ok := validator.(interface{ redeem() }); ok {
					redeemable.redeem()
				}
				i.validators[idx] = nil // prevents further (unsafe) usage
			}

			continue
		}

		validator.SetPath(path)
		result := validator.Validate(data)
		mainResult.Merge(result)
		mainResult.Inc()
		if result != nil && result.HasErrors() {
			break
		}
	}

	return mainResult
}

func (i *itemsValidator) typeValidator() valueValidator {
	return newTypeValidator(
		i.path,
		i.in,
		spec.StringOrArray([]string{i.items.Type}),
		i.items.Nullable,
		i.items.Format,
		i.Options,
	)
}

func (i *itemsValidator) commonValidator() valueValidator {
	return newBasicCommonValidator(
		"",
		i.in,
		i.items.Default,
		i.items.Enum,
		i.Options,
	)
}

func (i *itemsValidator) sliceValidator() valueValidator {
	return newBasicSliceValidator(
		"",
		i.in,
		i.items.Default,
		i.items.MaxItems,
		i.items.MinItems,
		i.items.UniqueItems,
		i.items.Items,
		i.root,
		i.KnownFormats,
		i.Options,
	)
}

func (i *itemsValidator) numberValidator() valueValidator {
	return newNumberValidator(
		"",
		i.in,
		i.items.Default,
		i.items.MultipleOf,
		i.items.Maximum,
		i.items.ExclusiveMaximum,
		i.items.Minimum,
		i.items.ExclusiveMinimum,
		i.items.Type,
		i.items.Format,
		i.Options,
	)
}

func (i *itemsValidator) stringValidator() valueValidator {
	return newStringValidator(
		"",
		i.in,
		i.items.Default,
		false, // Required
		false, // AllowEmpty
		i.items.MaxLength,
		i.items.MinLength,
		i.items.Pattern,
		i.Options,
	)
}

func (i *itemsValidator) formatValidator() valueValidator {
	return newFormatValidator(
		"",
		i.in,
		i.items.Format,
		i.KnownFormats,
		i.Options,
	)
}

func (i *itemsValidator) redeem() {
	poolOfItemsValidators.RedeemValidator(i)
}

func (i *itemsValidator) redeemChildren() {
	for idx, validator := range i.validators {
		if validator == nil {
			continue
		}
		if redeemableChildren, ok := validator.(interface{ redeemChildren() }); ok {
			redeemableChildren.redeemChildren()
		}
		if redeemable, ok := validator.(interface{ redeem() }); ok {
			redeemable.redeem()
		}
		i.validators[idx] = nil // free up allocated children if not in pool
	}
}

type basicCommonValidator struct {
	Path    string
	In      string
	Default interface{}
	Enum    []interface{}
	Options *SchemaValidatorOptions
}

func newBasicCommonValidator(path, in string, def interface{}, enum []interface{}, opts *SchemaValidatorOptions) *basicCommonValidator {
	if opts == nil {
		opts = new(SchemaValidatorOptions)
	}

	var b *basicCommonValidator
	if opts.recycleValidators {
		b = poolOfBasicCommonValidators.BorrowValidator()
	} else {
		b = new(basicCommonValidator)
	}

	b.Path = path
	b.In = in
	b.Default = def
	b.Enum = enum
	b.Options = opts

	return b
}

func (b *basicCommonValidator) SetPath(path string) {
	b.Path = path
}

func (b *basicCommonValidator) Applies(source interface{}, _ reflect.Kind) bool {
	switch source.(type) {
	case *spec.Parameter, *spec.Schema, *spec.Header:
		return true
	default:
		return false
	}
}

func (b *basicCommonValidator) Validate(data interface{}) (res *Result) {
	if b.Options.recycleValidators {
		defer func() {
			b.redeem()
		}()
	}

	if len(b.Enum) == 0 {
		return nil
	}

	for _, enumValue := range b.Enum {
		actualType := reflect.TypeOf(enumValue)
		if actualType == nil { // Safeguard
			continue
		}

		expectedValue := reflect.ValueOf(data)
		if expectedValue.IsValid() &&
			expectedValue.Type().ConvertibleTo(actualType) &&
			reflect.DeepEqual(expectedValue.Convert(actualType).Interface(), enumValue) {
			return nil
		}
	}

	return errorHelp.sErr(errors.EnumFail(b.Path, b.In, data, b.Enum), b.Options.recycleResult)
}

func (b *basicCommonValidator) redeem() {
	poolOfBasicCommonValidators.RedeemValidator(b)
}

// A HeaderValidator has very limited subset of validations to apply
type HeaderValidator struct {
	name         string
	header       *spec.Header
	validators   [6]valueValidator
	KnownFormats strfmt.Registry
	Options      *SchemaValidatorOptions
}

// NewHeaderValidator creates a new header validator object
func NewHeaderValidator(name string, header *spec.Header, formats strfmt.Registry, options ...Option) *HeaderValidator {
	opts := new(SchemaValidatorOptions)
	for _, o := range options {
		o(opts)
	}

	return newHeaderValidator(name, header, formats, opts)
}

func newHeaderValidator(name string, header *spec.Header, formats strfmt.Registry, opts *SchemaValidatorOptions) *HeaderValidator {
	if opts == nil {
		opts = new(SchemaValidatorOptions)
	}

	var p *HeaderValidator
	if opts.recycleValidators {
		p = poolOfHeaderValidators.BorrowValidator()
	} else {
		p = new(HeaderValidator)
	}

	p.name = name
	p.header = header
	p.KnownFormats = formats
	p.Options = opts
	p.validators = [6]valueValidator{
		newTypeValidator(
			name,
			"header",
			spec.StringOrArray([]string{header.Type}),
			header.Nullable,
			header.Format,
			p.Options,
		),
		p.stringValidator(),
		p.formatValidator(),
		p.numberValidator(),
		p.sliceValidator(),
		p.commonValidator(),
	}

	return p
}

// Validate the value of the header against its schema
func (p *HeaderValidator) Validate(data interface{}) *Result {
	if p.Options.recycleValidators {
		defer func() {
			p.redeemChildren()
			p.redeem()
		}()
	}

	if data == nil {
		return nil
	}

	var result *Result
	if p.Options.recycleResult {
		result = poolOfResults.BorrowResult()
	} else {
		result = new(Result)
	}

	tpe := reflect.TypeOf(data)
	kind := tpe.Kind()

	for idx, validator := range p.validators {
		if !validator.Applies(p.header, kind) {
			if p.Options.recycleValidators {
				// Validate won't be called, so relinquish this validator
				if redeemableChildren, ok := validator.(interface{ redeemChildren() }); ok {
					redeemableChildren.redeemChildren()
				}
				if redeemable, ok := validator.(interface{ redeem() }); ok {
					redeemable.redeem()
				}
				p.validators[idx] = nil // prevents further (unsafe) usage
			}

			continue
		}

		if err := validator.Validate(data); err != nil {
			result.Merge(err)
			if err.HasErrors() {
				break
			}
		}
	}
	return result
}

func (p *HeaderValidator) commonValidator() valueValidator {
	return newBasicCommonValidator(
		p.name,
		"response",
		p.header.Default,
		p.header.Enum,
		p.Options,
	)
}

func (p *HeaderValidator) sliceValidator() valueValidator {
	return newBasicSliceValidator(
		p.name,
		"response",
		p.header.Default,
		p.header.MaxItems,
		p.header.MinItems,
		p.header.UniqueItems,
		p.header.Items,
		p.header,
		p.KnownFormats,
		p.Options,
	)
}

func (p *HeaderValidator) numberValidator() valueValidator {
	return newNumberValidator(
		p.name,
		"response",
		p.header.Default,
		p.header.MultipleOf,
		p.header.Maximum,
		p.header.ExclusiveMaximum,
		p.header.Minimum,
		p.header.ExclusiveMinimum,
		p.header.Type,
		p.header.Format,
		p.Options,
	)
}

func (p *HeaderValidator) stringValidator() valueValidator {
	return newStringValidator(
		p.name,
		"response",
		p.header.Default,
		true,
		false,
		p.header.MaxLength,
		p.header.MinLength,
		p.header.Pattern,
		p.Options,
	)
}

func (p *HeaderValidator) formatValidator() valueValidator {
	return newFormatValidator(
		p.name,
		"response",
		p.header.Format,
		p.KnownFormats,
		p.Options,
	)
}

func (p *HeaderValidator) redeem() {
	poolOfHeaderValidators.RedeemValidator(p)
}

func (p *HeaderValidator) redeemChildren() {
	for idx, validator := range p.validators {
		if validator == nil {
			continue
		}
		if redeemableChildren, ok := validator.(interface{ redeemChildren() }); ok {
			redeemableChildren.redeemChildren()
		}
		if redeemable, ok := validator.(interface{ redeem() }); ok {
			redeemable.redeem()
		}
		p.validators[idx] = nil // free up allocated children if not in pool
	}
}

// A ParamValidator has very limited subset of validations to apply
type ParamValidator struct {
	param        *spec.Parameter
	validators   [6]valueValidator
	KnownFormats strfmt.Registry
	Options      *SchemaValidatorOptions
}

// NewParamValidator creates a new param validator object
func NewParamValidator(param *spec.Parameter, formats strfmt.Registry, options ...Option) *ParamValidator {
	opts := new(SchemaValidatorOptions)
	for _, o := range options {
		o(opts)
	}

	return newParamValidator(param, formats, opts)
}

func newParamValidator(param *spec.Parameter, formats strfmt.Registry, opts *SchemaValidatorOptions) *ParamValidator {
	if opts == nil {
		opts = new(SchemaValidatorOptions)
	}

	var p *ParamValidator
	if opts.recycleValidators {
		p = poolOfParamValidators.BorrowValidator()
	} else {
		p = new(ParamValidator)
	}

	p.param = param
	p.KnownFormats = formats
	p.Options = opts
	p.validators = [6]valueValidator{
		newTypeValidator(
			param.Name,
			param.In,
			spec.StringOrArray([]string{param.Type}),
			param.Nullable,
			param.Format,
			p.Options,
		),
		p.stringValidator(),
		p.formatValidator(),
		p.numberValidator(),
		p.sliceValidator(),
		p.commonValidator(),
	}

	return p
}

// Validate the data against the description of the parameter
func (p *ParamValidator) Validate(data interface{}) *Result {
	if data == nil {
		return nil
	}

	var result *Result
	if p.Options.recycleResult {
		result = poolOfResults.BorrowResult()
	} else {
		result = new(Result)
	}

	tpe := reflect.TypeOf(data)
	kind := tpe.Kind()

	if p.Options.recycleValidators {
		defer func() {
			p.redeemChildren()
			p.redeem()
		}()
	}

	// TODO: validate type
	for idx, validator := range p.validators {
		if !validator.Applies(p.param, kind) {
			if p.Options.recycleValidators {
				// Validate won't be called, so relinquish this validator
				if redeemableChildren, ok := validator.(interface{ redeemChildren() }); ok {
					redeemableChildren.redeemChildren()
				}
				if redeemable, ok := validator.(interface{ redeem() }); ok {
					redeemable.redeem()
				}
				p.validators[idx] = nil // prevents further (unsafe) usage
			}

			continue
		}

		if err := validator.Validate(data); err != nil {
			result.Merge(err)
			if err.HasErrors() {
				break
			}
		}
	}

	return result
}

func (p *ParamValidator) commonValidator() valueValidator {
	return newBasicCommonValidator(
		p.param.Name,
		p.param.In,
		p.param.Default,
		p.param.Enum,
		p.Options,
	)
}

func (p *ParamValidator) sliceValidator() valueValidator {
	return newBasicSliceValidator(
		p.param.Name,
		p.param.In,
		p.param.Default,
		p.param.MaxItems,
		p.param.MinItems,
		p.param.UniqueItems,
		p.param.Items,
		p.param,
		p.KnownFormats,
		p.Options,
	)
}

func (p *ParamValidator) numberValidator() valueValidator {
	return newNumberValidator(
		p.param.Name,
		p.param.In,
		p.param.Default,
		p.param.MultipleOf,
		p.param.Maximum,
		p.param.ExclusiveMaximum,
		p.param.Minimum,
		p.param.ExclusiveMinimum,
		p.param.Type,
		p.param.Format,
		p.Options,
	)
}

func (p *ParamValidator) stringValidator() valueValidator {
	return newStringValidator(
		p.param.Name,
		p.param.In,
		p.param.Default,
		p.param.Required,
		p.param.AllowEmptyValue,
		p.param.MaxLength,
		p.param.MinLength,
		p.param.Pattern,
		p.Options,
	)
}

func (p *ParamValidator) formatValidator() valueValidator {
	return newFormatValidator(
		p.param.Name,
		p.param.In,
		p.param.Format,
		p.KnownFormats,
		p.Options,
	)
}

func (p *ParamValidator) redeem() {
	poolOfParamValidators.RedeemValidator(p)
}

func (p *ParamValidator) redeemChildren() {
	for idx, validator := range p.validators {
		if validator == nil {
			continue
		}
		if redeemableChildren, ok := validator.(interface{ redeemChildren() }); ok {
			redeemableChildren.redeemChildren()
		}
		if redeemable, ok := validator.(interface{ redeem() }); ok {
			redeemable.redeem()
		}
		p.validators[idx] = nil // free up allocated children if not in pool
	}
}

type basicSliceValidator struct {
	Path         string
	In           string
	Default      interface{}
	MaxItems     *int64
	MinItems     *int64
	UniqueItems  bool
	Items        *spec.Items
	Source       interface{}
	KnownFormats strfmt.Registry
	Options      *SchemaValidatorOptions
}

func newBasicSliceValidator(
	path, in string,
	def interface{}, maxItems, minItems *int64, uniqueItems bool, items *spec.Items,
	source interface{}, formats strfmt.Registry,
	opts *SchemaValidatorOptions) *basicSliceValidator {
	if opts == nil {
		opts = new(SchemaValidatorOptions)
	}

	var s *basicSliceValidator
	if opts.recycleValidators {
		s = poolOfBasicSliceValidators.BorrowValidator()
	} else {
		s = new(basicSliceValidator)
	}

	s.Path = path
	s.In = in
	s.Default = def
	s.MaxItems = maxItems
	s.MinItems = minItems
	s.UniqueItems = uniqueItems
	s.Items = items
	s.Source = source
	s.KnownFormats = formats
	s.Options = opts

	return s
}

func (s *basicSliceValidator) SetPath(path string) {
	s.Path = path
}

func (s *basicSliceValidator) Applies(source interface{}, kind reflect.Kind) bool {
	switch source.(type) {
	case *spec.Parameter, *spec.Items, *spec.Header:
		return kind == reflect.Slice
	default:
		return false
	}
}

func (s *basicSliceValidator) Validate(data interface{}) *Result {
	if s.Options.recycleValidators {
		defer func() {
			s.redeem()
		}()
	}
	val := reflect.ValueOf(data)

	size := int64(val.Len())
	if s.MinItems != nil {
		if err := MinItems(s.Path, s.In, size, *s.MinItems); err != nil {
			return errorHelp.sErr(err, s.Options.recycleResult)
		}
	}

	if s.MaxItems != nil {
		if err := MaxItems(s.Path, s.In, size, *s.MaxItems); err != nil {
			return errorHelp.sErr(err, s.Options.recycleResult)
		}
	}

	if s.UniqueItems {
		if err := UniqueItems(s.Path, s.In, data); err != nil {
			return errorHelp.sErr(err, s.Options.recycleResult)
		}
	}

	if s.Items == nil {
		return nil
	}

	for i := 0; i < int(size); i++ {
		itemsValidator := newItemsValidator(s.Path, s.In, s.Items, s.Source, s.KnownFormats, s.Options)
		ele := val.Index(i)
		if err := itemsValidator.Validate(i, ele.Interface()); err != nil && err.HasErrors() {
			return err
		}
	}

	return nil
}

func (s *basicSliceValidator) redeem() {
	poolOfBasicSliceValidators.RedeemValidator(s)
}

type numberValidator struct {
	Path             string
	In               string
	Default          interface{}
	MultipleOf       *float64
	Maximum          *float64
	ExclusiveMaximum bool
	Minimum          *float64
	ExclusiveMinimum bool
	// Allows for more accurate behavior regarding integers
	Type    string
	Format  string
	Options *SchemaValidatorOptions
}

func newNumberValidator(
	path, in string, def interface{},
	multipleOf, maximum *float64, exclusiveMaximum bool, minimum *float64, exclusiveMinimum bool,
	typ, format string,
	opts *SchemaValidatorOptions) *numberValidator {
	if opts == nil {
		opts = new(SchemaValidatorOptions)
	}

	var n *numberValidator
	if opts.recycleValidators {
		n = poolOfNumberValidators.BorrowValidator()
	} else {
		n = new(numberValidator)
	}

	n.Path = path
	n.In = in
	n.Default = def
	n.MultipleOf = multipleOf
	n.Maximum = maximum
	n.ExclusiveMaximum = exclusiveMaximum
	n.Minimum = minimum
	n.ExclusiveMinimum = exclusiveMinimum
	n.Type = typ
	n.Format = format
	n.Options = opts

	return n
}

func (n *numberValidator) SetPath(path string) {
	n.Path = path
}

func (n *numberValidator) Applies(source interface{}, kind reflect.Kind) bool {
	switch source.(type) {
	case *spec.Parameter, *spec.Schema, *spec.Items, *spec.Header:
		isInt := kind >= reflect.Int && kind <= reflect.Uint64
		isFloat := kind == reflect.Float32 || kind == reflect.Float64
		return isInt || isFloat
	default:
		return false
	}
}

// Validate provides a validator for generic JSON numbers,
//
// By default, numbers are internally represented as float64.
// Formats float, or float32 may alter this behavior by mapping to float32.
// A special validation process is followed for integers, with optional "format":
// this is an attempt to provide a validation with native types.
//
// NOTE: since the constraint specified (boundary, multipleOf) is unmarshalled
// as float64, loss of information remains possible (e.g. on very large integers).
//
// Since this value directly comes from the unmarshalling, it is not possible
// at this stage of processing to check further and guarantee the correctness of such values.
//
// Normally, the JSON Number.MAX_SAFE_INTEGER (resp. Number.MIN_SAFE_INTEGER)
// would check we do not get such a loss.
//
// If this is the case, replace AddErrors() by AddWarnings() and IsValid() by !HasWarnings().
//
// TODO: consider replacing boundary check errors by simple warnings.
//
// TODO: default boundaries with MAX_SAFE_INTEGER are not checked (specific to json.Number?)
func (n *numberValidator) Validate(val interface{}) *Result {
	if n.Options.recycleValidators {
		defer func() {
			n.redeem()
		}()
	}

	var res *Result
	if n.Options.recycleResult {
		res = poolOfResults.BorrowResult()
	} else {
		res = new(Result)
	}

	resMultiple := poolOfResults.BorrowResult()
	resMinimum := poolOfResults.BorrowResult()
	resMaximum := poolOfResults.BorrowResult()

	// Used only to attempt to validate constraint on value,
	// even though value or constraint specified do not match type and format
	data := valueHelp.asFloat64(val)

	// Is the provided value within the range of the specified numeric type and format?
	res.AddErrors(IsValueValidAgainstRange(val, n.Type, n.Format, "Checked", n.Path))

	if n.MultipleOf != nil {
		// Is the constraint specifier within the range of the specific numeric type and format?
		resMultiple.AddErrors(IsValueValidAgainstRange(*n.MultipleOf, n.Type, n.Format, "MultipleOf", n.Path))
		if resMultiple.IsValid() {
			// Constraint validated with compatible types
			if err := MultipleOfNativeType(n.Path, n.In, val, *n.MultipleOf); err != nil {
				resMultiple.Merge(errorHelp.sErr(err, n.Options.recycleResult))
			}
		} else {
			// Constraint nevertheless validated, converted as general number
			if err := MultipleOf(n.Path, n.In, data, *n.MultipleOf); err != nil {
				resMultiple.Merge(errorHelp.sErr(err, n.Options.recycleResult))
			}
		}
	}

	if n.Maximum != nil {
		// Is the constraint specifier within the range of the specific numeric type and format?
		resMaximum.AddErrors(IsValueValidAgainstRange(*n.Maximum, n.Type, n.Format, "Maximum boundary", n.Path))
		if resMaximum.IsValid() {
			// Constraint validated with compatible types
			if err := MaximumNativeType(n.Path, n.In, val, *n.Maximum, n.ExclusiveMaximum); err != nil {
				resMaximum.Merge(errorHelp.sErr(err, n.Options.recycleResult))
			}
		} else {
			// Constraint nevertheless validated, converted as general number
			if err := Maximum(n.Path, n.In, data, *n.Maximum, n.ExclusiveMaximum); err != nil {
				resMaximum.Merge(errorHelp.sErr(err, n.Options.recycleResult))
			}
		}
	}

	if n.Minimum != nil {
		// Is the constraint specifier within the range of the specific numeric type and format?
		resMinimum.AddErrors(IsValueValidAgainstRange(*n.Minimum, n.Type, n.Format, "Minimum boundary", n.Path))
		if resMinimum.IsValid() {
			// Constraint validated with compatible types
			if err := MinimumNativeType(n.Path, n.In, val, *n.Minimum, n.ExclusiveMinimum); err != nil {
				resMinimum.Merge(errorHelp.sErr(err, n.Options.recycleResult))
			}
		} else {
			// Constraint nevertheless validated, converted as general number
			if err := Minimum(n.Path, n.In, data, *n.Minimum, n.ExclusiveMinimum); err != nil {
				resMinimum.Merge(errorHelp.sErr(err, n.Options.recycleResult))
			}
		}
	}
	res.Merge(resMultiple, resMinimum, resMaximum)
	res.Inc()
	return res
}

func (n *numberValidator) redeem() {
	poolOfNumberValidators.RedeemValidator(n)
}

type stringValidator struct {
	Path            string
	In              string
	Default         interface{}
	Required        bool
	AllowEmptyValue bool
	MaxLength       *int64
	MinLength       *int64
	Pattern         string
	Options         *SchemaValidatorOptions
}

func newStringValidator(
	path, in string,
	def interface{}, required, allowEmpty bool, maxLength, minLength *int64, pattern string,
	opts *SchemaValidatorOptions) *stringValidator {
	if opts == nil {
		opts = new(SchemaValidatorOptions)
	}

	var s *stringValidator
	if opts.recycleValidators {
		s = poolOfStringValidators.BorrowValidator()
	} else {
		s = new(stringValidator)
	}

	s.Path = path
	s.In = in
	s.Default = def
	s.Required = required
	s.AllowEmptyValue = allowEmpty
	s.MaxLength = maxLength
	s.MinLength = minLength
	s.Pattern = pattern
	s.Options = opts

	return s
}

func (s *stringValidator) SetPath(path string) {
	s.Path = path
}

func (s *stringValidator) Applies(source interface{}, kind reflect.Kind) bool {
	switch source.(type) {
	case *spec.Parameter, *spec.Schema, *spec.Items, *spec.Header:
		return kind == reflect.String
	default:
		return false
	}
}

func (s *stringValidator) Validate(val interface{}) *Result {
	if s.Options.recycleValidators {
		defer func() {
			s.redeem()
		}()
	}

	data, ok := val.(string)
	if !ok {
		return errorHelp.sErr(errors.InvalidType(s.Path, s.In, stringType, val), s.Options.recycleResult)
	}

	if s.Required && !s.AllowEmptyValue && (s.Default == nil || s.Default == "") {
		if err := RequiredString(s.Path, s.In, data); err != nil {
			return errorHelp.sErr(err, s.Options.recycleResult)
		}
	}

	if s.MaxLength != nil {
		if err := MaxLength(s.Path, s.In, data, *s.MaxLength); err != nil {
			return errorHelp.sErr(err, s.Options.recycleResult)
		}
	}

	if s.MinLength != nil {
		if err := MinLength(s.Path, s.In, data, *s.MinLength); err != nil {
			return errorHelp.sErr(err, s.Options.recycleResult)
		}
	}

	if s.Pattern != "" {
		if err := Pattern(s.Path, s.In, data, s.Pattern); err != nil {
			return errorHelp.sErr(err, s.Options.recycleResult)
		}
	}
	return nil
}

func (s *stringValidator) redeem() {
	poolOfStringValidators.RedeemValidator(s)
}
