package goelastic

import (
    "context"
    "encoding/json"
    "errors"
    "fmt"
    "gitee.com/leijmdas/gobase/goconfig/common/base/basedto"
    "gitee.com/leijmdas/gobase/goconfig/common/base/baseutils"
    "gitee.com/leijmdas/gobase/goconfig/common/base/jsonutils"
    "gitee.com/leijmdas/gobase/goconfig/common/golog"
    "gitee.com/leijmdas/gobase/goconfig/common/ichubconfig"
    "gitee.com/leijmdas/goweb/goes/pagees"
    "gitee.com/leijmdas/goweb/goes/pagereq"
    "github.com/elastic/go-elasticsearch/v8"
    "github.com/elastic/go-elasticsearch/v8/esapi"

    "github.com/gogf/gf/util/gconv"
    "github.com/olivere/elastic/v7"
    "github.com/sirupsen/logrus"
    "io"
    "strings"
)

type GoElastic struct {
    basedto.BaseEntitySingle
    client *elasticsearch.Client

    Opened bool   `json:"opened"`
    Info   string `json:"init"`
}

func Default() *GoElastic {
    return baseutils.NewOfPtrTypeProxy[*GoElastic]()
}

func NewGoElasticCli() *GoElastic {
    //var s = &GoElastic{}
    //s.InitProxy(s)
    //s.Init()
    return Default()
}
func (self *GoElastic) Client() *elasticsearch.Client {
    return self.client
}
func (self *GoElastic) Search(o ...func(*esapi.SearchRequest)) (*esapi.Response, error) {
    return self.client.Search(o...)

}

func (self *GoElastic) Search2Map(o ...func(*esapi.SearchRequest)) (map[string]any, error) {
    var res, err = self.Search(o...)
    if err != nil {
       logrus.Fatalf("Error getting response: %s", err)
    }
    defer res.Body.Close()
    if res.IsError() {
       logrus.Fatalf("Error: %s", res.String())
       return nil, err
    }
    var r map[string]any
    if err := json.NewDecoder(res.Body).Decode(&r); err != nil {
       logrus.Fatalf("Error parsing the response body: %s", err)
    }
    // 打印查询结果
    fmt.Printf("Query result: %v\n", jsonutils.ToJsonPretty(r))
    return r, nil
}
func (self *GoElastic) Search2PageEsResult(o ...func(*esapi.SearchRequest)) *pagees.PageEsResult {
    var res, err = self.Search2SearchResult(o...)
    if err != nil {
       golog.Error(err)
       return pagees.FailedPageEsResultErr(err)
    }

    var result = pagees.FindBeanPageEsResult()
    result.PageEsResultOfSearch(res, false)
    return result
}
func (self *GoElastic) Search2SearchResult(o ...func(*esapi.SearchRequest)) (*elastic.SearchResult, error) {
    var res, err = self.Search(o...)
    if err != nil {
       logrus.Fatalf("Error getting response: %s", err)
    }
    defer res.Body.Close()
    if res.IsError() {
       logrus.Fatalf("Error: %s", res.String())
       return nil, err
    }
    if res.StatusCode != 200 {
       golog.Error("Error: status code=", res.Status())
       return nil, errors.New("status code  =" + gconv.String(res.StatusCode))
    }
    var searchRes = new(elastic.SearchResult)
    if err := json.NewDecoder(res.Body).Decode(searchRes); err != nil {
       logrus.Fatalf("Error parsing the response body: %s", err)
    }
    // 打印查询结果
    fmt.Printf("Query result: %v\n", jsonutils.ToJsonPretty(searchRes))
    return searchRes, nil
}

func (self *GoElastic) SetClient(client *elasticsearch.Client) {
    self.client = client
}

func (self *GoElastic) Init() {
    var err error
    var esdto = ichubconfig.FindBeanIchubConfig().ReadIchubEs()
    golog.Info(esdto)
    self.client, err = elasticsearch.NewClient(elasticsearch.Config{
       Addresses: strings.Split(esdto.URL, ","),
       Username:  esdto.Username,
       Password:  esdto.Password,
    })
    self.Opened = err == nil

    if err != nil {
       golog.Error("Error creating the client: ", err)

    }

}
func (self *GoElastic) makeBody(req *pagereq.QueryRequest) io.Reader {
    var q = map[string]any{}
    q["query"], _ = req.BuildBoolQuery().Source()
    return strings.NewReader(jsonutils.ToJsonPretty(q))

}
func (self *GoElastic) Query(req *pagereq.QueryRequest) *pagees.PageEsResult {

    var res, err = self.Search2SearchResult(
       self.client.Search.WithContext(context.Background()),
       self.client.Search.WithIndex(strings.Split(req.IndexName, ",")...),
       //client.Search.WithQuery(query),
       self.client.Search.WithBody(self.makeBody(req)),
       self.client.Search.WithPretty(),
       self.client.Search.WithSize(req.Limit()),
       self.client.Search.WithFrom(req.Start()),
       self.client.Search.WithSource(req.Source))
    if err != nil {
       golog.Error(err)
       return pagees.FailedPageEsResultErr(err)
    }

    var result = pagees.FindBeanPageEsResult()
    result.PageEsResultOfSearch(res, false)
    return result
}

func (suite *TestGoElasticSuite) Test001_Search() {

    var src, _ = elastic.NewMatchQuery("name", "市场部门").Source()
    var q = map[string]any{}
    q["query"] = src
    var qq = pagereqcli.Default().SetPageSize(2)
    qq.Aggregation("count", elastic.NewValueCountAggregation().Field("shop_count"))
    qq.Aggregation("stats", elastic.NewStatsAggregation().Field("shop_count"))
    var agg, _ = elastic.NewStatsAggregation().Field("shop_count").Source()
    var aggs = map[string]any{}
    aggs["count"] = agg
    q["aggs"] = aggs
    var reader = strings.NewReader(jsonutils.ToJsonPretty(q))
    var qs = `{      
            "match_all": {
            } 
    }`
    q["query"] = qs
    q["query"], _ = elastic.NewMatchQuery("short_name", "古泳").Source() //Query(tic.NewMatchAllQuery()) //

    res, err := suite.inst.Search2SearchResult(
       suite.inst.Client().Search.WithContext(context.Background()),
       suite.inst.Client().Search.WithIndex("ichub_sys_dept"),
       //suite.inst.Client().Search.WithQuery(query),
       suite.inst.Client().Search.WithBody(reader),
       suite.inst.Client().Search.WithPretty(),
       suite.inst.Client().Search.WithSize(2),
       suite.inst.Client().Search.WithSource("id,name"),
    )
    golog.Info(res, err)
    var result = pagees.FindBeanPageEsResult()
    result.PageEsResultOfSearch(res, false)
    golog.Info(result, suite.inst)

}