package main

import (
	"context"
	"encoding/json"
	"fmt"
	"github.com/olivere/elastic"
	log "github.com/sirupsen/logrus"
	"reflect"
	"strings"
)

var ESClient *elastic.Client
var ESServerURL = []string{"http://127.0.0.1:9200"}

type Language struct {
	Name      string `json:"name"`
	BuildTime int    `json:"build_time"`
}

func main() {
	var esIndex = "programming"
	var esType = "language"

	ESClient, err := elastic.NewClient(
		elastic.SetSniff(false),
		elastic.SetURL(ESServerURL...))
	if err != nil {
		log.Errorf("Failed to build elasticsearch connection: %s %s", strings.Join(ESServerURL, ","), err.Error())
	}
	info, code, err := ESClient.Ping(strings.Join(ESServerURL, ",")).Do(context.Background())
	if err != nil {
		log.Error("ping es failed", err.Error())
	}
	fmt.Printf("Elasticsearch returned with code %d and version %s\n", code, info.Version.Number)

	c := &Language{
		Name:      "c",
		BuildTime: 1972,
	}
	php := &Language{
		Name:      "php",
		BuildTime: 1995,
	}
	java := Language{
		Name:      "java",
		BuildTime: 1995,
	}
	python := Language{
		Name:      "python",
		BuildTime: 1991,
	}

	//index exits
	exists, err := ESClient.IndexExists(esIndex).Do(context.Background())
	if err != nil {
		log.Error("check index exist failed", err.Error())
	}
	if !exists {
		log.Infof("index %s is not exist", esIndex)
		_, err := ESClient.CreateIndex(esIndex).Do(context.Background())
		if err != nil {
			log.Error("create index failed", err.Error())
		}
	}
	//
	//insert
	_, err = ESClient.Index().Index(esIndex).Type(esType).Id(c.Name).BodyJson(c).Do(context.Background())
	if err != nil {
		log.Error("insert es failed", err.Error())
	}

	//
	bulkRequest := ESClient.Bulk().Index(esIndex).Type(esType)
	req := elastic.NewBulkIndexRequest().Doc(java)
	req.Id(java.Name)
	bulkRequest.Add(req)
	req = elastic.NewBulkIndexRequest().Doc(php)
	req.Id(php.Name)
	bulkRequest.Add(req)
	req = elastic.NewBulkIndexRequest().Doc(python)
	req.Id(python.Name)
	bulkRequest.Add(req)
	_, err = bulkRequest.Do(context.TODO())
	if err != nil {
		log.Error(err.Error())
	}


	//update
	c.BuildTime = 2020
	_,err = ESClient.Update().Index(esIndex).Type(esType).Id("c").Doc(c).DetectNoop(false).Do(context.Background())
	if err != nil {
		log.Error(err.Error())
	}

	//query
	var resultType Language
	searchById,err := ESClient.Get().Index(esIndex).Type(esType).Id("java").Do(context.Background())
	if searchById.Found{

		if err := json.Unmarshal(searchById.Source,&resultType); err != nil{
			log.Error(err.Error())
		}
		fmt.Printf("search by id: %#v \n",resultType)
	}

	searchAll,err := ESClient.Search(esIndex).Type(esType).Do(context.Background())
	for _,item := range searchAll.Each(reflect.TypeOf(resultType)) {
		language := item.(Language)
		fmt.Printf("search by index all: %#v \n",language)
	}

	searchPart,err := ESClient.Search(esIndex).Type(esType).Size(2).Do(context.Background())
	for _,item := range searchPart.Each(reflect.TypeOf(resultType)) {
		language := item.(Language)
		fmt.Printf("search by index part: %#v \n",language)
	}

	boolquery := elastic.NewBoolQuery()
	boolquery.Must(elastic.NewMatchQuery("name","java"))
	searchByMatch,err := ESClient.Search(esIndex).Type(esType).Query(boolquery).Do(context.Background())
	for _,item := range searchByMatch.Each(reflect.TypeOf(resultType)) {
		language := item.(Language)
		fmt.Printf("search by match: %#v \n",language)
	}

	matchPhraseQuery := elastic.NewMatchPhraseQuery("name","py")
	searchByPhrase,err := ESClient.Search(esIndex).Type(esType).Query(matchPhraseQuery).Do(context.Background())
	for _,item := range searchByPhrase.Each(reflect.TypeOf(resultType)) {
		language := item.(Language)
		fmt.Printf("search by phrase: %#v \n",language)
	}

	boolquery2 := elastic.NewBoolQuery()
	boolquery2.Filter(elastic.NewRangeQuery("build_time").Gt(2000))
	searchByfilter,err := ESClient.Search(esIndex).Type(esType).Query(boolquery2).Do(context.Background())
	for _,item := range searchByfilter.Each(reflect.TypeOf(resultType)) {
		language := item.(Language)
		fmt.Printf("search by filter: %#v \n",language)
	}

	//delete
	_,err = ESClient.Delete().Index(esIndex).Type(esType).Id("c").Do(context.Background())
	if err != nil {
		log.Error(err.Error())
	}

	_, err = ESClient.DeleteIndex(esIndex).Do(context.Background())
	if err != nil {
		log.Error(err.Error())
	}
}