<?php
/**
 * The one folder under uploads where Shiftora keeps its own files.
 *
 * @package Shiftora\Support
 */

declare(strict_types=1);

namespace Shiftora\Support;

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

/**
 * uploads/shiftora/{backups,exports,diagnostics}, resolved from WordPress at
 * the moment of use. Uploads is web-served, so every folder gets a deny rule
 * for Apache and an index file for hosts that ignore it.
 */
final class DataDirectory {

	/** The folder under uploads where everything Shiftora keeps lives. */
	public const FOLDER = 'shiftora';

	public const BACKUPS     = 'backups';
	public const EXPORTS     = 'exports';
	public const DIAGNOSTICS = 'diagnostics';

	/** Files that guard a folder and must survive a clean-out. */
	private const GUARDS = [
		'.htaccess' => "deny from all\n",
		'index.php' => "<?php // Silence is golden.\n",
	];

	/** Where reports lived before they moved under the shared folder. */
	public const LEGACY_DIAGNOSTICS = 'shiftora-diagnostics';

	private const LEGACY_MOVED_OPTION = 'shiftora_legacy_diagnostics_moved';

	/** The Shiftora folder inside uploads, or '' when uploads cannot be resolved. */
	public static function root( ?string $uploads_base = null ): string {
		$base = $uploads_base;
		if ( null === $base || '' === $base ) {
			$uploads = wp_upload_dir( null, false );
			$base    = is_array( $uploads ) ? (string) ( $uploads['basedir'] ?? '' ) : '';
		}

		return '' === $base ? '' : untrailingslashit( $base ) . '/' . self::FOLDER;
	}

	/**
	 * The top-level folders of uploads that belong to Shiftora, whose contents no migration carries or writes.
	 *
	 * @return string[]
	 */
	public static function reserved_folders(): array {
		return [ self::FOLDER, self::LEGACY_DIAGNOSTICS ];
	}

	/** Absolute path of a folder, without touching the disk. */
	public static function path( string $name, ?string $uploads_base = null ): string {
		$root = self::root( $uploads_base );

		return '' === $root ? '' : $root . '/' . $name;
	}

	/**
	 * Creates a folder and its guards.
	 *
	 * @return string The folder, or '' when it or a guard could not be created.
	 */
	public static function ensure( string $name, ?string $uploads_base = null ): string {
		$root = self::root( $uploads_base );
		if ( '' === $root ) {
			return '';
		}

		$dir = $root . '/' . $name;
		foreach ( [ $root, $dir ] as $folder ) {
			if ( ! wp_mkdir_p( $folder ) || ! self::guard( $folder, $root ) ) {
				return '';
			}
		}

		return $dir;
	}

	/** Whether a path is one of the files that guard a folder. */
	public static function is_guard( string $path ): bool {
		return isset( self::GUARDS[ basename( $path ) ] );
	}

	/**
	 * Deletes every file in a folder except its guards.
	 *
	 * @return int Files removed.
	 */
	public static function clear( string $name, ?string $uploads_base = null ): int {
		$dir = self::path( $name, $uploads_base );
		if ( '' === $dir || is_link( $dir ) || ! is_dir( $dir ) ) {
			return 0;
		}

		$removed = 0;
		foreach ( (array) scandir( $dir ) as $entry ) {
			$path = $dir . '/' . $entry;
			if ( is_file( $path ) && ! self::is_guard( $path ) ) {
				wp_delete_file( $path );
				++$removed;
			}
		}

		return $removed;
	}

	/**
	 * Moves diagnostics reports from their old folder into the shared one.
	 * The old folder is gone afterwards, so this is cheap on every later call.
	 */
	public static function adopt_legacy_diagnostics( ?string $uploads_base = null ): void {
		$root = self::root( $uploads_base );
		if ( '' === $root ) {
			return;
		}

		$base   = dirname( $root );
		$legacy = $base . '/' . self::LEGACY_DIAGNOSTICS;
		if ( is_link( $legacy ) || ! is_dir( $legacy ) ) {
			return;
		}

		$target = self::ensure( self::DIAGNOSTICS, $uploads_base );
		if ( '' === $target ) {
			return;
		}

		foreach ( (array) glob( $legacy . '/issue-*.json' ) as $report ) {
			if ( is_string( $report ) && is_file( $report ) ) {
				Filesystem::move( $report, $target . '/' . basename( $report ), $base );
			}
		}

		Filesystem::delete_tree( $legacy, $base );
	}

	/** Runs the move once per site, from an administrator request, so the old unguarded folder does not linger. */
	public static function adopt_legacy_once(): void {
		if ( ! current_user_can( 'manage_options' ) || get_option( self::LEGACY_MOVED_OPTION ) ) {
			return;
		}

		self::adopt_legacy_diagnostics();
		update_option( self::LEGACY_MOVED_OPTION, 1, false );
	}

	/** Uninstall: removes the folder, the old reports folder and leftover transfer scratch files. */
	public static function remove_all( ?string $uploads_base = null ): void {
		$root = self::root( $uploads_base );
		if ( '' === $root ) {
			return;
		}

		$base = dirname( $root );
		Filesystem::delete_tree( $root, $base );
		Filesystem::delete_tree( $base . '/' . self::LEGACY_DIAGNOSTICS, $base );

		if ( ! is_dir( $base ) ) {
			return;
		}

		try {
			$files = new \RecursiveIteratorIterator(
				new \RecursiveDirectoryIterator( $base, \FilesystemIterator::SKIP_DOTS ),
				\RecursiveIteratorIterator::LEAVES_ONLY,
				\RecursiveIteratorIterator::CATCH_GET_CHILD
			);
			foreach ( $files as $file ) {
				if ( $file->isFile() && TransferTempFile::is_temp( $file->getPathname() ) ) {
					wp_delete_file( $file->getPathname() );
				}
			}
		} catch ( \UnexpectedValueException ) {
			// Only the top folder failing to open lands here; an unreadable subfolder is skipped by CATCH_GET_CHILD.
			return;
		}
	}

	/** Writes the deny rule and index file a folder is missing. */
	private static function guard( string $dir, string $root ): bool {
		foreach ( self::GUARDS as $name => $contents ) {
			if ( ! file_exists( $dir . '/' . $name ) && ! Filesystem::write( $dir . '/' . $name, $contents, $root ) ) {
				return false;
			}
		}

		return true;
	}
}