package timedTask

import (
	"app.yhyue.com/moapp/jybase/redis"
	"context"
	"encoding/json"
	"fmt"
	"github.com/gogf/gf/v2/errors/gerror"
	"github.com/gogf/gf/v2/frame/g"
	"github.com/gogf/gf/v2/util/gconv"
	"jyOrderManager/internal/jyutil"
	"jyOrderManager/internal/logic/order"
	"jyOrderManager/internal/logic/product"
	"log"
	"math"
	"net/rpc"
	"regexp"
	"strings"
	"time"
)

var (
	reg = regexp.MustCompile("[\\s()]+")
)

type FilterStr struct {
	PaybackNum     int
	paybackListArr []map[string]interface{}
}

func AutomaticPayment() {
	var ctx = context.Background()
	log.Println("自动回款匹配。。。开始")
	query := `select * from cbs.transaction where ISRELATION = 0 and OTHNAM is not null  and  OTHNAM != "" order by id`
	data, _ := g.DB().Query(ctx, query)
	if !data.IsEmpty() {
		returnOrderMap := make(map[string]int)
		orderData, _ := g.DB().Query(ctx, `SELECT
	a.*,
	b.paybackNum,
	b.paybackList 
FROM
	dataexport_order a
	LEFT JOIN (
	SELECT
		order_code,
		JSON_EXTRACT( plantList, "$.paybackNum" ) AS paybackNum,
		JSON_EXTRACT( plantList, "$.paybackList" ) AS paybackList 
	FROM
		return_money_plant 
	WHERE
		state != -1 and JSON_VALID( plantList ) 
	) b ON a.order_code = b.order_code 
WHERE
	( a.return_status = 0 OR a.return_status = 2 ) 
	AND a.audit_status = 3 
	AND ( a.order_status = 1 OR a.order_status = 0 )`)
		returnOrderData, _ := g.DB().Query(ctx, `SELECT order_code, COUNT(*) as total_count FROM return_money_record WHERE state =1   GROUP BY order_code `)
		if !returnOrderData.IsEmpty() {
			for _, i2 := range returnOrderData.List() {
				returnOrderMap[gconv.String(i2["order_code"])] = gconv.Int(i2["total_count"])
			}
		}
		filterMap := make(map[string]FilterStr)
		if !orderData.IsEmpty() { //优化 获取filter字段中的数据
			for _, o := range orderData.List() {
				var paybackList string
				if pList := gconv.String(o["paybackList"]); pList != "" && pList != `""` && strings.Contains(pList, "合计") {
					paybackList = strings.ReplaceAll(pList[1:len(pList)-1], "\\", "")
				}
				var paybackListArr []map[string]interface{}
				if paybackList != "" {
					_ = json.Unmarshal([]byte(paybackList), &paybackListArr)
				}
				paybackNum := strings.ReplaceAll(gconv.String(o["paybackNum"]), `"`, "")
				filterMap[gconv.String(o["order_code"])] = FilterStr{
					gconv.Int(paybackNum),
					paybackListArr,
				}
			}
		}
		for _, v := range data.List() {
			returnMoney := int(math.Floor(float64(float64(gconv.Float64(v["TRSBAL"]))*100) + 0.5))
			companyName := gconv.String(v["OTHNAM"])
			remark := gconv.String(v["TXTDSM"])
			remarks := gconv.String(v["NUSAGE"])
			id := gconv.Int(v["id"])
			returnTime := gconv.String(v["BNKTIM"])
			BNKFLW := gconv.String(v["BNKFLW"])
			BNKNAM := gconv.String(v["BNKNAM"])
			if !orderData.IsEmpty() {
				for _, o := range orderData.List() {
					//filterMap := make(map[string]interface{})
					//_ = json.Unmarshal([]byte(gconv.String(o["filter"])), &filterMap)
					money := gconv.Int(o["pay_money"]) - gconv.Int(o["commission"]) - gconv.Int(o["procedures_money"])
					paymentUser := gconv.String(o["payment_user"])
					if paymentUser == "" {
						paymentUser = gconv.String(o["company_name"])
					}
					orderCode := gconv.String(o["order_code"])
					if PaymentPlanMatching(money, returnMoney, paymentUser, companyName, remark, remarks, orderCode, filterMap[orderCode].PaybackNum, filterMap[orderCode].paybackListArr, returnOrderMap) {
						isExists, err := redis.Exists("qmx_filter", "qmx_auto_return_"+fmt.Sprint(id))
						if !isExists || err != nil {
							log.Println("自动回款匹配成功", id, orderCode)
							var returned_money int
							if calculation, _ := g.DB().GetOne(ctx, fmt.Sprintf("SELECT SUM(return_money) as returned_money  FROM return_money_record WHERE order_code=%s AND state=1", orderCode)); !calculation.IsEmpty() {
								returned_money = gconv.Int(calculation.Map()["returned_money"])
							}
							//isFirstReturn := config.JysqlDB.Count("return_money_record", map[string]interface{}{"state": 1, "order_code": orderCode}) == 0
							returnReq, _ := g.DB().Insert(ctx, "return_money_record", map[string]interface{}{
								"order_code":            orderCode,
								"return_time":           returnTime,
								"return_money":          returnMoney,
								"return_type":           3,
								"return_invoice_status": 0,
								"operate_time":          time.Now().Format("2006-01-02 15:04:05"),
								"flow_money":            returnMoney,
								"bank_name":             BNKNAM,
								"bank_flow":             BNKFLW,
								"operate_type":          2,
								"state":                 1,
								"pay_account_name":      paymentUser,
							})
							returnId, _ := returnReq.LastInsertId()
							//计算已回款金额
							if returned_money == 0 {
								if err := order.CommonChange(ctx, orderCode, returnTime, order.ReturnMoney); err != nil {
									log.Printf("%s 回款销售业绩生效异常 %v", orderCode, err)
									continue
								}
							}
							updateData := map[string]interface{}{"return_status": 2, "order_status": 1}
							if returned_money+returnMoney == money {
								redis.Put("qmx_filter", "qmx_auto_return_"+fmt.Sprint(id), 1, 3600)
								updateData["return_status"] = 1
							}
							if returnId > 0 {
								log.Println("自动回款创建回款记录成功", id, orderCode)
								g.DB().Update(ctx, "dataexport_order", updateData, map[string]interface{}{"order_code": orderCode})
								g.DB().Update(ctx, "transaction", map[string]interface{}{"ISRELATION": 1, "return_id": fmt.Sprint(returnId)}, map[string]interface{}{"id": id})
								log.Println("自动回款开通权益", orderCode, gconv.Int(o["return_status"]), updateData["return_status"], returned_money, returnMoney, money)
								if gconv.Int(o["return_status"]) != 1 && updateData["return_status"] == 1 {
									productDetail, err := g.DB().Ctx(ctx).Query(ctx, fmt.Sprintf(`SELECT * FROM jy_order_detail WHERE order_code ='%s' and returned_open =1`, orderCode))
									if err != nil || productDetail.IsEmpty() {
										continue
									}
									// 产品服务开通
									for _, m := range productDetail.List() {
										if !jyutil.IsServiceOpen(m) {
											continue
										}
										//参数注入
										m["phone"] = o["user_phone"]
										m["order_code"] = orderCode
										m["amount"] = m["final_price"]
										m["reqCompanyName"] = o["company_name"]
										m["reqSubject"] = o["buy_subject"]
										productCode := gconv.String(m["product_code"])
										pFunc, err := product.JyProFunc.GetProductInitFuncByCode(productCode)
										if err != nil {
											continue
										}
										pObj, err := pFunc(m)
										if err != nil {
											gerror.Wrap(err, fmt.Sprintf("获取%s商品异常", productCode))
											continue
										}
										if err = pObj.OpenService(ctx, time.Now()); err != nil {
											continue
										}
									}
								}

							} else {
								log.Println("自动回款创建回款记录失败", id, orderCode)
							}
						} else {
							log.Println("自动回款重复匹配过滤", id, orderCode)
						}
						//回款关闭相应的支付码支付
						go CancelOnlinePay(ctx, orderCode)
					}
				}
			}
		}
	} else {
		log.Println("回款信息查询为空")
	}
	log.Println("自动回款匹配。。。结束")
}

