package financewithdrawal

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

	"hyapp-admin-server/internal/appctx"
	"hyapp-admin-server/internal/integration/activityclient"
	"hyapp-admin-server/internal/integration/walletclient"
	"hyapp-admin-server/internal/model"
	"hyapp-admin-server/internal/modules/shared"
	"hyapp-admin-server/internal/repository"
	activityv1 "hyapp.local/api/proto/activity/v1"
	walletv1 "hyapp.local/api/proto/wallet/v1"

	"github.com/DATA-DOG/go-sqlmock"
	"gorm.io/driver/mysql"
	"gorm.io/gorm"
)

func TestOperationsApprovalMovesToFinanceWithoutWalletOrUserNotice(t *testing.T) {
	svc, mock, wallet, activity, closeService := newWithdrawalAuditServiceTest(t)
	defer closeService()
	expectWithdrawalMoneyAccess(mock, 8, "lalu")
	expectWithdrawalReviewLock(mock, model.WithdrawalApplicationStatusPending, model.WithdrawalOperationsStatusPending)
	mock.ExpectExec("UPDATE `admin_user_withdrawal_applications` SET").WillReturnResult(sqlmock.NewResult(0, 1))
	mock.ExpectCommit()

	dto, err := svc.ApproveOperationsApplication(appctx.WithContext(context.Background(), "lalu"), shared.Actor{
		UserID: 8, Username: "operations", Permissions: []string{permissionAuditOperationsWithdrawals},
	}, 77, "资料无误", "request-ops-approve")
	if err != nil {
		t.Fatalf("approve operations withdrawal failed: %v", err)
	}
	if dto.Status != model.WithdrawalApplicationStatusPending || dto.OperationsStatus != model.WithdrawalOperationsStatusApproved || dto.OperationsReviewerName != "operations" {
		t.Fatalf("operations approval state mismatch: %+v", dto)
	}
	if wallet.settleSalary != nil || wallet.releaseSalary != nil || wallet.settlePoint != nil || wallet.releasePoint != nil || activity.calls != 0 {
		t.Fatalf("operations approval must not touch wallet or send final notice: wallet=%+v notice_calls=%d", wallet, activity.calls)
	}
	if err := mock.ExpectationsWereMet(); err != nil {
		t.Fatalf("sql expectations mismatch: %v", err)
	}
}

func TestOperationsRejectionReleasesFrozenBalanceAndSendsFinalNotice(t *testing.T) {
	svc, mock, wallet, activity, closeService := newWithdrawalAuditServiceTest(t)
	defer closeService()
	expectWithdrawalMoneyAccess(mock, 8, "lalu")
	expectWithdrawalRejectionClaim(mock, model.WithdrawalOperationsStatusPending)
	expectWithdrawalRejectionFinalize(mock)

	dto, err := svc.RejectOperationsApplication(appctx.WithContext(context.Background(), "lalu"), shared.Actor{
		UserID: 8, Username: "operations", Permissions: []string{permissionAuditOperationsWithdrawals},
	}, 77, "收款资料不符", "request-ops-reject")
	if err != nil {
		t.Fatalf("reject operations withdrawal failed: %v", err)
	}
	if wallet.releaseSalary == nil || wallet.releaseSalary.GetCommandId() != "salary-withdrawal:77:operations" || wallet.releaseSalary.GetSalaryUsdMinor() != 5000 {
		t.Fatalf("operations rejection release mismatch: %+v", wallet.releaseSalary)
	}
	if wallet.settleSalary != nil || wallet.settlePoint != nil || wallet.releasePoint != nil {
		t.Fatalf("operations rejection must only release matching salary asset: %+v", wallet)
	}
	if activity.calls != 1 || activity.last.GetProducerEventId() != "operations-withdrawal:77:rejected" || activity.last.GetProducerEventType() != "operations_withdrawal_rejected" {
		t.Fatalf("operations rejection final notice mismatch: calls=%d request=%+v", activity.calls, activity.last)
	}
	if dto.Status != model.WithdrawalApplicationStatusRejected || dto.OperationsStatus != model.WithdrawalOperationsStatusRejected || dto.OperationsAuditTransactionID != "salary-release-tx" {
		t.Fatalf("operations rejection state mismatch: %+v", dto)
	}
	if err := mock.ExpectationsWereMet(); err != nil {
		t.Fatalf("sql expectations mismatch: %v", err)
	}
}

