package elastic

import (
	"context"
	"encoding/json"
	"eta/eta_forum_hub/models"
	"eta/eta_forum_hub/utils"
	"fmt"
	"github.com/olivere/elastic/v7"
)

// EsAddOrEditEdbInfoData 新增/修改es中的指标数据
func EsAddOrEditEdbInfoData(indexName, docId string, item *models.EdbInfoList) (err error) {
	defer func() {
		if err != nil {
			fmt.Println("EsAddOrEditData Err:", err.Error())
		}
	}()
	client := utils.EsClient

	resp, err := client.Index().Index(indexName).Id(docId).BodyJson(item).Do(context.Background())
	if err != nil {
		fmt.Println("新增失败:", err.Error())
		return err
	}
	fmt.Println(resp)
	if resp.Status == 0 {
		fmt.Println("新增成功", resp.Result)
		err = nil
	} else {
		fmt.Println("AddData", resp.Status, resp.Result)
	}
	return
}

// EsDeleteEdbInfoData 删除es中的指标数据
func EsDeleteEdbInfoData(indexName, docId string) (err error) {
	defer func() {
		if err != nil {
			fmt.Println("EsDeleteEdbInfoData Err:", err.Error())
		}
	}()
	client := utils.EsClient

	resp, err := client.Delete().Index(indexName).Id(docId).Do(context.Background())
	fmt.Println(resp)
	if err != nil {
		return
	}
	if resp.Status == 0 {
		fmt.Println("删除成功")
	} else {
		fmt.Println("AddData", resp.Status, resp.Result)
	}
	return
}

// EsAddOrEditChartInfoData 新增/修改es中的图表数据
func EsAddOrEditChartInfoData(indexName, docId string, item *models.ChartInfo) (err error) {
	defer func() {
		if err != nil {
			fmt.Println("EsAddOrEditData Err:", err.Error())
		}
	}()
	client := utils.EsClient

	resp, err := client.Index().Index(indexName).Id(docId).BodyJson(item).Do(context.Background())
	if err != nil {
		fmt.Println("新增失败:", err.Error())
		return err
	}
	fmt.Println(resp)
	if resp.Status == 0 {
		fmt.Println("新增成功", resp.Result)
		err = nil
	} else {
		fmt.Println("AddData", resp.Status, resp.Result)
	}
	return
}

// EsDeleteDataV2 删除es中的数据
func EsDeleteDataV2(indexName, docId string) (err error) {
	defer func() {
		if err != nil {
			fmt.Println("EsDeleteEdbInfoData Err:", err.Error())
		}
	}()
	client := utils.EsClient

	resp, err := client.Delete().Index(indexName).Id(docId).Do(context.Background())
	fmt.Println(resp)
	if err != nil {
		return
	}
	if resp.Status == 0 {
		fmt.Println("删除成功")
	} else {
		fmt.Println("AddData", resp.Status, resp.Result)
	}
	return
}

