<?php
/**
 * Conditional reveal: a set or a field offered only when another set is
 * picked a certain way.
 *
 * The whole behaviour lives in this module: the rule normaliser, the
 * evaluator, the save-time rule validation, the activity fixpoint, the
 * storefront lock line and its script, and the rule builders on the product
 * panel. The engine only carries the seams: a rule rides the stored config as
 * data, and with nothing registered to evaluate it, everything simply shows.
 *
 * The basic vocabulary ships in every build: show or hide a set or a field
 * when a choice is picked or a field is answered (is, is not, is any of,
 * answered, empty), with and/or groups, uncapped. The numeric compares
 * (is more than, is less than, is exactly) ask the 'reveal' capability; a
 * rule that uses them on a build without it is IGNORED WHOLE and its row
 * simply shows, never judged with only half its conditions. The same line
 * holds on a paid build with a lapsed licence.
 *
 * @package AddOnBoss
 */

defined( 'ABSPATH' ) || exit;

/**
 * Normalise a reveal rule to the canonical multi-condition shape WITHOUT
 * touching stored data.
 *
 * A legacy { set, is } becomes one 'is' condition; the canonical
 * { match, conditions:[{set,op,value}] } passes straight through; anything empty
 * is an unconditional rule. Idempotent, so it can run on every read and a
 * merchant's next save quietly persists the newer shape: a lazy upgrade with no
 * migration and nothing to go wrong for products saved years ago.
 *
 * @return array{match:string,conditions:array<int,array{set:string,op:string,value:string}>}
 */
function addon_boss_normalize_when( $when ): array {
	$when = is_array( $when ) ? $when : array();
	// Direction. Everything ever stored is a SHOW rule and carries no act at
	// all, so absent must keep meaning show or every configured product on
	// every install flips over on update.
	$act = ( 'hide' === (string) ( $when['act'] ?? '' ) ) ? 'hide' : 'show';

	// One condition, cleaned or dropped. The vocabulary is words a merchant
	// says out loud, and each trigger kind offers only the words that fit it:
	// a choice is / is not / is any of / is answered; a field adds filled and
	// empty, and a numeric compare for the fields that hold numbers.
	$bb_clean_cond = static function ( $c ) {
		if ( ! is_array( $c ) ) {
			return null;
		}
		// A condition names EITHER a set or a field, never both. A field
		// trigger is the newer half; a set trigger is unchanged.
		$bb_set   = (string) ( $c['set'] ?? '' );
		$bb_field = '' === $bb_set ? (string) ( $c['field'] ?? '' ) : '';
		if ( '' === $bb_set && '' === $bb_field ) {
			return null;
		}
		$bb_ops = '' !== $bb_field
			? array( 'is', 'is_not', 'is_any', 'filled', 'empty', 'more', 'less', 'exact' )
			: array( 'is', 'is_not', 'is_any', 'filled', 'empty' );
		$op     = in_array( $c['op'] ?? 'is', $bb_ops, true ) ? (string) $c['op'] : 'is';
		// is_any carries SEVERAL answers ("Birthday or Anniversary") and
		// absorbs most OR demand inside one sentence; it stores a clean list.
		if ( 'is_any' === $op ) {
			$bb_vals = array();
			foreach ( (array) ( $c['value'] ?? array() ) as $bb_v ) {
				$bb_v = (string) $bb_v;
				if ( '' !== $bb_v && ! in_array( $bb_v, $bb_vals, true ) ) {
					$bb_vals[] = $bb_v;
				}
			}
			if ( ! $bb_vals ) {
				return null; // "is any of nothing" is not a rule.
			}
			// One value is just "is": store the simpler sentence it really is.
			if ( 1 === count( $bb_vals ) ) {
				return array( 'set' => $bb_set, 'field' => $bb_field, 'op' => 'is', 'value' => $bb_vals[0] );
			}
			return array( 'set' => $bb_set, 'field' => $bb_field, 'op' => 'is_any', 'value' => $bb_vals );
		}
		// A numeric compare needs a number to compare with, or it is nothing.
		if ( in_array( $op, array( 'more', 'less', 'exact' ), true ) ) {
			$bb_num = trim( (string) ( $c['value'] ?? '' ) );
			if ( '' === $bb_num || ! is_numeric( $bb_num ) ) {
				return null;
			}
			return array( 'set' => '', 'field' => $bb_field, 'op' => $op, 'value' => (string) (float) $bb_num );
		}
		return array(
			'set'   => $bb_set,
			'field' => $bb_field,
			'op'    => $op,
			// filled / empty carry no value; keeping one would let a stale
			// string decide something nobody can see on the screen.
			'value' => in_array( $op, array( 'filled', 'empty' ), true ) ? '' : (string) ( $c['value'] ?? '' ),
		);
	};

	// The normal form is act + GROUPS: conditions inside a group must all
	// hold (the printed word "and"), and any one group holding fires the rule
	// ("Or when..."). Every older shape maps in without touching stored data:
	// a flat all-list is one group; a flat any-list is one group per
	// condition, because OR of singles is exactly what "any" always meant.
	$bb_groups = array();
	if ( isset( $when['groups'] ) && is_array( $when['groups'] ) ) {
		foreach ( $when['groups'] as $bb_g ) {
			$bb_conds = array();
			foreach ( (array) ( is_array( $bb_g ) && isset( $bb_g['conditions'] ) ? $bb_g['conditions'] : $bb_g ) as $c ) {
				$bb_c = $bb_clean_cond( $c );
				if ( null !== $bb_c ) {
					$bb_conds[] = $bb_c;
				}
			}
			if ( $bb_conds ) {
				$bb_groups[] = $bb_conds;
			}
		}
	} elseif ( isset( $when['conditions'] ) && is_array( $when['conditions'] ) ) {
		$bb_conds = array();
		foreach ( $when['conditions'] as $c ) {
			$bb_c = $bb_clean_cond( $c );
			if ( null !== $bb_c ) {
				$bb_conds[] = $bb_c;
			}
		}
		if ( $bb_conds ) {
			if ( 'any' === ( $when['match'] ?? 'all' ) ) {
				foreach ( $bb_conds as $bb_c ) {
					$bb_groups[] = array( $bb_c );
				}
			} else {
				$bb_groups[] = $bb_conds;
			}
		}
	} elseif ( isset( $when['set'] ) && array_key_exists( 'is', $when ) && '' !== (string) $when['set'] ) {
		$bb_groups[] = array( array( 'set' => (string) $when['set'], 'field' => '', 'op' => 'is', 'value' => (string) $when['is'] ) );
	}

	return array( 'act' => $act, 'groups' => $bb_groups );
}

/**
 * Every condition of a normalised rule, group boundaries flattened away, for
 * the readers that ask about triggers rather than logic (which triggers are
 * referenced, are they all fields, do any name this set).
 *
 * @return array<int,array{set:string,field:string,op:string,value:mixed}>
 */
function addon_boss_when_all_conditions( array $normal ): array {
	$out = array();
	foreach ( (array) ( $normal['groups'] ?? array() ) as $bb_g ) {
		foreach ( (array) $bb_g as $bb_c ) {
			$out[] = $bb_c;
		}
	}
	return $out;
}

/**
 * Does a rule use the numeric compares, the half of the vocabulary that asks
 * the 'reveal' capability?
 *
 * @param mixed $when The stored rule, any shape.
 */
function addon_boss_when_is_deep( $when ): bool {
	foreach ( addon_boss_when_all_conditions( addon_boss_normalize_when( $when ) ) as $bb_c ) {
		if ( in_array( $bb_c['op'], array( 'more', 'less', 'exact' ), true ) ) {
			return true;
		}
	}
	return false;
}

/**
 * Does this build EVALUATE a given rule? The basic vocabulary always runs;
 * a rule carrying a numeric compare runs only with the capability. A rule
 * this build does not evaluate is ignored whole and its row shows: judging
 * it with only the conditions this build understands could hide a row for
 * a reason the merchant never wrote.
 *
 * @param mixed $when The stored rule, any shape.
 */
function addon_boss_when_runs_here( $when ): bool {
	return addon_boss_engine_can( 'reveal' ) || ! addon_boss_when_is_deep( $when );
}

/**
 * Is ONE condition satisfied by the current answers?
 *
 * A trigger that is itself hidden answers nothing, whether it is a set or a
 * field. That is the discipline that stops a chain being satisfied through a
 * middle nobody can see, and it applies to both kinds by the same line of code.
 *
 * @param array $cond   One normalised condition.
 * @param array $picks  Set id => picked keys, plus field:<key> => answer.
 * @param array $active The same keys => whether that trigger is on the page.
 * @return bool
 */
function addon_boss_condition_met( array $cond, array $picks, array $active ): bool {
	$bb_id = '' !== $cond['set'] ? $cond['set'] : ADDON_BOSS_FIELD_RULE_KEY . $cond['field'];
	// A trigger that is not on the page answers NOTHING, rather than answering
	// false. The difference matters: "is not red" is satisfied by a colour
	// nobody was asked for, and so is "is empty". Short-circuiting the whole
	// condition to false instead would quietly invert both.
	$bb_answers = empty( $active[ $bb_id ] )
		? array()
		// A several-of trigger's entry is its ARRAY of picked keys; a pick-one
		// set and a field both hand over a string. "Is" means "is among the
		// answers", which for one answer is exactly the old equality.
		: array_map( 'strval', (array) ( $picks[ $bb_id ] ?? '' ) );
	$bb_filled  = (bool) array_filter( $bb_answers, 'strlen' );
	switch ( $cond['op'] ) {
		case 'filled':
			return $bb_filled;
		case 'empty':
			return ! $bb_filled;
		case 'is_not':
			return ! in_array( $cond['value'], $bb_answers, true );
		case 'is_any':
			// Several answers in one sentence: met when ANY of them is among
			// what was picked. The value is a list by construction.
			return (bool) array_intersect( array_map( 'strval', (array) $cond['value'] ), $bb_answers );
		case 'more':
		case 'less':
		case 'exact':
			// A numeric compare of the first real answer. An unanswered field
			// compares as nothing at all, the same way "is" of nothing fails:
			// no answer can never be "more than 5".
			if ( ! $bb_filled ) {
				return false;
			}
			$bb_first = null;
			foreach ( $bb_answers as $bb_a ) {
				if ( '' !== $bb_a ) {
					$bb_first = $bb_a;
					break;
				}
			}
			if ( null === $bb_first || ! is_numeric( $bb_first ) ) {
				return false;
			}
			$bb_n = (float) $bb_first;
			$bb_t = (float) $cond['value'];
			return 'more' === $cond['op'] ? $bb_n > $bb_t : ( 'less' === $cond['op'] ? $bb_n < $bb_t : $bb_n === $bb_t );
		default:
			return in_array( $cond['value'], $bb_answers, true );
	}
}

