package loanbill

import (
	"context"
	"fmt"
	"github.com/fonchain_enterprise/fonchain-main/api/account"
	"github.com/fonchain_enterprise/fonchain-main/api/artist"
	"github.com/fonchain_enterprise/fonchain-main/api/digital_copyright"
	"github.com/fonchain_enterprise/fonchain-main/api/loanbill"
	"github.com/fonchain_enterprise/fonchain-main/pkg/config"
	"github.com/fonchain_enterprise/fonchain-main/pkg/e"
	logic_loanbill "github.com/fonchain_enterprise/fonchain-main/pkg/logic/loanbill"
	"github.com/fonchain_enterprise/fonchain-main/pkg/model"
	model_loanbill "github.com/fonchain_enterprise/fonchain-main/pkg/model/loanbill"
	"github.com/fonchain_enterprise/fonchain-main/pkg/service"
	"github.com/fonchain_enterprise/fonchain-main/pkg/utils"
	"github.com/gin-gonic/gin"
	"github.com/jinzhu/copier"
	"go.uber.org/zap"
	"strings"
	"time"
)

func ProjectList(ctx *gin.Context) {
	resp, _err := service.GrpcLoanBillClientImpl.ProjectList(ctx, &loanbill.ProjectListReq{})
	if _err != nil {
		service.ResponseQuickMsg(ctx, e.Failed, _err.Error(), nil)
		return
	}
	service.ResponseQuickMsg(ctx, e.Ok, e.GetMsg(e.SUCCESS), resp)
	return
}

func UpdateBill(ctx *gin.Context) {
	var (
		err           error
		req           *loanbill.UpdateBillReq
		copyrightResp *digital_copyright.CopyrightListResp
	)
	if err = ctx.ShouldBind(&req); err != nil {
		service.ResponseQuickMsg(ctx, e.Failed, err.Error(), nil)
		return
	}
	if mLoginInfoAny, exists := ctx.Get("mLoginInfo"); exists {
		zap.L().Info("mLoginInfoAny", zap.Any("mLoginInfoAny", mLoginInfoAny))
		userInfo := mLoginInfoAny.(model.LoginInfo)
		req.LoanUserId = fmt.Sprint(userInfo.ID)
		req.LoanUsername = fmt.Sprint(userInfo.NickName)
		accountReq := account.ListV2Request{
			TelNum: userInfo.Phone,
		}
		accountResp, _ := service.AccountProvider.ListV2(ctx, &accountReq)
		if accountResp.Data != nil && len(accountResp.Data) > 0 {
			req.LoanUserNo = accountResp.Data[0].JobNum
		}
		//req.LoanUserDepartmentId = fmt.Sprint(userInfo.PositionUsers[0].DepartmentId)
		//req.LoanUserDepartmentName = userInfo.PositionUsers[0].DepartmentName
		var departmentKv map[string]string = map[string]string{}
		zap.L().Info("mLoginInfoAny", zap.Any("userInfo.PositionUsers", userInfo.PositionUsers))
		if len(userInfo.PositionUsers) > 0 {
			for _, v := range userInfo.PositionUsers {
				if _, ok := departmentKv[fmt.Sprint(v.DepartmentId)]; !ok {
					departmentKv[fmt.Sprint(v.DepartmentId)] = v.DepartmentName
				}
			}
			zap.L().Info("mLoginInfoAny", zap.Any("departmentKv", departmentKv))
			for k, v := range departmentKv {
				req.LoanUserDepartmentId = fmt.Sprintf("%s,%s", req.LoanUserDepartmentId, k)
				req.LoanUserDepartmentName = fmt.Sprintf("%s,%s", req.LoanUserDepartmentName, v)
			}
			req.LoanUserDepartmentId = strings.Trim(req.LoanUserDepartmentId, ",")
			req.LoanUserDepartmentName = strings.Trim(req.LoanUserDepartmentName, ",")
		}

	}
	if len(req.CopyrightIds) == 0 || req.LoanMoney == 0 {
		service.ResponseQuickMsg(ctx, e.Failed, e.ErrorLoanMoney, nil)
		return
	}
	// 根据版权ID查询版权信息
	if len(req.CopyrightIds) > 0 {
		if copyrightResp, err = service.GrpcCopyrightImpl.CopyrightList(ctx, &digital_copyright.CopyrightListReq{
			Page:         1,
			PageSize:     9999,
			CopyrightIds: req.CopyrightIds,
		}); err != nil {
			service.ResponseQuickMsg(ctx, e.Failed, err.Error(), nil)
			return
		}
		if copyrightResp.Data == nil {
			service.ResponseQuickMsg(ctx, e.Failed, e.GetMsg(e.NOTDATA), nil)
			return
		}
		// 查询画作的画家编号
		var artistUuids []string
		for _, v := range copyrightResp.Data {
			artistUuids = append(artistUuids, v.ArtistUuid)
		}
		var artistInfoKv map[string]string = map[string]string{}
		if len(artistUuids) > 0 {
			artistDataResp, _err := service.GrpcArtistImpl.ArtistData(context.Background(), &artist.ArtistDataRequest{Uids: artistUuids})
			if _err == nil {
				for _, v := range artistDataResp.Data {
					artistInfoKv[v.ProfileInfo.Uid] = v.ProfileInfo.Tnum
				}
			}
		}
		for _, v := range copyrightResp.Data {
			var tnum string
			if _, ok := artistInfoKv[v.ArtistUuid]; ok {
				tnum = artistInfoKv[v.ArtistUuid]
			}
			var temp loanbill.CopyrightDetailInfo = loanbill.CopyrightDetailInfo{
				ArtworkName: v.WorkName,
				ArtworkUuid: v.ArtworkUuid,
				Tfnum:       v.Tfnum,
				ArtistName:  v.ArtistName,
				ArtistUuid:  v.ArtistUuid,
				Amount:      v.Amount,
				AgentName:   v.AgentName,
				CopyrightId: v.CopyrightId,
				Tnum:        tnum,
			}

			req.CopyrightDetailData = append(req.CopyrightDetailData, &temp)
		}
	}
	zap.L().Info("loanbill-list", zap.Any("req", req))
	resp, _err := service.GrpcLoanBillClientImpl.UpdateBill(ctx, req)
	if _err != nil {
		service.ResponseQuickMsg(ctx, e.Failed, _err.Error(), nil)
		return
	}
	service.ResponseQuickMsg(ctx, e.Ok, e.GetMsg(e.SUCCESS), resp)
	return
}

