<?php
/**
 * Keep URL — the redirects core leaves out.
 *
 * WordPress already redirects a renamed post. It does it in wp_check_for_changed_slugs(), which
 * stores _wp_old_slug, and wp_old_slug_redirect(), which serves the 301. NONE OF THAT IS
 * REIMPLEMENTED HERE, and it must not be — a duplicate redirect layer is a bug, not a feature.
 *
 * This covers only what core deliberately skips. Verified against the core function, which bails
 * on two conditions:
 *
 *   1. `if ( $post->post_name === $post_before->post_name ) return;`
 *      A page moved to a different parent keeps its slug, so core records nothing — even though
 *      its address changed completely.
 *
 *   2. `|| is_post_type_hierarchical( $post->post_type )`
 *      Pages get nothing at all. Trac #4328, open for years.
 *
 * Non-hierarchical post types are therefore left entirely alone: core has them covered, and their
 * permalinks do not include the parent, so a parent change does not move them.
 *
 * @package Adminkeep
 */

namespace Adminkeep\Feature;

use Adminkeep\Feature;
use Adminkeep\Service\PathRedirectResolver;
use Adminkeep\Service\PathRedirectStore;

defined( 'ABSPATH' ) || exit;

/**
 * Records the addresses a page used to answer on, and 301s them to where it lives now.
 */
class KeepUrl implements Feature {

	/**
	 * Paths captured before an update, keyed by post id.
	 *
	 * @var array
	 */
	private $old_paths = array();

	/**
	 * Feature id.
	 *
	 * @return string
	 */
	public function id() {
		return 'keep_url';
	}

	/**
	 * Label.
	 *
	 * @return string
	 */
	public function label() {
		return __( 'Keep URL', 'adminkeep' );
	}

	/**
	 * Description.
	 *
	 * @return string
	 */
	public function description() {
		return __( 'Rename or move a page and its old address keeps working. WordPress already does this for posts but not for pages, and for nothing at all when you move a page under a different parent — which is when whole sections of a site break at once.', 'adminkeep' );
	}

	/**
	 * A word for what this feature is doing right now.
	 *
	 * @return string
	 */
	public function state_label() {
		return __( 'Watching', 'adminkeep' );
	}

	/**
	 * Settings schema. No translated strings — this runs before init.
	 *
	 * @return array
	 */
	public function settings_schema() {
		return array(
			'recorded' => array(
				'type'    => 'array',
				'default' => array(),
				'ui'      => 'status',
			),
		);
	}

	/**
	 * Field labels, resolved at render time.
	 *
	 * @param string $key Field key.
	 * @return string
	 */
	public function field_label( $key ) {
		if ( 'recorded' === $key ) {
			return __( 'Addresses being kept alive', 'adminkeep' );
		}

		return '';
	}

	/**
	 * What switching this on actually does.
	 *
	 * @return string[]
	 */
	public function how_it_works() {
		return array(
			__( 'Watches published pages for an address change — the page\'s own slug, a parent\'s slug, or being moved under a different parent.', 'adminkeep' ),
			__( 'Records the old address and sends it to the new one with a permanent redirect, so links and search rankings follow the page.', 'adminkeep' ),
			__( 'Renaming a parent page fixes every page underneath it, not just the parent.', 'adminkeep' ),
			__( 'Posts are left alone: WordPress already redirects those, and a second layer doing the same job is a bug waiting to happen.', 'adminkeep' ),
			__( 'If a page is later trashed, its old addresses stop redirecting rather than pointing at a missing page.', 'adminkeep' ),
			__( 'Switching this off stops new addresses being recorded. The ones already recorded keep working, because a redirect that disappeared would strand every link pointing at it. Remove them individually below, or uninstall the plugin to drop them all.', 'adminkeep' ),
		);
	}

	/**
	 * Register hooks.
	 *
	 * @param array $settings Resolved settings. Unused — this feature has none.
	 * @return void
	 */
	public function boot( array $settings ) {
		add_action( 'pre_post_update', array( $this, 'capture_paths' ), 10, 1 );
		add_action( 'post_updated', array( $this, 'record_changes' ), 10, 1 );
		add_action( 'before_delete_post', array( $this, 'forget_post' ), 10, 1 );

		add_action( 'template_redirect', array( $this, 'maybe_redirect' ), 5 );
	}

	/**
	 * Whether this post type is one core leaves uncovered.
	 *
	 * @param \WP_Post $post Post to check.
	 * @return bool
	 */
	private function is_covered_by_core( \WP_Post $post ) {
		return ! is_post_type_hierarchical( $post->post_type );
	}