/**
 * Is a reveal rule satisfied for one pick state?
 *
 * An unconditional rule is always TRUE in either match mode, so an empty rule
 * can never flip something to hidden. A condition tests a referenced set that
 * must itself be ACTIVE (an inert set's pick never counts) and picked with the
 * value; 'is_not' inverts. 'all' is AND, 'any' is OR.
 *
 * Those two are the classic client/server divergence footguns in this category,
 * so both are pinned by tests rather than left to reading.
 */
function addon_boss_when_met( $when, array $picks, array $active ): bool {
	$n = addon_boss_normalize_when( $when );
	if ( empty( $n['groups'] ) ) {
		return true;
	}
	$fired = addon_boss_when_groups_fired( $n, $picks, $active );
	if ( null === $fired ) {
		// PAUSED: the rule points at a question that is not on this product any
		// more. A paused rule rules nothing out, in either direction — the row
		// SHOWS, because visible breakage gets noticed and quietly-hidden
		// breakage never does. The builder says the same thing in words.
		return true;
	}
	// A HIDE rule says the opposite of what its conditions decide. The empty
	// case is handled above, deliberately: "hide when nothing" must never mean
	// "hide always", in either direction.
	return ( 'hide' === $n['act'] ) ? ! $fired : $fired;
}

/**
 * Did a normalised rule's conditions FIRE — before the act is applied?
 *
 * A group fires when EVERY condition in it holds (the printed word "and");
 * the rule fires when ANY group does ("Or when..."). One flat all-list is one
 * group; one flat any-list normalised to single-condition groups, so both of
 * yesterday's shapes keep exactly yesterday's answers.
 *
 * Returns NULL when the rule cannot be judged at all: some condition names a
 * trigger that is not in the state — a set taken off the product, a field row
 * deleted — as opposed to one that is attached but currently hidden, which
 * answers nothing and judges normally. Callers translate null to "paused".
 *
 * @param array $normal The {act,groups} shape from addon_boss_normalize_when().
 * @param array $picks  Trigger id => current answers.
 * @param array $active Trigger id => whether it is on the page; the KEY LIST
 *                      is the roster of what exists at all.
 * @return bool|null
 */
function addon_boss_when_groups_fired( array $normal, array $picks, array $active ) {
	foreach ( (array) ( $normal['groups'] ?? array() ) as $bb_g ) {
		foreach ( (array) $bb_g as $c ) {
			$bb_id = '' !== (string) $c['set'] ? (string) $c['set'] : ADDON_BOSS_FIELD_RULE_KEY . $c['field'];
			if ( ! array_key_exists( $bb_id, $active ) ) {
				return null;
			}
		}
	}
	foreach ( (array) ( $normal['groups'] ?? array() ) as $bb_g ) {
		$bb_all = true;
		foreach ( (array) $bb_g as $c ) {
			if ( ! addon_boss_condition_met( $c, $picks, $active ) ) {
				$bb_all = false;
				break;
			}
		}
		if ( $bb_all ) {
			return true;
		}
	}
	return false;
}

/**
 * Answer the engine's when-met seam with the real evaluator.
 *
 * @param bool  $shown  The default (visible).
 * @param mixed $when   The stored rule.
 * @param array $picks  Set id => picked option key.
 * @param array $active Set id => active.
 * @return bool
 */
function addon_boss_reveal_when_met( $shown, $when, array $picks, array $active ): bool {
	if ( ! addon_boss_when_runs_here( $when ) ) {
		return true; // a rule this build does not evaluate rules nothing out.
	}
	return addon_boss_when_met( $when, $picks, $active );
}
add_filter( 'addon_boss_when_met', 'addon_boss_reveal_when_met', 10, 4 );

/**
 * The reveal-rule second pass on a product's rows, applied to every row
 * including group children: a rule may only point at another set attached to
 * the product, with a real option of that set. Anything half-filled or
 * dangling is blanked. Mutates in place (groups recurse into their children).
 */
function addon_boss_validate_option_when( array &$rows, array $attached, array &$seen_fields = array() ): void {
	foreach ( $rows as $i => $row ) {
		if ( ( $row['row_type'] ?? '' ) === 'group' ) {
			$children = is_array( $row['children'] ?? null ) ? $row['children'] : array();
			addon_boss_validate_option_when( $children, $attached, $seen_fields );
			$rows[ $i ]['children'] = $children;
			continue;
		}
		// Validate through the canonical shape so a multi-condition rule survives
		// this pass. Reading only { set, is } silently blanked every rule with
		// more than one condition, which looked exactly like the save failing.
		$rule = addon_boss_normalize_when( $row['when'] ?? array() );

		// A SET row's rule may only speak the positive words. Its show rules
		// join the activation fixpoint, which converges because it only ever
		// turns things on; a negative there could leave the server counting a
		// required set active that the settled page hides — a checkout nobody
		// can complete. The builder never offers the words; this line keeps
		// hand-crafted data to the same grammar. Field rows, which nothing
		// else depends on, keep the full vocabulary.
		$bb_set_row = ( $row['row_type'] ?? '' ) !== 'field';

		// One condition, kept, repaired (is_any with a dead value keeps its live
		// ones) or dropped. Shared by every group so no group validates by a
		// different rulebook.
		$bb_judge = static function ( array $cond ) use ( $row, $attached, $seen_fields, $bb_set_row ) {
			$ref = (string) $cond['set'];
			if ( $bb_set_row && in_array( $cond['op'], array( 'is_not', 'empty' ), true ) ) {
				return null;
			}
			if ( '' !== (string) $cond['field'] ) {
				// A FIELD trigger must be a field already ASKED, which is to say
				// one of the rows above this one. That is what removes the need
				// for a fixpoint over field answers, and it makes a cycle
				// impossible rather than merely detected. (It also keeps a set
				// row from ruling on a field: the set fixpoint runs before the
				// field state exists, so such a rule could only ever pause.)
				$bb_f  = (string) $cond['field'];
				$bb_ok = isset( $seen_fields[ $bb_f ] )
					&& $bb_f !== (string) ( $row['field']['key'] ?? '' );
				if ( ! $bb_ok ) {
					return null;
				}
				if ( in_array( $cond['op'], array( 'is', 'is_not' ), true ) && '' === (string) $cond['value'] ) {
					return null; // "is" with nothing to compare against decides nothing
				}
				if ( 'is_any' === $cond['op'] && ! (array) $cond['value'] ) {
					return null;
				}
				return $cond;
			}
			if ( '' === $ref || $ref === ( $row['set'] ?? '' ) ) {
				return null;
			}
			$ref_set = in_array( $ref, $attached, true ) ? addon_boss_option_set( $ref ) : null;
			if ( ! $ref_set ) {
				// The set is off the product (or gone from the library). The
				// rule is KEPT, shape-checked only, and runs PAUSED — the row
				// shows and the builder says why. Blanking it here is how a
				// rival made re-attaching a set silently lose every rule that
				// pointed at it; visible breakage gets noticed, invisible
				// breakage never does.
				if ( in_array( $cond['op'], array( 'filled', 'empty' ), true ) ) {
					return $cond;
				}
				if ( 'is_any' === $cond['op'] ) {
					$bb_kept = array_values( array_filter( array_map( 'strval', (array) $cond['value'] ), 'addon_boss_option_key_valid' ) );
					if ( ! $bb_kept ) {
						return null;
					}
					$cond['value'] = $bb_kept;
					return $cond;
				}
				return addon_boss_option_key_valid( (string) $cond['value'] ) ? $cond : null;
			}
			$bb_keys = array_column( $ref_set['options'], 'key' );
			if ( 'is_any' === $cond['op'] ) {
				// Keep the values that are still real choices; one left is an
				// ordinary "is", none left is no condition.
				$bb_live = array_values( array_intersect( array_map( 'strval', (array) $cond['value'] ), $bb_keys ) );
				if ( ! $bb_live ) {
					return null;
				}
				if ( 1 === count( $bb_live ) ) {
					return array( 'set' => $ref, 'field' => '', 'op' => 'is', 'value' => $bb_live[0] );
				}
				$cond['value'] = $bb_live;
				return $cond;
			}
			$is = (string) $cond['value'];
			if ( in_array( $cond['op'], array( 'filled', 'empty' ), true ) ) {
				return $cond; // asks whether anything is picked; no value to check.
			}
			if ( '' === $is || ! addon_boss_option_key_valid( $is ) || ! in_array( $is, $bb_keys, true ) ) {
				return null;
			}
			return $cond;
		};

		$bb_groups = array();
		foreach ( (array) $rule['groups'] as $bb_g ) {
			$bb_kept = array();
			foreach ( $bb_g as $cond ) {
				$bb_c = $bb_judge( $cond );
				if ( null !== $bb_c ) {
					$bb_kept[] = $bb_c;
				}
			}
			if ( $bb_kept ) {
				$bb_groups[] = $bb_kept;
			}
		}

		// Recorded AFTER this row's own rule is judged, so a field can never
		// point at itself and the "above only" reading is exact. A field that
		// may not BE a trigger — display-only, hidden, an amount they choose —
		// is never recorded, so a rule pointing at one is judged dead here by
		// the same fence the builder's list applies.
		$bb_own_key = (string) ( $row['field']['key'] ?? '' );
		if ( '' !== $bb_own_key ) {
			$bb_own_type = (string) ( $row['field']['type'] ?? '' );
			$bb_types    = addon_boss_personalisation_field_types();
			if ( empty( $bb_types[ $bb_own_type ]['display_only'] )
				&& empty( $bb_types[ $bb_own_type ]['admin_only'] )
				&& empty( $bb_types[ $bb_own_type ]['own_amount'] ) ) {
				$seen_fields[ $bb_own_key ] = $bb_own_type;
			}
		}
		// Stored in the SMALLEST shape that says it (legacy single, flat, or
		// groups), so an ordinary rule is unchanged on disk and older readers
		// keep reading it.
		$rows[ $i ]['when'] = addon_boss_when_store_shape(
			array(
				'act'    => $rule['act'],
				'groups' => $bb_groups,
			)
		);
	}
}