func TestOperationsRejectionNoticeFailureStaysRejectingAndRetryKeepsFirstAuditContext(t *testing.T) {
	svc, mock, wallet, activity, closeService := newWithdrawalAuditServiceTest(t)
	defer closeService()
	noticeFailure := errors.New("activity unavailable")
	activity.failures = []error{noticeFailure, nil}

	expectWithdrawalMoneyAccess(mock, 8, "lalu")
	expectWithdrawalRejectionClaim(mock, model.WithdrawalOperationsStatusPending)
	_, err := svc.RejectOperationsApplication(appctx.WithContext(context.Background(), "lalu"), shared.Actor{
		UserID: 8, Username: "first-operator", Permissions: []string{permissionAuditOperationsWithdrawals},
	}, 77, "first rejection reason", "request-ops-reject-first")
	if !errors.Is(err, noticeFailure) {
		t.Fatalf("first rejection must surface notice failure, got %v", err)
	}

	// 第二个运营人员重试时只能沿用第一次 claim 快照；数据库 rejecting 行禁止改点通过，也不允许改写拒绝原因。
	expectWithdrawalMoneyAccess(mock, 18, "lalu")
	expectWithdrawalRejectionRetryClaim(mock, 8, "first-operator", "first rejection reason")
	expectWithdrawalRejectionFinalizeWithContext(mock, 8, "first-operator", "first rejection reason")
	dto, err := svc.RejectOperationsApplication(appctx.WithContext(context.Background(), "lalu"), shared.Actor{
		UserID: 18, Username: "retry-operator", Permissions: []string{permissionAuditOperationsWithdrawals},
	}, 77, "changed retry reason", "request-ops-reject-retry")
	if err != nil {
		t.Fatalf("retry rejecting withdrawal failed: %v", err)
	}
	if dto.OperationsStatus != model.WithdrawalOperationsStatusRejected || wallet.releaseSalary.GetOperatorUserId() != 8 || wallet.releaseSalary.GetReason() != "first rejection reason" {
		t.Fatalf("retry must preserve first claim context: dto=%+v wallet=%+v", dto, wallet.releaseSalary)
	}
	if activity.calls != 2 || activity.last == nil || activity.last.GetBody() != "Your withdrawal request has been rejected. Reason: first rejection reason" {
		t.Fatalf("retry notice must preserve first rejection reason: calls=%d request=%+v", activity.calls, activity.last)
	}
	if err := mock.ExpectationsWereMet(); err != nil {
		t.Fatalf("sql expectations mismatch: %v", err)
	}
}

func TestOperationsApprovalRejectsDurableRejectingClaimBeforeWalletOrNotice(t *testing.T) {
	svc, mock, wallet, activity, closeService := newWithdrawalAuditServiceTest(t)
	defer closeService()
	expectWithdrawalMoneyAccess(mock, 18, "lalu")
	mock.ExpectBegin()
	mock.ExpectQuery("SELECT \\* FROM `admin_user_withdrawal_applications`.*FOR UPDATE").
		WithArgs("lalu", uint(77), 1).
		WillReturnRows(withdrawalAuditRowsWithOperationsContext(model.WithdrawalApplicationStatusPending, model.WithdrawalOperationsStatusRejecting, 8, "first-operator", "first rejection reason"))
	mock.ExpectRollback()

	_, err := svc.ApproveOperationsApplication(appctx.WithContext(context.Background(), "lalu"), shared.Actor{
		UserID: 18, Username: "retry-operator", Permissions: []string{permissionAuditOperationsWithdrawals},
	}, 77, "改为通过", "request-ops-approve-after-reject")
	if !errors.Is(err, repository.ErrWithdrawalApplicationStageNotReviewable) {
		t.Fatalf("rejecting claim must block operations approval, got %v", err)
	}
	if wallet.settleSalary != nil || wallet.releaseSalary != nil || wallet.settlePoint != nil || wallet.releasePoint != nil || activity.calls != 0 {
		t.Fatalf("rejecting gate must run before integrations: wallet=%+v notices=%d", wallet, activity.calls)
	}
	if err := mock.ExpectationsWereMet(); err != nil {
		t.Fatalf("sql expectations mismatch: %v", err)
	}
}

