<?php
/**
 * Backup retention cleaner.
 *
 * @package Shiftora\Backup
 */

declare(strict_types=1);

namespace Shiftora\Backup;

use Shiftora\Contracts\BackupManagerInterface;

// Prevent direct file access.
if ( ! defined( 'ABSPATH' ) ) {
	exit;
}

/**
 * Enforces the backup retention limit by deleting the oldest backups from disk
 * and the database. Manual backups and rollback snapshots are separate pools,
 * so a pull's snapshot cannot push out a manual backup.
 */
class BackupCleaner {

	/** Manual pool: user-initiated backups only. */
	public const POOL_MANUAL = 'manual';

	/** Rollback pool: pre-migration safety snapshots only. */
	public const POOL_ROLLBACK = 'rollback';

	/** Manual backups kept until the user sets another number on the Settings screen. */
	public const DEFAULT_RETENTION = 3;

	/** Option holding the user's choice. */
	public const RETENTION_OPTION = 'shiftora_backup_retention';

	/** Bounds of the setting, shared by the form and the cleaner so they agree. */
	public const MIN_RETENTION = 1;
	public const MAX_RETENTION = 1000;

	/** How many manual backups are kept, within the form's bounds. */
	public static function retention(): int {
		$stored = (int) get_option( self::RETENTION_OPTION, self::DEFAULT_RETENTION );

		return max( self::MIN_RETENTION, min( self::MAX_RETENTION, $stored ) );
	}

	/** @var callable(): int[] Resolver for backup ids pinned by recovery locks. */
	private $pinned_backup_ids;

	public function __construct(
		private readonly BackupManagerInterface $manager,
		private readonly \wpdb         $wpdb,
		?callable $pinned_backup_ids = null
	) {
		$this->pinned_backup_ids = $pinned_backup_ids
			?? fn(): array => RecoveryManager::pinned_backup_ids( $this->wpdb );
	}

	/**
	 * Removes old backups exceeding the retention limit, oldest first, per pool.
	 * Backups pinned as a recovery restore point are kept regardless of age.
	 *
	 * @param int|null $limit Maximum rows to keep in the pool; null reads the manual-backup setting, 0 keeps everything.
	 * @param string   $pool  self::POOL_MANUAL or self::POOL_ROLLBACK.
	 * @return int Number of backups deleted.
	 */
	public function clean( ?int $limit = null, string $pool = self::POOL_MANUAL ): int {
		$limit = $limit ?? self::retention();
		if ( $limit <= 0 ) {
			return 0;
		}

		$wpdb = $this->wpdb;
		// phpcs:ignore WordPress.DB.DirectDatabaseQuery -- custom table, fresh read required
		$rows = $wpdb->get_results(
			$wpdb->prepare(
				'SELECT id, label FROM %i ORDER BY created_at DESC LIMIT %d OFFSET %d',
				$wpdb->prefix . 'shiftora_backups',
				PHP_INT_MAX,
				0
			)
		);

		$pinned  = array_map( 'intval', (array) ( $this->pinned_backup_ids )() );
		$kept    = 0;
		$deleted = 0;

		foreach ( $rows ?? [] as $row ) {
			$id        = (int) $row->id;
			$is_safety = str_starts_with( (string) ( $row->label ?? '' ), 'rollback-' );
			if ( self::POOL_ROLLBACK === $pool ? ! $is_safety : $is_safety ) {
				continue;
			}
			$kept++;
			if ( $kept > $limit && ! in_array( $id, $pinned, true ) ) {
				$this->manager->delete( $id );
				$deleted++;
			}
		}

		return $deleted;
	}

	/** Removes all backups for a migration, e.g. after permanent deletion. */
	public function clean_for_migration( int $migration_id ): void {
		$backups = $this->manager->list_for_migration( $migration_id );
		foreach ( $backups as $backup ) {
			$this->manager->delete( $backup->id );
		}
	}
}