func BillDetail(ctx *gin.Context) {
	var (
		err error
		req *loanbill.BillDetailReq
	)
	if err = ctx.ShouldBind(&req); err != nil {
		service.ResponseQuickMsg(ctx, e.Failed, err.Error(), nil)
		return
	}
	resp, _err := service.GrpcLoanBillClientImpl.BillDetail(ctx, req)
	if _err != nil {
		service.ResponseQuickMsg(ctx, e.Failed, _err.Error(), nil)
		return
	}
	service.ResponseQuickMsg(ctx, e.Ok, e.GetMsg(e.SUCCESS), resp)
	return
}

func BillList(ctx *gin.Context) {
	var (
		err error
		req *loanbill.BillListReq
	)
	if err = ctx.ShouldBind(&req); err != nil {
		service.ResponseQuickMsg(ctx, e.Failed, err.Error(), nil)
		return
	}
	resp, _err := service.GrpcLoanBillClientImpl.BillList(ctx, req)
	if _err != nil {
		service.ResponseQuickMsg(ctx, e.Failed, _err.Error(), nil)
		return
	}
	service.ResponseQuickMsg(ctx, e.Ok, e.GetMsg(e.SUCCESS), resp)
	return
}

func BillListExport(ctx *gin.Context) {
	var (
		err error
		req *loanbill.BillListReq
	)
	if err = ctx.ShouldBind(&req); err != nil {
		service.ResponseQuickMsg(ctx, e.Failed, err.Error(), nil)
		return
	}
	req.Page = 1
	req.PageSize = 999
	resp, _err := service.GrpcLoanBillClientImpl.BillList(ctx, req)
	if _err != nil {
		service.ResponseQuickMsg(ctx, e.Failed, _err.Error(), nil)
		return
	}
	var adminId uint64
	if config.Env != "dev" {
		if mLoginInfoAny, exists := ctx.Get("mLoginInfo"); exists {
			userInfo := mLoginInfoAny.(model.LoginInfo)
			adminId = userInfo.ID
		}
	}
	if resp.Data == nil {
		service.ResponseQuickMsg(ctx, e.Failed, e.GetMsg(e.NOTDATA), nil)
		return
	}
	columns := []string{"项目名称", "借款人", "借款人部门", "借款日期", "借款总额", "状态", "更新时间"}
	columnStruct := []string{"ProjectName", "LoanUsername", "LoanUserDepartmentName", "LoanDate", "Money", "Status", "UpdateTime"} // struct 字段
	data, _ := logic_loanbill.LoanbillkExcelData(resp.Data, columnStruct)
	exportFileName := fmt.Sprintf("借款单%s.xlsx", time.Now().Format("20060102"))
	filePath := fmt.Sprintf("./runtime/%d/%s", adminId, exportFileName)
	_, _ = utils.CheckDirPath("./runtime/"+fmt.Sprint(adminId), true)
	_, _ = utils.ToExcelByType(columns, data, "slice", filePath)
	var httpType string
	if config.IsHttps {
		httpType = model.HttpsType
	} else {
		httpType = model.HttpType
	}
	var exportUrl string = fmt.Sprintf("%s%s/static/%s", httpType, ctx.Request.Host, strings.Replace(filePath, "./runtime/", "", 1))
	service.ResponseQuickMsg(ctx, e.Ok, e.GetMsg(e.SUCCESS), map[string]string{
		"ExportUrl": exportUrl,
	})
	return
}