/**
 * Hook the validation into the engine's row sanitiser.
 *
 * @param array $rows     The sanitised rows.
 * @param array $attached The attached set ids.
 * @return array
 */
function addon_boss_reveal_sanitize_rows( array $rows, array $attached ): array {
	addon_boss_validate_option_when( $rows, $attached );
	return $rows;
}
add_filter( 'addon_boss_sanitize_option_rows', 'addon_boss_reveal_sanitize_rows', 10, 2 );

/**
 * Which resolved sets are ACTIVE for one pick state: the fixpoint over the
 * rules. A conditional set is active only when its rule fires against the
 * settled state; chains resolve and cycles stay inactive.
 *
 * Reveal rules activate monotonically (a set only ever turns ON as the
 * fixpoint runs), which is what keeps this loop sound — and it stays sound
 * because a SET row's show rule is positive by construction: the builder
 * offers is / is any of / is answered there and spells every negative as a
 * "Hidden when" rule instead, judged once after the settle. A negative that
 * could turn a set back off mid-loop would let two sets flip each other
 * forever, and — worse — could leave the server counting a required set
 * active that the browser's settled page hides, which is a checkout nobody
 * can complete. Fields, which nothing else depends on, take the full
 * evaluator with the full vocabulary.
 *
 * @param array $active Set id => active, seeded ruleless-true by the engine.
 * @param array $sets   Resolved sets carrying 'when'.
 * @param array $picks  Set id => currently picked option key.
 * @return array<string,bool>
 */
function addon_boss_reveal_active_sets( array $active, array $sets, array $picks ): array {
	// A rule this build does not evaluate is ignored whole, in BOTH directions:
	// its set is active as if it had no rule, before the passes below ever
	// judge anything. Settled here so a deep show rule cannot leave a set
	// seeded-off and a deep hide rule cannot turn one off.
	foreach ( $sets as $set ) {
		if ( ! empty( $set['when'] ) && ! addon_boss_when_runs_here( $set['when'] ) ) {
			$active[ $set['id'] ] = true;
		}
	}
	$rounds = count( $sets );
	for ( $i = 0; $i < $rounds; $i++ ) {
		$changed = false;
		// Every rule this pass is judged against the SAME state — the one the
		// previous pass settled on — so the answer never depends on which row
		// happened to be walked first.
		$frozen = $active;
		foreach ( $sets as $set ) {
			if ( ! empty( $active[ $set['id'] ] ) || empty( $set['when'] ) ) {
				continue;
			}
			$rule = addon_boss_normalize_when( $set['when'] );
			if ( 'hide' === $rule['act'] || empty( $rule['groups'] ) ) {
				continue; // seeded active by the engine; the pass below turns it off.
			}
			// The builder only offers a SET row's show rule the positive words
			// (is, is any of, is answered) and puts every negative behind the
			// "Hidden when" act instead — see the note on the save validation.
			// Positives only ever go from unmet to met as sets turn on, which
			// is what lets this loop converge and is why the browser's own
			// evaluation of the same rules lands on the same state. A PAUSED
			// rule (null: its trigger is off the product) shows, the same
			// fail-safe as everywhere else.
			$fired = addon_boss_when_groups_fired( $rule, $picks, $frozen );
			if ( false !== $fired ) {
				$active[ $set['id'] ] = true;
				$changed              = true;
			}
		}
		if ( ! $changed ) {
			break;
		}
	}
	// HIDE rules, once, against the settled state. The pass above only ever
	// turns things ON, which is what makes a chain of show rules converge; a
	// hide rule is the other direction and cannot ride it. Judged after the
	// settle, its conditions read exactly the state the shopper's page shows,
	// so the server's last word and the browser's agree. A paused hide rule
	// (trigger gone) hides nothing.
	foreach ( $sets as $set ) {
		if ( empty( $set['when'] ) || ! addon_boss_when_runs_here( $set['when'] ) ) {
			continue;
		}
		$rule = addon_boss_normalize_when( $set['when'] );
		if ( 'hide' !== $rule['act'] || empty( $rule['groups'] ) ) {
			continue;
		}
		if ( true === addon_boss_when_groups_fired( $rule, $picks, $active ) ) {
			$active[ $set['id'] ] = false;
		}
	}
	return $active;
}
add_filter( 'addon_boss_active_option_sets', 'addon_boss_reveal_active_sets', 10, 3 );

/**
 * The availability line for a conditional group, in the customer's words
 * and the configurator convention: "Available when <set> is <option>". It
 * states the condition positively (no "locked", no "unlock" mechanism
 * language), and falls back gracefully if the trigger can no longer be
 * resolved. The same string is the accessible reason for the greyed group.
 */
function addon_boss_standalone_when_reason( array $when, array $sets ): string {
	$bb_norm    = addon_boss_normalize_when( $when );
	$bb_groups  = $bb_norm['groups'];
	$bb_generic = __( 'Available after an earlier choice', 'addon-boss' );
	// A hide rule's lock line would have to say "until", a several-ways rule
	// would have to pick one way to name, and a long rule would not fit the
	// line. All of them take the honest generic instead of a half-truth.
	if ( 'hide' === $bb_norm['act'] || 1 !== count( $bb_groups ) || count( $bb_groups[0] ) > 2 ) {
		return $bb_generic;
	}
	$bb_bits = array();
	foreach ( $bb_groups[0] as $c ) {
		if ( '' === (string) $c['set'] ) {
			return $bb_generic; // a field trigger is named by the builder, not here.
		}
		$bb_name  = '';
		$bb_multi = false;
		$bb_opts  = array();
		foreach ( $sets as $s ) {
			if ( ( $s['id'] ?? '' ) === $c['set'] ) {
				$bb_name  = (string) $s['name'];
				$bb_multi = ! empty( $s['multi'] );
				foreach ( (array) ( $s['options'] ?? array() ) as $o ) {
					$bb_opts[ (string) ( $o['key'] ?? '' ) ] = (string) ( $o['label'] ?? '' );
				}
			}
		}
		if ( '' === $bb_name ) {
			return $bb_generic;
		}
		if ( 'filled' === $c['op'] ) {
			/* translators: %s: option set name. e.g. "Printed sign is answered". */
			$bb_bits[] = sprintf( __( '%s is answered', 'addon-boss' ), $bb_name );
			continue;
		}
		if ( 'is' === $c['op'] && isset( $bb_opts[ (string) $c['value'] ] ) && '' !== $bb_opts[ (string) $c['value'] ] ) {
			$bb_bits[] = sprintf(
				/* translators: 1: option set name, 2: one option label, or several joined with "or". e.g. "Occasion is Birthday or Anniversary". */
				$bb_multi ? __( '%1$s includes %2$s', 'addon-boss' ) : __( '%1$s is %2$s', 'addon-boss' ),
				$bb_name,
				$bb_opts[ (string) $c['value'] ]
			);
			continue;
		}
		if ( 'is_any' === $c['op'] ) {
			$bb_labels = array();
			foreach ( (array) $c['value'] as $bb_v ) {
				if ( isset( $bb_opts[ (string) $bb_v ] ) && '' !== $bb_opts[ (string) $bb_v ] ) {
					$bb_labels[] = $bb_opts[ (string) $bb_v ];
				}
			}
			if ( ! $bb_labels ) {
				return $bb_generic;
			}
			/* translators: 1: option set name, 2: one option label, or several joined with "or". e.g. "Occasion is Birthday or Anniversary". */
			$bb_bits[] = sprintf( __( '%1$s is %2$s', 'addon-boss' ), $bb_name, implode( __( ' or ', 'addon-boss' ), $bb_labels ) );
			continue;
		}
		return $bb_generic;
	}
	/* translators: %s: the condition in words, e.g. "Service is Printed and Colour is Red". */
	return sprintf( __( 'Available when %s', 'addon-boss' ), implode( __( ' and ', 'addon-boss' ), $bb_bits ) );
}

/**
 * The pieces a conditional group wears: the data attributes the script below
 * reads, the locked-or-revealed class, and the availability line. Answers the
 * engine's group-bits seam.
 *
 * @param array $bits   The bits so far (all empty).
 * @param array $when   The stored rule.
 * @param bool  $active Whether the group is currently active.
 * @param array $sets   The resolved sets.
 * @return array{attrs:string,class:string,lock:string}
 */
