package cast

import (
	"context"
	"errors"
	"fmt"
	"fonchain-fiee/api/accountFiee"
	"fonchain-fiee/api/bundle"
	"fonchain-fiee/api/cast"
	"fonchain-fiee/cmd/config"
	"fonchain-fiee/pkg/e"
	logicCast "fonchain-fiee/pkg/logic/cast"
	modelCast "fonchain-fiee/pkg/model/cast"
	"fonchain-fiee/pkg/service"
	"fonchain-fiee/pkg/utils/stime"
	"strconv"
	"time"

	"github.com/gin-gonic/gin"
	"go.uber.org/zap"
)

func UpdateWorkImage(ctx *gin.Context) {
	var req *cast.UpdateWorkImageReq
	var infoResp *accountFiee.UserInfoResponse
	var err error
	if err = ctx.ShouldBind(&req); err != nil {
		service.Error(ctx, err)
		return
	}
	if config.AppConfig.System.AppMode != "dev" {
		artistId, _ := strconv.ParseUint(req.ArtistUuid, 10, 64)
		infoResp, err = service.AccountFieeProvider.Info(context.Background(), &accountFiee.InfoRequest{
			ID:     artistId,
			Domain: "app",
		})
		zap.L().Info("UpdateWorkImage infoResp", zap.Any("infoResp", infoResp))
		if err != nil {
			service.Error(ctx, err)
			return
		}
	} else {
		infoResp = &accountFiee.UserInfoResponse{
			Name:        "小波",
			TelNum:      "18288888888",
			TelAreaCode: "86",
		}
	}
	req.ArtistName = infoResp.Name
	req.ArtistPhone = infoResp.TelNum
	req.ArtistPhoneAreaCode = infoResp.TelAreaCode
	artistID, _ := strconv.ParseUint(req.ArtistUuid, 10, 64)
	if err = CheckUserBundleBalance(int32(artistID), modelCast.BalanceTypeImageValue); err != nil {
		service.Error(ctx, err)
		return
	}
	newCtx := NewCtxWithUserInfo(ctx)
	req.Source = 1
	resp, err := service.CastProvider.UpdateWorkImage(newCtx, req)
	zap.L().Info("UpdateWorkImage resp", zap.Any("resp", resp))
	if err != nil {
		service.Error(ctx, err)
		return
	}
	service.Success(ctx, resp)
	return
}

func UpdateWorkVideo(ctx *gin.Context) {
	var req *cast.UpdateWorkVideoReq
	var infoResp *accountFiee.UserInfoResponse
	var err error
	if err = ctx.ShouldBind(&req); err != nil {
		service.Error(ctx, err)
		return
	}
	if config.AppConfig.System.AppMode != "dev" {
		artistId, _ := strconv.ParseUint(req.ArtistUuid, 10, 64)
		infoResp, err = service.AccountFieeProvider.Info(context.Background(), &accountFiee.InfoRequest{
			ID:     artistId,
			Domain: "app",
		})
		zap.L().Info("UpdateWorkVideo", zap.Any("infoResp", infoResp))
		if err != nil {
			service.Error(ctx, err)
			return
		}
	} else {
		infoResp = &accountFiee.UserInfoResponse{
			Name:        "小波",
			TelNum:      "18288888888",
			TelAreaCode: "86",
		}
	}
	artistID, _ := strconv.ParseUint(req.ArtistUuid, 10, 64)
	if err = CheckUserBundleBalance(int32(artistID), modelCast.BalanceTypeVideoValue); err != nil {
		service.Error(ctx, err)
		return
	}
	req.ArtistName = infoResp.Name
	req.ArtistPhone = infoResp.TelNum
	req.ArtistPhoneAreaCode = infoResp.TelAreaCode
	newCtx := NewCtxWithUserInfo(ctx)
	req.Source = 1
	resp, err := service.CastProvider.UpdateWorkVideo(newCtx, req)
	zap.L().Info("UpdateWorkVideo", zap.Any("resp", resp))
	if err != nil {
		service.Error(ctx, err)
		return
	}
	service.Success(ctx, resp)
	return
}

