/**
 * Test data seeding and cleanup utilities.
 *
 * Creates and removes test campaigns and donations via REST API
 * so E2E tests are self-contained and repeatable.
 *
 * @package SureDonation
 */

const SD_API = '/suredonation/v1';
const CAMPAIGN_CPT = 'suredonation_cmpgn';

/**
 * Unwrap a settings REST response.
 *
 * Endpoints return either `{ success, settings: {...} }` or the settings object
 * directly; this centralizes that shape assumption so it lives in one place.
 *
 * @param {Object} response REST response.
 * @return {Object} The settings object.
 */
function unwrapSettings( response ) {
	return ( response && response.settings ) || response || {};
}

let uniqueEmailCounter = 0;

/**
 * Generate a collision-free test email.
 *
 * `Date.now()` alone can repeat within the same millisecond across fast
 * sequential submits, so a monotonic counter is appended.
 *
 * @param {string} prefix Email local-part prefix.
 * @return {string} Unique `@test.local` email address.
 */
function uniqueEmail( prefix = 'e2e' ) {
	uniqueEmailCounter += 1;
	return `${ prefix }-${ Date.now() }-${ uniqueEmailCounter }@test.local`;
}

/**
 * Get current spam-protection (honeypot) settings via REST API.
 *
 * @param {Object} requestUtils Playwright requestUtils fixture.
 * @return {Promise<Object>} API response: { success, settings: { honeypot } }.
 */
async function getSpamProtectionSettings( requestUtils ) {
	return requestUtils.rest( {
		method: 'GET',
		path: `${ SD_API }/settings/spam-protection`,
	} );
}

/**
 * Toggle the honeypot setting via REST API.
 *
 * @param {Object}  requestUtils Playwright requestUtils fixture.
 * @param {boolean} enabled      Whether the honeypot should be enabled.
 * @return {Promise<Object>} API response.
 */
async function setHoneypot( requestUtils, enabled ) {
	try {
		return await requestUtils.rest( {
			method: 'POST',
			path: `${ SD_API }/settings/spam-protection`,
			data: { honeypot: enabled },
		} );
	} catch ( e ) {
		// Defensive fallback (mirrors enableOfflineDonations): if the option
		// write reports unchanged and the API surfaces an error, verify via GET.
		const settings = unwrapSettings(
			await getSpamProtectionSettings( requestUtils )
		);
		if ( settings.honeypot === enabled ) {
			return { success: true, settings };
		}
		throw e;
	}
}

/**
 * Enable the honeypot spam protection via REST API.
 *
 * @param {Object} requestUtils Playwright requestUtils fixture.
 * @return {Promise<Object>} API response.
 */
async function enableHoneypot( requestUtils ) {
	return setHoneypot( requestUtils, true );
}

/**
 * Disable the honeypot spam protection via REST API.
 *
 * @param {Object} requestUtils Playwright requestUtils fixture.
 * @return {Promise<Object>} API response.
 */
async function disableHoneypot( requestUtils ) {
	return setHoneypot( requestUtils, false );
}

/**
 * Create a test campaign via the WP REST API.
 *
 * @param {Object} requestUtils Playwright requestUtils fixture.
 * @return {Promise<number>} Campaign post ID.
 */
async function createTestCampaign( requestUtils ) {
	const campaign = await requestUtils.rest( {
		method: 'POST',
		path: `/wp/v2/${ CAMPAIGN_CPT }`,
		data: {
			title: `E2E Test Campaign ${ Date.now() }`,
			status: 'publish',
		},
	} );
	return campaign.id;
}

/**
 * Create a test donation via the plugin REST API.
 *
 * Creates the donation via POST with required fields (campaign_id, amount),
 * then PUTs all remaining fields to ensure they're set correctly.
 *
 * @param {Object} requestUtils Playwright requestUtils fixture.
 * @param {Object} data         Donation data.
 * @return {Promise<Object>} Created donation object (after update).
 */
async function createTestDonation( requestUtils, data ) {
	// POST with all non-subscription fields to create the record.
	const createData = { ...data };
	const subscriptionFields = {};

	for ( const key of [
		'subscription_id',
		'subscription_status',
		'parent_subscription_id',
	] ) {
		if ( key in createData ) {
			subscriptionFields[ key ] = createData[ key ];
			delete createData[ key ];
		}
	}

	const response = await requestUtils.rest( {
		method: 'POST',
		path: `${ SD_API }/donations`,
		data: createData,
	} );

	const donationId = response.donation?.id;

	if ( ! donationId ) {
		throw new Error(
			`Failed to create donation: ${ JSON.stringify( response ) }`
		);
	}

	// PUT all fields (including subscription fields) to ensure data is correct.
	// This double-write guarantees fields are set even if POST body parsing
	// doesn't apply all values.
	const updateData = { ...data };
	delete updateData.campaign_id; // Can't change campaign after creation.

	if ( Object.keys( updateData ).length > 0 ) {
		const updateResponse = await requestUtils.rest( {
			method: 'PUT',
			path: `${ SD_API }/donations/${ donationId }`,
			data: updateData,
		} );
		return updateResponse.donation || response.donation;
	}

	return response.donation;
}

/**
 * Seed a full recurring-donations test dataset.
 *
 * Creates 1 campaign and 4 donations:
 *   1. One-time (completed, $25)
 *   2. Recurring/subscription (completed, $50, active, fake sub ID)
 *   3. Renewal #1 linked to #2
 *   4. Renewal #2 linked to #2
 *
 * @param {Object} requestUtils Playwright requestUtils fixture.
 * @return {Promise<Object>} IDs of created entities.
 */
async function seedRecurringTestData( requestUtils ) {
	const campaignId = await createTestCampaign( requestUtils );

	// 1. One-time donation.
	const oneTime = await createTestDonation( requestUtils, {
		campaign_id: campaignId,
		donor_name: 'E2E One-Time Donor',
		donor_email: `e2e-onetime-${ Date.now() }@test.local`,
		amount: 25,
		payment_status: 'completed',
		donation_type: 'one-time',
		gateway: 'manual',
	} );

	// 2. Recurring subscription.
	const recurring = await createTestDonation( requestUtils, {
		campaign_id: campaignId,
		donor_name: 'E2E Recurring Donor',
		donor_email: `e2e-recurring-${ Date.now() }@test.local`,
		amount: 50,
		payment_status: 'completed',
		donation_type: 'recurring',
		gateway: 'stripe',
		transaction_id: `pi_testE2eFake${ Date.now() }`,
		subscription_id: `sub_testE2eFake${ Date.now() }`,
		subscription_status: 'active',
	} );

	// 3 & 4. Renewal donations linked to the recurring subscription.
	// Renewals must have the same subscription_id as parent (required by UI to show
	// the Parent Subscription link — guarded by `donation.subscription_id` check).
	const renewal1 = await createTestDonation( requestUtils, {
		campaign_id: campaignId,
		donor_name: 'E2E Recurring Donor',
		donor_email: recurring.donor_email,
		amount: 50,
		payment_status: 'completed',
		donation_type: 'renewal',
		gateway: 'stripe',
		transaction_id: `pi_testRenewal1_${ Date.now() }`,
		subscription_id: recurring.subscription_id,
		parent_subscription_id: recurring.id,
	} );

	const renewal2 = await createTestDonation( requestUtils, {
		campaign_id: campaignId,
		donor_name: 'E2E Recurring Donor',
		donor_email: recurring.donor_email,
		amount: 50,
		payment_status: 'completed',
		donation_type: 'renewal',
		gateway: 'stripe',
		transaction_id: `pi_testRenewal2_${ Date.now() }`,
		subscription_id: recurring.subscription_id,
		parent_subscription_id: recurring.id,
	} );

	return {
		campaignId,
		oneTimeDonationId: oneTime.id,
		recurringDonationId: recurring.id,
		renewalDonationIds: [ renewal1.id, renewal2.id ],
	};
}

