<?php

/**
 * !! Do not apply Woo-specific changes to this class !!
 *
 * This class is a part of the WordPress/php-toolkit project and is currently
 * duplicated between WordPress/php-toolkit and woocommerce/woocommerce:
 * * https://github.com/WordPress/php-toolkit/blob/trunk/components/DataLiberation/Importer/ImportSession.php
 * * https://github.com/woocommerce/woocommerce/blob/trunk/plugins/woocommerce/src/Internal/CLI/Migrator/Lib/ImportSession.php
 *
 * Apply all changes in both projects until Woo consumes php-toolkit as a
 * composer dependency. Generic changes belong to this class. Anything
 * Woo-specific should be implemented as an extension point.
 *
 * MODIFICATION: Made this class standalone by replacing external StreamImporter 
 * and AttachmentDownloaderEvent dependencies with internal constants to eliminate 
 * external imports and make the class fully self-contained.
 */

namespace Automattic\WooCommerce\Internal\CLI\Migrator\Lib;

use WP_Query;

use function get_all_post_meta_flat;
use function is_wp_error;

/**
 * Manages import session data in the WordPress database.
 *
 * Each import session is stored as a post of type 'import_session'.
 * Progress, stage, and other metadata are stored as post meta.
 */
class ImportSession {
	const POST_TYPE = 'import_session';

	// Import stage constants - replaces StreamImporter dependencies
	const STAGE_INITIAL = 'initial';
	const STAGE_FINISHED = 'finished';
	
	// Import stages in processing order
	const STAGES_IN_ORDER = array(
		self::STAGE_INITIAL,
		'indexing',
		'preparing',
		'importing',
		'finalizing',
		self::STAGE_FINISHED,
	);

	// Event type constants - replaces AttachmentDownloaderEvent dependencies  
	const EVENT_SUCCESS = 'success';
	const EVENT_ALREADY_EXISTS = 'already_exists';
	const EVENT_FAILURE = 'failure';

	/**
	 * @TODO: Make it extendable
	 * @TODO: Reuse the same entities list as WP_Stream_Importer
	 */
	const PROGRESS_ENTITIES = array(
		'site_option',
		'user',
		'category',
		'tag',
		'term',
		'post',
		'post_meta',
		'comment',
		'comment_meta',
	);

	const FRONTLOAD_STATUS_AWAITING_DOWNLOAD = 'awaiting_download';
	const FRONTLOAD_STATUS_IGNORED = 'ignored';
	const FRONTLOAD_STATUS_ERROR = 'error';
	const FRONTLOAD_STATUS_SUCCEEDED = 'succeeded';
	private $post_id;
	private $cached_stage;

	/**
	 * Creates a new import session.
	 *
	 * @param  array  $args  {
	 *
	 * @type string $data_source The data source (e.g. 'wxr_file', 'wxr_url', 'markdown_zip')
	 * @type string $source_url Optional. URL of the source file for remote imports
	 * @type int $attachment_id Optional. ID of the uploaded file attachment
	 * @type string $file_name Optional. Original name of the uploaded file
	 * }
	 * @return ImportSession The created ImportSession instance.
	 * @throws \Exception If the arguments are invalid.
	 */
	public static function create( $args ) {
		// Validate the required arguments for each data source.
		// @TODO: Leave it up to filters to make it extendable.
		switch ( $args['data_source'] ) {
			case 'wxr_file':
				if ( empty( $args['file_name'] ) ) {
					throw new \Exception( 'File name is required for WXR file imports' );
				}
				break;
			case 'wxr_url':
				if ( empty( $args['source_url'] ) ) {
					throw new \Exception( 'Source URL is required for remote imports' );
				}
				break;
			case 'markdown_zip':
				if ( empty( $args['file_name'] ) ) {
					throw new \Exception( 'File name is required for Markdown ZIP imports' );
				}
				break;
			case 'local_directory':
				if ( empty( $args['file_name'] ) ) {
					throw new \Exception( 'Directory path is required for local directory imports' );
				}
				break;
		}

		$post_id = wp_insert_post(
			array(
				'post_type'   => self::POST_TYPE,
				'post_status' => 'publish',
				'post_title'  => sprintf(
					'Import from %s - %s',
					$args['data_source'],
					$args['file_name'] ?? $args['source_url'] ?? 'Unknown source'
				),
				'meta_input'  => array(
					'data_source'   => $args['data_source'],
					'started_at'    => time(),
					'file_name'     => $args['file_name'] ?? null,
					'source_url'    => $args['source_url'] ?? null,
					'attachment_id' => $args['attachment_id'] ?? null,
				),
			),
			true
		);
		if ( is_wp_error( $post_id ) ) {
			throw new \Exception( 'Error creating an import session: ' . $post_id->get_error_message() );
		}

		if ( ! empty( $args['attachment_id'] ) ) {
			wp_update_post(
				array(
					'ID'          => $post_id,
					'post_parent' => $args['attachment_id'],
				)
			);
		}

		return new self( $post_id );
	}

