<?php
declare( strict_types=1 );

namespace Automattic\WooCommerce\Internal\StockNotifications\Frontend;

use Automattic\WooCommerce\Internal\StockNotifications\Config;
use Automattic\WooCommerce\Internal\StockNotifications\Emails\EmailManager;
use Automattic\WooCommerce\Internal\StockNotifications\Enums\NotificationStatus;
use Automattic\WooCommerce\Internal\StockNotifications\Factory;
use Automattic\WooCommerce\Internal\StockNotifications\Frontend\MyAccountEndpoint;
use Automattic\WooCommerce\Internal\StockNotifications\Notification;
use Automattic\WooCommerce\Internal\StockNotifications\NotificationQuery;
use Automattic\WooCommerce\Internal\StockNotifications\Utilities\EligibilityService;
use Automattic\WooCommerce\Internal\StockNotifications\Utilities\EmailNormalizer;

/**
 * A class for handling the business logic of the signup process.
 *
 * @internal
 */
class SignupService {

	// phpcs:disable
	public const SIGNUP_ALREADY_JOINED               = 'already_joined';
	public const SIGNUP_ALREADY_JOINED_DOUBLE_OPT_IN = 'already_joined_double_opt_in';
	public const SIGNUP_SUCCESS                      = 'success';
	public const SIGNUP_SUCCESS_DOUBLE_OPT_IN        = 'success_double_opt_in';

	public const ERROR_FAILED           = 'failed_to_signup';
	public const ERROR_INVALID_REQUEST  = 'invalid_request';
	public const ERROR_INVALID_PRODUCT  = 'invalid_product';
	public const ERROR_REQUIRES_ACCOUNT = 'requires_account';
	public const ERROR_RATE_LIMITED     = 'rate_limited';
	public const ERROR_INVALID_USER     = 'invalid_user';
	public const ERROR_INVALID_EMAIL    = 'invalid_email';

	/**
	 * @deprecated 11.2.0 Guest sign-ups no longer create accounts. Never emitted.
	 */
	public const SIGNUP_SUCCESS_ACCOUNT_CREATED = 'success_account_created';

	/**
	 * @deprecated 11.2.0 Guest sign-ups no longer create accounts. Never emitted.
	 */
	public const SIGNUP_SUCCESS_ACCOUNT_CREATED_DOUBLE_OPT_IN = 'success_account_created_double_opt_in';

	/**
	 * @deprecated 11.2.0 The account-creation consent checkbox was removed. Never emitted.
	 */
	public const ERROR_INVALID_OPT_IN = 'invalid_opt_in';
	// phpcs:enable

	/**
	 * Maximum length allowed for a single posted attribute value.
	 */
	private const MAX_ATTRIBUTE_LENGTH = 255;

	/**
	 * Eligibility service.
	 *
	 * @var EligibilityService
	 */
	private EligibilityService $eligibility_service;

	/**
	 * Notification management service.
	 *
	 * @var NotificationManagementService
	 */
	private NotificationManagementService $notification_management_service;

	/**
	 * Email manager.
	 *
	 * @var EmailManager
	 */
	private EmailManager $email_manager;

	/**
	 * The logger.
	 *
	 * @var \WC_Logger_Interface
	 */
	private $logger;

	/**
	 * Init the service.
	 *
	 * @internal
	 *
	 * @param EligibilityService            $eligibility_service The eligibility service.
	 * @param NotificationManagementService $notification_management_service The notification management service.
	 * @param EmailManager                  $email_manager The email manager.
	 */
	final public function init(
		EligibilityService $eligibility_service,
		NotificationManagementService $notification_management_service,
		EmailManager $email_manager
	) {
		$this->eligibility_service             = $eligibility_service;
		$this->notification_management_service = $notification_management_service;
		$this->email_manager                   = $email_manager;
		$this->logger                          = \wc_get_logger();
	}

