package withdrawal

import (
	"context"
	"errors"
	"testing"
	"time"

	"hfb_sys/backend/internal/database"
	"hfb_sys/backend/internal/model"
	"hfb_sys/backend/internal/modules/wallet"
	"hfb_sys/backend/pkg/crypto"

	"gorm.io/gorm"
	"gorm.io/gorm/logger"
)

type withdrawalFixture struct {
	db        *gorm.DB
	repo      *Repository
	userID    uint64
	adminID   uint64
	accountID uint64
}

func newWithdrawalFixture(t *testing.T) withdrawalFixture {
	t.Helper()
	db := database.NewTestDB()
	if err := database.AutoMigrateIfMissing(db,
		&model.User{},
		&model.AdminUser{},
		&model.UserPaymentAccount{},
		&model.WithdrawalRequest{},
		&model.WalletAccount{},
		&model.WalletLedger{},
		&model.RentalListing{},
		&model.RentalOrder{},
		&model.GameAccount{},
		&model.AdminPickup{},
		&model.AdminPickupFinancialAdjustment{},
		&model.DistributionSite{},
	); err != nil {
		t.Fatalf("migrate fixture: %v", err)
	}

	user := model.User{Phone: "13800000001", Nickname: "test-user", Status: "active"}
	admin := model.AdminUser{Username: "reviewer", PasswordHash: "test", Nickname: "reviewer", Status: "active"}
	if err := db.Create(&user).Error; err != nil {
		t.Fatalf("create user: %v", err)
	}
	if err := db.Create(&admin).Error; err != nil {
		t.Fatalf("create admin: %v", err)
	}
	account := model.UserPaymentAccount{
		UserID: user.ID, AccountType: "bank", AccountName: "Test User",
		AccountNo: "6222021234567890", BankName: "Test Bank", Status: "active",
	}
	if err := db.Create(&account).Error; err != nil {
		t.Fatalf("create payment account: %v", err)
	}
	if err := db.Create(&model.WalletAccount{
		UserID: user.ID, AvailableBalanceCent: 100_000, Status: "active",
	}).Error; err != nil {
		t.Fatalf("create wallet: %v", err)
	}

	return withdrawalFixture{
		db: db, repo: NewRepository(db, wallet.NewRepository(db), &crypto.MockEncryptor{}),
		userID: user.ID, adminID: admin.ID, accountID: account.ID,
	}
}

type withdrawalQueryCounter struct {
	logger.Interface
	count int
}

func (c *withdrawalQueryCounter) Trace(_ context.Context, _ time.Time, fc func() (string, int64), _ error) {
	c.count++
	fc()
}

func TestAdminListUsesBatchQueries(t *testing.T) {
	f := newWithdrawalFixture(t)
	for i := 0; i < 5; i++ {
		item := model.WithdrawalRequest{
			WithdrawNo:       "WD-BATCH-" + string(rune('A'+i)),
			UserID:           f.userID,
			AmountCent:       int64(1000 + i),
			ActualAmountCent: int64(1000 + i),
			AccountType:      "bank",
			AccountName:      "Test User",
			AccountNo:        "****0000",
			Status:           "pending",
		}
		if err := f.db.Create(&item).Error; err != nil {
			t.Fatalf("create withdrawal: %v", err)
		}
	}

	counter := &withdrawalQueryCounter{Interface: logger.Default.LogMode(logger.Silent)}
	repo := NewRepository(f.db.Session(&gorm.Session{Logger: counter}), f.repo.walletRepo, f.repo.encryptor)
	result, err := repo.AdminList(context.Background(), AdminListQuery{Page: 1, Size: 20})
	if err != nil {
		t.Fatalf("AdminList failed: %v", err)
	}
	if len(result.Items) != 5 {
		t.Fatalf("AdminList items = %d, want 5", len(result.Items))
	}
	if counter.count > 4 {
		t.Fatalf("AdminList queries = %d, want batch queries (<=4)", counter.count)
	}
}

