package consumer

import (
	"context"
	"encoding/json"
	"errors"
	"fmt"
	"fusenapi/constants"
	"fusenapi/initalize"
	"fusenapi/server/render/internal/svc"
	"fusenapi/utils/curl"
	"fusenapi/utils/file"
	"fusenapi/utils/hash"
	"fusenapi/utils/websocket_data"
	"github.com/zeromicro/go-zero/core/logx"
	"gorm.io/gorm"
	"io/ioutil"
	"strconv"
	"strings"
)

// 这里请求的py接口返回数据
type pythonApiRsp struct {
	Id      string `json:"id"`       //物料模板的id
	LogoUrl string `json:"logo_url"` //logo地址
	result  string `json:"result"`   //图片base64
}

// 消费渲染需要组装的数据
type MqConsumerRenderAssemble struct {
}

func (m *MqConsumerRenderAssemble) Run(ctx context.Context, data []byte) error {
	logx.Info("收到需要组装的消息:", string(data))
	var parseInfo websocket_data.AssembleRenderData
	if err := json.Unmarshal(data, &parseInfo); err != nil {
		logx.Error("MqConsumerRenderAssemble数据格式错误:", err)
		return nil //不返回错误就删除消息
	}
	val := ctx.Value("svcctx")
	if val == nil {
		return errors.New("svcctx is nil")
	}
	svcCtx, ok := val.(*svc.ServiceContext)
	if !ok {
		return errors.New("svcctx is nil!!")
	}
	rabbitmq := initalize.RabbitMqHandle{}
	//获取模板（产品第一个sku的模板）
	templateInfo, err := svcCtx.AllModels.FsProductTemplateV2.FindOneByProductIdTagIdWithSizeTable(ctx, parseInfo.RenderData.ProductId, fmt.Sprintf("%d", parseInfo.RenderData.TemplateTagId))
	if err != nil {
		if errors.Is(err, gorm.ErrRecordNotFound) {
			logx.Error("template info is not found")
			return nil
		}
		logx.Error("failed to get template info:", err)
		return err
	}
	combineImage := ""                         //刀版图
	combineHash := hash.JsonHashKey(parseInfo) //区别于云渲染的taskid,这个用获取刀版图缓存
	//获取该hash值下有没有对应的资源
	resource, err := svcCtx.AllModels.FsResource.FindOneById(ctx, combineHash)
	if err != nil && !errors.Is(err, gorm.ErrRecordNotFound) {
		logx.Error("failed to get resource :", err)
		return err
	}
	//如果不存在,则请求生成刀版图
	if errors.Is(err, gorm.ErrRecordNotFound) {
		combineImage, err = getCombineImage(ctx, svcCtx, parseInfo, combineHash)
		if err != nil {
			return err
		}
	} else {
		combineImage = *resource.ResourceUrl
	}
	//获取渲染设置信息
	element, err := svcCtx.AllModels.FsProductTemplateElement.FindOneByModelId(ctx, *templateInfo.ModelId)
	if err != nil {
		if errors.Is(err, gorm.ErrRecordNotFound) {
			logx.Error("element info is not found,model_id = ?", *templateInfo.ModelId)
			return nil
		}
		logx.Error("failed to get element list,", err)
		return err
	}
	//组装数据
	refletion := -1
	if element.Refletion != nil && *element.Refletion != "" {
		refletion, err = strconv.Atoi(*element.Refletion)
	}
	//组装data数据
	var mode map[string]interface{}
	if element.Mode != nil && *element.Mode != "" {
		if err = json.Unmarshal([]byte(*element.Mode), &mode); err != nil {
			logx.Error("faile to parse element mode json:", err)
			return err
		}
	}
	tempData := make([]map[string]interface{}, 0, 3)
	if element.Base != nil && *element.Base != "" {
		tempData = append(tempData, map[string]interface{}{
			"name":      "model",
			"data":      "0," + combineImage + "," + *element.Base,
			"type":      "other",
			"layer":     "0",
			"is_update": 1,
			"mode":      mode["model"],
		})
	}
	if element.Shadow != nil && *element.Shadow != "" {
		tempData = append(tempData, map[string]interface{}{
			"name":      "shadow",
			"data":      *element.Shadow,
			"type":      "other",
			"layer":     "0",
			"is_update": 0,
			"mode":      mode["shadow"],
		})
	}
	if element.ModelP != nil && *element.ModelP != "" {
		tempData = append(tempData, map[string]interface{}{
			"name":      "model_P",
			"data":      "0," + *element.ModelP,
			"type":      "other",
			"layer":     "0",
			"is_update": 0,
			"mode":      mode["model_P"],
		})
	}
	result := []interface{}{
		map[string]interface{}{
			"light":     *element.Light,
			"refletion": refletion,
			"scale":     *element.Scale,
			"sku_id":    *templateInfo.ProductId,
			"tid":       *element.Title,
			"rotation":  *element.Rotation,
			"filePath":  "", //todo 文件路径,针对千人千面
			"data":      tempData,
		},
	}
	sendData := map[string]interface{}{
		"id":               parseInfo.TaskId,
		"order_id":         0,
		"user_id":          parseInfo.RenderData.UserId,
		"guest_id":         parseInfo.RenderData.GuestId,
		"sku_ids":          []int64{parseInfo.RenderData.ProductId},
		"tids":             []string{*element.Title},
		"data":             result,
		"is_thousand_face": 0,
		"folder":           "", //todo 千人千面需要使用
	}
	b, _ := json.Marshal(sendData)
	if err = rabbitmq.SendMsg(constants.RABBIT_MQ_TO_UNITY, b); err != nil {
		logx.Error("发送渲染组装数据到rabbitmq失败：", err)
		return err
	}
	logx.Info("发送渲染组装数据到unity成功")
	return nil
}

// 获取刀版图
func getCombineImage(ctx context.Context, svcCtx *svc.ServiceContext, parseInfo websocket_data.AssembleRenderData, combineHash string) (image string, err error) {
	// todo 获取sku对应用来合成刀版图的json数据

	url := "http://192.168.1.7:45678/LogoCombine"
	header := make(map[string]string)
	header["content-type"] = "application/json"
	postData := "" // todo 请求数据要查出来
	httpRsp, err := curl.ApiCall(url, "POST", header, strings.NewReader(postData), 20)
	if err != nil {
		logx.Error("failed to combine logo:", err)
		return "", err
	}
	defer httpRsp.Body.Close()
	bytes, err := ioutil.ReadAll(httpRsp.Body)
	if err != nil {
		logx.Error("failed to read python api rsp body:", err)
		return "", err
	}
	var pythonApiInfo pythonApiRsp
	if err = json.Unmarshal(bytes, &pythonApiInfo); err != nil {
		logx.Error("failed to parse python api rsp:", err)
		return "", err
	}
	//上传刀版图
	var upload = file.Upload{
		Ctx:        ctx,
		MysqlConn:  svcCtx.MysqlConn,
		AwsSession: svcCtx.AwsSession,
	}
	uploadRes, err := upload.UploadFileByBase64(&file.UploadBaseReq{
		FileHash:     combineHash,
		FileData:     pythonApiInfo.result,
		UploadBucket: 1,
		ApiType:      2,
		UserId:       parseInfo.RenderData.UserId,
		GuestId:      parseInfo.RenderData.GuestId,
	})
	if err != nil {
		logx.Error("上传刀版图到s3失败:", err)
		return "", err
	}
	return uploadRes.ResourceUrl, nil
}