// Package model define model struct of model runtime service
package model

import (
	"context"
	"errors"
	"fmt"
	"math"
	"strings"

	"modelRT/constants"
	"modelRT/diagram"
	"modelRT/logger"
	"modelRT/util"

	"github.com/RediSearch/redisearch-go/v2/redisearch"
	redigo "github.com/gomodule/redigo/redis"
	"github.com/redis/go-redis/v9"
)

// SearchResult define struct to store redis query recommend search result
type SearchResult struct {
	// input redis key, used to distinguish which goroutine the result belongs to
	RecommendType constants.RecommendHierarchyType
	QueryDatas    []string
	IsFuzzy       bool
	IsFallback    bool
	Offset        int
	Err           error
}

var ac *redisearch.Autocompleter

// InitAutocompleterWithPool define func of initialize the Autocompleter with redigo pool
func InitAutocompleterWithPool(pool *redigo.Pool) {
	ac = redisearch.NewAutocompleterFromPool(pool, constants.RedisSearchDictName)
}

func levelOneRedisSearch(ctx context.Context, rdb *redis.Client, hierarchy constants.RecommendHierarchyType, recommendLenType string, searchInput string, searchRedisKey string, fanInChan chan SearchResult) {
	defer func() {
		if r := recover(); r != nil {
			logger.Error(ctx, "searchFunc panicked", "panic", r)
			fanInChan <- SearchResult{
				RecommendType: hierarchy,
				QueryDatas:    nil,
				IsFuzzy:       false,
				Err:           errors.New("search goroutine panicked"),
			}
		}
	}()

	exists, err := rdb.SIsMember(ctx, searchRedisKey, searchInput).Result()
	if err != nil {
		logger.Error(ctx, "redis membership check failed", "key", searchRedisKey, "member", searchInput, "op", "SIsMember", "error", err)

		fanInChan <- SearchResult{
			RecommendType: hierarchy,
			QueryDatas:    nil,
			IsFuzzy:       false,
			Err:           err,
		}
		return
	}

	// the input key is the complete hierarchical value
	if exists {
		fanInChan <- SearchResult{
			RecommendType: hierarchy,
			QueryDatas:    []string{"."},
			IsFuzzy:       false,
			Err:           nil,
		}
		return
	}

	// process fuzzy search result
	recommends, offset, err := runFuzzySearch(ctx, rdb, searchInput, "", hierarchy, recommendLenType)
	if err != nil {
		logger.Error(ctx, fmt.Sprintf("fuzzy search failed for %s hierarchical", util.GetLevelStrByRdsKey(searchRedisKey)), "search_input", searchInput, "error", err)
		fanInChan <- SearchResult{
			RecommendType: hierarchy,
			QueryDatas:    nil,
			IsFuzzy:       false,
			Err:           err,
		}
		return
	}

	if len(recommends) > 0 {
		fanInChan <- SearchResult{
			RecommendType: hierarchy,
			QueryDatas:    recommends,
			IsFuzzy:       true,
			Offset:        offset,
			Err:           nil,
		}
		return
	}

	recommends, err = fallbackAllCurrentLevel(ctx, rdb, hierarchy)
	if err != nil {
		logger.Error(ctx, "fallback all keys at current level failed", "hierarchy", hierarchy, "search_input", searchInput, "error", err)
		fanInChan <- SearchResult{
			RecommendType: hierarchy,
			QueryDatas:    nil,
			IsFuzzy:       true,
			IsFallback:    true,
			Err:           err,
		}
		return
	}

	fanInChan <- SearchResult{
		RecommendType: hierarchy,
		QueryDatas:    recommends,
		IsFuzzy:       true,
		IsFallback:    true,
		Offset:        0,
		Err:           nil,
	}
}

