<?php
/**
 * The [yopingme_status] shortcode: a compact public status strip.
 *
 * @package yopingme
 */

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

/**
 * Renders the connected account's status page as a one-line strip: overall
 * state, a dot per service, and always a link to the full hosted page.
 *
 * The link is the deal for using status pages from WordPress: the strip is a
 * teaser, the hosted page is the product, so markup() never emits a strip
 * without the link. The other side of that deal is silence on failure - an
 * unconfigured plugin, a deleted page, or an unreachable YoPingMe renders
 * nothing at all, because a public page is no place for our error copy.
 *
 * Data comes from the anonymous public JSON, never MCP: rendering a popular
 * page must not spend the account's metered queries (free plan: 50/day).
 */
class Yopingme_Status {

	/**
	 * Hook the shortcode and its stylesheet up. Unconditional, like
	 * Yopingme_Badge: the shortcode must work for logged-out visitors.
	 */
	public static function init() {
		add_shortcode( 'yopingme_status', array( __CLASS__, 'render' ) );
		add_action( 'wp_enqueue_scripts', array( __CLASS__, 'register_style' ) );
	}

	/**
	 * Register the (empty) style handle the inline CSS rides on. Enqueued
	 * lazily in render(), so pages without the shortcode ship no CSS.
	 */
	public static function register_style() {
		wp_register_style( 'yopingme-status', false, array(), YOPINGME_VERSION );
		wp_add_inline_style( 'yopingme-status', self::css() );
	}

	/**
	 * Shortcode callback.
	 *
	 * @param array|string $atts Shortcode attributes; `slug` overrides the
	 *                           configured page (documented limitation: two
	 *                           different slugs on one site share a single
	 *                           cache slot and will thrash it).
	 * @return string Empty string when there is nothing trustworthy to show.
	 */
	public static function render( $atts ) {
		$atts = is_array( $atts ) ? $atts : array();
		$page = get_option( 'yopingme_status_page', array() );

		$atts_slug = isset( $atts['slug'] ) ? $atts['slug'] : '';
		$slug      = is_scalar( $atts_slug ) ? (string) $atts_slug : '';
		$url       = '';
		if ( '' !== $slug ) {
			// An explicit attr slug composes its link from the renderer host:
			// there is no stored URL to prefer for it.
			$url = YOPINGME_STATUSPAGE_URL . rawurlencode( $slug );
		} elseif ( is_array( $page ) && ! empty( $page['slug'] ) && is_scalar( $page['slug'] ) ) {
			$slug     = (string) $page['slug'];
			$page_url = isset( $page['url'] ) ? $page['url'] : '';
			$url      = ( ! empty( $page_url ) && is_scalar( $page_url ) ) ? (string) $page_url : YOPINGME_STATUSPAGE_URL . rawurlencode( $slug );
		}

		if ( '' === $slug ) {
			return '';
		}

		$state = Yopingme_Status_Cache::get( $slug );
		if ( empty( $state['data'] ) ) {
			return '';
		}

		if ( function_exists( 'wp_enqueue_style' ) ) {
			wp_enqueue_style( 'yopingme-status' );
		}
		return self::markup( $state['data'], $url );
	}

	/**
	 * Worst state across the page's services.
	 *
	 * @param array $services Services from the public document.
	 * @return string up|down|confirming|unknown
	 */
	public static function rollup( $services ) {
		if ( ! is_array( $services ) || 0 === count( $services ) ) {
			return 'unknown';
		}
		$seen = array();
		foreach ( $services as $service ) {
			$raw_state = isset( $service['state'] ) ? $service['state'] : '';
			$seen[ is_scalar( $raw_state ) ? (string) $raw_state : '' ] = true;
		}
		foreach ( array( 'down', 'confirming', 'unknown', 'up' ) as $state ) {
			if ( isset( $seen[ $state ] ) ) {
				return $state;
			}
		}
		// Only future states we do not know: report them as unknown rather
		// than inventing a verdict.
		return 'unknown';
	}