func TestFinanceReviewRejectsOperationsPendingBeforeWalletOrNotice(t *testing.T) {
	svc, mock, wallet, activity, closeService := newWithdrawalAuditServiceTest(t)
	defer closeService()
	expectWithdrawalMoneyAccess(mock, 9, "lalu")
	mock.ExpectBegin()
	mock.ExpectQuery("SELECT \\* FROM `admin_user_withdrawal_applications`.*FOR UPDATE").
		WithArgs("lalu", uint(77), 1).
		WillReturnRows(withdrawalAuditRows(model.WithdrawalApplicationStatusPending, model.WithdrawalOperationsStatusPending))
	mock.ExpectRollback()

	_, err := svc.ApproveApplication(appctx.WithContext(context.Background(), "lalu"), shared.Actor{
		UserID: 9, Username: "finance", Permissions: []string{permissionAuditWithdrawalApplications},
	}, 77, "已打款", "https://example.com/proof.png", "request-finance-approve")
	if !errors.Is(err, repository.ErrWithdrawalApplicationStageNotReviewable) {
		t.Fatalf("finance must reject operations-pending application, got %v", err)
	}
	if wallet.settleSalary != nil || wallet.releaseSalary != nil || wallet.settlePoint != nil || wallet.releasePoint != nil || activity.calls != 0 {
		t.Fatalf("stage gate must run before wallet or notice: wallet=%+v notice_calls=%d", wallet, activity.calls)
	}
	if err := mock.ExpectationsWereMet(); err != nil {
		t.Fatalf("sql expectations mismatch: %v", err)
	}
}

func TestOperationsListRejectsExplicitAppOutsideMoneyScope(t *testing.T) {
	svc, mock, wallet, activity, closeService := newWithdrawalAuditServiceTest(t)
	defer closeService()
	expectWithdrawalMoneyAccess(mock, 8, "lalu")

	_, _, err := svc.ListOperationsApplications(shared.Actor{UserID: 8}, repository.WithdrawalApplicationListOptions{AppCode: "huwaa"})
	if !errors.Is(err, errWithdrawalMoneyScopeForbidden) {
		t.Fatalf("out-of-scope list must be forbidden, got %v", err)
	}
	if wallet.settleSalary != nil || wallet.releaseSalary != nil || activity.calls != 0 {
		t.Fatalf("out-of-scope list must not call integrations: wallet=%+v notices=%d", wallet, activity.calls)
	}
	if err := mock.ExpectationsWereMet(); err != nil {
		t.Fatalf("sql expectations mismatch: %v", err)
	}
}

func TestOperationsListWithoutAppRestrictsToMoneyScopeApps(t *testing.T) {
	svc, mock, _, _, closeService := newWithdrawalAuditServiceTest(t)
	defer closeService()
	expectWithdrawalMoneyAccess(mock, 8, "lalu", "fami")
	mock.ExpectQuery("SELECT count\\(\\*\\) FROM `admin_user_withdrawal_applications`.*app_code IN.*operations_status <> \\?").
		WithArgs("fami", "lalu", model.WithdrawalOperationsStatusSkipped).
		WillReturnRows(sqlmock.NewRows([]string{"count"}).AddRow(0))
	mock.ExpectQuery("SELECT \\* FROM `admin_user_withdrawal_applications`.*app_code IN.*operations_status <> \\?").
		WithArgs("fami", "lalu", model.WithdrawalOperationsStatusSkipped, 20).
		WillReturnRows(sqlmock.NewRows([]string{"id"}))

	items, total, err := svc.ListOperationsApplications(shared.Actor{UserID: 8}, repository.WithdrawalApplicationListOptions{Page: 1, PageSize: 20})
	if err != nil || total != 0 || len(items) != 0 {
		t.Fatalf("money-scoped operations list mismatch: total=%d items=%+v err=%v", total, items, err)
	}
	if err := mock.ExpectationsWereMet(); err != nil {
		t.Fatalf("sql expectations mismatch: %v", err)
	}
}

