<?php
/**
 * Question Kind
 *
 * Sorts what the caller said into a few kinds, with code, not a model.
 *
 * Why: speed. A turn takes about 5.5 s before the first sound, and about 3 s
 * of that is the model reading the prompt.
 *
 * - Small talk ("hello", "thanks"): answered here in code. No model call.
 * - Anything else: the model answers. But we pick a short opening line to
 *   play while it thinks. The line depends on DO something or LOOK UP something.
 *
 * Small talk must match the WHOLE sentence. "How are you" is small talk.
 * "How are my ticket sales" is not.
 *
 * @package Aisentic\Voice
 */

declare( strict_types = 1 );

namespace Aisentic\Voice;

defined( 'ABSPATH' ) || exit;

/**
 * Finds what kind of thing the caller said.
 */
class Question_Kind {

	/**
	 * A greeting, a thank you, a goodbye. No question in it.
	 *
	 * @var string
	 */
	public const SMALL_TALK = 'small_talk';

	/**
	 * "Open the settings", "how do I create an event". They want to go
	 * somewhere or do something.
	 *
	 * @var string
	 */
	public const NAVIGATION = 'navigation';

	/**
	 * "How many events", "what is my busiest month". They want a fact.
	 *
	 * @var string
	 */
	public const LOOKUP = 'lookup';

	/**
	 * Anything we cannot place. The opening line stays neutral.
	 *
	 * @var string
	 */
	public const UNCLEAR = 'unclear';

	/**
	 * Words that mean "take me there" or "do this for me".
	 *
	 * @var string[]
	 */
	private const DOING = [
		'how do i',
		'how to',
		'how can i',
		'where do i',
		'where is',
		'where are',
		'open',
		'take me',
		'go to',
		'show me',
		'create',
		'add',
		'make',
		'set up',
		'edit',
		'change',
		'delete',
		'remove',
		'enable',
		'disable',
		'install',
		// Replies to the assistant's own question, like "yes, do that".
		// They give permission, so they count as requests ("Of course" fits).
		'do that',
		'do it',
		'go ahead',
		'please do',
		'yes please',
		'i want to',
		'i need to',
		'i would like to',
		'id like to',
		'can you take me',
		'can you show',
		'let me',
		'can you open',
		'can i',
	];

	/**
	 * Words that mean "tell me a number or a name".
	 *
	 * @var string[]
	 */
	private const ASKING = [
		'how many',
		'how much',
		'how are my',
		'how is my',
		'how are the',
		'how is the',
		'what is',
		'what are',
		'whats',
		'which',
		'when is',
		'when are',
		'who is',
		'list',
		'do i have',
		'is there',
		'are there',
		'tell me',
		'give me',
		'can you give',
		'can you tell',
		'details about',
		'details of',
		'show details',
		'check',
		'find',
		'search',
		'look up',
		'count',
	];

	/**
	 * Noises a person makes before they start the sentence.
	 *
	 * These are removed from the start before matching.
	 * Why: "So I want to see my bookings" must match "i want to". In a test,
	 * three of four real turns started with a word like "so" and were sorted
	 * wrong.
	 *
	 * @var string[]
	 */
	private const LEADING_NOISE = [
		'so',
		'hi',
		'hello',
		'um',
		'umm',
		'uh',
		'uhh',
		'erm',
		'er',
		'ah',
		'oh',
		'well',
		'okay',
		'ok',
		'right',
		'now',
		'hey',
		'yeah',
		'yep',
		'yes',
		'please',
		'actually',
		'basically',
		'like',
		'alright',
		'and',
		'but',
		'then',
		'just',
		'hmm',
	];

	/**
	 * Words a person adds on the end that change nothing.
	 *
	 * Removed from the END only. "How are you today" becomes "how are you".
	 * "How are my ticket sales today" loses "today" but is still not small
	 * talk, which is correct.
	 *
	 * @var string[]
	 */
	private const TRAILING_NOISE = [
		'today',
		'now',
		'then',
		'though',
		'anyway',
		'mate',
		'buddy',
		'sir',
		'maam',
		'please',
		'there',
		'man',
	];

	/**
	 * Phrases that ask this site for a figure it holds.
	 *
	 * A small part of ASKING, on purpose. A match here tells the model it
	 * MUST call a tool, so a wrong match changes the answer.
	 *
	 * "what is", "which" and "tell me" are left out. Why: "What is an event"
	 * needs no tool. Forcing a tool would give "I cannot see that".
	 *
	 * @var string[]
	 */
	private const WANTS_A_FIGURE = [
		'how many',
		'how much',
		'how are my',
		'how is my',
		'how are the',
		'how is the',
		'do i have',
		'is there',
		'are there',
		'list',
		'count',
	];