// PaymentPlanMatching 回款计划匹配
func PaymentPlanMatching(money, returnMoney int, paymentUser, companyName, remark, remarks, orderCode string, paybackNum int, paybackListArr []map[string]interface{}, returnOrderMap map[string]int) bool {
	pUser := reg.ReplaceAllString(paymentUser, "")
	if money == returnMoney && (pUser == companyName || remark == orderCode || remarks == orderCode) {
		return true
	}
	if paybackNum > 1 { //仅订单回款计划有多期时，才匹配回款计划，回款计划如只有1期，则无需匹配

		isFirstReturn := returnOrderMap[orderCode]
		if isFirstReturn < paybackNum && len(paybackListArr) > 0 && len(paybackListArr) >= isFirstReturn {
			//②　如该订单已有X笔回款，则匹配第“X+1”期的回款计划，其他期的回款计划不进行匹配，例如：该笔订单无回款，则匹配第1期的回款计划；该笔订单有1笔回款，则匹配第2期的回款计划。
			if gconv.String(paybackListArr[isFirstReturn]["code"]) != "合计" && returnMoney == gconv.Int(paybackListArr[isFirstReturn]["money"])*100 && (pUser == companyName) {
				return true
			}
		}
		//}
	}
	return false
}

func CancelOnlinePay(ctx context.Context, orderCode string) {
	if total, _ := g.DB().Ctx(ctx).Query(ctx, "SELECT count(*) from return_money_online WHERE  status=0 and order_code=? and expire_time >?", orderCode, time.Now().Format("2006-01-02 15:04:05")); !total.IsEmpty() {
		r, err := rpc.DialHTTP("tcp", g.Cfg().MustGet(context.Background(), "jyPayRpc").String())
		defer r.Close()
		res := ""
		err = r.Call("JyPayRpc.CloseReturnOrder", orderCode, &res)
		if err != nil {
			log.Printf("%s关闭支付宝微信支付码失败 %s", orderCode, err)
		}
	}
}