package g

import "fmt"

// Set is a generic alias for a set implemented using a map.
type Set[T comparable] map[T]Unit

// NewSet creates a new Set of the specified size or an empty Set if no size is provided.
func NewSet[T comparable](size ...Int) Set[T] {
	if len(size) > 0 {
		return make(Set[T], size[0])
	}

	return make(Set[T])
}

// SetOf creates a new generic set containing the provided elements.
func SetOf[T comparable](values ...T) Set[T] {
	set := make(Set[T], len(values))
	for _, v := range values {
		set[v] = Unit{}
	}

	return set
}

// Transform applies a transformation function to the Set and returns the result.
func (s Set[T]) Transform[U any](fn func(Set[T]) U) U { return fn(s) }

// Iter returns an iterator (Seq[T]) for the Set, allowing for sequential iteration
// over its elements. It is commonly used in combination with higher-order functions,
// such as 'ForEach' or 'Map', to perform operations on each element of the Set.
//
// Returns:
//
// A Seq[T], which can be used for sequential iteration over the elements of the Set.
//
// Example usage:
//
//	g.SetOf(1, 2, 3).Iter().ForEach(func(val int) {
//	    fmt.Println(val) // Replace this with the function logic you need.
//	})
//
// The 'Iter' method provides a convenient way to traverse the elements of a Set
// in a functional style, enabling operations like mapping or filtering.
func (s Set[T]) Iter() Seq[T] {
	return func(yield func(T) bool) {
		for v := range s {
			if !yield(v) {
				return
			}
		}
	}
}

// Insert adds the provided elements to the set.
func (s Set[T]) Insert(values ...T) {
	for _, v := range values {
		s[v] = Unit{}
	}
}

// Remove removes the specified value from the Set and returns true if it was present.
func (s Set[T]) Remove(v T) bool {
	if _, ok := s[v]; ok {
		delete(s, v)
		return true
	}

	return false
}

// Len returns the number of values in the Set.
func (s Set[T]) Len() Int { return Int(len(s)) }

// Contains checks if the Set contains the specified value.
func (s Set[T]) Contains(v T) bool {
	_, ok := s[v]
	return ok
}

// ContainsAny checks if the Set contains any of the provided values, matching
// the variadic shape of Slice.ContainsAny and String.ContainsAny.
func (s Set[T]) ContainsAny(values ...T) bool {
	for _, v := range values {
		if _, ok := s[v]; ok {
			return true
		}
	}

	return false
}

// ContainsAll checks if the Set contains all of the provided values, matching
// the variadic shape of Slice.ContainsAll and String.ContainsAll.
func (s Set[T]) ContainsAll(values ...T) bool {
	for _, v := range values {
		if _, ok := s[v]; !ok {
			return false
		}
	}

	return true
}

// Clone creates a new Set that is a copy of the original Set.
func (s Set[T]) Clone() Set[T] {
	if s.IsEmpty() {
		return NewSet[T]()
	}

	clone := make(Set[T], len(s))
	for k := range s {
		clone[k] = Unit{}
	}

	return clone
}

// Intersection returns the intersection of the current set and another set, i.e., elements
// present in both sets.
//
// Parameters:
//
// - other Set[T]: The other set to calculate the intersection with.
//
// Returns:
//
// - Set[T]: A new Set containing the intersection of the two sets.
//
// Example usage:
//
//	s1 := g.SetOf(1, 2, 3, 4, 5)
//	s2 := g.SetOf(4, 5, 6, 7, 8)
//	intersection := s1.Intersection(s2)
//
// The resulting intersection will be: [4, 5].
func (s Set[T]) Intersection(other Set[T]) Set[T] {
	small, big := s, other
	if len(big) < len(small) {
		small, big = big, small
	}

	result := make(Set[T], len(small))

	for v := range small {
		if big.Contains(v) {
			result[v] = Unit{}
		}
	}

	return result
}

// Difference returns the difference between the current set and another set,
// i.e., elements present in the current set but not in the other set.
//
// Parameters:
//
// - other Set[T]: The other set to calculate the difference with.
//
// Returns:
//
// - Set[T]: A new Set containing the difference between the two sets.
//
// Example usage:
//
//	s1 := g.SetOf(1, 2, 3, 4, 5)
//	s2 := g.SetOf(4, 5, 6, 7, 8)
//	diff := s1.Difference(s2)
//
// The resulting diff will be: [1, 2, 3].
func (s Set[T]) Difference(other Set[T]) Set[T] {
	result := make(Set[T], len(s))

	for v := range s {
		if !other.Contains(v) {
			result[v] = Unit{}
		}
	}

	return result
}

