package shanghu

import (
	"duoduo/apis/shanghu/models"
	"duoduo/models/shanghu"
	"duoduo/tools"
	"duoduo/tools/app"
	"encoding/base64"
	"encoding/json"
	"errors"
	"fmt"
	"github.com/gin-gonic/gin"
	"github.com/skip2/go-qrcode"
	"time"
)

// 待核销金额
func PendingCancelAmount(c *gin.Context) {
	var inData models.PendingCancelAmountRequest
	var activePayTransSql shanghu.ClientActivePayTrans
	var outData models.PendingCancelAmountReply

	err := c.ShouldBindJSON(&inData)
	if err != nil {
		app.Error(c, 400, err, err.Error())
		return
	}

	if inData.Type == 1 { //商家
		activePayTransSql.MerchantOpenID = inData.OpenId
		activeAmount, err := activePayTransSql.GetPendingCancelByMerchant()
		if err != nil {
			app.Error(c, 500, err, err.Error())
			return
		}
		outData.Amount = activeAmount.MerchantAmount.String()

	} else if inData.Type == 2 { //个人
		activePayTransSql.ClientOpenID = inData.OpenId
		activeAmount, err := activePayTransSql.GetPendingCancelByClient()
		if err != nil {
			app.Error(c, 500, err, err.Error())
			return
		}
		outData.Amount = activeAmount.ClientAmount.String()

	} else {
		app.Error(c, 500, errors.New("type 类型错误"), err.Error())
		return
	}

	app.OK(c, outData, app.Success)

}

// 拼团购买
func GetGroupBuyPayList(c *gin.Context) {
	var inData models.GetGroupBuyPayRequest
	var sqlData shanghu.ClientActivePayTrans
	var outData []models.GetGroupBuyPayReply

	err := c.ShouldBindJSON(&inData)
	if err != nil {
		app.Error(c, 400, err, err.Error())
		return
	}

	//// 不是商家也不是c端客户
	//if inData.UserType != 1 && inData.UserType != 2 {
	//	app.Error(c, 500, errors.New("用户类型错误"), err.Error())
	//	return
	//}
	//
	//// 核销类型错误
	//if inData.GroupBuyType != 1 && inData.GroupBuyType != 2 {
	//	app.Error(c, 500, errors.New("核销类型错误"), err.Error())
	//	return
	//}

	var pageSize = 10
	var pageIndex = 1

	if inData.PageSize != 0 {
		pageSize = inData.PageSize
	}
	if inData.PageIndex != 0 {
		pageIndex = inData.PageIndex
	}

	activeDrawLogList, count, err := sqlData.GetActivePayTransList(pageSize, pageIndex, inData.OpenId)
	if err != nil {
		app.Error(c, 500, err, err.Error())
		return
	}

	for _, v := range activeDrawLogList {
		var data models.GetGroupBuyPayReply
		var activeSql shanghu.MerchantActiveConfig
		var groupBuySql shanghu.MerchantActiveGroupBuy
		var groupBuyProductSql shanghu.MerchantActiveGroupByProject
		var groupBuyProductCancel shanghu.ActiveCancelLog
		data.MerchantAmount = v.MerchantAmount.String()
		data.Amount = v.Amount.String()
		data.ClientAmount = v.ClientAmount.String()
		data.PayTime = v.PayTime.Format(time.DateTime)

		activeSql.ID = v.ActiveConfigID
		activeInfo, err := activeSql.GetConfigInfoById()
		if err != nil {
			app.Error(c, 500, err, err.Error())
			return
		}
		data.ActiveName = activeInfo.ActiveName
		groupBuySql.ID = v.GroupBuyID
		groupBuyInfo, err := groupBuySql.GetMerchantActiveGroupBuyById()
		if err != nil {
			app.Error(c, 500, err, err.Error())
			return
		}

		groupBuyProductSql.GroupBuyID = v.GroupBuyID
		groupBuyProductList, _, err := groupBuyProductSql.GetGroupBuyProjectList()
		if err != nil {
			app.Error(c, 500, err, err.Error())
			return
		}
		totalGroupBuyNum := 0
		for _, v := range groupBuyProductList {
			totalGroupBuyNum = totalGroupBuyNum + v.CancelNum
		}

		groupBuyProductCancel.ClientOpenID = inData.OpenId
		groupBuyProductCancel.ActiveConfigID = v.ActiveConfigID
		cancelNum := groupBuyProductCancel.GetActiveCancelNum()

		data.GroupBuyName = groupBuyInfo.GroupBuyName
		data.PayTime = v.PayTime.Format(time.DateTime)
		data.TradeNo = v.ThirdTradeNo
		data.TotalCancelNum = totalGroupBuyNum
		data.PendingCancelNum = totalGroupBuyNum - cancelNum
		data.Url = groupBuyInfo.GroupBuyUrl

		outData = append(outData, data)
	}
	app.PageOK(c, outData, count, pageIndex, pageSize, app.Success)

}