	/**
	 * Capture the addresses of a page and everything under it, before the update lands.
	 *
	 * Runs on pre_post_update, so get_page_uri() still sees the old ancestor chain. Descendants
	 * matter because renaming a parent moves every page beneath it and core records none of them.
	 *
	 * @param int $post_id Post about to be updated.
	 * @return void
	 */
	public function capture_paths( $post_id ) {
		$post = get_post( $post_id );

		if ( ! $post instanceof \WP_Post || $this->is_covered_by_core( $post ) ) {
			return;
		}

		// Only a published page has an address worth keeping alive.
		if ( 'publish' !== $post->post_status ) {
			return;
		}

		foreach ( array_merge( array( (int) $post_id ), $this->descendants_of( $post ) ) as $id ) {
			$this->old_paths[ $id ] = get_page_uri( $id );
		}
	}

	/**
	 * Record every address that actually changed.
	 *
	 * @param int $post_id Post that was updated.
	 * @return void
	 */
	public function record_changes( $post_id ) {
		if ( empty( $this->old_paths ) ) {
			return;
		}

		$captured        = $this->old_paths;
		$this->old_paths = array();

		foreach ( $captured as $id => $old_path ) {
			// The ancestor chain changed under these, so their cached objects can be stale.
			clean_post_cache( $id );

			$post = get_post( $id );

			if ( ! $post instanceof \WP_Post || 'publish' !== $post->post_status ) {
				continue;
			}

			$new_path = get_page_uri( $id );

			if ( '' === $old_path || $new_path === $old_path ) {
				continue;
			}

			PathRedirectStore::record( $old_path, $id );

			// This page now occupies an address something used to redirect away from. Leaving
			// that row would send the visitor away from the page they correctly asked for.
			PathRedirectStore::forget( $new_path );
		}
	}

	/**
	 * Drop recorded addresses for a post being permanently deleted.
	 *
	 * Trashing deliberately does not do this — a trashed page can be restored, and its addresses
	 * should come back with it. Until then the resolver refuses to redirect to it.
	 *
	 * @param int $post_id Post being deleted.
	 * @return void
	 */
	public function forget_post( $post_id ) {
		PathRedirectStore::forget_post( $post_id );
	}

	/**
	 * On a 404, send the visitor where the page went.
	 *
	 * @return void
	 */
	public function maybe_redirect() {
		if ( ! is_404() ) {
			return;
		}

		$target = PathRedirectResolver::resolve( PathRedirectResolver::requested_path() );

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

		// Only leave if the redirect was actually sent. Something on the wp_redirect filter can
		// veto it, and exiting anyway would turn a vetoed redirect into a blank page.
		if ( wp_safe_redirect( $target, 301 ) ) {
			exit;
		}
	}

	/**
	 * Published descendants of a page, depth-first.
	 *
	 * @param \WP_Post $post Ancestor.
	 * @return int[]
	 */
	private function descendants_of( \WP_Post $post ) {
		global $wpdb;

		$found = array();
		$queue = array( (int) $post->ID );
		$seen  = array( (int) $post->ID => true );

		while ( ! empty( $queue ) ) {
			$parent = array_shift( $queue );

			$children = $wpdb->get_col( // phpcs:ignore WordPress.DB.DirectDatabaseQuery
				$wpdb->prepare(
					"SELECT ID FROM {$wpdb->posts} WHERE post_parent = %d AND post_type = %s AND post_status = 'publish'",
					$parent,
					$post->post_type
				)
			);

			foreach ( $children as $child_id ) {
				$child_id = (int) $child_id;

				// A malformed parent chain must not spin forever.
				if ( isset( $seen[ $child_id ] ) ) {
					continue;
				}

				$seen[ $child_id ] = true;
				$found[]           = $child_id;
				$queue[]           = $child_id;
			}
		}

		return $found;
	}

	/**
	 * The recorded addresses, for the settings screen.
	 *
	 * @return array
	 */
	public function status() {
		$rows = array();

		foreach ( PathRedirectStore::all( 50 ) as $row ) {
			$permalink = get_permalink( (int) $row['post_id'] );
			$post      = get_post( (int) $row['post_id'] );
			$live      = $post instanceof \WP_Post && 'publish' === $post->post_status;

			$rows[] = array(
				array(
					'text' => '/' . $row['old_path'],
					'tone' => 'mono',
				),
				$live && $permalink
					? PathRedirectResolver::path_of( $permalink )
					: __( 'not redirecting — the page is not published', 'adminkeep' ),
			);
		}

		return array(
			'columns' => array(
				__( 'Old address', 'adminkeep' ),
				__( 'Now goes to', 'adminkeep' ),
			),
			'rows'    => $rows,
			'empty'   => __( 'No addresses recorded yet. One appears here the first time you rename or move a published page.', 'adminkeep' ),
		);
	}
}