<?php
/**
 * Reminder runner.
 *
 * @package HostKhata
 */

namespace HostKhata\Domain\Reminders;

defined( 'ABSPATH' ) || exit;

use HostKhata\Core\Hookable;
use HostKhata\Database\Repositories\CustomerRepository;
use HostKhata\Database\Repositories\DomainRepository;
use HostKhata\Database\Repositories\InvoiceRepository;
use HostKhata\Database\Repositories\ReminderRepository;
use HostKhata\Database\Repositories\ServiceRepository;
use HostKhata\Domain\Customers\CustomerStatus;
use HostKhata\Domain\Email\EmailVars;
use HostKhata\Domain\Email\Mailer;
use HostKhata\Settings\Settings;
use HostKhata\Support\Date;

/**
 * Looks for invoices, domains and hosting that match a reminder rule today and
 * queues one email for each, once.
 *
 * It runs hourly from WP-Cron. Nothing goes out before the "send reminders after
 * this hour" setting, and the log's unique key stops a second email for the same
 * rule, item and day. A day that WP-Cron never ran is not made up later.
 *
 * @since 0.1.0
 */
final class ReminderRunner implements Hookable {

	const HOOK = 'hostkhata_run_reminders';

	/**
	 * Rules.
	 *
	 * @var ReminderRepository
	 */
	private $rules;

	/**
	 * Rule service.
	 *
	 * @var ReminderService
	 */
	private $service;

	/**
	 * Mailer.
	 *
	 * @var Mailer
	 */
	private $mailer;

	/**
	 * Merge tag values.
	 *
	 * @var EmailVars
	 */
	private $vars;

	/**
	 * Customers.
	 *
	 * @var CustomerRepository
	 */
	private $customers;

	/**
	 * Invoices.
	 *
	 * @var InvoiceRepository
	 */
	private $invoices;

	/**
	 * Domains.
	 *
	 * @var DomainRepository
	 */
	private $domains;

	/**
	 * Hosting records.
	 *
	 * @var ServiceRepository
	 */
	private $services;

	/**
	 * Settings.
	 *
	 * @var Settings
	 */
	private $settings;

	/**
	 * Constructor.
	 *
	 * @param ReminderRepository $rules     Rules.
	 * @param ReminderService    $service   Rule service.
	 * @param Mailer             $mailer    Mailer.
	 * @param EmailVars          $vars      Merge tag values.
	 * @param CustomerRepository $customers Customers.
	 * @param InvoiceRepository  $invoices  Invoices.
	 * @param DomainRepository   $domains   Domains.
	 * @param ServiceRepository  $services  Hosting records.
	 * @param Settings           $settings  Settings.
	 */
	public function __construct(
		ReminderRepository $rules,
		ReminderService $service,
		Mailer $mailer,
		EmailVars $vars,
		CustomerRepository $customers,
		InvoiceRepository $invoices,
		DomainRepository $domains,
		ServiceRepository $services,
		Settings $settings
	) {
		$this->rules     = $rules;
		$this->service   = $service;
		$this->mailer    = $mailer;
		$this->vars      = $vars;
		$this->customers = $customers;
		$this->invoices  = $invoices;
		$this->domains   = $domains;
		$this->services  = $services;
		$this->settings  = $settings;
	}

	/**
	 * {@inheritdoc}
	 */
	public function register(): void {
		add_action( 'init', array( $this, 'schedule' ) );
		add_action( self::HOOK, array( $this, 'run' ) );
		add_filter( 'hostkhata_cron_hooks', array( $this, 'cron_hooks' ) );
	}

	/**
	 * Schedules the hourly event once.
	 *
	 * @since 0.1.0
	 *
	 * @return void
	 */
	public function schedule(): void {
		if ( ! wp_next_scheduled( self::HOOK ) ) {
			wp_schedule_event( time() + 5 * MINUTE_IN_SECONDS, 'hourly', self::HOOK );
		}
	}

	/**
	 * Registers the hook for unscheduling on deactivation.
	 *
	 * @since 0.1.0
	 *
	 * @param string[] $hooks Hooks.
	 * @return string[]
	 */
	public function cron_hooks( array $hooks ): array {
		$hooks[] = self::HOOK;

		return $hooks;
	}