/**
 * Clean up seeded test data.
 *
 * @param {Object} requestUtils Playwright requestUtils fixture.
 * @param {Object} ids          IDs from seedRecurringTestData().
 */
async function cleanupTestData( requestUtils, ids ) {
	const donationIds = [
		...( ids.renewalDonationIds || [] ),
		ids.recurringDonationId,
		ids.oneTimeDonationId,
	].filter( Boolean );

	for ( const id of donationIds ) {
		try {
			await requestUtils.rest( {
				method: 'DELETE',
				path: `${ SD_API }/donations/${ id }`,
			} );
		} catch ( e ) {
			// Ignore cleanup errors.
		}
	}

	if ( ids.campaignId ) {
		try {
			await requestUtils.rest( {
				method: 'DELETE',
				path: `/wp/v2/${ CAMPAIGN_CPT }/${ ids.campaignId }?force=true`,
			} );
		} catch ( e ) {
			// Ignore cleanup errors.
		}
	}
}

const FORM_CPT = 'suredonation_form';

/**
 * Create a recurring donation form page.
 *
 * Creates a campaign (which auto-generates a default form with all fields),
 * updates the payment block to subscription mode, then creates a published
 * page using the [suredonation_form] shortcode.
 *
 * @param {Object} requestUtils Playwright requestUtils fixture.
 * @return {Promise<Object>} { pageUrl, campaignId, formId, pageId }.
 */
async function createRecurringFormPage( requestUtils ) {
	// 1. Create a published campaign — auto-creates default form with
	//    amount, name, email, payment, and donate-button blocks.
	const campaignId = await createTestCampaign( requestUtils );

	// 2. Get the default form via the plugin's forms API.
	const formsResponse = await requestUtils.rest( {
		method: 'GET',
		path: `${ SD_API }/forms?campaign_id=${ campaignId }`,
	} );

	const forms = formsResponse.forms || formsResponse;
	const formId = forms?.[ 0 ]?.id;

	if ( ! formId ) {
		throw new Error( `Default form not created for campaign ${ campaignId }` );
	}

	// 3. Update the payment block from one-time to subscription.
	const form = await requestUtils.rest( {
		method: 'GET',
		path: `/wp/v2/${ FORM_CPT }/${ formId }?context=edit`,
	} );

	const updatedContent = ( form.content?.raw || '' ).replace(
		/"paymentType"\s*:\s*"one-time"/,
		`"paymentType":"subscription","subscriptionPlan":{"name":"Monthly Donation","interval":"month","billingCycles":"ongoing"}`
	);

	await requestUtils.rest( {
		method: 'PUT',
		path: `/wp/v2/${ FORM_CPT }/${ formId }`,
		data: { content: updatedContent },
	} );

	// 4. Create a page with the shortcode.
	const page = await requestUtils.rest( {
		method: 'POST',
		path: '/wp/v2/pages',
		data: {
			title: `E2E Recurring Donation ${ Date.now() }`,
			status: 'publish',
			content: `[suredonation_form id="${ formId }"]`,
		},
	} );

	return {
		pageUrl: page.link,
		campaignId,
		formId,
		pageId: page.id,
	};
}

/**
 * Clean up a recurring form page and its associated content.
 *
 * @param {Object} requestUtils Playwright requestUtils fixture.
 * @param {Object} ids          IDs from createRecurringFormPage().
 */
async function cleanupRecurringFormPage( requestUtils, ids ) {
	for ( const { path } of [
		{ path: `/wp/v2/pages/${ ids.pageId }?force=true` },
		{
			path: `/wp/v2/${ FORM_CPT }/${ ids.formId }?force=true`,
		},
		{
			path: `/wp/v2/${ CAMPAIGN_CPT }/${ ids.campaignId }?force=true`,
		},
	] ) {
		try {
			await requestUtils.rest( { method: 'DELETE', path } );
		} catch ( e ) {
			// Ignore cleanup errors.
		}
	}
}

/**
 * Enable offline donations via REST API.
 *
 * @param {Object} requestUtils  Playwright requestUtils fixture.
 * @param {string} instructions  Optional custom instructions HTML.
 * @return {Promise<Object>} API response.
 */
async function enableOfflineDonations( requestUtils, instructions ) {
	const data = { enabled: true };
	if ( instructions !== undefined ) {
		data.instructions = instructions;
	}
	try {
		return await requestUtils.rest( {
			method: 'POST',
			path: `${ SD_API }/payments/offline/settings`,
			data,
		} );
	} catch ( e ) {
		// WordPress update_option returns false when value is unchanged,
		// causing the API to return 500. Verify via GET instead.
		const current = await getOfflineSettings( requestUtils );
		const settings = current.settings || current;
		if ( settings.enabled === true ) {
			return { success: true, settings };
		}
		throw e;
	}
}

/**
 * Disable offline donations via REST API.
 *
 * @param {Object} requestUtils Playwright requestUtils fixture.
 * @return {Promise<Object>} API response.
 */
async function disableOfflineDonations( requestUtils ) {
	try {
		return await requestUtils.rest( {
			method: 'POST',
			path: `${ SD_API }/payments/offline/settings`,
			data: { enabled: false },
		} );
	} catch ( e ) {
		// WordPress update_option returns false when value is unchanged.
		const current = await getOfflineSettings( requestUtils );
		const settings = current.settings || current;
		if ( settings.enabled === false ) {
			return { success: true, settings };
		}
		throw e;
	}
}

/**
 * Get current offline donation settings via REST API.
 *
 * @param {Object} requestUtils Playwright requestUtils fixture.
 * @return {Promise<Object>} API response with settings.
 */
async function getOfflineSettings( requestUtils ) {
	return requestUtils.rest( {
		method: 'GET',
		path: `${ SD_API }/payments/offline/settings`,
	} );
}

/**
 * Create an offline donation form page.
 *
 * Creates a campaign (which auto-generates a default form),
 * updates the payment block to offline-only mode, then creates
 * a published page using the [suredonation_form] shortcode.
 *
 * @param {Object} requestUtils Playwright requestUtils fixture.
 * @return {Promise<Object>} { pageUrl, campaignId, formId, pageId }.
 */