function addon_boss_reveal_group_bits( array $bits, array $when, bool $active, array $sets ): array {
	// A rule this build does not evaluate gets no trigger, no lock and no
	// line: the row is plain and shown, exactly as the server judged it.
	if ( ! $when || ! addon_boss_when_runs_here( $when ) ) {
		return $bits;
	}
	// The WHOLE rule rides the group, normalised, with each trigger already
	// resolved to the name it wears in the DOM. The script evaluates it with
	// the same three steps as addon_boss_when_met(), so a rule of any shape
	// reacts the moment something changes, and there is one rule on the page
	// rather than a client shape and a server shape that can drift apart.
	//
	// It used to carry a single set and a single value, so anything richer got
	// no trigger at all and simply never moved until the page reloaded. A
	// merchant would tick their box, watch nothing happen, and conclude the
	// feature was broken.
	$bb_rule   = addon_boss_normalize_when( $when );
	$bb_groups = array();
	foreach ( $bb_rule['groups'] as $bb_g ) {
		$bb_conds = array();
		foreach ( $bb_g as $bb_c ) {
			$bb_conds[] = array(
				// A set answers under its own control name; a field answers under
				// bb_pf[key]. Resolved here so the script never has to know how
				// either one is named.
				'sel'   => '' !== $bb_c['set'] ? addon_boss_standalone_field_name( $bb_c['set'] ) : '',
				'field' => $bb_c['field'],
				'op'    => $bb_c['op'],
				'value' => $bb_c['value'],
			);
		}
		$bb_groups[] = $bb_conds;
	}
	$bits['attrs'] = ' data-bb-rule="' . esc_attr(
		(string) wp_json_encode(
			array(
				'act'    => $bb_rule['act'],
				'groups' => $bb_groups,
			)
		)
	) . '"';
	$bits['class'] = $active ? ' bb-when-revealed' : ' bb-glocked';
	$bits['lock']  = addon_boss_standalone_when_reason( $when, $sets );
	return $bits;
}
add_filter( 'addon_boss_reveal_group_bits', 'addon_boss_reveal_group_bits', 10, 4 );

/**
 * The storefront's rule evaluation, mirroring the server's activity map
 * exactly: a group whose referenced pick does not match locks AND clears its
 * own pick (the server discards it anyway; the page just stays honest). Runs
 * to a fixpoint so chains cascade in one pass.
 *
 * @param string $js The boot script so far.
 * @return string
 */
function addon_boss_reveal_boot_js( string $js ): string {
	// Every build ships the reaction script: the page only reacts to rules
	// that were given a trigger above, so a rule this build ignores never
	// reaches it.
	ob_start();
	?>
	( function () {
		// A conditional group is out of sight until its rule is satisfied, then
		// it appears in place. The row stays IN the page either way, because a
		// rule that can fire can also un-fire: tick the box and the upload goes,
		// untick it and the upload has to come back, which it cannot do if the
		// server deleted it from the markup.
		//
		// Hiding is display only. What is actually charged and actually required
		// is decided on the server, where a hidden row is inert whatever its
		// input happens to be carrying.
		function bbLock( group, lock ) {
			group.classList.toggle( 'bb-glocked', lock );
			group.classList.toggle( 'bb-when-revealed', ! lock );
		}
		// Every answer a control is currently giving, as a list of strings. A
		// pick-one select answers with one, a several-of select or a tick list
		// with each of its chosen rows, and anything unanswered with nothing.
		function bbAnswers( sel ) {
			var out = [];
			if ( ! sel ) { return out; }
			var box = document.querySelector( '.bb-standalone-options select[data-attribute="' + sel + '"], .bb-standalone-grid select[data-attribute="' + sel + '"]' );
			if ( box ) {
				if ( ! box.multiple ) { return box.value ? [ box.value ] : []; }
				for ( var i = 0; i < box.selectedOptions.length; i++ ) { out.push( box.selectedOptions[ i ].value ); }
				return out;
			}
			var checks = document.querySelector( '.bb-standalone-options .bb-checks[data-attribute="' + sel + '"], .bb-standalone-grid .bb-checks[data-attribute="' + sel + '"]' );
			if ( checks ) {
				checks.querySelectorAll( 'input:checked' ).forEach( function ( c ) { out.push( c.value ); } );
			}
			return out;
		}
		// The controls a field owns. Exact name first, then its repeats, so a
		// field whose key is the start of another field's key never swallows it.
		function bbFieldInputs( key ) {
			return document.querySelectorAll(
				'.bb-standalone-options [name="bb_pf[' + key + ']"], ' +
				'.bb-standalone-options [name^="bb_pf[' + key + ']["], ' +
				'.bb-standalone-grid [name="bb_pf[' + key + ']"], ' +
				'.bb-standalone-grid [name^="bb_pf[' + key + ']["]'
			);
		}
		function bbFieldAnswers( key ) {
			var out = [];
			bbFieldInputs( key ).forEach( function ( el ) {
				if ( el.type === 'checkbox' || el.type === 'radio' ) {
					// A control may answer rules under a plainer name than its
					// posted value (the custom colour answers as "custom",
					// whatever hex it carries) — the same seam the server has.
					if ( el.checked ) { out.push( el.dataset.bbRuleValue || el.value || '1' ); }
					return;
				}
				if ( el.type === 'file' ) {
					if ( el.files && el.files.length ) { out.push( el.files[ 0 ].name ); }
					return;
				}
				if ( el.value ) { out.push( el.value ); }
			} );
			return out;
		}
		// The group a trigger lives in, so an answer nobody can see counts for
		// nothing. Same discipline as the server: a hidden trigger answers
		// NOTHING rather than answering false, which is what keeps "is not red"
		// true of a colour nobody was ever asked for.
		function bbOwner( cond ) {
			var el = cond.field
				? document.querySelector( '.bb-standalone-options [name="bb_pf[' + cond.field + ']"], .bb-standalone-grid [name="bb_pf[' + cond.field + ']"]' )
				: document.querySelector( '.bb-standalone-options [data-attribute="' + cond.sel + '"], .bb-standalone-grid [data-attribute="' + cond.sel + '"]' );
			return el ? el.closest( '.bb-attr-group' ) : null;
		}
		// Does this condition's trigger EXIST on the page at all? A control the
		// merchant has since removed pauses the whole rule (the row shows); a
		// control that is merely locked out of sight stays a real trigger that
		// answers nothing. Same two states the server distinguishes.
		function bbCondSeen( cond ) {
			if ( cond.field ) { return bbFieldInputs( cond.field ).length > 0; }
			return !! document.querySelector(
				'.bb-standalone-options [data-attribute="' + cond.sel + '"], .bb-standalone-grid [data-attribute="' + cond.sel + '"]'
			);
		}
		function bbCondMet( cond ) {
			var owner = bbOwner( cond );
			var live  = ! owner || ! owner.classList.contains( 'bb-glocked' );
			var ans   = live ? ( cond.field ? bbFieldAnswers( cond.field ) : bbAnswers( cond.sel ) ) : [];
			var filled = ans.some( function ( a ) { return a !== ''; } );
			if ( cond.op === 'filled' ) { return filled; }
			if ( cond.op === 'empty' ) { return ! filled; }
			if ( cond.op === 'is_not' ) { return ans.indexOf( cond.value ) === -1; }
			if ( cond.op === 'is_any' ) {
				var list = Array.isArray( cond.value ) ? cond.value : [ cond.value ];
				return ans.some( function ( a ) { return list.indexOf( a ) !== -1; } );
			}
			if ( cond.op === 'more' || cond.op === 'less' || cond.op === 'exact' ) {
				// The first real answer, compared as a number; no answer can
				// never be "more than 5" — the server reads it the same way.
				var first = null;
				for ( var i = 0; i < ans.length; i++ ) { if ( ans[ i ] !== '' ) { first = ans[ i ]; break; } }
				var n = parseFloat( first );
				var t = parseFloat( cond.value );
				if ( first === null || isNaN( n ) || isNaN( t ) ) { return false; }
				return cond.op === 'more' ? n > t : ( cond.op === 'less' ? n < t : n === t );
			}
			return ans.indexOf( cond.value ) !== -1;
		}
		// The same steps as addon_boss_when_met(): AND inside a group, OR
		// across groups, invert for a hide rule, and an empty rule always
		// shows. A rule whose trigger is gone from the page is PAUSED and
		// shows too. Kept deliberately parallel to the server, because a
		// client rule and a server rule that drift apart is the classic fault
		// in this category.
		function bbRuleShows( rule ) {
			if ( ! rule || ! rule.groups || ! rule.groups.length ) { return true; }
			var paused = rule.groups.some( function ( g ) {
				return g.some( function ( c ) { return ! bbCondSeen( c ); } );
			} );
			if ( paused ) { return true; }
			var fired = rule.groups.some( function ( g ) {
				return g.every( bbCondMet );
			} );
			return rule.act === 'hide' ? ! fired : fired;
		}
		function bbEvalWhen() {
			var groups = document.querySelectorAll( '.bb-standalone-options .bb-attr-group[data-bb-rule], .bb-standalone-grid .bb-attr-group[data-bb-rule]' );
			if ( ! groups.length ) { return; }
			for ( var pass = 0; pass < groups.length + 1; pass++ ) {
				var changed = false;
				groups.forEach( function ( group ) {
					var rule;
					try { rule = JSON.parse( group.dataset.bbRule ); } catch ( e ) { return; }
					var shows  = bbRuleShows( rule );
					var locked = group.classList.contains( 'bb-glocked' );
					if ( shows === ! locked ) { return; }
					bbLock( group, ! shows );
					if ( ! shows ) { group.dispatchEvent( new CustomEvent( 'bb-clear-group', { bubbles: true } ) ); }
					changed = true;
				} );
				if ( ! changed ) { break; }
			}
			// The photo swap and the totals re-read the surviving picks.
			document.dispatchEvent( new CustomEvent( 'bb-reveal-change' ) );
			document.dispatchEvent( new CustomEvent( 'bb-live-change' ) );
		}
		document.addEventListener( 'bb-pick-change', function () { bbEvalWhen(); } );
		// A field is a trigger now, so typing and ticking move rules too, not
		// only picking an option.
		document.addEventListener( 'input', function ( e ) {
			if ( e.target && e.target.name && e.target.name.indexOf( 'bb_pf[' ) === 0 ) { bbEvalWhen(); }
		} );
		document.addEventListener( 'change', function ( e ) {
			if ( e.target && e.target.name && e.target.name.indexOf( 'bb_pf[' ) === 0 ) { bbEvalWhen(); }
		} );
		if ( 'loading' !== document.readyState ) { bbEvalWhen(); } else { document.addEventListener( 'DOMContentLoaded', bbEvalWhen ); }
	} )();
	<?php
	return $js . (string) ob_get_clean();
}
add_filter( 'addon_boss_standalone_boot_js', 'addon_boss_reveal_boot_js' );