	/**
	 * Queues today's reminders.
	 *
	 * @since 0.1.0
	 *
	 * @param bool        $force Ignore the quiet hours (used by "run now" and tests).
	 * @param string|null $today Day to run for, `YYYY-MM-DD`; defaults to today (UTC).
	 * @return array{queued: int, skipped: int}
	 */
	public function run( $force = false, $today = null ): array {
		$result = array(
			'queued'  => 0,
			'skipped' => 0,
		);

		if ( ! $this->settings->get( 'reminders_enabled' ) ) {
			return $result;
		}

		if ( true !== $force && (int) current_time( 'G' ) < (int) $this->settings->get( 'reminder_send_hour' ) ) {
			return $result;
		}

		$this->service->ensure_defaults();

		$today = is_string( $today ) && Date::is_valid_date( $today ) ? $today : Date::today_gmt();

		foreach ( $this->rules->all( 'active' ) as $rule ) {
			$day = Date::add_days( $today, -$rule['days_offset'] );

			foreach ( $this->targets( $rule['rule_type'], $day ) as $target_id ) {
				$this->remind( $rule, $target_id, $today, $result );
			}
		}

		/** This action is documented in src/Domain/Billing/BillingRunner.php. */
		do_action( 'hostkhata_cron_ran', 'reminders', $result );

		return $result;
	}

	/**
	 * Ids of the items that match a rule on a day.
	 *
	 * @param string $type Rule type.
	 * @param string $day  The date the items must have.
	 * @return int[]
	 */
	private function targets( string $type, string $day ): array {
		switch ( $type ) {
			case ReminderService::TYPE_INVOICE:
				return $this->invoices->ids_due_on( $day );
			case ReminderService::TYPE_DOMAIN:
				return $this->domains->ids_expiring_on( $day );
			case ReminderService::TYPE_SERVICE:
				return $this->services->ids_due_on( $day );
			default:
				return array();
		}
	}

	/**
	 * Sends one reminder, unless the customer should not get it or it was already sent.
	 *
	 * @param array<string, mixed> $rule   Rule.
	 * @param int                  $id     Target id.
	 * @param string               $today  Today.
	 * @param array<string, int>   $result Counters, updated by this method.
	 * @return void
	 */
	private function remind( array $rule, int $id, string $today, array &$result ): void {
		$item = $this->load( $rule['rule_type'], $id );

		if ( null === $item ) {
			return;
		}

		$customer = $this->customers->find( (int) $item['customer_id'] );

		if (
			null === $customer
			|| ! empty( $customer['reminders_muted'] )
			|| in_array( $customer['status'], array( CustomerStatus::BLOCKED, CustomerStatus::ANONYMISED ), true )
			|| empty( $customer['user_email'] )
		) {
			++$result['skipped'];
			return;
		}

		if ( ! $this->rules->claim( $rule['id'], $rule['rule_type'], $id, $today ) ) {
			return;
		}

		$vars = array_merge( $this->vars->base( $customer ), $this->item_vars( $rule['rule_type'], $item ), array( 'days' => (string) abs( $rule['days_offset'] ) ) );
		$name = trim( $customer['first_name'] . ' ' . $customer['last_name'] );
		$type = ReminderService::TYPE_INVOICE === $rule['rule_type'] ? 'invoice' : ( ReminderService::TYPE_DOMAIN === $rule['rule_type'] ? 'domain' : 'service' );

		if ( $this->mailer->queue( $rule['template_key'], (string) $customer['user_email'], $name, $vars, $type, $id ) > 0 ) {
			++$result['queued'];
		}

		if ( $rule['send_admin_copy'] || $this->settings->get( 'reminder_admin_copy' ) ) {
			$this->mailer->queue_to_admin( $rule['template_key'], $vars, $type, $id );
		}
	}

	/**
	 * Loads the item behind a rule type.
	 *
	 * @param string $type Rule type.
	 * @param int    $id   Item id.
	 * @return array<string, mixed>|null
	 */
	private function load( string $type, int $id ): ?array {
		switch ( $type ) {
			case ReminderService::TYPE_INVOICE:
				return $this->invoices->find( $id );
			case ReminderService::TYPE_DOMAIN:
				return $this->domains->find( $id );
			case ReminderService::TYPE_SERVICE:
				return $this->services->find( $id );
			default:
				return null;
		}
	}

	/**
	 * Merge tag values for an item.
	 *
	 * @param string               $type Rule type.
	 * @param array<string, mixed> $item Item.
	 * @return array<string, string>
	 */
	private function item_vars( string $type, array $item ): array {
		switch ( $type ) {
			case ReminderService::TYPE_INVOICE:
				return $this->vars->invoice( $item );
			case ReminderService::TYPE_DOMAIN:
				return array(
					'domain'     => (string) $item['domain_name'],
					'expires_on' => $this->vars->date( (string) $item['expires_on'] ),
				);
			default:
				return array(
					'domain'   => (string) $item['domain'],
					'due_date' => $this->vars->date( (string) $item['next_due_date'] ),
					'amount'   => $this->vars->money( (int) $item['recurring_amount'] ),
				);
		}
	}
}