// RedisSearchRecommend define func of redis search by input string and return recommend results
func RedisSearchRecommend(ctx context.Context, input string) map[string]SearchResult {
	rdb := diagram.GetRedisClientInstance()
	finalizeResults := func(results map[string]SearchResult) map[string]SearchResult {
		return normalizeRecommendResults(input, results)
	}

	if input == "" {
		fanInChan := make(chan SearchResult, 2)
		// return all grid tagname
		go getAllKeyByGridLevel(ctx, rdb, fanInChan)
		// return all component nspath
		go getAllKeyByNSPathLevel(ctx, rdb, fanInChan)
		results := make(map[string]SearchResult)
		for range 2 {
			result := <-fanInChan
			if result.Err != nil {
				logger.Error(ctx, "return all keys at the special level from redis failed", "recommend_type", result.RecommendType, "error", result.Err)
				continue
			}

			if result.RecommendType == constants.CompNSPathRecommendHierarchyType {
				result.QueryDatas = filterLocalNSPathResults(result.QueryDatas)
			}
			results[result.RecommendType.String()] = result
		}

		return finalizeResults(results)
	}

	inputSlice := strings.Split(input, ".")
	inputSliceLen := len(inputSlice)

	fanInChan := make(chan SearchResult, 4)
	switch inputSliceLen {
	case 1:
		searchInput := inputSlice[0]
		// grid tagname search
		go levelOneRedisSearch(ctx, rdb, constants.GridRecommendHierarchyType, constants.FullRecommendLength, searchInput, constants.RedisAllGridSetKey, fanInChan)
		// component nspath search
		go levelOneRedisSearch(ctx, rdb, constants.CompNSPathRecommendHierarchyType, constants.IsLocalRecommendLength, searchInput, constants.RedisAllCompNSPathSetKey, fanInChan)

		results := make(map[string]SearchResult)
		// TODO 后续根据支持的数据标识语法长度,进行值的变更
		for range 2 {
			result := <-fanInChan
			if result.Err != nil {
				logger.Error(ctx, "exec redis fuzzy search by key failed", "recommend_type", result.RecommendType, "error", result.Err)
				continue
			}

			if result.RecommendType == constants.CompNSPathRecommendHierarchyType {
				result.QueryDatas = filterLocalNSPathResults(result.QueryDatas)
			}
			results[result.RecommendType.String()] = result
		}

		return finalizeResults(results)
	case 2:
		// zone tagname search
		go handleLevelFuzzySearch(ctx, rdb, constants.ZoneRecommendHierarchyType, constants.FullRecommendLength, constants.RedisAllZoneSetKey, inputSlice, fanInChan)
		// component tagname search
		go handleLevelFuzzySearch(ctx, rdb, constants.CompTagRecommendHierarchyType, constants.IsLocalRecommendLength, constants.RedisAllCompTagSetKey, inputSlice, fanInChan)
		// measurement tagname search by token4-token7 shorthand
		go handleNSPathMeasSearch(ctx, rdb, inputSlice, fanInChan)
		results := make(map[string]SearchResult)
		for range 3 {
			result := <-fanInChan
			if result.Err != nil {
				logger.Error(ctx, "query all keys at the special level from redis failed", "query_key", result.RecommendType, "error", result.Err)
				continue
			}
			results[result.RecommendType.String()] = result
		}

		return finalizeResults(results)
	case 3:
		// station tanname search
		go handleLevelFuzzySearch(ctx, rdb, constants.StationRecommendHierarchyType, constants.FullRecommendLength, constants.RedisAllStationSetKey, inputSlice, fanInChan)
		// config search
		go handleLevelFuzzySearch(ctx, rdb, constants.ConfigRecommendHierarchyType, constants.IsLocalRecommendLength, constants.RedisAllConfigSetKey, inputSlice, fanInChan)

		results := make(map[string]SearchResult)
		for range 2 {
			result := <-fanInChan
			if result.Err != nil {
				logger.Error(ctx, "query all keys at the special level from redis failed", "query_key", result.RecommendType, "error", result.Err)
				continue
			}
			results[result.RecommendType.String()] = result
		}

		return finalizeResults(results)
	case 4:
		// component nspath search
		go handleLevelFuzzySearch(ctx, rdb, constants.CompNSPathRecommendHierarchyType, constants.FullRecommendLength, constants.RedisAllCompNSPathSetKey, inputSlice, fanInChan)
		// measurement tagname search
		go handleLevelFuzzySearch(ctx, rdb, constants.MeasTagRecommendHierarchyType, constants.IsLocalRecommendLength, constants.RedisAllConfigSetKey, inputSlice, fanInChan)

		results := make(map[string]SearchResult)
		for range 2 {
			result := <-fanInChan
			if result.Err != nil {
				logger.Error(ctx, "query all keys at the special level from redis failed", "query_key", result.RecommendType, "error", result.Err)
				continue
			}
			results[result.RecommendType.String()] = result
		}

		return finalizeResults(results)
	case 5:
		// component tagname search
		go handleLevelFuzzySearch(ctx, rdb, constants.CompTagRecommendHierarchyType, constants.FullRecommendLength, constants.RedisAllCompTagSetKey, inputSlice, fanInChan)

		results := make(map[string]SearchResult)
		for range 1 {
			result := <-fanInChan
			if result.Err != nil {
				logger.Error(ctx, "query all keys at the special level from redis failed", "query_key", result.RecommendType, "error", result.Err)
				continue
			}
			results[result.RecommendType.String()] = result
		}

		return finalizeResults(results)
	case 6:
		// config search
		go handleLevelFuzzySearch(ctx, rdb, constants.ConfigRecommendHierarchyType, constants.FullRecommendLength, constants.RedisAllConfigSetKey, inputSlice, fanInChan)

		results := make(map[string]SearchResult)
		for range 1 {
			result := <-fanInChan
			if result.Err != nil {
				logger.Error(ctx, "query all keys at the special level from redis failed", "query_key", result.RecommendType, "error", result.Err)
				continue
			}
			results[result.RecommendType.String()] = result
		}

		return finalizeResults(results)
	case 7:
		// measurement tagname search
		go handleLevelFuzzySearch(ctx, rdb, constants.MeasTagRecommendHierarchyType, constants.FullRecommendLength, constants.RedisAllMeasTagSetKey, inputSlice, fanInChan)

		results := make(map[string]SearchResult)
		for range 1 {
			result := <-fanInChan
			if result.Err != nil {
				logger.Error(ctx, "query all keys at the special level from redis failed", "query_key", result.RecommendType, "error", result.Err)
				continue
			}
			results[result.RecommendType.String()] = result
		}

		return finalizeResults(results)
	default:
		logger.Error(ctx, "unsupport length of search input", "input_len", inputSliceLen)
		return nil
	}
}

