package store_test

import (
	"errors"
	"testing"
	"time"

	"github.com/wangjia/pay/internal/model"
	"github.com/wangjia/pay/internal/store"
)

func TestGetOrderAndAttemptByRef(t *testing.T) {
	s := store.NewOrderStore(model.OpenTestDB(t))
	seedOrder(t, s, "PAY-Q1") // 复用 order_test.go 的 seedOrder(建 order + attempt provider_ref="P-PAY-Q1")

	o, err := s.GetOrder("PAY-Q1")
	if err != nil || o.OutTradeNo != "PAY-Q1" {
		t.Fatalf("GetOrder = %+v, %v", o, err)
	}
	if _, err := s.GetOrder("NOPE"); !errors.Is(err, store.ErrOrderNotFound) {
		t.Fatalf("缺单应 ErrOrderNotFound, got %v", err)
	}

	att, err := s.AttemptByProviderRef("P-PAY-Q1")
	if err != nil || att.OutTradeNo != "PAY-Q1" || att.Channel != "crypto" {
		t.Fatalf("AttemptByProviderRef = %+v, %v", att, err)
	}
	if _, err := s.AttemptByProviderRef("P-UNKNOWN"); !errors.Is(err, store.ErrAttemptNotFound) {
		t.Fatalf("缺尝试应 ErrAttemptNotFound, got %v", err)
	}
}

func TestListPendingAndExpire(t *testing.T) {
	s := store.NewOrderStore(model.OpenTestDB(t))
	seedOrder(t, s, "PAY-Q2")

	pending, err := s.ListAttemptsByStatus(model.AttemptPending, 10)
	if err != nil || len(pending) != 1 {
		t.Fatalf("ListAttemptsByStatus pending = %d, %v", len(pending), err)
	}

	n, err := s.ExpirePendingAttempts("PAY-Q2")
	if err != nil || n != 1 {
		t.Fatalf("ExpirePendingAttempts = %d, %v", n, err)
	}
	pending2, _ := s.ListAttemptsByStatus(model.AttemptPending, 10)
	if len(pending2) != 0 {
		t.Fatalf("弃过期后应无 pending, got %d", len(pending2))
	}
	_ = time.Now
}

func TestExpireStaleOrders(t *testing.T) {
	db := model.OpenTestDB(t)
	s := store.NewOrderStore(db)
	now := time.Date(2026, 7, 10, 12, 0, 0, 0, time.UTC)

	// 三张单:旧 pending(应过期)、新 pending(未到点)、旧 paid(不动)。
	mk := func(no string, st model.OrderStatusV2, createdAgo time.Duration) {
		o := &model.OrderV2{OutTradeNo: no, AmountMinor: 100, Currency: "USDT", Status: st}
		if err := s.CreateOrder(o); err != nil {
			t.Fatalf("create %s: %v", no, err)
		}
		// 直接回填 created_at 制造账龄(GORM 默认写 now)。
		if err := db.Model(&model.OrderV2{}).Where("out_trade_no = ?", no).
			Update("created_at", now.Add(-createdAgo)).Error; err != nil {
			t.Fatalf("backdate %s: %v", no, err)
		}
	}
	mk("STALE", model.OrderPendingV2, 2*time.Hour)   // 旧 pending
	mk("FRESH", model.OrderPendingV2, 5*time.Minute) // 新 pending
	mk("PAID", model.OrderPaidV2, 2*time.Hour)       // 旧 paid

	cutoff := now.Add(-time.Hour) // TTL=1h
	n, err := s.ExpireStaleOrders(cutoff, 500)
	if err != nil {
		t.Fatalf("expire: %v", err)
	}
	if n != 1 {
		t.Fatalf("应关闭 1 张(仅 STALE), got %d", n)
	}
	assertStatus := func(no string, want model.OrderStatusV2) {
		o, _ := s.GetOrder(no)
		if o.Status != want {
			t.Fatalf("%s status = %v, want %v", no, o.Status, want)
		}
	}
	assertStatus("STALE", model.OrderExpiredV2)
	assertStatus("FRESH", model.OrderPendingV2)
	assertStatus("PAID", model.OrderPaidV2)

	// 幂等:再跑一次不再关闭(STALE 已非 pending)。
	if n2, _ := s.ExpireStaleOrders(cutoff, 500); n2 != 0 {
		t.Fatalf("重跑应 0, got %d", n2)
	}
}

