<?php
if ( ! defined( 'WPINC' ) ) {
	die;
}

class AIO_TOTP {

	private static $_base32Map = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ234567';

	/**
	 * Generate a cryptographically random Base32 TOTP secret.
	 */
	public static function generate_secret( $length = 16 ) {
		$secret = '';
		for ( $i = 0; $i < $length; $i++ ) {
			$secret .= self::$_base32Map[ random_int( 0, 31 ) ];
		}
		return $secret;
	}

	/**
	 * Build standard otpauth:// URI for local client-side QR rendering (zero external API leak).
	 */
	public static function get_otpauth_uri( $issuer, $account_name, $secret ) {
		$clean_issuer  = str_replace( ':', '', (string) $issuer );
		$clean_account = str_replace( ':', '', (string) $account_name );
		$label         = rawurlencode( $clean_issuer ) . ':' . rawurlencode( $clean_account );
		$issuer_param  = rawurlencode( $clean_issuer );
		$secret_param  = preg_replace( '/[^A-Z2-7]/', '', strtoupper( (string) $secret ) );

		return "otpauth://totp/{$label}?secret={$secret_param}&issuer={$issuer_param}&algorithm=SHA1&digits=6&period=30";
	}

	/**
	 * Deprecated alias retained for backward compatibility without leaking secrets externally.
	 */
	public static function get_qr_url( $issuer, $account_name, $secret ) {
		return self::get_otpauth_uri( $issuer, $account_name, $secret );
	}

	/**
	 * Verify a 6-digit TOTP code and optionally return the matched 30-second time slice for replay protection.
	 */
	public static function verify_code( $secret, $code, $discrepancy = 1, &$matched_slice = null ) {
		$code = preg_replace( '/\s+/', '', (string) $code );
		if ( ! preg_match( '/^\d{6}$/', $code ) ) {
			return false;
		}

		$current_time_slice = (int) floor( time() / 30 );

		for ( $i = -$discrepancy; $i <= $discrepancy; $i++ ) {
			$slice           = $current_time_slice + $i;
			$calculated_code = self::get_code( $secret, $slice );
			if ( $calculated_code !== '' && hash_equals( $calculated_code, $code ) ) {
				$matched_slice = $slice;
				return true;
			}
		}
		return false;
	}

	/**
	 * Calculate 6-digit TOTP code for a given time slice (RFC 6238 / RFC 4226).
	 */
	public static function get_code( $secret, $time_slice = null ) {
		if ( $time_slice === null ) {
			$time_slice = (int) floor( time() / 30 );
		}

		$secret_key = self::base32_decode( $secret );
		if ( empty( $secret_key ) ) {
			return '';
		}

		$time     = "\x00\x00\x00\x00" . pack( 'N*', $time_slice );
		$hmac     = hash_hmac( 'SHA1', $time, $secret_key, true );
		$offset   = ord( substr( $hmac, -1 ) ) & 0x0F;
		$hashpart = substr( $hmac, $offset, 4 );
		$value    = unpack( 'N', $hashpart );
		$value    = $value[1] & 0x7FFFFFFF;

		return str_pad( (string) ( $value % 1000000 ), 6, '0', STR_PAD_LEFT );
	}

	/**
	 * Generate one-time 2FA backup/recovery codes (returns both display codes and salted SHA-256 hashes).
	 */
	public static function generate_backup_codes( $count = 8 ) {
		$charset = 'ABCDEFGHJKLMNPQRSTUVWXYZ23456789';
		$max_idx = strlen( $charset ) - 1;
		$plain   = array();
		$hashes  = array();

		for ( $i = 0; $i < $count; $i++ ) {
			$raw = '';
			for ( $j = 0; $j < 8; $j++ ) {
				$raw .= $charset[ random_int( 0, $max_idx ) ];
			}
			$formatted = substr( $raw, 0, 4 ) . '-' . substr( $raw, 4, 4 );
			$plain[]   = $formatted;
			$hashes[]  = self::hash_backup_code( $raw );
		}

		return array(
			'plain'  => $plain,
			'hashes' => $hashes,
		);
	}

	/**
	 * Hash a normalized backup code using site auth salt.
	 */
	public static function hash_backup_code( $code ) {
		$normalized = strtoupper( preg_replace( '/[^A-Za-z0-9]/', '', (string) $code ) );
		return hash_hmac( 'sha256', 'aio-2fa-backup:' . $normalized, wp_salt( 'auth' ) );
	}

	/**
	 * Verify and consume a one-time backup code for a given user.
	 */
	public static function verify_and_consume_backup_code( $user_id, $code ) {
		$normalized = strtoupper( preg_replace( '/[^A-Za-z0-9]/', '', (string) $code ) );
		if ( strlen( $normalized ) < 8 ) {
			return false;
		}

		$stored_hashes = get_user_meta( $user_id, '_aio_2fa_backup_codes', true );
		if ( ! is_array( $stored_hashes ) || empty( $stored_hashes ) ) {
			return false;
		}

		$candidate_hash = self::hash_backup_code( $normalized );
		foreach ( $stored_hashes as $idx => $saved_hash ) {
			if ( is_string( $saved_hash ) && hash_equals( $saved_hash, $candidate_hash ) ) {
				unset( $stored_hashes[ $idx ] );
				update_user_meta( $user_id, '_aio_2fa_backup_codes', array_values( $stored_hashes ) );
				return true;
			}
		}

		return false;
	}

	/**
	 * Clean RFC 4648 Base32 decoder without error-suppression operators.
	 */
	private static function base32_decode( $secret ) {
		if ( empty( $secret ) || ! is_string( $secret ) ) {
			return '';
		}

		$secret = strtoupper( rtrim( trim( $secret ), '=' ) );
		if ( $secret === '' ) {
			return '';
		}

		$flipped = array_flip( str_split( self::$_base32Map ) );
		$bits    = '';
		$len     = strlen( $secret );

		for ( $i = 0; $i < $len; $i++ ) {
			$ch = $secret[ $i ];
			if ( ! isset( $flipped[ $ch ] ) ) {
				return '';
			}
			$bits .= str_pad( decbin( $flipped[ $ch ] ), 5, '0', STR_PAD_LEFT );
		}

		$output     = '';
		$byte_count = (int) floor( strlen( $bits ) / 8 );
		for ( $i = 0; $i < $byte_count; $i++ ) {
			$output .= chr( bindec( substr( $bits, $i * 8, 8 ) ) );
		}

		return $output;
	}
}