func TestAdminReviewContextSummarizesIncomeAndHistory(t *testing.T) {
	f := newWithdrawalFixture(t)
	renter := model.User{Phone: "13800000002", Nickname: "renter", Status: "active"}
	if err := f.db.Create(&renter).Error; err != nil {
		t.Fatal(err)
	}
	account := model.GameAccount{OwnerID: f.userID, ServerRegion: "cn", LoginPlatform: "pc", Title: "审核订单"}
	if err := f.db.Create(&account).Error; err != nil {
		t.Fatal(err)
	}
	listing := model.RentalListing{ListingNo: "202610280362", AccountID: account.ID, OwnerID: f.userID, Status: "active"}
	if err := f.db.Create(&listing).Error; err != nil {
		t.Fatal(err)
	}

	orders := []model.RentalOrder{
		{OrderNo: "RO-WALLET", ListingID: listing.ID, AccountID: account.ID, OwnerID: f.userID, RenterID: renter.ID, Status: "completed", SettlementStatus: "settled", SettlementMode: "owner_wallet", RentAmountCent: 1000, OwnerRentAmountCent: 700},
		{OrderNo: "RO-PLATFORM", ListingID: listing.ID, AccountID: account.ID, OwnerID: f.userID, RenterID: renter.ID, Status: "completed", SettlementStatus: "arbitrated", SettlementMode: "platform_managed", RentAmountCent: 200, OwnerRentAmountCent: 100, OfflineSettlementStatus: "settled", OfflineSettlementAmountCent: 100},
		{OrderNo: "RO-OPEN", ListingID: listing.ID, AccountID: account.ID, OwnerID: f.userID, RenterID: renter.ID, Status: "renting", SettlementStatus: "unsettled", SettlementMode: "owner_wallet"},
	}
	for i := range orders {
		if err := f.db.Create(&orders[i]).Error; err != nil {
			t.Fatalf("create order: %v", err)
		}
	}

	orderID := orders[0].ID
	ledgers := []model.WalletLedger{
		{LedgerNo: "WL-OWNER-INCOME", UserID: f.userID, OrderID: &orderID, Direction: "in", AmountCent: 700, BalanceType: "available", BizType: "owner_income", BizNo: "RO-WALLET"},
		{LedgerNo: "WL-DEPOSIT-COMP", UserID: f.userID, OrderID: &orderID, Direction: "in", AmountCent: 50, BalanceType: "available", BizType: "deposit_compensation", BizNo: "RO-WALLET"},
	}
	if err := f.db.Create(&ledgers).Error; err != nil {
		t.Fatal(err)
	}

	now := time.Now()
	pickups := []model.AdminPickup{
		{PickupNo: "PK-WALLET", ListingID: listing.ID, AccountID: account.ID, OwnerID: f.userID, AdminID: f.adminID, Status: "completed", SettlementMode: "owner_wallet", SettleAmountCent: 200, CompletedAt: &now},
		{PickupNo: "PK-PLATFORM", ListingID: listing.ID, AccountID: account.ID, OwnerID: f.userID, AdminID: f.adminID, Status: "completed", SettlementMode: "platform_managed", SettleAmountCent: 100, OfflineSettlementStatus: "settled", CompletedAt: &now},
	}
	if err := f.db.Create(&pickups).Error; err != nil {
		t.Fatal(err)
	}
	adjustments := []model.AdminPickupFinancialAdjustment{
		{PickupID: pickups[0].ID, SettleDeltaCent: 50, SettlementMode: "owner_wallet", Status: "settled", Reason: "补款", CreatedBy: f.adminID},
		{PickupID: pickups[1].ID, SettleDeltaCent: 20, SettlementMode: "platform_managed", Status: "settled", Reason: "补款", CreatedBy: f.adminID},
	}
	if err := f.db.Create(&adjustments).Error; err != nil {
		t.Fatal(err)
	}

	withdrawals := []model.WithdrawalRequest{
		{WithdrawNo: "WD-CURRENT", UserID: f.userID, AmountCent: 300, ActualAmountCent: 300, AccountType: "bank", AccountName: "Test User", AccountNo: "****0000", Status: "pending", CreatedAt: now},
		{WithdrawNo: "WD-PAID", UserID: f.userID, AmountCent: 300, ActualAmountCent: 300, AccountType: "bank", AccountName: "Test User", AccountNo: "****0000", Status: "completed", CreatedAt: now.Add(-time.Hour)},
		{WithdrawNo: "WD-REJECTED", UserID: f.userID, AmountCent: 100, ActualAmountCent: 100, AccountType: "bank", AccountName: "Test User", AccountNo: "****0000", Status: "rejected", CreatedAt: now.Add(-2 * time.Hour)},
	}
	if err := f.db.Create(&withdrawals).Error; err != nil {
		t.Fatal(err)
	}

	contextDTO, err := f.repo.AdminReviewContext(context.Background(), withdrawals[0].ID, WithdrawalReviewContextQuery{PageSize: 10})
	if err != nil {
		t.Fatalf("AdminReviewContext failed: %v", err)
	}
	summary := contextDTO.Summary
	if summary.OwnerOrderCount != 3 || summary.FinalizedOrderCount != 2 {
		t.Fatalf("order summary = %+v", summary)
	}
	if summary.OwnerPickupCount != 2 || summary.PickupIncomeCent != 370 {
		t.Fatalf("pickup summary = %+v", summary)
	}
	if summary.WalletPickupIncomeCent != 250 || summary.PlatformManagedPickupIncomeCent != 120 {
		t.Fatalf("pickup income summary = %+v", summary)
	}
	if summary.WalletActualIncomeCent != 1000 || summary.PlatformManagedIncomeCent != 220 {
		t.Fatalf("income summary = %+v", summary)
	}
	if summary.WithdrawalCount != 3 || summary.WithdrawnAmountCent != 300 || summary.PendingWithdrawalAmountCent != 300 || summary.RejectedWithdrawalCount != 1 {
		t.Fatalf("withdrawal summary = %+v", summary)
	}
	if summary.ReconcileDifferenceAmountCent != 400 {
		t.Fatalf("reconcile difference = %d, want 400", summary.ReconcileDifferenceAmountCent)
	}
	if len(contextDTO.Orders) != 3 || contextDTO.Orders[0].ListingNo != listing.ListingNo {
		t.Fatalf("review orders = %+v", contextDTO.Orders)
	}
	if len(contextDTO.Pickups) != 2 || contextDTO.Pickups[0].ListingNo != listing.ListingNo {
		t.Fatalf("review pickups = %+v", contextDTO.Pickups)
	}
	if len(contextDTO.Withdrawals) != 3 || contextDTO.Withdrawals[0].WithdrawNo != "WD-CURRENT" {
		t.Fatalf("review withdrawals = %+v", contextDTO.Withdrawals)
	}
}

