// SPDX-FileCopyrightText: Copyright 2015-2025 go-swagger maintainers
// SPDX-License-Identifier: Apache-2.0

package validate

import (
	"reflect"

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

type schemaSliceValidator struct {
	Path            pathSegments
	In              string
	MaxItems        *int64
	MinItems        *int64
	UniqueItems     bool
	AdditionalItems *spec.SchemaOrBool
	Items           *spec.SchemaOrArray
	Root            any
	KnownFormats    strfmt.Registry
	Options         *SchemaValidatorOptions
}

func newSliceValidator(path pathSegments, in string,
	maxItems, minItems *int64, uniqueItems bool,
	additionalItems *spec.SchemaOrBool, items *spec.SchemaOrArray,
	root any, formats strfmt.Registry, opts *SchemaValidatorOptions,
) *schemaSliceValidator {
	if opts == nil {
		opts = new(SchemaValidatorOptions)
	}

	var v *schemaSliceValidator
	if opts.recycleValidators {
		v = validatorPools.sliceValidators.Borrow()
	} else {
		v = new(schemaSliceValidator)
	}

	v.Path = path
	v.In = in
	v.MaxItems = maxItems
	v.MinItems = minItems
	v.UniqueItems = uniqueItems
	v.AdditionalItems = additionalItems
	v.Items = items
	v.Root = root
	v.KnownFormats = formats
	v.Options = opts

	return v
}

func (s *schemaSliceValidator) Applies(source any, kind reflect.Kind) bool {
	_, ok := source.(*spec.Schema)
	r := ok && kind == reflect.Slice
	return r
}

func (s *schemaSliceValidator) Validate(data any) *Result {
	if s.Options.recycleValidators {
		defer func() {
			s.redeem()
		}()
	}

	var result *Result
	if s.Options.recycleResult {
		result = validatorPools.results.Borrow()
	} else {
		result = new(Result)
	}
	if data == nil {
		return result
	}
	val := reflect.ValueOf(data)
	size := val.Len()

	if s.Items != nil && s.Items.Schema != nil {
		for i := range size {
			// the index has to reach the constructor: the sub-validators that
			// report the error are built there, and setting the path afterwards
			// would leave them located on the array rather than on the item.
			validator := newSchemaValidator(s.Items.Schema, s.Root, s.Path.item(i), s.KnownFormats, s.Options)
			value := val.Index(i)
			result.mergeForSlice(val, i, validator.Validate(value.Interface()))
		}
	}

	itemsSize := 0
	if s.Items != nil && len(s.Items.Schemas) > 0 {
		itemsSize = len(s.Items.Schemas)
		for i := range itemsSize {
			if size <= i {
				break
			}

			validator := newSchemaValidator(&s.Items.Schemas[i], s.Root, s.Path.item(i), s.KnownFormats, s.Options)
			result.mergeForSlice(val, i, validator.Validate(val.Index(i).Interface()))
		}
	}
	if s.AdditionalItems != nil && itemsSize < size {
		if s.Items != nil && len(s.Items.Schemas) > 0 && !s.AdditionalItems.Allows {
			result.addErrorsAt(s.Path, arrayDoesNotAllowAdditionalItemsMsg())
		}
		if s.AdditionalItems.Schema != nil {
			for i := itemsSize; i < size-itemsSize+1; i++ {
				validator := newSchemaValidator(s.AdditionalItems.Schema, s.Root, s.Path.item(i), s.KnownFormats, s.Options)
				result.mergeForSlice(val, i, validator.Validate(val.Index(i).Interface()))
			}
		}
	}

	if s.MinItems != nil {
		if err := MinItems(s.Path.dotted(), s.In, int64(size), *s.MinItems); err != nil {
			result.addErrorsAt(s.Path, err)
		}
	}
	if s.MaxItems != nil {
		if err := MaxItems(s.Path.dotted(), s.In, int64(size), *s.MaxItems); err != nil {
			result.addErrorsAt(s.Path, err)
		}
	}
	if s.UniqueItems {
		if err := UniqueItems(s.Path.dotted(), s.In, val.Interface()); err != nil {
			result.addErrorsAt(s.Path, err)
		}
	}
	result.Inc()
	return result
}

func (s *schemaSliceValidator) setPath(path pathSegments) {
	s.Path = path
}

func (s *schemaSliceValidator) redeem() {
	validatorPools.sliceValidators.Redeem(s)
}