package eswebclient

import (
	"gitee.com/leijmdas/gobase/goconfig/common/base/basedto"
	"gitee.com/leijmdas/gobase/goconfig/common/base/baseindex"
	"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/common/webclient"
	"gitee.com/leijmdas/goweb/common/webclient/webmsg"
	"gitee.com/leijmdas/goweb/goes/esconst"
	"gitee.com/leijmdas/goweb/goes/pagees"
	"gitee.com/leijmdas/goweb/goes/pagereq"
	"gitee.com/leijmdas/goweb/goes/pagereq/cmddto"
	"gitee.com/leijmdas/goweb/goes/pagereqcli"
	"gitee.com/leijmdas/goweb/gopage/page"
	"github.com/gogf/gf/util/gconv"
	"github.com/olivere/elastic/v7"
	"gorm.io/gorm/schema"
)

const ESServerName = "web.esserver.com"

// 依赖 suite.Suite
type EsWebClient struct {
	*webclient.WebClient
}

func DefaultEs() *EsWebClient {
	var cli = &EsWebClient{
		WebClient: webclient.DefaultEs(),
	}
	return cli
}
func NewEsWebClient() *EsWebClient {
	var cli = &EsWebClient{}
	return cli.init()
}
func (this *EsWebClient) Single() bool {

	return true
}

// 每个测试运行前，会执行
func (this *EsWebClient) init() *EsWebClient {

	var config = ichubconfig.FindBeanIchubConfig()
	web := config.ReadIchubWebClient()
	web.ServerName = ESServerName
	this.WebClient = webclient.New(web)

	return this
}

func (this *EsWebClient) Get(IndexName, Id string) *page.PageResult {
	var req = pagereq.NewQueryRequest()
	req.IndexName = IndexName
	req.Id = Id
	req.CmdType = esconst.ES_QUERY_TYPE_GET
	return this.Query(req)
}
func (this *EsWebClient) QueryAs(req *pagereq.QueryRequest, out interface{}) *page.PageResult {
	return this.Query(req)
}

func (this *EsWebClient) Query(req *pagereq.QueryRequest) *page.PageResult {

	//req
	var msg = webmsg.NewWebMsg()
	msg.SetUrl("query")
	msg.SetMethod("POST")
	msg.SetBody(req.ToJsonBytes())
	msg.SetHeaders(map[string]string{
		"Content-Type": "application/json",
	})
	var ret = this.WebClient.Post2PageResult(msg)
	ret.Hosturl = msg.HostUrl
	return ret

}
func (this *EsWebClient) Should(req *pagereq.QueryRequest) *page.PageResult {
	req.CmdType = esconst.Should
	return this.Query(req)
}

func (this *EsWebClient) Filter(req *pagereq.QueryRequest) *page.PageResult {
	req.CmdType = esconst.Filter
	return this.Query(req)
}
func (this *EsWebClient) Must(req *pagereq.QueryRequest) *page.PageResult {
	req.CmdType = esconst.Must
	return this.Query(req)
}
func (this *EsWebClient) MustNot(req *pagereq.QueryRequest) *page.PageResult {
	req.CmdType = esconst.MustNot
	return this.Query(req)
}

func (this *EsWebClient) Cmd(cmd *pagereq.CmdRequest) *basedto.IchubResult {

	//req
	var msg = webmsg.NewWebMsg()
	msg.SetUrl("cmd")
	msg.SetMethod("POST")
	msg.SetBody(cmd.ToJsonBytes())
	msg.SetHeaders(map[string]string{
		"Content-Type": "application/json",
	})
	return this.WebClient.Post2Result(msg)

}

func (this *EsWebClient) CmdBulkIndex(cmd *pagereq.CmdRequest) *basedto.IchubResult {
	cmd.CmdType = esconst.ES_CMD_TYPE_BULKINDEX
	return this.Cmd(cmd)
}
func (this *EsWebClient) CmdBulkUpdate(cmd *pagereq.CmdRequest) *basedto.IchubResult {
	cmd.CmdType = esconst.ES_CMD_TYPE_BULKUPDATE
	return this.Cmd(cmd)
}