func TestFinanceAuditRejectsHeaderAppOutsideMoneyScopeBeforeWallet(t *testing.T) {
	svc, mock, wallet, activity, closeService := newWithdrawalAuditServiceTest(t)
	defer closeService()
	expectWithdrawalMoneyAccess(mock, 9, "fami")

	_, err := svc.ApproveApplication(appctx.WithContext(context.Background(), "lalu"), shared.Actor{
		UserID: 9, Username: "finance", Permissions: []string{permissionAuditWithdrawalApplications},
	}, 77, "paid", "https://example.com/proof.png", "request-out-of-scope")
	if !errors.Is(err, errWithdrawalMoneyScopeForbidden) {
		t.Fatalf("out-of-scope audit must be forbidden, got %v", err)
	}
	if wallet.settleSalary != nil || wallet.releaseSalary != nil || wallet.settlePoint != nil || wallet.releasePoint != nil || activity.calls != 0 {
		t.Fatalf("money scope gate must run before row lock, wallet, or notice: wallet=%+v notices=%d", wallet, activity.calls)
	}
	if err := mock.ExpectationsWereMet(); err != nil {
		t.Fatalf("sql expectations mismatch: %v", err)
	}
}

func TestWithdrawalAuditNotificationEventIDPreservesFinanceCompatibility(t *testing.T) {
	t.Parallel()
	if got := withdrawalAuditNotificationEventID(77, repository.WithdrawalApplicationReviewStageFinance, model.WithdrawalApplicationStatusApproved); got != "finance-withdrawal:77:approved" {
		t.Fatalf("finance event id = %q", got)
	}
	if got := withdrawalAuditNotificationEventID(77, repository.WithdrawalApplicationReviewStageOperations, model.WithdrawalApplicationStatusRejected); got != "operations-withdrawal:77:rejected" {
		t.Fatalf("operations event id = %q", got)
	}
}

func TestApplyWalletDecisionRoutesPointApprovalToPointSettlement(t *testing.T) {
	wallet := &fakeAuditWalletClient{}
	svc := &Service{wallet: wallet}

	transactionID, err := svc.applyWalletDecision(context.Background(), model.WithdrawalApplicationStatusApproved, "audit:77:approved", "fami", 42001, "POINT", 1_000_000, 25_000, 975_000, 200_000, 250, shared.Actor{UserID: 90001}, "paid", 77)
	if err != nil {
		t.Fatalf("apply point approval failed: %v", err)
	}
	if transactionID != "point-settle-tx" {
		t.Fatalf("point approval transaction id mismatch: %s", transactionID)
	}
	if wallet.settlePoint == nil ||
		wallet.settlePoint.GetCommandId() != "audit:77:approved" ||
		wallet.settlePoint.GetAppCode() != "fami" ||
		wallet.settlePoint.GetUserId() != 42001 ||
		wallet.settlePoint.GetAssetType() != "POINT" ||
		wallet.settlePoint.GetGrossPointAmount() != 1_000_000 ||
		wallet.settlePoint.GetFeePointAmount() != 25_000 ||
		wallet.settlePoint.GetNetPointAmount() != 975_000 ||
		wallet.settlePoint.GetPointsPerUsd() != 200_000 ||
		wallet.settlePoint.GetFeeBps() != 250 ||
		wallet.settlePoint.GetOperatorUserId() != 90001 ||
		wallet.settlePoint.GetWithdrawalApplicationId() != "77" {
		t.Fatalf("SettlePointWithdrawal payload mismatch: %+v", wallet.settlePoint)
	}
	if wallet.settleSalary != nil || wallet.releasePoint != nil || wallet.releaseSalary != nil {
		t.Fatalf("point approval must not call legacy salary or release RPCs: wallet=%+v", wallet)
	}
}