func TestSumPaidAttemptMinorByAccountSince(t *testing.T) {
	db := model.OpenTestDB(t)
	s := store.NewOrderStore(db)
	now := time.Date(2026, 7, 10, 12, 0, 0, 0, time.UTC)
	dayStart := time.Date(2026, 7, 10, 0, 0, 0, 0, time.UTC)

	mk := func(no, acct string, minor int64, st model.AttemptStatus, paidAgo time.Duration) {
		paid := now.Add(-paidAgo)
		a := &model.Attempt{OutTradeNo: no, Channel: "alipay", AccountID: acct, ProviderRef: "R-" + no,
			AmountMinor: minor, Currency: "CNY", Status: st, PaidAt: &paid}
		if err := s.CreateAttempt(a); err != nil {
			t.Fatalf("attempt %s: %v", no, err)
		}
	}
	mk("A", "acct-1", 10000, model.AttemptPaid, 1*time.Hour)      // 今日,计入
	mk("B", "acct-1", 5000, model.AttemptPaid, 2*time.Hour)       // 今日,计入 → acct-1=15000
	mk("C", "acct-2", 7000, model.AttemptPaid, 30*time.Minute)    // 今日 acct-2=7000
	mk("D", "acct-1", 9999, model.AttemptPending, 10*time.Minute) // 未付,不计
	mk("E", "acct-1", 8888, model.AttemptPaid, 20*time.Hour)      // 昨天(paid_at < dayStart),不计

	got, err := s.SumPaidAttemptMinorByAccountSince(dayStart)
	if err != nil {
		t.Fatalf("sum: %v", err)
	}
	if got["acct-1"] != 15000 || got["acct-2"] != 7000 {
		t.Fatalf("聚合 = %+v, want acct-1=15000 acct-2=7000", got)
	}
}

func TestListRecentlyPaidAttempts(t *testing.T) {
	db := model.OpenTestDB(t)
	s := store.NewOrderStore(db)
	now := time.Date(2026, 7, 10, 12, 0, 0, 0, time.UTC)
	mk := func(no string, st model.AttemptStatus, paidAgo time.Duration) {
		paid := now.Add(-paidAgo)
		_ = s.CreateAttempt(&model.Attempt{OutTradeNo: no, Channel: "fake", ProviderRef: "R-" + no,
			AmountMinor: 100, Currency: "USDT", Status: st, PaidAt: &paid})
	}
	mk("RECENT", model.AttemptPaid, 10*time.Minute) // 近期已付 → 命中
	mk("OLD", model.AttemptPaid, 5*time.Hour)       // 太旧 → 不命中
	mk("PEND", model.AttemptPending, 1*time.Minute) // 未付 → 不命中

	got, err := s.ListRecentlyPaidAttempts(now.Add(-time.Hour), 50)
	if err != nil {
		t.Fatalf("list: %v", err)
	}
	if len(got) != 1 || got[0].OutTradeNo != "RECENT" {
		t.Fatalf("只应含 RECENT, got %+v", got)
	}
}

// TestListOrdersByStatus 供 P6+P4 义务的「退款修复扫描」定位候选订单:按状态集合
// 列订单(如 refunding/partially_refunded),与 refund 表的 succeeded 记录取并集
// 作为重算候选。
func TestListOrdersByStatus(t *testing.T) {
	db := model.OpenTestDB(t)
	s := store.NewOrderStore(db)
	mk := func(no string, st model.OrderStatusV2) {
		_ = s.CreateOrder(&model.OrderV2{OutTradeNo: no, AmountMinor: 100, Currency: "CNY", Status: st})
	}
	mk("O-PAID", model.OrderPaidV2)
	mk("O-REFUNDING", model.OrderRefundingV2)
	mk("O-PART", model.OrderPartRefundedV2)
	mk("O-DONE", model.OrderRefundedV2)
	mk("O-PENDING", model.OrderPendingV2)

	got, err := s.ListOrdersByStatus([]model.OrderStatusV2{model.OrderRefundingV2, model.OrderPartRefundedV2}, 50)
	if err != nil {
		t.Fatalf("list: %v", err)
	}
	if len(got) != 2 {
		t.Fatalf("应命中 2 张(REFUNDING/PART), got %d: %+v", len(got), got)
	}
	seen := map[string]bool{}
	for _, o := range got {
		seen[o.OutTradeNo] = true
	}
	if !seen["O-REFUNDING"] || !seen["O-PART"] {
		t.Fatalf("命中集合不对: %+v", got)
	}
}