// 拼团核销码
func GroupBuyPayCode(c *gin.Context) {
	var inData models.GroupBuyPayCodeRequest
	var outData models.GroupBuyPayCodeReply
	var payTransSql shanghu.ClientActivePayTrans
	var groupBuyProductSql shanghu.MerchantActiveGroupByProject
	var groupBuyProductCancel shanghu.ActiveCancelLog

	err := c.ShouldBindJSON(&inData)
	if err != nil {
		app.Error(c, 400, err, err.Error())
		return
	}
	//校验核销次数
	payTransSql.ThirdTradeNo = inData.TradeNo
	payTransInfo, err := payTransSql.GetPayTransByThirdTradeNo()
	if err != nil {
		app.Error(c, 500, err, err.Error())
		return
	}

	groupBuyProductSql.GroupBuyID = payTransInfo.GroupBuyID
	groupBuyProductList, _, err := groupBuyProductSql.GetGroupBuyProjectList()
	if err != nil {
		app.Error(c, 500, err, err.Error())
		return
	}
	totalGroupBuyNum := 0
	for _, v := range groupBuyProductList {
		totalGroupBuyNum = totalGroupBuyNum + v.CancelNum
	}

	groupBuyProductCancel.ClientOpenID = payTransInfo.ClientOpenID
	groupBuyProductCancel.ActiveConfigID = payTransInfo.ActiveConfigID
	cancelNum := groupBuyProductCancel.GetActiveCancelNum()

	if totalGroupBuyNum <= cancelNum {
		app.Error(c, 500, errors.New("核销次数用完"), "核销次数用完")
		return
	}

	outData.Key = "GROU" + tools.MD5(inData.TradeNo+"zhangkun429@")
	outData.TradeNo = inData.TradeNo

	str, err := json.Marshal(&outData)
	if err != nil {
		app.Error(c, 500, err, err.Error())
		return
	}
	qr, err := qrcode.Encode(string(str), qrcode.High, 200)
	if err != nil {
		app.Error(c, 500, err, err.Error())
		return
	}
	encodedData := base64.StdEncoding.EncodeToString(qr)

	app.OK(c, encodedData, app.Success)
}