func TestApplyWalletDecisionRoutesPointRejectionToPointRelease(t *testing.T) {
	wallet := &fakeAuditWalletClient{}
	svc := &Service{wallet: wallet}

	transactionID, err := svc.applyWalletDecision(context.Background(), model.WithdrawalApplicationStatusRejected, "audit:78:rejected", "huwaa", 42002, "COIN_SELLER_POINT", 2_000_000, 100_000, 1_900_000, 100_000, 500, shared.Actor{UserID: 90002}, "bad address", 78)
	if err != nil {
		t.Fatalf("apply point rejection failed: %v", err)
	}
	if transactionID != "point-release-tx" {
		t.Fatalf("point rejection transaction id mismatch: %s", transactionID)
	}
	if wallet.releasePoint == nil ||
		wallet.releasePoint.GetCommandId() != "audit:78:rejected" ||
		wallet.releasePoint.GetAppCode() != "huwaa" ||
		wallet.releasePoint.GetUserId() != 42002 ||
		wallet.releasePoint.GetAssetType() != "COIN_SELLER_POINT" ||
		wallet.releasePoint.GetGrossPointAmount() != 2_000_000 ||
		wallet.releasePoint.GetFeePointAmount() != 100_000 ||
		wallet.releasePoint.GetNetPointAmount() != 1_900_000 ||
		wallet.releasePoint.GetOperatorUserId() != 90002 ||
		wallet.releasePoint.GetReason() != "bad address" ||
		wallet.releasePoint.GetWithdrawalApplicationId() != "78" {
		t.Fatalf("ReleasePointWithdrawal payload mismatch: %+v", wallet.releasePoint)
	}
	if wallet.settlePoint != nil || wallet.settleSalary != nil || wallet.releaseSalary != nil {
		t.Fatalf("point rejection must not call legacy salary or settle RPCs: wallet=%+v", wallet)
	}
}

func TestApplyWalletDecisionKeepsLegacySalaryAssetsOnSalaryRPC(t *testing.T) {
	wallet := &fakeAuditWalletClient{}
	svc := &Service{wallet: wallet}

	transactionID, err := svc.applyWalletDecision(context.Background(), model.WithdrawalApplicationStatusApproved, "audit:79:approved", "lalu", 42003, "HOST_SALARY_USD", 12_345, 0, 0, 0, 0, shared.Actor{UserID: 90003}, "", 79)
	if err != nil {
		t.Fatalf("apply salary approval failed: %v", err)
	}
	if transactionID != "salary-settle-tx" {
		t.Fatalf("salary approval transaction id mismatch: %s", transactionID)
	}
	if wallet.settleSalary == nil ||
		wallet.settleSalary.GetAppCode() != "lalu" ||
		wallet.settleSalary.GetUserId() != 42003 ||
		wallet.settleSalary.GetSalaryAssetType() != "HOST_SALARY_USD" ||
		wallet.settleSalary.GetSalaryUsdMinor() != 12_345 ||
		wallet.settleSalary.GetWithdrawalApplicationId() != "79" {
		t.Fatalf("SettleSalaryWithdrawal payload mismatch: %+v", wallet.settleSalary)
	}
	if wallet.settlePoint != nil || wallet.releasePoint != nil {
		t.Fatalf("legacy salary asset must not call point RPCs: wallet=%+v", wallet)
	}
}

type fakeAuditWalletClient struct {
	walletclient.Client
	settlePoint   *walletv1.SettlePointWithdrawalRequest
	releasePoint  *walletv1.ReleasePointWithdrawalRequest
	settleSalary  *walletv1.SettleSalaryWithdrawalRequest
	releaseSalary *walletv1.ReleaseSalaryWithdrawalRequest
}

func (f *fakeAuditWalletClient) SettlePointWithdrawal(_ context.Context, req *walletv1.SettlePointWithdrawalRequest) (*walletv1.SettlePointWithdrawalResponse, error) {
	f.settlePoint = req
	return &walletv1.SettlePointWithdrawalResponse{TransactionId: "point-settle-tx"}, nil
}

