// 初始化敏感詞切片
var sensitiveWords = []string{}

// TrieNode 表示Trie樹的節(jié)點(diǎn)
type TrieNode struct {
	children map[rune]*TrieNode
	isEnd    bool
	Text     string
}

// Trie 表示敏感詞的Trie樹
type Trie struct {
	root *TrieNode
}

// NewTrie 創(chuàng)建一個(gè)新的Trie樹
func NewTrie() *Trie {
	return &Trie{
		root: &TrieNode{
			children: make(map[rune]*TrieNode),
			isEnd:    false,
		},
	}
}

// Insert 將一個(gè)敏感詞插入到Trie樹中
func (t *Trie) Insert(word string) {
	node := t.root
	for _, char := range []rune(word) {
		if _, ok := node.children[char]; !ok {
			node.children[char] = &TrieNode{
				children: make(map[rune]*TrieNode),
				isEnd:    false,
			}
		}
		node = node.children[char]
	}

	node.Text = word
	node.isEnd = true
}

// Contains 檢測(cè)文本中是否包含敏感詞
func (t *Trie) Contains(text string) bool {
	node := t.root
	for _, char := range []rune(text) {
		if _, ok := node.children[char]; !ok {
			continue
		}
		node = node.children[char]
		if node.isEnd {
			return true
		}
	}
	return false
}

func TestCheckWord1(t *testing.T) {
	trie := NewTrie()
	for _, word := range sensitiveWords {
		trie.Insert(word)
	}

	content := "這里是一段非法活動(dòng)文本。"

	search := trie.Contains(content)

	assert.Equal(t, search, true)
}

package sensitivewordcheck

import "sync"

// TrieV1Node 表示TrieV1樹的節(jié)點(diǎn)
type TrieV1Node struct {
	children map[rune]*TrieV1Node // 子節(jié)點(diǎn)
	isEnd    bool
	Text     string
	Value    rune
	parent   *TrieV1Node // 父節(jié)點(diǎn)
}

// TrieV1 表示敏感詞的TrieV1樹
type TrieV1 struct {
	root *TrieV1Node
	lock sync.RWMutex
}

// NewTrieV1 創(chuàng)建一個(gè)新的TrieV1樹
func NewTrieV1() *TrieV1 {
	return &TrieV1{
		root: &TrieV1Node{
			children: make(map[rune]*TrieV1Node),
			isEnd:    false,
		},
	}
}

// Insert 將一個(gè)敏感詞插入到TrieV1樹中
func (t *TrieV1) Insert(word string) {
	t.lock.Lock()
	defer t.lock.Unlock()

	node := t.root
	for _, char := range []rune(word) {
		if _, ok := node.children[char]; !ok {
			node.children[char] = &TrieV1Node{
				children: make(map[rune]*TrieV1Node),
				isEnd:    false,
				parent:   node,
				Value:    char,
			}
		}
		node = node.children[char]
	}

	node.Text = word
	node.isEnd = true
}

// Contains 檢測(cè)文本中是否包含敏感詞
func (t *TrieV1) Contains(text string) bool {
	t.lock.RLock()
	defer t.lock.RUnlock()

	node := t.root
	for _, char := range []rune(text) {
		if _, ok := node.children[char]; !ok {
			continue
		}
		node = node.children[char]
		if node.isEnd {
			return true
		}
	}
	return false
}

// Check 檢測(cè)文本中是否包含敏感詞，并返回第一個(gè)敏感詞
func (t *TrieV1) Check(text string) string {
	t.lock.RLock()
	defer t.lock.RUnlock()

	node := t.root
	for _, char := range text {
		if _, ok := node.children[char]; !ok {
			continue
		}
		node = node.children[char]
		if node.isEnd {
			return node.Text
		}
	}

	return ""
}

// Rebuild 重新構(gòu)建敏感詞樹
func (t *TrieV1) Rebuild(words []string) {
	t.lock.Lock()
	defer t.lock.Unlock()

	t.root = &TrieV1Node{}

	for _, word := range words {
		t.Insert(word)
	}
}

// Delete 刪除一個(gè)敏感詞
func (t *TrieV1) Delete(word string) {
	t.lock.Lock()
	defer t.lock.Unlock()

	node := t.root

	for _, char := range []rune(word) {
		if _, ok := node.children[char]; !ok {
			return
		}
		node = node.children[char]

		if node.isEnd {
			node.isEnd = false
			node.Text = ""

			if len(node.children) > 0 { // 有子節(jié)點(diǎn)，不能刪除
				break
			}

			// 遞歸刪除
			t.doDel(node)
		}

	}
}

func (t *TrieV1) doDel(node *TrieV1Node) {
	// 再次判斷是否可以刪除
	if node == nil || len(node.children) > 0 {
		return
	}

	// 從上級(jí)節(jié)點(diǎn)的children中刪除本節(jié)點(diǎn)
	delete(node.parent.children, node.Value)

	// 判斷上一層節(jié)點(diǎn)是否可以刪除
	t.doDel(node.parent)
}

package sensitivewordcheck

import (
	"github.com/stretchr/testify/assert"
	"testing"
)

var trieV1 *TrieV1

func init() {
	trieV1 = NewTrieV1()
	for _, word := range sensitiveWords {
		trieV1.Insert(word)
	}
}

func TestCheckWordAndDelete(t *testing.T) {

	// 添加敏感詞 非法捕魚
	trieV1.Insert("非法捕魚")

	assert.Equal(t, trieV1.Contains("你要去非法捕魚嗎？"), true)

	// 添加敏感詞 非法打獵
	trieV1.Insert("非法打獵")

	assert.Equal(t, trieV1.Contains("你要去非法打獵嗎？"), true)

	// 刪除敏感詞 非法打獵
	trieV1.Delete("非法打獵")

	// 不再包含 非法打獵
	assert.Equal(t, trieV1.Contains("你要去非法打獵嗎？"), false)

	// 非法捕魚 不受影響
	assert.Equal(t, trieV1.Contains("你要去非法捕魚嗎？"), true)

	// 更長(zhǎng)的敏感詞
	trieV1.Insert("非法捕魚工具")
	assert.Equal(t, trieV1.Contains("你要去買非法捕魚工具嗎？"), true)

	// 刪除 非法捕魚
	trieV1.Delete("非法捕魚")
	assert.Equal(t, trieV1.Contains("你要去非法捕魚嗎？"), false)
	// 如果有子節(jié)點(diǎn)，不刪除
	assert.Equal(t, trieV1.Contains("你要去買非法捕魚工具嗎？"), true)

}