	/**
	 * Signup.
	 *
	 * Fail-closed: once the rate limit window is claimed it is not released, so a failure or an
	 * exception raised further down still holds the customer back until the window expires. A
	 * window that cannot be claimed at all is the exception, and lets the sign-up through.
	 *
	 * The rate limit is checked before the duplicate sign-up lookup, so a limited request is
	 * rejected without also paying for that lookup.
	 *
	 * @param int    $product_id The product ID.
	 * @param int    $user_id The user ID.
	 * @param string $user_email The user email.
	 * @param array  $posted_attributes The posted attributes (Optional).
	 * @return SignupResult|\WP_Error The signup result.
	 */
	public function signup( int $product_id, int $user_id, string $user_email, array $posted_attributes = array() ) {

		$user_email = EmailNormalizer::normalize( $user_email );

		// Sanity checks.
		if ( ! Config::allows_signups() ) {
			return new \WP_Error( self::ERROR_FAILED );
		}

		if ( empty( $user_email ) && empty( $user_id ) ) {
			return new \WP_Error( self::ERROR_INVALID_REQUEST );
		}

		$product = wc_get_product( $product_id );
		if ( ! $product ) {
			return new \WP_Error( self::ERROR_INVALID_PRODUCT );
		}

		if ( ! $this->eligibility_service->is_product_eligible( $product ) ) {
			return new \WP_Error( self::ERROR_INVALID_PRODUCT );
		}

		if ( $this->eligibility_service->is_stock_status_eligible( $product->get_stock_status() ) ) {
			return new \WP_Error( self::ERROR_INVALID_REQUEST );
		}

		if ( ! $this->eligibility_service->product_allows_signups( $product ) ) {
			return new \WP_Error( self::ERROR_INVALID_PRODUCT );
		}

		if ( SignupRateLimiter::is_rate_limited( $user_email ) ) {
			return new \WP_Error( self::ERROR_RATE_LIMITED );
		}

		// An existing rate limit window blocks these attempts too, but attempts that only find
		// an existing active or pending sign-up, or activate an existing pending one, never claim
		// a window themselves: they create nothing new and send no verification mail.
		$notification = $this->is_already_signed_up( $product_id, $user_id, $user_email, $posted_attributes );
		if ( $notification instanceof Notification ) {
			if ( NotificationStatus::ACTIVE === $notification->get_status() ) {
				return new SignupResult( self::SIGNUP_ALREADY_JOINED, $notification );
			}

			if ( NotificationStatus::PENDING === $notification->get_status() ) {
				if ( Config::requires_double_opt_in() ) {
					return new SignupResult( self::SIGNUP_ALREADY_JOINED_DOUBLE_OPT_IN, $notification );
				}

				// Double opt-in is not required, so activate the pending notification instead of creating one.
				$notification->set_status( NotificationStatus::ACTIVE );
				$saved = $notification->save();
				if ( \is_wp_error( $saved ) || ! $saved ) {
					return new \WP_Error( self::ERROR_FAILED );
				}

				/**
				 * Action: woocommerce_customer_stock_notifications_signup
				 *
				 * @since 10.2.0
				 *
				 * @param Notification $notification The notification.
				 */
				do_action( 'woocommerce_customer_stock_notifications_signup', $notification );
				return new SignupResult( self::SIGNUP_SUCCESS, $notification );
			}
		}

		// Claim the rate limit window before storing a notification or sending mail. This
		// narrows the window in which two near-simultaneous requests both get through; it
		// does not close it.
		//
		// A claim only fails when the rate limit table cannot be written to, which a shopper
		// can neither cause nor resolve. Let the sign-up through rather than turn a broken
		// limiter into a store-wide sign-up outage.
		if ( ! SignupRateLimiter::apply( $user_email ) ) {
			$this->logger->warning(
				'Could not claim the stock notification sign-up rate limit window. Allowing the sign-up to proceed.',
				array( 'source' => 'stock-notifications-signup-errors' )
			);
		}

		$notification = new Notification();
		$notification->set_status( NotificationStatus::ACTIVE );
		$notification->set_product_id( $product_id );
		$notification->set_user_id( $user_id );
		$notification->set_user_email( $user_email );

		if ( ! empty( $posted_attributes ) ) {
			// Sort by key so the stored blob matches what the duplicate lookup serializes.
			ksort( $posted_attributes );
			$notification->update_meta_data( 'posted_attributes', $posted_attributes );
		}

		if ( Config::requires_double_opt_in() ) {
			$notification->set_status( NotificationStatus::PENDING );
		}

		$saved = $notification->save();
		if ( \is_wp_error( $saved ) || ! $saved ) {
			return new \WP_Error( self::ERROR_FAILED );
		}

		/**
		 * Action: woocommerce_customer_stock_notifications_signup
		 *
		 * @since 10.2.0
		 *
		 * @param Notification $notification The notification.
		 */
		do_action( 'woocommerce_customer_stock_notifications_signup', $notification );

		if ( Config::requires_double_opt_in() && NotificationStatus::PENDING === $notification->get_status() ) {
			$this->email_manager->send_verify_email( $notification );
		}

		$signup_code = Config::requires_double_opt_in() ? self::SIGNUP_SUCCESS_DOUBLE_OPT_IN : self::SIGNUP_SUCCESS;
		return new SignupResult( $signup_code, $notification );
	}

