package threadsafeset

import (
	"sync"

	"code.wmdillon.com/GoApi/set/simpleset"
)

type ThreadsafeSet[T comparable] struct {
	mutex sync.RWMutex
	set   *simpleset.SimpleSet[T]
}

func New[T comparable]() *ThreadsafeSet[T] {
	return &ThreadsafeSet[T]{
		set: simpleset.New[T](),
	}
}

func (s *ThreadsafeSet[T]) lockedInitMapIfNil() {
	if s.set == nil {
		s.set = simpleset.New[T]()
	}
}

func (s *ThreadsafeSet[T]) Insert(t T) (inserted bool) {
	s.mutex.Lock()
	defer s.mutex.Unlock()
	s.lockedInitMapIfNil()
	return s.set.Insert(t)
}

func (s *ThreadsafeSet[T]) InsertSlice(slice []T) (inserted []bool) {
	s.mutex.Lock()
	defer s.mutex.Unlock()
	return s.set.InsertSlice(slice)
}

func (s *ThreadsafeSet[T]) Contains(t T) bool {
	s.mutex.RLock()
	defer s.mutex.RUnlock()
	return s.set != nil && s.set.Contains(t)
}

func (s *ThreadsafeSet[T]) ContainsSlice(slice []T) []bool {
	s.mutex.RLock()
	defer s.mutex.RUnlock()
	return s.set.ContainsSlice(slice)
}

func (s *ThreadsafeSet[T]) Len() int {
	s.mutex.RLock()
	defer s.mutex.RUnlock()
	if s.set == nil {
		return 0
	}
	return s.set.Len()
}

func (s *ThreadsafeSet[T]) ToSlice() []T {
	s.mutex.RLock()
	defer s.mutex.RUnlock()
	if s.set == nil {
		return nil
	}
	return s.set.ToSlice()
}

func (s *ThreadsafeSet[T]) Clear() {
	s.mutex.Lock()
	defer s.mutex.Unlock()
	s.lockedInitMapIfNil()
	s.set.Clear()
}

func (s *ThreadsafeSet[T]) Remove(t T) (removed bool) {
	s.mutex.Lock()
	defer s.mutex.Unlock()
	s.lockedInitMapIfNil()
	return s.set.Remove(t)
}

func (s *ThreadsafeSet[T]) RemoveSlice(slice []T) (removed []bool) {
	s.mutex.Lock()
	defer s.mutex.Unlock()
	return s.set.RemoveSlice(slice)
}