package mailArtwork

import (
	"context"
	"errors"
	"fmt"
	"github.com/fonchain_enterprise/fonchain-main/api/account"
	"github.com/fonchain_enterprise/fonchain-main/api/artist"
	"github.com/fonchain_enterprise/fonchain-main/api/artistInfoArtwork"
	"github.com/fonchain_enterprise/fonchain-main/api/artistInfoUser"
	"github.com/fonchain_enterprise/fonchain-main/api/artwork"
	"github.com/fonchain_enterprise/fonchain-main/api/mailArtwork"
	"github.com/fonchain_enterprise/fonchain-main/pkg/common"
	"github.com/fonchain_enterprise/fonchain-main/pkg/config"
	"github.com/fonchain_enterprise/fonchain-main/pkg/e"
	"github.com/fonchain_enterprise/fonchain-main/pkg/service"
	"github.com/fonchain_enterprise/fonchain-main/pkg/service/artistInfo/asPush"
	"github.com/fonchain_enterprise/fonchain-main/pkg/service/artistInfo/asUtil"
	"github.com/fonchain_enterprise/utils/utils"
	"github.com/getsentry/sentry-go"
	"github.com/gin-gonic/gin"
	"golang.org/x/sync/errgroup"
	"net/url"
	"strings"
	"time"
)

// 创建MailArtwork
func (a *MailArtworkHandler) CreateMailArtwork(c *gin.Context) {
	var req mailArtwork.MailArtworkData
	if err := c.ShouldBindJSON(&req); err != nil {
		service.Error(c, e.InvalidParams, err, "无效参数")
		return
	}
	_, err := service.GrpcMailArtworkImpl.CreateMailArtwork(c, &req)
	if err != nil {
		service.Error(c, e.Failed, err)
		return
	}
	service.Success(c)
}

