package order

import (
	"app.yhyue.com/moapp/jybase/common"
	"app.yhyue.com/moapp/jybase/date"
	"context"
	"errors"
	"fmt"
	"github.com/gogf/gf/v2/database/gdb"
	"github.com/gogf/gf/v2/errors/gerror"
	"github.com/gogf/gf/v2/frame/g"
	"github.com/gogf/gf/v2/util/gconv"
	"jyOrderManager/internal/consts"
	"jyOrderManager/internal/jyutil"
	"jyOrderManager/internal/logic/product"
	"jyOrderManager/internal/model"
	"log"
	"strings"
	"time"
)

// OperateOrderRedPunch 红冲
func OperateOrderRedPunch(ctx context.Context, params model.OrderRedPunchParams) error {
	orderData, err := g.DB().GetOne(ctx, fmt.Sprintf(`SELECT user_phone,buy_subject,company_name,signing_subject,procedures_money,order_money,commission+(select IFNULL(sum(commission),0) as return_money from moneyCorrection where orderCode= '%s') as commission,pay_money+(select IFNULL(sum(payMoney),0) as return_money from moneyCorrection where orderCode='%s') as pay_money FROM dataexport_order  WHERE order_code = '%s'`, params.OrderCode, params.OrderCode, params.OrderCode))
	if err != nil || orderData.IsEmpty() {
		return errors.New("未找到订单")
	}
	isSubject := true
	updateData := map[string]interface{}{}
	var (
		insertDataArr               []map[string]interface{}
		commission, proceduresMoney int
	)
	for _, param := range params.RedPunch {
		insertData := map[string]interface{}{
			"orderCode":        params.OrderCode,
			"correctionReason": param.CorrectionReason,
			"createTime":       date.NowFormat(date.Date_Full_Layout),
			"createPerson":     jyutil.GetUserMsgFromCtx(ctx).EntUserName,
			"redType":          params.RedType,
			"detail_id":        param.Id,
			"activity_code":    param.ActiveCode,
		}
		if strings.Contains(params.RedType, "签约主体") {
			if param.PayMoney == 0 {
				param.PayMoney = common.IntAll(orderData.Map()["pay_money"])
			}
			if param.Commission == 0 {
				param.Commission = common.IntAll(orderData.Map()["commission"])
			}
			//if param.ProceduresMoney == 0 {
			//	param.ProceduresMoney = common.IntAll(orderData.Map()["procedures_money"])
			//}
			oldInsertData := map[string]interface{}{
				"payMoney":   param.PayMoney * -1,
				"commission": param.Commission * -1,
				//"orderMoney":       param.OrderMoney * -1,
				"orderCode":        params.OrderCode,
				"correctionReason": param.CorrectionReason,
				"createTime":       date.NowFormat(date.Date_Full_Layout),
				"createPerson":     jyutil.GetUserMsgFromCtx(ctx).EntUserName,
				"proceduresMoney":  param.ProceduresMoney * -1,
				"redType":          params.RedType,
			}
			newInsertData := map[string]interface{}{
				"payMoney":   param.PayMoney,
				"commission": param.Commission,
				//"orderMoney":       param.OrderMoney,
				"proceduresMoney":  param.ProceduresMoney,
				"orderCode":        params.OrderCode,
				"correctionReason": param.CorrectionReason,
				"createTime":       date.NowFormat(date.Date_Full_Layout),
				"createPerson":     jyutil.GetUserMsgFromCtx(ctx).EntUserName,
				"redType":          params.RedType,
			}
			var signingSubject string
			if param.SigningSubject == "北京剑鱼信息技术有限公司" {
				updateData["signing_subject"] = "h01"
				signingSubject = "北京拓普丰联信息科技股份有限公司"
			} else {
				updateData["signing_subject"] = "h02"
				signingSubject = "北京剑鱼信息技术有限公司"
			}

			oldInsertData["signingSubject"] = signingSubject
			newInsertData["newSigningSubject"] = param.SigningSubject

			insertDataArr = append(insertDataArr, oldInsertData, newInsertData)
		} else {
			commission += param.Commission
			proceduresMoney += param.ProceduresMoney
			isSubject = false
			newEnt := common.If(orderData.Map()["signing_subject"] == "h01", "北京剑鱼信息技术有限公司", "北京拓普丰联信息科技股份有限公司").(string)
			newEntData, err := g.DB().GetOne(ctx, fmt.Sprintf(`SELECT newSigningSubject FROM moneyCorrection WHERE orderCode = '%s' AND redType = '签约主体红冲' AND newSigningSubject is not null ORDER BY createTime DESC LIMIT 0,1 `, params.OrderCode))
			if err != nil && !newEntData.IsEmpty() {
				newEnt = common.InterfaceToStr(newEntData.Map()["newSigningSubject"])
			}
			var pMoney int
			if param.Id > 0 {
				activeData, _ := g.DB().GetOne(ctx, `SELECT final_price+(select IFNULL(sum(payMoney),0) as return_money from moneyCorrection where orderCode=? and detail_id = ?) as final_price FROM jy_order_detail WHERE id = ? and status =1`, params.OrderCode, param.Id, param.Id)
				if !activeData.IsEmpty() {
					pMoney = gconv.Int(activeData.Map()["final_price"])
				}
				insertData["payMoney"] = param.PayMoney - pMoney
			} else if param.ActiveCode != "" && param.PayMoney > 0 {
				activeData, _ := g.DB().GetOne(ctx, `SELECT sum(final_price)+(select IFNULL(sum(payMoney),0) as return_money from moneyCorrection where orderCode=? and activity_code = ?) as final_price FROM jy_order_detail WHERE activity_code = ? and order_code = ? and status =1`, params.OrderCode, param.ActiveCode, param.ActiveCode, params.OrderCode)
				if !activeData.IsEmpty() {
					pMoney = gconv.Int(activeData.Map()["final_price"])
				}
				insertData["payMoney"] = param.PayMoney - pMoney
			} else if param.Commission > 0 {
				insertData["commission"] = param.Commission - common.IntAll(orderData.Map()["commission"])
			}
			//}
			insertData["signingSubject"] = newEnt
			//insertData["orderMoney"] = param.OrderMoney - common.IntAll(orderData.Map()["order_money"])
			commission += param.Commission

			//proceduresMoney += param.ProceduresMoney
			//insertData["proceduresMoney"] = param.ProceduresMoney - common.IntAll(orderData.Map()["procedures_money"])
			insertDataArr = append(insertDataArr, insertData)
		}
	}
	if !isSubject {
		g.DB().Update(ctx, "contract", map[string]interface{}{"contract_money": params.PayMoney}, map[string]interface{}{"order_code": params.OrderCode})
		returnData, _ := g.DB().GetOne(ctx, fmt.Sprintf(`select IFNULL(sum(return_money),0) as return_money from return_money_record where order_code='%s' and state=1`, params.OrderCode))
		refundData, _ := g.DB().GetOne(ctx, fmt.Sprintf(`select IFNULL(sum(refund_money),0) as refund_money from refund_record where order_code='%s'`, params.OrderCode))
		return_money := common.IntAll(returnData.Map()["return_money"])
		refund_money := common.IntAll(refundData.Map()["refund_money"])
		if params.PayMoney-commission-proceduresMoney <= return_money-refund_money {
			updateData["return_status"] = 1
		} else if params.PayMoney-commission-proceduresMoney > return_money-refund_money && return_money-refund_money > 0 {
			updateData["return_status"] = 2
		}
		if return_money == refund_money && return_money > 0 {
			updateData["refund_status"] = 1
		} else if return_money > refund_money && refund_money > 0 {
			updateData["refund_status"] = 2
		}
		if refund_money >= params.PayMoney {
			updateData["refund_status"] = 1
		}
		if return_money >= params.PayMoney {
			updateData["return_status"] = 1
			productDetail, _ := g.DB().Ctx(ctx).Query(ctx, fmt.Sprintf(`SELECT * FROM jy_order_detail WHERE order_code ='%s' and returned_open =1 and is_service_open = 0 and status =1`, params.OrderCode))
			if !productDetail.IsEmpty() {
				uData, entId, userPositionId, err := jyutil.GetCreateUserData(gconv.String(orderData.Map()["user_phone"]), gconv.String(orderData.Map()["company_name"]), gconv.Int(orderData.Map()["buy_subject"]) == 2)
				if err != nil {
					return errors.New("用户创建失败")
				}
				//全额回款开通权益
				if !consts.PhoneRegex.MatchString(gconv.String(orderData["user_phone"])) {
					return errors.New("手机号格式异常")
				}
				if err = g.DB().Transaction(ctx, func(ctx context.Context, tx gdb.TX) error {
					// 产品服务开通
					for _, m := range productDetail.List() {
						if !jyutil.IsServiceOpen(m) {
							continue
						}
						//参数注入
						m["userMap"] = map[string]interface{}{
							"userData": uData, "entId": entId, "userPositionId": userPositionId,
						}
						m["phone"] = orderData.Map()["user_phone"]
						m["order_code"] = params.OrderCode
						m["reqCompanyName"] = orderData.Map()["company_name"]
						m["amount"] = m["final_price"]
						m["reqSubject"] = orderData.Map()["buy_subject"]
						m["linked_orderId"] = m["linked_detail_id"]
						productCode := gconv.String(m["product_code"])
						pFunc, err := product.JyProFunc.GetProductInitFuncByCode(productCode)
						if err != nil {
							return err
						}
						pObj, err := pFunc(m)
						if err != nil {
							return gerror.Wrap(err, fmt.Sprintf("获取%s商品异常", productCode))
						}
						if err := pObj.OpenService(ctx, time.Now()); err != nil {
							return err
						}
					}
					if orderUserId := gconv.String(orderData.Map()["user_id"]); orderUserId == "" || orderUserId != gconv.String(uData["userId"]) {
						log.Printf("同步更新订单用户身份:orderUserId:%s,userId:%s,entId:%d\n", orderUserId, uData["userId"], entId)
						upData := g.Map{
							"user_id": uData["userId"],
						}
						if entId > 0 { //企业服务
							upData["ent_id"] = entId
							if personPhone := gconv.String(orderData.Map()["personPhone"]); personPhone != "" {
								jyutil.EndAddUser(ctx, entId, gconv.String(orderData.Map()["user_phone"]), personPhone, gconv.String(orderData.Map()["personName"]))
							}
						}
						//更新订单
						_, err = g.DB().Update(ctx, consts.OrderListTableName, upData, "order_code=?", params.OrderCode)
						if err != nil {
							return err
						}
					}

					return nil
				}); err != nil {
					log.Println(err)
					return err
				}
			}
		}
		//红冲金额新增销售业绩
		if err := OrderMoneyMakeRed(ctx, params.OrderCode, int64(params.PayMoney-proceduresMoney-commission)); err != nil {
			log.Printf("业绩红冲 %s 业绩变更异常 %v\n", params.OrderCode, err)
			return err
		}
	}

	g.DB().Update(ctx, "dataexport_order", updateData, map[string]interface{}{"order_code": params.OrderCode})
	for _, m := range insertDataArr {
		g.DB().Insert(ctx, "moneyCorrection", m)
	}

	return nil
}