	/**
	 * Get the active or pending notification for the request data.
	 *
	 * @param int    $product_id The product ID.
	 * @param int    $user_id The user ID.
	 * @param string $user_email The user email.
	 * @param array  $posted_attributes The posted attributes (Optional).
	 * @return Notification|null The notification, or null if it doesn't exist.
	 */
	public function is_already_signed_up( int $product_id, int $user_id, string $user_email, array $posted_attributes = array() ) {

		$user_email = EmailNormalizer::normalize( $user_email );

		if ( empty( $product_id ) ) {
			return null;
		}

		if ( empty( $user_id ) && empty( $user_email ) ) {
			return null;
		}

		// A customer may have signed up as a guest (user_id 0) before creating an account with the same
		// email, or vice versa. Match on user ID first, then fall back to the email so both states are found.
		$identities = array();
		if ( ! empty( $user_id ) ) {
			$identities[] = array(
				'user_id'    => $user_id,
				'user_email' => '',
			);
		}
		if ( ! empty( $user_email ) ) {
			$identities[] = array(
				'user_id'    => 0,
				'user_email' => $user_email,
			);
		}

		foreach ( $identities as $identity ) {
			$notification_id = NotificationQuery::get_matching_notification_id( $product_id, $identity['user_id'], $identity['user_email'], $posted_attributes );
			if ( empty( $notification_id ) ) {
				continue;
			}

			$notification = Factory::get_notification( $notification_id );
			if ( $notification instanceof Notification ) {
				return $notification;
			}
		}

		return null;
	}

	/**
	 * Parse the request data from a given source.
	 *
	 * @param array $source The source data, e.g. $_POST or $_REQUEST.
	 * @return array|\WP_Error {
	 *  The parsed request data, or a WP_Error if the request data is invalid.
	 *
	 *  @type int    $product_id The product ID.
	 *  @type int    $user_id The user ID.
	 *  @type string $user_email The user email.
	 *  @type array  $posted_attributes The posted attributes (Optional).
	 * }
	 */
	public function parse( array $source ) {

		$parsed_data = $this->parse_user_data( $source );
		if ( \is_wp_error( $parsed_data ) ) {
			return $parsed_data;
		}

		$product = $this->parse_product( $source );
		if ( \is_wp_error( $product ) ) {
			return $product;
		}

		$parsed_data['product_id'] = $product->get_id();
		if ( $product instanceof \WC_Product_Variation ) {
			$posted_attributes = $this->parse_posted_attributes( $source, $product );
			if ( \is_wp_error( $posted_attributes ) ) {
				return $posted_attributes;
			}

			if ( ! empty( $posted_attributes ) ) {
				$parsed_data['posted_attributes'] = $posted_attributes;
			}
		}

		return $parsed_data;
	}

	/**
	 * Parse the user data from the source data.
	 *
	 * @param array $source The source data, e.g. $_POST or $_REQUEST.
	 * @return array|\WP_Error The parsed user data, or a WP_Error if the user data is invalid.
	 */
	private function parse_user_data( array $source ) {
		$data = array();

		$is_logged_in = \is_user_logged_in();
		if ( ! $is_logged_in && Config::requires_account() ) {
			return new \WP_Error( self::ERROR_REQUIRES_ACCOUNT );
		}

		if ( ! $is_logged_in ) {
			$posted_email = isset( $source['wc_bis_email'] ) && is_string( $source['wc_bis_email'] ) ? sanitize_email( wp_unslash( $source['wc_bis_email'] ) ) : '';
			$email        = is_email( $posted_email ) ? EmailNormalizer::normalize( $posted_email ) : '';
			if ( '' === $email ) {
				return new \WP_Error( self::ERROR_INVALID_EMAIL );
			}

			// A guest sign-up stays unlinked until the customer verifies the email: an address typed
			// into a form proves nothing about who owns the matching account.
			$data['user_id']    = 0;
			$data['user_email'] = $email;
		} else {
			$user = wp_get_current_user();
			if ( ! $user ) {
				return new \WP_Error( self::ERROR_INVALID_USER );
			}

			$data['user_id']    = $user->ID;
			$data['user_email'] = EmailNormalizer::normalize( $user->user_email );
		}

		return $data;
	}