func UpdateApproval(ctx *gin.Context) {
	var req *cast.UpdateStatusReq
	var err error
	if err = ctx.ShouldBind(&req); err != nil {
		service.Error(ctx, err)
		return
	}
	req.WorkAction = cast.WorkActionENUM_APPROVAL
	newCtx := NewCtxWithUserInfo(ctx)
	resp, err := service.CastProvider.UpdateStatus(newCtx, req)
	if err != nil {
		service.Error(ctx, err)
		return
	}
	service.Success(ctx, resp)
	return
}

func WorkList(ctx *gin.Context) {
	var (
		req  *cast.WorkListReq
		resp *cast.WorkListResp
	)
	var err error
	if err = ctx.ShouldBind(&req); err != nil {
		service.Error(ctx, err)
		return
	}
	newCtx := NewCtxWithUserInfo(ctx)
	resp, err = service.CastProvider.WorkList(newCtx, req)
	if err != nil {
		service.Error(ctx, err)
		return
	}
	if len(resp.Data) > 0 {
		var workUuidApprovalIDMap = make(map[int]string)
		for _, v := range resp.Data {
			if v.WorkStatus == 2 && v.ApprovalID != "" {
				approvalID, _ := strconv.ParseUint(v.ApprovalID, 10, 64)
				workUuidApprovalIDMap[int(approvalID)] = v.WorkUuid
			}
			statusUpdateDate, _ := stime.DatetimeToTimes(v.StatusUpdateTime, "2006-01-02 15:04:05")
			if v.WorkStatus == 6 && (time.Now().Unix()-int64(statusUpdateDate) < 300) {
				go func() {
					_, _ = service.CastProvider.PublishMediaInfo(context.Background(), &cast.PublishMediaInfoReq{
						WorkUuid: v.WorkUuid,
					})
				}()
			}
		}
		if len(workUuidApprovalIDMap) > 0 {
			_ = RefreshWorkApprovalStatus(ctx, workUuidApprovalIDMap)
		}
	}
	service.Success(ctx, resp)
	return
}

func WorkDetail(ctx *gin.Context) {
	var (
		req  *cast.WorkDetailReq
		resp *cast.WorkDetailResp
	)
	var err error
	if err = ctx.ShouldBind(&req); err != nil {
		service.Error(ctx, err)
		return
	}
	newCtx := NewCtxWithUserInfo(ctx)
	resp, err = service.CastProvider.WorkDetail(newCtx, req)
	if err != nil {
		service.Error(ctx, err)
		return
	}
	service.Success(ctx, resp)
	return
}

func CheckUserBundleBalance(userID int32, balanceType modelCast.BalanceTypeEnum) (err error) {
	zap.L().Info("CheckUserBundleBalance", zap.Any("userID", userID))
	resp, err := service.BundleProvider.GetBundleBalanceByUserId(context.Background(), &bundle.GetBundleBalanceByUserIdReq{UserId: userID})
	if err != nil {
		zap.L().Error("CheckUserBundleBalance", zap.Any("err", err))
		return
	}
	zap.L().Info("CheckUserBundleBalance", zap.Any("resp", resp))
	fmt.Println("CheckUserBundleBalance resp", resp)
	switch balanceType {
	case modelCast.BalanceTypeAccountValue:
		if resp.AccountNumber-resp.AccountConsumptionNumber <= 0 {
			err = errors.New(e.ErrorBalanceInsufficient)
			return
		}
	case modelCast.BalanceTypeImageValue:
		if resp.ImageNumber-resp.ImageConsumptionNumber <= 0 {
			err = errors.New(e.ErrorBalanceInsufficient)
			return
		}
	case modelCast.BalanceTypeVideoValue:
		if resp.VideoNumber-resp.VideoConsumptionNumber <= 0 {
			err = errors.New(e.ErrorBalanceInsufficient)
			return
		}
	}
	return
}