async function createOfflineFormPage( requestUtils ) {
	// 1. Create a published campaign — auto-creates default form.
	const campaignId = await createTestCampaign( requestUtils );

	// 2. Get the default form via the plugin's forms API.
	const formsResponse = await requestUtils.rest( {
		method: 'GET',
		path: `${ SD_API }/forms?campaign_id=${ campaignId }`,
	} );

	const forms = formsResponse.forms || formsResponse;
	const formId = forms?.[ 0 ]?.id;

	if ( ! formId ) {
		throw new Error( `Default form not created for campaign ${ campaignId }` );
	}

	// 3. Update the payment block to use offline gateway only.
	const form = await requestUtils.rest( {
		method: 'GET',
		path: `/wp/v2/${ FORM_CPT }/${ formId }?context=edit`,
	} );

	let updatedContent = form.content?.raw || '';

	// Update the gateway attribute to offline.
	updatedContent = updatedContent.replace(
		/"gateway"\s*:\s*"stripe"/,
		`"gateway":"offline"`
	);

	// Replace paymentMethods array or add it.
	if ( /"paymentMethods"/.test( updatedContent ) ) {
		updatedContent = updatedContent.replace(
			/"paymentMethods"\s*:\s*\[[^\]]*\]/,
			`"paymentMethods":["offline"]`
		);
	} else {
		// Add paymentMethods next to paymentType.
		updatedContent = updatedContent.replace(
			/"paymentType"\s*:\s*"one-time"/,
			`"paymentType":"one-time","paymentMethods":["offline"]`
		);
	}

	// Inject block_id (and formId for payment block) into ALL suredonation/* blocks.
	// The Gutenberg editor normally sets block_id on mount via useEffect.
	// Server-side validation skips blocks without block_id, so we must inject them.
	updatedContent = updatedContent.replace(
		/<!-- wp:suredonation\/(\w[\w-]*) \{(?!"block_id")/g,
		( match, blockName ) => {
			const id = Math.random().toString( 36 ).substring( 2, 9 );
			if ( blockName === 'payment' ) {
				return `<!-- wp:suredonation/${ blockName } {"block_id":"${ id }","formId":${ formId },`;
			}
			return `<!-- wp:suredonation/${ blockName } {"block_id":"${ id }",`;
		}
	);

	await requestUtils.rest( {
		method: 'PUT',
		path: `/wp/v2/${ FORM_CPT }/${ formId }`,
		data: { content: updatedContent },
	} );

	// 4. Create a page with the shortcode.
	const page = await requestUtils.rest( {
		method: 'POST',
		path: '/wp/v2/pages',
		data: {
			title: `E2E Offline Donation ${ Date.now() }`,
			status: 'publish',
			content: `[suredonation_form id="${ formId }"]`,
		},
	} );

	return {
		pageUrl: page.link,
		campaignId,
		formId,
		pageId: page.id,
	};
}

/**
 * Clean up an offline form page and its associated content.
 *
 * @param {Object} requestUtils Playwright requestUtils fixture.
 * @param {Object} ids          IDs from createOfflineFormPage().
 */
async function cleanupOfflineFormPage( requestUtils, ids ) {
	for ( const { path } of [
		{ path: `/wp/v2/pages/${ ids.pageId }?force=true` },
		{
			path: `/wp/v2/${ FORM_CPT }/${ ids.formId }?force=true`,
		},
		{
			path: `/wp/v2/${ CAMPAIGN_CPT }/${ ids.campaignId }?force=true`,
		},
	] ) {
		try {
			await requestUtils.rest( { method: 'DELETE', path } );
		} catch ( e ) {
			// Ignore cleanup errors.
		}
	}
}

/**
 * Seed offline donations test dataset.
 *
 * Creates 1 campaign and 3 donations:
 *   1. One-time completed (stripe gateway)
 *   2. Offline pending ($50)
 *   3. Offline completed ($75)
 *
 * @param {Object} requestUtils Playwright requestUtils fixture.
 * @return {Promise<Object>} IDs of created entities.
 */
async function seedOfflineTestData( requestUtils ) {
	const campaignId = await createTestCampaign( requestUtils );

	// 1. One-time completed donation (stripe).
	const oneTime = await createTestDonation( requestUtils, {
		campaign_id: campaignId,
		donor_name: 'E2E One-Time Donor',
		donor_email: `e2e-onetime-${ Date.now() }@test.local`,
		amount: 25,
		payment_status: 'completed',
		donation_type: 'one-time',
		gateway: 'stripe',
		transaction_id: `pi_testOneTime${ Date.now() }`,
	} );

	// 2. Offline pending donation.
	const offlinePending = await createTestDonation( requestUtils, {
		campaign_id: campaignId,
		donor_name: 'E2E Offline Pending Donor',
		donor_email: `e2e-offline-pending-${ Date.now() }@test.local`,
		amount: 50,
		payment_status: 'pending',
		donation_type: 'one-time',
		gateway: 'offline',
	} );

	// 3. Offline completed donation.
	const offlineCompleted = await createTestDonation( requestUtils, {
		campaign_id: campaignId,
		donor_name: 'E2E Offline Completed Donor',
		donor_email: `e2e-offline-completed-${ Date.now() }@test.local`,
		amount: 75,
		payment_status: 'completed',
		donation_type: 'one-time',
		gateway: 'offline',
	} );

	return {
		campaignId,
		oneTimeDonationId: oneTime.id,
		offlinePendingId: offlinePending.id,
		offlineCompletedId: offlineCompleted.id,
	};
}

/**
 * Clean up offline test data.
 *
 * @param {Object} requestUtils Playwright requestUtils fixture.
 * @param {Object} ids          IDs from seedOfflineTestData().
 */
async function cleanupOfflineTestData( requestUtils, ids ) {
	const donationIds = [
		ids.offlineCompletedId,
		ids.offlinePendingId,
		ids.oneTimeDonationId,
	].filter( Boolean );

	for ( const id of donationIds ) {
		try {
			await requestUtils.rest( {
				method: 'DELETE',
				path: `${ SD_API }/donations/${ id }`,
			} );
		} catch ( e ) {
			// Ignore cleanup errors.
		}
	}

	if ( ids.campaignId ) {
		try {
			await requestUtils.rest( {
				method: 'DELETE',
				path: `/wp/v2/${ CAMPAIGN_CPT }/${ ids.campaignId }?force=true`,
			} );
		} catch ( e ) {
			// Ignore cleanup errors.
		}
	}
}

/**
 * Get the global payment settings via the Stripe settings REST API.
 *
 * @param {Object} requestUtils Playwright requestUtils fixture.
 * @return {Promise<Object>} Payment settings object (currency, payment_mode, …).
 */
async function getPaymentSettings( requestUtils ) {
	const response = await requestUtils.rest( {
		method: 'GET',
		path: `${ SD_API }/payments/stripe/settings`,
	} );
	return response.settings || response;
}

/**
 * Set the global payment mode (test|live) via the Stripe settings REST API.
 *
 * @param {Object} requestUtils Playwright requestUtils fixture.
 * @param {string} mode         'test' or 'live'.
 * @return {Promise<Object>} API response.
 */