func normalizeRecommendResults(input string, results map[string]SearchResult) map[string]SearchResult {
	for key, result := range results {
		if result.Err != nil {
			continue
		}
		if result.IsFallback {
			result.Offset = maxRecommendLength(result.QueryDatas)
			results[key] = result
			continue
		}
		if !result.IsFuzzy {
			result.Offset = calcSearchResultOffset(input, result.QueryDatas)
		}
		result.QueryDatas = trimRecommendTerms(result.QueryDatas, result.Offset)
		results[key] = result
	}
	return results
}

func calcSearchResultOffset(input string, recommends []string) int {
	var minOffset int
	for index, recommend := range recommends {
		offset := util.GetLongestCommonPrefixLength(input, recommend)
		if index == 0 || offset < minOffset {
			minOffset = offset
		}
	}
	return minOffset
}

func maxRecommendLength(recommends []string) int {
	var maxLen int
	for _, recommend := range recommends {
		if length := len([]rune(recommend)); length > maxLen {
			maxLen = length
		}
	}
	return maxLen
}

func trimRecommendTerms(recommends []string, offset int) []string {
	resultRecommends := make([]string, 0, len(recommends))
	seen := make(map[string]struct{})

	for _, recommend := range recommends {
		recommendRunes := []rune(recommend)
		if offset > len(recommendRunes) {
			continue
		}

		recommendTerm := string(recommendRunes[offset:])
		if recommendTerm == "" {
			continue
		}
		if _, exists := seen[recommendTerm]; exists {
			continue
		}

		seen[recommendTerm] = struct{}{}
		resultRecommends = append(resultRecommends, recommendTerm)
	}
	return resultRecommends
}

func filterLocalNSPathResults(queryDatas []string) []string {
	filterResults := make([]string, 0, len(queryDatas))
	for _, queryData := range queryDatas {
		if queryData == "." {
			filterResults = append(filterResults, queryData)
			continue
		}

		var nsPath string
		if lastDotIndex := strings.LastIndex(queryData, "."); lastDotIndex == -1 {
			nsPath = queryData
		} else {
			nsPath = queryData[lastDotIndex+1:]
		}

		// TODO 考虑为 NSPathToIsLocalMap 增加读写锁或改为并发安全快照, 保证过滤数据一致性
		if isLocal, ok := NSPathToIsLocalMap[nsPath]; ok && isLocal {
			filterResults = append(filterResults, queryData)
		}
	}
	return filterResults
}