func (this *EsWebClient) CmdBulkCreate(cmd *pagereq.CmdRequest) *basedto.IchubResult {
	cmd.CmdType = esconst.ES_CMD_TYPE_BULKCREATE
	return this.Cmd(cmd)
}
func (this *EsWebClient) CmdBulkDelete(cmd *pagereq.CmdRequest) *basedto.IchubResult {
	cmd.CmdType = esconst.ES_CMD_TYPE_BULKDELETE
	return this.Cmd(cmd)
}
func (this *EsWebClient) CmdDelete(index schema.Tabler, ids []string) *basedto.IchubResult {
	cmd := pagereq.DefaultCmd()
	cmd.CmdType = esconst.ES_CMD_TYPE_BULKDELETE
	cmd.IndexName = index.TableName()
	cmd.Ids = ids
	return this.Cmd(cmd)
}
func (this *EsWebClient) CreateAlias(indexname, aliasname string) *basedto.IchubResult {
	var req = pagereq.NewMetadataRequest()
	req.CmdType = esconst.ES_METADATA_CREATEALIAS
	req.IndexName = indexname
	req.IndexAlias = aliasname
	return this.Metadata(req)

}

func (this *EsWebClient) Metadata(req *pagereq.MetadataRequest) *basedto.IchubResult {

	//req
	var msg = webmsg.NewWebMsg()
	msg.SetUrl("meta")
	msg.SetMethod("POST")
	msg.SetBody(req.ToJsonBytes())
	msg.SetHeaders(map[string]string{
		"Content-Type": "application/json",
	})
	return this.WebClient.Post2Result(msg)

}
func (this *EsWebClient) Keyword(req *pagees.PageEsRequest) *page.PageResult {

	//req
	var msg = webmsg.NewWebMsg()
	msg.SetUrl("keyword")
	msg.SetMethod("POST")
	msg.SetBody(req.ToJsonBytes())
	msg.SetHeaders(map[string]string{
		"Content-Type": "application/json",
	})
	return this.WebClient.Post2PageResult(msg)

}

// hhtpcliqueryAgg
func (webcli *EsWebClient) HttpCliQuery(q *pagereqcli.HttpCliQuery, query ...elastic.Query) *page.PageResult {
	if len(query) == 0 {
		q.CmdType = esconst.ES_HTTPCLI_QUERY
		return webcli.Query(q.QueryRequest)
	}
	return webcli.HttpCliQueryNew(q, query[0])
}