	/**
	 * Openings that mean "tell me", but start like a DOING phrase.
	 *
	 * These are removed, and the rest of the sentence is checked alone.
	 * Why: "I want to know how many bookings" matched "i want to" (DOING), so
	 * no tool was called. The model said 24 bookings. The site had 250,970.
	 * "I want to know how to create an event" is still DOING after the cut.
	 *
	 * @var string[]
	 */
	private const ASKING_TO_BE_TOLD = [
		'i want to know',
		'i need to know',
		'i would like to know',
		'id like to know',
		'i wanted to know',
	];

	/**
	 * Take off an opening that only means "tell me".
	 *
	 * @param string $plain The question, already lowercased and stripped.
	 * @return string What is left, or the question unchanged.
	 */
	private static function without_asking_to_be_told( string $plain ): string {
		foreach ( self::ASKING_TO_BE_TOLD as $phrase ) {
			if ( self::opens_with( $plain, $phrase ) ) {
				return trim( substr( $plain, strlen( $phrase ) ) );
			}
		}

		return $plain;
	}

	/**
	 * Check if this question names one of this site's settings.
	 *
	 * Looks for a setting name anywhere in the sentence, as a whole word.
	 * Why: settings questions start with "which" or "what is", and those are
	 * not in WANTS_A_FIGURE. Whole words, so "tax" does not match "taxi".
	 * The names come from integrations, through the filter below.
	 *
	 * @param string $plain The question, already lowercased and stripped.
	 * @return bool
	 */
	private static function names_a_setting( string $plain ): bool {
		/**
		 * Filters the setting names that make a spoken question a lookup.
		 *
		 * If the caller says one of these, the model must look it up first.
		 * Add only real setting names of your plugin, in lowercase.
		 * Do not add plain words like "settings": "which page has the
		 * settings" asks to open a page.
		 *
		 * @param string[] $subjects Setting names, lowercase.
		 */
		$subjects = (array) apply_filters( 'aisentic_voice_setting_subjects', [] );

		foreach ( $subjects as $subject ) {
			$subject = mb_strtolower( trim( (string) $subject ) );

			if ( '' !== $subject && 1 === preg_match( '/\b' . preg_quote( $subject, '/' ) . '\b/u', $plain ) ) {
				return true;
			}
		}

		return false;
	}

	/**
	 * Check if this question must use a tool before the model answers.
	 *
	 * When true, the "look it up first" instruction is sent on the first ask.
	 * Why: before, it was only sent on a retry. "How many tickets have I sold?"
	 * was answered from memory, rejected, and the retry cost 30.4 s.
	 *
	 * DOING phrases still win, like in of(): "how do I find the list" is not
	 * a question about a number.
	 *
	 * @param string $text What the caller said.
	 * @return bool
	 */
	public static function asks_to_be_looked_up( string $text ): bool {
		if ( ! empty( self::small_talk_replies( $text ) ) ) {
			return false;
		}

		$plain = self::plain( $text );

		if ( '' === $plain ) {
			return false;
		}

		// "I want to know how many..." is a question, not a request to open a
		// page. Remove the opening and check the rest.
		$plain = self::without_asking_to_be_told( $plain );

		if ( '' === $plain ) {
			return false;
		}

		foreach ( self::DOING as $phrase ) {
			if ( self::opens_with( $plain, $phrase ) ) {
				return false;
			}
		}

		foreach ( self::WANTS_A_FIGURE as $phrase ) {
			if ( self::opens_with( $plain, $phrase ) ) {
				return true;
			}
		}

		// The start did not ask for a number. Check for a setting name
		// anywhere in the sentence.
		return self::names_a_setting( $plain );
	}

	/**
	 * Find the kind of this sentence.
	 *
	 * @param string $text What the caller said.
	 * @return string One of the four constants above.
	 */
	public static function of( string $text ): string {
		if ( ! empty( self::small_talk_replies( $text ) ) ) {
			return self::SMALL_TALK;
		}

		// Lowercase, no punctuation, single spaces, no "so" or "um" at the
		// start. So "Um, how many?" and "how many" match the same way.
		$plain = self::plain( $text );

		if ( '' === $plain ) {
			return self::UNCLEAR;
		}

		// Check the START of the sentence first, DOING before ASKING.
		// - "How do I find the settings" is DOING, even with "find" in it.
		// - "How many ... open" is ASKING, because "how many" is at the start.
		foreach ( [ self::DOING, self::ASKING ] as $index => $phrases ) {
			foreach ( $phrases as $phrase ) {
				if ( self::opens_with( $plain, $phrase ) ) {
					return 0 === $index ? self::NAVIGATION : self::LOOKUP;
				}
			}
		}

		// No match at the start. Now look anywhere in the sentence.
		// A loose match is fine here. A wrong match only changes the short
		// opening line ("Of course" or "Let me see"), not the answer.
		foreach ( [ self::DOING, self::ASKING ] as $index => $phrases ) {
			foreach ( $phrases as $phrase ) {
				if ( false !== strpos( $plain, ' ' . $phrase . ' ' ) || self::ends_with( $plain, ' ' . $phrase ) ) {
					return 0 === $index ? self::NAVIGATION : self::LOOKUP;
				}
			}
		}

		return self::UNCLEAR;
	}

