<?php

namespace ChargeForms\Includes;

if ( ! defined( 'ABSPATH' ) ) {
	exit;
}

/**
 * Resume-token generation and verification — isolated in its own class
 * (rather than inlined in Draft/Draft_Service) so the one piece of this
 * feature that's a genuine secret has one obvious, independently-testable
 * home. Every existing "token-shaped" thing in this codebase before this
 * feature was actually a *deterministic* value (SubmissionHandler's
 * optin_token() is `wp_hash('chargeforms_optin_' . $entry_id)` — re-derivable
 * from the entry id + site secret, not a stored, standalone secret). A
 * draft resume token is different on purpose: it MUST be a real random
 * secret with no derivation from the draft's row id, because "never expose
 * database IDs" is an explicit requirement here — a resume URL has to work
 * as the sole credential, and nothing about the token should let a holder
 * (or an attacker) infer or enumerate the underlying database id.
 *
 * The raw token is only ever handed to the browser/email and is NEVER
 * stored — only its SHA-256 hash is persisted (Draft::token_hash), the
 * same "store a hash, verify by re-hashing and comparing" shape WordPress
 * core itself uses for password-reset keys, so a stolen copy of the
 * `wp_chargeforms_drafts` table alone can never be used to resume a draft.
 */
class Draft_Token {

	/** 32 random bytes -> 64 hex chars — large enough that guessing is not a realistic attack vector even without rate limiting, which this feature also has as defense in depth (see Draft_Service::is_rate_limited()). */
	const BYTES = 32;

	/** A fresh, cryptographically random token. Callers store only hash() of this — never the return value itself. */
	public static function generate() {
		return bin2hex( random_bytes( self::BYTES ) );
	}

	/** The value actually persisted to Draft::token_hash. Deterministic (same token always hashes the same way) but one-way — the hash alone can't be turned back into a usable token. */
	public static function hash( $token ) {
		return hash( 'sha256', (string) $token );
	}

	/** Constant-time comparison — a plain `===`/`==` on hashes would leak timing information about how many leading bytes matched, the same reason WordPress core's own key-verification functions use hash_equals(). */
	public static function matches( $token, $stored_hash ) {
		if ( ! is_string( $token ) || '' === $token || ! is_string( $stored_hash ) || '' === $stored_hash ) {
			return false;
		}
		return hash_equals( $stored_hash, self::hash( $token ) );
	}
}