func queryMemberFromSpecificsLevel(ctx context.Context, rdb *redis.Client, hierarchy constants.RecommendHierarchyType, keyPrefix string) ([]string, error) {
	queryKey := getSpecificKeyByLength(hierarchy, keyPrefix)
	return rdb.SMembers(ctx, queryKey).Result()
}

func fallbackAllCurrentLevel(ctx context.Context, rdb *redis.Client, hierarchy constants.RecommendHierarchyType) ([]string, error) {
	setKey, ok := getAllSetKeyByHierarchy(hierarchy)
	if !ok {
		return nil, fmt.Errorf("unsupported recommend hierarchy for fallback: %s", hierarchy)
	}

	members, err := rdb.SMembers(ctx, setKey).Result()
	if err != nil && err != redis.Nil {
		return nil, err
	}
	return members, nil
}

func getAllSetKeyByHierarchy(hierarchy constants.RecommendHierarchyType) (string, bool) {
	switch hierarchy {
	case constants.GridRecommendHierarchyType:
		return constants.RedisAllGridSetKey, true
	case constants.ZoneRecommendHierarchyType:
		return constants.RedisAllZoneSetKey, true
	case constants.StationRecommendHierarchyType:
		return constants.RedisAllStationSetKey, true
	case constants.CompNSPathRecommendHierarchyType:
		return constants.RedisAllCompNSPathSetKey, true
	case constants.CompTagRecommendHierarchyType:
		return constants.RedisAllCompTagSetKey, true
	case constants.ConfigRecommendHierarchyType:
		return constants.RedisAllConfigSetKey, true
	case constants.MeasTagRecommendHierarchyType:
		return constants.RedisAllMeasTagSetKey, true
	default:
		return "", false
	}
}

func getAllKeyByGridLevel(ctx context.Context, rdb *redis.Client, fanInChan chan SearchResult) {
	setKey := constants.RedisAllGridSetKey
	hierarchy := constants.GridRecommendHierarchyType
	members, err := rdb.SMembers(ctx, setKey).Result()
	if err != nil && err != redigo.ErrNil {
		logger.Error(ctx, "get all members from redis by special key failed", "key", setKey, "op", "SMembers", "error", err)

		fanInChan <- SearchResult{
			RecommendType: hierarchy,
			QueryDatas:    nil,
			IsFuzzy:       false,
			Err:           err,
		}
		return
	}

	fanInChan <- SearchResult{
		RecommendType: hierarchy,
		QueryDatas:    members,
		IsFuzzy:       false,
		Err:           nil,
	}
}

func getAllKeyByNSPathLevel(ctx context.Context, rdb *redis.Client, fanInChan chan SearchResult) {
	queryKey := constants.RedisAllCompNSPathSetKey
	hierarchy := constants.CompNSPathRecommendHierarchyType
	members, err := rdb.SMembers(ctx, queryKey).Result()
	if err != nil && err != redigo.ErrNil {
		logger.Error(ctx, "get all members by special key failed", "key", queryKey, "op", "SMembers", "error", err)

		fanInChan <- SearchResult{
			RecommendType: hierarchy,
			QueryDatas:    nil,
			IsFuzzy:       false,
			Err:           err,
		}
		return
	}

	fanInChan <- SearchResult{
		RecommendType: hierarchy,
		QueryDatas:    members,
		IsFuzzy:       false,
		Err:           nil,
	}
}