// TestListOrdersByStatusSinceExcludesStale 钉住回溯窗:updated_at 早于 since 的订单
// 不应入候选(防 refunding/partially_refunded 长期驻留占满 LIMIT 名额——见 RefundApplyTask)。
func TestListOrdersByStatusSinceExcludesStale(t *testing.T) {
	db := model.OpenTestDB(t)
	s := store.NewOrderStore(db)
	now := time.Now()
	stale := now.Add(-72 * time.Hour)
	fresh := now.Add(-time.Hour)

	if err := s.CreateOrder(&model.OrderV2{OutTradeNo: "O-STALE", AmountMinor: 100, Currency: "CNY", Status: model.OrderRefundingV2}); err != nil {
		t.Fatal(err)
	}
	if err := db.Model(&model.OrderV2{}).Where("out_trade_no = ?", "O-STALE").Update("updated_at", stale).Error; err != nil {
		t.Fatal(err)
	}
	if err := s.CreateOrder(&model.OrderV2{OutTradeNo: "O-FRESH", AmountMinor: 100, Currency: "CNY", Status: model.OrderRefundingV2}); err != nil {
		t.Fatal(err)
	}
	if err := db.Model(&model.OrderV2{}).Where("out_trade_no = ?", "O-FRESH").Update("updated_at", fresh).Error; err != nil {
		t.Fatal(err)
	}

	got, err := s.ListOrdersByStatusSince([]model.OrderStatusV2{model.OrderRefundingV2}, now.Add(-48*time.Hour), 50)
	if err != nil {
		t.Fatalf("list: %v", err)
	}
	if len(got) != 1 || got[0].OutTradeNo != "O-FRESH" {
		t.Fatalf("只应命中窗内的 O-FRESH, got %+v", got)
	}
}

// TestListAttemptsByChannelSince 供 orphan 扫描构造"已知期望金额集":同渠道、
// created_at>=since、任意状态的 attempt(pending/paid/expired 都算——凡 pay
// 合法签发过的金额都不算孤儿)。
func TestListAttemptsByChannelSince(t *testing.T) {
	db := model.OpenTestDB(t)
	s := store.NewOrderStore(db)
	now := time.Date(2026, 7, 10, 12, 0, 0, 0, time.UTC)
	mk := func(no, ch string, ago time.Duration) {
		_ = s.CreateAttempt(&model.Attempt{OutTradeNo: no, Channel: ch, ProviderRef: "R-" + no,
			AmountMinor: 100, Currency: "USDT", Status: model.AttemptPending})
		_ = db.Model(&model.Attempt{}).Where("out_trade_no = ?", no).Update("created_at", now.Add(-ago)).Error
	}
	mk("C1", "crypto", 10*time.Minute)
	mk("C2", "crypto", 5*time.Hour) // 太旧
	mk("A1", "alipay", 1*time.Minute)

	got, err := s.ListAttemptsByChannelSince("crypto", now.Add(-time.Hour), 100)
	if err != nil {
		t.Fatalf("list: %v", err)
	}
	if len(got) != 1 || got[0].OutTradeNo != "C1" {
		t.Fatalf("只应含近期 crypto, got %+v", got)
	}
}

// TestMarkDisputed 覆盖 P8 Task6 打标:条件 UPDATE 只在 disputed=false 时翻转,重投同一
// dispute(第二次调用)幂等 no-op(rows_affected=0,不报错)。
func TestMarkDisputed(t *testing.T) {
	s := store.NewOrderStore(model.OpenTestDB(t))
	seedOrder(t, s, "PAY-Q3")

	flipped, err := s.MarkDisputed("PAY-Q3")
	if err != nil || !flipped {
		t.Fatalf("first MarkDisputed: flipped=%v err=%v", flipped, err)
	}
	o, err := s.GetOrder("PAY-Q3")
	if err != nil || !o.Disputed {
		t.Fatalf("order after MarkDisputed = %+v, %v", o, err)
	}

	// 重投同一 dispute → 幂等 no-op,不报错。
	again, err := s.MarkDisputed("PAY-Q3")
	if err != nil || again {
		t.Fatalf("dup MarkDisputed: again=%v err=%v", again, err)
	}
}