package consumer

import (
	"bytes"
	"context"
	"encoding/json"
	"errors"
	"fmt"
	"fusenapi/constants"
	"fusenapi/initalize"
	"fusenapi/model/gmodel"
	"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"
	"os"
	"strconv"
	"time"
)

// 这里请求的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 {
	defer func() {
		if err := recover(); err != nil {
			logx.Error("MqConsumerRenderAssemble panic:", err)
		}
	}()
	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 {
		logx.Error("svcctx is nil")
		return nil //不返回错误就删除消息
	}
	svcCtx, ok := val.(*svc.ServiceContext)
	if !ok {
		logx.Error("svcctx is nil!!")
		return nil //不返回错误就删除消息
	}
	rabbitmq := initalize.RabbitMqHandle{}
	//获取模板（产品第一个sku的模板）
	productTemplate, 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 nil //不返回错误就删除消息
	}
	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 nil //不返回错误就删除消息
	}
	//如果不存在,则请求生成刀版图
	if errors.Is(err, gorm.ErrRecordNotFound) {
		combineImage, err = getCombineImage(ctx, svcCtx, parseInfo, productTemplate, combineHash)
		if err != nil {
			return nil //不返回错误就删除消息
		}
	} else {
		combineImage = *resource.ResourceUrl
	}
	//获取渲染设置信息
	element, err := svcCtx.AllModels.FsProductTemplateElement.FindOneByModelId(ctx, *productTemplate.ModelId)
	if err != nil {
		if errors.Is(err, gorm.ErrRecordNotFound) {
			logx.Error("element info is not found,model_id = ?", *productTemplate.ModelId)
			return nil //不返回错误就删除消息
		}
		logx.Error("failed to get element list,", err)
		return nil //不返回错误就删除消息
	}
	//组装数据
	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 nil //不返回错误就删除消息
		}
	}
	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":    parseInfo.RenderData.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 nil //不返回错误就删除消息
	}
	logx.Info("发送渲染组装数据到unity成功")
	return nil
}

// 获取刀版图
func getCombineImage(ctx context.Context, svcCtx *svc.ServiceContext, parseInfo websocket_data.AssembleRenderData, productTemplate *gmodel.FsProductTemplateV2, combineHash string) (image string, err error) {
	if productTemplate.TemplateInfo == nil || *productTemplate.TemplateInfo == "" {
		logx.Error("product template info`template_info is empty")
		return "", errors.New("product template info`template_info is empty")
	}
	//反序列化替换其中一些参数
	var moduleInfo interface{}
	if err = json.Unmarshal([]byte(*productTemplate.TemplateInfo), &moduleInfo); err != nil {
		logx.Error("failed to parse json:template_info:", err)
		return "", err
	}
	//需要替换的参数
	paramData := map[string]interface{}{
		"logo_url":       parseInfo.RenderData.Logo,
		"website":        parseInfo.RenderData.Website,
		"slogan":         parseInfo.RenderData.Slogan,
		"address":        parseInfo.RenderData.Address,
		"phone":          parseInfo.RenderData.Phone,
		"colors":         []string{},
		"template_tagid": []string{"b1a"},
		"is_crop":        false,
		"shape":          "",
		"ratio":          0,
		"line":           "",
		"other":          "",
		"other1":         "",
	}
	//获取用户素材信息
	if parseInfo.RenderData.UserMaterialId > 0 {
		userMaterial, err := svcCtx.AllModels.FsUserMaterial.FindOneById(ctx, parseInfo.RenderData.UserMaterialId)
		if err != nil {
			if errors.Is(err, gorm.ErrRecordNotFound) {
				logx.Error("user material not exists:", parseInfo.RenderData.UserMaterialId)
				return "", errors.New("user material not exists")
			}
			logx.Error("err failed to get user material info")
		}
		if userMaterial.Metadata != nil && *userMaterial.Metadata != "" {
			//解析元数据
			var materialMetaData map[string]interface{}
			if err = json.Unmarshal([]byte(*userMaterial.Metadata), &materialMetaData); err != nil {
				logx.Error("failed to parse user material`matadata: ", err)
				return "", err
			}
			//赋值
			paramData["colors"] = materialMetaData["colors"]
			paramData["logo_url"] = materialMetaData["logo_url"]
			paramData["shape"] = materialMetaData["shape"]
			paramData["is_crop"] = materialMetaData["is_crop"]
			paramData["ratio"] = materialMetaData["ratio"]
			paramData["line"] = materialMetaData["line"]
			paramData["other"] = materialMetaData["other"]
			paramData["other1"] = materialMetaData["other1"]
		}
	}
	combineInfo := map[string]interface{}{
		"module_data": moduleInfo,
		"param_data":  paramData,
	}
	postData, _ := json.Marshal(combineInfo)
	//请求合成图片
	url := svcCtx.Config.PythonApi.CombineImageUrl
	header := make(map[string]string)
	header["content-type"] = "application/json"
	/*	f, _ := os.Create("a.txt")
		defer f.Close()
		f.Write(postData)*/
	httpRsp, err := curl.ApiCall(url, "POST", header, bytes.NewReader(postData), time.Second*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
	}
	logx.Info("发送渲染组装数据到unity成功")
	return uploadRes.ResourceUrl, nil
}