func (webcli *EsWebClient) HttpQuery(q *pagereqcli.HttpCliQuery, query ...elastic.Query) *page.PageResult {
	if len(query) == 0 && q.EsQuery == nil {
		q.EsQuery = q.BuildBoolQuery()
	}
	if len(query) == 0 && q.EsQuery != nil {
		query = append(query, q.EsQuery)
	}
	if len(query) == 0 && q.HttpcliBody != "" {
		q.CmdType = esconst.ES_HTTPCLI_QUERY
		return webcli.Query(q.QueryRequest)
	}
	return webcli.HttpCliQueryNew(q, query[0])
}
func (webcli *EsWebClient) HttpCliQueryNew(q *pagereqcli.HttpCliQuery, query elastic.Query) *page.PageResult {

	var src, err = query.Source()
	if err != nil {
		return page.ResultFailedPageResultErr(err)
	}
	//golog.Info("query =", src)
	q.HttpcliBody = jsonutils.ToJsonPretty(src)
	//`{"bool":{"must":[{"bool":{"should":{"terms":{"manager_shop_id":[722819552238895105,722819552698826753,722820039095025665,722896539725529089,743328316525051905,787953376778584065,722820038610157569,770106024101117953,735639267747987457,722831231565856769,722827384433508353,722893463554392065,799908008593948673,723147915575558145,722887659976130561]}}}},{"term":{"invoice_type":"outbound"}}],"must_not":{"terms":{"biz_type.keyword":["platform_sales_order","platform_sales_order_refund","self_sales_order","self_sales_order_refund","service"]}}}}`
	q.CmdType = esconst.ES_HTTPCLI_QUERY
	//golog.Info(q)
	return webcli.Query(q.QueryRequest)

}
func (webcli *EsWebClient) ExecuteQuery(q *pagereqcli.HttpCliQuery) *page.PageResult {
	return webcli.Query(q.QueryRequest)
}
func (webcli *EsWebClient) HttpQuerySource(q *pagereqcli.HttpCliQuery) *page.PageResult {
	q.QuerySourceBody()

	q.CmdCategory = esconst.ES_HTTPCLI_CATEGORY
	q.CmdType = esconst.ES_HTTPCLI_QUERY_SOURCE
	//golog.Info("EsWebClient [HttpQuerySource] q =", q)
	var ret = webcli.Query(q.QueryRequest)
	if ret.IsFailed() {
		golog.Error("EsWebClient [HttpQuerySource] ret =", ret)
	}
	return ret

}
func (webcli *EsWebClient) MetaCreateIndex(index baseindex.IndexMapping) *basedto.IchubResult {
	var req = pagereq.DefaultMetadata()
	req.SetIndexTable(index)
	req.CmdType = esconst.ES_METADATA_CREATEINDEX
	req.Mappings = index.GetMapping()
	return webcli.Metadata(req)
}
func (webcli *EsWebClient) MetaDropIndex(index schema.Tabler) *basedto.IchubResult {
	var req = pagereq.DefaultMetadata()
	req.SetIndexTable(index)
	req.CmdType = esconst.ES_METADATA_DROPINDEX
	return webcli.Metadata(req)
}
func (webcli *EsWebClient) MetaGetMapping(index schema.Tabler) *basedto.IchubResult {
	var req = pagereq.DefaultMetadata()
	req.SetIndexTable(index)
	req.CmdType = esconst.ES_METADATA_GETMAPPING
	return webcli.Metadata(req)
}
func (webcli *EsWebClient) MetaIndexExists(index schema.Tabler) *basedto.IchubResult {
	var req = pagereq.DefaultMetadata()
	req.SetIndexTable(index)
	req.CmdType = esconst.ES_METADATA_INDEXEXISTS
	return webcli.Metadata(req)
}
func (webcli *EsWebClient) CreateIndexesIfNotExist(indexes ...baseindex.IndexMapping) *basedto.IchubResult {
	for _, v := range indexes {
		var result = webcli.CreateIndexIfNotExist(v)
		if result.IsFailed() {
			if result.IsFailed() {

				golog.Error("[CreateIndexesIfNotExist]", result)
				return result
			}
		}
	}
	return basedto.ResultSuccessData(true)
}

func (webcli *EsWebClient) CreateIndexIfNotExist(index baseindex.IndexMapping) *basedto.IchubResult {
	//i++
	golog.Info("create index ", index.TableName())
	var result = webcli.MetaIndexExists(index)
	if result.IsFailed() {
		golog.Error(index.TableName() + " " + index.GetMapping())
		golog.Error(result)
		return result
	}
	if result.Data.(bool) {
		result.Msg = index.TableName() + "索引已存在"
		golog.Info("索引已存在", index.TableName())
		return result
	}
	//	_, err := es.Elastic().CreateIndex(imap.TableName()).BodyString(imap.GetMapping()).Do(ctx)
	result = webcli.MetaCreateIndex(index)
	if result.IsFailed() {
		golog.Error(result)

		return result
	}
	if result.Data.(bool) {
		result.Msg = index.TableName() + "创建索引成功"
		golog.Info("创建索引成功", index.TableName())
	} else {
		result.Msg = index.TableName() + "创建索引不成功"
		golog.Info("创建索引不成功", index.TableName())
	}
	return result
}

func (webcli *EsWebClient) InsertIfNotExists(req *pagereq.CmdRequest) *basedto.IchubResult {

	req.CmdType = esconst.ES_CMD_TYPE_INSERT_IF_NOTEXISTS
	return webcli.Cmd(req)

}
func (webcli *EsWebClient) BulkIndex(tabler schema.Tabler, docs []*cmddto.BulkDoc) *basedto.IchubResult {
	var cmd = pagereq.DefaultCmd()

	cmd.SetIndexTable(tabler)
	cmd.BulkDocs = docs
	cmd.CmdType = esconst.ES_CMD_TYPE_BULKINDEX

	return webcli.Cmd(cmd)
}