	/**
	 * Gets an existing import session by ID.
	 *
	 * @param  int  $post_id  The import session post ID
	 *
	 * @return WP_Import_Model|null The import model instance or null if not found
	 */
	public static function by_id( $post_id ) {
		$post = get_post( $post_id );
		if ( ! $post || $post->post_type !== self::POST_TYPE ) {
			return false;
		}

		return new self( $post_id );
	}

	/**
	 * Gets the most recent active import session.
	 *
	 * @return WP_Import_Session|null The most recent import or null if none found
	 */
	public static function get_active() {
		$posts = get_posts(
			array(
				'post_type'      => self::POST_TYPE,
				'post_status'    => array( 'publish' ),
				'posts_per_page' => 1,
				'orderby'        => 'date',
				'order'          => 'DESC',
				'meta_query'     => array(
					// @TODO: This somehow makes $post empty.
					// array(
					// 'key' => 'current_stage',
					// 'value' => WP_Stream_Importer::STAGE_FINISHED,
					// 'compare' => '!='
					// )
				),
			)
		);

		if ( empty( $posts ) ) {
			return false;
		}

		return new self( $posts[0]->ID );
	}

	public function __construct( $post_id ) {
		$this->post_id = $post_id;
	}

	/**
	 * Gets the import session ID.
	 *
	 * @return int The post ID
	 */
	public function get_id() {
		return $this->post_id;
	}

	public function get_metadata() {
		$cursor = $this->get_reentrancy_cursor();

		return array(
			'post_id'       => $this->post_id,
			'cursor'        => $cursor ? $cursor : null,
			'data_source'   => get_post_meta( $this->post_id, 'data_source', true ),
			'source_url'    => get_post_meta( $this->post_id, 'source_url', true ),
			'attachment_id' => get_post_meta( $this->post_id, 'attachment_id', true ),
		);
	}

	public function get_data_source() {
		return get_post_meta( $this->post_id, 'data_source', true );
	}

	public function get_human_readable_file_reference() {
		switch ( $this->get_data_source() ) {
			case 'wxr_file':
			case 'markdown_zip':
				return get_post_meta( $this->post_id, 'file_name', true );
			case 'wxr_url':
				return get_post_meta( $this->post_id, 'source_url', true );
		}

		return '';
	}

	public function archive() {
		wp_update_post(
			array(
				'ID'          => $this->post_id,
				'post_status' => 'archived',
			)
		);
	}

	/**
	 * Gets the current progress information.
	 *
	 * @return array The progress data
	 */
	public function count_imported_entities() {
		$progress = array();
		foreach ( self::PROGRESS_ENTITIES as $entity ) {
			$progress[] = array(
				'label'    => $entity,
				'imported' => (int) get_post_meta( $this->post_id, 'imported_' . $entity, true ),
				'total'    => (int) get_post_meta( $this->post_id, 'total_' . $entity, true ),
			);
		}

		return $progress;
	}

	public function count_all_imported_entities() {
		$counts = $this->count_imported_entities();

		return array_sum( array_column( $counts, 'imported' ) );
	}

	public function count_all_total_entities() {
		$counts = $this->count_imported_entities();

		return array_sum( array_column( $counts, 'total' ) );
	}