	/**
	 * Parse the product from the source data.
	 *
	 * @param array $source The source data, e.g. $_POST or $_REQUEST.
	 * @return \WC_Product|\WP_Error The product, or a WP_Error if the product is invalid.
	 */
	private function parse_product( array $source ) {
		$product_id = isset( $source['wc_bis_product_id'] ) ? absint( wp_unslash( $source['wc_bis_product_id'] ) ) : false;
		if ( ! $product_id ) {
			return new \WP_Error( self::ERROR_INVALID_PRODUCT );
		}

		$product = wc_get_product( $product_id );
		if ( ! $product instanceof \WC_Product ) {
			return new \WP_Error( self::ERROR_INVALID_PRODUCT );
		}

		if ( ! $this->eligibility_service->is_product_eligible( $product ) ) {
			return new \WP_Error( self::ERROR_INVALID_PRODUCT );
		}

		if ( ! $this->eligibility_service->product_allows_signups( $product ) ) {
			return new \WP_Error( self::ERROR_INVALID_PRODUCT );
		}

		return $product;
	}

	/**
	 * Parse variation attributes from source data.
	 *
	 * This method extracts attributes that are defined as 'any' in the variation and need to be
	 * explicitly specified during signup. These attributes cannot be retrieved directly from the variation
	 * since they are not fixed values.
	 *
	 * For example, if a t-shirt variation has 'any' size but a specific color, we need to capture
	 * the chosen size from the form submission while the color comes from the variation itself.
	 *
	 * Only 'any' attributes are read from the request. Every attribute the variation fixes is
	 * already identified by the variation ID, so a posted value for one carries no information
	 * and is ignored.
	 *
	 * Posted values are checked against the attribute's declared values, the same way
	 * `WC_Cart::add_to_cart()` checks them for an 'any' attribute, so a request cannot store a
	 * value the store never offered and mint a sign-up row that no later request can match.
	 *
	 * @see \WC_Cart::add_to_cart() for similar attribute parsing and validation logic.
	 *
	 * @param array       $source The source data, e.g. $_POST or $_REQUEST.
	 * @param \WC_Product $variation The variation.
	 * @return array|\WP_Error The posted attributes, or a WP_Error if a posted value is too long or not one the store offers.
	 */
	private function parse_posted_attributes( array $source, \WC_Product $variation ) {

		if ( ! $variation instanceof \WC_Product_Variation ) {
			return array();
		}

		$product = wc_get_product( $variation->get_parent_id() );
		if ( ! $product ) {
			return array();
		}

		// Empty values are the 'any' attributes, so what is left is the set the variation fixes.
		$fixed_attributes = array_filter( $variation->get_variation_attributes(), 'wc_array_filter_default_attributes' );

		$posted_attributes = array();
		foreach ( $product->get_attributes() as $attribute ) {
			if ( ! $attribute instanceof \WC_Product_Attribute || ! $attribute['is_variation'] ) {
				continue;
			}

			$attribute_key = 'attribute_' . sanitize_title( $attribute['name'] );
			if ( isset( $fixed_attributes[ $attribute_key ] ) || ! isset( $source[ $attribute_key ] ) ) {
				continue;
			}

			// A request can post the value as an array, which the string sanitizers below cannot take.
			$raw_value = wp_unslash( $source[ $attribute_key ] );
			if ( ! is_string( $raw_value ) ) {
				return new \WP_Error( self::ERROR_INVALID_REQUEST );
			}

			if ( $attribute['is_taxonomy'] ) {
				$value = sanitize_title( $raw_value );
			} else {
				$value = html_entity_decode( wc_clean( $raw_value ), ENT_QUOTES, get_bloginfo( 'charset' ) );
			}

			// Don't include if it's empty.
			if ( empty( $value ) && '0' !== $value ) {
				continue;
			}

			// Length first, so an oversized value is rejected without reading the declared ones.
			if ( strlen( $value ) > self::MAX_ATTRIBUTE_LENGTH || ! in_array( $value, $attribute->get_slugs(), true ) ) {
				return new \WP_Error( self::ERROR_INVALID_REQUEST );
			}

			$posted_attributes[ $attribute_key ] = $value;
		}

		return $posted_attributes;
	}