// Union returns a new set containing the unique elements of the current set and the provided
// other set.
//
// Parameters:
//
// - other Set[T]: The other set to create the union with.
//
// Returns:
//
// - Set[T]: A new Set containing the unique elements of the current set and the provided
// other set.
//
// Example usage:
//
//	s1 := g.SetOf(1, 2, 3)
//	s2 := g.SetOf(3, 4, 5)
//	union := s1.Union(s2)
//
// The resulting union set will be: [1, 2, 3, 4, 5].
func (s Set[T]) Union(other Set[T]) Set[T] {
	result := make(Set[T], len(s)+len(other))

	for v := range s {
		result[v] = Unit{}
	}

	for v := range other {
		result[v] = Unit{}
	}

	return result
}

// SymmetricDifference returns the symmetric difference between the current set and another
// set, i.e., elements present in either the current set or the other set but not in both.
//
// Parameters:
//
// - other Set[T]: The other set to calculate the symmetric difference with.
//
// Returns:
//
// - Set[T]: A new Set containing the symmetric difference between the two sets.
//
// Example usage:
//
//	s1 := g.SetOf(1, 2, 3, 4, 5)
//	s2 := g.SetOf(4, 5, 6, 7, 8)
//	symDiff := s1.SymmetricDifference(s2)
//
// The resulting symDiff will be: [1, 2, 3, 6, 7, 8].
func (s Set[T]) SymmetricDifference(other Set[T]) Set[T] {
	result := make(Set[T])

	for v := range s {
		if !other.Contains(v) {
			result[v] = Unit{}
		}
	}

	for v := range other {
		if !s.Contains(v) {
			result[v] = Unit{}
		}
	}

	return result
}

// Subset checks if the current set 's' is a subset of the provided 'other' set.
// A set 's' is a subset of 'other' if all elements of 's' are also elements of 'other'.
//
// Parameters:
//
// - other Set[T]: The other set to compare with.
//
// Returns:
//
// - bool: true if 's' is a subset of 'other', false otherwise.
//
// Example usage:
//
//	s1 := g.SetOf(1, 2, 3)
//	s2 := g.SetOf(1, 2, 3, 4, 5)
//	isSubset := s1.Subset(s2) // Returns true
func (s Set[T]) Subset(other Set[T]) bool {
	if len(s) > len(other) {
		return false
	}

	for v := range s {
		if _, ok := other[v]; !ok {
			return false
		}
	}

	return true
}

// Superset checks if the current set 's' is a superset of the provided 'other' set.
// A set 's' is a superset of 'other' if all elements of 'other' are also elements of 's'.
//
// Parameters:
//
// - other Set[T]: The other set to compare with.
//
// Returns:
//
// - bool: true if 's' is a superset of 'other', false otherwise.
//
// Example usage:
//
//	s1 := g.SetOf(1, 2, 3, 4, 5)
//	s2 := g.SetOf(1, 2, 3)
//	isSuperset := s1.Superset(s2) // Returns true
func (s Set[T]) Superset(other Set[T]) bool { return other.Subset(s) }

// Eq checks if two Sets are equal.
func (s Set[T]) Eq(other Set[T]) bool {
	if len(s) != len(other) {
		return false
	}

	for v := range other {
		if _, ok := s[v]; !ok {
			return false
		}
	}

	return true
}

// Ne checks if two Sets are not equal.
func (s Set[T]) Ne(other Set[T]) bool { return !s.Eq(other) }

// Clear removes all values from the Set.
func (s Set[T]) Clear() { clear(s) }

// IsEmpty checks if the Set is empty.
func (s Set[T]) IsEmpty() bool { return len(s) == 0 }

// String returns a string representation of the Set.
func (s Set[T]) String() string {
	if s.IsEmpty() {
		return "Set{}"
	}

	var b Builder
	b.Grow(Int(len(s)) * 8)
	b.WriteString("Set{")

	first := true
	for v := range s {
		if !first {
			b.WriteString(", ")
		}

		first = false
		fmt.Fprint(&b, v)
	}

	b.WriteString("}")

	return b.String().Std()
}

// Disjoint reports whether the set has no elements in common with other.
// It is the complement of ContainsAny.
func (s Set[T]) Disjoint(other Set[T]) bool {
	small, big := s, other
	if len(big) < len(small) {
		small, big = big, small
	}

	for v := range small {
		if _, ok := big[v]; ok {
			return false
		}
	}

	return true
}

// Print writes the elements of the Set to the standard output (console)
// and returns the Set unchanged.
func (s Set[T]) Print() Set[T] { fmt.Print(s); return s }

// Println writes the elements of the Set to the standard output (console) with a newline
// and returns the Set unchanged.
func (s Set[T]) Println() Set[T] { fmt.Println(s); return s }