<?php
/**
 * The GA4 events offered in the site editor.
 *
 * @package TurtleReport
 */

namespace TurtleReport\Google;

defined( 'ABSPATH' ) || exit;

/**
 * Merges what a property recorded with what GA4 marks as key events.
 *
 * Two lists answer two different questions. The recorded list says what the
 * property is actually sending, which is the only way to spot a custom event
 * name nobody wrote down. The key-event list says which of those the property
 * owner treats as a conversion, and it holds events the chosen period happens
 * not to have recorded, so a newly configured or seasonal conversion is still
 * offered rather than silently missing.
 *
 * Nothing here is applied on its own: the editor ticks nothing until someone
 * says so. Reports are unaffected, because they count only the events a site
 * has been configured with.
 */
final class EventCatalog {

	/**
	 * Event names that usually mean a conversion.
	 *
	 * GA4's own recommended events, plus the names analytics setups most often
	 * use for the same things.
	 */
	const LIKELY = array(
		'generate_lead',
		'purchase',
		'sign_up',
		'subscribe',
		'begin_checkout',
		'add_to_cart',
		'trial_start',
		'book_meeting',
		'book_appointment',
		'file_download',
		'contact',
		'form_submit',
		'form_submission',
		'submit_lead_form',
		'request_quote',
		'phone_call',
		'click_to_call',
	);

	/**
	 * Word parts in an event name that hint at a conversion.
	 */
	const LIKELY_PATTERN = '/(lead|purchase|checkout|contact|enquir|inquir|quote|appointment|booking|sign_?up|subscrib|download|submit)/i';

	/**
	 * Builds the list for the editor's event picker.
	 *
	 * @param array[]  $recorded   Rows with name and count, as recorded in the period.
	 * @param string[] $key_events Event names GA4 marks as key events.
	 * @return array[] Items with name, count, key and suggested; key events first.
	 */
	public static function build( array $recorded, array $key_events ) {
		$keys = array();
		foreach ( $key_events as $name ) {
			$name = (string) $name;
			if ( '' !== $name ) {
				$keys[ $name ] = true;
			}
		}

		$out  = array();
		$seen = array();
		foreach ( $recorded as $row ) {
			$name = isset( $row['name'] ) ? (string) $row['name'] : '';
			if ( '' === $name || isset( $seen[ $name ] ) ) {
				continue;
			}
			$seen[ $name ] = true;
			$out[]         = self::item( $name, isset( $row['count'] ) ? (int) $row['count'] : 0, isset( $keys[ $name ] ) );
		}

		// Key events with no activity in the period are still offered, so they can be chosen before they fire.
		foreach ( array_keys( $keys ) as $name ) {
			if ( ! isset( $seen[ $name ] ) ) {
				$seen[ $name ] = true;
				$out[]         = self::item( $name, 0, true );
			}
		}

		usort(
			$out,
			static function ( $a, $b ) {
				if ( $a['key'] !== $b['key'] ) {
					return $a['key'] ? -1 : 1;
				}
				if ( $a['count'] !== $b['count'] ) {
					return $a['count'] < $b['count'] ? 1 : -1;
				}
				return strcmp( $a['name'], $b['name'] );
			}
		);

		return $out;
	}

	/**
	 * One event in the list.
	 *
	 * @param string $name   Event name.
	 * @param int    $count  Times recorded in the period.
	 * @param bool   $is_key Whether GA4 marks it as a key event.
	 * @return array
	 */
	private static function item( $name, $count, $is_key ) {
		return array(
			'name'      => $name,
			'count'     => (int) $count,
			'key'       => (bool) $is_key,
			'suggested' => self::suggested( $name, $is_key ),
		);
	}

	/**
	 * Whether to put this event forward as a likely conversion.
	 *
	 * A suggestion only draws the eye; it never ticks anything.
	 *
	 * @param string $name   Event name.
	 * @param bool   $is_key Whether GA4 marks it as a key event.
	 * @return bool
	 */
	private static function suggested( $name, $is_key ) {
		if ( $is_key ) {
			return true;
		}

		/**
		 * Filters the event names treated as likely conversions in the site editor.
		 *
		 * @param string[] $names Event names.
		 */
		$names = (array) apply_filters( 'turtlereport_conversion_event_names', self::LIKELY );
		foreach ( $names as $likely ) {
			if ( 0 === strcasecmp( $name, (string) $likely ) ) {
				return true;
			}
		}
		return (bool) preg_match( self::LIKELY_PATTERN, $name );
	}
}