// -----------------------------------------------------------------
// The rule preview: what the customer sees, in the trigger's two states.
// -----------------------------------------------------------------

/**
 * The two-state preview for one rule.
 *
 * The research round's finding, and the reason this exists: what catches a
 * mistake is not better wording, it is seeing the thing run. A merchant reads
 * "Hidden when Use my own artwork is ticked" and cannot easily tell they have
 * it backwards. They can tell instantly from two lists side by side.
 *
 * Built by asking the REAL evaluator, twice, with the trigger answered and
 * unanswered. A preview that computes its own answer is a second engine that
 * can disagree with the first, and a preview that lies is worse than none.
 *
 * @param string $subject The label of the row the rule sits on.
 * @param array  $when    The stored rule.
 * @param array  $names   Trigger id => the name to show for it.
 * @return string Markup, already escaped.
 */
function addon_boss_rule_preview( string $subject, array $when, array $names = array() ): string {
	$rule = addon_boss_normalize_when( $when );
	if ( empty( $rule['groups'] ) ) {
		return '';
	}
	// The id one condition answers under, and an answer that satisfies it.
	$bb_cond_id = static function ( array $c ): string {
		return '' !== $c['set'] ? $c['set'] : ADDON_BOSS_FIELD_RULE_KEY . $c['field'];
	};
	$bb_satisfy = static function ( array $c ): string {
		switch ( $c['op'] ) {
			case 'filled':
				return 'x';
			case 'empty':
			case 'is_not':
				// An active trigger left unanswered satisfies both.
				return '';
			case 'is_any':
				return (string) ( ( (array) $c['value'] )[0] ?? '' );
			case 'more':
				return (string) ( (float) $c['value'] + 1 );
			case 'less':
				return (string) ( (float) $c['value'] - 1 );
			default:
				return (string) $c['value'];
		}
	};

	// Every trigger the rule names is ON THE PRODUCT for the demonstration —
	// the preview shows the rule working, not the rule paused.
	$bb_active = array();
	foreach ( addon_boss_when_all_conditions( $rule ) as $bb_c ) {
		$bb_active[ $bb_cond_id( $bb_c ) ] = true;
	}

	// The preview demonstrates the FIRST condition of the FIRST group — the
	// one the merchant is looking at. The rest of that group is answered
	// satisfyingly in BOTH panes, so the two panes differ by exactly the
	// thing being demonstrated rather than by a wall of unanswered questions.
	$bb_group = $rule['groups'][0];
	$bb_first = $bb_group[0];
	$bb_id    = $bb_cond_id( $bb_first );
	$bb_name  = (string) ( $names[ $bb_id ] ?? __( 'the trigger', 'addon-boss' ) );

	$bb_held = array();
	foreach ( $bb_group as $bb_c ) {
		$bb_held[ $bb_cond_id( $bb_c ) ] = $bb_satisfy( $bb_c );
	}

	// "Answered" answers with what the rule NAMES, which for a negative
	// condition (is not, left blank) is exactly the answer that stops the rule
	// firing: the panes then demonstrate the flip, whichever way it points.
	$bb_answered = $bb_satisfy( $bb_first );
	if ( 'is_not' === $bb_first['op'] ) {
		$bb_answered = (string) $bb_first['value'];
	} elseif ( 'empty' === $bb_first['op'] ) {
		$bb_answered = 'x';
	}

	$bb_states = array(
		/* translators: %s: the name of the trigger question */
		'off' => array( 'label' => sprintf( __( 'With %s unanswered', 'addon-boss' ), $bb_name ), 'picks' => array( $bb_id => '' ) + $bb_held ),
		/* translators: %s: the name of the trigger question */
		'on'  => array( 'label' => sprintf( __( 'With %s answered', 'addon-boss' ), $bb_name ), 'picks' => array( $bb_id => $bb_answered ) + $bb_held ),
	);

	$out = '<div class="bb-when-preview"><span class="bb-when-previewlab">' . esc_html__( 'What the customer sees', 'addon-boss' ) . '</span><div class="bb-when-panes">';
	foreach ( $bb_states as $bb_key => $bb_state ) {
		$bb_shown = addon_boss_when_met( $when, $bb_state['picks'], $bb_active );
		$out     .= '<div class="bb-when-pane bb-when-pane--' . esc_attr( $bb_key ) . '">'
			. '<span class="bb-when-panehead">' . esc_html( $bb_state['label'] ) . '</span>'
			. '<span class="bb-when-paneitem' . ( $bb_shown ? '' : ' is-gone' ) . '">' . esc_html( $subject ) . '</span>'
			. '<span class="bb-when-panenote">'
			. esc_html( $bb_shown ? __( 'shown', 'addon-boss' ) : __( 'not shown', 'addon-boss' ) )
			. '</span></div>';
	}
	return $out . '</div></div>';
}

// -----------------------------------------------------------------
// The product panel's rule builders.
// -----------------------------------------------------------------

/**
 * One rule builder shell, shared by field rows and set rows.
 *
 * The controls inside are built by the panel script from the ONE carrier: a
 * hidden json input holding the whole rule in the canonical act+groups shape.
 * The server renders the shell, the stored rule, and the two-state preview;
 * the script renders the sentence and the editing controls from what is
 * actually on the panel at that moment. That is what keeps a freshly added
 * field usable as a trigger without a save-and-reload, and it means there is
 * exactly one posted representation of a rule, sanitised in one place.
 *
 * Collapsed by default to its read-back sentence: the sentence IS the rule's
 * summary, in the words the builder uses, so a rule out of sight is never a
 * rule out of mind — the classic misread this category's builders cause.
 *
 * @param string $bb_kind    'field' or 'set' — which row family owns the rule.
 * @param string $ix         The row index (also a template placeholder).
 * @param array  $when       The stored rule.
 * @param array  $bb_names   Trigger id => display name, for the preview.
 * @param string $bb_subject What the preview calls the ruled row.
 */
function addon_boss_reveal_rule_shell( string $bb_kind, string $ix, array $when, array $bb_names, string $bb_subject ): void {
	$bb_norm = addon_boss_when_to_groups( $when );
	$bb_name = ( 'field' === $bb_kind ? 'bb_pf_when_json[' : 'bb_po_when_json[' ) . $ix . ']';
	$bb_has  = (bool) $bb_norm['groups'];
	?>
	<div class="bb-po-when bb-when-builder" data-kind="<?php echo esc_attr( $bb_kind ); ?>" data-idx="<?php echo esc_attr( $ix ); ?>">
		<input type="hidden" class="bb-when-json" name="<?php echo esc_attr( $bb_name ); ?>" value="<?php echo esc_attr( (string) wp_json_encode( $bb_norm ) ); ?>">
		<div class="bb-when-line">
			<span class="bb-when-sentence"><?php echo esc_html( $bb_has ? __( 'Shown by a rule.', 'addon-boss' ) : __( 'Always shown.', 'addon-boss' ) ); ?></span>
			<button type="button" class="button-link bb-when-toggle" aria-expanded="false"><?php esc_html_e( 'Edit rule', 'addon-boss' ); ?></button>
		</div>
		<p class="bb-msec-hint bb-when-warn" hidden></p>
		<div class="bb-when-body" hidden></div>
		<?php
		if ( $bb_has ) {
			// Drawn at load from the SAVED rule by the real evaluator. The
			// script clears it the moment the rule is edited, because a
			// preview of yesterday's rule under today's sentence would be a
			// preview that lies; it returns, true again, on save.
			// phpcs:ignore WordPress.Security.EscapeOutput.OutputNotEscaped -- every value is escaped inside the preview builder.
			echo addon_boss_rule_preview( $bb_subject, $when, $bb_names );
		}
		?>
	</div>
	<?php
}

/**
 * The rule builder on a FIELD row. Answers the engine's seam by printing the
 * shell and returning true; with the plan down it prints nothing, and the
 * engine falls back to its hidden json carrier.
 *
 * @param bool  $printed      Whether an editor has been printed.
 * @param mixed $ix           The row index.
 * @param array $when         The stored rule.
 * @param array $sibling_sets The attached sets a rule may point at.
 * @param array $sibling_fields Fields asked above this row.
 * @param bool  $force        True on the new-row template, which must carry
 *                            the builder even before anything exists to point
 *                            at (the script fills the lists in live).
 * @return bool
 */
function addon_boss_reveal_field_row_when_editor( $printed, $ix, array $when, array $sibling_sets, array $sibling_fields = array(), bool $force = false ): bool {
	if ( $printed || ( ! $sibling_sets && ! $sibling_fields && ! $force ) ) {
		return (bool) $printed;
	}
	$bb_names = array();
	foreach ( $sibling_sets as $bb_sid => $bb_sdef ) {
		$bb_names[ $bb_sid ] = (string) ( is_array( $bb_sdef ) ? ( $bb_sdef['name'] ?? $bb_sid ) : $bb_sdef );
	}
	foreach ( $sibling_fields as $bb_fk => $bb_fe ) {
		$bb_names[ ADDON_BOSS_FIELD_RULE_KEY . $bb_fk ] = addon_boss_sibling_field( $bb_fe, (string) $bb_fk )['label'];
	}
	addon_boss_reveal_rule_shell( 'field', (string) $ix, $when, $bb_names, __( 'This field', 'addon-boss' ) );
	return true;
}
add_filter( 'addon_boss_field_row_when_editor', 'addon_boss_reveal_field_row_when_editor', 10, 6 );