// 发起寄画
func (a *MailArtworkHandler) ConfirmMailArtwork(c *gin.Context) {
	var req mailArtwork.ConfirmMailArtworkRequest
	if err := c.ShouldBindJSON(&req); err != nil {
		service.Error(c, e.InvalidParams, err, "无效参数")
		return
	}
	if len([]rune(req.Remark)) > 200 {
		service.Error(c, e.InvalidParams, nil, "备注内容过长，请限制在200字以内！")
		return
	}
	// 如果画家为空，则按照画家吧画作进行分组，依次请求
	var artistRelArtworkUid = make(map[string][]string)
	if req.ArtistUid == "" {
		artworkRecords, err := service.GrpcArtistInfoArtworkImpl.GetArtworkLockRecords(c, &artistInfoArtwork.GetArtworkLockRecordsRequest{
			Page:        1,
			PageSize:    int64(len(req.ArtworkUid)),
			ArtworkUids: req.ArtworkUid,
		})
		if err != nil {
			service.ErrorWithMark(c, e.Failed, err, "查询失败")
			return
		}
		for _, v := range artworkRecords.Data {
			v := v
			artistRelArtworkUid[v.ArtistUid] = append(artistRelArtworkUid[v.ArtistUid], v.ArtworkUid)
		}
	} else {
		artistRelArtworkUid[req.ArtistUid] = append(artistRelArtworkUid[req.ArtistUid], req.ArtworkUid...)
	}
	//用来等待短信全部发送完并获取错误信息
	group, _ := errgroup.WithContext(context.Background())
	for artistUid, artworkUidList := range artistRelArtworkUid {
		artistUid := artistUid
		artworkUidList := artworkUidList
		var protoReq = mailArtwork.ConfirmMailArtworkRequest{
			ArtistUid:    artistUid,
			ArtworkUid:   artworkUidList,
			CourierType:  req.CourierType,
			ReturnReason: req.ReturnReason,
			TrackingNo:   req.TrackingNo,
			Remark:       req.Remark,
		}
		resp, err := service.GrpcMailArtworkImpl.ConfirmMailArtwork(c, &protoReq)
		if err != nil {
			service.Error(c, e.Failed, err)
			return
		}
		var returnArtworkEditAddress string
		if req.CourierType == 2 {
			group.Go(func() error {
				//发短信
				params := url.Values{}
				params.Set("groupId", resp.ReturnArtwork[0].GroupId)
				returnArtworkEditAddress = config.MailArtwork.EditReturnArtworkUrl + "?" + params.Encode()
				fmt.Println("returnArtworkEditAddress:", returnArtworkEditAddress)
				returnArtworkEditAddress, err = utils.CreateShortUrl(returnArtworkEditAddress)
				if err != nil {
					fmt.Println("CreateShortUrl err", err)
					sentry.WithScope(func(scope *sentry.Scope) {
						scope.SetLevel(sentry.LevelError)
						scope.SetExtra("returnArtworkEditAddress", returnArtworkEditAddress)
						scope.SetExtra("err", err.Error())
						sentry.CaptureMessage("退画管理短网址生成失败")
					})
					return fmt.Errorf("%s:通知短信生成失败(处理进度:20)", a.GetArtistInfo(artistUid))
				}
				userRes := &artistInfoUser.GetUserListResp{}
				userRes, err = service.GrpcArtistInfoUserImpl.GetUserList(c, &artistInfoUser.GetUserListRequest{
					Query:    &artistInfoUser.UserData{MgmtArtistUid: artistUid},
					Page:     1,
					PageSize: 1,
				})
				if err != nil {
					return fmt.Errorf("%s:通知短信生成失败(处理进度:40)", a.GetArtistInfo(artistUid))
				}
				if userRes.Total == 0 {
					return fmt.Errorf("%s:通知短信生成失败(处理进度:60)", a.GetArtistInfo(artistUid))
				}
				endpoint := strings.Replace(returnArtworkEditAddress, "https://dwz.cn/", "", -1)
				_, err = service.AccountProvider.SendCustomMsg(c, &account.SendCustomMsgRequest{
					ID:      uint64(userRes.List[0].MgmtAccId),
					TelNum:  userRes.List[0].TelNum,
					Url:     endpoint,
					MId:     203886,
					SigNo:   155120,
					Domain:  config.Domain,
					Project: "artistinfo",
				})
				if err != nil {
					return fmt.Errorf("%s:通知短信发送失败(%s)", a.GetArtistInfo(artistUid), err.Error())
				}
				return nil
			})
		}
	}
	if req.CourierType == 2 && req.TrackingNo != "" {
		err := group.Wait()
		if err != nil {
			service.Error(c, e.Failed, err)
			return
		}
		//如果发起退画，需要同步到画作系统
		for _, artworkUid := range req.ArtworkUid {
			errs := SyncToOutStorageOfArtworkSystem(artworkUid, req.TrackingNo, req.ReturnReason, c.GetHeader(e.Authorization))
			if errs != nil {
				service.Error(c, e.Failed, errs, errs.Error())
				return
			}
			time.Sleep(200 * time.Millisecond)
		}
	}
	//发起app通知
	go func() {
		for artistUid, _ := range artistRelArtworkUid {
			fmt.Println("artistUid：", artistUid)
			userRes, errs := service.GrpcArtistInfoUserImpl.GetUserList(c, &artistInfoUser.GetUserListRequest{
				Query: &artistInfoUser.UserData{MgmtArtistUid: artistUid},
				Page:  1, PageSize: 1,
			})
			if errs != nil {
				fmt.Println("发送app通知失败，查询画家用户失败", errs.Error())
			}
			if userRes.Total == 0 {
				fmt.Println("发送app通知失败，查询画家用户为空")
			}
			fmt.Println("userRes.List[0].ID", userRes.List[0].ID)
			switch req.CourierType {
			case 1:
				_ = asPush.NewPusher().ArtworkWaitToBeMailedNotice(userRes.List[0].ID)
			// 填写快递单号，变成已寄出时再发送通知
			case 2:
				if req.TrackingNo != "" {
					_ = asPush.NewPusher().ArtworkWaitToBeReceivedNotice(userRes.List[0].ID)
				}
			}
		}
	}()
	service.Success(c)
}
func (a *MailArtworkHandler) GetArtistInfo(artistUid string) string {
	artistProfile, err := service.GrpcArtistImpl.GetArtistProfileList(context.Background(), &artist.GetArtistProfileListRequest{
		Query:    &artist.ArtistProfileData{Uid: artistUid},
		Page:     1,
		PageSize: 1,
	})
	if err != nil {
		return ""
	}
	if artistProfile.Total == 0 {
		return ""
	}
	return fmt.Sprintf("%s[%s]", artistProfile.List[0].Name, artistProfile.List[0].Tnum)

}

