package extypes

import "reflect"

type HashMap[K comparable, V any] map[K]V

func NewMapFrom[K comparable, V any](m map[K]V) HashMap[K, V] {
	out := make(HashMap[K, V])
	for k, v := range m {
		out[k] = v
	}
	return out
}
func (m HashMap[K, V]) Len() int { return len(m) }
func (m HashMap[K, V]) Add(key K, val V) HashMap[K, V] {
	m[key] = val
	return m
}
func (m HashMap[K, V]) Remove(key K) HashMap[K, V] {
	delete(m, key)
	return m
}
func (m HashMap[K, V]) Get(key K) V { return m[key] }
func (m HashMap[K, V]) GetOrDefault(key K, def V) V {
	v, ok := m[key]
	if !ok {
		return def
	}
	return v
}
func (m HashMap[K, V]) Contains(key K) bool {
	_, ok := m[key]
	return ok
}
func (m HashMap[K, V]) IndexKey(key K) int {
	index := 0
	for k, _ := range m {
		if k == key {
			return index
		}
		index++
	}
	return -1
}
func (m HashMap[K, V]) IndexValue(value V) int {
	index := 0
	for _, v := range m {
		if reflect.DeepEqual(value, v) {
			return index
		}
		index++
	}
	return -1
}
func (m HashMap[K, V]) Keys() []K {
	keys := make([]K, 0, m.Len())
	for k := range m {
		keys = append(keys, k)
	}
	return keys
}
func (m HashMap[K, V]) Values() []V {
	values := make([]V, 0, m.Len())
	for _, v := range m {
		values = append(values, v)
	}
	return values
}
func (m HashMap[K, V]) Items() ([]K, []V) {
	keys := make(Slice[K], 0, m.Len())
	values := make(Slice[V], 0, m.Len())
	for k, v := range m {
		keys = keys.Push(k)
		values = values.Push(v)
	}
	return keys, values
}

func (m HashMap[K, V]) Filter(f func(K, V) bool) HashMap[K, V] {
	out := make(HashMap[K, V])
	for k, v := range m {
		if !f(k, v) {
			continue
		}
		out[k] = v
	}
	return out
}
func (m HashMap[K, V]) ForEach(f func(K, V)) HashMap[K, V] {
	for k, v := range m {
		f(k, v)
	}
	return m
}
func (m HashMap[K, V]) Map(f func(K, V) V) HashMap[K, V] {
	for k, v := range m {
		m[k] = f(k, v)
	}
	return m
}