<?php

namespace ChargeForms\Includes;

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

/**
 * The field-tree-flattening and scalar/array/repeater sanitization logic
 * every consumer of a submitted-or-draft value set needs, extracted out of
 * SubmissionHandler (which owned it exclusively until the Save & Resume
 * feature needed the identical logic for draft saves — a draft is
 * "a submission that doesn't have to be complete yet," not a different
 * kind of data). Deliberately does NOT include anything that blocks/rejects
 * (required checks, format validation, repeater row-count limits) — those
 * stay owned by each caller, since a real submission must enforce them
 * strictly (wp_die on violation) while a draft must never enforce them at
 * all (the entire point of a draft is "incomplete, come back later").
 * Splitting "sanitize" from "validate" this way is what makes the same
 * sanitization code safely reusable by two callers with opposite
 * strictness requirements.
 */
class Field_Sanitizer {

	/**
	 * Field types with no `id`-keyed submitted value of their own — display-
	 * only commerce lines (Product/Price/Subtotal/Tax/Discount/Total/Formula)
	 * and layout/content markers. Matches what SubmissionHandler::handle()'s
	 * own loop always skipped; pulled out as a shared constant so a second
	 * caller (Draft_Service) doesn't need to keep a second copy of this list
	 * in sync by hand.
	 */
	const NON_INPUT_TYPES = [
		'section_break', 'page_break', 'html', 'rich_text',
		'product', 'price', 'subtotal', 'tax', 'discount', 'total', 'formula',
		'action_hook', 'quiz_score',
	];

	/**
	 * Recursively flattens a field tree into just the leaf fields that can
	 * hold a submitted value — skips container wrapper nodes (section/row/
	 * column/container/tabs/tab_pane/accordion/accordion_panel — they have
	 * no input of their own, only their children do) and `isHidden` fields
	 * (never rendered, never actually submittable). `repeat_container` is
	 * deliberately NOT recursed into — its children are a template, not
	 * real fields; it's kept as one leaf collected as a whole array-of-rows
	 * value by the caller. Moved here verbatim from SubmissionHandler
	 * (previously `flatten_submittable_fields()`) — same behavior, same
	 * tests, now usable by Draft_Service too without a second
	 * implementation to keep in sync.
	 */
	public static function flatten_submittable_fields( array $fields ) {
		$flat = [];
		foreach ( $fields as $field ) {
			if ( ! empty( $field['isHidden'] ) ) {
				continue;
			}
			if ( in_array( $field['type'], [ 'section', 'row', 'column', 'container', 'tabs', 'tab_pane', 'accordion', 'accordion_panel' ], true ) ) {
				if ( ! empty( $field['children'] ) && is_array( $field['children'] ) ) {
					$flat = array_merge( $flat, self::flatten_submittable_fields( $field['children'] ) );
				}
				continue;
			}
			$flat[] = $field;
		}
		return $flat;
	}

	/** Finds one leaf field by id anywhere in a (possibly nested) field tree — used wherever a caller only has a field id (e.g. the draft file-staging REST route's field_id request param) and needs the real field definition (type, maxSizeMb, allowedExtensions, ...) to validate against. Returns null if no such leaf field exists. */
	public static function find_field_by_id( array $fields, $field_id ) {
		foreach ( self::flatten_submittable_fields( $fields ) as $field ) {
			if ( $field['id'] === $field_id ) {
				return $field;
			}
		}
		return null;
	}

	/** The generic scalar/array sanitize every ordinary text-ish field gets — moved here unchanged from the inline version at the end of SubmissionHandler::handle()'s per-field loop. Not used for file/image_upload/signature (real uploads and draft-staged-file references are each handled by their own caller-specific logic, not this shared path) or repeat_container (see sanitize_repeater_value() below). */
	public static function sanitize_value( $raw_value ) {
		return is_array( $raw_value )
			? array_map( [ __CLASS__, 'sanitize_value' ], $raw_value )
			: sanitize_textarea_field( $raw_value );
	}

	/**
	 * A Repeater's raw value is `[ 0 => [childId => val, ...], 1 => [...] ]`
	 * — recursively sanitizes every leaf value the same way sanitize_value()
	 * does for an ordinary field. Row-count/required-per-row *validation*
	 * (blocking) is a separate concern owned by each strict caller (see
	 * SubmissionHandler::validate_repeater_rows()) — a draft save never
	 * calls that, only this.
	 */
	public static function sanitize_repeater_value( $value ) {
		if ( is_array( $value ) ) {
			return array_map( [ __CLASS__, 'sanitize_repeater_value' ], $value );
		}
		return sanitize_textarea_field( (string) $value );
	}
}