	/**
	 * The overall one-liner for a rollup state. ASCII punctuation only.
	 *
	 * @param string $state Rollup state.
	 * @return string
	 */
	public static function rollup_label( $state ) {
		switch ( $state ) {
			case 'up':
				return __( 'All systems operational', 'yopingme' );
			case 'down':
				return __( 'Some systems are down', 'yopingme' );
			case 'confirming':
				return __( 'Checking a possible issue', 'yopingme' );
			default:
				return __( 'Status unknown', 'yopingme' );
		}
	}

	/**
	 * The strip's HTML. Pure: no options, no enqueues, fully testable.
	 *
	 * Every remote string is escaped here and nowhere else - the document
	 * comes from the account owner's page, but "it is my own data" is
	 * exactly the assumption stored XSS lives on.
	 *
	 * @param array  $doc      Decoded public status-page document.
	 * @param string $page_url Full status page URL for the mandatory link.
	 * @return string
	 */
	public static function markup( $doc, $page_url ) {
		$services = isset( $doc['services'] ) && is_array( $doc['services'] ) ? $doc['services'] : array();
		$state    = self::rollup( $services );

		$out  = '<div class="yopingme-status">';
		$out .= '<span class="yopingme-status-overall">' . self::dot( $state ) . ' ' . esc_html( self::rollup_label( $state ) ) . '</span>';

		foreach ( $services as $service ) {
			// Non-scalar name/state (an array or object in the remote JSON)
			// would otherwise trigger an "Array to string conversion"
			// warning on cast; treat a non-scalar name as no name at all.
			$raw_name = isset( $service['name'] ) ? $service['name'] : '';
			if ( ! is_scalar( $raw_name ) ) {
				continue;
			}
			$name = (string) $raw_name;
			if ( '' === $name ) {
				continue;
			}
			$raw_state = isset( $service['state'] ) ? $service['state'] : '';
			$svc_state = is_scalar( $raw_state ) ? (string) $raw_state : '';
			// The dot is the only visual cue for state; a sighted user reads
			// its color, so a screen-reader-only label carries the same
			// information for everyone else instead of relying on color alone.
			$out .= '<span class="yopingme-status-service">' . self::dot( $svc_state )
				. '<span class="screen-reader-text">' . esc_html( Yopingme_Widget::status_label( $svc_state ) ) . '</span>'
				. ' ' . esc_html( $name ) . '</span>';
		}

		$href = esc_url( $page_url );
		// Mandatory link contract: never render a strip without the link.
		// If the URL was rejected (malformed or non-http scheme), return nothing.
		if ( '' === $href ) {
			return '';
		}
		$out .= '<a class="yopingme-status-link" href="' . $href . '">' . esc_html( __( 'View full status page', 'yopingme' ) ) . '</a>';
		$out .= '</div>';
		return $out;
	}

	/**
	 * A colored state dot. Colors come from the dashboard widget so both
	 * surfaces always agree; unknown states get its gray default.
	 *
	 * @param string $state Service or rollup state.
	 * @return string
	 */
	private static function dot( $state ) {
		return '<span class="yopingme-status-dot" style="background:' . esc_attr( Yopingme_Widget::status_color( $state ) ) . '"></span>';
	}

	/**
	 * The strip's CSS: enough to read as one line with wrapping, restylable
	 * by the theme via the class names, no more.
	 *
	 * @return string
	 */
	private static function css() {
		return '.yopingme-status{display:flex;flex-wrap:wrap;gap:.75em;align-items:center;font-size:.95em}'
			. '.yopingme-status-dot{display:inline-block;width:.6em;height:.6em;border-radius:50%;vertical-align:baseline}'
			. '.yopingme-status-overall{font-weight:600}'
			// The link flows as an ordinary item rather than being pushed
			// right with margin-left:auto. Themes set the content width, and
			// an auto margin only looks deliberate in the narrow band where
			// the strip nearly fills the line: wider leaves the link marooned
			// across a gap, narrower drops it onto a line of its own.
			. '.yopingme-status-link{white-space:nowrap}'
			// Most themes already ship .screen-reader-text; this is a minimal
			// fallback (WordPress's own clip pattern) for themes that do not,
			// so the per-service state label stays hidden visually everywhere.
			. '.yopingme-status .screen-reader-text{border:0;clip:rect(1px,1px,1px,1px);clip-path:inset(50%);height:1px;margin:-1px;overflow:hidden;padding:0;position:absolute;width:1px;word-wrap:normal!important}';
	}
}