<?php
/**
 * @package PlugixaCrm
 */

declare( strict_types = 1 );

namespace PlugixaCrm\Core\Database;

use PlugixaCrm\Core\Modules\ModuleRegistry;

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

/**
 * Drops the tables left behind by the six add-on plugins the CRM used to host.
 *
 * WHY THIS EXISTS AT ALL. Between 3.0 and 3.2 some features lived in separate add-on plugins —
 * `plugixa-billing`, `-inventory`, `-purchasing`, `-projects`, `-advanced`, `-scheduler` — and every
 * one of them created its tables inside the CRM's own `plugixacrm_` prefix. That was deliberate then:
 * the prefix was the family's, not one plugin's. It stops being true the moment the family collapses
 * back into a single plugin, and it leaves up to 50 tables that nothing on the site will ever open
 * again. Each pack shipped an `uninstall.php` that would have dropped its own, but uninstalling a
 * plugin is not something a site owner necessarily did — deactivating and deleting the directory is
 * far more common, and that runs nothing.
 *
 * WHY A HARDCODED LIST AND NOT A PREFIX SWEEP. `SHOW TABLES LIKE 'wp_plugixacrm_%'` would match the
 * CRM's own thirty tables too. The prefix cannot distinguish them; only a list can. So the names are
 * written out in full below, which also makes this file the record of what those plugins owned.
 *
 * WHY THERE IS A SAFETY CHECK ON TOP OF THE LIST. A hardcoded list is only as good as the moment it
 * was written. If a future module ever claims one of these names — a Products module, say, or Cases
 * reusing something — this would silently delete live customer data on the next version bump. So
 * every name is checked against what the installed modules actually declare, and anything claimed is
 * refused and reported rather than dropped. The list is the intent; the modules are the authority.
 *
 * THIS IS DESTRUCTIVE AND DELIBERATELY SO. The decision taken was to drop this data rather than
 * carry it: products, quotes, invoices and payments were features in CRM 2.x, so live
 * wordpress.org installs do have rows here, and they are being discarded rather than exported. That
 * was an explicit product call, not an oversight.
 */
final class LegacyCleanup {

	/**
	 * Set once the sweep has run, so it costs one option read per version bump rather than 50
	 * `DROP TABLE IF EXISTS` statements every time.
	 */
	private const DONE_OPTION = 'plugixa_crm_legacy_packs_dropped';

	/**
	 * Options the six pack plugins owned. Removed alongside their tables — a stale
	 * `plugixa_billing_db_version` is harmless but it reads as though the plugin is still around.
	 */
	private const LEGACY_OPTIONS = array(
		'plugixa_advanced_db_version',
		'plugixa_billing_db_version',
		'plugixa_inventory_db_version',
		'plugixa_projects_db_version',
		'plugixa_purchasing_db_version',
		'plugixa_scheduler_db_version',
	);

	/**
	 * Bare table names (no `$wpdb->prefix`, no `plugixacrm_`) the add-ons created.
	 *
	 * Grouped by the plugin that owned them so the list can be audited against a repository if any of
	 * this ever has to be reconstructed.
	 *
	 * @return string[]
	 */
	private static function legacy_tables(): array {
		return array(
			// plugixa-billing — the nine money modules.
			'products',
			'product_categories',
			'brands',
			'tax_classes',
			'quotes',
			'quote_lines',
			'sales_orders',
			'sales_order_lines',
			'invoices',
			'invoice_lines',
			'credit_notes',
			'credit_note_lines',
			'payments',
			'payment_allocations',
			'payment_requests',
			'payment_request_invoices',
			'subscriptions',
			'subscription_lines',
			'subscription_periods',

			// plugixa-inventory.
			'warehouses',
			'inventory_transactions',
			'inventory_numbers',
			'inventory_documents',
			'inventory_document_lines',
			'attributes',
			'attribute_options',
			'product_attributes',
			'price_books',
			'price_rules',

			// plugixa-purchasing.
			'suppliers',
			'purchase_orders',
			'purchase_order_lines',
			'bills',
			'bill_lines',
			'bill_credits',
			'bill_credit_lines',
			'return_orders',
			'return_order_lines',

			// plugixa-projects.
			'projects',
			'project_stages',
			'milestones',
			'project_tasks',
			'project_task_dependencies',
			'project_task_history',
			'project_members',

			// plugixa-scheduler.
			'scheduler_booking_types',
			'scheduler_booking_type_hosts',
			'scheduler_availability',
			'scheduler_availability_overrides',
			'scheduler_bookings',
		);
	}

	/**
	 * Drop what the add-ons left, once.
	 *
	 * @param ModuleRegistry|null $modules The installed modules, used as the authority on what must
	 *                                     NOT be dropped. When null the check is skipped and nothing
	 *                                     is dropped, because a sweep with no authority to check
	 *                                     against is exactly the dangerous case.
	 *
	 * @return string[] The bare names actually dropped.
	 */
	public static function run( ?ModuleRegistry $modules = null ): array {
		if ( get_option( self::DONE_OPTION ) ) {
			return array();
		}

		if ( null === $modules ) {
			return array();
		}

		$claimed = self::claimed_tables( $modules );
		$dropped = array();

		foreach ( self::legacy_tables() as $bare ) {
			if ( isset( $claimed[ $bare ] ) ) {
				// A live module owns this name. The list is out of date, not the module — say so
				// loudly and leave the data alone.
				self::warn( $bare, $claimed[ $bare ] );
				continue;
			}

			if ( ! Schema::exists( $bare ) ) {
				continue;
			}

			Schema::drop( $bare );
			$dropped[] = $bare;
		}

		foreach ( self::LEGACY_OPTIONS as $option ) {
			delete_option( $option );
		}

		update_option( self::DONE_OPTION, PLUGIXA_CRM_VERSION );

		return $dropped;
	}

	/**
	 * Every bare table name the installed modules declare.
	 *
	 * Read from the modules themselves rather than from a second list here, so this cannot drift.
	 *
	 * @param ModuleRegistry $modules The installed modules.
	 *
	 * @return array<string, string> Bare table name => the module class that claims it.
	 */
	private static function claimed_tables( ModuleRegistry $modules ): array {
		$claimed = array();

		foreach ( $modules->all() as $module ) {
			$schema = str_replace( '\\Module', '\\Schema', $module::class );

			if ( ! class_exists( $schema ) || ! method_exists( $schema, 'tables' ) ) {
				continue;
			}

			foreach ( (array) $schema::tables() as $bare ) {
				$claimed[ (string) $bare ] = $schema;
			}
		}

		return $claimed;
	}

	/**
	 * @param string $bare  The table that was refused.
	 * @param string $owner The class that claims it.
	 */
	private static function warn( string $bare, string $owner ): void {
		if ( ! defined( 'WP_DEBUG' ) || ! WP_DEBUG ) {
			return;
		}

		// phpcs:ignore WordPress.PHP.DevelopmentFunctions.error_log_error_log -- WP_DEBUG-only, and a silent skip here would hide a list that has gone stale against a live module.
		error_log(
			sprintf(
				'Plugixa CRM: refusing to drop legacy table "%s" — %s claims it. Remove it from LegacyCleanup.',
				$bare,
				$owner
			)
		);
	}
}