package assert

import (
	"reflect"
	"strings"
)

// Contains asserts that a contains b
func Contains(t test, container any, element any) {
	if contains(container, element) {
		return
	}

	t.Errorf(formatMessage("Contains", element, container))
	t.FailNow()
}

// NotContains asserts that a doesn't contain b
func NotContains(t test, container any, element any) {
	if !contains(container, element) {
		return
	}

	t.Errorf(formatMessage("NotContains", element, container))
	t.FailNow()
}

// contains returns whether container contains the given element
func contains(container any, element any) bool {
	containerValue := reflect.ValueOf(container)

	switch containerValue.Kind() {
	case reflect.String:
		elementValue := reflect.ValueOf(element)
		return strings.Contains(containerValue.String(), elementValue.String())

	case reflect.Map:
		keys := containerValue.MapKeys()
		for _, key := range keys {
			if key.Interface() == element {
				return true
			}
		}

	case reflect.Slice:
		elementValue := reflect.ValueOf(element)

		if elementValue.Kind() == reflect.Slice {
			elementLength := elementValue.Len()

			if elementLength == 0 {
				return true
			}

			if elementLength > containerValue.Len() {
				return false
			}

			// Check for subsequence
			for i := 0; i <= containerValue.Len()-elementLength; i++ {
				match := true
				for j := range elementLength {
					if containerValue.Index(i+j).Interface() != elementValue.Index(j).Interface() {
						match = false
						break
					}
				}
				if match {
					return true
				}
			}
			return false
		}

		// Check for single element
		for i := range containerValue.Len() {
			if containerValue.Index(i).Interface() == element {
				return true
			}
		}
	}

	return false
}