func TestAdminReviewContextScopesIncomeByWithdrawalSite(t *testing.T) {
	f := newWithdrawalFixture(t)
	siteA := model.DistributionSite{SiteCode: "audit-a", SiteName: "审核站A", Domain: "a.example.com", Status: "active"}
	siteB := model.DistributionSite{SiteCode: "audit-b", SiteName: "审核站B", Domain: "b.example.com", Status: "active"}
	if err := f.db.Create(&siteA).Error; err != nil {
		t.Fatal(err)
	}
	if err := f.db.Create(&siteB).Error; err != nil {
		t.Fatal(err)
	}
	renter := model.User{Phone: "13800000003", Nickname: "renter-site", Status: "active"}
	if err := f.db.Create(&renter).Error; err != nil {
		t.Fatal(err)
	}
	account := model.GameAccount{OwnerID: f.userID, ServerRegion: "cn", LoginPlatform: "pc", Title: "分站审核"}
	if err := f.db.Create(&account).Error; err != nil {
		t.Fatal(err)
	}
	listingA := model.RentalListing{ListingNo: "SITE-A-LISTING", AccountID: account.ID, OwnerID: f.userID, Status: "active", DistributionSiteID: &siteA.ID}
	listingB := model.RentalListing{ListingNo: "SITE-B-LISTING", AccountID: account.ID, OwnerID: f.userID, Status: "active", DistributionSiteID: &siteB.ID}
	if err := f.db.Create(&listingA).Error; err != nil {
		t.Fatal(err)
	}
	if err := f.db.Create(&listingB).Error; err != nil {
		t.Fatal(err)
	}
	orderA := model.RentalOrder{OrderNo: "RO-SITE-A", ListingID: listingA.ID, AccountID: account.ID, OwnerID: f.userID, RenterID: renter.ID, Status: "completed", SettlementStatus: "settled", SettlementMode: "owner_wallet", DistributionSiteID: &siteA.ID}
	orderB := model.RentalOrder{OrderNo: "RO-SITE-B", ListingID: listingB.ID, AccountID: account.ID, OwnerID: f.userID, RenterID: renter.ID, Status: "completed", SettlementStatus: "settled", SettlementMode: "owner_wallet", DistributionSiteID: &siteB.ID}
	if err := f.db.Create(&orderA).Error; err != nil {
		t.Fatal(err)
	}
	if err := f.db.Create(&orderB).Error; err != nil {
		t.Fatal(err)
	}
	if err := f.db.Create(&[]model.WalletLedger{
		{LedgerNo: "WL-SITE-A", UserID: f.userID, DistributionSiteID: siteA.ID, OrderID: &orderA.ID, Direction: "in", AmountCent: 100, BalanceType: "available", BizType: "owner_income", BizNo: orderA.OrderNo},
		{LedgerNo: "WL-SITE-B", UserID: f.userID, DistributionSiteID: siteB.ID, OrderID: &orderB.ID, Direction: "in", AmountCent: 999, BalanceType: "available", BizType: "owner_income", BizNo: orderB.OrderNo},
	}).Error; err != nil {
		t.Fatal(err)
	}
	if err := f.db.Create(&[]model.AdminPickup{
		{PickupNo: "PK-SITE-A", ListingID: listingA.ID, AccountID: account.ID, OwnerID: f.userID, AdminID: f.adminID, Status: "completed", SettlementMode: "owner_wallet", SettleAmountCent: 100},
		{PickupNo: "PK-SITE-B", ListingID: listingB.ID, AccountID: account.ID, OwnerID: f.userID, AdminID: f.adminID, Status: "completed", SettlementMode: "owner_wallet", SettleAmountCent: 999},
	}).Error; err != nil {
		t.Fatal(err)
	}
	current := model.WithdrawalRequest{WithdrawNo: "WD-SITE-A", UserID: f.userID, DistributionSiteID: siteA.ID, AmountCent: 100, ActualAmountCent: 100, AccountType: "bank", AccountName: "Test User", AccountNo: "****0000", Status: "pending"}
	if err := f.db.Create(&current).Error; err != nil {
		t.Fatal(err)
	}

	contextDTO, err := f.repo.AdminReviewContext(context.Background(), current.ID, WithdrawalReviewContextQuery{PageSize: 10})
	if err != nil {
		t.Fatal(err)
	}
	if contextDTO.Summary.OwnerOrderCount != 1 || contextDTO.Summary.OwnerPickupCount != 1 {
		t.Fatalf("site-scoped business count = %+v", contextDTO.Summary)
	}
	if contextDTO.Summary.WalletActualIncomeCent != 200 || contextDTO.Summary.WithdrawalCount != 1 {
		t.Fatalf("site-scoped income/withdrawal = %+v", contextDTO.Summary)
	}
}

