package blevex

import (
	"fmt"
	"github.com/blevesearch/bleve/v2"
	"github.com/blevesearch/bleve/v2/mapping"
	"github.com/yanyiwu/gojieba"
	"sync"
)

// InitAnalyzer 加载自定义分词器（结巴分词）

var defaultAnalyzer *mapping.IndexMappingImpl

func InitAnalyzer() {
	indexMapping := bleve.NewIndexMapping()
	//os.RemoveAll(IndexDir)
	//// clean index when example finished
	//defer os.RemoveAll(IndexDir)

	err := indexMapping.AddCustomTokenizer("gojieba",
		map[string]interface{}{
			"dictpath":     gojieba.DICT_PATH,
			"hmmpath":      gojieba.HMM_PATH,
			"userdictpath": gojieba.USER_DICT_PATH,
			"idf":          gojieba.IDF_PATH,
			"stop_words":   gojieba.STOP_WORDS_PATH,
			"type":         "gojieba",
		},
	)
	if err != nil {
		panic(err)
	}
	err = indexMapping.AddCustomAnalyzer("gojieba",
		map[string]interface{}{
			"type":      "gojieba",
			"tokenizer": "gojieba",
		},
	)
	if err != nil {
		panic(err)
	}
	indexMapping.DefaultAnalyzer = "gojieba"
	defaultAnalyzer = indexMapping
}

var indexMap sync.Map

func NewIndex(indexName string) (bleve.Index, error) {
	if defaultAnalyzer == nil {
		InitAnalyzer()
	}
	index, err := bleve.New(indexName, defaultAnalyzer)
	if err == bleve.ErrorIndexPathExists {
		index, err = bleve.Open(indexName)
		if err != nil {
			return nil, err
		}
		return index, nil
	} else if err != nil {
		return nil, err
	}
	return index, nil
}

func LoadIndex(indexName string) (bleve.Index, error) {
	if v, ok := indexMap.Load(indexName); ok {
		return v.(bleve.Index), nil
	}
	index, err := NewIndex(indexName)
	if err == nil {
		indexMap.Store(indexName, index)
	}
	return index, err
}
func Search(indexName string, keyword string, from, size int) (ids []string, total uint64, err error) {
	index, err := LoadIndex(indexName)
	if err != nil {
		return
	}
	req := bleve.NewSearchRequest(bleve.NewQueryStringQuery(keyword))
	req.From = from
	req.Size = size
	res, err := index.Search(req)
	if err != nil {
		return nil, 0, err
	}
	if res == nil {
		return
	}
	for _, ret := range dealResult(res) {
		ids = append(ids, ret.Id)
	}
	return ids, res.Total, nil
}

func ComplexSearch(indexName string, keyword string, conditions map[string]interface{}, from, size int) (ids []string, total uint64, err error) {
	index, err := LoadIndex(indexName)
	if err != nil {
		return nil, 0, err
	}

	// Create a boolean query with a should clause for fuzzy search
	boolQuery := bleve.NewBooleanQuery()

	fuzzyQuery := bleve.NewFuzzyQuery(keyword)
	fuzzyQuery.SetFuzziness(2) // Set the fuzziness level as needed

	boolQuery.AddShould(fuzzyQuery)

	// Add a must clause for category filtering
	for key, val := range conditions {
		query := bleve.NewQueryStringQuery(fmt.Sprintf("%s:%s", key, val))
		boolQuery.AddMust(query)
	}
	req := bleve.NewSearchRequest(boolQuery)
	req.From = from
	req.Size = size
	res, err := index.Search(req)
	if err != nil {
		return nil, 0, err
	}
	if res == nil {
		return
	}
	for _, ret := range dealResult(res) {
		ids = append(ids, ret.Id)
	}
	return ids, res.Total, nil
}

type Result struct {
	Id    string  `json:"id"`
	Score float64 `json:"score"`
}

func dealResult(res *bleve.SearchResult) []Result {
	var results []Result
	for _, item := range res.Hits {
		results = append(results, Result{item.ID, item.Score})
	}
	return results
}