func combineQueryResultByInput(hierarchy constants.RecommendHierarchyType, recommendLenType string, inputSlice []string, queryResults []string) []string {
	prefixs := make([]string, 0, len(inputSlice))
	recommandResults := make([]string, 0, len(queryResults))
	switch recommendLenType {
	case constants.FullRecommendLength:
		switch hierarchy {
		case constants.ZoneRecommendHierarchyType:
			prefixs = []string{inputSlice[0]}
		case constants.StationRecommendHierarchyType:
			prefixs = inputSlice[0:2]
		case constants.CompNSPathRecommendHierarchyType:
			prefixs = inputSlice[0:3]
		case constants.CompTagRecommendHierarchyType:
			prefixs = inputSlice[0:4]
		case constants.ConfigRecommendHierarchyType:
			prefixs = inputSlice[0:5]
		case constants.MeasTagRecommendHierarchyType:
			prefixs = inputSlice[0:6]
		default:
			return []string{}
		}
	case constants.IsLocalRecommendLength:
		switch hierarchy {
		case constants.CompTagRecommendHierarchyType:
			prefixs = []string{inputSlice[0]}
		case constants.ConfigRecommendHierarchyType:
			prefixs = inputSlice[0:2]
		case constants.MeasTagRecommendHierarchyType:
			prefixs = inputSlice[0:3]
		default:
			return []string{}
		}
	}

	for _, queryResult := range queryResults {
		combineStrs := make([]string, 0, len(inputSlice))
		combineStrs = append(combineStrs, prefixs...)
		combineStrs = append(combineStrs, queryResult)
		recommandResult := strings.Join(combineStrs, ".")
		recommandResults = append(recommandResults, recommandResult)
	}
	return recommandResults
}

func getSpecificKeyByLength(hierarchy constants.RecommendHierarchyType, keyPrefix string) string {
	switch hierarchy {
	case constants.GridRecommendHierarchyType:
		return constants.RedisAllGridSetKey
	case constants.ZoneRecommendHierarchyType:
		return fmt.Sprintf(constants.RedisSpecGridZoneSetKey, keyPrefix)
	case constants.StationRecommendHierarchyType:
		return fmt.Sprintf(constants.RedisSpecZoneStationSetKey, keyPrefix)
	case constants.CompNSPathRecommendHierarchyType:
		return fmt.Sprintf(constants.RedisSpecStationCompNSPATHSetKey, keyPrefix)
	case constants.CompTagRecommendHierarchyType:
		return fmt.Sprintf(constants.RedisSpecCompNSPathCompTagSetKey, keyPrefix)
	case constants.ConfigRecommendHierarchyType:
		return constants.RedisAllConfigSetKey
	case constants.MeasTagRecommendHierarchyType:
		return fmt.Sprintf(constants.RedisSpecCompTagMeasSetKey, keyPrefix)
	default:
		return constants.RedisAllGridSetKey
	}
}

func handleNSPathMeasSearch(ctx context.Context, rdb *redis.Client, inputSlice []string, fanInChan chan SearchResult) {
	hierarchy := constants.MeasTagRecommendHierarchyType
	nsPath := inputSlice[0]
	searchInput := inputSlice[1]

	nsPathExists, err := rdb.SIsMember(ctx, constants.RedisAllCompNSPathSetKey, nsPath).Result()
	if err != nil {
		logger.Error(ctx, "check nspath exist from redis set failed", "key", constants.RedisAllCompNSPathSetKey, "nspath", nsPath, "error", err)
		fanInChan <- SearchResult{
			RecommendType: hierarchy,
			QueryDatas:    nil,
			IsFuzzy:       false,
			Err:           err,
		}
		return
	}
	if !nsPathExists {
		fanInChan <- SearchResult{
			RecommendType: hierarchy,
			QueryDatas:    []string{},
			IsFuzzy:       false,
			Err:           nil,
		}
		return
	}

	queryKey := fmt.Sprintf(constants.RedisSpecCompNSPathMeasSetKey, nsPath)
	if searchInput == "" {
		members, err := rdb.SMembers(ctx, queryKey).Result()
		if err != nil && err != redis.Nil {
			logger.Error(ctx, "query measurement tags by nspath failed", "key", queryKey, "nspath", nsPath, "error", err)
			fanInChan <- SearchResult{
				RecommendType: hierarchy,
				QueryDatas:    nil,
				IsFuzzy:       false,
				Err:           err,
			}
			return
		}

		fanInChan <- SearchResult{
			RecommendType: hierarchy,
			QueryDatas:    combineNSPathMeasResults(nsPath, members),
			IsFuzzy:       false,
			Err:           nil,
		}
		return
	}

	measTagExists, err := rdb.SIsMember(ctx, queryKey, searchInput).Result()
	if err != nil {
		logger.Error(ctx, "check measurement tag exist from nspath set failed", "key", queryKey, "meas_tag", searchInput, "error", err)
		fanInChan <- SearchResult{
			RecommendType: hierarchy,
			QueryDatas:    nil,
			IsFuzzy:       false,
			Err:           err,
		}
		return
	}
	if measTagExists {
		fanInChan <- SearchResult{
			RecommendType: hierarchy,
			QueryDatas:    []string{""},
			IsFuzzy:       false,
			Err:           nil,
		}
		return
	}

	recommends, offset, err := runNSPathMeasFuzzySearch(ctx, nsPath, searchInput)
	if err != nil {
		fanInChan <- SearchResult{
			RecommendType: hierarchy,
			QueryDatas:    nil,
			IsFuzzy:       true,
			Err:           err,
		}
		return
	}

	fanInChan <- SearchResult{
		RecommendType: hierarchy,
		QueryDatas:    recommends,
		IsFuzzy:       true,
		Offset:        offset,
		Err:           nil,
	}
}