async function setPaymentMode( requestUtils, mode ) {
	try {
		return await requestUtils.rest( {
			method: 'POST',
			path: `${ SD_API }/payments/stripe/settings`,
			data: { payment_mode: mode },
		} );
	} catch ( e ) {
		// WordPress update_option returns false when the value is unchanged,
		// surfacing as an API error. Verify via GET instead.
		const current = await getPaymentSettings( requestUtils );
		if ( current.payment_mode === mode ) {
			return { success: true, settings: current };
		}
		throw e;
	}
}

/**
 * Get fee recovery settings via the Stripe settings REST API.
 *
 * @param {Object} requestUtils Playwright requestUtils fixture.
 * @return {Promise<Object>} Fee recovery settings object.
 */
async function getFeeRecoverySettings( requestUtils ) {
	const response = await requestUtils.rest( {
		method: 'GET',
		path: `${ SD_API }/payments/stripe/settings`,
	} );

	const settings = response.settings || response;
	return settings.fee_recovery || {};
}

/**
 * Update fee recovery settings via the Stripe settings REST API.
 *
 * @param {Object} requestUtils Playwright requestUtils fixture.
 * @param {Object} feeRecovery  Fee recovery settings to set.
 * @return {Promise<Object>} API response.
 */
async function updateFeeRecoverySettings( requestUtils, feeRecovery ) {
	try {
		return await requestUtils.rest( {
			method: 'POST',
			path: `${ SD_API }/payments/stripe/settings`,
			data: { fee_recovery: feeRecovery },
		} );
	} catch ( e ) {
		// WordPress update_option returns false when value is unchanged,
		// causing the API to return 500. Verify via GET instead.
		const current = await getFeeRecoverySettings( requestUtils );
		if ( current.fee_mode === feeRecovery.fee_mode ) {
			return { success: true, settings: { fee_recovery: current } };
		}
		throw e;
	}
}

/**
 * Create a donation form page with a cover-fees block.
 *
 * Creates a campaign (which auto-generates a default form), injects the
 * suredonation/cover-fees block into the form content, then creates a published
 * page using the [suredonation_form] shortcode.
 *
 * @param {Object} requestUtils Playwright requestUtils fixture.
 * @param {Object} options      Cover-fees block options.
 * @return {Promise<Object>} { pageUrl, campaignId, formId, pageId }.
 */
async function createFeeRecoveryFormPage( requestUtils, options = {} ) {
	// 1. Create a published campaign — auto-creates default form.
	const campaignId = await createTestCampaign( requestUtils );

	// 2. Get the default form via the plugin's forms API.
	const formsResponse = await requestUtils.rest( {
		method: 'GET',
		path: `${ SD_API }/forms?campaign_id=${ campaignId }`,
	} );

	const forms = formsResponse.forms || formsResponse;
	const formId = forms?.[ 0 ]?.id;

	if ( ! formId ) {
		throw new Error( `Default form not created for campaign ${ campaignId }` );
	}

	// 3. Fetch form content.
	const form = await requestUtils.rest( {
		method: 'GET',
		path: `/wp/v2/${ FORM_CPT }/${ formId }?context=edit`,
	} );

	let updatedContent = form.content?.raw || '';

	// 4. Set payment methods.
	const paymentMethods = options.paymentMethods || [ 'offline' ];
	const isOfflineOnly =
		paymentMethods.length === 1 && paymentMethods[ 0 ] === 'offline';

	if ( isOfflineOnly ) {
		updatedContent = updatedContent.replace(
			/"gateway"\s*:\s*"stripe"/,
			`"gateway":"offline"`
		);
	}

	if ( /"paymentMethods"/.test( updatedContent ) ) {
		updatedContent = updatedContent.replace(
			/"paymentMethods"\s*:\s*\[[^\]]*\]/,
			`"paymentMethods":${ JSON.stringify( paymentMethods ) }`
		);
	} else {
		updatedContent = updatedContent.replace(
			/"paymentType"\s*:\s*"one-time"/,
			`"paymentType":"one-time","paymentMethods":${ JSON.stringify( paymentMethods ) }`
		);
	}

	// 5. Inject block_id into all suredonation/* blocks (same pattern as createOfflineFormPage).
	updatedContent = updatedContent.replace(
		/<!-- wp:suredonation\/(\w[\w-]*) \{(?!"block_id")/g,
		( match, blockName ) => {
			const id = Math.random().toString( 36 ).substring( 2, 9 );
			if ( blockName === 'payment' ) {
				return `<!-- wp:suredonation/${ blockName } {"block_id":"${ id }","formId":${ formId },`;
			}
			return `<!-- wp:suredonation/${ blockName } {"block_id":"${ id }",`;
		}
	);

	// 6. Build the cover-fees block markup.
	const coverFeesAttrs = {
		block_id: Math.random().toString( 36 ).substring( 2, 9 ),
		slug: 'cover-fees',
		label: options.label || "I'd like to cover the processing fees",
		useGlobalDefaults: options.useGlobalDefaults ?? true,
		feePercentage: options.feePercentage ?? 2.9,
		feeFixed: options.feeFixed ?? 0.3,
		feeMode: options.feeMode ?? 'all_gateways',
		gatewayFees: options.gatewayFees ?? {},
		formId,
		checked: options.checked ?? false,
	};

	const coverFeesBlock = `<!-- wp:suredonation/cover-fees ${ JSON.stringify(
		coverFeesAttrs
	) } /-->`;

	// 7. Insert before the donate-button block.
	if ( updatedContent.includes( '<!-- wp:suredonation/donate-button' ) ) {
		updatedContent = updatedContent.replace(
			'<!-- wp:suredonation/donate-button',
			coverFeesBlock + '\n<!-- wp:suredonation/donate-button'
		);
	} else {
		// Fallback: append at the end.
		updatedContent += '\n' + coverFeesBlock;
	}

	await requestUtils.rest( {
		method: 'PUT',
		path: `/wp/v2/${ FORM_CPT }/${ formId }`,
		data: { content: updatedContent },
	} );

	// 8. Create a page with the shortcode.
	const page = await requestUtils.rest( {
		method: 'POST',
		path: '/wp/v2/pages',
		data: {
			title: `E2E Fee Recovery ${ Date.now() }`,
			status: 'publish',
			content: `[suredonation_form id="${ formId }"]`,
		},
	} );

	return {
		pageUrl: page.link,
		campaignId,
		formId,
		pageId: page.id,
	};
}

/**
 * Clean up a fee recovery form page and its associated content.
 *
 * @param {Object} requestUtils Playwright requestUtils fixture.
 * @param {Object} ids          IDs from createFeeRecoveryFormPage().
 */