func Publish(ctx *gin.Context) {
	var (
		req  *cast.PublishReq
		resp *cast.PublishResp
		//workInfoResp *cast.WorkInfoResp
	)
	var err error
	if err = ctx.ShouldBind(&req); err != nil {
		service.Error(ctx, err)
		return
	}
	newCtx := NewCtxWithUserInfo(ctx)
	resp, err = service.CastProvider.Publish(newCtx, req)
	if err != nil {
		service.Error(ctx, err)
		return
	}
	service.Success(ctx, resp)
	return
}

func RePublish(ctx *gin.Context) {
	var (
		req  *cast.RePublishReq
		resp *cast.RePublishResp
		//workInfoResp *cast.WorkInfoResp
	)
	var err error
	if err = ctx.ShouldBind(&req); err != nil {
		service.Error(ctx, err)
		return
	}
	newCtx := NewCtxWithUserInfo(ctx)
	/*	workInfoResp, err = service.CastProvider.WorkInfo(context.Background(), &cast.WorkInfoReq{
			WorkUuid: req.WorkUuid,
		})
		if err != nil {
			service.Error(ctx, err)
			return
		}
		fmt.Println(workInfoResp)*/
	/*artistID, _ := strconv.ParseInt(workInfoResp.ArtistUuid, 10, 64)
	if err = CheckUserBundleBalance(int32(artistID), modelCast.BalanceTypeVideoValue); err != nil {
		service.Error(ctx, err)
		return
	}
	balanceReq := &bundle.AddBundleBalanceReq{
		UserId: int32(artistID),
	}
	if workInfoResp.WorkCategory == 1 {
		balanceReq.ImageConsumptionNumber = 1
	}
	if workInfoResp.WorkCategory == 2 {
		balanceReq.VideoConsumptionNumber = 1
	}
	_, err = service.BundleProvider.AddBundleBalance(context.Background(), balanceReq)
	if err != nil {
		service.Error(ctx, err)
		return
	}*/
	resp, err = service.CastProvider.RePublish(newCtx, req)
	if err != nil {
		service.Error(ctx, err)
		return
	}
	service.Success(ctx, resp)
	return
}

// 修改余量我还需要调用吗
func UserBundleBalanceCost() {
	service.BundleProvider.AddBundleBalance(context.Background(), &bundle.AddBundleBalanceReq{})
}

func RefreshWorkApprovalStatus(ctx *gin.Context, approvalIDWorkUuidMap map[int]string) (err error) {
	var castS = new(CastService)
	var data = make(map[int]modelCast.Item)
	var approvalIDs []int
	for approvalId, _ := range approvalIDWorkUuidMap {
		approvalIDs = append(approvalIDs, approvalId)
	}
	if len(approvalIDs) == 0 {
		return
	}
	data, err = castS.ApprovalDetail(approvalIDs)
	// status: 1待审批 2审批通过 3审批不通过 6撤销发其中 7撤销完成
	var newData = make(map[int]modelCast.Item, len(approvalIDs))
	for _, v := range approvalIDs {
		newData[v] = data[v]
	}
	newCtx := NewCtxWithUserInfo(ctx)
	if len(newData) > 0 {
		for approvalId, v := range newData {
			if v.ID == 0 {
				_, _ = service.CastProvider.UpdateStatus(newCtx, &cast.UpdateStatusReq{
					WorkAction:    cast.WorkActionENUM_APPROVAL_DELETE,
					WorkUuid:      approvalIDWorkUuidMap[approvalId],
					ApprovalID:    fmt.Sprint(approvalId),
					ApprovalReply: "",
				})
				continue
			}
			var workAction cast.WorkActionENUM
			if v.Status == 2 {
				workAction = cast.WorkActionENUM_APPROVAL_PASS
			} else if v.Status == 3 {
				workAction = cast.WorkActionENUM_APPROVAL_REJECT
			} else {
				continue
			}
			_, _ = service.CastProvider.UpdateStatus(newCtx, &cast.UpdateStatusReq{
				WorkAction:    workAction,
				WorkUuid:      approvalIDWorkUuidMap[approvalId],
				ApprovalID:    fmt.Sprint(approvalId),
				ApprovalReply: v.Reply,
			})
		}
	}
	return
}

