package util

import "encoding/json"

type present struct{}

type Set[T comparable] map[T]present

func NewSet[T comparable](elements ...T) Set[T] {
	set := Set[T]{}

	for _, elem := range elements {
		set.Add(elem)
	}

	return set
}

func (set Set[T]) Has(value T) bool {
	_, present := set[value]
	return present
}

func (set Set[T]) HasAny(values ...T) bool {
	for _, value := range values {
		if _, present := set[value]; present {
			return true
		}
	}
	return false
}

func (set Set[T]) Contains(other Set[T]) bool {
	for v := range other {
		if !set.Has(v) {
			return false
		}
	}
	return true
}

func (set Set[T]) Add(value T) {
	set[value] = present{}
}

func (set Set[T]) Remove(value T) {
	delete(set, value)
}

func (set Set[T]) Elements() []T {
	elements := []T{}

	for elem := range set {
		elements = append(elements, elem)
	}

	return elements
}

func (set Set[T]) MarshalJSON() ([]byte, error) {
	return json.Marshal(set.Elements())
}

func (set Set[T]) UnmarshalJSON(data []byte) error {
	elements := []T{}
	if err := json.Unmarshal(data, &elements); err != nil {
		return err
	}

	for _, v := range elements {
		set.Add(v)
	}

	return nil
}