<?php
/**
 * The admin-specific functionality of the plugin.
 *
 * @package AICOSO_Dynamic_Pricing_For_WooCommerce
 */

// Exit if accessed directly.
if ( ! defined( 'ABSPATH' ) ) {
	exit;
}

/**
 * The admin-specific functionality of the plugin.
 */
class DP_AICOSO_Admin {

	/**
	 * The ID of this plugin.
	 *
	 * @var string $plugin_name The ID of this plugin.
	 */
	private $plugin_name;

	/**
	 * The version of this plugin.
	 *
	 * @var string $version The current version of this plugin.
	 */
	private $version;

	/**
	 * Initialize the class and set its properties.
	 *
	 * @param string $plugin_name The name of this plugin.
	 * @param string $version     The version of this plugin.
	 */
	public function __construct( $plugin_name, $version ) {
		$this->plugin_name = $plugin_name;
		$this->version     = $version;
	}

	/**
	 * Helper method for cached database queries.
	 *
	 * @param string   $cache_key    The cache key.
	 * @param callable $query_func   The query function to execute if cache miss.
	 * @param int      $cache_expire Cache expiration time in seconds (default: 300).
	 * @return mixed The query result.
	 */
	private function cached_query( $cache_key, $query_func, $cache_expire = 300 ) {
		$result = wp_cache_get( $cache_key, 'dp_aicoso_admin' );

		if ( false === $result ) {
			// phpcs:ignore WordPress.DB.DirectDatabaseQuery.DirectQuery, WordPress.DB.DirectDatabaseQuery.NoCaching -- Query is cached
			$result = call_user_func( $query_func );
			wp_cache_set( $cache_key, $result, 'dp_aicoso_admin', $cache_expire );
		}

		return $result;
	}

	/**
	 * Get safe table name for SQL queries.
	 *
	 * @param string $table Base table name.
	 * @return string Full table name with prefix.
	 */
	private function get_table_name( $table ) {
		global $wpdb;
		return $wpdb->prefix . $table;
	}

	/**
	 * Register the stylesheets for the admin area.
	 *
	 * @param string $hook The current admin page hook.
	 */
	public function enqueue_styles( $hook ) {
		if ( false === strpos( $hook, 'dp-aicoso' ) && false === strpos( $hook, 'dynamic-pricing' ) ) {
			return;
		}

		wp_enqueue_style(
			$this->plugin_name,
			DP_AICOSO_PLUGIN_URL . 'admin/css/dp-aicoso-admin.css',
			array(),
			$this->version,
			'all'
		);

		wp_enqueue_style( 'wp-color-picker' );
		// Use WordPress built-in jQuery UI styles.
		wp_enqueue_style( 'jquery-ui-style', includes_url( 'css/jquery-ui-dialog.min.css' ), array(), $this->version, 'all' );
	}