/**
 * The closed row's line of facts owns up to a rule: a field that only
 * appears under one says so without being opened, in the same quiet
 * voice as its fee and its placement. The builder JS keeps the bit true
 * while the rule is edited; this is the truth at load.
 *
 * @param mixed  $bits  The facts so far.
 * @param array  $field The field def (the rule rides beside it, not in it).
 * @param string $type  The field type.
 * @param array  $when  The stored rule.
 * @return array
 */
function addon_boss_reveal_field_row_bits( $bits, $field, $type, $when = array() ) {
	if ( addon_boss_when_runs_here( is_array( $when ) ? $when : array() ) ) {
		$bb_norm = addon_boss_when_to_groups( is_array( $when ) ? $when : array() );
		if ( $bb_norm['groups'] ) {
			$bits[] = 'hide' === $bb_norm['act'] ? __( 'hidden by a rule', 'addon-boss' ) : __( 'shown by a rule', 'addon-boss' );
		}
	}
	return (array) $bits;
}
add_filter( 'addon_boss_field_row_bits', 'addon_boss_reveal_field_row_bits', 10, 4 );

/**
 * The rule builder on a SET row. Same contract as the field row's: print and
 * return true, or leave the engine to its carrier.
 *
 * A set row's builder offers only OTHER SETS as triggers, and only the
 * positive words on them — see the note on the save validation for why a set
 * activation rule must never be a negative.
 *
 * @param bool  $printed  Whether an editor has been printed.
 * @param mixed $ix       The row index.
 * @param array $when     The stored rule.
 * @param array $siblings Set id => name, the sets a rule may point at.
 * @param array $sets     The whole library, for the trigger's options.
 * @return bool
 */
function addon_boss_reveal_set_row_when_editor( $printed, $ix, array $when, array $siblings, array $sets ): bool {
	if ( $printed || ! $siblings ) {
		return (bool) $printed;
	}
	$bb_names = array();
	foreach ( $siblings as $bb_sid => $bb_sname ) {
		$bb_names[ $bb_sid ] = (string) ( is_array( $bb_sname ) ? ( $bb_sname['name'] ?? $bb_sid ) : $bb_sname );
	}
	addon_boss_reveal_rule_shell( 'set', (string) $ix, $when, $bb_names, __( 'This set', 'addon-boss' ) );
	return true;
}
add_filter( 'addon_boss_set_row_when_editor', 'addon_boss_reveal_set_row_when_editor', 10, 5 );

/**
 * The rule builders' browser half: the whole editing surface, built live from
 * the panel.
 *
 * Sentence rows joined by the printed word "and" — no all/any control,
 * because that switch is the one users reliably misread. "Or when…" adds an
 * alternative group of and-rows, so OR exists without ever wearing a toggle.
 * Every trigger's operator menu holds at most four words, picked by what the
 * trigger IS: a pick-one set speaks is / is not / is any of / is answered, a
 * tick box is ticked, a number compares. The read-back sentence above the
 * controls re-renders on every change and STAYS as the rule's summary when
 * the editor is folded, with the warnings in the same voice: a paused
 * trigger, a conditional trigger, a group that can never be true.
 *
 * Triggers are mined from the rows actually on the panel each time a menu is
 * opened — never baked at render — so a field added a moment ago is offered a
 * moment later, and "only a question asked ABOVE this one" stays true as rows
 * are dragged. Printed after the product panel so the ids it binds to exist.
 */