	public function count_remaining_entities() {
		$counts = $this->count_imported_entities();

		return array_sum( array_column( $counts, 'total' ) ) - array_sum( array_column( $counts, 'imported' ) );
	}

	/**
	 * Cache of imported entity counts to avoid repeated database queries
	 *
	 * @var array
	 */
	private $cached_imported_counts = array();

	/**
	 * Updates the progress information.
	 *
	 * @param  array  $newly_imported_entities  The new progress data with keys: posts, comments, terms, attachments, users
	 */
	public function bump_imported_entities_counts( $newly_imported_entities ) {
		foreach ( $newly_imported_entities as $field => $count ) {
			if ( ! in_array( $field, static::PROGRESS_ENTITIES, true ) ) {
				_doing_it_wrong(
					__METHOD__,
					'Cannot bump imported entities count for unknown entity type: ' . $field,
					'1.0.0'
				);
				continue;
			}

			// Get current count from cache or database
			if ( ! isset( $this->cached_imported_counts[ $field ] ) ) {
				$this->cached_imported_counts[ $field ] = (int) get_post_meta( $this->post_id, 'imported_' . $field, true );
			}

			// Add new count to total
			$new_count = $this->cached_imported_counts[ $field ] + $count;

			// Update database and cache
			update_post_meta( $this->post_id, 'imported_' . $field, $new_count );
			$this->cached_imported_counts[ $field ] = $new_count;
			/*
			@TODO run an atomic query instead:
			$sql = $wpdb->prepare(
				"INSERT INTO {$wpdb->postmeta} (post_id, meta_key, meta_value)
				VALUES (%d, %s, %d)
				ON DUPLICATE KEY UPDATE meta_value = meta_value + %d",
				$this->post_id,
				'imported_' . $field,
				$count,
				$count
			);
			$wpdb->query($sql);
			*/
		}
	}

	public function count_awaiting_frontloading_stubs() {
		global $wpdb;

		return (int) $wpdb->get_var(
			$wpdb->prepare(
				"SELECT COUNT(*) FROM $wpdb->posts
				 WHERE post_type = 'frontloading_stub'
				 AND post_parent = %d
				 AND post_status = %s",
				$this->post_id,
				self::FRONTLOAD_STATUS_AWAITING_DOWNLOAD
			)
		);
	}

	public function count_unfinished_frontloading_stubs() {
		global $wpdb;

		return (int) $wpdb->get_var(
			$wpdb->prepare(
				"SELECT COUNT(*) FROM $wpdb->posts
				 WHERE post_type = 'frontloading_stub'
				 AND post_parent = %d
				 AND post_status != %s
				 AND post_status != %s",
				$this->post_id,
				self::FRONTLOAD_STATUS_SUCCEEDED,
				self::FRONTLOAD_STATUS_IGNORED
			)
		);
	}

	public function mark_frontloading_errors_as_ignored() {
		global $wpdb;
		$wpdb->update(
			$wpdb->posts,
			array( 'post_status' => self::FRONTLOAD_STATUS_IGNORED ),
			array(
				'post_type' => 'frontloading_stub',
				// 'post_status !=' => self::FRONTLOAD_STATUS_SUCCEEDED,
			)
		);
	}

	public function get_frontloading_stubs( $options = array() ) {
		$query = new WP_Query(
			array(
				'post_type'      => 'frontloading_stub',
				'post_status'    => 'any',
				'post_parent'    => $this->post_id,
				'posts_per_page' => $options['per_page'] ?? 25,
				'paged'          => $options['page'] ?? 1,
				'orderby'        => array(
					'post_status' => array(
						self::FRONTLOAD_STATUS_ERROR             => 0,
						self::FRONTLOAD_STATUS_AWAITING_DOWNLOAD => 1,
						'any'                                    => 2,
					),
					'ID'          => 'ASC',
				),
			)
		);

		if ( ! $query->have_posts() ) {
			return array();
		}

		$posts = $query->posts;
		$ids   = array_map(
			function ( $post ) {
				return $post->ID;
			},
			$posts
		);
		update_meta_cache( 'post', $ids );
		foreach ( $posts as $post ) {
			$post->meta = get_all_post_meta_flat( $post->ID );
		}

		return $posts;
	}

