package payment

import (
	"context"
	"net/http"
	"sync"

	"github.com/gogf/gf/v2/errors/gerror"
	"github.com/gogf/gf/v2/frame/g"
	"github.com/gogf/gf/v2/os/gtime"
	"github.com/shopspring/decimal"

	"github.com/qianfree/team-api/internal/dao"
	"github.com/qianfree/team-api/internal/logic/billing"
	"github.com/qianfree/team-api/internal/logic/common"
	do "github.com/qianfree/team-api/internal/model/do"
)

// 订单级互斥锁，防止回调重复处理。
//
// 采用 sharded mutex（按 orderNo 哈希到固定数量分片）替代原先 sync.Map + 手工引用计数
// 的实现：原 UnlockOrder 在 rcm.mu.Unlock() 之后才 refCount--，存在「归零后误 Delete」的
// 竞态窗口——并发 LockOrder 在 Delete 前后可能拿到不同的 rcm 对象，导致两路回调各自持有
// 「订单锁」却互不互斥。sharded 方案无动态分配、无引用计数、无 Delete，内存恒定为分片数，
// 且同一 orderNo 必然命中同一分片 → 互斥语义对同一订单始终正确。跨实例并发由 DB 条件更新
// （WHERE status='pending'）兜底，进程内锁仅用于降低同实例并发回调时的 DB 竞争。
const orderLockShardCount = 256

var orderLockShards [orderLockShardCount]sync.Mutex

// orderLockShardIndex 按 orderNo 选定分片。FNV-1a 简单快速、分布均匀，避免不同订单扎堆。
func orderLockShardIndex(orderNo string) int {
	const (
		offset32 = uint32(2166136261)
		prime32  = uint32(16777619)
	)
	h := offset32
	for i := 0; i < len(orderNo); i++ {
		h ^= uint32(orderNo[i])
		h *= prime32
	}
	return int(h % orderLockShardCount)
}

// paymentAmountTolerance 回调金额与订单金额容差（0.01 CNY）。
// 用 decimal 表达，避免 float64 在 0.01 这种边界值上的二进制表示误差导致误判。
var paymentAmountTolerance = decimal.NewFromFloat(0.01)

// LockOrder 对订单号加锁（按 orderNo 哈希到固定分片，同订单始终命中同一分片）。
func LockOrder(orderNo string) {
	orderLockShards[orderLockShardIndex(orderNo)].Lock()
}

// UnlockOrder 释放订单锁。
func UnlockOrder(orderNo string) {
	orderLockShards[orderLockShardIndex(orderNo)].Unlock()
}