// SearchChartInfoData 查询es中的图表数据
func SearchChartInfoData(indexName, keywordStr string, showSysId []int, sourceList []int, permissionClassifyIdList []int, from, size int) (list []*models.ChartInfo, total int64, err error) {
	list = make([]*models.ChartInfo, 0)
	defer func() {
		if err != nil {
			fmt.Println("EsAddOrEditData Err:", err.Error())
		}
	}()
	client := utils.EsClient

	//queryString := elastic.NewQueryStringQuery(keywordStr)
	//boolQueryJson, err := json.Marshal(queryString)
	//if err != nil {
	//	fmt.Println("boolQueryJson err:", err)
	//} else {
	//	fmt.Println("boolQueryJson ", string(boolQueryJson))
	//}

	highlight := elastic.NewHighlight()
	highlight = highlight.Fields(elastic.NewHighlighterField("ChartName"))
	highlight = highlight.PreTags("<font color='red'>").PostTags("</font>")

	mustMap := make([]interface{}, 0)
	mustNotMap := make([]interface{}, 0)

	//指标来源
	if len(showSysId) > 0 {
		mustMap = append(mustMap, map[string]interface{}{
			"terms": map[string]interface{}{
				"SysUserId": showSysId,
				//"Frequency.keyword": "月度",
			},
		})
	}
	mustMap = append(mustMap, map[string]interface{}{
		"terms": map[string]interface{}{
			"Source": sourceList,
		},
	})
	// permissionClassifyIdList 只在特定的分类ID下的图表
	if len(permissionClassifyIdList) > 0 {
		mustMap = append(mustMap, map[string]interface{}{
			"terms": map[string]interface{}{
				"ChartClassifyId": permissionClassifyIdList,
				//"Frequency.keyword": "月度",
			},
		})
	}
	//关键字匹配
	//shouldMap := map[string]interface{}{
	//	"should": []interface{}{
	//		map[string]interface{}{
	//			"match": map[string]interface{}{
	//				"ChartName": keywordStr,
	//				//"Frequency.keyword": "月度",
	//			},
	//		},
	//		// 因为关键词被分了，所以需要用下面的语句来让他 整个词 查询，从而加重整词的权重
	//		map[string]interface{}{
	//			"match": map[string]interface{}{
	//				"ChartName": map[string]interface{}{
	//					"query":    keywordStr,
	//					"operator": "and",
	//				},
	//				//"Frequency.keyword": "月度",
	//			},
	//		},
	//		map[string]interface{}{
	//			"match": map[string]interface{}{
	//				"ChartNameEn": keywordStr,
	//				//"Frequency.keyword": "月度",
	//			},
	//		},
	//		// 因为关键词被分了，所以需要用下面的语句来让他 整个词 查询，从而加重整词的权重
	//		map[string]interface{}{
	//			"match": map[string]interface{}{
	//				"ChartNameEn": map[string]interface{}{
	//					"query":    keywordStr,
	//					"operator": "and",
	//				},
	//				//"Frequency.keyword": "月度",
	//			},
	//		},
	//	},
	//}

	// 默认使用中文名字字段去匹配
	keywordNameKey := `ChartName`
	// 如果没有中文，则使用英文名称字段去匹配
	/*if !utils.ContainsChinese(keywordStr) {
		keywordNameKey = `ChartNameEn`
	}*/
	shouldMap := map[string]interface{}{
		"should": []interface{}{
			/*map[string]interface{}{
				"match": map[string]interface{}{
					keywordNameKey: keywordStr,
					//"Frequency.keyword": "月度",
				},
			},*/
			// 因为关键词被分了，所以需要用下面的语句来让他 整个词 查询，从而加重整词的权重
			map[string]interface{}{
				"match": map[string]interface{}{
					keywordNameKey: map[string]interface{}{
						"query":    keywordStr,
						"operator": "and",
					},
					//"Frequency.keyword": "月度",
				},
			},
		},
	}

	mustMap = append(mustMap, map[string]interface{}{
		"bool": shouldMap,
	})

	queryMap := map[string]interface{}{
		"query": map[string]interface{}{
			"bool": map[string]interface{}{
				"must":     mustMap,
				"must_not": mustNotMap,
				//"should":   shouldMap,
			},
		},
	}

	//根据条件数量统计
	requestTotalHits := client.Count(indexName).BodyJson(queryMap)
	total, err = requestTotalHits.Do(context.Background())
	if err != nil {
		return
	}

	// 分页查询
	queryMap["from"] = from
	queryMap["size"] = size
	jsonBytes, _ := json.Marshal(queryMap)
	fmt.Println(string(jsonBytes))

	request := client.Search(indexName).Highlight(highlight).Source(queryMap) // sets the JSON request

	//requestJson, err := json.Marshal(request)
	//if err != nil {
	//	fmt.Println("requestJson err:", err)
	//}
	//fmt.Println("requestJson ", string(requestJson))
	searchMap := make(map[string]string)

	searchResp, err := request.Do(context.Background())
	if err != nil {
		return
	}
	fmt.Println(searchResp)
	fmt.Println(searchResp.Status)
	if searchResp.Status != 0 {
		return
	}

	if searchResp.Hits != nil {
		for _, v := range searchResp.Hits.Hits {
			if _, ok := searchMap[v.Id]; !ok {
				itemJson, tmpErr := v.Source.MarshalJSON()
				if tmpErr != nil {
					err = tmpErr
					fmt.Println("movieJson err:", err)
					return
				}
				chartInfoItem := new(models.ChartInfo)
				tmpErr = json.Unmarshal(itemJson, &chartInfoItem)
				if err != nil {
					fmt.Println("json.Unmarshal chartInfoJson err:", err)
					err = tmpErr
					return
				}
				if len(v.Highlight["ChartName"]) > 0 {
					chartInfoItem.ChartName = v.Highlight["ChartName"][0]
				}
				list = append(list, chartInfoItem)
				searchMap[v.Id] = v.Id
			}
		}
	}

	//for _, v := range result {
	//	fmt.Println(v)
	//}
	return
}

// EsAddOrEditDataInterface 新增/修改es中的数据
func EsAddOrEditDataInterface(indexName, docId string, item interface{}) (err error) {
	defer func() {
		if err != nil {
			fmt.Println("EsAddOrEditData Err:", err.Error())
		}
	}()
	client := utils.EsClient

	resp, err := client.Index().Index(indexName).Id(docId).BodyJson(item).Do(context.Background())
	if err != nil {
		fmt.Println("新增失败:", err.Error())
		return err
	}
	fmt.Println(resp)
	if resp.Status == 0 {
		fmt.Println("新增成功", resp.Result)
		err = nil
	} else {
		fmt.Println("AddData", resp.Status, resp.Result)
	}
	return
}