	public function get_total_number_of_entities() {
		$totals = array();
		foreach ( static::PROGRESS_ENTITIES as $field ) {
			$totals[ $field ] = (int) get_post_meta( $this->post_id, 'total_' . $field, true );
		}
		$totals['download'] = $this->get_total_number_of_assets();

		return $totals;
	}

	public function get_total_number_of_assets() {
		global $wpdb;

		return (int) $wpdb->get_var(
			$wpdb->prepare(
				"SELECT COUNT(*) FROM $wpdb->posts
			WHERE post_type = 'frontloading_stub'
			AND post_parent = %d",
				$this->post_id
			)
		);
	}

	public function get_frontloading_stub( $url ) {
		global $wpdb;
		$id = $wpdb->get_var(
			$wpdb->prepare(
				"SELECT p.ID FROM $wpdb->posts p
				 INNER JOIN $wpdb->postmeta pm ON p.ID = pm.post_id
				 WHERE p.post_type = 'frontloading_stub'
				 AND p.post_parent = %d
				 AND pm.meta_key = 'current_url'
				 AND pm.meta_value = %s
				 LIMIT 1",
				$this->post_id,
				$url
			)
		);

		return get_post( $id );
	}

	/**
	 * Creates placeholder attachments for the assets to be downloaded in the
	 * frontloading stage.
	 */
	public function create_frontloading_stubs( $urls ) {
		global $wpdb;

		foreach ( $urls as $url => $_ ) {
			/**
			 * Check if placeholder with this URL already exists
			 * There's a race condition here – another insert may happen
			 * between the check and the insert.
			 *
			 * @TODO: Explore solutions. A custom table with a UNIQUE constraint
			 * may or may not be an option, depending on the performance impact
			 * on 100GB+ VIP databases.
			 */
			$exists = $wpdb->get_var(
				$wpdb->prepare(
					"SELECT ID FROM $wpdb->posts
				WHERE post_type = 'frontloading_stub'
				AND post_parent = %d
				AND guid = %s
				LIMIT 1",
					$this->post_id,
					$url
				)
			);

			if ( $exists ) {
				continue;
			}

			$post_data        = array(
				'post_type'   => 'frontloading_stub',
				'post_parent' => $this->post_id,
				'post_title'  => basename( $url ),
				'post_status' => self::FRONTLOAD_STATUS_AWAITING_DOWNLOAD,
				'guid'        => $url,
				'meta_input'  => array(
					'original_url' => $url,
					'current_url'  => $url,
					'attempts'     => 0,
					'last_error'   => null,
					'target_path'  => '',
				),
			);
			$insertion_result = wp_insert_post( $post_data );
			if ( is_wp_error( $insertion_result ) ) {
				throw new \Exception( 'Failed to insert frontloading placeholder' );
			}
		}
	}

	/**
	 * Sets the total number of entities to import for each type.
	 *
	 * @param  array  $totals  The total number of entities for each type
	 */
	private $cached_totals = array();

	public function bump_total_number_of_entities( $newly_indexed_entities ) {
		foreach ( $newly_indexed_entities as $field => $count ) {
			if ( ! in_array( $field, static::PROGRESS_ENTITIES, true ) ) {
				_doing_it_wrong(
					__METHOD__,
					'Cannot set total number of entities for unknown entity type: ' . $field,
					'1.0.0'
				);
				continue;
			}

			// Get current total from cache or database
			if ( ! isset( $this->cached_totals[ $field ] ) ) {
				$this->cached_totals[ $field ] = (int) get_post_meta( $this->post_id, 'total_' . $field, true );
			}

			// Add new count to total
			$new_total = $this->cached_totals[ $field ] + $count;

			// Update database and cache
			update_post_meta( $this->post_id, 'total_' . $field, $new_total );
			$this->cached_totals[ $field ] = $new_total;
		}
	}

