package bus

import (
	"assetcenter/conf"
	"assetcenter/log"
	"crypto/sha256"
	"encoding/json"
	"errors"
	"fmt"
	"io"
	"net/http"
	"path"
	"strings"
)

type SortMilvusSearchSlice []*MlivusSearchRes

func (s SortMilvusSearchSlice) Len() int {
	return len(s)
}

func (s SortMilvusSearchSlice) Swap(i, j int) {
	s[i], s[j] = s[j], s[i]
}

func (s SortMilvusSearchSlice) Less(i, j int) bool {
	return s[i].Score < s[j].Score
}

func RemoveDuplicateMilvusSearch(slice []*MlivusSearchRes) []*MlivusSearchRes {
	keys := make(map[string]bool)
	list := make([]*MlivusSearchRes, 0)

	for _, entry := range slice {
		if _, value := keys[entry.ProductId]; !value {
			keys[entry.ProductId] = true
			list = append(list, entry)
		}
	}

	return list
}

type MlivusDeleteRes struct {
	Status bool   `json:"status"`
	Msg    string `json:"msg"`
}

func deleteImageToMlivus(tableName, product_id string) {
	im_hash := product_id

	req, err := http.NewRequest("POST", fmt.Sprintf("%s%s", conf.AppConfig.SearchImageAddr, "/delete/record"), nil)
	if err != nil {
		log.Error(err)
		return
	}
	q := req.URL.Query()
	q.Add("table_name", tableName)
	q.Add("im_hash", im_hash)
	req.URL.RawQuery = q.Encode()
	rep, err := http.DefaultClient.Do(req)
	if err != nil {
		log.Error(err)
		return
	}
	defer rep.Body.Close()
	res, _ := io.ReadAll(rep.Body)
	uploadRes := MlivusDeleteRes{}
	err = json.Unmarshal(res, &uploadRes)
	if err != nil {
		log.Error(err)
		return
	}

}

type MlivusSearchRes struct {
	ImHash    string  `json:"im_hash"`
	ProductId string  `json:"product_id"`
	Score     float64 `json:"score"`
}

func searchImageToMlivus(tableName, url string) ([]*MlivusSearchRes, error) {
	ext := strings.ToLower(path.Ext(url))
	if ext != ".jpg" && ext != ".png" && ext != ".jpeg" {
		return nil, errors.New("只支持jpg/png/jpeg图片")
	}
	req, err := http.NewRequest("POST", fmt.Sprintf("%s%s", conf.AppConfig.SearchImageAddr, "/img/search"), nil)
	if err != nil {
		log.Error(err)
		return nil, errors.New("上传文件请求配置失败")
	}
	q := req.URL.Query()
	q.Add("table_name", tableName)
	q.Add("url", url)
	req.URL.RawQuery = q.Encode()
	rep, err := http.DefaultClient.Do(req)
	if err != nil {
		log.Error(err)
		return nil, errors.New("处理图片失败")
	}
	defer rep.Body.Close()
	res, _ := io.ReadAll(rep.Body)
	uploadRes := []*MlivusSearchRes{}
	err = json.Unmarshal(res, &uploadRes)
	if err != nil {
		fmt.Println(err)
		return nil, err
	}
	return uploadRes, nil
}

type MlivusUploadRes struct {
	ImHash string `json:"id"`
}

func uploadImageToMlivus(tableName, productId, url string) {
	im_hash := productId
	// ext := strings.ToLower(path.Ext(url))
	// fmt.Println(ext)
	// if ext != ".jpg" && ext != ".png" && ext != ".jpeg" {
	// 	log.Error("只支持jpg/png/jpeg图片")
	// 	return
	// }
	req, err := http.NewRequest("POST", fmt.Sprintf("%s%s", conf.AppConfig.SearchImageAddr, "/img/upload"), nil)
	if err != nil {
		log.Error(err)
		return
	}
	q := req.URL.Query()
	q.Add("table_name", tableName)
	q.Add("product_id", productId)
	q.Add("im_hash", im_hash)
	q.Add("url", url)
	req.URL.RawQuery = q.Encode()
	rep, err := http.DefaultClient.Do(req)
	if err != nil {
		log.Error(err)
		return
	}
	defer rep.Body.Close()
	res, _ := io.ReadAll(rep.Body)
	uploadRes := MlivusUploadRes{}
	err = json.Unmarshal(res, &uploadRes)
	if err != nil {
		log.Error(err)
		return
	}

}

func getImageHash(url string) string {
	data := []byte(url)
	hasher := sha256.New()
	hasher.Write(data)
	hash := hasher.Sum(nil)

	return fmt.Sprintf("%x", hash)
}

// func getUserById(apictx *ApiSession, id primitive.ObjectID) (*model.UserSmaple, error) {
// 	user := &model.UserSmaple{}
// 	_, err := repo.RepoSeachDoc(apictx.CreateRepoCtx(), &repo.DocSearchOptions{
// 		Db:          "user",
// 		CollectName: repo.CollectionUsers,
// 		Query:       repo.Map{"_id": id},
// 		Project:     []string{"name", "avatar", "city", "loginName"},
// 	}, user)
// 	return user, err
// }