// 删除MailArtwork
func (a *MailArtworkHandler) DeleteMailArtwork(c *gin.Context) {
	var req mailArtwork.DeleteMailArtworkRequest
	if err := c.ShouldBindJSON(&req); err != nil {
		service.Error(c, e.InvalidParams, err, "无效参数")
		return
	}
	_, err := service.GrpcMailArtworkImpl.DeleteMailArtwork(c, &req)
	if err != nil {
		service.Error(c, e.Failed, err)
		return
	}
	service.Success(c)
}

// 更新MailArtwork
func (a *MailArtworkHandler) UpdateMailArtwork(c *gin.Context) {
	var req mailArtwork.MailArtworkData
	if err := c.ShouldBindJSON(&req); err != nil {
		service.Error(c, e.InvalidParams, err, "无效参数")
		return
	}
	_, err := service.GrpcMailArtworkImpl.UpdateMailArtwork(c, &req)
	if err != nil {
		service.Error(c, e.Failed, err)
		return
	}
	service.Success(c)
}

// 使用id查询MailArtwork
func (a *MailArtworkHandler) GetMailArtworkDetail(c *gin.Context) {
	var req mailArtwork.GetMailArtworkByIdRequest
	if err := c.ShouldBindJSON(&req); err != nil {
		service.Error(c, e.InvalidParams, err, "无效参数")
		return
	}
	resp, err := service.GrpcMailArtworkImpl.GetMailArtworkDetail(c, &req)
	if err != nil {
		service.Error(c, e.Failed, err)
		return
	}
	service.Success(c, resp)
}

// 批量查询MailArtwork
func (a *MailArtworkHandler) GetMailArtworkList(c *gin.Context) {
	var req GetMailArtworkListRequest
	if err := c.ShouldBindJSON(&req); err != nil {
		service.Error(c, e.InvalidParams, err, "无效参数")
		return
	}
	var protoReq = mailArtwork.GetMailArtworkListRequest{Query: &mailArtwork.MailArtworkData{}}
	asUtil.RequestDataConvert(&req, &protoReq)
	resp, err := service.GrpcMailArtworkImpl.GetMailArtworkList(c, &protoReq)
	if err != nil {
		service.Error(c, e.Failed, err)
		return
	}
	service.ResponseList(c, resp.List, service.OptionPage(resp.Page, resp.PageSize, resp.Total), service.OptionMsg("查询成功"))
}

// 批量查询 ViewMailArtworkData 包含画作信息
func (a *MailArtworkHandler) GetViewMailArtworkDataList(c *gin.Context) {
	var req GetViewMailArtworkDataListRequest
	if err := c.ShouldBindJSON(&req); err != nil {
		service.Error(c, e.InvalidParams, err, "无效参数")
		return
	}
	if req.ArtistUid == "" {
		service.Error(c, e.InvalidParams, nil, "画家uid不能为空")
		return
	}
	var protoReq = mailArtwork.GetViewMailArtworkListRequest{Query: &mailArtwork.ViewMailArtworkData{}}
	asUtil.RequestDataConvert(&req, &protoReq)
	resp, err := service.GrpcMailArtworkImpl.GetViewMailArtworkList(c, &protoReq)
	if err != nil {
		service.Error(c, e.Failed, err)
		return
	}
	service.ResponseList(c, resp.List, service.OptionPage(resp.Page, resp.PageSize, resp.Total), service.OptionMsg("查询成功"))
}