	/**
	 * Saves an array of [$url => ['received' => $downloaded_bytes, 'total' => $total_bytes | null]]
	 * of the currently fetched files. The list is ephemeral and changes as we stream the data. There
	 * will never be more than $concurrency_limit files in the list at any given time.
	 */
	public function bump_frontloading_progress( $frontloading_progress, $events = array() ) {
		update_post_meta( $this->post_id, 'frontloading_progress', $frontloading_progress );

		foreach ( $events as $event ) {
			$url         = $event->resource_id;
			$placeholder = $this->get_frontloading_stub( $url );
			if ( ! $placeholder ) {
				_doing_it_wrong(
					__METHOD__,
					'Frontloading placeholder post not found for URL: ' . $url,
					'1.0.0'
				);
				continue;
			}

			update_post_meta( $placeholder->ID, 'last_error', $event->error );

			$attempts     = get_post_meta( $placeholder->ID, 'attempts', true );
			$new_attempts = $attempts;
			$new_status   = $placeholder->post_status;
			switch ( $event->type ) {
				case self::EVENT_SUCCESS:
					$new_status   = self::FRONTLOAD_STATUS_SUCCEEDED;
					$new_attempts = $attempts + 1;
					break;
				case self::EVENT_ALREADY_EXISTS:
					$new_status = self::FRONTLOAD_STATUS_SUCCEEDED;
					break;
				case self::EVENT_FAILURE:
					$new_status   = self::FRONTLOAD_STATUS_ERROR;
					$new_attempts = $attempts + 1;
					break;
			}

			if ( $new_attempts !== $attempts ) {
				update_post_meta( $placeholder->ID, 'attempts', $new_attempts );
			}

			if ( $new_status !== $placeholder->post_status ) {
				wp_update_post(
					array(
						'ID'          => $placeholder->ID,
						'post_status' => $new_status,
					)
				);
			}
		}
	}

	public function get_frontloading_progress() {
		$meta = get_post_meta( $this->post_id, 'frontloading_progress', true );

		return $meta ? $meta : array();
	}

	public function is_stage_completed( $stage ) {
		$current_stage       = $this->get_stage();
		$stage_index         = array_search( $stage, self::STAGES_IN_ORDER, true );
		$current_stage_index = array_search( $current_stage, self::STAGES_IN_ORDER, true );

		return $current_stage_index > $stage_index;
	}

	/**
	 * Gets the current import stage.
	 *
	 * @return string The current stage
	 */
	public function get_stage() {
		if ( ! isset( $this->cached_stage ) ) {
			$meta               = get_post_meta( $this->post_id, 'current_stage', true );
			$this->cached_stage = $meta ? $meta : self::STAGE_INITIAL;
		}

		return $this->cached_stage;
	}

	/**
	 * Updates the current import stage.
	 *
	 * @param  string  $stage  The new stage
	 */
	public function set_stage( $stage ) {
		if ( $stage === $this->get_stage() ) {
			return;
		}
		if ( self::STAGE_FINISHED === $stage ) {
			update_post_meta( $this->post_id, 'finished_at', time() );
		}
		update_post_meta( $this->post_id, 'current_stage', $stage );
		$this->cached_stage = $stage;
	}

	public function get_started_at() {
		return get_post_meta( $this->post_id, 'started_at', true );
	}

	public function get_finished_at() {
		return get_post_meta( $this->post_id, 'finished_at', true );
	}

	public function is_finished() {
		return ! empty( get_post_meta( $this->post_id, 'finished_at', true ) );
	}

	/**
	 * Gets the importer cursor for resuming imports.
	 *
	 * @return string|null The cursor data
	 */
	public function get_reentrancy_cursor() {
		return get_post_meta( $this->post_id, 'importer_cursor', true );
	}

	/**
	 * Updates the importer cursor.
	 *
	 * @param  string  $cursor  The new cursor data
	 */
	public function set_reentrancy_cursor( $cursor ) {
		// WordPress, sadly, removes single slashes from the meta value and
		// requires an addslashes() call to preserve them.
		update_post_meta( $this->post_id, 'importer_cursor', addslashes( $cursor ) );
	}
}