func combineNSPathMeasResults(nsPath string, measTags []string) []string {
	results := make([]string, 0, len(measTags))
	for _, measTag := range measTags {
		results = append(results, fmt.Sprintf("%s.%s", nsPath, measTag))
	}
	return results
}

func runNSPathMeasFuzzySearch(ctx context.Context, nsPath string, searchInput string) ([]string, int, error) {
	searchInputLen := len([]rune(searchInput))
	for searchInputLen != 0 {
		fuzzyInput := fmt.Sprintf("%s.%s", nsPath, searchInput)
		results, err := ac.SuggestOpts(fuzzyInput, redisearch.SuggestOptions{
			Num:          math.MaxInt16,
			Fuzzy:        true,
			WithScores:   false,
			WithPayloads: false,
		})
		if err != nil {
			logger.Error(ctx, "query measurement tag by nspath fuzzy search failed", "query_key", fuzzyInput, "error", err)
			return nil, 0, fmt.Errorf("redisearch suggest failed: %w", err)
		}

		if len(results) == 0 {
			searchInput = trimLastRune(searchInput)
			searchInputLen = len([]rune(searchInput))
			continue
		}

		recommends := make([]string, 0, len(results))
		for _, result := range results {
			termPrefix, termLastPart := splitLastToken(result.Term)
			if termPrefix == nsPath && strings.HasPrefix(termLastPart, searchInput) {
				recommends = append(recommends, result.Term)
			}
		}
		if len(recommends) == 0 {
			searchInput = trimLastRune(searchInput)
			searchInputLen = len([]rune(searchInput))
			continue
		}

		return recommends, len([]rune(fmt.Sprintf("%s.%s", nsPath, searchInput))), nil
	}
	return []string{}, 0, nil
}

func splitLastToken(term string) (string, string) {
	lastDotIndex := strings.LastIndex(term, ".")
	if lastDotIndex == -1 {
		return "", term
	}
	return term[:lastDotIndex], term[lastDotIndex+1:]
}

