<?php
/**
 * @fs_premium_only
 *
 * Token-savings estimator.
 *
 * Compares, over a bounded sample of the site's content, the size of the
 * rendered HTML the crawler would otherwise parse against the clean Markdown
 * this plugin serves, and turns the difference into an estimated token and
 * bandwidth saving. Uses a coarse ~4-chars-per-token heuristic (typical for
 * English prose); the point is a real, site-specific order-of-magnitude, not a
 * tokenizer-exact figure.
 *
 * The result is cached in a transient so the (potentially heavy) sampling runs
 * at most once a day unless forced from the admin.
 *
 * @package ADG_AI_Markdown
 */

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

class ADG_AIM_Token_Savings {

	/** Rough characters-per-token ratio. */
	const CHARS_PER_TOKEN = 4;

	/** How many posts to sample. */
	const SAMPLE = 40;

	/** Cache TTL. */
	const TRANSIENT = 'adg_aim_token_savings';

	/**
	 * Get the (cached) estimate, computing it on a miss.
	 *
	 * @param bool $force Recompute and refresh the cache.
	 * @return array
	 */
	public static function get( $force = false ) {
		if ( ! $force ) {
			$cached = get_transient( self::TRANSIENT );
			if ( is_array( $cached ) ) {
				return $cached;
			}
		}
		$data = self::compute();
		set_transient( self::TRANSIENT, $data, DAY_IN_SECONDS );
		return $data;
	}

	/**
	 * Compute the estimate over a content sample.
	 *
	 * @return array {
	 *   @type int   posts        Sampled post count.
	 *   @type int   html_bytes   Total rendered-HTML bytes.
	 *   @type int   md_bytes     Total Markdown bytes.
	 *   @type int   bytes_saved  html_bytes - md_bytes (>= 0).
	 *   @type float pct          Percentage reduction (0..100).
	 *   @type int   tokens_html  Estimated tokens for the HTML.
	 *   @type int   tokens_md    Estimated tokens for the Markdown.
	 *   @type int   tokens_saved Estimated tokens saved.
	 * }
	 */
	public static function compute() {
		$types = (array) ADG_AIM_Plugin::get_setting( 'post_types', array( 'post', 'page' ) );
		if ( empty( $types ) ) {
			$types = array( 'post', 'page' );
		}

		$posts = get_posts(
			array(
				'post_type'        => $types,
				'post_status'      => 'publish',
				'numberposts'      => self::SAMPLE,
				'orderby'          => 'modified',
				'order'            => 'DESC',
			)
		);

		$html_bytes = 0;
		$md_bytes   = 0;
		$counted    = 0;

		foreach ( $posts as $post ) {
			if ( get_post_meta( $post->ID, '_adg_hide_from_ai_bots', true ) ) {
				continue;
			}

			$html = (string) apply_filters( 'the_content', $post->post_content );
			$md   = (string) ADG_AIM_Markdown_Cache::get( $post, false );

			$h = strlen( $html );
			$m = strlen( $md );
			if ( 0 === $h ) {
				continue;
			}

			$html_bytes += $h;
			$md_bytes   += $m;
			++$counted;
		}

		return self::shape( $counted, $html_bytes, $md_bytes );
	}

	/**
	 * Turn raw byte sums into the full result array.
	 *
	 * @param int $posts      Sampled posts.
	 * @param int $html_bytes HTML bytes.
	 * @param int $md_bytes   Markdown bytes.
	 * @return array
	 */
	private static function shape( $posts, $html_bytes, $md_bytes ) {
		$bytes_saved = max( 0, $html_bytes - $md_bytes );
		$pct         = $html_bytes > 0 ? round( ( $bytes_saved / $html_bytes ) * 100, 1 ) : 0.0;

		return array(
			'posts'        => (int) $posts,
			'html_bytes'   => (int) $html_bytes,
			'md_bytes'     => (int) $md_bytes,
			'bytes_saved'  => (int) $bytes_saved,
			'pct'          => (float) $pct,
			'tokens_html'  => self::tokens( $html_bytes ),
			'tokens_md'    => self::tokens( $md_bytes ),
			'tokens_saved' => max( 0, self::tokens( $html_bytes ) - self::tokens( $md_bytes ) ),
		);
	}

	/**
	 * Estimate tokens from a byte/char count.
	 *
	 * @param int $chars Character count.
	 * @return int
	 */
	public static function tokens( $chars ) {
		return (int) ceil( max( 0, (int) $chars ) / self::CHARS_PER_TOKEN );
	}

	/**
	 * Drop the cached estimate (e.g. after content changes or a manual refresh).
	 */
	public static function clear() {
		delete_transient( self::TRANSIENT );
	}
}