// 拼团核销详情
func GroupBuyCancelInfo(c *gin.Context) {
	var inData models.GroupBuyCancelInfoRequest
	var outData models.GroupBuyCancelInfoReply
	var sqlData shanghu.ClientActivePayTrans
	var activeConfigSql shanghu.MerchantActiveConfig
	var groupBuySql shanghu.MerchantActiveGroupBuy
	var groupBuyProjectSql shanghu.MerchantActiveGroupByProject

	err := c.ShouldBindJSON(&inData)
	if err != nil {
		app.Error(c, 400, err, err.Error())
		return
	}

	key := "GROU" + tools.MD5(inData.TradeNo+"zhangkun429@")
	if inData.Key != key {
		app.Error(c, 500, errors.New("数据错误"), "数据错误")
		return
	}
	sqlData.ThirdTradeNo = inData.TradeNo
	payTransInfo, err := sqlData.GetPayTransByThirdTradeNo()
	if err != nil {
		app.Error(c, 500, err, err.Error())
		return
	}

	//校验分账类型
	//if payTransInfo.AccountStatus != shanghu.ClientActivePayTransAccountStatusUnSettle && payTransInfo.AccountStatus != shanghu.ClientActivePayTransAccountStatusSettleFail {
	//	app.Error(c, 500, errors.New("核销已完成"), "核销已完成")
	//	return
	//}
	// 校验支付类型
	if payTransInfo.Status != shanghu.ClientActivePayTransStatusPaySuccess {
		app.Error(c, 500, errors.New("未支付交易不准核销"), "未支付交易不准核销")
		return
	}

	// 返回拼团信息
	outData.Amount = payTransInfo.Amount.String()
	outData.TradeNo = inData.TradeNo
	outData.PayTime = payTransInfo.PayTime.Format(time.DateTime)
	outData.MerchantAmount = payTransInfo.MerchantAmount.String()
	outData.ClientAmount = payTransInfo.ClientAmount.String()

	activeConfigSql.ID = payTransInfo.ActiveConfigID
	activeConfigInfo, err := activeConfigSql.GetConfigInfoById()
	if err != nil {
		app.Error(c, 500, err, err.Error())
		return
	}
	outData.ActiveName = activeConfigInfo.ActiveName
	groupBuySql.ID = payTransInfo.GroupBuyID
	groupBuyInfo, err := groupBuySql.GetMerchantActiveGroupBuyById()
	if err != nil {
		app.Error(c, 500, err, err.Error())
		return
	}

	outData.GroupBuyName = groupBuyInfo.GroupBuyName
	groupBuyProjectSql.GroupBuyID = payTransInfo.GroupBuyID
	project, _, err := groupBuyProjectSql.GetGroupBuyProjectList()
	if err != nil {
		app.Error(c, 500, err, err.Error())
		return
	}

	for _, v := range project {
		var projectInfo models.CancelGroupBuyProject
		var activeCancelSql shanghu.ActiveCancelLog
		activeCancelSql.ClientOpenID = payTransInfo.ClientOpenID
		activeCancelSql.ActiveConfigID = payTransInfo.ActiveConfigID
		activeCancelSql.GroupByProjectID = v.ID
		activeCancelSql.TransID = payTransInfo.ID
		num := activeCancelSql.GetActiveCancelNumByProjectID()
		fmt.Println("num = ", num)

		projectInfo.ProjectName = v.ProjectName
		projectInfo.TotalCancelNum = v.CancelNum
		projectInfo.PendingCancelNum = v.CancelNum - num
		projectInfo.ID = v.ID
		outData.GroupBuyProject = append(outData.GroupBuyProject, projectInfo)
	}

	app.OK(c, outData, app.Success)
}