func (f *fakeAuditWalletClient) ReleasePointWithdrawal(_ context.Context, req *walletv1.ReleasePointWithdrawalRequest) (*walletv1.ReleasePointWithdrawalResponse, error) {
	f.releasePoint = req
	return &walletv1.ReleasePointWithdrawalResponse{TransactionId: "point-release-tx"}, nil
}

func (f *fakeAuditWalletClient) SettleSalaryWithdrawal(_ context.Context, req *walletv1.SettleSalaryWithdrawalRequest) (*walletv1.SettleSalaryWithdrawalResponse, error) {
	f.settleSalary = req
	return &walletv1.SettleSalaryWithdrawalResponse{TransactionId: "salary-settle-tx"}, nil
}

func (f *fakeAuditWalletClient) ReleaseSalaryWithdrawal(_ context.Context, req *walletv1.ReleaseSalaryWithdrawalRequest) (*walletv1.ReleaseSalaryWithdrawalResponse, error) {
	f.releaseSalary = req
	return &walletv1.ReleaseSalaryWithdrawalResponse{TransactionId: "salary-release-tx"}, nil
}

type fakeAuditActivityClient struct {
	activityclient.Client
	last     *activityv1.CreateInboxMessageRequest
	calls    int
	failures []error
}

func (f *fakeAuditActivityClient) CreateInboxMessage(_ context.Context, req *activityv1.CreateInboxMessageRequest) (*activityv1.CreateInboxMessageResponse, error) {
	f.last = req
	f.calls++
	if index := f.calls - 1; index < len(f.failures) && f.failures[index] != nil {
		return nil, f.failures[index]
	}
	return &activityv1.CreateInboxMessageResponse{}, nil
}

func newWithdrawalAuditServiceTest(t *testing.T) (*Service, sqlmock.Sqlmock, *fakeAuditWalletClient, *fakeAuditActivityClient, func()) {
	t.Helper()
	sqlDB, mock, err := sqlmock.New()
	if err != nil {
		t.Fatalf("create sql mock failed: %v", err)
	}
	gormDB, err := gorm.Open(mysql.New(mysql.Config{Conn: sqlDB, SkipInitializeWithVersion: true}), &gorm.Config{})
	if err != nil {
		_ = sqlDB.Close()
		t.Fatalf("create gorm db failed: %v", err)
	}
	wallet := &fakeAuditWalletClient{}
	activity := &fakeAuditActivityClient{}
	svc := &Service{
		store: repository.New(gormDB), wallet: wallet, activity: activity,
		now: func() time.Time { return time.UnixMilli(1_700_000_300_000).UTC() },
	}
	return svc, mock, wallet, activity, func() { _ = sqlDB.Close() }
}

func expectWithdrawalReviewLock(mock sqlmock.Sqlmock, status string, operationsStatus string) {
	mock.ExpectBegin()
	mock.ExpectQuery("SELECT \\* FROM `admin_user_withdrawal_applications`.*FOR UPDATE").
		WithArgs("lalu", uint(77), 1).
		WillReturnRows(withdrawalAuditRows(status, operationsStatus))
}

func expectWithdrawalRejectionClaim(mock sqlmock.Sqlmock, operationsStatus string) {
	mock.ExpectBegin()
	mock.ExpectQuery("SELECT \\* FROM `admin_user_withdrawal_applications`.*FOR UPDATE").
		WithArgs("lalu", uint(77), 1).
		WillReturnRows(withdrawalAuditRows(model.WithdrawalApplicationStatusPending, operationsStatus))
	if operationsStatus == model.WithdrawalOperationsStatusPending {
		mock.ExpectExec("UPDATE `admin_user_withdrawal_applications` SET").WillReturnResult(sqlmock.NewResult(0, 1))
	}
	mock.ExpectCommit()
}

func expectWithdrawalRejectionRetryClaim(mock sqlmock.Sqlmock, reviewerID uint, reviewerName string, remark string) {
	mock.ExpectBegin()
	mock.ExpectQuery("SELECT \\* FROM `admin_user_withdrawal_applications`.*FOR UPDATE").
		WithArgs("lalu", uint(77), 1).
		WillReturnRows(withdrawalAuditRowsWithOperationsContext(model.WithdrawalApplicationStatusPending, model.WithdrawalOperationsStatusRejecting, reviewerID, reviewerName, remark))
	mock.ExpectCommit()
}