func (a *MailArtworkHandler) CourierEdit(c *gin.Context) {
	var req mailArtwork.ArtworkBindCourierRequest
	if err := c.ShouldBindJSON(&req); err != nil {
		service.Error(c, e.InvalidParams, err, "无效参数")
		return
	}
	//绑定快递信息
	resp, err := service.GrpcMailArtworkImpl.ArtworkBindCourier(c, &req)
	if err != nil {
		service.Error(c, e.Failed, err)
		return
	}
	//将快递信息同步到画作系统的仓储页面
	switch req.CourierType {
	case 1:
		for _, artworkUid := range req.ArtworkUid {
			err = SyncToInStorageOfArtworkSystem(artworkUid, req.TrackingNo, c.GetHeader(e.Authorization))
			if err != nil {
				fmt.Println("同步失败", err.Error())
			}
		}
	case 2:
		var thisArtistUid string
		for _, artworkUid := range req.ArtworkUid {
			returnData, errs := service.GrpcMailArtworkImpl.GetReturnArtworkList(c, &mailArtwork.GetReturnArtworkListRequest{
				Query:    &mailArtwork.ReturnArtworkData{ArtworkUid: artworkUid},
				Page:     1,
				PageSize: 1,
				Order:    "id desc",
			})
			returnReason := ""
			if returnData != nil && len(returnData.List) > 0 {
				returnReason = returnData.List[0].ReturnReason
			}
			if errs == nil {
				errs = SyncToOutStorageOfArtworkSystem(artworkUid, req.TrackingNo, returnReason, c.GetHeader(e.Authorization))
				if errs != nil {
					fmt.Println("同步失败", errs.Error())
				}
			} else {
				fmt.Printf("画作:%s查询失败:%s\n", artworkUid, errs.Error())
			}
			if returnData != nil && len(returnData.List) > 0 {
				thisArtistUid = returnData.List[0].ArtistUid
			}
		}
		if thisArtistUid != "" {
			userRes, errs := service.GrpcArtistInfoUserImpl.GetUserList(c, &artistInfoUser.GetUserListRequest{
				Query: &artistInfoUser.UserData{MgmtArtistUid: thisArtistUid},
			})
			if errs == nil {
				_ = asPush.NewPusher().ArtworkWaitToBeReceivedNotice(userRes.List[0].ID)
			}
		}
	}

	//格式转换
	var newResp = MailDetail{}
	newResp.Convert(resp.Info, resp.History)
	service.Success(c, newResp)
}

func (a *MailArtworkHandler) CourierDetail(c *gin.Context) {
	var req mailArtwork.GetCourierInfoByIdRequest
	if err := c.ShouldBindJSON(&req); err != nil {
		service.Error(c, e.InvalidParams, err, "无效参数")
		return
	}
	if req.Id == 0 {
		service.Error(c, e.InvalidParams, errors.New("无效参数"))
		return
	}
	resp, err := service.GrpcMailArtworkImpl.GetCourierInfoDetail(c, &req)
	if err != nil {
		service.Error(c, e.Failed, err)
		return
	}
	//格式转换
	var newResp = MailDetail{}
	newResp.Convert(resp.Info, resp.History)
	service.Success(c, newResp)
}

func (a *MailArtworkHandler) GetCanSendMailArtworkList(c *gin.Context) {
	var req GetCanSendMailArtworkListRequest
	if err := c.ShouldBindJSON(&req); err != nil {
		service.Error(c, e.InvalidParams, err, "无效参数")
		return
	}
	var protoReq mailArtwork.GetCanSendMailArtworkListRequest
	asUtil.RequestDataConvert(&req, &protoReq)
	if protoReq.Query == nil || protoReq.Query.ArtistUid == "" {
		service.ResponseList(c, []struct{}{}, service.OptionPage(req.Page, req.PageSize, 0), service.OptionMsg("画家uid不能为空"))
		return
	}
	resp, err := service.GrpcMailArtworkImpl.GetCanSendMailArtworkList(c, &protoReq)
	if err != nil {
		service.Error(c, e.Failed, err)
		return
	}
	service.ResponseList(c, resp.Data, service.OptionPage(resp.Page, resp.PageSize, resp.Total), service.OptionMsg("查询成功"))
}

