package asContract

import (
	"context"
	"dubbo.apache.org/dubbo-go/v3/common/logger"
	"fmt"
	"github.com/fonchain_enterprise/fonchain-main/api/artist"
	"github.com/fonchain_enterprise/fonchain-main/api/artistInfoArtwork"
	"github.com/fonchain_enterprise/fonchain-main/api/artistInfoContract"
	"github.com/fonchain_enterprise/fonchain-main/api/artistInfoUser"
	"github.com/fonchain_enterprise/fonchain-main/api/artwork_query"
	"github.com/fonchain_enterprise/fonchain-main/pkg/e"
	"github.com/fonchain_enterprise/fonchain-main/pkg/serializer"
	"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/fonchain-main/pkg/utils"
	"github.com/gin-gonic/gin"
	"github.com/jinzhu/copier"
	"go.uber.org/zap"
	"strings"
	"time"
)

func CreateContractMgmt(c *gin.Context) {
	var createContractRequest artistInfoContract.CreateContractRequest
	if err := c.ShouldBind(&createContractRequest); err != nil {
		logger.Errorf("putInRequest ShouldBind err", err)
		service.ResponseMsg(c, e.SUCCESS, serializer.Response{
			Data:   nil,
			Msg:    err.Error(),
			Status: e.Failed,
		})
		return
	}
	fmt.Println("1111111111111111111")
	rep, err := service.GrpcArtistInfoContracImpl.CreateContract(context.Background(), &createContractRequest)
	fmt.Println("1111111111111111111")
	fmt.Printf("err:%v\n", err)
	fmt.Println("rep", rep)
	if err != nil {
		fmt.Println("222222222222222222222")
		logger.Error("err1212121212", utils.If(err == nil, "", err.Error()))
		service.ResponseMsg(c, e.SUCCESS, serializer.Response{
			Msg:    err.Error(),
			Status: e.Failed,
		})
		return
	}
	fmt.Println("23333333333333333333")
	go func() {
		//增加画作流转记录
		for _, artworkUid := range createContractRequest.ArtworkUid {
			_, _ = service.GrpcArtistInfoArtworkImpl.AddArtworkFlowRecord(context.Background(), &artistInfoArtwork.AddArtworkFlowRecordRequest{
				ArtistUid:  createContractRequest.ArtistUid,
				ArtworkUid: artworkUid,
				TimeStamp:  time.Now().Unix(),
				FlowState:  artistInfoArtwork.FlowState_ContractGenerate,
				Operator:   artistInfoArtwork.Operator_Backend,
			})
		}
	}()
	service.ResponseMsg(c, e.SUCCESS, serializer.Response{
		Msg:    rep.Msg,
		Status: e.Ok,
		Data:   rep,
	})
}

func ContractListMgmt(c *gin.Context) {
	var ContractListMgmtRequest artistInfoContract.ContractListMgmtRequest
	if err := c.ShouldBind(&ContractListMgmtRequest); err != nil {
		logger.Errorf("ContractListMgmt ShouldBind err", err)
		service.ResponseMsg(c, e.SUCCESS, serializer.Response{
			Data:   nil,
			Msg:    err.Error(),
			Status: e.Failed,
		})
		return
	}

	fmt.Println("ContractListMgmtRequest", ContractListMgmtRequest)
	rep, err := service.GrpcArtistInfoContracImpl.ContractListMgmt(context.Background(), &ContractListMgmtRequest)
	if err != nil {
		service.ResponseMsg(c, e.SUCCESS, serializer.Response{
			Msg:    err.Error(),
			Status: e.Failed,
		})
		return
	}
	var resp []ContractListType
	for _, v := range rep.Data {
		v := v
		var relArtwork string
		if v.Type == artistInfoContract.ContractType_PowerOfAttorney || v.Type == artistInfoContract.ContractType_ArtworkRegistrationPromise {
			artworkInfo, errs := service.GrpcArtworkQueryImpl.GetArtworkProfileList(context.Background(), &artwork_query.GetArtworkProfileListRequest{
				Page:     1,
				PageSize: 1,
				Query: &artwork_query.ArtworkProfileData{
					Uuid: v.ArtworkUid,
				},
			})
			if errs == nil && artworkInfo.Total > 0 {
				relArtwork = artworkInfo.List[0].Name + "_" + artworkInfo.List[0].Tfnum
			}
		}
		resp = append(resp, ContractListType{
			RelArtwork: relArtwork,
			Contracts:  v,
		})
	}
	service.ResponseList(c, resp, service.OptionPage(ContractListMgmtRequest.Page, ContractListMgmtRequest.PageSize, rep.Total))
}