func expectWithdrawalRejectionFinalize(mock sqlmock.Sqlmock) {
	expectWithdrawalRejectionFinalizeWithContext(mock, 8, "operations", "收款资料不符")
}

func expectWithdrawalRejectionFinalizeWithContext(mock sqlmock.Sqlmock, reviewerID uint, reviewerName string, remark string) {
	mock.ExpectBegin()
	mock.ExpectQuery("SELECT \\* FROM `admin_user_withdrawal_applications`.*FOR UPDATE").
		WithArgs("lalu", uint(77), 1).
		WillReturnRows(withdrawalAuditRowsWithOperationsContext(model.WithdrawalApplicationStatusPending, model.WithdrawalOperationsStatusRejecting, reviewerID, reviewerName, remark))
	mock.ExpectExec("UPDATE `admin_user_withdrawal_applications` SET").WillReturnResult(sqlmock.NewResult(0, 1))
	mock.ExpectCommit()
}

func expectWithdrawalMoneyAccess(mock sqlmock.Sqlmock, userID uint, appCodes ...string) {
	mock.ExpectQuery("SELECT \\* FROM `admin_users` WHERE `admin_users`.`id` = \\? ORDER BY `admin_users`.`id` LIMIT \\?").
		WillReturnRows(sqlmock.NewRows([]string{"id", "username", "name", "status"}).AddRow(userID, "reviewer", "Reviewer", "active"))
	mock.ExpectQuery("SELECT \\* FROM `admin_user_roles` WHERE `admin_user_roles`.`user_id` = \\?").
		WillReturnRows(sqlmock.NewRows([]string{"user_id", "role_id"}))
	rows := sqlmock.NewRows([]string{"id", "user_id", "app_code", "region_id", "created_at_ms", "updated_at_ms"})
	for index, appCode := range appCodes {
		rows.AddRow(index+1, userID, appCode, 0, int64(1_700_000_000_000), int64(1_700_000_000_000))
	}
	mock.ExpectQuery("SELECT \\* FROM `admin_user_money_scopes` WHERE user_id = \\? ORDER BY app_code ASC, region_id ASC").
		WillReturnRows(rows)
}

func withdrawalAuditRows(status string, operationsStatus string) *sqlmock.Rows {
	return withdrawalAuditRowsWithOperationsContext(status, operationsStatus, 0, "", "")
}

func withdrawalAuditRowsWithOperationsContext(status string, operationsStatus string, reviewerID uint, reviewerName string, remark string) *sqlmock.Rows {
	var storedReviewerID any
	var reviewedAtMS any
	operationsCommandID := ""
	if reviewerID > 0 {
		storedReviewerID = reviewerID
		reviewedAtMS = int64(1_700_000_300_000)
		operationsCommandID = "salary-withdrawal:77:operations"
	}
	return sqlmock.NewRows([]string{
		"id", "app_code", "user_id", "salary_asset_type", "withdraw_amount", "withdraw_amount_minor",
		"withdraw_method", "withdraw_address", "freeze_command_id", "freeze_transaction_id",
		"audit_command_id", "audit_transaction_id", "status", "operations_status",
		"approver_user_id", "approver_name", "audit_remark", "audit_image_url", "approved_at_ms",
		"operations_reviewer_user_id", "operations_reviewer_name", "operations_audit_remark",
		"operations_audit_command_id", "operations_audit_transaction_id", "operations_reviewed_at_ms",
		"created_at_ms", "updated_at_ms",
	}).AddRow(
		77, "lalu", "42001", "HOST_SALARY_USD", "50.00", int64(5000),
		"usdt_trc20", "TRON-address", "freeze-command", "freeze-tx",
		"", "", status, operationsStatus, nil, "", "", "", nil,
		storedReviewerID, reviewerName, remark, operationsCommandID, "", reviewedAtMS,
		int64(1_700_000_000_000), int64(1_700_000_000_000),
	)
}