	/**
	 * Check if the sentence starts with this phrase, as whole words.
	 *
	 * "list" must not match "listen", and "add" must not match "address".
	 * After plain(), a whole word ends with a space or the end of the text.
	 *
	 * @param string $text   The sentence, from plain().
	 * @param string $phrase The phrase to look for.
	 * @return bool
	 */
	private static function opens_with( string $text, string $phrase ): bool {
		$length = strlen( $phrase );

		return 0 === strpos( $text, $phrase ) && ( strlen( $text ) === $length || ' ' === $text[ $length ] );
	}

	/**
	 * Check if the sentence ends with this phrase.
	 *
	 * @param string $text   The sentence.
	 * @param string $phrase The phrase to look for.
	 * @return bool
	 */
	private static function ends_with( string $text, string $phrase ): bool {
		$at = strlen( $text ) - strlen( $phrase );

		return $at >= 0 && strpos( $text, $phrase, $at ) === $at;
	}

	/**
	 * A fixed reply to small talk, so no model call is needed.
	 *
	 * Why: a model call adds about 4 s and gives nothing for "hello".
	 * handle_greet() does the same for the first hello.
	 * English only, on purpose. Other languages go to the model, which
	 * answers in the right language.
	 *
	 * @param string $text What the caller said.
	 * @return string The line to say, or an empty string when this is a real
	 *                question and the model must answer it.
	 */
	public static function small_talk_reply( string $text ): string {
		return self::one_of( self::small_talk_replies( $text ) );
	}

	/**
	 * Every reply we would accept for this piece of small talk.
	 *
	 * Returns all of them, not one. The caller can only play a line whose
	 * audio clip is already made, so it picks from the full list.
	 * See Voice_Controller::pick_said().
	 *
	 * @param string $text What the caller said.
	 * @return string[] Empty when this is a real question for the model.
	 */
	public static function small_talk_replies( string $text ): array {
		// Try two versions: the raw text, and the text with noise words
		// ("so", "um", "today") removed. A version must match a phrase fully.
		// A real question has extra words, so it never matches.
		$tries = array_values(
			array_unique(
				array_filter(
					[
						self::letters( $text ),
						self::letters( self::plain( $text ) ),
					]
				)
			)
		);

		if ( empty( $tries ) ) {
			return [];
		}

		foreach ( self::small_talk() as $phrases => $replies ) {
			foreach ( explode( '|', (string) $phrases ) as $phrase ) {
				if ( in_array( self::letters( $phrase ), $tries, true ) ) {
					return array_values( array_filter( $replies ) );
				}
			}
		}

		return [];
	}

	/**
	 * The small talk we answer ourselves, and what we answer with.
	 *
	 * Key: the ways to say it, split by "|". Value: replies to pick from,
	 * so the caller does not hear the same reply twice.
	 *
	 * Keep this list short. A phrase here never reaches the model, so do
	 * not add anything that could be a real question.
	 *
	 * @return array<string,string[]>
	 */
	private static function small_talk(): array {
		return [
			'hi|hello|hey|hi there|hello there|yo'        => [
				__( 'Hey! What can I do for you?', 'aisentic' ),
				__( "Hello! I'm listening.", 'aisentic' ),
			],
			'how are you|how are you doing|how you doing|how r u|hows it going|how is it going|how is everything|hows everything|whats up|you okay|you ok' => [
				__( "I'm good, thanks for asking! What can I help you with?", 'aisentic' ),
				__( 'Doing well, thank you! What are we working on?', 'aisentic' ),
			],
			'good morning|good afternoon|good evening|morning' => [
				__( 'Good to hear from you! What shall we do?', 'aisentic' ),
			],
			'thanks|thank you|thanks a lot|thank you so much|cheers|ta' => [
				__( 'Anytime! Anything else?', 'aisentic' ),
				__( "You're welcome. Need anything else?", 'aisentic' ),
			],
			// Not here on purpose: ok, okay, alright, right, got it, sure,
			// cool, nice, great, yes.
			// Why: the assistant ends most answers with a question (rule 9 of
			// the voice prompt). So "okay" usually means "yes, go ahead". The
			// model must answer it, because it knows what was asked.
			'lovely|perfect|brilliant|wonderful'          => [
				__( 'Anything else I can find for you?', 'aisentic' ),
				__( 'Just say the word if you need more.', 'aisentic' ),
			],
			'who are you|what are you|whats your name|what is your name' => [
				__( "I'm your site assistant. I can look things up and open pages for you.", 'aisentic' ),
			],
			'what can you do|what do you do|help|can you help me' => [
				__( 'I can find things on your site and open the right page for you. Just ask.', 'aisentic' ),
			],
			'bye|goodbye|good bye|see you|see ya|thats all|that is all|nothing|no thanks|no thank you|im done|i am done' => [
				__( 'Bye for now! Just say the word when you need me.', 'aisentic' ),
				__( 'Alright, talk soon!', 'aisentic' ),
			],
			'sorry|my bad|never mind|nevermind|forget it' => [
				__( 'No problem at all. What would you like instead?', 'aisentic' ),
			],
		];
	}