async function cleanupFeeRecoveryFormPage( requestUtils, ids ) {
	for ( const { path } of [
		{ path: `/wp/v2/pages/${ ids.pageId }?force=true` },
		{
			path: `/wp/v2/${ FORM_CPT }/${ ids.formId }?force=true`,
		},
		{
			path: `/wp/v2/${ CAMPAIGN_CPT }/${ ids.campaignId }?force=true`,
		},
	] ) {
		try {
			await requestUtils.rest( { method: 'DELETE', path } );
		} catch ( e ) {
			// Ignore cleanup errors.
		}
	}
}

/**
 * Update campaign meta value via the plugin's campaigns REST API.
 *
 * @param {Object}  requestUtils Playwright requestUtils fixture.
 * @param {number}  campaignId   Campaign post ID.
 * @param {string}  metaKey      Meta key (e.g., 'allow_fees_coverage').
 * @param {*}       metaValue    Meta value to set.
 * @return {Promise<Object>} API response.
 */
async function updateCampaignMeta(
	requestUtils,
	campaignId,
	metaKey,
	metaValue
) {
	return requestUtils.rest( {
		method: 'PUT',
		path: `${ SD_API }/campaigns/${ campaignId }`,
		data: { [ metaKey ]: metaValue },
	} );
}

/**
 * Update form post meta via the WP REST API.
 *
 * @param {Object} requestUtils Playwright requestUtils fixture.
 * @param {number} formId       Form post ID.
 * @param {Object} meta         Meta key/value pairs to set.
 * @return {Promise<Object>} API response.
 */
async function updateFormMeta( requestUtils, formId, meta ) {
	return requestUtils.rest( {
		method: 'PUT',
		path: `/wp/v2/${ FORM_CPT }/${ formId }`,
		data: { meta },
	} );
}

/**
 * Inject block_id (and formId for payment blocks) into all suredonation/* blocks.
 *
 * Server-side validation skips blocks without block_id, so we must inject them
 * when creating forms via REST API (the editor normally sets block_id on mount).
 *
 * @param {string} content Form block content.
 * @param {number} formId  Form post ID.
 * @return {string} Updated content with block_id injected.
 */