	/**
	 * Get the error message for the error code.
	 *
	 * @param string $error_code The error code.
	 * @return string The error message.
	 */
	public function get_error_message( string $error_code ): string {
		switch ( $error_code ) {
			case self::ERROR_INVALID_PRODUCT:
				return wp_kses_post( __( 'Invalid product.', 'woocommerce' ) );
			case self::ERROR_INVALID_USER:
				return wp_kses_post( __( 'Invalid user.', 'woocommerce' ) );
			case self::ERROR_INVALID_EMAIL:
				return wp_kses_post( __( 'Invalid email address.', 'woocommerce' ) );
			case self::ERROR_RATE_LIMITED:
				return wp_kses_post( __( 'Please wait a moment before signing up again.', 'woocommerce' ) );
			case self::ERROR_INVALID_OPT_IN: // Deprecated code kept for callers passing the old code.
				return wp_kses_post( __( 'To proceed, please consent to the creation of a new account with your e-mail.', 'woocommerce' ) );
			default:
				return wp_kses_post( __( 'Failed to sign up. Please try again.', 'woocommerce' ) );
		}
	}

	/**
	 * Get the signup user message for the signup code.
	 *
	 * @param string       $signup_code The signup code.
	 * @param Notification $notification The notification.
	 * @return string The signup user message.
	 */
	public function get_signup_user_message( string $signup_code, Notification $notification ): string {
		$message           = '';
		$has_action_button = false;
		switch ( $signup_code ) {

			case self::SIGNUP_SUCCESS:
				/* translators: Product name */
				$message = sprintf( esc_html__( 'You have successfully signed up! You will be notified when "%s" is back in stock.', 'woocommerce' ), $notification->get_product_name() );
				break;

			case self::SIGNUP_SUCCESS_DOUBLE_OPT_IN:
				$message = esc_html__( 'Thanks for signing up! Please complete the sign-up process by following the verification link sent to your e-mail.', 'woocommerce' );
				break;

			case self::SIGNUP_SUCCESS_ACCOUNT_CREATED: // Deprecated code kept for callers passing the old code.
				/* translators: Product name */
				$message = sprintf( esc_html__( 'You have successfully signed up and will be notified when "%s" is back in stock! Note that a new account has been created for you; please check your e-mail for details.', 'woocommerce' ), $notification->get_product_name() );
				break;

			case self::SIGNUP_SUCCESS_ACCOUNT_CREATED_DOUBLE_OPT_IN: // Deprecated code kept for callers passing the old code.
				$message = esc_html__( 'Thanks for signing up! An account has been created for you. Please complete the sign-up process by following the verification link sent to your e-mail.', 'woocommerce' );
				break;

			case self::SIGNUP_ALREADY_JOINED:
				$message = esc_html__( 'You have already joined this waitlist.', 'woocommerce' );
				break;

			case self::SIGNUP_ALREADY_JOINED_DOUBLE_OPT_IN:
				$notice_text     = esc_html__( 'You have already joined this waitlist. Please complete the sign-up process by following the verification link sent to your e-mail.', 'woocommerce' );
				$url             = $this->notification_management_service->get_resend_verification_email_url( $notification );
				$button_class    = wc_wp_theme_get_element_class_name( 'button' );
				$wp_button_class = $button_class ? ' ' . $button_class : '';
				$message         = sprintf(
					'<a href="%s" class="button wc-forward%s">%s</a> %s',
					$url,
					$wp_button_class,
					esc_html_x( 'Resend verification', 'notice action', 'woocommerce' ),
					$notice_text
				);

				$has_action_button = true;
				break;
			default:
				$message = '';
				break;
		}

		// The endpoint can be switched off from Settings > Advanced, leaving nowhere to link to.
		if ( is_user_logged_in() && ! $has_action_button && '' !== MyAccountEndpoint::get_endpoint_slug() ) {
			$button_class    = \wc_wp_theme_get_element_class_name( 'button' );
			$wp_button_class = $button_class ? ' ' . $button_class : '';
			$message         = sprintf( '<a href="%s" class="button wc-forward%s">%s</a> %s', esc_url( \wc_get_account_endpoint_url( MyAccountEndpoint::ENDPOINT ) ), $wp_button_class, esc_html_x( 'Manage notifications', 'notice action', 'woocommerce' ), $message );
		}

		return $message;
	}
}