// ProcessCallback 统一回调处理流程。
// channelType 为渠道类型字符串（如 "epay"）。
func ProcessCallback(ctx context.Context, r *http.Request, channelType string) error {
	// 1. 从 sys_options 加载渠道配置
	cfg, err := GetChannelConfigAndProvider(ctx, channelType)
	if err != nil {
		return gerror.Wrapf(err, "加载支付渠道配置失败")
	}

	// 2. 获取 Provider
	provider := GetProvider(channelType)
	if provider == nil {
		return gerror.Newf("不支持的支付渠道: %s", channelType)
	}

	// 3. 调用 Provider 验签并解析回调
	result, err := provider.HandleCallback(ctx, r, cfg)
	if err != nil {
		return gerror.Wrapf(err, "回调验证失败")
	}

	// 4. 订单级加锁
	LockOrder(result.OrderNo)
	defer UnlockOrder(result.OrderNo)

	// 5. 读取订单当前状态与支付信息（可履约性判断见下方 claimable）
	var order *struct {
		ID          int64       `json:"id"`
		Status      string      `json:"status"`
		FinalAmount float64     `json:"final_amount"`
		PaymentNo   string      `json:"payment_no"`
		ExpiredAt   *gtime.Time `json:"expired_at"`
	}
	err = dao.OrdOrders.Ctx(ctx).
		Where("order_no", result.OrderNo).Scan(&order)
	if err != nil {
		return gerror.Wrapf(err, "查询订单失败")
	}
	if order == nil {
		return common.NewNotFoundError("订单")
	}
	// 5. 幂等 / 可履约状态检查。
	// 可履约状态：pending，以及「支付成功但订单已被过期任务置为 expired」——用户在渠道
	// 完成扣款可能晚于订单有效期（或回调延迟到达），此时渠道已实际收款，拒绝入账会造成
	// 用户已付款却得不到权益，只能人工兜底；因此过期订单的成功回调照常履约，仅记告警日志。
	// 其余状态（paid/fulfilled/cancelled/refunded 等）幂等返回。
	claimable := order.Status == "pending" || (result.Success && order.Status == "expired")
	if !claimable {
		if result.Success && order.Status == "cancelled" {
			// 渠道已收款但订单已被取消：无法自动履约，记录告警等待人工处理（线下退款或补单）
			g.Log().Errorf(ctx, "[Payment] order=%s status=cancelled but received SUCCESS callback (trade_no=%s amount=%.2f), money captured without fulfillment, manual intervention required",
				result.OrderNo, result.TradeNo, result.PaidAmount)
		}
		// 重复支付检测：订单已 paid/fulfilled，又收到【不同流水号】的成功回调——说明用户
		// 对同一订单在多个渠道/多次完成了支付，渠道端已重复收款，第二笔在系统内无对应
		// 入账，必须人工在渠道侧退回。幂等吞掉不留痕会造成资金无声滞留。
		if result.Success && (order.Status == "paid" || order.Status == "fulfilled") &&
			result.TradeNo != "" && result.TradeNo != order.PaymentNo {
			g.Log().Errorf(ctx, "[Payment] order=%s already %s with trade_no=%s but received ANOTHER success callback trade_no=%s amount=%.2f, duplicate payment captured, manual refund required",
				result.OrderNo, order.Status, order.PaymentNo, result.TradeNo, result.PaidAmount)
		}
		return nil // 已处理或不可履约终态，幂等返回
	}
	if result.Success && (order.Status == "expired" ||
		(order.ExpiredAt != nil && !order.ExpiredAt.IsZero() && order.ExpiredAt.Before(gtime.Now()))) {
		g.Log().Warningf(ctx, "[Payment] order=%s paid after expiration, proceed with fulfillment", result.OrderNo)
	}

	// 6. 金额校验：回调金额与订单金额必须一致（容差 0.01 元，CNY）
	//    用 decimal 比较，避免 float64 直接相减在边界值（如 0.01）上的二进制误差误判。
	if result.Success && result.PaidAmount > 0 && order.FinalAmount > 0 {
		paid := billing.NewFromFloat(result.PaidAmount)
		expected := billing.NewFromFloat(order.FinalAmount)
		diff := paid.Sub(expected).Abs()
		if diff.GreaterThan(paymentAmountTolerance) {
			g.Log().Warningf(ctx, "[Payment] amount mismatch: order=%s expected=%.2f received=%.2f",
				result.OrderNo, order.FinalAmount, result.PaidAmount)
			return gerror.Newf("支付金额不一致: 期望 %.2f 实付 %.2f", order.FinalAmount, result.PaidAmount)
		}
	}

	if result.Success {
		// 7. 原子领取订单：pending/expired → paid。
		// 该条件更新的 RowsAffected 是【跨实例】幂等闸门：多实例并发回调时，两个回调都会
		// 通过上面第 5 步的状态检查，但条件原子更新只有一个能命中（另一个在行锁释放后重读
		// 到 status 已是 paid → 0 行）。据此仅让真正把订单翻成 paid 的那次回调去履约，
		// 杜绝重复入账/重复发套餐。进程内 orderLockShards 仅单实例有效，不能作为并发保护依赖。
		// expired 一并纳入条件：过期订单的成功回调照常入账（见第 5 步说明），
		// 同时覆盖「第 5 步读到 pending、过期任务随后将其置 expired」的竞态窗口。
		res, err := dao.OrdOrders.Ctx(ctx).
			Where("id", order.ID).
			WhereIn("status", g.Slice{"pending", "expired"}).
			Data(do.OrdOrders{
				Status:    "paid",
				PaidAt:    gtime.Now(),
				PaymentNo: result.TradeNo,
			}).Update()
		if err != nil {
			return gerror.Wrapf(err, "更新订单状态失败")
		}
		affected, err := res.RowsAffected()
		if err != nil {
			return gerror.Wrapf(err, "确认订单状态更新结果失败")
		}
		if affected == 0 {
			// 另一并发回调已抢先领取并负责履约，本次幂等返回，绝不重复履约
			g.Log().Infof(ctx, "[Payment] order=%s already claimed by a concurrent callback, skip duplicate fulfill", result.OrderNo)
			return nil
		}

		// 8. 履约（仅领取成功者执行）
		return FulfillOrder(ctx, order.ID)
	}

	return nil
}

// QueryOrderPaid 查询订单是否已完成支付（paid 或 fulfilled）。
// 用于浏览器同步回跳时展示结果，不参与履约处理。
func QueryOrderPaid(ctx context.Context, orderNo string) bool {
	if orderNo == "" {
		return false
	}
	var status string
	_ = dao.OrdOrders.Ctx(ctx).
		Where("order_no", orderNo).
		Fields("status").
		Scan(&status)
	return status == "paid" || status == "fulfilled"
}