func (f withdrawalFixture) create(t *testing.T, amountCent int64) *WithdrawalDTO {
	t.Helper()
	dto, err := f.repo.Create(context.Background(), f.userID, CreateWithdrawalRequest{
		PaymentAccountID: f.accountID,
		AmountCent:       amountCent,
	})
	if err != nil {
		t.Fatalf("Create: %v", err)
	}
	return dto
}

func (f withdrawalFixture) assertBalance(t *testing.T, available, frozen int64) {
	t.Helper()
	var account model.WalletAccount
	if err := f.db.Where("user_id = ?", f.userID).First(&account).Error; err != nil {
		t.Fatalf("load wallet: %v", err)
	}
	if account.AvailableBalanceCent != available || account.FrozenBalanceCent != frozen {
		t.Fatalf("balance = available:%d frozen:%d, want available:%d frozen:%d",
			account.AvailableBalanceCent, account.FrozenBalanceCent, available, frozen)
	}
}

func TestWithdrawalCreateAndCancelPreservesBalance(t *testing.T) {
	f := newWithdrawalFixture(t)
	dto := f.create(t, 20_000)
	if dto.Status != "pending" || dto.FeeCent != 0 || dto.ActualAmountCent != 20_000 {
		t.Fatalf("created withdrawal = %+v", dto)
	}
	f.assertBalance(t, 80_000, 20_000)

	if err := f.repo.Cancel(context.Background(), f.userID, dto.ID); err != nil {
		t.Fatalf("Cancel: %v", err)
	}
	f.assertBalance(t, 100_000, 0)
	if err := f.repo.Cancel(context.Background(), f.userID, dto.ID); !errors.Is(err, ErrWithdrawalLocked) {
		t.Fatalf("second Cancel error = %v, want ErrWithdrawalLocked", err)
	}
	f.assertBalance(t, 100_000, 0)
}

