// Package http add by blacknc <blacknc@163.com> at 2023/04/03 15:46:39
package http

import (
	"context"
	"dataservices/commons/httpclient"
	"dataservices/commons/utils"
	controllerdto "dataservices/internal/dto/dataapi_control"
	dto "dataservices/internal/dto/dataapi_gateway"
	"dataservices/internal/entity"
	"encoding/json"
	"fmt"
	"time"

	"github.com/tidbcloud/tiinf/errs"
)

func ReportDownloadDataAppLogResult(ctx context.Context, req controllerdto.DownloadLogResult) error {
	return postToDataserviceCentral(ctx, "/inner/dataservice/download_log_res", req, nil)
}

func GetPlaygroundAccount(ctx context.Context, projectID, clusterID uint64) (resp *GetPlaygroundAccountResp, e error) {
	url := fmt.Sprintf("/inner/dataservice/projects/%d/clusters/%d/account/playground", projectID, clusterID)
	resp = &GetPlaygroundAccountResp{}
	e = getToPlaygroundAccount(ctx, url, resp)
	return
}

func ReportEndpointExecRecord(ctx context.Context, record *entity.EndpointExecRecord) error {
	return ReportEventRecord(ctx, dto.EndpointExecRecordType, record)
}

func ListDataAppUsage(ctx context.Context, url string) (*entity.O11YResp, error) {
	resp, code, err := httpclient.Get(url)
	if err != nil {
		return nil, err
	}
	o11YResp := &entity.O11YResp{}
	err = parseResp(ctx, resp, code, err, o11YResp)
	if err != nil {
		return nil, err
	}
	return o11YResp, nil
}

func ReportEventRecord(ctx context.Context, recordType dto.RecordType, recordContent any) error {
	recordJson, err := json.Marshal(recordContent)
	if err != nil {
		return errs.NewBadRequest("invalid event record info", err)
	}
	request := dto.HistoryRecordReq{
		RecordType:    recordType,
		RecordTime:    utils.Now(),
		RecordContent: string(recordJson),
	}
	return postToDataserviceCentral(ctx, "/inner/dataservice/event_record", request, nil)
}

func getToPlaygroundAccount(ctx context.Context, url string, resp interface{}) (err error) {
	defer func() {
		recordHttpCounterMetric("dataservice-central-service", err)
	}()
	return getRequestToGlobal(ctx, "dataservice-central-service", url, nil, resp)
}

func postToDataserviceCentral(ctx context.Context, url string, req interface{}, resp interface{}) (err error) {
	defer func() {
		recordHttpCounterMetric("dataservice-central-service", err)
	}()
	return postRequestToGlobal(ctx, "dataservice-central-service", url, req, resp)
}

func (g GetPlaygroundAccountResp) GetErrCode() int {
	return g.Code
}

func (g GetPlaygroundAccountResp) GetErrMsg() string {
	return g.Message
}

type GetPlaygroundAccountResp struct {
	Code             int       `json:"code"`
	Message          string    `json:"message"`
	Host             string    `json:"host"`
	Port             int       `json:"port"`
	Token            string    `json:"token"`
	ServerlessUser   string    `json:"serverless_user"`
	ServerlessPasswd string    `json:"serverless_passwd"`
	CreateAt         time.Time `json:"create_at"`
	ClusterId        uint64    `json:"cluster_id"`
	IsDedicate       bool      `json:"is_dedicate"`
}