// handleLevelFuzzySearch define func to process recommendation logic for specific levels(level >= 2)
func handleLevelFuzzySearch(ctx context.Context, rdb *redis.Client, hierarchy constants.RecommendHierarchyType, recommendLenType string, redisSetKey string, inputSlice []string, fanInChan chan SearchResult) {
	inputSliceLen := len(inputSlice)
	searchInputIndex := inputSliceLen - 1
	searchInput := inputSlice[searchInputIndex]
	searchPrefix := strings.Join(inputSlice[0:searchInputIndex], ".")

	if searchInput == "" {
		var specificalKey string
		specificalKeyIndex := searchInputIndex - 1
		if hierarchy == constants.MeasTagRecommendHierarchyType {
			specificalKeyIndex = searchInputIndex - 2
		}

		if specificalKeyIndex >= 0 {
			specificalKey = inputSlice[specificalKeyIndex]
		}

		if recommendLenType == constants.IsLocalRecommendLength && hierarchy == constants.ConfigRecommendHierarchyType {
			// token4-token7 model and query all config keys
			redisSetKey = constants.RedisAllCompTagSetKey
			keyExists, err := rdb.SIsMember(ctx, redisSetKey, specificalKey).Result()
			if err != nil {
				logger.Error(ctx, "check key exist from redis set failed ", "key", redisSetKey, "error", err)
				fanInChan <- SearchResult{
					RecommendType: hierarchy,
					QueryDatas:    nil,
					IsFuzzy:       false,
					Err:           err,
				}
				return
			}

			if !keyExists {
				fanInChan <- SearchResult{
					RecommendType: hierarchy,
					QueryDatas:    []string{},
					IsFuzzy:       false,
					Err:           nil,
				}
				return
			}
		}

		members, err := queryMemberFromSpecificsLevel(ctx, rdb, hierarchy, specificalKey)
		if err != nil && err != redis.Nil {
			logger.Error(ctx, "query members from redis by special key failed", "key", specificalKey, "member", searchInput, "op", "SMember", "error", err)
			fanInChan <- SearchResult{
				RecommendType: hierarchy,
				QueryDatas:    nil,
				IsFuzzy:       false,
				Err:           err,
			}
			return
		}

		recommandResults := combineQueryResultByInput(hierarchy, recommendLenType, inputSlice, members)
		if hierarchy == constants.ConfigRecommendHierarchyType || hierarchy == constants.MeasTagRecommendHierarchyType {
			// check the relevance between the config hierarchy and measurement hierarchy output and the request input, i.e., use FT.SUGGET search_suggestions_dict "recommandResult" max 1 for an exact query to check if the result exists
			secondConfirmResults := make([]string, 0, len(recommandResults))
			for _, res := range recommandResults {
				results, err := ac.SuggestOpts(res, redisearch.SuggestOptions{
					Num:          1,
					Fuzzy:        false,
					WithScores:   false,
					WithPayloads: false,
				})
				if err != nil {
					logger.Error(ctx, "config hierarchy query key second confirmation failed", "query_key", res, "error", err)
					continue
				}

				if len(results) == 0 {
					continue
				}
				secondConfirmResults = append(secondConfirmResults, res)
			}
			recommandResults = secondConfirmResults
		}
		fanInChan <- SearchResult{
			RecommendType: hierarchy,
			QueryDatas:    recommandResults,
			IsFuzzy:       false,
			Err:           nil,
		}
		return
	}

	keyExists, err := rdb.SIsMember(ctx, redisSetKey, searchInput).Result()
	if err != nil {
		logger.Error(ctx, "check key exist from redis set failed ", "key", redisSetKey, "error", err)
		fanInChan <- SearchResult{
			RecommendType: hierarchy,
			QueryDatas:    nil,
			IsFuzzy:       false,
			Err:           err,
		}
		return
	}

	if keyExists {
		var QueryData []string
		if hierarchy == constants.MaxIdentifyHierarchy || (hierarchy == constants.IdentifyHierarchy && redisSetKey == constants.RedisAllMeasTagSetKey) {
			QueryData = []string{""}
		} else {
			QueryData = []string{"."}
		}

		fanInChan <- SearchResult{
			RecommendType: hierarchy,
			QueryDatas:    QueryData,
			IsFuzzy:       false,
			Err:           nil,
		}
		return
	}

	// start redis fuzzy search
	recommends, offset, err := runFuzzySearch(ctx, rdb, searchInput, searchPrefix, hierarchy, recommendLenType)
	if err != nil {
		logger.Error(ctx, "fuzzy search failed by hierarchy", "hierarchy", hierarchy, "search_input", searchInput, "error", err)
		fanInChan <- SearchResult{
			RecommendType: hierarchy,
			QueryDatas:    nil,
			IsFuzzy:       false,
			Err:           err,
		}
		return
	}

	isFallback := false
	if len(recommends) == 0 {
		logger.Info(ctx, "fuzzy search without result", "hierarchy", hierarchy, "search_input", searchInput, "error", err)
		recommends, err = fallbackAllCurrentLevel(ctx, rdb, hierarchy)
		if err != nil {
			logger.Error(ctx, "fallback all keys at current level failed", "hierarchy", hierarchy, "search_input", searchInput, "error", err)
			fanInChan <- SearchResult{
				RecommendType: hierarchy,
				QueryDatas:    nil,
				IsFuzzy:       true,
				IsFallback:    true,
				Err:           err,
			}
			return
		}
		isFallback = true
		offset = 0
	}

	fanInChan <- SearchResult{
		RecommendType: hierarchy,
		QueryDatas:    recommends,
		IsFuzzy:       true,
		IsFallback:    isFallback,
		Offset:        offset,
		Err:           nil,
	}
}