// 拼团核销
func GroupBuyCancel(c *gin.Context) {
	var inData models.GroupBuyCancelRequest
	var payTrans shanghu.ClientActivePayTrans
	var activeCancelLogList []shanghu.ActiveCancelLog

	err := c.ShouldBindJSON(&inData)
	if err != nil {
		app.Error(c, 400, err, err.Error())
		return
	}

	key := "GROU" + tools.MD5(inData.TradeNo+"zhangkun429@")
	if inData.Key != key {
		app.Error(c, 500, errors.New("数据错误"), "数据错误")
		return
	}

	//查交易
	payTrans.ThirdTradeNo = inData.TradeNo

	transInfo, err := payTrans.GetPayTransByThirdTradeNo()
	if err != nil {
		app.Error(c, 500, err, err.Error())
		return
	}

	//校验分账类型
	//if transInfo.AccountStatus != shanghu.ClientActivePayTransAccountStatusUnSettle && transInfo.AccountStatus != shanghu.ClientActivePayTransAccountStatusSettleFail {
	//	app.Error(c, 500, errors.New("核销已完成"), "核销已完成")
	//	return
	//}

	// 校验支付类型
	if transInfo.Status != shanghu.ClientActivePayTransStatusPaySuccess {
		app.Error(c, 500, errors.New("未支付交易不准核销"), "未支付交易不准核销")
		return
	}

	if transInfo.AccountStatus == shanghu.ClientActivePayTransAccountStatusSettlePending {
		app.Error(c, 500, errors.New("正在分账中"), "正在分账中")
		return
	}

	//查看核销次数
	//是否可以核销，默认不可以核销,只要有一个可以核销就为true
	isCancel := false
	for _, v := range inData.GroupBuyProject {
		var projectSql shanghu.MerchantActiveGroupByProject
		var activeCancel shanghu.ActiveCancelLog

		projectSql.ID = v.ID
		projectInfo, err := projectSql.GetMerchantActiveGroupBuyProjectByID()
		if err != nil {
			app.Error(c, 500, err, err.Error())
			return
		}

		activeCancel.ClientOpenID = transInfo.ClientOpenID
		activeCancel.ActiveConfigID = transInfo.ActiveConfigID
		activeCancel.GroupByProjectID = v.ID
		activeCancel.TransID = transInfo.ID

		cancelNum := activeCancel.GetActiveCancelNumByProjectID()
		fmt.Println("cancelNum = ", cancelNum)
		fmt.Println("projectInfo.CancelNum = ", projectInfo.CancelNum)
		fmt.Println("v.CancelNum = ", v.CancelNum)

		if v.CancelNum <= 0 {
			continue
		}

		if projectInfo.CancelNum >= cancelNum+v.CancelNum && v.CancelNum > 0 {
			isCancel = true
			for i := 0; i < v.CancelNum; i++ {
				var activeCancelLogInfo shanghu.ActiveCancelLog
				activeCancelLogInfo.ActiveConfigID = transInfo.ActiveConfigID
				activeCancelLogInfo.ClientOpenID = transInfo.ClientOpenID
				activeCancelLogInfo.MerchantOpenID = inData.OpenId
				activeCancelLogInfo.GroupByProjectID = v.ID
				activeCancelLogInfo.TransID = transInfo.ID
				activeCancelLogInfo.CreatedAt = time.Now()
				activeCancelLogInfo.UpdatedAt = time.Now()

				activeCancelLogList = append(activeCancelLogList, activeCancelLogInfo)
			}
		} else {
			app.Error(c, 500, errors.New("核销次数不够"), "核销次数不够")
			return
		}

	}

	if !isCancel {
		app.Error(c, 500, errors.New("核销次数不够"), "核销次数不够")
		return
	}

	// 分账
	if transInfo.AccountStatus == shanghu.ClientActivePayTransAccountStatusSettleSuccess {
		//不需要分账
		var activeCancel shanghu.ActiveCancelLog
		err = activeCancel.TXActiveCancelLogCreate(activeCancelLogList)
		if err != nil {
			app.Error(c, 500, err, err.Error())
			return
		}
	} else { // 需要分账
		// 分账中
		fmt.Println("分账中...")
		payTrans.ID = transInfo.ID
		payTrans.AccountStatus = shanghu.ClientActivePayTransAccountStatusSettlePending
		err = payTrans.UpdateAccountStatusByID()
		if err != nil {
			dataErr := make(map[string]interface{})
			dataErr["account_status"] = shanghu.ClientActivePayTransAccountStatusSettleFail //分账失败
			dataErr["account_err_log"] = "修改分账中失败：" + err.Error()                           //分账失败日志
			dataErr["updated_at"] = time.Now()
			_ = payTrans.UpdateById(dataErr)

			app.Error(c, 500, err, err.Error())
			return
		}

		//校验是否被分过，分过后不再分账
		var merchantAccountLog shanghu.MerchantAccountLog
		merchantAccountLog.PayTransId = transInfo.ID
		merchantAccountLog.TransType = shanghu.MerchantAccountLogTransTypeGroupBuy
		num := merchantAccountLog.GetAccountLogNum()
		if num > 0 { //交易已经分过账
			dataErr := make(map[string]interface{})
			dataErr["account_status"] = shanghu.ClientActivePayTransAccountStatusSettleFail //分账失败
			dataErr["account_err_log"] = "交易已分过账"                                           //分账失败日志
			dataErr["updated_at"] = time.Now()
			_ = payTrans.UpdateById(dataErr)
			app.Error(c, 500, errors.New("交易已分过账"), "交易已分过账")
			return
		}
		//分账校验账号
		var merchantAccount shanghu.MerchantAccount
		merchantAccount.MerchantOpenID = transInfo.MerchantOpenID
		merchantAccountInfo, err := merchantAccount.GetMerchantAccount()
		if err != nil && err.Error() != "record not found" {
			dataErr := make(map[string]interface{})
			dataErr["account_status"] = shanghu.ClientActivePayTransAccountStatusSettleFail //分账失败
			dataErr["account_err_log"] = "商家分账校验账号：" + err.Error()                          //分账失败日志
			dataErr["updated_at"] = time.Now()
			_ = payTrans.UpdateById(dataErr)

			app.Error(c, 500, err, err.Error())
			return
		}
		if merchantAccountInfo.ID == 0 { //需要创建新账号
			merchantAccount.MerchantOpenID = transInfo.MerchantOpenID
			merchantAccount.Version = 1
			merchantAccount.CreatedAt = time.Now()
			merchantAccount.UpdatedAt = time.Now()
			merchantAccount, err = merchantAccount.Create()
			if err != nil {

				dataErr := make(map[string]interface{})
				dataErr["account_status"] = shanghu.ClientActivePayTransAccountStatusSettleFail //分账失败
				dataErr["account_err_log"] = "创建新的商家账号：" + err.Error()                          //分账失败日志
				dataErr["updated_at"] = time.Now()
				_ = payTrans.UpdateById(dataErr)

				app.Error(c, 500, err, err.Error())
				return
			}

		}
		var clientAccount shanghu.ActiveClientAccount
		if transInfo.InvitationCode != shanghu.YuanShiMa { //校验c端客户
			var activeUser shanghu.ActiveUser
			activeUser.Code = transInfo.InvitationCode
			activeUserInfo, err := activeUser.GetUserInfoByCode()
			if err != nil {

				dataErr := make(map[string]interface{})
				dataErr["account_status"] = shanghu.ClientActivePayTransAccountStatusSettleFail         //分账失败
				dataErr["account_err_log"] = "根据Code获取c端客户信息：" + transInfo.InvitationCode + err.Error() //分账失败日志
				dataErr["updated_at"] = time.Now()
				_ = payTrans.UpdateById(dataErr)

				app.Error(c, 500, err, err.Error())
				return
			}
			clientAccount.ClientOpenID = activeUserInfo.OpenID
			clientAccountInfo, err := clientAccount.GetActiveAccount()
			if err != nil && err.Error() != "record not found" {

				dataErr := make(map[string]interface{})
				dataErr["account_status"] = shanghu.ClientActivePayTransAccountStatusSettleFail //分账失败
				dataErr["account_err_log"] = "获取c端客户账户：" + err.Error()                          //分账失败日志
				dataErr["updated_at"] = time.Now()
				_ = payTrans.UpdateById(dataErr)

				app.Error(c, 500, err, err.Error())
				return
			}

			if clientAccountInfo.ID == 0 { //需要创建新账号
				clientAccount.ClientOpenID = activeUserInfo.OpenID
				clientAccount.Version = 1
				clientAccount.CreatedAt = time.Now()
				clientAccount.UpdatedAt = time.Now()
				clientAccount, err = clientAccount.Create()
				if err != nil {

					dataErr := make(map[string]interface{})
					dataErr["account_status"] = shanghu.ClientActivePayTransAccountStatusSettleFail //分账失败
					dataErr["account_err_log"] = "创建c端客户：" + err.Error()                            //分账失败日志
					dataErr["updated_at"] = time.Now()
					_ = payTrans.UpdateById(dataErr)

					app.Error(c, 500, err, err.Error())
					return
				}

			}

		}

		//分账 根据merchant-openid + activeUserInfo.openid 进行分账
		//商家分多少钱，客户分多少钱
		err = merchantAccount.ActiveCancelSettle(activeCancelLogList, merchantAccount, clientAccount, transInfo)
		if err != nil {

			dataErr := make(map[string]interface{})
			dataErr["account_status"] = shanghu.ClientActivePayTransAccountStatusSettleFail //分账失败
			dataErr["account_err_log"] = "分账失败：" + err.Error()                              //分账失败日志
			dataErr["updated_at"] = time.Now()
			_ = payTrans.UpdateById(dataErr)

			app.Error(c, 500, err, err.Error())
			return
		}

	}
	app.OK(c, nil, app.Success)

}