<?php
/**
 * Keeps the data model consistent.
 *
 * @package KarmaDocs
 */

namespace KarmaDocs;

defined( 'ABSPATH' ) || exit;

/**
 * Rules enforced:
 *  - A nested article always shares the category of its parent article.
 *  - An article's knowledge base term always matches its category's knowledge base.
 */
class Sync {

	/**
	 * Recursion guard.
	 *
	 * @var bool
	 */
	private static $running = false;

	/**
	 * Suspend flag used by bulk operations that already write consistent data.
	 *
	 * @var bool
	 */
	private static $suspended = false;

	/**
	 * Suspends / resumes syncing.
	 *
	 * @param bool $suspend Suspend.
	 */
	public static function suspend( $suspend = true ) {
		self::$suspended = (bool) $suspend;
	}

	/**
	 * Hooks.
	 */
	public function register() {
		add_action( 'save_post_' . PostTypes::ARTICLE, array( $this, 'on_save' ), 20 );
		add_action( 'rest_after_insert_' . PostTypes::ARTICLE, array( $this, 'on_rest_insert' ), 20 );
		add_action( 'set_object_terms', array( $this, 'on_set_terms' ), 20, 4 );
	}

	/**
	 * Classic save.
	 *
	 * @param int $post_id Post id.
	 */
	public function on_save( $post_id ) {
		if ( wp_is_post_revision( $post_id ) || wp_is_post_autosave( $post_id ) ) {
			return;
		}
		self::article( $post_id );
	}

	/**
	 * REST save (terms are assigned after save_post).
	 *
	 * @param \WP_Post $post Post.
	 */
	public function on_rest_insert( $post ) {
		self::article( $post->ID );
	}

	/**
	 * Category assignments.
	 *
	 * @param int    $object_id Object.
	 * @param array  $terms     Terms.
	 * @param array  $tt_ids    TT ids.
	 * @param string $taxonomy  Taxonomy.
	 */
	public function on_set_terms( $object_id, $terms, $tt_ids, $taxonomy ) {
		if ( Taxonomies::CATEGORY === $taxonomy && PostTypes::ARTICLE === get_post_type( $object_id ) ) {
			self::article( $object_id );
		}
	}

	/**
	 * Applies the rules to a single article (and cascades category to descendants).
	 *
	 * @param int $post_id Article id.
	 */
	public static function article( $post_id ) {
		if ( self::$running || self::$suspended ) {
			return;
		}
		self::$running = true;

		$post = get_post( $post_id );
		if ( $post && PostTypes::ARTICLE === $post->post_type ) {
			if ( $post->post_parent && PostTypes::ARTICLE === get_post_type( $post->post_parent ) ) {
				$parent_cat = Taxonomies::article_category( $post->post_parent );
				$own_cat    = Taxonomies::article_category( $post );
				if ( $parent_cat && ( ! $own_cat || $own_cat->term_id !== $parent_cat->term_id ) ) {
					wp_set_object_terms( $post->ID, array( (int) $parent_cat->term_id ), Taxonomies::CATEGORY );
				}
				if ( ! $parent_cat ) {
					$parent_kb = Taxonomies::article_kb( $post->post_parent );
					if ( $parent_kb ) {
						wp_set_object_terms( $post->ID, array( (int) $parent_kb->term_id ), Taxonomies::KB );
					}
				}
			}

			$cat = Taxonomies::article_category( $post );
			if ( $cat ) {
				$kb_id = Taxonomies::category_kb( $cat->term_id );
				if ( $kb_id ) {
					wp_set_object_terms( $post->ID, array( $kb_id ), Taxonomies::KB );
				}
			}

			self::cascade( $post->ID );
		}

		self::$running = false;
	}

	/**
	 * Copies an article's category + KB onto all of its descendants.
	 *
	 * @param int $post_id Parent article.
	 */
	public static function cascade( $post_id ) {
		$cat = Taxonomies::article_category( $post_id );
		$kb  = Taxonomies::article_kb( $post_id );

		$children = get_posts(
			array(
				'post_type'      => PostTypes::ARTICLE,
				'post_parent'    => $post_id,
				'post_status'    => 'any',
				'posts_per_page' => -1,
				'fields'         => 'ids',
			)
		);
		foreach ( $children as $child_id ) {
			wp_set_object_terms( $child_id, $cat ? array( (int) $cat->term_id ) : array(), Taxonomies::CATEGORY );
			if ( $kb ) {
				wp_set_object_terms( $child_id, array( (int) $kb->term_id ), Taxonomies::KB );
			}
			self::cascade( $child_id );
		}
	}
}