func (a *MailArtworkHandler) PutInStorage(c *gin.Context) {
	var req []PutInStorageRequest
	if err := c.ShouldBindJSON(&req); err != nil {
		service.Error(c, e.InvalidParams, err, "无效参数")
		return
	}
	var protoRequests []*artwork.UpdateStorageRequest
	for _, v := range req {
		var storageRequest = &artwork.UpdateStorageRequest{
			ArtworkUuid: v.ArtworkUuid,
			Type:        1,
			Detail:      v.Detail,
		}
		if err := storageRequest.Validate(); err != nil {
			err = common.SubstrError(err)
			service.ResponseQuickMsg(c, e.Failed, err.Error(), nil)
			return
		}
		protoRequests = append(protoRequests, storageRequest)
	}
	// 存储数据到画作系统
	var ctx = context.Background()
	for i := range protoRequests {
		var artworkDetailReq = &artwork.ArtworkDetailRequest{
			ArtworkUuid: protoRequests[i].ArtworkUuid,
			Type:        "1",
		}
		fmt.Println("service.GrpcArtworkImpl is nil", service.GrpcArtworkImpl == nil)
		awDetailInfo, err := service.GrpcArtworkImpl.ArtworkDetail(ctx, artworkDetailReq)
		if err != nil {
			service.ResponseQuickMsg(c, e.Failed, err.Error(), nil)
			return
		}
		var artistInfoReq artist.ArtistInfoRequest
		artistInfoReq.Uid = awDetailInfo.ProfileInfo.ArtistUuid
		artistInfo, err := service.GrpcArtistImpl.ArtistInfo(ctx, &artistInfoReq)
		if err != nil {
			service.ResponseQuickMsg(c, e.Failed, err.Error(), nil)
			return
		}
		protoRequests[i].ArtistData = &artwork.UpdateStorageRequest_ArtistInfo{}
		protoRequests[i].ArtistData.ArtistUuid = artistInfo.ProfileInfo.Uid
		protoRequests[i].ArtistData.Seqnum = artistInfo.ProfileInfo.Seqnum
		protoRequests[i].ArtistData.Tnum = artistInfo.ProfileInfo.Tnum
		protoRequests[i].ArtistData.Num = artistInfo.ProfileInfo.Num
		_, err = service.GrpcArtworkImpl.UpdateStorage(ctx, protoRequests[i])
		if err != nil {
			service.Error(c, e.Failed, err)
			sentry.WithScope(func(scope *sentry.Scope) {
				scope.SetLevel(sentry.LevelError)
				scope.SetExtra("err", fmt.Sprintf("%v", err))
				//scope.SetFingerprint([]string{"countList"})
				sentry.CaptureMessage("寄画-画作系统入库失败")
			})
			return
		}
		time.Sleep(200 * time.Millisecond)
	}
	//更新画家宝的入库状态
	{
		var updateStorageStatus = mailArtwork.PutInStorageRequest{ArtworkUid: []string{}}
		for _, v := range req {
			updateStorageStatus.ArtworkUid = append(updateStorageStatus.ArtworkUid, v.ArtworkUuid)
		}
		_, err := service.GrpcMailArtworkImpl.PutInStorage(c, &updateStorageStatus)
		if err != nil {
			service.ErrorWithMark(c, e.Failed, err, "UpdateStorage Err", err.Error())
			return
		}
	}
	service.Success(c)
}

func (a *MailArtworkHandler) ArtworkCourierGroup(c *gin.Context) {
	var req ArtworkCourierGroupRequest
	if err := c.ShouldBindJSON(&req); err != nil {
		service.Error(c, e.InvalidParams, err, "无效参数")
		return
	}
	var protoRequest = &mailArtwork.GetViewMailArtworkListRequest{
		Page:     1,
		PageSize: -1,
		Where:    fmt.Sprintf("artwork_uid in (%s)", "'"+strings.Join(req.ArtworkUid, "','")+"'"),
	}
	res, err := service.GrpcMailArtworkImpl.GetViewMailArtworkList(c, protoRequest)
	if err != nil {
		service.Error(c, e.Failed, err, "查询失败")
		return
	}
	service.ResponseList(c, res.List, service.OptionPage(res.Page, res.PageSize, res.Total))
}

func (a *MailArtworkHandler) ShortUrlTest(c *gin.Context) {
	var req ShortUrlTestRequest
	if err := c.ShouldBindJSON(&req); err != nil {
		service.Error(c, e.InvalidParams, err, "无效参数")
		return
	}
	returnArtworkEditAddress, err := utils.CreateShortUrl(req.Url)
	if err != nil {
		service.Error(c, e.Failed, err, err.Error())
		return
	}
	service.Success(c, map[string]string{
		"shortUrl": returnArtworkEditAddress,
	})
}