// runFuzzySearch define func to process redis fuzzy search
func runFuzzySearch(ctx context.Context, rdb *redis.Client, searchInput string, searchPrefix string, hierarchy constants.RecommendHierarchyType, recommendLenType string) ([]string, int, error) {
	var configToken string
	var comparePrefix string
	searchInputLen := len([]rune(searchInput))
	compareHierarchyLen := int(hierarchy)
	comparePrefix = searchPrefix
	if hierarchy == constants.MeasTagRecommendHierarchyType {
		compareHierarchyLen = int(hierarchy) - 1
		lastDotIndex := strings.LastIndex(searchPrefix, ".")
		if lastDotIndex == -1 {
			configToken = ""
		} else {
			configToken = searchPrefix[lastDotIndex+1:]
			comparePrefix = searchPrefix[:lastDotIndex]
		}
	}

	for searchInputLen != 0 {
		fuzzyInput := searchInput
		if comparePrefix != "" {
			fuzzyInput = comparePrefix + "." + searchInput
		}
		results, err := ac.SuggestOpts(fuzzyInput, redisearch.SuggestOptions{
			Num:          math.MaxInt16,
			Fuzzy:        true,
			WithScores:   false,
			WithPayloads: false,
		})
		if err != nil {
			logger.Error(ctx, "query key by redis fuzzy search failed", "query_key", fuzzyInput, "error", err)
			return nil, 0, fmt.Errorf("redisearch suggest failed: %w", err)
		}

		if len(results) == 0 {
			// 如果没有结果，退一步（删除最后一个字符）并继续循环
			// TODO 考虑使用其他方式代替 for 循环退一字符的查询方式
			searchInput = trimLastRune(searchInput)
			searchInputLen = len([]rune(searchInput))
			continue
		}

		var recommends []string
		for _, result := range results {
			term := result.Term
			var termHierarchyLen int
			var termPrefix string
			var termLastPart string

			lastDotIndex := strings.LastIndex(term, ".")
			if lastDotIndex == -1 {
				termPrefix = ""
				termLastPart = term
			} else {
				termPrefix = term[:lastDotIndex]
				termLastPart = term[lastDotIndex+1:]
			}

			if recommendLenType == constants.FullRecommendLength && hierarchy == constants.GridRecommendHierarchyType {
				exists, err := rdb.SIsMember(ctx, constants.RedisAllGridSetKey, termLastPart).Result()
				if err != nil || !exists {
					logger.Info(ctx, "query key by redis fuzzy search failed or term not in redis all grid set", "query_key", fuzzyInput, "exists", exists, "error", err)
					continue
				}
			}

			switch recommendLenType {
			case constants.FullRecommendLength:
				if result.Term == "" {
					termHierarchyLen = 1
				} else {
					termHierarchyLen = strings.Count(result.Term, ".") + 1
				}
			case constants.IsLocalRecommendLength:
				if result.Term == "" {
					termHierarchyLen = 4
				} else {
					termHierarchyLen = strings.Count(result.Term, ".") + 4
				}
			}

			if termHierarchyLen == compareHierarchyLen && termPrefix == comparePrefix && strings.HasPrefix(termLastPart, searchInput) {
				recommend := result.Term
				if hierarchy == constants.MeasTagRecommendHierarchyType {
					recommend = strings.Join([]string{termPrefix, configToken, termLastPart}, ".")
				}
				recommends = append(recommends, recommend)
			}
		}

		if len(recommends) == 0 {
			searchInput = trimLastRune(searchInput)
			searchInputLen = len([]rune(searchInput))
			continue
		}

		return recommends, len([]rune(searchInput)), nil
	}
	return []string{}, 0, nil
}

func trimLastRune(s string) string {
	runes := []rune(s)
	if len(runes) == 0 {
		return s
	}
	return string(runes[:len(runes)-1])
}