func ContractListMgmtV2(c *gin.Context) {
	var ContractListMgmtRequest artistInfoContract.ContractListMgmtV2Request
	if err := c.ShouldBind(&ContractListMgmtRequest); err != nil {
		logger.Errorf("ContractListMgmt ShouldBind err", err)
		service.ResponseMsg(c, e.SUCCESS, serializer.Response{
			Data:   nil,
			Msg:    err.Error(),
			Status: e.Failed,
		})
		return
	}

	fmt.Println("ContractListMgmtRequest", ContractListMgmtRequest)
	rep, err := service.GrpcArtistInfoContracImpl.ContractListMgmtV2(context.Background(), &ContractListMgmtRequest)
	if err != nil {
		service.ResponseMsg(c, e.SUCCESS, serializer.Response{
			Msg:    err.Error(),
			Status: e.Failed,
		})
		return
	}
	var resp []ContractListType
	for _, v := range rep.Data {
		v := v
		var relArtwork string
		if v.Type == artistInfoContract.ContractType_PowerOfAttorney || v.Type == artistInfoContract.ContractType_ArtworkRegistrationPromise {
			artworkInfo, errs := service.GrpcArtworkQueryImpl.GetArtworkProfileList(context.Background(), &artwork_query.GetArtworkProfileListRequest{
				Page:     1,
				PageSize: 1,
				Query: &artwork_query.ArtworkProfileData{
					Uuid: v.ArtworkUid,
				},
			})
			if errs == nil && artworkInfo.Total > 0 {
				relArtwork = artworkInfo.List[0].Name + "_" + artworkInfo.List[0].Tfnum
			}
		}
		resp = append(resp, ContractListType{
			RelArtwork: relArtwork,
			Contracts:  v,
		})
	}
	service.ResponseList(c, resp, service.OptionPage(ContractListMgmtRequest.Page, ContractListMgmtRequest.PageSize, rep.Total))
}

func GetContractArtistStatList(c *gin.Context) {
	var request GetContractArtistStatListRequest
	if err := c.ShouldBind(&request); err != nil {
		service.Error(c, e.Failed, err, "参数错误")
		return
	}
	var protoRequest artistInfoContract.ContractArtistStatListRequest
	asUtil.RequestDataConvert(&request, &protoRequest)
	rep, err := service.GrpcArtistInfoContracImpl.GetContractArtistStatList(c, &protoRequest)
	if err != nil {
		service.ErrorWithMark(c, e.Failed, err, "查询失败")
		return
	}
	var resp []*ContractArtistStatType
	copier.Copy(&resp, &rep.Data)
	if len(resp) > 0 {
		var artistUidList = []string{}
		for _, v := range resp {
			v := v
			artistUidList = append(artistUidList, v.ArtistUid)
		}
		res, err := service.GrpcArtistImpl.GetArtistProfileList(c, &artist.GetArtistProfileListRequest{
			Page:     1,
			PageSize: -1,
			Where:    fmt.Sprintf("uid in (%s)", "'"+strings.Join(artistUidList, "','")+"'"),
		})
		if err != nil {
			service.Error(c, e.Failed, err, "查询失败")
			return
		}
		for i, _ := range resp {
			for _, vv := range res.List {
				vv := vv
				if vv.Uid == resp[i].ArtistUid {
					resp[i].PenName = vv.PenName
				}
			}
		}
	}
	service.ResponseList(c, resp, service.OptionPage(rep.Page, rep.PageSize, rep.Total), service.OptionAddField_ArtshowCount("artistUid"))
}