function injectBlockIds( content, formId ) {
	return content.replace(
		/<!-- wp:suredonation\/(\w[\w-]*) \{(?!"block_id")/g,
		( match, blockName ) => {
			const id = Math.random().toString( 36 ).substring( 2, 9 );
			if ( blockName === 'payment' ) {
				return `<!-- wp:suredonation/${ blockName } {"block_id":"${ id }","formId":${ formId },`;
			}
			return `<!-- wp:suredonation/${ blockName } {"block_id":"${ id }",`;
		}
	);
}

/**
 * Create a campaign with a default form, optionally setting form meta,
 * and return the prepared form content with block_id injected.
 *
 * Shared setup for both block embed and shortcode form page helpers.
 *
 * @param {Object} requestUtils Playwright requestUtils fixture.
 * @param {Object} options      Options for form setup.
 * @return {Promise<Object>} Object with campaignId, formId, and prepared content.
 */
async function prepareFormAndCampaign( requestUtils, options = {} ) {
	const campaignId = await createTestCampaign( requestUtils );

	const formsResponse = await requestUtils.rest( {
		method: 'GET',
		path: `${ SD_API }/forms?campaign_id=${ campaignId }`,
	} );

	const forms = formsResponse.forms || formsResponse;
	const formId = forms?.[ 0 ]?.id;

	if ( ! formId ) {
		throw new Error( `Default form not created for campaign ${ campaignId }` );
	}

	// Get form content and inject block_id attributes.
	const form = await requestUtils.rest( {
		method: 'GET',
		path: `/wp/v2/${ FORM_CPT }/${ formId }?context=edit`,
	} );

	const updatedContent = injectBlockIds( form.content?.raw || '', formId );

	await requestUtils.rest( {
		method: 'PUT',
		path: `/wp/v2/${ FORM_CPT }/${ formId }`,
		data: { content: updatedContent },
	} );

	// Set form confirmation meta if provided.
	const meta = {};
	if ( options.confirmationType || options.successMessage || options.redirectUrl ) {
		const confirmationData = {
			confirmation_type: 'same page',
			message: '',
			submission_action: 'hide form',
			custom_url: '',
			page_url: '',
		};

		if ( options.confirmationType === 'redirect' ) {
			confirmationData.confirmation_type = 'custom url';
			confirmationData.custom_url = options.redirectUrl || '';
		} else if ( options.confirmationType === 'message' || options.successMessage ) {
			confirmationData.confirmation_type = 'same page';
			confirmationData.message = options.successMessage || '';
		}

		meta._suredonation_form_confirmation = JSON.stringify( confirmationData );
	}

	// For standalone forms, clear the campaign link so the form
	// renders without a campaign (both block and shortcode fall back
	// to form meta for campaign_id).
	if ( options.standalone ) {
		meta._suredonation_campaign_id = 0;
	}

	if ( Object.keys( meta ).length > 0 ) {
		await updateFormMeta( requestUtils, formId, meta );
	}

	return { campaignId, formId };
}

/**
 * Create a page with the donation form embed block.
 *
 * @param {Object} requestUtils Playwright requestUtils fixture.
 * @param {Object} options      Options.
 * @param {boolean} options.standalone       If true, omit campaignId from block attributes.
 * @param {string}  options.confirmationType Form confirmation type ('message' or 'redirect').
 * @param {string}  options.successMessage   Custom success message.
 * @param {string}  options.redirectUrl      Redirect URL for redirect confirmation.
 * @return {Promise<Object>} Object with pageUrl, campaignId, formId, pageId.
 */
async function createEmbedBlockFormPage( requestUtils, options = {} ) {
	const { campaignId, formId } = await prepareFormAndCampaign(
		requestUtils,
		options
	);

	// Build block attributes.
	const blockAttrs = { formId };
	if ( ! options.standalone ) {
		blockAttrs.campaignId = campaignId;
	}

	const blockContent = `<!-- wp:suredonation/donation-form ${ JSON.stringify(
		blockAttrs
	) } /-->`;

	const page = await requestUtils.rest( {
		method: 'POST',
		path: '/wp/v2/pages',
		data: {
			title: `E2E Embed Block ${ Date.now() }`,
			status: 'publish',
			content: blockContent,
		},
	} );

	return {
		pageUrl: page.link,
		campaignId,
		formId,
		pageId: page.id,
	};
}

/**
 * Create a page with the donation form shortcode.
 *
 * @param {Object} requestUtils Playwright requestUtils fixture.
 * @param {Object} options      Options (same shape as createEmbedBlockFormPage).
 * @return {Promise<Object>} Object with pageUrl, campaignId, formId, pageId.
 */
async function createShortcodeFormPage( requestUtils, options = {} ) {
	const { campaignId, formId } = await prepareFormAndCampaign(
		requestUtils,
		options
	);

	const page = await requestUtils.rest( {
		method: 'POST',
		path: '/wp/v2/pages',
		data: {
			title: `E2E Shortcode Form ${ Date.now() }`,
			status: 'publish',
			content: `[suredonation_form id="${ formId }"]`,
		},
	} );

	return {
		pageUrl: page.link,
		campaignId,
		formId,
		pageId: page.id,
	};
}

/**
 * Clean up a form page and its associated content.
 *
 * @param {Object} requestUtils Playwright requestUtils fixture.
 * @param {Object} ids          IDs from createEmbedBlockFormPage/createShortcodeFormPage.
 */
async function cleanupFormPage( requestUtils, ids ) {
	for ( const { path } of [
		{ path: `/wp/v2/pages/${ ids.pageId }?force=true` },
		{
			path: `/wp/v2/${ FORM_CPT }/${ ids.formId }?force=true`,
		},
		{
			path: `/wp/v2/${ CAMPAIGN_CPT }/${ ids.campaignId }?force=true`,
		},
	] ) {
		try {
			await requestUtils.rest( { method: 'DELETE', path } );
		} catch ( e ) {
			// Ignore cleanup errors.
		}
	}
}

// ─── Form Validation Test Data ──────────────────────────────────

/**
 * Get the form-validation default messages via REST API.
 *
 * @param {Object} requestUtils Playwright requestUtils fixture.
 * @return {Promise<Object>} API response: { success, settings: { ...messages } }.
 */
async function getValidationSettings( requestUtils ) {
	return requestUtils.rest( {
		method: 'GET',
		path: `${ SD_API }/settings/validation`,
	} );
}

/**
 * Update the form-validation default messages via REST API.
 *
 * @param {Object} requestUtils Playwright requestUtils fixture.
 * @param {Object} messages     Map of message key => message.
 * @return {Promise<Object>} API response.
 */
async function updateValidationSettings( requestUtils, messages ) {
	try {
		return await requestUtils.rest( {
			method: 'POST',
			path: `${ SD_API }/settings/validation`,
			data: messages,
		} );
	} catch ( e ) {
		// WordPress update_option returns false when the value is unchanged,
		// which can surface as an API error. Verify via GET instead.
		const current = await getValidationSettings( requestUtils );
		const settings = current.settings || current;
		const matches = Object.keys( messages ).every(
			( key ) => settings[ key ] === messages[ key ]
		);
		if ( matches ) {
			return { success: true, settings };
		}
		throw e;
	}
}

/**
 * Create a donation form page for field-validation tests.
 *
 * Builds on the default form (name, email, donation-amount, payment,
 * donate-button) and optionally injects a required number field (slug
 * "quantity") with min/max bounds and/or a per-field custom Error Message on
 * the name input. block_id attributes are injected so server-side validation
 * runs. Rendered via the [suredonation_form] shortcode.
 *
 * @param {Object} requestUtils      Playwright requestUtils fixture.
 * @param {Object} options           Options.
 * @param {string} options.inputErrorMsg Custom Error Message for the name field.
 * @param {number} options.minValue      Number field minimum (default 5).
 * @param {number} options.maxValue      Number field maximum (default 50).
 * @param {boolean} options.numberField  Set false to omit the number field.
 * @return {Promise<Object>} { pageUrl, campaignId, formId, pageId }.
 */
async function createValidationFormPage( requestUtils, options = {} ) {
	// Standalone so the form renders without a campaign dependency.
	const { campaignId, formId } = await prepareFormAndCampaign( requestUtils, {
		standalone: true,
	} );

	const form = await requestUtils.rest( {
		method: 'GET',
		path: `/wp/v2/${ FORM_CPT }/${ formId }?context=edit`,
	} );

	let content = form.content?.raw || '';

	// Inject a block_id into every suredonation/* field block that lacks one.
	// The default template only sets slugs (the editor adds block_id on mount),
	// and server-side validation skips blocks without a block_id — so REST-built
	// forms need them injected for the stored block config to include the fields.
	content = content.replace(
		/<!-- wp:suredonation\/(\w[\w-]*) \{(?!"block_id")/g,
		( match, blockName ) => {
			const id = Math.random().toString( 36 ).substring( 2, 9 );
			if ( blockName === 'payment' ) {
				return `<!-- wp:suredonation/${ blockName } {"block_id":"${ id }","formId":${ formId },`;
			}
			return `<!-- wp:suredonation/${ blockName } {"block_id":"${ id }",`;
		}
	);

	// Set a per-field custom Error Message on the name (input) block. Default
	// forms omit the empty errorMsg attribute, so inject it into the opening tag.
	if ( options.inputErrorMsg ) {
		content = content.replace(
			/<!-- wp:suredonation\/input \{/,
			`<!-- wp:suredonation/input {"errorMsg":${ JSON.stringify(
				options.inputErrorMsg
			) },`
		);
	}

	// Set a per-field custom invalid-email message on the email block. It ships
	// with a non-empty default, so replace the existing value if present.
	if ( options.emailInvalidMsg ) {
		if ( /"invalidEmailMsg"\s*:/.test( content ) ) {
			content = content.replace(
				/"invalidEmailMsg"\s*:\s*"(?:[^"\\]|\\.)*"/,
				`"invalidEmailMsg":${ JSON.stringify( options.emailInvalidMsg ) }`
			);
		} else {
			content = content.replace(
				/<!-- wp:suredonation\/email \{/,
				`<!-- wp:suredonation/email {"invalidEmailMsg":${ JSON.stringify(
					options.emailInvalidMsg
				) },`
			);
		}
	}

	// Inject a required number field with explicit slug (so update_field_slugs
	// leaves it alone) and min/max bounds, before the donate button.
	if ( options.numberField !== false ) {
		const numberAttrs = {
			block_id: Math.random().toString( 36 ).substring( 2, 9 ),
			slug: 'quantity',
			label: 'Quantity',
			required: true,
			minValue: options.minValue ?? 5,
			maxValue: options.maxValue ?? 50,
			formId,
		};
		if ( options.numberErrorMsg ) {
			numberAttrs.errorMsg = options.numberErrorMsg;
		}
		const numberBlock = `<!-- wp:suredonation/number ${ JSON.stringify(
			numberAttrs
		) } /-->`;

		if ( content.includes( '<!-- wp:suredonation/donate-button' ) ) {
			content = content.replace(
				'<!-- wp:suredonation/donate-button',
				numberBlock + '\n<!-- wp:suredonation/donate-button'
			);
		} else {
			content += '\n' + numberBlock;
		}
	}

	await requestUtils.rest( {
		method: 'PUT',
		path: `/wp/v2/${ FORM_CPT }/${ formId }`,
		data: { content },
	} );

	const page = await requestUtils.rest( {
		method: 'POST',
		path: '/wp/v2/pages',
		data: {
			title: `E2E Field Validation ${ Date.now() }`,
			status: 'publish',
			content: `[suredonation_form id="${ formId }"]`,
		},
	} );

	return { pageUrl: page.link, campaignId, formId, pageId: page.id };
}

/**
 * Get PayPal settings via the plugin REST API.
 *
 * @param {Object} requestUtils Playwright requestUtils fixture.
 * @return {Promise<Object>} API response with settings.
 */
async function getPayPalSettings( requestUtils ) {
	return requestUtils.rest( {
		method: 'GET',
		path: `${ SD_API }/payments/paypal/settings`,
	} );
}

/**
 * Simulate PayPal disconnection via the plugin REST API.
 *
 * @param {Object} requestUtils Playwright requestUtils fixture.
 * @return {Promise<Object>} API response.
 */
async function simulatePayPalDisconnection( requestUtils ) {
	try {
		return await requestUtils.rest( {
			method: 'POST',
			path: `${ SD_API }/payments/paypal/disconnect`,
		} );
	} catch ( e ) {
		// Disconnection may fail if already disconnected or no real PayPal
		// credentials are present. Verify via GET instead.
		const current = await getPayPalSettings( requestUtils );
		const settings = current.settings || current;
		if ( settings.connected === false ) {
			return { success: true, settings };
		}
		throw e;
	}
}

/**
 * Seed PayPal donations test dataset.
 *
 * Creates 1 campaign and 3 donations:
 *   1. Completed one-time ($30, gateway: paypal, with transaction_id)
 *   2. Pending one-time ($45, gateway: paypal)
 *   3. Completed recurring with subscription ($50, gateway: paypal)
 *
 * @param {Object} requestUtils Playwright requestUtils fixture.
 * @return {Promise<Object>} IDs of created entities.
 */
async function seedPayPalTestData( requestUtils ) {
	const campaignId = await createTestCampaign( requestUtils );

	// 1. Completed one-time PayPal donation.
	const completed = await createTestDonation( requestUtils, {
		campaign_id: campaignId,
		donor_name: 'E2E PayPal Completed Donor',
		donor_email: `e2e-paypal-completed-${ Date.now() }@test.local`,
		amount: 30,
		payment_status: 'completed',
		donation_type: 'one-time',
		gateway: 'paypal',
		transaction_id: `PAYPAL_CAPTURE_${ Date.now() }`,
	} );

	// 2. Pending one-time PayPal donation.
	const pending = await createTestDonation( requestUtils, {
		campaign_id: campaignId,
		donor_name: 'E2E PayPal Pending Donor',
		donor_email: `e2e-paypal-pending-${ Date.now() }@test.local`,
		amount: 45,
		payment_status: 'pending',
		donation_type: 'one-time',
		gateway: 'paypal',
	} );

	// 3. Completed recurring PayPal donation with subscription.
	const subscription = await createTestDonation( requestUtils, {
		campaign_id: campaignId,
		donor_name: 'E2E PayPal Subscription Donor',
		donor_email: `e2e-paypal-sub-${ Date.now() }@test.local`,
		amount: 50,
		payment_status: 'completed',
		donation_type: 'recurring',
		gateway: 'paypal',
		transaction_id: `PAYPAL_CAPTURE_SUB_${ Date.now() }`,
		subscription_id: `I-FAKE_E2E_${ Date.now() }`,
		subscription_status: 'active',
	} );

	return {
		campaignId,
		completedId: completed.id,
		pendingId: pending.id,
		subscriptionId: subscription.id,
	};
}

/**
 * Clean up PayPal test data.
 *
 * @param {Object} requestUtils Playwright requestUtils fixture.
 * @param {Object} ids          IDs from seedPayPalTestData().
 */
async function cleanupPayPalTestData( requestUtils, ids ) {
	const donationIds = [
		ids.subscriptionId,
		ids.pendingId,
		ids.completedId,
	].filter( Boolean );

	for ( const id of donationIds ) {
		try {
			await requestUtils.rest( {
				method: 'DELETE',
				path: `${ SD_API }/donations/${ id }`,
			} );
		} catch ( e ) {
			// Ignore cleanup errors.
		}
	}

	if ( ids.campaignId ) {
		try {
			await requestUtils.rest( {
				method: 'DELETE',
				path: `/wp/v2/${ CAMPAIGN_CPT }/${ ids.campaignId }?force=true`,
			} );
		} catch ( e ) {
			// Ignore cleanup errors.
		}
	}
}

/**
 * Create a PayPal donation form page.
 *
 * Creates a campaign (which auto-generates a default form),
 * updates the payment block to PayPal-only mode, then creates
 * a published page using the [suredonation_form] shortcode.
 *
 * @param {Object} requestUtils Playwright requestUtils fixture.
 * @return {Promise<Object>} { pageUrl, campaignId, formId, pageId }.
 */
async function createPayPalFormPage( requestUtils ) {
	// 1. Create a published campaign — auto-creates default form.
	const campaignId = await createTestCampaign( requestUtils );

	// 2. Get the default form via the plugin's forms API.
	const formsResponse = await requestUtils.rest( {
		method: 'GET',
		path: `${ SD_API }/forms?campaign_id=${ campaignId }`,
	} );

	const forms = formsResponse.forms || formsResponse;
	const formId = forms?.[ 0 ]?.id;

	if ( ! formId ) {
		throw new Error(
			`Default form not created for campaign ${ campaignId }`
		);
	}

	// 3. Update the payment block to use PayPal gateway only.
	const form = await requestUtils.rest( {
		method: 'GET',
		path: `/wp/v2/${ FORM_CPT }/${ formId }?context=edit`,
	} );

	let updatedContent = form.content?.raw || '';

	// Update the gateway attribute to paypal.
	updatedContent = updatedContent.replace(
		/"gateway"\s*:\s*"stripe"/,
		`"gateway":"paypal"`
	);

	// Replace paymentMethods array or add it.
	if ( /"paymentMethods"/.test( updatedContent ) ) {
		updatedContent = updatedContent.replace(
			/"paymentMethods"\s*:\s*\[[^\]]*\]/,
			`"paymentMethods":["paypal"]`
		);
	} else {
		// Add paymentMethods next to paymentType.
		updatedContent = updatedContent.replace(
			/"paymentType"\s*:\s*"one-time"/,
			`"paymentType":"one-time","paymentMethods":["paypal"]`
		);
	}

	// Inject block_id (and formId for payment block) into ALL suredonation/* blocks.
	updatedContent = updatedContent.replace(
		/<!-- wp:suredonation\/(\w[\w-]*) \{(?!"block_id")/g,
		( match, blockName ) => {
			const id = Math.random().toString( 36 ).substring( 2, 9 );
			if ( blockName === 'payment' ) {
				return `<!-- wp:suredonation/${ blockName } {"block_id":"${ id }","formId":${ formId },`;
			}
			return `<!-- wp:suredonation/${ blockName } {"block_id":"${ id }",`;
		}
	);

	await requestUtils.rest( {
		method: 'PUT',
		path: `/wp/v2/${ FORM_CPT }/${ formId }`,
		data: { content: updatedContent },
	} );

	// 4. Create a page with the shortcode.
	const page = await requestUtils.rest( {
		method: 'POST',
		path: '/wp/v2/pages',
		data: {
			title: `E2E PayPal Donation ${ Date.now() }`,
			status: 'publish',
			content: `[suredonation_form id="${ formId }"]`,
		},
	} );

	return {
		pageUrl: page.link,
		campaignId,
		formId,
		pageId: page.id,
	};
}

/**
 * Clean up a PayPal form page and its associated content.
 *
 * @param {Object} requestUtils Playwright requestUtils fixture.
 * @param {Object} ids          IDs from createPayPalFormPage().
 */
async function cleanupPayPalFormPage( requestUtils, ids ) {
	for ( const { path } of [
		{ path: `/wp/v2/pages/${ ids.pageId }?force=true` },
		{
			path: `/wp/v2/${ FORM_CPT }/${ ids.formId }?force=true`,
		},
		{
			path: `/wp/v2/${ CAMPAIGN_CPT }/${ ids.campaignId }?force=true`,
		},
	] ) {
		try {
			await requestUtils.rest( { method: 'DELETE', path } );
		} catch ( e ) {
			// Ignore cleanup errors.
		}
	}
}

// ─── Donor Management Test Data ──────────────────────────────────

/**
 * Seed a donor management test dataset.
 *
 * Creates 1 campaign and donations for 3 different donors:
 *   - Donor A: 2 completed donations ($25 + $50)
 *   - Donor B: 1 completed donation ($100)
 *   - Donor C: 1 pending donation ($10)
 *
 * @param {Object} requestUtils Playwright requestUtils fixture.
 * @return {Promise<Object>} IDs and metadata of created entities.
 */
async function seedDonorTestData( requestUtils ) {
	const ts = Date.now();
	const campaignId = await createTestCampaign( requestUtils );

	const donorAEmail = `e2e-donor-a-${ ts }@test.local`;
	const donorBEmail = `e2e-donor-b-${ ts }@test.local`;
	const donorCEmail = `e2e-donor-c-${ ts }@test.local`;

	// Donor A: 2 completed donations.
	const donationA1 = await createTestDonation( requestUtils, {
		campaign_id: campaignId,
		donor_name: 'E2E Donor Alpha',
		donor_email: donorAEmail,
		amount: 25,
		payment_status: 'completed',
		donation_type: 'one-time',
		gateway: 'stripe',
		transaction_id: `pi_donorA1_${ ts }`,
	} );

	const donationA2 = await createTestDonation( requestUtils, {
		campaign_id: campaignId,
		donor_name: 'E2E Donor Alpha',
		donor_email: donorAEmail,
		amount: 50,
		payment_status: 'completed',
		donation_type: 'one-time',
		gateway: 'stripe',
		transaction_id: `pi_donorA2_${ ts }`,
	} );

	// Donor B: 1 completed donation.
	const donationB = await createTestDonation( requestUtils, {
		campaign_id: campaignId,
		donor_name: 'E2E Donor Beta',
		donor_email: donorBEmail,
		amount: 100,
		payment_status: 'completed',
		donation_type: 'one-time',
		gateway: 'stripe',
		transaction_id: `pi_donorB_${ ts }`,
	} );

	// Donor C: 1 pending donation.
	const donationC = await createTestDonation( requestUtils, {
		campaign_id: campaignId,
		donor_name: 'E2E Donor Gamma',
		donor_email: donorCEmail,
		amount: 10,
		payment_status: 'pending',
		donation_type: 'one-time',
		gateway: 'offline',
	} );

	// Donor IDs may be 0 from REST API donation creation if get_or_create
	// doesn't work in the test environment. Get IDs from the donors list
	// by fetching all donors and matching by email, with a retry.
	let donorAId = donationA1.donor_id || null;
	let donorBId = donationB.donor_id || null;
	let donorCId = donationC.donor_id || null;

	// If donor_id was 0, try fetching from the donors list API.
	if ( ! donorAId || ! donorBId || ! donorCId ) {
		try {
			const resp = await requestUtils.rest( {
				method: 'GET',
				path: `${ SD_API }/donors?per_page=50`,
			} );
			const donors = resp.donors || [];
			if ( ! donorAId ) {
				donorAId = donors.find( ( d ) => d.email === donorAEmail )?.id || null;
			}
			if ( ! donorBId ) {
				donorBId = donors.find( ( d ) => d.email === donorBEmail )?.id || null;
			}
			if ( ! donorCId ) {
				donorCId = donors.find( ( d ) => d.email === donorCEmail )?.id || null;
			}
		} catch ( e ) {
			// Ignore — IDs remain null, tests will skip.
		}
	}

	return {
		campaignId,
		donorA: { id: donorAId, email: donorAEmail, name: 'E2E Donor Alpha' },
		donorB: { id: donorBId, email: donorBEmail, name: 'E2E Donor Beta' },
		donorC: { id: donorCId, email: donorCEmail, name: 'E2E Donor Gamma' },
		donationIds: [
			donationA1.id,
			donationA2.id,
			donationB.id,
			donationC.id,
		],
	};
}

/**
 * Clean up donor management test data.
 *
 * @param {Object} requestUtils Playwright requestUtils fixture.
 * @param {Object} data         Data from seedDonorTestData().
 */
async function cleanupDonorTestData( requestUtils, data ) {
	// Delete donations first (foreign key to donors).
	for ( const id of data.donationIds || [] ) {
		try {
			await requestUtils.rest( {
				method: 'DELETE',
				path: `${ SD_API }/donations/${ id }`,
			} );
		} catch ( e ) {
			// Ignore cleanup errors.
		}
	}

	// Delete donors.
	for ( const donor of [ data.donorA, data.donorB, data.donorC ] ) {
		if ( donor?.id ) {
			try {
				await requestUtils.rest( {
					method: 'DELETE',
					path: `${ SD_API }/donors/${ donor.id }`,
				} );
			} catch ( e ) {
				// Ignore cleanup errors.
			}
		}
	}

	// Delete campaign.
	if ( data.campaignId ) {
		try {
			await requestUtils.rest( {
				method: 'DELETE',
				path: `/wp/v2/${ CAMPAIGN_CPT }/${ data.campaignId }?force=true`,
			} );
		} catch ( e ) {
			// Ignore cleanup errors.
		}
	}
}

module.exports = {
	unwrapSettings,
	uniqueEmail,
	getSpamProtectionSettings,
	enableHoneypot,
	disableHoneypot,
	createTestCampaign,
	createTestDonation,
	seedRecurringTestData,
	cleanupTestData,
	createRecurringFormPage,
	cleanupRecurringFormPage,
	enableOfflineDonations,
	disableOfflineDonations,
	getOfflineSettings,
	createOfflineFormPage,
	cleanupOfflineFormPage,
	seedOfflineTestData,
	cleanupOfflineTestData,
	getPaymentSettings,
	setPaymentMode,
	getFeeRecoverySettings,
	updateFeeRecoverySettings,
	createFeeRecoveryFormPage,
	cleanupFeeRecoveryFormPage,
	updateCampaignMeta,
	updateFormMeta,
	createEmbedBlockFormPage,
	createShortcodeFormPage,
	cleanupFormPage,
	getPayPalSettings,
	simulatePayPalDisconnection,
	seedPayPalTestData,
	cleanupPayPalTestData,
	createPayPalFormPage,
	cleanupPayPalFormPage,
	seedDonorTestData,
	cleanupDonorTestData,
	getValidationSettings,
	updateValidationSettings,
	createValidationFormPage,
};