function addon_boss_reveal_panel_js(): void {
	$sets = addon_boss_option_sets();
	ob_start();
	?>
	jQuery( function ( $ ) {
		var panel = $( '#bundle_boss_options_panel' );
		if ( ! panel.length ) { return; }
		// Every library set's options, metadata, and the worded operator menus.
		var bbWhenOptions = <?php
		$bb_when_map = array();
		foreach ( $sets as $sid => $set_def ) {
			foreach ( (array) ( $set_def['options'] ?? array() ) as $set_opt ) {
				$bb_when_map[ $sid ][] = array( $set_opt['key'], $set_opt['label'] );
			}
		}
		echo wp_json_encode( $bb_when_map );
		?>;
		var bbWhenSetMeta = <?php
		$bb_meta_map = array();
		foreach ( $sets as $sid => $set_def ) {
			$bb_meta_map[ $sid ] = array( 'multi' => ! empty( $set_def['multi'] ) );
		}
		echo wp_json_encode( $bb_meta_map );
		?>;
		var bbWhenOps = <?php
		$bb_ops_map = array(
			'__set'       => addon_boss_trigger_op_choices( 'set' ),
			'__set_multi' => addon_boss_trigger_op_choices( 'set', '', true ),
			'__set_noopt' => addon_boss_trigger_op_choices( 'set', '', false, false ),
		);
		foreach ( addon_boss_personalisation_field_types() as $bb_tk => $bb_td ) {
			$bb_ops_map[ $bb_tk ] = addon_boss_trigger_op_choices( 'field', $bb_tk );
		}
		echo wp_json_encode( $bb_ops_map );
		?>;
		// Field types that may never BE a trigger: nothing to answer (display
		// only), the merchant's own note (hidden), or an amount they choose
		// (pay-more-see-more must stay unbuildable).
		var bbNoTrigger = <?php echo wp_json_encode( array_values( array_keys( array_filter( addon_boss_personalisation_field_types(), function ( $t ) { return ! empty( $t['display_only'] ) || ! empty( $t['admin_only'] ) || ! empty( $t['own_amount'] ); } ) ) ) ); ?>;
		var bbFieldPrefix = <?php echo wp_json_encode( ADDON_BOSS_FIELD_RULE_KEY ); ?>;
		var bbL = <?php echo wp_json_encode( array(
			'always'    => __( 'always (no rule)', 'addon-boss' ),
			'showLead'  => __( 'Available only when', 'addon-boss' ),
			'hideLead'  => __( 'Hidden when', 'addon-boss' ),
			'bitShown'  => __( 'shown by a rule', 'addon-boss' ),
			'bitHidden' => __( 'hidden by a rule', 'addon-boss' ),
			'andWord'   => __( 'and', 'addon-boss' ),
			'orLink'    => __( 'Or when…', 'addon-boss' ),
			'orJoin'    => __( ', or when ', 'addon-boss' ),
			'addCond'   => __( '+ Add another condition', 'addon-boss' ),
			'dropCond'  => __( 'Remove this condition', 'addon-boss' ),
			'dropGroup' => __( 'Remove this alternative', 'addon-boss' ),
			'editRule'  => __( 'Edit rule', 'addon-boss' ),
			'doneRule'  => __( 'Done', 'addon-boss' ),
			'alwaysSt'  => __( 'Always shown.', 'addon-boss' ),
			'custom'    => __( 'Custom', 'addon-boss' ),
			'setsGrp'   => __( 'Option sets', 'addon-boss' ),
			'fieldsGrp' => __( 'Fields above this one', 'addon-boss' ),
			/* translators: %s: comma-separated field labels asked after this one. */
			'belowMsg'  => __( 'A rule can only read fields ABOVE this one. To use %s, drag it higher.', 'addon-boss' ),
			/* translators: %s: the trigger's stored id. */
			'paused'    => __( 'Paused: %s is no longer on this product, so the rule is ignored and this row shows. Re-add it, or clear the rule.', 'addon-boss' ),
			/* translators: %s: the trigger question's name. */
			'chained'   => __( 'Note: %s is itself conditional, so this row also waits on that rule.', 'addon-boss' ),
			/* translators: %s: the trigger question's name. */
			'never'     => __( 'These can never both be true: %s cannot be two different answers at once.', 'addon-boss' ),
			'valuePh'   => __( 'value', 'addon-boss' ),
		) ); ?>;

		// ---- what may trigger a rule, read off the live panel ----------
		function bbShellRow( shell ) { return shell.closest( '.bb-po-row' ); }
		function bbMineSets( shell ) {
			var self = shell.data( 'kind' ) === 'set'
				? ( bbShellRow( shell ).find( 'input[name^="bb_po_set["]' ).first().val() || '' )
				: '';
			var out = [];
			panel.find( 'input[name^="bb_po_set["]' ).each( function () {
				var sid = this.value;
				if ( ! sid || sid === self ) { return; }
				if ( out.some( function ( t ) { return t.id === sid; } ) ) { return; }
				var opts = bbWhenOptions[ sid ] || [];
				out.push( {
					id: sid, kind: 'set',
					name: ( window.addonBossSetNames || {} )[ sid ] || sid,
					multi: !! ( bbWhenSetMeta[ sid ] || {} ).multi,
					noopt: ! opts.length,
					opts: opts
				} );
			} );
			return out;
		}
		// Fields split by whether they are asked before or after this row; the
		// "after" half is why the drag-it-above note exists.
		function bbMineFields( shell ) {
			var split = { above: [], below: [] };
			if ( shell.data( 'kind' ) !== 'field' ) { return split; }
			var mine = bbShellRow( shell );
			if ( ! mine.length ) { return split; }
			var rows = panel.find( '.bb-po-row' );
			var stop = rows.index( mine );
			rows.each( function ( i ) {
				if ( i === stop ) { return; }
				var r    = $( this );
				var key  = ( r.find( 'input[name$="[key]"]' ).first().val() || '' ).trim();
				var type = r.find( '.bb-pf-type' ).val() || '';
				if ( ! key || bbNoTrigger.indexOf( type ) !== -1 ) { return; }
				var label = ( r.find( '.bb-pf-label' ).val() || '' ).trim() || key;
				var t = { id: bbFieldPrefix + key, kind: 'field', key: key, name: label, type: type, row: r };
				split[ i < stop ? 'above' : 'below' ].push( t );
			} );
			return split;
		}
		function bbTriggers( shell ) {
			return bbMineSets( shell ).concat( bbMineFields( shell ).above );
		}
		function bbFindTrigger( shell, id ) {
			var all = bbTriggers( shell );
			for ( var i = 0; i < all.length; i++ ) { if ( all[ i ].id === id ) { return all[ i ]; } }
			return null;
		}
		// A colour field's swatches, as saved: the value select offers exactly
		// what a rule can be true of — saved slugs, plus Custom when allowed.
		function bbColourValues( trig ) {
			var out = [];
			if ( ! trig || ! trig.row ) { return out; }
			trig.row.find( '.bb-pf-colourrow' ).each( function () {
				var slug  = $( this ).find( 'input[type=hidden][name$="[value]"]' ).val() || '';
				var label = ( $( this ).find( '.bb-pf-colourlabel' ).val() || '' ).trim();
				if ( slug && label ) { out.push( [ slug, label ] ); }
			} );
			if ( trig.row.find( '.bb-pf-colourallow' ).is( ':checked' ) ) {
				out.push( [ 'custom', bbL.custom ] );
			}
			return out;
		}
		function bbValueList( shell, trig ) {
			if ( ! trig ) { return []; }
			if ( trig.kind === 'set' ) { return trig.opts; }
			if ( trig.type === 'color' ) { return bbColourValues( trig ); }
			return null; // free-typed
		}
		function bbOpsFor( shell, trig ) {
			var ops;
			if ( ! trig ) { return {}; }
			if ( trig.kind === 'set' ) {
				ops = trig.noopt ? bbWhenOps.__set_noopt : ( trig.multi ? bbWhenOps.__set_multi : bbWhenOps.__set );
			} else {
				ops = bbWhenOps[ trig.type ] || { filled: 'is filled in', empty: 'is left blank' };
			}
			// A SET row's activation joins a loop that only ever turns things
			// on; a negative there could strand a required set the settled
			// page hides. Its menu keeps to the positive words, and "Hidden
			// when" is how a merchant says the negative thing.
			if ( shell.data( 'kind' ) === 'set' ) {
				var pos = {};
				$.each( ops, function ( k, v ) { if ( k !== 'is_not' && k !== 'empty' ) { pos[ k ] = v; } } );
				return pos;
			}
			return ops;
		}

		// ---- the rule object and its one carrier ------------------------
		function bbRead( shell ) {
			var rule = shell.data( 'bbRule' );
			if ( rule ) { return rule; }
			try { rule = JSON.parse( shell.find( '.bb-when-json' ).val() || '' ); } catch ( e ) { rule = null; }
			if ( ! rule || ! Array.isArray( rule.groups ) ) { rule = { act: 'show', groups: [] }; }
			if ( rule.act !== 'hide' ) { rule.act = 'show'; }
			shell.data( 'bbRule', rule );
			return rule;
		}
		function bbWrite( shell ) {
			var rule = bbRead( shell );
			// Tidy: drop empty conditions and empty groups before it posts.
			rule.groups = rule.groups.map( function ( g ) {
				return g.filter( function ( c ) { return c && ( c.set || c.field ); } );
			} ).filter( function ( g ) { return g.length; } );
			shell.find( '.bb-when-json' ).val( JSON.stringify( rule ) );
			bbSay( shell );
			// An edited rule outgrows the preview drawn from the saved one; a
			// stale preview is worse than none. It returns on save.
			shell.find( '.bb-when-preview' ).remove();
		}

		// ---- the sentence and its warnings ------------------------------
		function bbValueLabel( shell, trig, value ) {
			var list = trig ? bbValueList( shell, trig ) : null;
			if ( list ) {
				for ( var i = 0; i < list.length; i++ ) { if ( list[ i ][ 0 ] === value ) { return list[ i ][ 1 ]; } }
			}
			return String( value );
		}
		function bbClause( shell, c ) {
			var id   = c.set || ( bbFieldPrefix + c.field );
			var trig = bbFindTrigger( shell, id );
			var name = trig ? trig.name : id;
			var ops  = trig ? bbOpsFor( shell, trig ) : {};
			var word = ops[ c.op ] || c.op;
			var bits = name + ' ' + word;
			if ( c.op === 'filled' || c.op === 'empty' ) { return bits; }
			if ( c.op === 'is_any' ) {
				var vals = ( Array.isArray( c.value ) ? c.value : [ c.value ] ).map( function ( v ) { return bbValueLabel( shell, trig, v ); } );
				return bits + ' ' + vals.join( ', ' );
			}
			return bits + ' ' + bbValueLabel( shell, trig, c.value );
		}
		function bbSay( shell ) {
			var rule = bbRead( shell );
			var out;
			if ( ! rule.groups.length ) {
				out = bbL.alwaysSt;
			} else {
				var parts = rule.groups.map( function ( g ) {
					return g.map( function ( c ) { return bbClause( shell, c ); } ).join( ' ' + bbL.andWord + ' ' );
				} );
				out = ( rule.act === 'hide' ? bbL.hideLead : bbL.showLead ) + ' ' + parts.join( bbL.orJoin ) + '.';
			}
			shell.find( '.bb-when-sentence' ).text( out );
			bbWarn( shell );
			// The row's shut line owns up to its rule; tell it to re-read.
			shell.closest( '.bb-po-fieldrow' ).trigger( 'bb-pf-resummarise' );
		}
		function bbWarn( shell ) {
			var rule  = bbRead( shell );
			var warns = [];
			var seen  = {};
			rule.groups.forEach( function ( g ) {
				var pins = {}; // single-answer trigger id => the one value "is" pinned
				g.forEach( function ( c ) {
					var id   = c.set || ( bbFieldPrefix + c.field );
					var trig = bbFindTrigger( shell, id );
					if ( ! trig ) {
						if ( ! seen[ 'p' + id ] ) { warns.push( bbL.paused.replace( '%s', id ) ); seen[ 'p' + id ] = 1; }
						return;
					}
					// A trigger that is itself ruled: this row waits on both.
					var trow = trig.row || panel.find( 'input[name^="bb_po_set["]' ).filter( function () { return this.value === id; } ).closest( '.bb-po-row' );
					if ( trow && trow.length ) {
						var tj = trow.find( '.bb-when-json' ).first().val() || '';
						if ( tj.indexOf( '"groups":[[' ) !== -1 && ! seen[ 'c' + id ] ) {
							warns.push( bbL.chained.replace( '%s', trig.name ) );
							seen[ 'c' + id ] = 1;
						}
					}
					// One single-pick question asked to be two values at once.
					var single = ( trig.kind === 'set' && ! trig.multi && ! trig.noopt ) || ( trig.kind === 'field' && !! bbValueList( shell, trig ) );
					if ( ! single ) { return; }
					var want = null;
					if ( c.op === 'is' ) { want = [ String( c.value ) ]; }
					if ( c.op === 'is_any' ) { want = ( Array.isArray( c.value ) ? c.value : [ c.value ] ).map( String ); }
					if ( ! want ) { return; }
					if ( pins[ id ] ) {
						var both = pins[ id ].filter( function ( v ) { return want.indexOf( v ) !== -1; } );
						if ( ! both.length && ! seen[ 'n' + id ] ) {
							warns.push( bbL.never.replace( '%s', trig.name ) );
							seen[ 'n' + id ] = 1;
						}
						pins[ id ] = both.length ? both : pins[ id ];
					} else {
						pins[ id ] = want;
					}
				} );
			} );
			var box = shell.find( '.bb-when-warn' );
			box.text( warns.join( ' ' ) ).prop( 'hidden', ! warns.length );
		}

		// ---- the controls, rebuilt from the rule ------------------------
		function bbTriggerSelect( shell, current ) {
			var sel    = $( '<select class="bb-when-set"></select>' );
			var sets   = bbMineSets( shell );
			var fields = bbMineFields( shell ).above;
			sel.append( $( '<option value=""></option>' ).text( bbL.always ) );
			var setHome = sel;
			if ( sets.length && fields.length ) {
				setHome = $( '<optgroup></optgroup>' ).attr( 'label', bbL.setsGrp ).appendTo( sel );
			}
			sets.forEach( function ( t ) { setHome.append( $( '<option></option>' ).val( t.id ).text( t.name ) ); } );
			if ( fields.length ) {
				var g = sets.length ? $( '<optgroup></optgroup>' ).attr( 'label', bbL.fieldsGrp ).appendTo( sel ) : sel;
				fields.forEach( function ( t ) { g.append( $( '<option></option>' ).val( t.id ).text( t.name ) ); } );
			}
			// A rule already pointing somewhere keeps pointing there, even at
			// a trigger since removed: silently repointing a saved rule would
			// change a live product with nobody asking. It reads as paused.
			if ( current && ! sel.find( 'option' ).filter( function () { return this.value === current; } ).length ) {
				sel.append( $( '<option></option>' ).val( current ).text( current ) );
			}
			sel.val( current || '' );
			return sel;
		}
		function bbValueControl( shell, trig, op, value ) {
			if ( ! trig || op === 'filled' || op === 'empty' ) { return $(); }
			if ( op === 'more' || op === 'less' || op === 'exact' ) {
				return $( '<input type="number" step="any" class="bb-when-num">' ).val( value || '' );
			}
			var list = bbValueList( shell, trig );
			if ( ! list ) {
				return $( '<input type="text" class="bb-when-txt">' ).attr( 'placeholder', bbL.valuePh )
					.val( op === 'is_any' && Array.isArray( value ) ? value.join( ', ' ) : ( value || '' ) );
			}
			if ( op === 'is_any' ) {
				var box  = $( '<span class="bb-when-multi" role="group"></span>' );
				var have = Array.isArray( value ) ? value.map( String ) : [ String( value || '' ) ];
				list.forEach( function ( pair ) {
					var lab = $( '<label class="bb-when-multiopt"></label>' );
					$( '<input type="checkbox" class="bb-when-multival">' ).val( pair[ 0 ] )
						.prop( 'checked', have.indexOf( String( pair[ 0 ] ) ) !== -1 ).appendTo( lab );
					lab.append( $( '<span></span>' ).text( pair[ 1 ] ) );
					box.append( lab );
				} );
				return box;
			}
			var sel = $( '<select class="bb-when-is"></select>' );
			list.forEach( function ( pair ) { sel.append( $( '<option></option>' ).val( pair[ 0 ] ).text( pair[ 1 ] ) ); } );
			if ( value && ! sel.find( 'option' ).filter( function () { return this.value === value; } ).length ) {
				sel.append( $( '<option></option>' ).val( value ).text( value ) );
			}
			sel.val( value || ( list[ 0 ] ? list[ 0 ][ 0 ] : '' ) );
			return sel;
		}
		function bbCondRow( shell, gi, ci, cond ) {
			var row  = $( '<div class="bb-when-row"></div>' ).attr( { 'data-g': gi, 'data-c': ci } );
			var id   = cond ? ( cond.set || ( cond.field ? bbFieldPrefix + cond.field : '' ) ) : '';
			var trig = id ? bbFindTrigger( shell, id ) : null;
			if ( ci > 0 ) { row.append( $( '<span class="bb-when-and"></span>' ).text( bbL.andWord ) ); }
			row.append( bbTriggerSelect( shell, id ) );
			if ( id ) {
				var ops   = bbOpsFor( shell, trig );
				var opSel = $( '<select class="bb-when-op"></select>' );
				$.each( ops, function ( k, word ) { opSel.append( $( '<option></option>' ).val( k ).text( word ) ); } );
				var op = cond && ops[ cond.op ] ? cond.op : opSel.find( 'option' ).first().val();
				opSel.val( op );
				row.append( opSel );
				row.append( bbValueControl( shell, trig, op, cond ? cond.value : '' ) );
			}
			row.append( $( '<button type="button" class="bb-when-drop">&#10005;</button>' ).attr( 'aria-label', bbL.dropCond ) );
			return row;
		}
		function bbRender( shell ) {
			var rule = bbRead( shell );
			var body = shell.find( '.bb-when-body' ).empty();
			var lead = $( '<select class="bb-when-actsel bb-when-lead"></select>' )
				.append( $( '<option value="show"></option>' ).text( bbL.showLead ) )
				.append( $( '<option value="hide"></option>' ).text( bbL.hideLead ) )
				.val( rule.act );
			body.append( $( '<div class="bb-when-head"></div>' ).append( lead ) );
			var groups = rule.groups.length ? rule.groups : [ [ null ] ];
			groups.forEach( function ( g, gi ) {
				var gbox = $( '<div class="bb-when-group"></div>' ).attr( 'data-g', gi );
				if ( gi > 0 ) {
					gbox.append(
						$( '<div class="bb-when-orhead"></div>' )
							.append( $( '<span class="bb-when-orword"></span>' ).text( bbL.orLink.replace( '…', '' ) ) )
							.append( $( '<button type="button" class="bb-when-gdrop">&#10005;</button>' ).attr( 'aria-label', bbL.dropGroup ) )
					);
				}
				var rows = $( '<div class="bb-when-rows"></div>' );
				( g.length ? g : [ null ] ).forEach( function ( c, ci ) { rows.append( bbCondRow( shell, gi, ci, c ) ); } );
				gbox.append( rows );
				if ( g.length && g[ 0 ] ) {
					gbox.append( $( '<button type="button" class="button-link bb-when-add"></button>' ).attr( 'data-g', gi ).text( bbL.addCond ) );
				}
				body.append( gbox );
			} );
			if ( rule.groups.length && rule.groups[ rule.groups.length - 1 ].length ) {
				body.append( $( '<button type="button" class="button-link bb-when-or"></button>' ).text( bbL.orLink ) );
			}
			// Which fields are OUT of reach from here, and what to do about it.
			var below = bbMineFields( shell ).below;
			if ( below.length ) {
				body.append( $( '<p class="bb-msec-hint bb-when-below"></p>' ).text(
					bbL.belowMsg.replace( '%s', below.map( function ( f ) { return f.name; } ).join( ', ' ) )
				) );
			}
			bbSay( shell );
		}

		// ---- reading an edit back into the rule --------------------------
		function bbCondFromRow( shell, row ) {
			var id = row.find( '.bb-when-set' ).val() || '';
			if ( ! id ) { return null; }
			var isField = id.indexOf( bbFieldPrefix ) === 0;
			var cond    = {
				set:   isField ? '' : id,
				field: isField ? id.slice( bbFieldPrefix.length ) : '',
				op:    row.find( '.bb-when-op' ).val() || 'is',
				value: ''
			};
			if ( cond.op === 'is_any' ) {
				var vals = [];
				row.find( '.bb-when-multival:checked' ).each( function () { vals.push( this.value ); } );
				if ( ! vals.length ) {
					var typed = ( row.find( '.bb-when-txt' ).val() || '' ).split( ',' );
					typed.forEach( function ( v ) { v = v.trim(); if ( v ) { vals.push( v ); } } );
				}
				cond.value = vals;
			} else if ( cond.op !== 'filled' && cond.op !== 'empty' ) {
				cond.value = row.find( '.bb-when-is, .bb-when-num, .bb-when-txt' ).first().val() || '';
			}
			return cond;
		}
		function bbHarvest( shell ) {
			var rule = bbRead( shell );
			rule.act = shell.find( '.bb-when-actsel' ).val() === 'hide' ? 'hide' : 'show';
			var groups = [];
			shell.find( '.bb-when-group' ).each( function () {
				var g = [];
				$( this ).find( '.bb-when-row' ).each( function () {
					var c = bbCondFromRow( shell, $( this ) );
					if ( c ) { g.push( c ); }
				} );
				groups.push( g );
			} );
			rule.groups = groups.filter( function ( g ) { return g.length; } );
			shell.data( 'bbRule', rule );
			bbWrite( shell );
		}

		// ---- wiring ------------------------------------------------------
		panel.on( 'click', '.bb-when-toggle', function ( e ) {
			e.preventDefault();
			var shell = $( this ).closest( '.bb-when-builder' );
			var body  = shell.find( '.bb-when-body' );
			var open  = body.prop( 'hidden' );
			if ( open ) { bbRender( shell ); }
			body.prop( 'hidden', ! open );
			$( this ).attr( 'aria-expanded', open ? 'true' : 'false' ).text( open ? bbL.doneRule : bbL.editRule );
		} );
		// Trigger or operator changed: the row's other controls follow, so the
		// sentence can never hold words that do not fit its trigger.
		panel.on( 'change', '.bb-when-builder .bb-when-set, .bb-when-builder .bb-when-op', function () {
			var shell = $( this ).closest( '.bb-when-builder' );
			var row   = $( this ).closest( '.bb-when-row' );
			if ( $( this ).hasClass( 'bb-when-set' ) ) {
				// Rebuild the whole row for the new trigger's vocabulary.
				var fresh = bbCondRow( shell, +row.attr( 'data-g' ), +row.attr( 'data-c' ), bbCondFromRow( shell, row ) );
				row.replaceWith( fresh );
			} else {
				var id   = row.find( '.bb-when-set' ).val() || '';
				var trig = bbFindTrigger( shell, id );
				row.find( '.bb-when-is, .bb-when-num, .bb-when-txt, .bb-when-multi' ).remove();
				bbValueControl( shell, trig, $( this ).val(), '' ).insertAfter( row.find( '.bb-when-op' ) );
			}
			bbHarvest( shell );
		} );
		panel.on( 'change input', '.bb-when-builder .bb-when-is, .bb-when-builder .bb-when-num, .bb-when-builder .bb-when-txt, .bb-when-builder .bb-when-multival, .bb-when-builder .bb-when-actsel', function () {
			bbHarvest( $( this ).closest( '.bb-when-builder' ) );
		} );
		panel.on( 'click', '.bb-when-builder .bb-when-add', function ( e ) {
			e.preventDefault();
			var shell = $( this ).closest( '.bb-when-builder' );
			bbHarvest( shell );
			var rule = bbRead( shell );
			var gi   = +$( this ).attr( 'data-g' ) || 0;
			if ( rule.groups[ gi ] ) { rule.groups[ gi ].push( { set: '', field: '', op: 'is', value: '' } ); }
			bbRender( shell );
		} );
		panel.on( 'click', '.bb-when-builder .bb-when-or', function ( e ) {
			e.preventDefault();
			var shell = $( this ).closest( '.bb-when-builder' );
			bbHarvest( shell );
			var rule = bbRead( shell );
			rule.groups.push( [] );
			bbRender( shell );
		} );
		panel.on( 'click', '.bb-when-builder .bb-when-drop', function ( e ) {
			e.preventDefault();
			var shell = $( this ).closest( '.bb-when-builder' );
			$( this ).closest( '.bb-when-row' ).remove();
			bbHarvest( shell );
			bbRender( shell );
		} );
		panel.on( 'click', '.bb-when-builder .bb-when-gdrop', function ( e ) {
			e.preventDefault();
			var shell = $( this ).closest( '.bb-when-builder' );
			$( this ).closest( '.bb-when-group' ).remove();
			bbHarvest( shell );
			bbRender( shell );
		} );
		// The closed row's line of facts owns up to a rule, and follows edits
		// live: bbSay pokes the row, this reads the carrier the save will read.
		window.addonBossSummarise = window.addonBossSummarise || [];
		window.addonBossSummarise.push( function ( bits, ftype, row ) {
			var shell = row.find( '.bb-when-builder' ).first();
			if ( ! shell.length ) { return bits; }
			var rule = null;
			try { rule = JSON.parse( shell.find( '.bb-when-json' ).val() || '' ); } catch ( e ) { rule = null; }
			if ( rule && Array.isArray( rule.groups ) && rule.groups.length ) {
				bits.push( rule.act === 'hide' ? bbL.bitHidden : bbL.bitShown );
			}
			return bits;
		} );
		// Every saved rule reads itself out loud once the panel is up.
		panel.find( '.bb-when-builder' ).each( function () { bbSay( $( this ) ); } );
	} );
	<?php
	addon_boss_inline_js( (string) ob_get_clean() );
}
add_action( 'woocommerce_product_data_panels', 'addon_boss_reveal_panel_js', 20 );