	/**
	 * Register the JavaScript for the admin area.
	 *
	 * @param string $hook The current admin page hook.
	 */
	public function enqueue_scripts( $hook ) {
		if ( false === strpos( $hook, 'dp-aicoso' ) && false === strpos( $hook, 'dynamic-pricing' ) ) {
			return;
		}

		wp_enqueue_script( 'wc-enhanced-select' );
		wp_enqueue_script( 'selectWoo' );
		wp_enqueue_style( 'woocommerce_admin_styles' );

		wp_enqueue_script(
			$this->plugin_name,
			DP_AICOSO_PLUGIN_URL . 'admin/js/dp-aicoso-admin.js',
			array( 'jquery', 'wp-color-picker', 'jquery-ui-datepicker', 'selectWoo' ),
			$this->version,
			true
		);

		// Get available roles for JavaScript.
		$available_roles = array();
		if ( class_exists( 'DP_AICOSO_Role_Rule' ) ) {
			$available_roles = DP_AICOSO_Role_Rule::get_available_roles();
		}

		wp_localize_script(
			$this->plugin_name,
			'dp_aicoso_admin',
			array(
				'ajax_url'              => admin_url( 'admin-ajax.php' ),
				'admin_url'             => admin_url( 'admin.php' ),
				'plugin_url'            => DP_AICOSO_PLUGIN_URL,
				'nonce'                 => wp_create_nonce( 'dp_aicoso_admin' ),
				'search_products_nonce' => wp_create_nonce( 'dp_aicoso_admin' ),
				'export_nonce'          => wp_create_nonce( 'dp_aicoso_export' ),
				'available_roles'       => $available_roles,
				'strings'               => array(
					'confirm_delete'    => __( 'Are you sure you want to delete this rule?', 'aicoso-dynamic-pricing-for-woocommerce' ),
					'saving'            => __( 'Saving...', 'aicoso-dynamic-pricing-for-woocommerce' ),
					'dates_cleared'     => __( 'Dates Cleared!', 'aicoso-dynamic-pricing-for-woocommerce' ),
					'saved'             => __( 'Rule saved successfully', 'aicoso-dynamic-pricing-for-woocommerce' ),
					'error'             => __( 'An error occurred', 'aicoso-dynamic-pricing-for-woocommerce' ),
					'cache_cleared'     => __( 'Cache cleared successfully!', 'aicoso-dynamic-pricing-for-woocommerce' ),
					'cache_clear_error' => __( 'Error clearing cache.', 'aicoso-dynamic-pricing-for-woocommerce' ),
				),
			)
		);

		wp_add_inline_script( $this->plugin_name, 'var dp_aicoso_plugin_url = "' . esc_js( DP_AICOSO_PLUGIN_URL ) . '";', 'before' );

		// Export button handler (replaces inline <script> in import-export page template).
		wp_add_inline_script(
			$this->plugin_name,
			'jQuery(document).ready(function($){
				$("#export-rules-btn").on("click",function(){
					var format = $("input[name=\'export_format\']:checked").val();
					window.location.href = dp_aicoso_admin.admin_url + "?page=dp-aicoso-import-export&export=rules&format=" + format + "&nonce=" + dp_aicoso_admin.export_nonce;
				});
			});'
		);

		// Clear cache button handler (replaces inline <script> in settings-page.php template).
		wp_add_inline_script(
			$this->plugin_name,
			'jQuery(document).ready(function($){
				$("#dp-aicoso-clear-cache").on("click",function(){
					var $button = $(this);
					var $spinner = $button.next(".spinner");
					$button.prop("disabled",true);
					$spinner.addClass("is-active");
					$.ajax({
						url: dp_aicoso_admin.ajax_url,
						type: "POST",
						data: {
							action: "dp_aicoso_clear_cache",
							nonce: dp_aicoso_admin.nonce
						},
						success: function(response){
							$button.prop("disabled",false);
							$spinner.removeClass("is-active");
							if(response.success){
								alert(dp_aicoso_admin.strings.cache_cleared);
								location.reload();
							} else {
								alert(dp_aicoso_admin.strings.cache_clear_error);
							}
						}
					});
				});
			});'
		);
	}

	/**
	 * Add admin menu items.
	 */
	public function add_admin_menu() {
		add_submenu_page(
			'woocommerce',
			__( 'Dynamic Pricing', 'aicoso-dynamic-pricing-for-woocommerce' ),
			__( 'Dynamic Pricing', 'aicoso-dynamic-pricing-for-woocommerce' ),
			'manage_woocommerce',
			'dp-aicoso',
			array( $this, 'display_admin_page' )
		);

		add_submenu_page(
			'dp-aicoso',
			__( 'All Rules', 'aicoso-dynamic-pricing-for-woocommerce' ),
			__( 'All Rules', 'aicoso-dynamic-pricing-for-woocommerce' ),
			'manage_woocommerce',
			'dp-aicoso',
			array( $this, 'display_admin_page' )
		);

		add_submenu_page(
			'dp-aicoso',
			__( 'Add New Rule', 'aicoso-dynamic-pricing-for-woocommerce' ),
			__( 'Add New Rule', 'aicoso-dynamic-pricing-for-woocommerce' ),
			'manage_woocommerce',
			'dp-aicoso-add-rule',
			array( $this, 'display_add_rule_page' )
		);

		add_submenu_page(
			'dp-aicoso',
			__( 'Settings', 'aicoso-dynamic-pricing-for-woocommerce' ),
			__( 'Settings', 'aicoso-dynamic-pricing-for-woocommerce' ),
			'manage_woocommerce',
			'dp-aicoso-settings',
			array( $this, 'display_settings_page' )
		);

		add_submenu_page(
			'dp-aicoso',
			__( 'Export', 'aicoso-dynamic-pricing-for-woocommerce' ),
			__( 'Export', 'aicoso-dynamic-pricing-for-woocommerce' ),
			'manage_woocommerce',
			'dp-aicoso-import-export',
			array( $this, 'display_import_export_page' )
		);
	}

	/**
	 * Display the main admin page.
	 */
	public function display_admin_page() {
		require_once DP_AICOSO_PLUGIN_DIR . 'admin/class-dp-aicoso-rules-list-table.php';
		$list_table = new DP_AICOSO_Rules_List_Table();
		$list_table->prepare_items();
		?>
		<div class="wrap">
			<h1>
				<?php echo esc_html( get_admin_page_title() ); ?>
				<a href="<?php echo esc_url( admin_url( 'admin.php?page=dp-aicoso-add-rule' ) ); ?>" class="page-title-action">
					<?php esc_html_e( 'Add New', 'aicoso-dynamic-pricing-for-woocommerce' ); ?>
				</a>
				<a href="<?php echo esc_url( admin_url( 'admin.php?page=dp-aicoso-import-export' ) ); ?>" class="page-title-action">
					<?php esc_html_e( 'Export', 'aicoso-dynamic-pricing-for-woocommerce' ); ?>
				</a>
			</h1>

			<?php
			// phpcs:ignore WordPress.Security.NonceVerification.Recommended -- Just checking for display messages in admin area.
			if ( isset( $_GET['message'] ) ) {
				$message = '';
				// phpcs:ignore WordPress.Security.NonceVerification.Recommended -- Just checking for display messages in admin area.
				switch ( sanitize_text_field( wp_unslash( $_GET['message'] ) ) ) {
					case 'rule_created':
						$message = __( 'Rule created successfully.', 'aicoso-dynamic-pricing-for-woocommerce' );
						break;
					case 'rule_updated':
						$message = __( 'Rule updated successfully.', 'aicoso-dynamic-pricing-for-woocommerce' );
						break;
					case 'rule_deleted':
						$message = __( 'Rule deleted successfully.', 'aicoso-dynamic-pricing-for-woocommerce' );
						break;
					case 'rules_imported':
						$message = __( 'Rules imported successfully.', 'aicoso-dynamic-pricing-for-woocommerce' );
						break;
				}
				if ( $message ) {
					echo '<div class="notice notice-success is-dismissible"><p>' . esc_html( $message ) . '</p></div>';
				}
			}
			?>

			<form method="post">
				<?php $list_table->display(); ?>
			</form>
		</div>
		<?php
	}

	/**
	 * Display the add/edit rule page.
	 */
	public function display_add_rule_page() {
		// Include the form template.
		include DP_AICOSO_PLUGIN_DIR . 'admin/partials/rule-form.php';
	}

	/**
	 * Display the settings page.
	 */
	public function display_settings_page() {
		// Include the settings template.
		include DP_AICOSO_PLUGIN_DIR . 'admin/partials/settings-page.php';
	}

	/**
	 * Handle export early in admin_init to prevent page rendering.
	 */
	public function handle_export_early() {
		if ( isset( $_GET['page'] ) && 'dp-aicoso-import-export' === $_GET['page'] && isset( $_GET['export'] ) && 'rules' === $_GET['export'] ) {
			if ( ! isset( $_GET['nonce'] ) || ! wp_verify_nonce( sanitize_text_field( wp_unslash( $_GET['nonce'] ) ), 'dp_aicoso_export' ) ) {
				wp_die( esc_html__( 'Security check failed', 'aicoso-dynamic-pricing-for-woocommerce' ) );
			}

			$format = isset( $_GET['format'] ) ? sanitize_text_field( wp_unslash( $_GET['format'] ) ) : 'json';
			$this->handle_export( $format );
			exit;
		}
	}

	/**
	 * Display the export page.
	 */
	public function display_import_export_page() {

		if ( isset( $_POST['create_test_rule'] ) && defined( 'WP_DEBUG' ) && WP_DEBUG ) {
			if ( ! isset( $_POST['test_rule_nonce'] ) || ! wp_verify_nonce( sanitize_text_field( wp_unslash( $_POST['test_rule_nonce'] ) ), 'create_test_rule' ) ) {
				add_action(
					'admin_notices',
					function () {
						echo '<div class="notice notice-error is-dismissible"><p>' . esc_html__( 'Security check failed.', 'aicoso-dynamic-pricing-for-woocommerce' ) . '</p></div>';
					}
				);
			} else {
				$this->create_test_rule();
			}
		}

		?>
		<div class="wrap">
			<h1>
				<?php esc_html_e( 'Export Rules', 'aicoso-dynamic-pricing-for-woocommerce' ); ?>
				<a href="<?php echo esc_url( admin_url( 'admin.php?page=dp-aicoso' ) ); ?>" class="page-title-action">
					<?php esc_html_e( 'Back to Dashboard', 'aicoso-dynamic-pricing-for-woocommerce' ); ?>
				</a>
			</h1>

			<?php
			// Display current rule count.
			global $wpdb;
			$rules_table = $wpdb->prefix . 'dp_aicoso_rules';

			$rule_count = $this->cached_query(
				'dp_aicoso_rule_count',
				function () use ( $wpdb, $rules_table ) {
					// Table name is safely constructed with $wpdb->prefix.
					return $wpdb->get_var( "SELECT COUNT(*) FROM `$rules_table`" ); // phpcs:ignore PluginCheck.Security.DirectDB.UnescapedDBParameter, WordPress.DB.PreparedSQL.NotPrepared, WordPress.DB.PreparedSQL.InterpolatedNotPrepared, WordPress.DB.InterpolatedNotPrepared, WordPress.DB.DirectDatabaseQuery.DirectQuery, WordPress.DB.DirectDatabaseQuery.NoCaching
				}
			);
			?>
			<p class="description">
				<?php
				/* translators: %d: number of rules */
				printf( esc_html__( 'Currently, you have %d pricing rule(s) in the database.', 'aicoso-dynamic-pricing-for-woocommerce' ), intval( $rule_count ) );
				?>
			</p>

			<?php if ( defined( 'WP_DEBUG' ) && WP_DEBUG ) : ?>
			<div class="dp-aicoso-debug-panel" style="background: #fff; border: 1px solid #ccd0d4; padding: 15px; margin-bottom: 20px;">
				<h3>Debug Information</h3>
				<?php
				global $wpdb;
				$rules_table = $wpdb->prefix . 'dp_aicoso_rules';

				$table_exists = $this->cached_query(
					'dp_aicoso_table_exists',
					function () use ( $wpdb, $rules_table ) {
						// phpcs:ignore WordPress.DB.DirectDatabaseQuery.DirectQuery, WordPress.DB.DirectDatabaseQuery.NoCaching -- Query is cached.
						return $wpdb->get_var( "SELECT COUNT(*) FROM information_schema.tables WHERE table_schema = DATABASE() AND table_name = '$rules_table'" ); // phpcs:ignore PluginCheck.Security.DirectDB.UnescapedDBParameter, WordPress.DB.PreparedSQL.NotPrepared, WordPress.DB.PreparedSQL.InterpolatedNotPrepared, WordPress.DB.InterpolatedNotPrepared, WordPress.DB.DirectDatabaseQuery.DirectQuery, WordPress.DB.DirectDatabaseQuery.NoCaching
					}
				);

				if ( $table_exists ) {
					// Get table columns with caching.
					$columns = $this->cached_query(
						'dp_aicoso_table_columns',
						function () use ( $wpdb, $rules_table ) {
							// Table name is safely constructed with $wpdb->prefix.
							return $wpdb->get_results( "DESCRIBE `$rules_table`" ); // phpcs:ignore PluginCheck.Security.DirectDB.UnescapedDBParameter, WordPress.DB.PreparedSQL.NotPrepared, WordPress.DB.PreparedSQL.InterpolatedNotPrepared, WordPress.DB.InterpolatedNotPrepared, WordPress.DB.DirectDatabaseQuery.DirectQuery, WordPress.DB.DirectDatabaseQuery.NoCaching
						}
					);
					$column_names = array_column( $columns, 'Field' );

					// Get total rules count with caching.
					$total_rules = $this->cached_query(
						'dp_aicoso_total_rules',
						function () use ( $wpdb, $rules_table ) {
							// Table name is safely constructed with $wpdb->prefix.
							return $wpdb->get_var( "SELECT COUNT(*) FROM `$rules_table`" ); // phpcs:ignore PluginCheck.Security.DirectDB.UnescapedDBParameter, WordPress.DB.PreparedSQL.NotPrepared, WordPress.DB.PreparedSQL.InterpolatedNotPrepared, WordPress.DB.InterpolatedNotPrepared, WordPress.DB.DirectDatabaseQuery.DirectQuery, WordPress.DB.DirectDatabaseQuery.NoCaching
						}
					);

					// Get sample rules with caching.
					$sample_rules = $this->cached_query(
						'dp_aicoso_sample_rules',
						function () use ( $wpdb, $rules_table ) {
							// Table name is safely constructed with $wpdb->prefix.
							return $wpdb->get_results( "SELECT rule_id, rule_name, rule_type, rule_status, created_at FROM `$rules_table` ORDER BY created_at DESC LIMIT 5", ARRAY_A ); // phpcs:ignore PluginCheck.Security.DirectDB.UnescapedDBParameter, WordPress.DB.PreparedSQL.NotPrepared, WordPress.DB.PreparedSQL.InterpolatedNotPrepared, WordPress.DB.InterpolatedNotPrepared, WordPress.DB.DirectDatabaseQuery.DirectQuery, WordPress.DB.DirectDatabaseQuery.NoCaching
						}
					);
				}
				?>
				<p><strong>Table '<?php echo esc_html( $rules_table ); ?>' exists:</strong> <?php echo $table_exists ? 'Yes' : 'No'; ?></p>
				<?php if ( $table_exists ) : ?>
					<p><strong>Table columns:</strong> <?php echo esc_html( implode( ', ', $column_names ) ); ?></p>
					<p><strong>Total rules in database:</strong> <?php echo esc_html( $total_rules ); ?></p>
					<?php if ( $sample_rules ) : ?>
					<p><strong>Recent rules:</strong></p>
					<table class="wp-list-table widefat fixed striped">
						<tr>
							<th>ID</th>
							<th>Name</th>
							<th>Type</th>
							<th>Status</th>
							<th>Created</th>
						</tr>
						<?php foreach ( $sample_rules as $rule ) : ?>
						<tr>
							<td><?php echo esc_html( $rule['rule_id'] ); ?></td>
							<td><?php echo esc_html( $rule['rule_name'] ); ?></td>
							<td><?php echo esc_html( $rule['rule_type'] ); ?></td>
							<td><?php echo esc_html( $rule['rule_status'] ); ?></td>
							<td><?php echo esc_html( $rule['created_at'] ); ?></td>
						</tr>
						<?php endforeach; ?>
					</table>
					<?php else : ?>
					<p><em>No rules found in database.</em></p>
					<?php endif; ?>
				<?php else : ?>
					<p><em><strong>ERROR:</strong> Database table does not exist. Please deactivate and reactivate the plugin.</em></p>
				<?php endif; ?>

				<form method="post" style="margin-top: 15px;">
					<input type="submit" name="create_test_rule" class="button" value="Create Test Rule" />
					<?php wp_nonce_field( 'create_test_rule', 'test_rule_nonce' ); ?>
				</form>
			</div>
			<?php endif; ?>

			<div class="dp-aicoso-panel">
				<h2><?php esc_html_e( 'Export Pricing Rules', 'aicoso-dynamic-pricing-for-woocommerce' ); ?></h2>
				<p><?php esc_html_e( 'Export all pricing rules for backup or migration to another site.', 'aicoso-dynamic-pricing-for-woocommerce' ); ?></p>

				<div class="export-format-wrapper" style="margin: 20px 0;">
					<h4><?php esc_html_e( 'Select Export Format:', 'aicoso-dynamic-pricing-for-woocommerce' ); ?></h4>
					<label style="display: block; margin-bottom: 10px;">
						<input type="radio" name="export_format" value="json" checked />
						<strong><?php esc_html_e( 'JSON Format', 'aicoso-dynamic-pricing-for-woocommerce' ); ?></strong>
						<span class="description" style="display: block; margin-left: 25px;">
							<?php esc_html_e( 'Recommended for full data backup. Preserves all rule settings and relationships.', 'aicoso-dynamic-pricing-for-woocommerce' ); ?>
						</span>
					</label>
					<label style="display: block;">
						<input type="radio" name="export_format" value="csv" />
						<strong><?php esc_html_e( 'CSV Format', 'aicoso-dynamic-pricing-for-woocommerce' ); ?></strong>
						<span class="description" style="display: block; margin-left: 25px;">
							<?php esc_html_e( 'Best for viewing and editing in spreadsheet applications like Excel.', 'aicoso-dynamic-pricing-for-woocommerce' ); ?>
						</span>
					</label>
				</div>

				<button type="button" id="export-rules-btn" class="button button-primary button-large">
					<span class="dashicons dashicons-download" style="vertical-align: middle; margin-top: -2px;"></span>
					<?php esc_html_e( 'Export Rules', 'aicoso-dynamic-pricing-for-woocommerce' ); ?>
				</button>

				<p class="description" style="margin-top: 15px;">
					<strong><?php esc_html_e( 'Note:', 'aicoso-dynamic-pricing-for-woocommerce' ); ?></strong>
					<?php esc_html_e( 'The export file will contain all your pricing rules and their configurations. Keep this file secure as it contains your pricing strategy.', 'aicoso-dynamic-pricing-for-woocommerce' ); ?>
				</p>


			</div>
		</div>
		<?php
	}

	/**
	 * Handle export functionality.
	 *
	 * @param string $format Export format (json or csv).
	 */
	private function handle_export( $format = 'json' ) {
		if ( ! current_user_can( 'manage_woocommerce' ) ) {
			wp_die( esc_html__( 'Insufficient permissions', 'aicoso-dynamic-pricing-for-woocommerce' ) );
		}

		global $wpdb;
		$rules_table = $wpdb->prefix . 'dp_aicoso_rules';
		$rel_table   = $wpdb->prefix . 'dp_aicoso_rule_relationships';

		// Get all rules with caching.
		$rules = $this->cached_query(
			'dp_aicoso_all_rules_export',
			function () use ( $wpdb, $rules_table ) {
				// Table name is safely constructed with $wpdb->prefix.
				return $wpdb->get_results( "SELECT * FROM `$rules_table` ORDER BY rule_id ASC", ARRAY_A ); // phpcs:ignore PluginCheck.Security.DirectDB.UnescapedDBParameter, WordPress.DB.PreparedSQL.NotPrepared, WordPress.DB.PreparedSQL.InterpolatedNotPrepared, WordPress.DB.InterpolatedNotPrepared, WordPress.DB.DirectDatabaseQuery.DirectQuery, WordPress.DB.DirectDatabaseQuery.NoCaching
			},
			60 // Shorter cache for export data.
		);

		if ( empty( $rules ) ) {
			if ( 'csv' === $format ) {
				$this->export_empty_csv();
			} else {
				$this->export_empty_json();
			}
			return;
		}

		$processed_rules = array();
		foreach ( $rules as $rule ) {
			// Get relationships with caching.
			$relationships = $this->cached_query(
				'dp_aicoso_rule_relationships_' . $rule['rule_id'],
				function () use ( $wpdb, $rel_table, $rule ) {
					// Table name is safely constructed with $wpdb->prefix.
					// phpcs:ignore WordPress.DB.DirectDatabaseQuery.DirectQuery, WordPress.DB.DirectDatabaseQuery.NoCaching, WordPress.DB.PreparedSQL.InterpolatedNotPrepared -- Query is cached via cached_query(), table name is safe.
					return $wpdb->get_results(
						$wpdb->prepare(
							'SELECT object_id, object_type FROM ' . esc_sql( $rel_table ) . ' WHERE rule_id = %d',
							$rule['rule_id']
						),
						ARRAY_A
					);
				}
			);

			$conditions = $rule['conditions'];
			if ( ! empty( $conditions ) ) {
				$decoded_conditions = json_decode( $conditions, true );
				if ( JSON_ERROR_NONE === json_last_error() && is_array( $decoded_conditions ) ) {
					$rule['conditions'] = $decoded_conditions;
				} else {
					$rule['conditions'] = array();
				}
			} else {
				$rule['conditions'] = array();
			}

			$adjustments = $rule['adjustments'];
			if ( ! empty( $adjustments ) ) {
				$decoded_adjustments = json_decode( $adjustments, true );
				if ( JSON_ERROR_NONE === json_last_error() ) {
					if ( isset( $decoded_adjustments['discount_type'] ) || isset( $decoded_adjustments['discount_value'] ) ) {
						$type  = isset( $decoded_adjustments['discount_type'] ) ? $decoded_adjustments['discount_type'] : 'percentage';
						$value = isset( $decoded_adjustments['discount_value'] ) ? floatval( $decoded_adjustments['discount_value'] ) : 0;
						$rule['adjustments'] = array(
							array(
								'type'  => $type,
								'value' => $value,
							),
						);
					} elseif ( is_array( $decoded_adjustments ) ) {
						$rule['adjustments'] = $decoded_adjustments;
					} else {
						$rule['adjustments'] = array();
					}
				} else {
					$rule['adjustments'] = array();
				}
			} else {
				$rule['adjustments'] = array();
			}

			if ( '0000-00-00 00:00:00' === $rule['start_date'] || empty( $rule['start_date'] ) ) {
				$rule['start_date'] = null;
			}
			if ( '0000-00-00 00:00:00' === $rule['end_date'] || empty( $rule['end_date'] ) ) {
				$rule['end_date'] = null;
			}

			$rule['relationships'] = $relationships;

			if ( 'csv' === $format ) {
				$product_ids  = array();
				$category_ids = array();
				$user_roles   = array();

				foreach ( $relationships as $rel ) {
					if ( 'product' === $rel['object_type'] ) {
						$product_ids[] = $rel['object_id'];
					} elseif ( 'category' === $rel['object_type'] ) {
						$category_ids[] = $rel['object_id'];
					} elseif ( 0 === strpos( $rel['object_type'], 'role:' ) ) {
						$user_roles[] = substr( $rel['object_type'], 5 );
					}
				}

				$rule['product_ids']  = implode( ',', $product_ids );
				$rule['category_ids'] = implode( ',', $category_ids );
				$rule['user_roles']   = implode( ',', $user_roles );
			}

			$processed_rules[] = $rule;
		}

		if ( 'csv' === $format ) {
			$this->export_as_csv( $processed_rules );
		} else {
			$this->export_as_json( $processed_rules );
		}
	}

	/**
	 * Export rules as JSON.
	 *
	 * @param array $rules Array of rules to export.
	 */
	private function export_as_json( $rules ) {
		$clean_rules = array();
		foreach ( $rules as $rule ) {
			unset( $rule['product_ids'], $rule['category_ids'], $rule['user_roles'] );

			$rule['rule_id']  = intval( $rule['rule_id'] );
			$rule['priority'] = intval( $rule['priority'] );

			if ( ! is_array( $rule['conditions'] ) ) {
				$rule['conditions'] = array();
			}
			if ( ! is_array( $rule['adjustments'] ) ) {
				$rule['adjustments'] = array();
			}
			if ( ! is_array( $rule['relationships'] ) ) {
				$rule['relationships'] = array();
			}

			$clean_rules[] = $rule;
		}

		$export_data = array(
			'plugin'          => 'Dynamic Pricing AICOSO',
			'version'         => $this->version,
			'export_date'     => current_time( 'mysql' ),
			'export_timezone' => get_option( 'timezone_string' ) ? get_option( 'timezone_string' ) : 'UTC',
			'site_url'        => get_site_url(),
			'rules_count'     => count( $clean_rules ),
			'rules'           => $clean_rules,
		);

		header( 'Content-Type: application/json; charset=utf-8' );
		header( 'Content-Disposition: attachment; filename="dp-aicoso-rules-' . gmdate( 'Y-m-d-H-i-s' ) . '.json"' );
		header( 'Cache-Control: no-cache, no-store, must-revalidate' );
		header( 'Pragma: no-cache' );
		header( 'Expires: 0' );

		echo wp_json_encode( $export_data, JSON_PRETTY_PRINT | JSON_UNESCAPED_UNICODE | JSON_UNESCAPED_SLASHES );
		exit;
	}

	/**
	 * Export rules as CSV.
	 *
	 * @param array $rules Array of rules to export.
	 */
	private function export_as_csv( $rules ) {
		header( 'Content-Type: text/csv; charset=utf-8' );
		header( 'Content-Disposition: attachment; filename="dp-aicoso-rules-' . gmdate( 'Y-m-d-H-i-s' ) . '.csv"' );
		header( 'Cache-Control: no-cache, no-store, must-revalidate' );
		header( 'Pragma: no-cache' );
		header( 'Expires: 0' );

		echo "\xEF\xBB\xBF";

		// phpcs:ignore WordPress.WP.AlternativeFunctions.file_system_operations_fopen -- Direct output stream
		$output = fopen( 'php://output', 'w' );

		$headers = array(
			'Rule ID',
			'Rule Name',
			'Rule Type',
			'Status',
			'Priority',
			'Product IDs',
			'Category IDs',
			'User Roles',
			'Adjustment Type',
			'Adjustment Value',
			'Min Quantity',
			'Max Quantity',
			'Start Date',
			'End Date',
			'Conditions (JSON)',
			'Created At',
			'Updated At',
		);
		fputcsv( $output, $headers );

		foreach ( $rules as $rule ) {
			$adjustment_type  = '';
			$adjustment_value = '';
			if ( ! empty( $rule['adjustments'] ) && is_array( $rule['adjustments'] ) ) {
				$first_adjustment = reset( $rule['adjustments'] );
				if ( is_array( $first_adjustment ) ) {
					$adjustment_type  = isset( $first_adjustment['type'] ) ? $first_adjustment['type'] : '';
					$adjustment_value = isset( $first_adjustment['value'] ) ? $first_adjustment['value'] : '';
				}
			}

			$min_quantity = '';
			$max_quantity = '';
			if ( ! empty( $rule['conditions'] ) && is_array( $rule['conditions'] ) ) {
				foreach ( $rule['conditions'] as $condition ) {
					if ( is_array( $condition ) && isset( $condition['type'] ) && 'quantity' === $condition['type'] ) {
						$min_quantity = isset( $condition['min'] ) ? $condition['min'] : '';
						$max_quantity = isset( $condition['max'] ) ? $condition['max'] : '';
						break;
					}
				}
			}

			$row = array(
				$rule['rule_id'],
				$rule['rule_name'],
				$rule['rule_type'],
				$rule['rule_status'],
				$rule['priority'],
				isset( $rule['product_ids'] ) ? $rule['product_ids'] : '',
				isset( $rule['category_ids'] ) ? $rule['category_ids'] : '',
				isset( $rule['user_roles'] ) ? $rule['user_roles'] : '',
				$adjustment_type,
				$adjustment_value,
				$min_quantity,
				$max_quantity,
				! empty( $rule['start_date'] ) ? $rule['start_date'] : '',
				! empty( $rule['end_date'] ) ? $rule['end_date'] : '',
				! empty( $rule['conditions'] ) ? wp_json_encode( $rule['conditions'], JSON_UNESCAPED_UNICODE ) : '',
				isset( $rule['created_at'] ) ? $rule['created_at'] : '',
				isset( $rule['updated_at'] ) ? $rule['updated_at'] : '',
			);

			fputcsv( $output, $row );
		}

		// phpcs:ignore WordPress.WP.AlternativeFunctions.file_system_operations_fclose -- Direct output stream
		fclose( $output );
		exit;
	}

	/**
	 * Export empty JSON when no rules exist.
	 */
	private function export_empty_json() {
		$export_data = array(
			'plugin'          => 'Dynamic Pricing AICOSO',
			'version'         => $this->version,
			'export_date'     => current_time( 'mysql' ),
			'export_timezone' => get_option( 'timezone_string' ) ? get_option( 'timezone_string' ) : 'UTC',
			'site_url'        => get_site_url(),
			'rules_count'     => 0,
			'rules'           => array(),
		);

		header( 'Content-Type: application/json; charset=utf-8' );
		header( 'Content-Disposition: attachment; filename="dp-aicoso-rules-empty-' . gmdate( 'Y-m-d-H-i-s' ) . '.json"' );
		header( 'Cache-Control: no-cache, no-store, must-revalidate' );
		header( 'Pragma: no-cache' );
		header( 'Expires: 0' );

		echo wp_json_encode( $export_data, JSON_PRETTY_PRINT | JSON_UNESCAPED_UNICODE | JSON_UNESCAPED_SLASHES );
		exit;
	}

	/**
	 * Export empty CSV when no rules exist.
	 */
	private function export_empty_csv() {
		header( 'Content-Type: text/csv; charset=utf-8' );
		header( 'Content-Disposition: attachment; filename="dp-aicoso-rules-empty-' . gmdate( 'Y-m-d-H-i-s' ) . '.csv"' );
		header( 'Cache-Control: no-cache, no-store, must-revalidate' );
		header( 'Pragma: no-cache' );
		header( 'Expires: 0' );

		echo "\xEF\xBB\xBF";
		// phpcs:ignore WordPress.WP.AlternativeFunctions.file_system_operations_fopen -- Direct output stream
		$output = fopen( 'php://output', 'w' );

		$headers = array(
			'Rule ID',
			'Rule Name',
			'Rule Type',
			'Status',
			'Priority',
			'Product IDs',
			'Category IDs',
			'User Roles',
			'Adjustment Type',
			'Adjustment Value',
			'Min Quantity',
			'Max Quantity',
			'Start Date',
			'End Date',
			'Conditions (JSON)',
			'Created At',
			'Updated At',
		);
		fputcsv( $output, $headers );

		// phpcs:ignore WordPress.WP.AlternativeFunctions.file_system_operations_fclose -- Direct output stream
		fclose( $output );
		exit;
	}

	/**
	 * Handle import functionality.
	 */
	private function handle_import() {
		if ( ! isset( $_POST['dp_aicoso_import_nonce'] ) || ! wp_verify_nonce( sanitize_text_field( wp_unslash( $_POST['dp_aicoso_import_nonce'] ) ), 'dp_aicoso_import' ) ) {
			add_action(
				'admin_notices',
				function () {
					echo '<div class="notice notice-error is-dismissible"><p>' . esc_html__( 'Security check failed.', 'aicoso-dynamic-pricing-for-woocommerce' ) . '</p></div>';
				}
			);
			return;
		}

		if ( ! current_user_can( 'manage_woocommerce' ) ) {
			add_action(
				'admin_notices',
				function () {
					echo '<div class="notice notice-error is-dismissible"><p>' . esc_html__( 'Insufficient permissions.', 'aicoso-dynamic-pricing-for-woocommerce' ) . '</p></div>';
				}
			);
			return;
		}

		if ( ! isset( $_FILES['import_file'] ) || ! isset( $_FILES['import_file']['error'] ) || UPLOAD_ERR_OK !== $_FILES['import_file']['error'] ) {
			$error_message = ( isset( $_FILES['import_file'] ) && isset( $_FILES['import_file']['error'] ) ) ? $this->get_upload_error_message( intval( $_FILES['import_file']['error'] ) ) : 'No file uploaded.';
			add_action(
				'admin_notices',
				function () use ( $error_message ) {
					echo '<div class="notice notice-error is-dismissible"><p>' . esc_html( $error_message ) . '</p></div>';
				}
			);
			return;
		}

		if ( ! isset( $_FILES['import_file']['name'] ) ) {
			add_action(
				'admin_notices',
				function () {
					echo '<div class="notice notice-error is-dismissible"><p>' . esc_html__( 'Invalid file upload.', 'aicoso-dynamic-pricing-for-woocommerce' ) . '</p></div>';
				}
			);
			return;
		}
		$file_info = pathinfo( sanitize_file_name( wp_unslash( $_FILES['import_file']['name'] ) ) );
		$extension = isset( $file_info['extension'] ) ? strtolower( $file_info['extension'] ) : '';

		if ( ! in_array( $extension, array( 'json', 'csv' ), true ) ) {
			add_action(
				'admin_notices',
				function () use ( $extension ) {
					echo '<div class="notice notice-error is-dismissible"><p>' .
						sprintf(
							/* translators: %s: file extension */
							esc_html__( 'Please upload a valid JSON or CSV file. File extension detected: %s', 'aicoso-dynamic-pricing-for-woocommerce' ),
							$extension ? esc_html( $extension ) : 'none'
						) .
						'</p></div>';
				}
			);
			return;
		}

		if ( 'csv' === $extension ) {
			if ( ! isset( $_FILES['import_file']['tmp_name'] ) ) {
				add_action(
					'admin_notices',
					function () {
						echo '<div class="notice notice-error is-dismissible"><p>' . esc_html__( 'Invalid file upload.', 'aicoso-dynamic-pricing-for-woocommerce' ) . '</p></div>';
					}
				);
				return;
			}
			$import_data = $this->parse_csv_import( sanitize_text_field( wp_unslash( $_FILES['import_file']['tmp_name'] ) ) );
			if ( is_wp_error( $import_data ) ) {
				add_action(
					'admin_notices',
					function () use ( $import_data ) {
						echo '<div class="notice notice-error is-dismissible"><p>' .
							esc_html( $import_data->get_error_message() ) .
							'</p></div>';
					}
				);
				return;
			}
		} else {
			if ( ! isset( $_FILES['import_file']['tmp_name'] ) ) {
				add_action(
					'admin_notices',
					function () {
						echo '<div class="notice notice-error is-dismissible"><p>' . esc_html__( 'Invalid file upload.', 'aicoso-dynamic-pricing-for-woocommerce' ) . '</p></div>';
					}
				);
				return;
			}
			$json_data = file_get_contents( sanitize_text_field( wp_unslash( $_FILES['import_file']['tmp_name'] ) ) );
			if ( false === $json_data ) {
				add_action(
					'admin_notices',
					function () {
						echo '<div class="notice notice-error is-dismissible"><p>' . esc_html__( 'Could not read the uploaded file.', 'aicoso-dynamic-pricing-for-woocommerce' ) . '</p></div>';
					}
				);
				return;
			}

			$import_data = json_decode( $json_data, true );
			$json_error  = json_last_error();

			if ( JSON_ERROR_NONE !== $json_error || ! $import_data || ! isset( $import_data['rules'] ) ) {
				$error_msg = JSON_ERROR_NONE !== $json_error ? json_last_error_msg() : 'Invalid import file format.';
				add_action(
					'admin_notices',
					function () use ( $error_msg ) {
						echo '<div class="notice notice-error is-dismissible"><p>' .
							esc_html__( 'Invalid import file: ', 'aicoso-dynamic-pricing-for-woocommerce' ) .
							esc_html( $error_msg ) .
							'</p></div>';
					}
				);
				return;
			}
		}

		global $wpdb;
		$rules_table = $this->get_table_name( 'dp_aicoso_rules' );
		$rel_table   = $this->get_table_name( 'dp_aicoso_rule_relationships' );

		// Check if tables exist (with caching).
		$tables_exist = $this->cached_query(
			'dp_aicoso_import_tables_exist',
			function () use ( $wpdb, $rules_table ) {
				// phpcs:ignore WordPress.DB.DirectDatabaseQuery.DirectQuery, WordPress.DB.DirectDatabaseQuery.NoCaching -- Query is cached.
				return $wpdb->get_var( $wpdb->prepare( 'SHOW TABLES LIKE %s', $rules_table ) ) === $rules_table;
			}
		);

		if ( ! $tables_exist ) {
			add_action(
				'admin_notices',
				function () {
					echo '<div class="notice notice-error is-dismissible"><p>' .
						esc_html__( 'Database tables not found. Please deactivate and reactivate the plugin.', 'aicoso-dynamic-pricing-for-woocommerce' ) .
						'</p></div>';
				}
			);
			return;
		}

		if ( ! empty( $_POST['replace_existing'] ) ) {
			// Build safe queries - table names are from WordPress prefix.
			$rel_table_name = $this->get_table_name( 'dp_aicoso_rule_relationships' );
			$rules_table_name = $this->get_table_name( 'dp_aicoso_rules' );

			// Delete all relationships.
			// phpcs:ignore WordPress.DB.DirectDatabaseQuery.DirectQuery, WordPress.DB.DirectDatabaseQuery.NoCaching, WordPress.DB.PreparedSQL.InterpolatedNotPrepared -- Write operation, table name is safe.
			$wpdb->query( 'DELETE FROM ' . esc_sql( $rel_table_name ) );

			// Delete all rules.
			// phpcs:ignore WordPress.DB.DirectDatabaseQuery.DirectQuery, WordPress.DB.DirectDatabaseQuery.NoCaching, WordPress.DB.PreparedSQL.InterpolatedNotPrepared -- Write operation, table name is safe.
			$wpdb->query( 'DELETE FROM ' . esc_sql( $rules_table_name ) );

			// Clear all related cache.
			wp_cache_flush_group( 'dp_aicoso_admin' );
		}

		$imported_count = 0;
		$errors         = array();

		foreach ( $import_data['rules'] as $index => $rule ) {
			$old_id        = isset( $rule['rule_id'] ) ? $rule['rule_id'] : ( isset( $rule['id'] ) ? $rule['id'] : null );
			$relationships = isset( $rule['relationships'] ) ? $rule['relationships'] : array();

			if ( empty( $rule['rule_name'] ) || empty( $rule['rule_type'] ) ) {
				/* translators: %d: rule index */
				$errors[] = sprintf( esc_html__( 'Rule %d: Missing required fields (name or type)', 'aicoso-dynamic-pricing-for-woocommerce' ), $index + 1 );
				continue;
			}

			$db_rule = array(
				'rule_name'   => $rule['rule_name'],
				'rule_type'   => $rule['rule_type'],
				'rule_status' => isset( $rule['rule_status'] ) ? $rule['rule_status'] : 'active',
				'priority'    => isset( $rule['priority'] ) ? intval( $rule['priority'] ) : 10,
				'created_at'  => current_time( 'mysql' ),
				'updated_at'  => current_time( 'mysql' ),
			);

			if ( ! empty( $rule['start_date'] ) && '0000-00-00 00:00:00' !== $rule['start_date'] ) {
				$db_rule['start_date'] = $rule['start_date'];
			} else {
				$db_rule['start_date'] = null;
			}

			if ( ! empty( $rule['end_date'] ) && '0000-00-00 00:00:00' !== $rule['end_date'] ) {
				$db_rule['end_date'] = $rule['end_date'];
			} else {
				$db_rule['end_date'] = null;
			}

			if ( isset( $rule['conditions'] ) ) {
				if ( is_array( $rule['conditions'] ) ) {
					$db_rule['conditions'] = wp_json_encode( $rule['conditions'] );
				} elseif ( is_string( $rule['conditions'] ) ) {
					$db_rule['conditions'] = $rule['conditions'];
				} else {
					$db_rule['conditions'] = '[]';
				}
			} else {
				$db_rule['conditions'] = '[]';
			}

			if ( isset( $rule['adjustments'] ) ) {
				if ( is_array( $rule['adjustments'] ) ) {
					$db_rule['adjustments'] = wp_json_encode( $rule['adjustments'] );
				} elseif ( is_string( $rule['adjustments'] ) ) {
					$db_rule['adjustments'] = $rule['adjustments'];
				} else {
					$db_rule['adjustments'] = '[]';
				}
			} else {
				$db_rule['adjustments'] = '[]';
			}

			// phpcs:ignore WordPress.DB.DirectDatabaseQuery.DirectQuery, WordPress.DB.DirectDatabaseQuery.NoCaching -- Write operation
			$result = $wpdb->insert( $rules_table, $db_rule );

			if ( false === $result ) {
				$errors[] = sprintf(
					/* translators: %1$d: rule index, %2$s: rule name, %3$s: error message */
					esc_html__( 'Rule %1$d (%2$s): Database insertion failed - %3$s', 'aicoso-dynamic-pricing-for-woocommerce' ),
					$index + 1,
					$db_rule['rule_name'],
					$wpdb->last_error
				);
				continue;
			}

			$new_id = $wpdb->insert_id;
			$imported_count++;

			foreach ( $relationships as $relationship ) {
				unset( $relationship['id'] );
				$relationship['rule_id'] = $new_id;
				// phpcs:ignore WordPress.DB.DirectDatabaseQuery.DirectQuery, WordPress.DB.DirectDatabaseQuery.NoCaching -- Write operation
				$wpdb->insert( $rel_table, $relationship );
			}
		}

		// Get total rules count with caching.
		$total_rules = $this->cached_query(
			'dp_aicoso_total_rules_after_import',
			function () use ( $wpdb ) {
				$rules_table_name = $this->get_table_name( 'dp_aicoso_rules' );
				// phpcs:ignore WordPress.DB.DirectDatabaseQuery.DirectQuery, WordPress.DB.DirectDatabaseQuery.NoCaching, WordPress.DB.PreparedSQL.InterpolatedNotPrepared -- Query is cached, table name is safe.
				return $wpdb->get_var( 'SELECT COUNT(*) FROM ' . esc_sql( $rules_table_name ) );
			}
		);

		if ( class_exists( 'DP_AICOSO_Price_Calculator' ) ) {
			$calculator = DP_AICOSO_Price_Calculator::get_instance();
			$calculator->clear_cache();
		}

		$import_result = array(
			'imported_count' => $imported_count,
			'errors'         => $errors,
			'total_rules'    => count( $import_data['rules'] ),
		);

		set_transient( 'dp_aicoso_import_result', $import_result, 30 );

		wp_safe_redirect( admin_url( 'admin.php?page=dp-aicoso-import-export&imported=1' ) );
		exit;
	}

	/**
	 * Parse CSV import file.
	 *
	 * @param string $file_path Path to CSV file.
	 * @return array|WP_Error Parsed data or error.
	 */
	private function parse_csv_import( $file_path ) {
		// phpcs:ignore WordPress.WP.AlternativeFunctions.file_system_operations_fopen -- Reading uploaded file
		$handle = fopen( $file_path, 'r' );
		if ( ! $handle ) {
			return new WP_Error( 'csv_read_error', __( 'Could not read the CSV file.', 'aicoso-dynamic-pricing-for-woocommerce' ) );
		}

		// phpcs:ignore WordPress.WP.AlternativeFunctions.file_system_operations_fread -- Reading uploaded file
		$bom = fread( $handle, 3 );
		if ( "\xEF\xBB\xBF" !== $bom ) {
			rewind( $handle );
		}

		$headers = fgetcsv( $handle );
		if ( ! $headers ) {
			// phpcs:ignore WordPress.WP.AlternativeFunctions.file_system_operations_fclose -- Reading uploaded file
			fclose( $handle );
			return new WP_Error( 'csv_no_headers', __( 'CSV file has no headers.', 'aicoso-dynamic-pricing-for-woocommerce' ) );
		}

		$headers = array_map(
			function ( $header ) {
				return str_replace( ' ', '_', strtolower( trim( $header ) ) );
			},
			$headers
		);

		$header_map = array(
			'rule_id'          => array( 'rule_id', 'id' ),
			'rule_name'        => array( 'rule_name', 'name', 'title' ),
			'rule_type'        => array( 'rule_type', 'type' ),
			'rule_status'      => array( 'rule_status', 'status' ),
			'priority'         => array( 'priority', 'order' ),
			'product_ids'      => array( 'product_ids', 'products' ),
			'category_ids'     => array( 'category_ids', 'categories' ),
			'user_roles'       => array( 'user_roles', 'roles' ),
			'adjustment_type'  => array( 'adjustment_type', 'discount_type' ),
			'adjustment_value' => array( 'adjustment_value', 'discount_value', 'value' ),
			'min_quantity'     => array( 'min_quantity', 'min_qty' ),
			'max_quantity'     => array( 'max_quantity', 'max_qty' ),
			'start_date'       => array( 'start_date', 'from_date' ),
			'end_date'         => array( 'end_date', 'to_date' ),
			'conditions_json'  => array( 'conditions_json', 'conditions' ),
		);

		$header_indices = array();
		foreach ( $header_map as $field => $possible_headers ) {
			foreach ( $possible_headers as $header ) {
				$index = array_search( $header, $headers, true );
				if ( false !== $index ) {
					$header_indices[ $field ] = $index;
					break;
				}
			}
		}

		$rules      = array();
		$row_number = 2;

		while ( ( $row = fgetcsv( $handle ) ) !== false ) {
			if ( empty( array_filter( $row ) ) ) {
				$row_number++;
				continue;
			}

			$rule = array();

			if ( ! isset( $header_indices['rule_name'] ) || empty( $row[ $header_indices['rule_name'] ] ) ) {
				$row_number++;
				continue;
			}

			$rule['rule_name'] = $row[ $header_indices['rule_name'] ];
			$rule['rule_type'] = isset( $header_indices['rule_type'] ) && ! empty( $row[ $header_indices['rule_type'] ] )
				? $row[ $header_indices['rule_type'] ]
				: 'product';
			$rule['rule_status'] = isset( $header_indices['rule_status'] ) && ! empty( $row[ $header_indices['rule_status'] ] )
				? $row[ $header_indices['rule_status'] ]
				: 'active';
			$rule['priority'] = isset( $header_indices['priority'] ) && ! empty( $row[ $header_indices['priority'] ] )
				? intval( $row[ $header_indices['priority'] ] )
				: 10;

			$relationships = array();

			if ( isset( $header_indices['product_ids'] ) && ! empty( $row[ $header_indices['product_ids'] ] ) ) {
				$product_ids = explode( ',', $row[ $header_indices['product_ids'] ] );
				foreach ( $product_ids as $product_id ) {
					$product_id = trim( $product_id );
					if ( is_numeric( $product_id ) ) {
						$relationships[] = array(
							'object_id'   => intval( $product_id ),
							'object_type' => 'product',
						);
					}
				}
			}

			if ( isset( $header_indices['category_ids'] ) && ! empty( $row[ $header_indices['category_ids'] ] ) ) {
				$category_ids = explode( ',', $row[ $header_indices['category_ids'] ] );
				foreach ( $category_ids as $category_id ) {
					$category_id = trim( $category_id );
					if ( is_numeric( $category_id ) ) {
						$relationships[] = array(
							'object_id'   => intval( $category_id ),
							'object_type' => 'category',
						);
					}
				}
			}

			if ( isset( $header_indices['user_roles'] ) && ! empty( $row[ $header_indices['user_roles'] ] ) ) {
				$roles = explode( ',', $row[ $header_indices['user_roles'] ] );
				foreach ( $roles as $role ) {
					$role = trim( $role );
					if ( ! empty( $role ) ) {
						$relationships[] = array(
							'object_id'   => 0,
							'object_type' => 'role:' . $role,
						);
					}
				}
			}

			$rule['relationships'] = $relationships;

			$adjustments = array();
			if ( isset( $header_indices['adjustment_type'] ) && ! empty( $row[ $header_indices['adjustment_type'] ] ) ) {
				$adjustment = array(
					'type' => $row[ $header_indices['adjustment_type'] ],
				);
				if ( isset( $header_indices['adjustment_value'] ) && isset( $row[ $header_indices['adjustment_value'] ] ) ) {
					$adjustment['value'] = floatval( $row[ $header_indices['adjustment_value'] ] );
				}
				$adjustments[] = $adjustment;
			}
			$rule['adjustments'] = ! empty( $adjustments ) ? $adjustments : array();

			$conditions = array();

			if ( isset( $header_indices['conditions_json'] ) && ! empty( $row[ $header_indices['conditions_json'] ] ) ) {
				$json_conditions = json_decode( $row[ $header_indices['conditions_json'] ], true );
				if ( is_array( $json_conditions ) ) {
					$conditions = $json_conditions;
				}
			}

			if ( ( isset( $header_indices['min_quantity'] ) && ! empty( $row[ $header_indices['min_quantity'] ] ) ) ||
				( isset( $header_indices['max_quantity'] ) && ! empty( $row[ $header_indices['max_quantity'] ] ) ) ) {
				$qty_condition = array( 'type' => 'quantity' );
				if ( isset( $header_indices['min_quantity'] ) && ! empty( $row[ $header_indices['min_quantity'] ] ) ) {
					$qty_condition['min'] = intval( $row[ $header_indices['min_quantity'] ] );
				}
				if ( isset( $header_indices['max_quantity'] ) && ! empty( $row[ $header_indices['max_quantity'] ] ) ) {
					$qty_condition['max'] = intval( $row[ $header_indices['max_quantity'] ] );
				}
				$conditions[] = $qty_condition;
			}

			$rule['conditions'] = $conditions;

			if ( isset( $header_indices['start_date'] ) && ! empty( $row[ $header_indices['start_date'] ] ) ) {
				$rule['start_date'] = $row[ $header_indices['start_date'] ];
			}
			if ( isset( $header_indices['end_date'] ) && ! empty( $row[ $header_indices['end_date'] ] ) ) {
				$rule['end_date'] = $row[ $header_indices['end_date'] ];
			}

			$rules[] = $rule;
			$row_number++;
		}

		// phpcs:ignore WordPress.WP.AlternativeFunctions.file_system_operations_fclose -- Reading uploaded file
		fclose( $handle );

		if ( empty( $rules ) ) {
			return new WP_Error( 'csv_no_rules', __( 'No valid rules found in CSV file.', 'aicoso-dynamic-pricing-for-woocommerce' ) );
		}

		return array(
			'rules' => $rules,
		);
	}

	/**
	 * Create a test rule for debugging (debug mode only).
	 */
	private function create_test_rule() {
		if ( ! isset( $_POST['test_rule_nonce'] ) || ! wp_verify_nonce( sanitize_text_field( wp_unslash( $_POST['test_rule_nonce'] ) ), 'create_test_rule' ) ) {
			return;
		}

		global $wpdb;
		$rules_table = $wpdb->prefix . 'dp_aicoso_rules';

		$test_rule = array(
			'rule_name'   => 'Test Rule ' . time(),
			'rule_type'   => 'product',
			'rule_status' => 'active',
			'priority'    => 10,
			'conditions'  => wp_json_encode( array() ),
			'adjustments' => wp_json_encode(
				array(
					array(
						'type'  => 'percentage',
						'value' => 10,
					),
				)
			),
			'start_date'  => null,
			'end_date'    => null,
			'created_at'  => current_time( 'mysql' ),
			'updated_at'  => current_time( 'mysql' ),
		);

		// phpcs:ignore WordPress.DB.DirectDatabaseQuery.DirectQuery, WordPress.DB.DirectDatabaseQuery.NoCaching -- Write operation
		$result = $wpdb->insert( $rules_table, $test_rule );

		if ( $result ) {
			add_action(
				'admin_notices',
				function () {
					echo '<div class="notice notice-success is-dismissible"><p>Test rule created successfully!</p></div>';
				}
			);
		} else {
			add_action(
				'admin_notices',
				function () use ( $wpdb ) {
					echo '<div class="notice notice-error is-dismissible"><p>Failed to create test rule: ' . esc_html( $wpdb->last_error ) . '</p></div>';
				}
			);
		}
	}

	/**
	 * Get user-friendly upload error message.
	 *
	 * @param int $error Upload error code.
	 * @return string Error message.
	 */
	private function get_upload_error_message( $error ) {
		switch ( $error ) {
			case UPLOAD_ERR_INI_SIZE:
			case UPLOAD_ERR_FORM_SIZE:
				return __( 'The uploaded file is too large.', 'aicoso-dynamic-pricing-for-woocommerce' );
			case UPLOAD_ERR_PARTIAL:
				return __( 'The file was only partially uploaded.', 'aicoso-dynamic-pricing-for-woocommerce' );
			case UPLOAD_ERR_NO_FILE:
				return __( 'No file was uploaded.', 'aicoso-dynamic-pricing-for-woocommerce' );
			case UPLOAD_ERR_NO_TMP_DIR:
				return __( 'Missing a temporary folder.', 'aicoso-dynamic-pricing-for-woocommerce' );
			case UPLOAD_ERR_CANT_WRITE:
				return __( 'Failed to write file to disk.', 'aicoso-dynamic-pricing-for-woocommerce' );
			case UPLOAD_ERR_EXTENSION:
				return __( 'A PHP extension stopped the file upload.', 'aicoso-dynamic-pricing-for-woocommerce' );
			default:
				return __( 'Unknown upload error.', 'aicoso-dynamic-pricing-for-woocommerce' );
		}
	}

	/**
	 * AJAX handler for saving rules.
	 */
	public function ajax_save_rule() {
		// Verify nonce - accept both field names for compatibility.
		// phpcs:ignore WordPress.Security.NonceVerification.Missing
		$nonce = isset( $_POST['dp_aicoso_nonce'] ) ? sanitize_text_field( wp_unslash( $_POST['dp_aicoso_nonce'] ) ) : ( isset( $_POST['security'] ) ? sanitize_text_field( wp_unslash( $_POST['security'] ) ) : '' );

		// Try both nonce actions for compatibility.
		if ( ! wp_verify_nonce( $nonce, 'dp_aicoso_save_rule' ) && ! wp_verify_nonce( $nonce, 'dp_aicoso_admin' ) ) {
			wp_send_json_error( array( 'message' => 'Security check failed. Please refresh the page and try again.' ) );
		}

		// Check capabilities.
		if ( ! current_user_can( 'manage_woocommerce' ) ) {
			wp_send_json_error( array( 'message' => 'Insufficient permissions' ) );
		}

		// Validate required fields.
		// phpcs:ignore WordPress.Security.NonceVerification.Missing
		if ( empty( $_POST['rule_name'] ) ) {
			wp_send_json_error( array( 'message' => 'Rule name is required' ) );
		}

		// phpcs:ignore WordPress.Security.NonceVerification.Missing
		if ( empty( $_POST['rule_type'] ) ) {
			wp_send_json_error( array( 'message' => 'Rule type is required' ) );
		}

		// Collect rule data.
		// phpcs:ignore WordPress.Security.NonceVerification.Missing
		$rule_id = isset( $_POST['rule_id'] ) ? intval( $_POST['rule_id'] ) : 0;

		// Process adjustments - handle both simple discounts and quantity ranges.
		$adjustments = array();

		// Get rule type to determine if quantity ranges should be saved.
		$rule_type = sanitize_text_field( wp_unslash( $_POST['rule_type'] ) );

		// Handle disable settings (for all rule types).
		if ( isset( $_POST['adjustments'] ) ) {
			// phpcs:ignore WordPress.Security.ValidatedSanitizedInput.InputNotSanitized -- Sanitized individually in following lines
			$post_adjustments = wp_unslash( $_POST['adjustments'] );

			// Save disable_on_sale setting.
			if ( isset( $post_adjustments['disable_on_sale'] ) ) {
				$adjustments['disable_on_sale'] = ( '1' === sanitize_text_field( $post_adjustments['disable_on_sale'] ) ) ? '1' : '0';
			} else {
				$adjustments['disable_on_sale'] = '0'; // Default to not disabled.
			}

			// Save disable_with_coupons setting.
			if ( isset( $post_adjustments['disable_with_coupons'] ) ) {
				$adjustments['disable_with_coupons'] = ( '1' === sanitize_text_field( $post_adjustments['disable_with_coupons'] ) ) ? '1' : '0';
			} else {
				$adjustments['disable_with_coupons'] = '0'; // Default to not disabled.
			}
		}

		// Check if quantity pricing is actually enabled (not just if data exists).
		$quantity_pricing_enabled = isset( $_POST['enable_quantity_pricing'] ) && '1' === $_POST['enable_quantity_pricing'];

		// For product type rules, handle quantity-based vs simple pricing.
		if ( 'product' === $rule_type ) {
			if ( $quantity_pricing_enabled &&
				 isset( $_POST['adjustments']['quantity_ranges'] ) &&
				 ! empty( $_POST['adjustments']['quantity_ranges'] ) ) {
				// Quantity-based pricing is enabled.
				$raw_ranges = map_deep( wp_unslash( $_POST['adjustments']['quantity_ranges'] ), 'sanitize_text_field' );
				// Validate and auto-correct overlapping ranges.
				$adjustments['quantity_ranges'] = $this->validate_quantity_ranges( $raw_ranges );
				$adjustments['enable_quantity_pricing'] = '1';
				// Clear any simple discount fields to avoid confusion.
				unset( $adjustments['discount_type'] );
				unset( $adjustments['discount_value'] );
			} else {
				// Simple pricing - make sure to clear quantity ranges.
				if ( isset( $_POST['adjustments'] ) ) {
					$post_adjustments = map_deep( wp_unslash( $_POST['adjustments'] ), 'sanitize_text_field' );

					// Preserve disable settings.
					$disable_on_sale = isset( $adjustments['disable_on_sale'] ) ? $adjustments['disable_on_sale'] : '0';
					$disable_with_coupons = isset( $adjustments['disable_with_coupons'] ) ? $adjustments['disable_with_coupons'] : '0';

					// Get simple discount settings.
					if ( isset( $post_adjustments['discount_type'] ) && isset( $post_adjustments['discount_value'] ) ) {
						$type  = $post_adjustments['discount_type'];
						$value = floatval( $post_adjustments['discount_value'] );
						if ( ! empty( $type ) && $value > 0 ) {
							$adjustments[] = array(
								'type'  => $type,
								'value' => $value,
							);
						}
					}

					// Restore disable settings.
					$adjustments['disable_on_sale'] = $disable_on_sale;
					$adjustments['disable_with_coupons'] = $disable_with_coupons;
				}
				// Explicitly clear quantity pricing data.
				unset( $adjustments['quantity_ranges'] );
				unset( $adjustments['enable_quantity_pricing'] );
			}
		} elseif ( isset( $_POST['adjustments'] ) ) {
				$post_adjustments = map_deep( wp_unslash( $_POST['adjustments'] ), 'sanitize_text_field' );

			// Preserve disable settings.
			$disable_on_sale = isset( $adjustments['disable_on_sale'] ) ? $adjustments['disable_on_sale'] : '0';
			$disable_with_coupons = isset( $adjustments['disable_with_coupons'] ) ? $adjustments['disable_with_coupons'] : '0';

			if ( is_array( $post_adjustments ) && isset( $post_adjustments[0] ) && isset( $post_adjustments[0]['type'] ) ) {
				$adjustments = $post_adjustments;
				// Restore disable settings.
				$adjustments['disable_on_sale'] = $disable_on_sale;
				$adjustments['disable_with_coupons'] = $disable_with_coupons;
			} elseif ( is_array( $post_adjustments ) ) {
				if ( isset( $post_adjustments['discount_type'] ) || isset( $post_adjustments['discount_value'] ) ) {
					$type  = isset( $post_adjustments['discount_type'] ) ? $post_adjustments['discount_type'] : 'percentage';
					$value = isset( $post_adjustments['discount_value'] ) ? floatval( $post_adjustments['discount_value'] ) : 0;
					if ( ! empty( $type ) && 0 < $value ) {
						$adjustments[] = array(
							'type'  => $type,
							'value' => $value,
						);
					}
				}

				// For category rules, always save include_subcategories setting.
				// Checkboxes don't submit when unchecked, so we need to explicitly set '0' in that case.
				if ( 'category' === $rule_type ) {
					if ( ! is_array( $adjustments ) || isset( $adjustments[0] ) ) {
						$simple_discount = is_array( $adjustments ) && isset( $adjustments[0] ) ? $adjustments[0] : null;
						$adjustments     = array();
						if ( $simple_discount ) {
							$adjustments[] = $simple_discount;
						}
					}
					// Check if the checkbox is set (checked) or not (unchecked).
					$adjustments['include_subcategories'] = isset( $post_adjustments['include_subcategories'] ) && '1' === $post_adjustments['include_subcategories'] ? '1' : '0';
				}

				// Restore disable settings.
				$adjustments['disable_on_sale'] = $disable_on_sale;
				$adjustments['disable_with_coupons'] = $disable_with_coupons;
			}
		} elseif ( isset( $_POST['discount_type'] ) || isset( $_POST['discount_value'] ) ) {
			$type  = isset( $_POST['discount_type'] ) ? sanitize_text_field( wp_unslash( $_POST['discount_type'] ) ) : 'percentage';
			$value = isset( $_POST['discount_value'] ) ? floatval( $_POST['discount_value'] ) : 0;
			if ( ! empty( $type ) && 0 < $value ) {
				$adjustments[] = array(
					'type'  => $type,
					'value' => $value,
				);
			}
		}

		// Process conditions with special handling for operators.
		$conditions = array();
		if ( isset( $_POST['conditions'] ) && is_array( $_POST['conditions'] ) ) {
			// phpcs:ignore WordPress.Security.ValidatedSanitizedInput.InputNotSanitized -- Sanitized in the loop below
			foreach ( wp_unslash( $_POST['conditions'] ) as $condition ) {
				$processed_condition = array();

				// Sanitize type and value normally.
				if ( isset( $condition['type'] ) ) {
					$processed_condition['type'] = sanitize_text_field( wp_unslash( $condition['type'] ) );
				}

				// Handle operator specially to preserve comparison operators.
				if ( isset( $condition['operator'] ) ) {
					$operator = wp_unslash( $condition['operator'] );
					// Whitelist valid operators.
					$valid_operators = array( '=', '!=', '>', '>=', '<', '<=', 'equals', 'not_equals', 'greater_than', 'greater_than_or_equal', 'less_than', 'less_than_or_equal', 'in', 'not_in', 'after', 'before', 'between' );
					if ( in_array( $operator, $valid_operators, true ) ) {
						$processed_condition['operator'] = $operator;
					} else {
						$processed_condition['operator'] = '=';
					}
				}

				// Sanitize value - handle both regular value and roles array for user_role.
				if ( isset( $processed_condition['type'] ) && 'user_role' === $processed_condition['type'] ) {
					// For user_role conditions, use roles array.
					if ( isset( $condition['roles'] ) && is_array( $condition['roles'] ) ) {
						$processed_condition['roles'] = array_map( 'sanitize_text_field', array_map( 'wp_unslash', $condition['roles'] ) );
						// Also store in value for backward compatibility.
						$processed_condition['value'] = implode( ',', $processed_condition['roles'] );
					} elseif ( isset( $condition['value'] ) ) {
						// Backward compatibility - if value is set but not roles.
						$processed_condition['value'] = sanitize_text_field( wp_unslash( $condition['value'] ) );
						$processed_condition['roles'] = array( $processed_condition['value'] );
					}
					// Set operator to 'in' for user roles (user must be in one of the selected roles).
					$processed_condition['operator'] = 'in';
				} elseif ( isset( $condition['value'] ) ) {
					if ( is_array( $condition['value'] ) ) {
						$processed_condition['value'] = array_map( 'sanitize_text_field', array_map( 'wp_unslash', $condition['value'] ) );
					} else {
						$processed_condition['value'] = sanitize_text_field( wp_unslash( $condition['value'] ) );
					}
				}

				$conditions[] = $processed_condition;
			}
		}

		$rule_data = array(
			'rule_name'    => sanitize_text_field( wp_unslash( $_POST['rule_name'] ) ),
			'rule_type'    => sanitize_text_field( wp_unslash( $_POST['rule_type'] ) ),
			'rule_status'  => isset( $_POST['rule_status'] ) ? sanitize_text_field( wp_unslash( $_POST['rule_status'] ) ) : 'active',
			'priority'     => isset( $_POST['priority'] ) ? intval( $_POST['priority'] ) : 10,
			'conditions'   => $conditions,
			'adjustments'  => $adjustments,
		);

		// Handle dates - explicitly handle empty values to clear dates.
		// phpcs:ignore WordPress.Security.NonceVerification.Missing -- Nonce already verified above.
		if ( isset( $_POST['start_date'] ) ) {
			$start_date = sanitize_text_field( wp_unslash( $_POST['start_date'] ) );
			if ( ! empty( $start_date ) ) {
				// phpcs:ignore WordPress.Security.NonceVerification.Missing -- Nonce already verified above.
				$start_time = ! empty( $_POST['start_time'] ) ? sanitize_text_field( wp_unslash( $_POST['start_time'] ) ) : '00:00';
				$rule_data['start_date'] = $start_date . ' ' . $start_time . ':00';
			} else {
				// Explicitly set to null when empty to clear the date.
				$rule_data['start_date'] = null;
			}
		}

		// phpcs:ignore WordPress.Security.NonceVerification.Missing -- Nonce already verified above.
		if ( isset( $_POST['end_date'] ) ) {
			$end_date = sanitize_text_field( wp_unslash( $_POST['end_date'] ) );
			if ( ! empty( $end_date ) ) {
				// phpcs:ignore WordPress.Security.NonceVerification.Missing -- Nonce already verified above.
				$end_time = ! empty( $_POST['end_time'] ) ? sanitize_text_field( wp_unslash( $_POST['end_time'] ) ) : '23:59';
				$rule_data['end_date'] = $end_date . ' ' . $end_time . ':59';
			} else {
				// Explicitly set to null when empty to clear the date.
				$rule_data['end_date'] = null;
			}
		}

		// Save to database.
		global $wpdb;
		$table_name = $wpdb->prefix . 'dp_aicoso_rules';

		$db_data = array(
			'rule_name'    => $rule_data['rule_name'],
			'rule_type'    => $rule_data['rule_type'],
			'rule_status'  => $rule_data['rule_status'],
			'priority'     => $rule_data['priority'],
			'conditions'   => wp_json_encode( $rule_data['conditions'] ),
			'adjustments'  => wp_json_encode( $rule_data['adjustments'] ),
		);

		// Always set date fields (even if null) to ensure they can be cleared.
		$db_data['start_date'] = isset( $rule_data['start_date'] ) ? $rule_data['start_date'] : null;
		$db_data['end_date'] = isset( $rule_data['end_date'] ) ? $rule_data['end_date'] : null;

		if ( $rule_id > 0 ) {
			// Update existing rule.
			$db_data['updated_at'] = current_time( 'mysql' );
			// phpcs:ignore WordPress.DB.DirectDatabaseQuery.DirectQuery, WordPress.DB.DirectDatabaseQuery.NoCaching -- Write operation
			$result = $wpdb->update( $table_name, $db_data, array( 'rule_id' => $rule_id ) );
		} else {
			// Insert new rule.
			$db_data['created_at'] = current_time( 'mysql' );
			$db_data['updated_at'] = current_time( 'mysql' );
			// phpcs:ignore WordPress.DB.DirectDatabaseQuery.DirectQuery, WordPress.DB.DirectDatabaseQuery.NoCaching -- Write operation
			$result = $wpdb->insert( $table_name, $db_data );
			$rule_id = $wpdb->insert_id;
		}

		if ( false === $result ) {
			$error = $wpdb->last_error ? $wpdb->last_error : 'Unknown database error';
			wp_send_json_error( array( 'message' => 'Database error: ' . $error ) );
		}

		// Save relationships.
		$this->save_rule_relationships( $rule_id, $rule_data );

		// Clear cache if calculator exists.
		if ( class_exists( 'DP_AICOSO_Price_Calculator' ) ) {
			$calculator = DP_AICOSO_Price_Calculator::get_instance();
			$calculator->clear_cache();
		}

		// Clear all related cache entries - both transients and wp_cache.
		delete_transient( 'dp_aicoso_active_rules' );
		delete_transient( 'dp_aicoso_active_rules_data' );
		wp_cache_flush_group( 'dp_aicoso_admin' );

		wp_send_json_success(
			array(
				'message' => $rule_id > 0 ? 'Rule updated successfully' : 'Rule created successfully',
				'rule_id' => $rule_id,
			)
		);
	}

	/**
	 * Validate and auto-correct overlapping quantity ranges.
	 *
	 * @param array $quantity_ranges The quantity ranges to validate.
	 * @return array Cleaned and validated quantity ranges.
	 */
	private function validate_quantity_ranges( $quantity_ranges ) {
		if ( empty( $quantity_ranges ) || ! is_array( $quantity_ranges ) ) {
			return array();
		}

		// Convert and filter valid ranges.
		$valid_ranges = array();
		foreach ( $quantity_ranges as $range ) {
			$min = isset( $range['min_quantity'] ) ? intval( $range['min_quantity'] ) : 0;
			$max = isset( $range['max_quantity'] ) ? intval( $range['max_quantity'] ) : 0;

			// Skip invalid ranges.
			if ( $min <= 0 ) {
				continue;
			}

			// Ensure max is not less than min.
			if ( $max > 0 && $max < $min ) {
				$max = $min;
			}

			$valid_ranges[] = array(
				'min_quantity'   => $min,
				'max_quantity'   => $max,
				'discount_type'  => isset( $range['discount_type'] ) ? sanitize_text_field( $range['discount_type'] ) : 'percentage',
				'discount_value' => isset( $range['discount_value'] ) ? floatval( $range['discount_value'] ) : 0,
			);
		}

		// Sort ranges by min_quantity.
		usort(
			$valid_ranges,
			function ( $a, $b ) {
				return $a['min_quantity'] - $b['min_quantity'];
			}
		);

		// Auto-correct overlaps.
		$cleaned_ranges = array();
		$prev_max = 0;

		foreach ( $valid_ranges as $index => $range ) {
			// Auto-correct overlapping minimum.
			if ( $prev_max > 0 && $range['min_quantity'] <= $prev_max ) {
				$range['min_quantity'] = $prev_max + 1;
			}

			// Skip if min exceeds max after correction (invalid range).
			if ( $range['max_quantity'] > 0 && $range['min_quantity'] > $range['max_quantity'] ) {
				continue;
			}

			$cleaned_ranges[] = $range;

			// Update prev_max for next iteration.
			if ( $range['max_quantity'] > 0 ) {
				$prev_max = $range['max_quantity'];
			} else {
				// If max is unlimited, no further ranges should be processed.
				break;
			}
		}

		return $cleaned_ranges;
	}

	/**
	 * Save rule relationships.
	 *
	 * @param int   $rule_id   Rule ID.
	 * @param array $rule_data Rule data.
	 */
	private function save_rule_relationships( $rule_id, $rule_data ) {
		global $wpdb;
		$rel_table = $wpdb->prefix . 'dp_aicoso_rule_relationships';

		// phpcs:ignore WordPress.DB.DirectDatabaseQuery.DirectQuery, WordPress.DB.DirectDatabaseQuery.NoCaching -- Write operation
		$wpdb->delete( $rel_table, array( 'rule_id' => $rule_id ), array( '%d' ) );

		// Clear related cache entries.
		wp_cache_delete( 'dp_aicoso_rule_relationships_' . $rule_id, 'dp_aicoso_admin' );
		wp_cache_delete( 'dp_aicoso_all_rules_export', 'dp_aicoso_admin' );
		wp_cache_delete( 'dp_aicoso_total_rules_after_import', 'dp_aicoso_admin' );

		switch ( $rule_data['rule_type'] ) {
			case 'product':
				// phpcs:ignore WordPress.Security.NonceVerification.Missing
				if ( ! empty( $_POST['product_ids'] ) ) {
					// phpcs:ignore WordPress.Security.NonceVerification.Missing
					foreach ( map_deep( wp_unslash( $_POST['product_ids'] ), 'intval' ) as $product_id ) {
						// phpcs:ignore WordPress.DB.DirectDatabaseQuery.DirectQuery, WordPress.DB.DirectDatabaseQuery.NoCaching -- Write operation
						$wpdb->insert(
							$rel_table,
							array(
								'rule_id'     => $rule_id,
								'object_id'   => $product_id,
								'object_type' => 'product',
							)
						);
					}
				}
				break;

			case 'category':
				// phpcs:ignore WordPress.Security.NonceVerification.Missing
				if ( ! empty( $_POST['category_ids'] ) ) {
					// phpcs:ignore WordPress.Security.NonceVerification.Missing
					foreach ( map_deep( wp_unslash( $_POST['category_ids'] ), 'intval' ) as $category_id ) {
						// phpcs:ignore WordPress.DB.DirectDatabaseQuery.DirectQuery, WordPress.DB.DirectDatabaseQuery.NoCaching -- Write operation
						$wpdb->insert(
							$rel_table,
							array(
								'rule_id'     => $rule_id,
								'object_id'   => $category_id,
								'object_type' => 'category',
							)
						);
					}
				}
				break;

			case 'role':
				// phpcs:ignore WordPress.Security.NonceVerification.Missing
				if ( ! empty( $_POST['user_roles'] ) ) {
					// phpcs:ignore WordPress.Security.NonceVerification.Missing
					foreach ( map_deep( wp_unslash( $_POST['user_roles'] ), 'sanitize_text_field' ) as $role ) {
						// phpcs:ignore WordPress.DB.DirectDatabaseQuery.DirectQuery, WordPress.DB.DirectDatabaseQuery.NoCaching -- Write operation
						$wpdb->insert(
							$rel_table,
							array(
								'rule_id'     => $rule_id,
								'object_id'   => 0,
								'object_type' => 'role:' . $role,
							)
						);
					}
				}
				break;
		}
	}

	/**
	 * AJAX handler for deleting rules.
	 */
	public function ajax_delete_rule() {
		if ( ! isset( $_POST['nonce'] ) || ! wp_verify_nonce( sanitize_text_field( wp_unslash( $_POST['nonce'] ) ), 'dp_aicoso_admin' ) ) {
			wp_send_json_error( array( 'message' => 'Security check failed' ) );
		}

		if ( ! current_user_can( 'manage_woocommerce' ) ) {
			wp_send_json_error( array( 'message' => 'Insufficient permissions' ) );
		}

		$rule_id = isset( $_POST['rule_id'] ) ? intval( $_POST['rule_id'] ) : 0;

		if ( ! $rule_id ) {
			wp_send_json_error( array( 'message' => 'Invalid rule ID' ) );
		}

		global $wpdb;
		$rules_table = $wpdb->prefix . 'dp_aicoso_rules';
		$rel_table   = $wpdb->prefix . 'dp_aicoso_rule_relationships';

		// phpcs:ignore WordPress.DB.DirectDatabaseQuery.DirectQuery, WordPress.DB.DirectDatabaseQuery.NoCaching -- Write operation
		$wpdb->delete( $rel_table, array( 'rule_id' => $rule_id ), array( '%d' ) );

		// phpcs:ignore WordPress.DB.DirectDatabaseQuery.DirectQuery, WordPress.DB.DirectDatabaseQuery.NoCaching -- Write operation
		$result = $wpdb->delete( $rules_table, array( 'rule_id' => $rule_id ), array( '%d' ) );

		if ( false === $result ) {
			wp_send_json_error( array( 'message' => 'Failed to delete rule' ) );
		}

		if ( class_exists( 'DP_AICOSO_Price_Calculator' ) ) {
			$calculator = DP_AICOSO_Price_Calculator::get_instance();
			$calculator->clear_cache();
		}

		// Clear all related cache entries - both transients and wp_cache.
		delete_transient( 'dp_aicoso_active_rules' );
		delete_transient( 'dp_aicoso_active_rules_data' );
		wp_cache_flush_group( 'dp_aicoso_admin' );

		wp_send_json_success( array( 'message' => 'Rule deleted successfully' ) );
	}

	/**
	 * AJAX handler for duplicating rules.
	 */
	public function ajax_duplicate_rule() {
		if ( ! isset( $_POST['nonce'] ) || ! wp_verify_nonce( sanitize_text_field( wp_unslash( $_POST['nonce'] ) ), 'dp_aicoso_admin' ) ) {
			wp_send_json_error( array( 'message' => 'Security check failed' ) );
		}

		if ( ! current_user_can( 'manage_woocommerce' ) ) {
			wp_send_json_error( array( 'message' => 'Insufficient permissions' ) );
		}

		$rule_id = isset( $_POST['rule_id'] ) ? intval( $_POST['rule_id'] ) : 0;

		if ( ! $rule_id ) {
			wp_send_json_error( array( 'message' => 'Invalid rule ID' ) );
		}

		global $wpdb;
		$rules_table_name = $this->get_table_name( 'dp_aicoso_rules' );
		$rel_table_name   = $this->get_table_name( 'dp_aicoso_rule_relationships' );

		// Get rule - use proper SQL formatting.
		$rule = $wpdb->get_row( // phpcs:ignore WordPress.DB.DirectDatabaseQuery.DirectQuery, WordPress.DB.DirectDatabaseQuery.NoCaching
			$wpdb->prepare(
				"SELECT * FROM {$wpdb->prefix}dp_aicoso_rules WHERE rule_id = %d",
				$rule_id
			),
			ARRAY_A
		);

		if ( ! $rule ) {
			wp_send_json_error( array( 'message' => 'Rule not found' ) );
		}

		unset( $rule['rule_id'] );
		$rule['rule_name']   = $rule['rule_name'] . ' (Copy)';
		$rule['rule_status'] = 'inactive';
		$rule['created_at']  = current_time( 'mysql' );
		$rule['updated_at']  = current_time( 'mysql' );

		// phpcs:ignore WordPress.DB.DirectDatabaseQuery.DirectQuery, WordPress.DB.DirectDatabaseQuery.NoCaching -- Write operation.
		$result = $wpdb->insert( $rules_table_name, $rule );

		if ( false === $result ) {
			wp_send_json_error( array( 'message' => 'Failed to duplicate rule' ) );
		}

		$new_rule_id = $wpdb->insert_id;

		// Check if relationships table exists (with caching).
		$table_exists = $this->cached_query(
			'dp_aicoso_rel_table_exists_duplicate',
			function () use ( $wpdb, $rel_table_name ) {
				// phpcs:ignore WordPress.DB.DirectDatabaseQuery.DirectQuery, WordPress.DB.DirectDatabaseQuery.NoCaching -- Query is cached.
				return $wpdb->get_var( $wpdb->prepare( 'SHOW TABLES LIKE %s', $rel_table_name ) ) === $rel_table_name;
			}
		);

		if ( $table_exists ) {
			// Get relationships with caching.
			$relationships = $this->cached_query(
				'dp_aicoso_rule_relationships_duplicate_' . $rule_id,
				function () use ( $wpdb, $rel_table_name, $rule_id ) {
					// phpcs:ignore WordPress.DB.DirectDatabaseQuery.DirectQuery, WordPress.DB.DirectDatabaseQuery.NoCaching -- Query is cached.
					return $wpdb->get_results(
						$wpdb->prepare(
							"SELECT * FROM {$wpdb->prefix}dp_aicoso_rule_relationships WHERE rule_id = %d",
							$rule_id
						),
						ARRAY_A
					);
				}
			);

			foreach ( $relationships as $relationship ) {
				unset( $relationship['id'] );
				$relationship['rule_id'] = $new_rule_id;
				// phpcs:ignore WordPress.DB.DirectDatabaseQuery.DirectQuery, WordPress.DB.DirectDatabaseQuery.NoCaching -- Write operation
				$wpdb->insert( $rel_table_name, $relationship );
			}
		}

		// Clear cache after duplication.
		delete_transient( 'dp_aicoso_active_rules' );
		delete_transient( 'dp_aicoso_active_rules_data' );
		if ( class_exists( 'DP_AICOSO_Price_Calculator' ) ) {
			$calculator = DP_AICOSO_Price_Calculator::get_instance();
			$calculator->clear_cache();
		}
		wp_cache_flush_group( 'dp_aicoso_admin' );

		wp_send_json_success(
			array(
				'message' => 'Rule duplicated successfully',
				'rule_id' => $new_rule_id,
			)
		);
	}

	/**
	 * AJAX handler for toggling rule status.
	 */
	public function ajax_toggle_status() {
		if ( ! isset( $_POST['nonce'] ) || ! wp_verify_nonce( sanitize_text_field( wp_unslash( $_POST['nonce'] ) ), 'dp_aicoso_admin' ) ) {
			wp_send_json_error( array( 'message' => 'Security check failed' ) );
		}

		if ( ! current_user_can( 'manage_woocommerce' ) ) {
			wp_send_json_error( array( 'message' => 'Insufficient permissions' ) );
		}

		$rule_id = isset( $_POST['rule_id'] ) ? intval( $_POST['rule_id'] ) : 0;
		$status  = isset( $_POST['status'] ) ? sanitize_text_field( wp_unslash( $_POST['status'] ) ) : '';

		if ( ! $rule_id || ! in_array( $status, array( 'active', 'inactive' ), true ) ) {
			wp_send_json_error( array( 'message' => 'Invalid parameters' ) );
		}

		global $wpdb;
		$rules_table = $wpdb->prefix . 'dp_aicoso_rules';

		// phpcs:ignore WordPress.DB.DirectDatabaseQuery.DirectQuery, WordPress.DB.DirectDatabaseQuery.NoCaching -- Write operation
		$result = $wpdb->update(
			$rules_table,
			array(
				'rule_status' => $status,
				'updated_at'  => current_time( 'mysql' ),
			),
			array( 'rule_id' => $rule_id ),
			array( '%s', '%s' ),
			array( '%d' )
		);

		if ( false === $result ) {
			wp_send_json_error( array( 'message' => 'Failed to update rule status' ) );
		}

		if ( class_exists( 'DP_AICOSO_Price_Calculator' ) ) {
			$calculator = DP_AICOSO_Price_Calculator::get_instance();
			$calculator->clear_cache();
		}

		wp_send_json_success(
			array(
				'message' => 'Rule status updated successfully',
				'status' => $status,
			)
		);
	}

	/**
	 * AJAX handler for searching products - our custom implementation.
	 */
	public function ajax_search_products() {
		$nonce = isset( $_REQUEST['security'] ) ? sanitize_text_field( wp_unslash( $_REQUEST['security'] ) ) : '';

		if ( ! wp_verify_nonce( $nonce, 'dp_aicoso_admin' ) ) {
			wp_send_json( array() );
			return;
		}

		if ( ! current_user_can( 'manage_woocommerce' ) ) {
			wp_send_json( array() );
			return;
		}

		$term = isset( $_REQUEST['term'] ) ? sanitize_text_field( wp_unslash( $_REQUEST['term'] ) ) : '';

		if ( 1 > strlen( $term ) ) {
			wp_send_json( array() );
			return;
		}

		if ( ! function_exists( 'wc_get_product' ) ) {
			wp_send_json( array() );
			return;
		}

		$products = array();

		$args = array(
			'post_type'      => 'product',
			'post_status'    => 'publish',
			'posts_per_page' => 30,
			's'              => $term,
			'orderby'        => 'title',
			'order'          => 'ASC',
		);

		$query = new WP_Query( $args );

		if ( $query->have_posts() ) {
			while ( $query->have_posts() ) {
				$query->the_post();
				$product_id = get_the_ID();
				$product    = wc_get_product( $product_id );

				if ( $product ) {
					$formatted_name = $product->get_name();

					$sku = $product->get_sku();
					if ( $sku ) {
						$formatted_name .= ' (' . $sku . ')';
					}

					$price = $product->get_price();
					if ( $price ) {
						$formatted_name .= ' - ' . wc_price( $price );
					}

					$products[] = array(
						'id'   => $product_id,
						'text' => wp_strip_all_tags( $formatted_name ),
					);
				}
			}
		}

		wp_reset_postdata();

		if ( empty( $products ) || 5 > count( $products ) ) {
			global $wpdb;
			// Search by SKU with caching.
			$sku_results = $this->cached_query(
				'dp_aicoso_sku_search_' . md5( $term ),
				function () use ( $wpdb, $term ) {
					// phpcs:ignore WordPress.DB.DirectDatabaseQuery.DirectQuery, WordPress.DB.DirectDatabaseQuery.NoCaching -- Query is cached.
					return $wpdb->get_results(
						$wpdb->prepare(
							"SELECT post_id FROM {$wpdb->postmeta}
							WHERE meta_key = '_sku'
							AND meta_value LIKE %s
							LIMIT 10",
							'%' . $wpdb->esc_like( $term ) . '%'
						)
					);
				},
				60 // Short cache for search results.
			);

			foreach ( $sku_results as $result ) {
				$product = wc_get_product( $result->post_id );
				if ( $product && 'publish' === $product->get_status() ) {
					$formatted_name = $product->get_name();
					$sku            = $product->get_sku();
					if ( $sku ) {
						$formatted_name .= ' (SKU: ' . $sku . ')';
					}

					$products[] = array(
						'id'   => $result->post_id,
						'text' => wp_strip_all_tags( $formatted_name ),
					);
				}
			}
		}

		$unique_products = array();
		$seen_ids        = array();
		foreach ( $products as $product ) {
			if ( ! in_array( $product['id'], $seen_ids, true ) ) {
				$unique_products[] = $product;
				$seen_ids[]        = $product['id'];
			}
		}

		wp_send_json( $unique_products );
	}

	/**
	 * AJAX handler for clearing cache.
	 */
	public function ajax_clear_cache() {
		if ( ! isset( $_POST['nonce'] ) || ! wp_verify_nonce( sanitize_text_field( wp_unslash( $_POST['nonce'] ) ), 'dp_aicoso_admin' ) ) {
			wp_die(
				wp_json_encode(
					array(
						'success' => false,
						'message' => 'Security check failed',
					)
				)
			);
		}

		if ( ! current_user_can( 'manage_woocommerce' ) ) {
			wp_die(
				wp_json_encode(
					array(
						'success' => false,
						'message' => 'Insufficient permissions',
					)
				)
			);
		}

		global $wpdb;
		$table_name = $this->get_table_name( 'dp_aicoso_price_cache' );

		// Build query without interpolated variables.
		// phpcs:ignore WordPress.DB.DirectDatabaseQuery.DirectQuery, WordPress.DB.DirectDatabaseQuery.NoCaching -- Write operation.
		$wpdb->query( $wpdb->prepare( 'TRUNCATE TABLE `%s`', $table_name ) );

		// Also flush the WordPress object cache for our cache group.
		wp_cache_flush_group( 'dp_aicoso_admin' );

		wp_die(
			wp_json_encode(
				array(
					'success' => true,
					'message' => 'Cache cleared successfully',
				)
			)
		);
	}
}