<?php
/**
 * Split content into small chunks for embedding.
 *
 * Paragraphs are split first, merged until they reach the target size, and then
 * given an overlap so that context is not lost at the boundary between two chunks.
 *
 * @package AI House
 */

defined( 'ABSPATH' ) || exit;

/**
 * Class MYBOT_Chunker
 */
class MYBOT_Chunker {

	/**
	 * Convert HTML into plain text.
	 *
	 * @param string $html HTML content.
	 * @return string
	 */
	public static function to_text( $html ) {
		$text = wp_strip_all_tags( (string) $html, true );
		$text = html_entity_decode( $text, ENT_QUOTES | ENT_HTML5, 'UTF-8' );

		// Normalize whitespace while preserving paragraph boundaries.
		$text = preg_replace( '/[ \t]+/u', ' ', $text );
		$text = preg_replace( '/\s*\n\s*/u', "\n", (string) $text );
		$text = preg_replace( '/\n{3,}/u', "\n\n", (string) $text );

		return trim( (string) $text );
	}

	/**
	 * UTF-8 safe string length.
	 *
	 * @param string $text The string.
	 * @return int
	 */
	public static function length( $text ) {
		return function_exists( 'mb_strlen' ) ? mb_strlen( (string) $text, 'UTF-8' ) : strlen( (string) $text );
	}

	/**
	 * UTF-8 safe string slice.
	 *
	 * @param string   $text   The string.
	 * @param int      $start  Starting position.
	 * @param int|null $length Length.
	 * @return string
	 */
	public static function slice( $text, $start, $length = null ) {
		if ( function_exists( 'mb_substr' ) ) {
			return null === $length ? mb_substr( (string) $text, $start, null, 'UTF-8' ) : mb_substr( (string) $text, $start, $length, 'UTF-8' );
		}

		return null === $length ? substr( (string) $text, $start ) : substr( (string) $text, $start, $length );
	}

	/**
	 * Split the text into chunks.
	 *
	 * @param string $text     Plain text.
	 * @param int    $size     Target size, in characters.
	 * @param int    $overlap  Number of overlapping characters.
	 * @return array
	 */
	public function split( $text, $size = 1200, $overlap = 200 ) {
		$text = trim( (string) $text );

		if ( '' === $text ) {
			return array();
		}

		$size    = max( 300, (int) $size );
		$overlap = max( 0, min( (int) ( $size / 3 ), (int) $overlap ) );

		$paragraphs = preg_split( '/\n\s*\n/u', $text );

		if ( ! is_array( $paragraphs ) ) {
			$paragraphs = array( $text );
		}

		$raw    = array();
		$buffer = '';

		foreach ( $paragraphs as $paragraph ) {
			$paragraph = trim( (string) $paragraph );

			if ( '' === $paragraph ) {
				continue;
			}

			// Short paragraph: merge it into the buffer until the target size is reached.
			if ( ( self::length( $buffer ) + self::length( $paragraph ) + 2 ) <= $size ) {
				$buffer .= ( '' === $buffer ? '' : "\n\n" ) . $paragraph;
				continue;
			}

			if ( '' !== $buffer ) {
				$raw[]  = $buffer;
				$buffer = '';
			}

			// Paragraph longer than the target size: cut at a sentence boundary if possible.
			while ( self::length( $paragraph ) > $size ) {
				$piece     = $this->cut_at_sentence( $paragraph, $size );
				$raw[]     = $piece;
				$paragraph = trim( self::slice( $paragraph, self::length( $piece ) ) );
			}

			$buffer = $paragraph;
		}

		if ( '' !== $buffer ) {
			$raw[] = $buffer;
		}

		return $this->apply_overlap( $raw, $overlap );
	}

	/**
	 * Cut a long paragraph at the nearest sentence boundary.
	 *
	 * @param string $text The text.
	 * @param int    $size Maximum size.
	 * @return string
	 */
	protected function cut_at_sentence( $text, $size ) {
		$window = self::slice( $text, 0, $size );

		// Look for a sentence terminator in the last 30% of the window.
		$search_from = (int) ( $size * 0.7 );
		$tail        = self::slice( $window, $search_from );

		if ( preg_match( '/^.*?[.!?…](?=\s|$)/us', $tail, $matches ) ) {
			return self::slice( $window, 0, $search_from + self::length( $matches[0] ) );
		}

		return $window;
	}

	/**
	 * Add overlap between adjacent chunks.
	 *
	 * @param array $chunks  Raw chunks.
	 * @param int   $overlap Number of overlapping characters.
	 * @return array
	 */
	protected function apply_overlap( $chunks, $overlap ) {
		if ( $overlap <= 0 || count( $chunks ) < 2 ) {
			return array_values( array_filter( $chunks, 'strlen' ) );
		}

		$result = array();
		$count  = count( $chunks );

		foreach ( $chunks as $index => $chunk ) {
			if ( 0 === $index ) {
				$result[] = $chunk;
				continue;
			}

			$previous = $chunks[ $index - 1 ];
			$tail     = self::slice( $previous, max( 0, self::length( $previous ) - $overlap ) );

			$result[] = trim( $tail . "\n\n" . $chunk );

			unset( $count );
		}

		return array_values( array_filter( $result, 'strlen' ) );
	}
}