func DelWork(ctx *gin.Context) {
	var req *cast.DelWorkReq
	var err error
	if err = ctx.ShouldBind(&req); err != nil {
		service.Error(ctx, err)
		return
	}
	newCtx := NewCtxWithUserInfo(ctx)
	_, err = service.CastProvider.DelWork(newCtx, req)
	if err != nil {
		service.Error(ctx, err)
		return
	}
	service.Success(ctx, nil)
	return
}

func Remind(ctx *gin.Context) {
	var req *cast.WorkInfoReq
	var err error
	var workInfo *cast.WorkInfoResp
	if err = ctx.ShouldBind(&req); err != nil {
		service.Error(ctx, err)
		return
	}
	workInfo, err = service.CastProvider.WorkInfo(context.Background(), req)
	if err != nil {
		service.Error(ctx, err)
		return
	}
	if workInfo.WorkStatus != modelCast.WorkStatusArtistConfirming {
		service.Error(ctx, errors.New(e.InvalidStatus))
		return
	}
	if workInfo.ArtistPhoneAreaCode == "" {
		workInfo.ArtistPhoneAreaCode = "86"
	}
	artistID, _ := strconv.ParseUint(workInfo.ArtistUuid, 10, 64)
	infoResp, err := service.AccountFieeProvider.Info(context.Background(), &accountFiee.InfoRequest{
		ID:     artistID,
		Domain: "app",
	})
	if err != nil {
		service.Error(ctx, err)
		return
	}
	if workInfo.ArtistPhoneAreaCode == "86" {
		_, err = service.AccountFieeProvider.OnlySendMsg(context.Background(), &accountFiee.SendMsgRequest{
			Domain:   "app",
			TelNum:   infoResp.TelNum,
			Project:  "fiee",
			SignNo:   0,
			MId:      277385,
			Scope:    "",
			Zone:     infoResp.TelAreaCode,
			NonceStr: "",
		})
	} else {
		_, err = service.AccountFieeProvider.SendNationTemplateMsg(context.Background(), &accountFiee.SendNationMsgRequest{
			Domain:  "app",
			TelNum:  fmt.Sprintf("%s%s", infoResp.TelAreaCode, infoResp.TelNum),
			Project: "fiee",
			SignNo:  0,
			MId:     108375,
			Scope:   "",
		})
	}
	if err != nil {
		service.Error(ctx, err)
		return
	}
	service.Success(ctx, nil)
	return
}

func PublishInfo(ctx *gin.Context) {
	var req *cast.PublishMediaInfoReq
	var resp *cast.PublishMediaInfoResp
	var err error
	if err = ctx.ShouldBind(&req); err != nil {
		service.Error(ctx, err)
		return
	}
	resp, err = service.CastProvider.PublishMediaInfo(context.Background(), req)
	if err != nil {
		service.Error(ctx, err)
		return
	}
	service.Success(ctx, resp)
	return
}

func WorkListExport(ctx *gin.Context) {
	var (
		req  *cast.WorkListReq
		resp *cast.WorkListResp
	)
	var err error
	if err = ctx.ShouldBind(&req); err != nil {
		service.Error(ctx, err)
		return
	}
	newCtx := NewCtxWithUserInfo(ctx)
	resp, err = service.CastProvider.WorkList(newCtx, req)
	if err != nil {
		service.Error(ctx, err)
		return
	}
	var loigcCastWork = new(logicCast.Work)
	excelFile, err := loigcCastWork.ExportExcelWorkList(resp.Data)
	if err != nil {
		service.Error(ctx, err)
		return
	}
	fileName := fmt.Sprintf("作品列表_%s.xlsx", time.Now().Format("20060102"))
	ctx.Header("Content-Type", "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet")
	ctx.Header("Content-Disposition", "attachment; filename="+fileName)
	ctx.Header("File-Name", fileName)
	ctx.Header("Access-Control-Expose-Headers", "File-Name")
	_ = excelFile.Write(ctx.Writer)
}