func BillStatusUpdate(ctx *gin.Context) {
	var (
		err error
		req *loanbill.BillStatusUpdateReq
	)
	if err = ctx.ShouldBind(&req); err != nil {
		service.ResponseQuickMsg(ctx, e.Failed, err.Error(), nil)
		return
	}
	resp, _err := service.GrpcLoanBillClientImpl.BillStatusUpdate(ctx, req)
	if _err != nil {
		service.ResponseQuickMsg(ctx, e.Failed, _err.Error(), nil)
		return
	}
	service.ResponseQuickMsg(ctx, e.Ok, e.GetMsg(e.SUCCESS), resp)
	return
}

func VoucherUpdate(ctx *gin.Context) {
	var (
		err error
		req *loanbill.VoucherUpdateReq
	)
	if err = ctx.ShouldBind(&req); err != nil {
		service.ResponseQuickMsg(ctx, e.Failed, err.Error(), nil)
		return
	}
	resp, _err := service.GrpcLoanBillClientImpl.VoucherUpdate(ctx, req)
	if _err != nil {
		service.ResponseQuickMsg(ctx, e.Failed, _err.Error(), nil)
		return
	}
	service.ResponseQuickMsg(ctx, e.Ok, e.GetMsg(e.SUCCESS), resp)
	return
}