func TestWithdrawalRejectedReturnsFrozenBalanceOnce(t *testing.T) {
	f := newWithdrawalFixture(t)
	dto := f.create(t, 30_000)
	approved := false
	result, err := f.repo.Review(context.Background(), f.adminID, dto.ID, ReviewWithdrawalRequest{
		Approved: &approved,
		Remark:   "account mismatch",
	})
	if err != nil {
		t.Fatalf("Review rejected: %v", err)
	}
	if result.Status != "rejected" || result.ReviewedByName != "reviewer" {
		t.Fatalf("review result = %+v", result)
	}
	f.assertBalance(t, 100_000, 0)
	if _, err := f.repo.Review(context.Background(), f.adminID, dto.ID, ReviewWithdrawalRequest{Approved: &approved}); !errors.Is(err, ErrWithdrawalLocked) {
		t.Fatalf("second Review error = %v, want ErrWithdrawalLocked", err)
	}
}

func TestWithdrawalApprovedAndPaidConsumesFrozenBalanceOnce(t *testing.T) {
	f := newWithdrawalFixture(t)
	dto := f.create(t, 40_000)
	approved := true
	if _, err := f.repo.Review(context.Background(), f.adminID, dto.ID, ReviewWithdrawalRequest{Approved: &approved}); err != nil {
		t.Fatalf("Review approved: %v", err)
	}
	f.assertBalance(t, 60_000, 40_000)

	result, err := f.repo.ConfirmPayment(context.Background(), f.adminID, dto.ID, ConfirmPaymentRequest{
		PaymentProofURL: "proof/test.png",
		Remark:          "paid",
	})
	if err != nil {
		t.Fatalf("ConfirmPayment: %v", err)
	}
	if result.Status != "completed" || result.PaidByName != "reviewer" {
		t.Fatalf("payment result = %+v", result)
	}
	f.assertBalance(t, 60_000, 0)
	if _, err := f.repo.ConfirmPayment(context.Background(), f.adminID, dto.ID, ConfirmPaymentRequest{}); !errors.Is(err, ErrWithdrawalLocked) {
		t.Fatalf("second ConfirmPayment error = %v, want ErrWithdrawalLocked", err)
	}
	f.assertBalance(t, 60_000, 0)
}

func TestWithdrawalCreateRollsBackWhenBalanceIsInsufficient(t *testing.T) {
	f := newWithdrawalFixture(t)
	_, err := f.repo.Create(context.Background(), f.userID, CreateWithdrawalRequest{
		PaymentAccountID: f.accountID,
		AmountCent:       100_001,
	})
	if !errors.Is(err, wallet.ErrInsufficientBalance) {
		t.Fatalf("Create error = %v, want ErrInsufficientBalance", err)
	}
	var count int64
	if err := f.db.Model(&model.WithdrawalRequest{}).Count(&count).Error; err != nil {
		t.Fatalf("count withdrawals: %v", err)
	}
	if count != 0 {
		t.Fatalf("withdrawal count = %d, want 0", count)
	}
	f.assertBalance(t, 100_000, 0)
}

func TestWithdrawalDetailIncludesDistributionSiteInfo(t *testing.T) {
	f := newWithdrawalFixture(t)
	if err := f.db.AutoMigrate(&model.DistributionSite{}); err != nil {
		t.Fatal(err)
	}
	site := model.DistributionSite{SiteCode: "sub_site", SiteName: "分销子站", Domain: "sub.example.com", Status: "active"}
	if err := f.db.Create(&site).Error; err != nil {
		t.Fatal(err)
	}
	wReq := model.WithdrawalRequest{
		WithdrawNo:         "WD2026TESTSITE",
		UserID:             f.userID,
		DistributionSiteID: site.ID,
		AmountCent:         5000,
		ActualAmountCent:   5000,
		Status:             "pending",
	}
	if err := f.db.Create(&wReq).Error; err != nil {
		t.Fatal(err)
	}

	detail, err := f.repo.AdminFindByID(context.Background(), wReq.ID)
	if err != nil {
		t.Fatalf("AdminFindByID failed: %v", err)
	}
	if detail.DistributionSiteID != site.ID || detail.DistributionSiteName != "分销子站" || detail.DistributionSiteCode != "sub_site" {
		t.Fatalf("unexpected detail site info: %+v", detail)
	}
}