<?php

namespace DaftPlug\Rankify\Features\Meta;

if (!defined('ABSPATH')) {
  exit();
}

/**
 * What the current request actually is, resolved once and shared.
 *
 * Titles, robots directives, canonicals, social tags and the schema graph all
 * need the same three answers — which kind of view is this, which object is it
 * about, and which settings key holds its templates. Resolving that separately
 * in five classes is where the inconsistencies creep in (the classic symptom
 * being a canonical that disagrees with og:url), so it happens exactly once
 * here and everything else reads from it.
 */
class Context
{
  const TYPE_HOME = 'home';
  const TYPE_SINGULAR = 'singular';
  const TYPE_POST_TYPE_ARCHIVE = 'postTypeArchive';
  const TYPE_TAXONOMY = 'taxonomy';
  const TYPE_AUTHOR = 'author';
  const TYPE_DATE = 'date';
  const TYPE_SEARCH = 'search';
  const TYPE_NOT_FOUND = 'notFound';

  /** @var Context|null Per-request memo. */
  protected static $current = null;

  /** @var string One of the TYPE_* constants. */
  public $type = self::TYPE_NOT_FOUND;

  /** @var \WP_Post|\WP_Term|\WP_User|null The object this view is about. */
  public $object = null;

  /** @var int 0 when the view is not about a single object. */
  public $objectId = 0;

  /** @var string Post type for singular and post type archive views. */
  public $postType = '';

  /** @var string Taxonomy for term archives. */
  public $taxonomy = '';

  /**
   * Settings key this view's templates live under, e.g. 'post', 'tax_category',
   * 'author'. Kept separate from $type because every post type and taxonomy is
   * separately configurable while sharing one type.
   */
  public $settingsKey = '';

  /** @var int Current page of a paginated view, 1-based. */
  public $page = 1;

  /**
   * Resolve the current request, memoized.
   *
   * Deliberately not cached across requests — it is derived entirely from the
   * main query, which is cheap to read and different on every request anyway.
   */
  public static function current()
  {
    if (self::$current === null) {
      self::$current = self::resolve();
    }

    return self::$current;
  }

  /**
   * Drop the memo. Only needed by tests and by code that legitimately runs the
   * output pipeline more than once per request (the meta preview endpoint).
   */
  public static function flush()
  {
    self::$current = null;
  }

  protected static function resolve()
  {
    $context = new self();
    $context->page = self::resolvePage();

    // Order matters. is_home() is true on a blog-posts front page and
    // is_front_page() is true on a static one, so the front page has to be
    // settled before anything else claims the request.
    if (is_404()) {
      $context->type = self::TYPE_NOT_FOUND;
      $context->settingsKey = 'notFound';

      return $context;
    }

    if (is_search()) {
      $context->type = self::TYPE_SEARCH;
      $context->settingsKey = 'search';

      return $context;
    }

    if (is_front_page() || is_home()) {
      $context->type = self::TYPE_HOME;
      $context->settingsKey = 'home';

      // A static front page is still a real post, and its per-post overrides
      // have to win over the home template.
      $frontId = (int) get_option('page_on_front');
      if (is_front_page() && 'page' === get_option('show_on_front') && $frontId) {
        $context->object = get_post($frontId);
        $context->objectId = $frontId;
        $context->postType = 'page';
      }

      return $context;
    }

    if (is_singular()) {
      $post = get_queried_object();
      $context->type = self::TYPE_SINGULAR;
      $context->object = $post instanceof \WP_Post ? $post : null;
      $context->objectId = $context->object ? (int) $context->object->ID : 0;
      $context->postType = $context->object ? $context->object->post_type : '';
      $context->settingsKey = $context->postType;

      return $context;
    }

    if (is_post_type_archive()) {
      $postType = get_query_var('post_type');
      if (is_array($postType)) {
        $postType = reset($postType);
      }
      $context->type = self::TYPE_POST_TYPE_ARCHIVE;
      $context->postType = (string) $postType;
      $context->settingsKey = 'pta_' . $context->postType;

      return $context;
    }

    if (is_category() || is_tag() || is_tax()) {
      $term = get_queried_object();
      $context->type = self::TYPE_TAXONOMY;
      $context->object = $term instanceof \WP_Term ? $term : null;
      $context->objectId = $context->object ? (int) $context->object->term_id : 0;
      $context->taxonomy = $context->object ? $context->object->taxonomy : '';
      $context->settingsKey = 'tax_' . $context->taxonomy;

      return $context;
    }

    if (is_author()) {
      $user = get_queried_object();
      $context->type = self::TYPE_AUTHOR;
      $context->object = $user instanceof \WP_User ? $user : null;
      $context->objectId = $context->object ? (int) $context->object->ID : 0;
      $context->settingsKey = 'author';

      return $context;
    }

    if (is_date()) {
      $context->type = self::TYPE_DATE;
      $context->settingsKey = 'date';

      return $context;
    }

    // Anything left is an archive shape we do not template separately.
    $context->type = self::TYPE_POST_TYPE_ARCHIVE;
    $context->settingsKey = 'pta_post';

    return $context;
  }

  /**
   * Both `paged` (archive pagination) and `page` (a multi-page single post)
   * matter, and only one is ever set, so taking the larger gets the right
   * number without caring which kind of view this is.
   */
  protected static function resolvePage()
  {
    $paged = (int) get_query_var('paged');
    $page = (int) get_query_var('page');

    return max(1, $paged, $page);
  }

  public function isPaged()
  {
    return $this->page > 1;
  }

  /**
   * True when this view is about a post that actually exists. Guards every
   * get_post_meta() call, since objectId is also set for terms and users.
   */
  public function hasPost()
  {
    return $this->object instanceof \WP_Post;
  }

  public function hasTerm()
  {
    return $this->object instanceof \WP_Term;
  }

  public function hasUser()
  {
    return $this->object instanceof \WP_User;
  }
}