package extypes

import (
	"reflect"
)

type Slice[T any] []T

func NewSliceFrom[T any](slice []T) Slice[T] {
	s := make(Slice[T], len(slice))
	copy(s, slice)
	return s
}
func (s Slice[T]) Len() int        { return len(s) }
func (s Slice[T]) Cap() int        { return cap(s) }
func (s Slice[T]) Get(index int) T { return s[index] }
func (s Slice[T]) Last() T         { return s.Get(s.Len() - 1) }
func (s Slice[T]) First() T        { return s.Get(0) }

func (s Slice[T]) Index(el T) int {
	for i := range s {
		if reflect.DeepEqual(s[i], el) {
			return i
		}
	}
	return -1
}

func (s Slice[T]) Push(e T) Slice[T] { return append(s, e) }
func (s Slice[T]) Pop(index int) Slice[T] {
	if index == 0 {
		return s[1:]
	}
	out := make(Slice[T], s.Len()-1)
	copy(out, s[:index])
	copy(out[index:], s[index+1:])
	return out
}
func (s Slice[T]) Remove(el T) Slice[T] {
	index := s.Index(el)
	if index == -1 {
		return s
	}
	return s.Pop(index)
}

// Swap is mutable func
func (s Slice[T]) Swap(i, j int) Slice[T] {
	s[i], s[j] = s[j], s[i]
	return s
}

func (s Slice[T]) Equal(s2 Slice[T]) bool {
	if s.Len() != s2.Len() {
		return false
	}
	if s.Cap() != s2.Cap() {
		return false
	}
	for i := range s {
		if !reflect.DeepEqual(s[i], s2[i]) {
			return false
		}
	}
	return true
}

func (s Slice[T]) ToArray() []T {
	out := make([]T, len(s))
	copy(out, s)
	return out
}
func (s Slice[T]) ToAnyArray() []any {
	out := make([]any, len(s))
	for i, v := range s {
		out[i] = v
	}
	return out
}
func (s Slice[T]) ToSet() Set[T]     { return NewSetFrom(s) }
func (s Slice[T]) ToTuple() Tuple[T] { return NewTupleFrom(s) }

func (s Slice[T]) Filter(f func(e T) bool) Slice[T] {
	out := make(Slice[T], 0)
	for _, v := range s {
		if f(v) {
			out = append(out, v)
		}
	}
	return out
}
func (s Slice[T]) ForEach(f func(int, T)) Slice[T] {
	for i, v := range s {
		f(i, v)
	}
	return s
}

// Map is mutable func
func (s Slice[T]) Map(f func(e T) T) Slice[T] {
	for i, v := range s {
		s[i] = f(v)
	}
	return s
}