package testutils

import (
	"reflect"
	"sort"

	"github.com/golang/mock/gomock"

	"github.com/ethereum/go-ethereum/common"
)

const EthSymbol = "ETH"
const SntSymbol = "SNT"
const DaiSymbol = "DAI"

func SliceContains[T comparable](slice []T, value T) bool {
	for _, v := range slice {
		if v == value {
			return true
		}
	}
	return false
}
func StructExistsInSlice[T any](target T, slice []T) bool {
	for _, item := range slice {
		if reflect.DeepEqual(target, item) {
			return true
		}
	}
	return false
}

func Filter[T any](ss []T, test func(T) bool) (ret []T) {
	for _, s := range ss {
		if test(s) {
			ret = append(ret, s)
		}
	}
	return
}

// AddressSliceMatcher is a custom matcher for comparing common.Address slices regardless of order.
type AddressSliceMatcher struct {
	expected []common.Address
}

func NewAddressSliceMatcher(expected []common.Address) gomock.Matcher {
	return &AddressSliceMatcher{expected: expected}
}

func (m *AddressSliceMatcher) Matches(x interface{}) bool {
	actual, ok := x.([]common.Address)
	if !ok {
		return false
	}

	if len(m.expected) != len(actual) {
		return false
	}

	// Create copies of the slices to sort them
	expectedCopy := make([]common.Address, len(m.expected))
	actualCopy := make([]common.Address, len(actual))
	copy(expectedCopy, m.expected)
	copy(actualCopy, actual)

	sort.Slice(expectedCopy, func(i, j int) bool { return expectedCopy[i].Hex() < expectedCopy[j].Hex() })
	sort.Slice(actualCopy, func(i, j int) bool { return actualCopy[i].Hex() < actualCopy[j].Hex() })

	for i := range expectedCopy {
		if expectedCopy[i] != actualCopy[i] {
			return false
		}
	}

	return true
}

func (m *AddressSliceMatcher) String() string {
	return "matches Address slice regardless of order"
}

// Uint64SliceMatcher is a custom matcher for comparing uint64 slices regardless of order.
type Uint64SliceMatcher struct {
	expected []uint64
}

func NewUint64SliceMatcher(expected []uint64) gomock.Matcher {
	return &Uint64SliceMatcher{expected: expected}
}

func (m *Uint64SliceMatcher) Matches(x interface{}) bool {
	actual, ok := x.([]uint64)
	if !ok {
		return false
	}

	if len(m.expected) != len(actual) {
		return false
	}

	// Create copies of the slices to sort them
	expectedCopy := make([]uint64, len(m.expected))
	actualCopy := make([]uint64, len(actual))
	copy(expectedCopy, m.expected)
	copy(actualCopy, actual)

	sort.Slice(expectedCopy, func(i, j int) bool { return expectedCopy[i] < expectedCopy[j] })
	sort.Slice(actualCopy, func(i, j int) bool { return actualCopy[i] < actualCopy[j] })

	for i := range expectedCopy {
		if expectedCopy[i] != actualCopy[i] {
			return false
		}
	}

	return true
}

func (m *Uint64SliceMatcher) String() string {
	return "matches uint64 slice regardless of order"
}