func BatchCreateContract(c *gin.Context) {
	var req BatchCreateContractRequest
	if err := c.ShouldBind(&req); err != nil {
		logger.Errorf("ContractListMgmt ShouldBind err", err)
		service.ResponseMsg(c, e.SUCCESS, serializer.Response{
			Data:   nil,
			Msg:    err.Error(),
			Status: e.Failed,
		})
		return
	}
	if err := req.Validate(); err != nil {
		service.Error(c, e.Failed, err, err.Error())
		return
	}
	// ------------------------------------------------批量生成合同------------------------------------------------
	for _, t := range req.ContractType {
		rep, createErr := service.GrpcArtistInfoContracImpl.CreateContract(context.Background(), &artistInfoContract.CreateContractRequest{
			ArtistUid:  req.ArtistUid,
			ArtworkUid: req.ArtworkUids,
			Type:       t,
		})
		if createErr != nil {
			fmt.Printf("CreateContract err:%v\n", createErr)
			if rep != nil {
				fmt.Printf("CreateContract rep:%v\n", rep)
			}
			zap.L().Error("batch create contract err", zap.Error(createErr), zap.String("contractType", t.String()), zap.String("artistUid", req.ArtistUid), zap.Strings("artworkUids", req.ArtworkUids))
			service.ResponseMsg(c, e.SUCCESS, serializer.Response{
				Msg:    createErr.Error(),
				Status: e.Failed,
			})
			return
		}
	}
	go func() {
		//增加画作流转记录
		for _, artworkUid := range req.ArtworkUids {
			_, _ = service.GrpcArtistInfoArtworkImpl.AddArtworkFlowRecord(context.Background(), &artistInfoArtwork.AddArtworkFlowRecordRequest{
				ArtistUid:  req.ArtistUid,
				ArtworkUid: artworkUid,
				TimeStamp:  time.Now().Unix(),
				FlowState:  artistInfoArtwork.FlowState_ContractGenerate,
				Operator:   artistInfoArtwork.Operator_Backend,
			})
		}
		//app推送
		userRes, err := service.GrpcArtistInfoUserImpl.GetUserList(context.Background(), &artistInfoUser.GetUserListRequest{
			Query:    &artistInfoUser.UserData{MgmtArtistUid: req.ArtistUid},
			Page:     1,
			PageSize: 1,
		})
		if err != nil {
			return
		}
		_ = asPush.NewPusher().ContractOnWaitToBeSignedNotice(userRes.List[0].ID)
	}()
	service.Success(c)
}

