package set

import (

	"bytes"

	"fmt"

	"sync"

)

type Set struct {

	m map[interface{}]bool

	sync.RWMutex

}

func New() *Set {

	return &Set{m: make(map[interface{}]bool)}

}

func (self *Set) Add(e interface{}) bool {

	self.Lock()

	defer self.Unlock()

	if self.m[e] {

		return false

	}

	self.m[e] = true

	return true

}

func (self *Set) Remove(e interface{}) bool {

	self.Lock()

	defer self.Unlock()

	delete(self.m, e)

	return true

}

func (self *Set) Clear() bool {

	self.Lock()

	defer self.Unlock()

	self.m = make(map[interface{}]bool)

	return true

}

func (self *Set) Contains(e interface{}) bool {

	self.Lock()

	defer self.Unlock()

	//return self.m[e]

	_, ok := self.m[e]

	return ok

}

func (self *Set) IsEmpty() bool {

	return self.Len() == 0

}

func (self *Set) Len() int {

	self.Lock()

	defer self.Unlock()

	return len(self.m)

}

func (self *Set) Same(other *Set) bool {

	if other == nil {

		return false

	}

	if self.Len() != other.Len() {

		return false

	}

	for k, _ := range other.m {

		if !self.Contains(k) {

			return false

		}

	}

	return true

}

func (self *Set) Elements() interface{} {

	self.Lock()

	defer self.Unlock()

	// for k := range self.m{

	//    snapshot = snapshot(snapshot, k)

	// }

	initialLen := self.Len()

	actualLen := 0

	snapshot := make([]interface{}, initialLen)

	for k := range self.m {

		if actualLen < initialLen {

			snapshot[actualLen] = k

		} else {

			snapshot = append(snapshot, k)

		}

		actualLen++

	}

	if actualLen < initialLen {

		snapshot = snapshot[:actualLen]

	}

	return snapshot

}

func (self *Set) String() string {

	self.Lock()

	defer self.Unlock()

	var buf bytes.Buffer

	buf.WriteString("Set{")

	flag := true

	for k := range self.m {

		if flag {

			flag = false

		} else {

			buf.WriteString(" ")

		}

		buf.WriteString(fmt.Sprintf("%v", k))

	}

	buf.WriteString("}")

	return buf.String()

}

func (self *Set) IsSuperSet(other *Set) bool {

	self.Lock()

	defer self.Unlock()

	if other == nil {

		return false

	}

	selfLen := self.Len()

	otherLen := other.Len()

	if otherLen == 0 || selfLen == otherLen {

		return false

	}

	if selfLen > 0 && otherLen == 0 {

		return true

	}

	for v := range other.m {

		if !self.Contains(v) {

			return false

		}

	}

	return true

}

//属于A或属于B的元素

func (self *Set) Union(other *Set) *Set {

	self.Lock()

	defer self.Unlock()

	// if other == nil || other.Len() == 0{

	//    return self

	// }

	//

	// for v := range other.m{

	//    self.Add(v)

	// }

	// return self

	//不能改变集合A的范围

	union := New()

	for v := range self.m {

		union.Add(v)

	}

	for v := range other.m {

		union.Add(v)

	}

	return union

}

//属于A且属于B的元素

func (self *Set) Intersect(other *Set) *Set {

	self.Lock()

	defer self.Unlock()

	if other == nil || other.Len() == 0 {

		return New()

	}

	intsSet := New()

	for v, _ := range other.m {

		if self.Contains(v) {

			intsSet.Add(v)

		}

	}

	return intsSet

}

//属于A且不属于B的元素

func (self *Set) Difference(other *Set) *Set {

	self.Lock()

	defer self.Unlock()

	diffSet := New()

	if other == nil || other.Len() == 0 {

		diffSet.Union(self)

	} else {

		for v := range self.m {

			if !other.Contains(v) {

				diffSet.Add(v)

			}

		}

	}

	return diffSet

}

//集合A与集合B中所有不属于A∩B的元素的集合

func (self *Set) SymmetricDifference(other *Set) *Set {

	self.Lock()

	defer self.Unlock()

	//此时A∩B=∅，A中所有元素均不属于空集

	// if other == nil || other.Len() == 0{

	//    return self

	// }

	// ints := self.Intersect(other)

	// //此时A∩B=∅，A为空或B为空,B为空前面已经判断，此时B不能为空，即A为空

	// if ints == nil || ints.Len() == 0 {

	//    return other

	// }

	//

	// unionSet := self.Union(other)

	// result := New()

	// for v := range unionSet.m{

	//    if !ints.Contains(v){

	//       result.Add(v)

	//    }

	// }

	ints := self.Difference(other)

	union := self.Union(other)

	return union.Difference(ints)

}

package main

import (

	"fmt"

	"go_dev/go_set/set"

)

func main() {

	setTest()

}

func setTest() {

	set1 := set.New()

	set1.Add(1)

	set1.Add("e2")

	set1.Add(3)

	set1.Add("e4")

	fmt.Println("set1:", set1)

	fmt.Printf("set1 Elements:%v\n", set1.Elements())

	set2 := set.New()

	set2.Add(3)

	set2.Add("e2")

	set2.Add(5)

	set2.Add("e6")

	fmt.Println("set2:", set2)

	fmt.Printf("set1 union set2:%v\n", set1.Union(set2))

	fmt.Printf("set1 intersect set2:%v\n", set1.Intersect(set2))

	fmt.Println(set1,set2)

	fmt.Printf("set1 difference set2:%v\n", set1.Difference(set2))

	fmt.Printf("set1 SymmetricDifference set2:%v\n", set1.SymmetricDifference(set2))

	set1.Clear()

	fmt.Println(set1)

}