func CopyrightArtworkList(ctx *gin.Context) {
	var (
		listReq  *digital_copyright.CopyrightFilterListReq
		listResp *digital_copyright.CopyrightFilterListResp
		err      error
	)
	if err = ctx.ShouldBind(&listReq); err != nil {
		zap.L().Error("CopyrightArtworkList err ShouldBind", zap.Error(err))
		service.ResponseQuickMsg(ctx, e.Failed, e.GetMsg(e.InvalidParams), nil)
		return
	}
	loadEndResp, _err := service.GrpcLoanBillClientImpl.LoadEndCopyright(ctx, &loanbill.LoadEndCopyrightReq{})
	if loadEndResp != nil {
		for _, v := range loadEndResp.Data {
			listReq.CopyrightIdsNotIn = append(listReq.CopyrightIdsNotIn, v.CopyrightId)
		}
	}

	listReq.Status = "DIGITAL_WAIT_PAY"
	if listResp, err = service.GrpcCopyrightImpl.CopyrightFilterList(ctx, listReq); err != nil {
		zap.L().Error("loanbill err CopyrightArtworkList", zap.Error(err))
		service.ResponseQuickMsg(ctx, e.Failed, err.Error(), nil)
		return
	}
	var resp model_loanbill.CopyrightArtworkResp
	var data []*model_loanbill.CopyrightArtworkInfo
	_ = copier.Copy(&data, listResp.Data)
	//for _, vv := range listResp.Data {
	//	var temp model_loanbill.CopyrightArtworkInfo
	//	_ = copier.Copy(&temp, vv)
	//	temp.Amount = vv.Amount
	//	data = append(data, &temp)
	//}

	var copyrightIds []string
	for _, v := range data {
		copyrightIds = append(copyrightIds, v.CopyrightId)
		v.ArtworkName = v.WorkName
		v.LoanBillStatus = 1
	}
	infoResp, _err := service.GrpcLoanBillClientImpl.ArtworkLoanInfo(ctx, &loanbill.ArtworkLoanInfoReq{CopyrightIds: copyrightIds})
	if _err != nil {
		service.ResponseQuickMsg(ctx, e.Failed, _err.Error(), nil)
		return
	}
	set := make(map[int32]bool)
	nums := []int32{1, 2, 3}
	for _, num := range nums {
		set[num] = true
	}
	var artistUuids []string
	for _, v := range data {
		artistUuids = append(artistUuids, v.ArtistUuid)
		for _, vv := range infoResp.Data {
			if vv.CopyrightId == v.CopyrightId {
				if _, ok := set[vv.Status]; ok {
					v.LoanBillStatus = 2
					v.BillUuid = vv.BillUuid
				}
			}
		}
	}
	if len(artistUuids) > 0 {
		artistData, errS := service.GrpcArtistImpl.ArtistData(context.Background(), &artist.ArtistDataRequest{Uids: artistUuids})
		if errS == nil {
			for _, v := range data {
				for _, vv := range artistData.Data {
					if v.ArtistUuid == vv.ProfileInfo.Uid {
						v.Tnum = vv.ProfileInfo.Tnum
					}
				}
			}
		}
	}
	resp.Count = int(listResp.Count)
	resp.Page = int(listReq.Page)
	resp.PageSize = int(listReq.PageSize)
	resp.Data = data
	service.ResponseQuickMsg(ctx, e.Ok, e.GetMsg(e.SUCCESS), resp)
	return
}

func BillDel(ctx *gin.Context) {
	var (
		req *loanbill.DeleteBillReq
		err error
	)
	if err = ctx.ShouldBind(&req); err != nil {
		zap.L().Error("loanbill err BillDel", zap.Error(err))
		service.ResponseQuickMsg(ctx, e.Failed, e.GetMsg(e.InvalidParams), nil)
		return
	}
	if _, err = service.GrpcLoanBillClientImpl.DeleteBill(ctx, req); err != nil {
		service.ResponseQuickMsg(ctx, e.Failed, err.Error(), nil)
		return
	}
	service.ResponseQuickMsg(ctx, e.Ok, e.GetMsg(e.SUCCESS), nil)
	return
}

func Test(ctx *gin.Context) {
	if mLoginInfoAny, exists := ctx.Get("mLoginInfo"); exists {
		zap.L().Info("mLoginInfoAny", zap.Any("mLoginInfoAny", mLoginInfoAny))
		userInfo := mLoginInfoAny.(model.LoginInfo)
		var LoanUserDepartmentId string
		var LoanUserDepartmentName string
		var departmentKv map[string]string
		if len(userInfo.PositionUsers) > 0 {
			for _, v := range userInfo.PositionUsers {
				if _, ok := departmentKv[fmt.Sprint(v.DepartmentId)]; !ok {
					departmentKv[fmt.Sprint(v.DepartmentId)] = v.DepartmentName
				}
			}
			for k, v := range departmentKv {
				LoanUserDepartmentId = fmt.Sprintf("%s,%s", LoanUserDepartmentId, k)
				LoanUserDepartmentName = fmt.Sprintf("%s,%s", LoanUserDepartmentName, v)
			}
			LoanUserDepartmentId = strings.Trim(LoanUserDepartmentId, ",")
			LoanUserDepartmentName = strings.Trim(LoanUserDepartmentName, ",")
		}

		service.ResponseQuickMsg(ctx, 0, "ok", map[string]string{
			"LoanUserDepartmentId":   LoanUserDepartmentId,
			"LoanUserDepartmentName": LoanUserDepartmentName,
		})
		return
	}
	service.ResponseQuickMsg(ctx, 1, "fail", nil)
	return
}