	/**
	 * A short line to say while the model thinks, chosen to fit the question.
	 *
	 * "Of course" fits "open the settings". "Let me see" fits "how many
	 * events do I have".
	 * Keep lines to 2 or 3 words, each a full phrase. Why: "Happy to — one
	 * second." sounded unnatural, and the dash became a long pause.
	 *
	 * @param string $kind One of the constants above.
	 * @return string Empty for small talk, which needs no cover because it is
	 *                answered at once.
	 */
	public static function opening_line( string $kind ): string {
		return self::one_of( self::opening_lines( $kind ) );
	}

	/**
	 * Every opening line that would fit this kind of question.
	 *
	 * Returns all of them, for the same reason as small_talk_replies().
	 *
	 * @param string $kind One of the constants above.
	 * @return string[] Empty for small talk, which is answered at once.
	 */
	public static function opening_lines( string $kind ): array {
		$lines = [
			self::NAVIGATION => [
				__( 'Of course.', 'aisentic' ),
				__( 'Right away.', 'aisentic' ),
				__( 'Sure.', 'aisentic' ),
			],
			self::LOOKUP     => [
				__( 'Let me see.', 'aisentic' ),
				__( 'One moment.', 'aisentic' ),
			],
			self::UNCLEAR    => [
				__( 'Okay.', 'aisentic' ),
				__( 'Right.', 'aisentic' ),
				__( 'Understood.', 'aisentic' ),
				__( 'Got it.', 'aisentic' ),
				__( 'Let me check.', 'aisentic' ),
				__( 'One moment.', 'aisentic' ),
			],
		];

		return isset( $lines[ $kind ] ) ? array_values( array_filter( $lines[ $kind ] ) ) : [];
	}

	/**
	 * Pick one at random.
	 *
	 * @param string[] $options Lines to choose between.
	 * @return string
	 */
	private static function one_of( array $options ): string {
		$options = array_values( array_filter( $options ) );

		if ( empty( $options ) ) {
			return '';
		}

		return $options[ wp_rand( 0, count( $options ) - 1 ) ];
	}

	/**
	 * Lowercase, no punctuation, single spaces.
	 *
	 * Also removes noise words from the start and end. Spaces are kept, so
	 * "how many" does not match inside "howmanyevents".
	 *
	 * @param string $text Raw text.
	 * @return string
	 */
	private static function plain( string $text ): string {
		$text = mb_strtolower( trim( $text ) );
		$text = (string) preg_replace( '/[^\p{L}\p{N}\s]+/u', ' ', $text );
		$text = (string) preg_replace( '/\s+/u', ' ', $text );

		$words = array_values( array_filter( explode( ' ', trim( $text ) ) ) );

		// Remove noise words from the start. "so um okay I want" becomes
		// "i want". Always keep at least one word, so "Okay" stays "okay".
		$left = count( $words );

		while ( $left > 1 && in_array( $words[0], self::LEADING_NOISE, true ) ) {
			array_shift( $words );
			--$left;
		}

		// Remove noise words from the end, but always keep at least one word.
		while ( $left > 1 && in_array( end( $words ), self::TRAILING_NOISE, true ) ) {
			array_pop( $words );
			--$left;
		}

		return implode( ' ', $words );
	}

	/**
	 * Letters and numbers only, lowercase.
	 *
	 * So "How are you?", "how are you" and "Howareyou" are the same.
	 * Used for whole-sentence matching of small talk.
	 *
	 * @param string $text Raw text.
	 * @return string
	 */
	private static function letters( string $text ): string {
		return mb_strtolower( (string) preg_replace( '/[^\p{L}\p{N}]+/u', '', $text ) );
	}
}