func (webcli *EsWebClient) BulkUpdate(tabler schema.Tabler, docs []*cmddto.BulkDoc) *basedto.IchubResult {
	var cmd = pagereq.DefaultCmd()

	cmd.SetIndexTable(tabler)
	cmd.BulkDocs = docs
	cmd.CmdType = esconst.ES_CMD_TYPE_BULKUPDATE

	return webcli.Cmd(cmd)
}
func (webcli *EsWebClient) BulkScriptUpdate(tabler schema.Tabler, docs []*cmddto.BulkDoc) *basedto.IchubResult {
	var cmd = pagereq.DefaultCmd()

	cmd.SetIndexTable(tabler)
	cmd.BulkDocs = docs
	cmd.CmdType = esconst.ES_CMD_TYPE_BULKSCRIPTUPSERT

	return webcli.Cmd(cmd)
}
func (webcli *EsWebClient) Delete(tabler schema.Tabler, id any) *basedto.IchubResult {
	var cmd = pagereq.DefaultCmd()
	cmd.Id = gconv.String(id)
	cmd.SetIndexTable(tabler)
	cmd.CmdType = esconst.ES_CMD_TYPE_DELETE
	return webcli.Cmd(cmd)
}
func (webcli *EsWebClient) DeleteByQuery(req *pagereq.CmdRequest) *basedto.IchubResult {
	req.CmdType = esconst.ES_CMD_TYPE_DELETEBYQUERY
	return webcli.Cmd(req)

}

// func (webcli *EsWebClient) UpdateStru(cmd *pagereq.CmdRequest, id any, stru any) *basedto.IchubResult {
//
//	return webcli.Update(cmd, id, jsonutils.Stru2Map(stru))
//
// }
func (webcli *EsWebClient) BulkCreate(tabler schema.Tabler, docs []*cmddto.BulkDoc) *basedto.IchubResult {
	var cmd = pagereq.DefaultCmd()

	cmd.SetIndexTable(tabler)
	cmd.BulkDocs = docs
	cmd.CmdType = esconst.ES_CMD_TYPE_BULKCREATE

	return webcli.Cmd(cmd)
}
func (webcli *EsWebClient) BulkDelete(tabler schema.Tabler, ids ...any) *basedto.IchubResult {
	var cmd = pagereq.DefaultCmd()
	for _, id := range ids {
		cmd.Ids = append(cmd.Ids, gconv.String(id))
	}
	cmd.SetIndexTable(tabler)
	cmd.CmdType = esconst.ES_CMD_TYPE_BULKDELETE

	return webcli.Cmd(cmd)
}

func (webcli *EsWebClient) ExistId(q *pagereq.QueryRequest) *page.PageResult {
	q.CmdCategory = esconst.ES_CMD_CATEGORY_QUERY
	q.CmdType = esconst.ES_QUERY_TYPE_EXISTS_ID
	q.SetPageSize(0)
	return webcli.Query(q)
}

func (webcli *EsWebClient) BulkUpsert(cmd *pagereq.CmdRequest) *basedto.IchubResult {

	cmd.CmdType = esconst.ES_CMD_TYPE_BULKDOCASUPSERT
	return webcli.Cmd(cmd)
}

func (webcli *EsWebClient) GeneralQuerySource(q *pagereqcli.HttpCliQuery) *page.PageResult {
	if q.Models() == nil {
		golog.Error("EsWebClient [GeneralQuerySource] models is nil")
		return page.ResultFailedPageResult(500, "models is nil")
	}
	var result = webcli.HttpQuerySource(q)
	if result.IsSuccess() && result.Data != nil {

		err := jsonutils.Decode2StruList(result.Data, q.Models())
		if err != nil {
			golog.Error("EsWebClient GeneralQuerySource ", err, q)
			return page.ResultFailedPageResult(500, "jsonutils.FromJson err ="+err.Error())
		}
		result.Data = q.Models()
	}

	return result

}