func ReBatchCreateContract(c *gin.Context) {
	var req BatchCreateContractRequest
	if err := c.ShouldBind(&req); err != nil {
		logger.Errorf("ContractListMgmt ShouldBind err", err)
		service.ResponseMsg(c, e.SUCCESS, serializer.Response{
			Data:   nil,
			Msg:    err.Error(),
			Status: e.Failed,
		})
		return
	}
	// ------------------------------------------------校验------------------------------------------------
	if err := req.Validate(); err != nil {
		service.Error(c, e.Failed, err, err.Error())
		return
	}
	//将当前批次的合同丢到合同垃圾箱
	_, err := service.GrpcArtistInfoContracImpl.MoveCurrentBathContractsToTrash(context.Background(), &artistInfoContract.MoveCurrentBathContractsToTrashRequest{
		ArtistUid: req.ArtistUid,
	})
	if err != nil {
		service.Error(c, e.Failed, err)
		return
	}
	// ------------------------------------------------批量生成合同------------------------------------------------
	for _, t := range req.ContractType {
		rep, createErr := service.GrpcArtistInfoContracImpl.CreateContract(context.Background(), &artistInfoContract.CreateContractRequest{
			ArtistUid:  req.ArtistUid,
			ArtworkUid: req.ArtworkUids,
			Type:       t,
		})
		if createErr != nil {
			fmt.Printf("CreateContract err:%v\n", createErr)
			if rep != nil {
				fmt.Printf("CreateContract rep:%v\n", rep)
			}
			zap.L().Error("batch create contract err", zap.Error(createErr), zap.String("contractType", t.String()), zap.String("artistUid", req.ArtistUid), zap.Strings("artworkUids", req.ArtworkUids))
			service.ResponseMsg(c, e.SUCCESS, serializer.Response{
				Msg:    createErr.Error(),
				Status: e.Failed,
			})
			return
		}
	}
	go func() {
		//增加画作流转记录
		for _, artworkUid := range req.ArtworkUids {
			_, _ = service.GrpcArtistInfoArtworkImpl.AddArtworkFlowRecord(context.Background(), &artistInfoArtwork.AddArtworkFlowRecordRequest{
				ArtistUid:  req.ArtistUid,
				ArtworkUid: artworkUid,
				TimeStamp:  time.Now().Unix(),
				FlowState:  artistInfoArtwork.FlowState_ContractGenerate,
				Operator:   artistInfoArtwork.Operator_Backend,
			})
		}
		//app推送
		userRes, err := service.GrpcArtistInfoUserImpl.GetUserList(context.Background(), &artistInfoUser.GetUserListRequest{
			Query:    &artistInfoUser.UserData{MgmtArtistUid: req.ArtistUid},
			Page:     1,
			PageSize: 1,
		})
		if err != nil {
			return
		}
		_ = asPush.NewPusher().ContractOnWaitToBeSignedNotice(userRes.List[0].ID)
	}()
	service.Success(c)
}

func ContractArtworkList(c *gin.Context) {
	var req artistInfoContract.GetContractArtworkListRequest
	if err := c.ShouldBind(&req); err != nil {
		logger.Errorf("ContractListMgmt ShouldBind err", err)
		service.ResponseMsg(c, e.SUCCESS, serializer.Response{
			Data:   nil,
			Msg:    err.Error(),
			Status: e.Failed,
		})
		return
	}
	result, err := service.GrpcArtistInfoContracImpl.GetContractArtworkList(context.Background(), &req)
	if err != nil {
		service.ErrorWithMark(c, e.Failed, err, "查询失败")
		return
	}
	var resp = []ContractArtworkType{}
	if result.Total > 0 {
		var ArtworkUids []string
		for _, v := range result.Data {
			v := v
			ArtworkUids = append(ArtworkUids, v.ArtworkUid)
		}
		artworkResult, err := service.GrpcArtworkQueryImpl.GetArtworkProfileList(context.Background(), &artwork_query.GetArtworkProfileListRequest{
			Page:     1,
			PageSize: -1,
			Where:    fmt.Sprintf("uuid in (%s)", "'"+strings.Join(ArtworkUids, "','")+"'"),
		})
		if err != nil {
			service.ResponseMsg(c, e.SUCCESS, serializer.Response{
				Msg:    err.Error(),
				Status: e.Failed,
			})
			return
		}
		for _, v := range result.Data {
			for _, vv := range artworkResult.List {
				if v.ArtworkUid == vv.Uuid {
					v := v
					vv := vv
					resp = append(resp, ContractArtworkType{
						HasContract:  v.HasContract,
						ArtworkName:  vv.Name,
						Tfnum:        vv.Tfnum,
						HdPic:        vv.HdPic,
						ArtistPhoto:  vv.ArtistPhoto,
						Width:        vv.Width,
						Length:       vv.Length,
						Ruler:        vv.Ruler,
						InscribeDate: vv.InscribeDate,
						CreatedDate:  vv.CreatedDate,
					})
				}
			}
		}
	}
	service.ResponseList(c, resp, service.OptionPage(req.Page, req.PageSize, result.Total))
}