<?php

namespace AutomateWoo\Jobs;

use AutomateWoo\ActionScheduler\ActionSchedulerInterface;
use AutomateWoo\Cart;
use AutomateWoo\Cart_Factory;
use AutomateWoo\Cart_Query;
use AutomateWoo\DateTime;
use AutomateWoo\Jobs\Traits\ValidateItemAsIntegerId;
use AutomateWoo\OptionsStore;
use AutomateWoo\Options;
use Exception;

defined( 'ABSPATH' ) || exit;

/**
 * Finds active carts that appear to be abandoned and changes their status.
 *
 * @since 5.1.0
 */
class AbandonedCarts extends AbstractRecurringBatchedActionSchedulerJob {

	use ValidateItemAsIntegerId;

	/**
	 * @var OptionsStore $options_store
	 */
	protected $options_store;

	/**
	 * AbstractBatchedJob constructor.
	 *
	 * @param ActionSchedulerInterface  $action_scheduler
	 * @param ActionSchedulerJobMonitor $monitor
	 * @param OptionsStore              $options_store
	 */
	public function __construct( ActionSchedulerInterface $action_scheduler, ActionSchedulerJobMonitor $monitor, OptionsStore $options_store ) {
		$this->options_store = $options_store;
		parent::__construct( $action_scheduler, $monitor );
	}

	/**
	 * Get the name of the job.
	 *
	 * @return string
	 */
	public function get_name() {
		return 'abandoned_carts';
	}

	/**
	 * Get the base abandoned carts query for this job.
	 *
	 * @return Cart_Query
	 * @throws Exception On date error.
	 */
	protected function get_base_abandoned_carts_query() {
		$timeout_date = new DateTime();
		$timeout_date->sub(
			new \DateInterval(
				sprintf( 'PT%dM', absint( $this->options_store->get_abandoned_cart_timeout() ) )
			)
		);

		return ( new Cart_Query() )
			->where_status( Cart::STATUS_ACTIVE )
			->where_date_modified( $timeout_date, '<' )
			->set_ordering( 'last_modified', 'DESC' );
	}

	/**
	 * Can the job start.
	 *
	 * Because this job runs every 2 minutes this method is over-ridden here to prevent a create batch action from
	 * being created every 2 minutes.
	 *
	 * @return bool Returns true if the job can start.
	 *
	 * @throws Exception On date parse error.
	 */
	protected function can_start(): bool {
		if (
			! $this->options_store->get_cart_tracking_enabled() ||
			! $this->get_base_abandoned_carts_query()->has_results() ) {
			return false;
		}

		return parent::can_start();
	}

	/**
	 * Get a new batch of items.
	 *
	 * @param int   $batch_number The batch number increments for each new batch in the job cycle.
	 * @param array $args         The args for this instance of the job. Args are already validated.
	 *
	 * @return int[]
	 * @throws Exception On date parse error.
	 */
	protected function get_batch( int $batch_number, array $args ) {
		return $this->get_base_abandoned_carts_query()
			->set_limit( $this->get_batch_size() )
			->get_results_as_ids();
	}

	/**
	 * Process a single item.
	 *
	 * @param int   $cart_id
	 * @param array $args The args for this instance of the job. Args are already validated.
	 */
	protected function process_item( $cart_id, array $args ) {
		$cart = Cart_Factory::get( $cart_id );

		if ( ! $cart ) {
			// The cart may have been deleted as a stale duplicate by another item in the batch.
			return;
		}

		if ( $cart->get_status() !== Cart::STATUS_ACTIVE ) {
			// The cart is no longer active — for example it was purchased,
			// recovered or emptied between this batch being built and processed —
			// so it must not be (re)marked abandoned, which would fire
			// abandoned-cart workflows for a cart that has already left the
			// active state. (Before terminal statuses existed such a cart was
			// deleted, so this path was previously covered by the null check above.)
			return;
		}

		if ( ! $this->should_process_cart( $cart ) ) {
			return;
		}

		$cart->update_status( 'abandoned' );
	}

	/**
	 * Check whether the cart is the latest stored cart for its customer.
	 *
	 * Duplicate active carts for the same customer can cause duplicate abandoned cart workflows. Keep the most recent
	 * stored cart and delete stale duplicates so they can't be processed by a later batch item.
	 *
	 * @param Cart $cart
	 *
	 * @return bool
	 */
	protected function should_process_cart( Cart $cart ): bool {
		$customer = $cart->get_customer();

		if ( ! $customer ) {
			return true;
		}

		$duplicate_query = ( new Cart_Query() )
			->where_customer( $customer )
			->where_status( [ Cart::STATUS_ACTIVE, Cart::STATUS_ABANDONED ] );

		foreach ( $duplicate_query->get_results() as $duplicate_cart ) {
			if ( $duplicate_cart->get_id() === $cart->get_id() ) {
				continue;
			}

			if ( $this->cart_is_newer_than( $duplicate_cart, $cart ) ) {
				$cart->delete();
				return false;
			}

			$duplicate_cart->delete();
		}

		return true;
	}

	/**
	 * Compare two carts by last modified date, then ID.
	 *
	 * @param Cart $cart
	 * @param Cart $cart_to_compare
	 *
	 * @return bool
	 */
	protected function cart_is_newer_than( Cart $cart, Cart $cart_to_compare ): bool {
		$cart_modified            = $cart->get_date_last_modified();
		$cart_to_compare_modified = $cart_to_compare->get_date_last_modified();

		if ( $cart_modified && $cart_to_compare_modified ) {
			if ( $cart_modified->getTimestamp() > $cart_to_compare_modified->getTimestamp() ) {
				return true;
			}

			if ( $cart_modified->getTimestamp() < $cart_to_compare_modified->getTimestamp() ) {
				return false;
			}
		}

		return $cart->get_id() > $cart_to_compare->get_id();
	}

	/**
	 * Return the recurring job's interval in seconds.
	 *
	 * @return int The interval for this action
	 */
	public function get_interval(): int {
		return JobService::TWO_MINUTE_INTERVAL;
	}

	/**
	 * If cart tracking is not enabled then disable the job to prevent
	 * recurring actions from being scheduled.
	 *
	 * @since 6.0.28
	 *
	 * @return bool
	 */
	public function is_enabled(): bool {
		return Options::abandoned_cart_enabled();
	}
}
