<?php
declare(strict_types=1);

namespace WebCalendar\WP\Admin;

defined( 'ABSPATH' ) || exit;

use DateTimeImmutable;
use WebCalendar\Core\Domain\Repository\ResourceRepositoryInterface;
use WebCalendar\WP\Migration\Tec\TecEventMapper;
use WebCalendar\WP\Migration\Tec\TecImporter;
use WebCalendar\WP\Migration\Tec\TecReaderInterface;
use WebCalendar\WP\Migration\Tec\TecSyncScheduler;

/**
 * "The Events Calendar" tab of the Import screen — Epics 4 and 8 of the
 * TEC import plan (STATUS.md § TEC Import).
 *
 * Analyze → confirm (organizer checkbox) → import → results, plus a
 * Previous Imports table with per-run Undo, side-by-side sync settings
 * (Epic 8.3/8.4) and a "Remove all TEC events" undo-all. TEC data is
 * never modified. The success screen's advice depends on sync: comparing
 * keeps TEC active, switching deactivates it.
 *
 * @psalm-suppress UnusedClass -- wired into the Import screen tabs.
 */
final class TecMigrationTab {

	private const NONCE = 'webcal_tec_import';

	public function __construct(
		private readonly TecReaderInterface $reader,
		private readonly TecImporter $importer,
		private readonly TecEventMapper $mapper,
		private readonly ?ResourceRepositoryInterface $resources = null,
		private ?TecSyncScheduler $scheduler = null,
	) {
	}

	/**
	 * The sync scheduler, sharing this tab's reader and pipeline.
	 */
	public function scheduler(): TecSyncScheduler {
		$this->scheduler ??= new TecSyncScheduler( $this->reader, $this );
		return $this->scheduler;
	}

	/**
	 * Production wiring, shared by the Import screen and the CLI.
	 */
	public static function create(): self {
		/** @var \wpdb $wpdb */
		$wpdb      = $GLOBALS['wpdb'];
		$container = \WebCalendar\WP\Container::get_instance();
		$host      = wp_parse_url( home_url(), PHP_URL_HOST );

		return new self(
			new \WebCalendar\WP\Migration\Tec\WpdbTecReader(),
			new TecImporter(
				$container->get_pdo(),
				$wpdb->prefix,
				$container->get_event_repository()
			),
			new TecEventMapper(
				wp_timezone(),
				is_string( $host ) && '' !== $host ? $host : 'WordPress.local',
				new \WebCalendar\WP\Migration\Tec\TecRecurrenceConverter()
			),
			$container->get_resource_repository()
		);
	}

	/**
	 * Shared calendars that can own imported events: resources without a
	 * URL (a URL means a remote-calendar subscription), login => name.
	 *
	 * @return array<string, string>
	 */
	public function shared_calendars(): array {
		if ( null === $this->resources ) {
			return array();
		}
		try {
			$calendars = array();
			foreach ( $this->resources->findAll() as $resource ) {
				if ( null === $resource->url() ) {
					$calendars[ $resource->login() ] = $resource->name();
				}
			}
			return $calendars;
		} catch ( \Exception $e ) {
			return array();
		}
	}

	public function render(): void {
		// phpcs:ignore WordPress.Security.NonceVerification.Missing -- step routing only; each handler verifies its own nonce.
		$step = isset( $_POST['webcal_tec_step'] ) && is_string( $_POST['webcal_tec_step'] ) ? sanitize_text_field( wp_unslash( $_POST['webcal_tec_step'] ) ) : '';

		if ( 'run' === $step ) {
			$this->handle_run();
			return;
		}
		if ( 'rollback' === $step ) {
			$this->handle_rollback();
			return;
		}
		if ( 'sync-settings' === $step ) {
			$this->handle_sync_settings();
			return;
		}
		if ( 'remove-all' === $step ) {
			$this->handle_remove_all();
			return;
		}
		if ( 'sync-now' === $step ) {
			$this->handle_sync_now();
			return;
		}
		$this->render_analysis();
	}

	/**
	 * What the site's TEC data looks like, for the analysis screen.
	 *
	 * @return array{available: bool, status_counts: array<string, int>, recurring: int, with_venue: int, with_organizer: int, categories: int}
	 */
	public function analyze(): array {
		if ( ! $this->reader->is_available() ) {
			return array(
				'available'      => false,
				'status_counts'  => array(),
				'recurring'      => 0,
				'with_venue'     => 0,
				'with_organizer' => 0,
				'categories'     => 0,
			);
		}

		$recurring      = 0;
		$with_venue     = 0;
		$with_organizer = 0;
		foreach ( $this->reader->events() as $event ) {
			if ( null !== $event->recurrence ) {
				++$recurring;
			}
			if ( null !== $event->venue_id ) {
				++$with_venue;
			}
			if ( null !== $event->organizer_id ) {
				++$with_organizer;
			}
		}

		return array(
			'available'      => true,
			'status_counts'  => $this->reader->count_events_by_status(),
			'recurring'      => $recurring,
			'with_venue'     => $with_venue,
			'with_organizer' => $with_organizer,
			'categories'     => count( $this->reader->categories() ),
		);
	}

	/**
	 * A warning naming the Additional Fields this import does not carry.
	 *
	 * Recorded on the run as well as shown beforehand, so the history of an
	 * import says what it left behind rather than only what it took.
	 *
	 * @return list<string>
	 */
	private function additional_field_warning(): array {
		$unreadable = array_column(
			array_values(
				array_filter(
					$this->reader->additional_fields(),
					static fn( array $field ): bool => '' === $field['key']
				)
			),
			'label'
		);

		if ( array() === $unreadable ) {
			return array();
		}

		return array(
			sprintf(
				/* translators: %s: comma-separated field labels. */
				__( 'These Additional Fields could not be read and were not imported: %s.', 'agenticdaisy-calendar' ),
				implode( ', ', $unreadable )
			),
		);
	}

	/**
	 * Make sure this site has a custom field for each of TEC's, and return
	 * the mapping from TEC's meta keys to our field names.
	 *
	 * Definitions are created rather than assumed: importing values into
	 * fields nobody has defined would put them straight back where they were
	 * before this release — in the table and on no screen. Existing fields
	 * are matched by name and left alone, so a second import does not
	 * duplicate them or overwrite a label somebody has since edited.
	 *
	 * @return array<string, string> TEC meta key => this site's field name.
	 */
	private function ensure_extra_fields(): array {
		$tec_fields = array_values(
			array_filter(
				$this->reader->additional_fields(),
				static fn( array $field ): bool => '' !== $field['key']
			)
		);
		if ( array() === $tec_fields ) {
			return array();
		}

		$existing = \WebCalendar\WP\SiteExtraFields::all();
		$by_name  = array();
		foreach ( $existing as $field ) {
			$by_name[ $field['name'] ] = true;
		}

		$map   = array();
		$added = array();
		foreach ( $tec_fields as $field ) {
			$name = sanitize_key( $field['label'] );
			if ( '' === $name ) {
				continue;
			}
			$map[ $field['key'] ] = $name;

			if ( ! isset( $by_name[ $name ] ) ) {
				$definition = array(
					'name'  => $name,
					'label' => $field['label'],
					'type'  => self::map_field_type( $field['type'] ),
				);
				// Choices come from The Events Calendar's own definition, so a
				// dropdown arrives offering what it was configured with rather
				// than only the values events happen to use.
				if ( 'select' === $definition['type'] ) {
					$definition['options'] = $field['options'];
				}
				$added[]          = $definition;
				$by_name[ $name ] = true;
			}
		}

		if ( array() !== $added ) {
			\WebCalendar\WP\SiteExtraFields::save( array_merge( $existing, $added ) );
		}

		return $map;
	}

	/**
	 * The Events Calendar's field types onto ours.
	 *
	 * Anything unrecognised becomes text, which renders every value legibly
	 * even when it loses a little meaning — the alternative is dropping the
	 * field, and a checkbox shown as text is better than a checkbox lost.
	 */
	private static function map_field_type( string $tec_type ): string {
		switch ( strtolower( trim( $tec_type ) ) ) {
			case 'textarea':
			case 'text area':
				return 'textarea';

			case 'url':
				return 'url';

			case 'dropdown':
			case 'select':
			case 'radio':
				// Radio is a select with different chrome: one value from a
				// fixed list, which is what a select stores.
				return 'select';

			case 'checkbox':
				// Not our checkbox. The Events Calendar Pro's is a group of
				// checkboxes with an options list, so an event can hold
				// several values at once; ours is a single yes/no. There is
				// nowhere to put more than one value — webcal_site_extras is
				// keyed (cal_id, cal_name) — so the stored string is kept as
				// text: legible and complete, rather than a boolean that
				// discards every choice after the first.
				return 'text';

			default:
				return 'text';
		}
	}

	/**
	 * Read, map and import every published TEC event.
	 *
	 * @param bool    $append_organizer Append organizer blocks to descriptions.
	 * @param ?string $target_login     Shared calendar to own every imported
	 *                                  event; null keeps each event on its
	 *                                  original author's calendar.
	 * @return array{import_id: int, imported: int, duplicates: int, instances: int, categories: int, tags: int, skipped: int, warnings: list<string>}
	 * @throws \InvalidArgumentException When $target_login is not a shared
	 *                                    calendar — before anything is written.
	 * @throws \Throwable On import failure — nothing was written.
	 */
	public function run_import( bool $append_organizer, ?string $target_login = null ): array {
		$this->assert_valid_target( $target_login );

		$this->mapper->set_extra_field_map( $this->ensure_extra_fields() );
		$batch = $this->map_events( $this->reader->events(), $append_organizer, $target_login );

		$report             = $this->importer->import( $batch['mapped'], $batch['instance_map'] );
		$report['skipped']  = $batch['skipped'];
		$report['warnings'] = array_merge( $report['warnings'], $batch['warnings'], $this->additional_field_warning() );
		return $report;
	}

	/**
	 * One sync cycle — Epic 8 (STATUS.md): mirror TEC changes since the
	 * last cycle onto the imported events, then sweep the mirror against
	 * TEC's current published set so deletes, trashes and unpublishes
	 * converge (a modified-since read cannot see them). One-way: TEC wins,
	 * TEC data is never modified.
	 *
	 * @param bool               $append_organizer Same meaning as run_import();
	 *                                             cycles should reuse the
	 *                                             original import's choice.
	 * @param ?string            $target_login     Same meaning as run_import().
	 * @param ?DateTimeImmutable $since            Only map TEC events modified
	 *                                             at or after this UTC instant;
	 *                                             null maps everything.
	 * @return array{import_id: int, added: int, updated: int, unchanged: int, removed: int, instances: int, categories: int, tags: int, skipped: int, warnings: list<string>}
	 * @throws \InvalidArgumentException When $target_login is not a shared
	 *                                    calendar — before anything is written.
	 * @throws \Throwable On failure — the cycle wrote nothing (the sweep runs
	 *                     in its own transaction after a successful sync).
	 */
	public function run_sync( bool $append_organizer, ?string $target_login = null, ?DateTimeImmutable $since = null ): array {
		$this->assert_valid_target( $target_login );

		$this->mapper->set_extra_field_map( $this->ensure_extra_fields() );
		$batch = $this->map_events( $this->reader->events( $since ), $append_organizer, $target_login );

		$report             = $this->importer->sync( $batch['mapped'], $batch['instance_map'] );
		$report['skipped']  = $batch['skipped'];
		$report['warnings'] = array_merge( $report['warnings'], $batch['warnings'], $this->additional_field_warning() );

		// Deletion sweep: mirrored events whose TEC post is no longer
		// published. The TEC post id is parsed out of the uid rather than
		// recomputed from the current host so a site-domain change cannot
		// orphan the whole mirror.
		$published = array_fill_keys( $this->reader->published_ids(), true );
		$orphans   = array();
		foreach ( $this->importer->mirrored_base_uids() as $uid ) {
			if ( 1 === preg_match( '/^tec-(\d+)@/', $uid, $m ) && ! isset( $published[ (int) $m[1] ] ) ) {
				$orphans[] = $uid;
			}
		}
		$report['removed'] += $this->importer->remove( $orphans );

		return $report;
	}

	/**
	 * @throws \InvalidArgumentException When the target is not a shared calendar.
	 */
	private function assert_valid_target( ?string $target_login ): void {
		if ( null !== $target_login && ! isset( $this->shared_calendars()[ $target_login ] ) ) {
			throw new \InvalidArgumentException(
				sprintf( 'Unknown shared calendar "%s".', esc_html( $target_login ) )
			);
		}
	}

	/**
	 * Map TEC events into import-engine input: resolve venues, organizers
	 * and categories, map each event, and collect occurrence lists for
	 * non-convertible recurrences. Shared by run_import() and run_sync().
	 *
	 * @param list<\WebCalendar\WP\Migration\Tec\TecEvent> $events TEC events.
	 * @return array{mapped: list<\WebCalendar\WP\Migration\Tec\MappedTecEvent>, instance_map: array<string, list<DateTimeImmutable>>, skipped: int, warnings: list<string>}
	 */
	private function map_events( array $events, bool $append_organizer, ?string $target_login ): array {
		$venue_ids     = array();
		$organizer_ids = array();
		foreach ( $events as $event ) {
			if ( null !== $event->venue_id ) {
				$venue_ids[] = $event->venue_id;
			}
			if ( null !== $event->organizer_id ) {
				$organizer_ids[] = $event->organizer_id;
			}
		}
		$venues     = $this->reader->venues( array_values( array_unique( $venue_ids ) ) );
		$organizers = $this->reader->organizers( array_values( array_unique( $organizer_ids ) ) );
		$categories = $this->reader->categories();

		$mapped       = array();
		$instance_map = array();
		$skipped      = 0;
		$warnings     = array();

		foreach ( $events as $event ) {
			$event_categories = array();
			foreach ( $event->category_ids as $term_id ) {
				if ( isset( $categories[ $term_id ] ) ) {
					$event_categories[] = $categories[ $term_id ];
				}
			}

			try {
				$item = $this->mapper->map(
					$event,
					null !== $event->venue_id ? ( $venues[ $event->venue_id ] ?? null ) : null,
					null !== $event->organizer_id ? ( $organizers[ $event->organizer_id ] ?? null ) : null,
					$event_categories,
					$target_login ?? $this->resolve_creator_login( $event->author_id ),
					$append_organizer
				);
			} catch ( \InvalidArgumentException $e ) {
				++$skipped;
				$warnings[] = sprintf(
					/* translators: 1: event title, 2: error detail. */
					__( 'Skipped "%1$s": %2$s', 'agenticdaisy-calendar' ),
					$event->title,
					$e->getMessage()
				);
				continue;
			}

			if ( $item->needs_instance_expansion ) {
				$occurrences = $this->mapper->map_occurrences( $event, $this->reader->occurrences( $event->id ) );
				if ( array() !== $occurrences ) {
					$instance_map[ $item->event->uid() ] = $occurrences;
				}
			}

			$mapped[] = $item;
		}

		return array(
			'mapped'       => $mapped,
			'instance_map' => $instance_map,
			'skipped'      => $skipped,
			'warnings'     => $warnings,
		);
	}

	/**
	 * The webcal login an imported event belongs to: the TEC post author's
	 * login, or the importing user when the author no longer exists.
	 *
	 * @throws \RuntimeException When no importing user is available either —
	 *         cannot happen in wp-admin (the capability check guarantees a
	 *         user), but a CLI caller without --user would otherwise create
	 *         ownerless events.
	 */
	public function resolve_creator_login( int $author_id ): string {
		if ( $author_id > 0 ) {
			$user = get_userdata( $author_id );
			if ( false !== $user && '' !== $user->user_login ) {
				return $user->user_login;
			}
		}

		// The anonymous user (WP-CLI without --user) reports user_login as
		// false, not '' — observed live — so gate on exists() rather than
		// trusting the property's stubbed string type.
		$current = wp_get_current_user();
		if ( $current->exists() && '' !== $current->user_login ) {
			return $current->user_login;
		}
		throw new \RuntimeException( 'No importing user available to own events whose TEC author no longer exists.' );
	}

	private function render_analysis( string $error = '' ): void {
		if ( '' !== $error ) {
			echo '<div class="notice notice-error"><p>' . esc_html( $error ) . '</p></div>';
		}

		$sync_notice = $this->scheduler()->settings()['notice'];
		if ( null !== $sync_notice ) {
			echo '<div class="notice notice-warning"><p>' . esc_html( $sync_notice ) . '</p></div>';
		}

		$analysis = $this->analyze();
		?>
		<h2><?php esc_html_e( 'Import from The Events Calendar', 'agenticdaisy-calendar' ); ?></h2>
		<?php
		if ( ! $analysis['available'] ) {
			echo '<p>' . esc_html__( 'No data from The Events Calendar was found in this site\'s database.', 'agenticdaisy-calendar' ) . '</p>';
			$this->render_previous_runs();
			return;
		}

		$publish = $analysis['status_counts']['publish'] ?? 0;
		$other   = array_sum( $analysis['status_counts'] ) - $publish;

		// Said before the import, not after: the point is to let somebody
		// decide, and a note in the summary of a completed run is too late to
		// act on. Events Calendar Pro's Additional Fields are configured
		// deliberately, so losing them without a word is worse than declining
		// to carry them.
		$extra_fields = $this->reader->additional_fields();
		if ( array() !== $extra_fields ) {
			$readable = array_values( array_filter( $extra_fields, static fn( array $f ): bool => '' !== $f['key'] ) );
			$labels   = array_column( $readable, 'label' );

			if ( array() !== $labels ) {
				echo '<div class="notice notice-info"><p>' . esc_html(
					sprintf(
						/* translators: %s: comma-separated field labels. */
						__( 'Additional Fields from The Events Calendar Pro will be imported as custom fields: %s. Matching fields are created under Calendar → Custom Fields if they do not exist.', 'agenticdaisy-calendar' ),
						implode( ', ', $labels )
					)
				) . '</p></div>';
			}

			// A definition with no storage key cannot be read at all, so say
			// so separately rather than implying it will come across.
			$unreadable = array_column(
				array_values( array_filter( $extra_fields, static fn( array $f ): bool => '' === $f['key'] ) ),
				'label'
			);
			if ( array() !== $unreadable ) {
				echo '<div class="notice notice-warning"><p>' . esc_html(
					sprintf(
						/* translators: %s: comma-separated field labels. */
						__( 'These Additional Fields cannot be read and will not be imported: %s.', 'agenticdaisy-calendar' ),
						implode( ', ', $unreadable )
					)
				) . '</p></div>';
			}
		}
		?>
		<p><?php esc_html_e( 'Imports published events — with venues, organizers, categories, featured images and recurrence — into WebCalendar. The Events Calendar\'s own data is not changed. Nothing is written until you confirm below, and the import can be undone afterwards.', 'agenticdaisy-calendar' ); ?></p>
		<table class="widefat striped" style="max-width:420px;">
			<tbody>
				<tr><td><?php esc_html_e( 'Published events', 'agenticdaisy-calendar' ); ?></td><td><?php echo esc_html( (string) $publish ); ?></td></tr>
				<tr><td><?php esc_html_e( 'Unpublished (drafts etc., not imported)', 'agenticdaisy-calendar' ); ?></td><td><?php echo esc_html( (string) $other ); ?></td></tr>
				<tr><td><?php esc_html_e( 'Recurring events', 'agenticdaisy-calendar' ); ?></td><td><?php echo esc_html( (string) $analysis['recurring'] ); ?></td></tr>
				<tr><td><?php esc_html_e( 'With a venue', 'agenticdaisy-calendar' ); ?></td><td><?php echo esc_html( (string) $analysis['with_venue'] ); ?></td></tr>
				<tr><td><?php esc_html_e( 'With an organizer', 'agenticdaisy-calendar' ); ?></td><td><?php echo esc_html( (string) $analysis['with_organizer'] ); ?></td></tr>
				<tr><td><?php esc_html_e( 'Categories', 'agenticdaisy-calendar' ); ?></td><td><?php echo esc_html( (string) $analysis['categories'] ); ?></td></tr>
			</tbody>
		</table>
		<form method="post" style="margin-top:12px;">
			<?php wp_nonce_field( self::NONCE ); ?>
			<input type="hidden" name="webcal_tec_step" value="run">
			<p>
				<label>
					<?php
					// Follow the sync setting rather than a fixed default. On a
					// fresh site that is off, which is the intended new
					// behaviour; on a site already syncing with it on, this
					// keeps the two in step. They must agree: an import that
					// writes descriptions one way and a sync that maps them the
					// other rewrites the same events on every cycle forever.
					$organizer_default = $this->scheduler()->settings()['append_organizer'];
					?>
					<input type="checkbox" name="webcal_tec_organizer" value="1" <?php checked( $organizer_default ); ?>>
					<?php esc_html_e( 'Also copy organizer details into each event description', 'agenticdaisy-calendar' ); ?>
				</label>
				<br>
				<span class="description">
					<?php esc_html_e( 'Organizer name, phone, email and website are imported and shown on the event page whether or not this is ticked. Copying them into the description as well duplicates them, and the copy does not update if the organizer changes later.', 'agenticdaisy-calendar' ); ?>
				</span>
			</p>
			<?php $shared = $this->shared_calendars(); ?>
			<?php if ( array() !== $shared ) : ?>
				<fieldset style="margin:8px 0;">
					<legend><strong><?php esc_html_e( 'Assign imported events to', 'agenticdaisy-calendar' ); ?></strong></legend>
					<p>
						<label>
							<input type="radio" name="webcal_tec_target" value="author" checked>
							<?php esc_html_e( "Each event's original author", 'agenticdaisy-calendar' ); ?>
						</label>
					</p>
					<p>
						<label>
							<input type="radio" name="webcal_tec_target" value="shared">
							<?php esc_html_e( 'A shared calendar:', 'agenticdaisy-calendar' ); ?>
						</label>
						<select name="webcal_tec_shared_login">
							<?php foreach ( $shared as $login => $label ) : ?>
								<option value="<?php echo esc_attr( $login ); ?>"><?php echo esc_html( $label ); ?></option>
							<?php endforeach; ?>
						</select>
					</p>
					<p class="description">
						<?php esc_html_e( 'Re-running the import skips events that were already imported regardless of this choice — to change the assignment of a completed import, undo it first.', 'agenticdaisy-calendar' ); ?>
					</p>
				</fieldset>
			<?php endif; ?>
			<?php
			submit_button(
				sprintf(
					/* translators: %d: number of events. */
					__( 'Import %d events', 'agenticdaisy-calendar' ),
					$publish
				),
				'primary',
				'submit',
				true,
				array( 'data-webcal-loading' => __( 'Importing…', 'agenticdaisy-calendar' ) )
			);
			?>
		</form>
		<?php
		$this->render_sync_settings();
		$this->render_previous_runs();
	}

	/**
	 * The side-by-side sync box: keep the mirror fresh on a schedule so
	 * WebCalendar can run next to TEC for comparison — Epic 8 (STATUS.md).
	 */
	private function render_sync_settings(): void {
		$settings = $this->scheduler()->settings();
		?>
		<h3><?php esc_html_e( 'Keep in sync with The Events Calendar', 'agenticdaisy-calendar' ); ?></h3>
		<p><?php esc_html_e( 'Comparing side by side? Turn this on and WebCalendar mirrors The Events Calendar on a schedule: edits are copied over, new events appear, deleted events disappear. One-way only — The Events Calendar\'s data is never changed. Edits made to mirrored events in WebCalendar are overwritten on the next sync.', 'agenticdaisy-calendar' ); ?></p>
		<?php if ( is_array( $settings['last_result'] ) ) : ?>
			<p class="description">
				<?php if ( isset( $settings['last_result']['error'] ) ) : ?>
					<?php
					echo esc_html(
						sprintf(
							/* translators: 1: UTC timestamp, 2: error detail. */
							__( 'Last sync attempt (%1$s UTC) failed: %2$s', 'agenticdaisy-calendar' ),
							(string) ( $settings['last_result']['time'] ?? '' ),
							(string) $settings['last_result']['error']
						)
					);
					?>
				<?php else : ?>
					<?php
					echo esc_html(
						sprintf(
							/* translators: 1: UTC timestamp, 2: added, 3: updated, 4: removed, 5: unchanged. */
							__( 'Last sync %1$s UTC: %2$d added, %3$d updated, %4$d removed, %5$d unchanged.', 'agenticdaisy-calendar' ),
							(string) ( $settings['last_result']['time'] ?? '' ),
							(int) ( $settings['last_result']['added'] ?? 0 ),
							(int) ( $settings['last_result']['updated'] ?? 0 ),
							(int) ( $settings['last_result']['removed'] ?? 0 ),
							(int) ( $settings['last_result']['unchanged'] ?? 0 )
						)
					);
					?>
				<?php endif; ?>
			</p>
		<?php endif; ?>
		<form method="post" style="margin-top:8px;">
			<?php wp_nonce_field( self::NONCE ); ?>
			<input type="hidden" name="webcal_tec_step" value="sync-settings">
			<p>
				<label>
					<input type="checkbox" name="webcal_tec_sync_enabled" value="1" <?php checked( $settings['enabled'] ); ?>>
					<?php esc_html_e( 'Sync automatically', 'agenticdaisy-calendar' ); ?>
				</label>
				<select name="webcal_tec_sync_interval">
					<option value="hourly" <?php selected( $settings['interval'], 'hourly' ); ?>><?php esc_html_e( 'Hourly', 'agenticdaisy-calendar' ); ?></option>
					<option value="twicedaily" <?php selected( $settings['interval'], 'twicedaily' ); ?>><?php esc_html_e( 'Twice daily', 'agenticdaisy-calendar' ); ?></option>
					<option value="daily" <?php selected( $settings['interval'], 'daily' ); ?>><?php esc_html_e( 'Daily', 'agenticdaisy-calendar' ); ?></option>
				</select>
			</p>
			<p>
				<label>
					<input type="checkbox" name="webcal_tec_sync_organizer" value="1" <?php checked( $settings['append_organizer'] ); ?>>
					<?php esc_html_e( 'Also copy organizer details into each event description', 'agenticdaisy-calendar' ); ?>
				</label>
				<br>
				<span class="description">
					<?php esc_html_e( 'Not needed for the details to appear — they are shown on the event page either way. A copy in the description is written once per sync and will not match if the organizer changes upstream.', 'agenticdaisy-calendar' ); ?>
				</span>
			</p>
			<?php $shared = $this->shared_calendars(); ?>
			<?php if ( array() !== $shared ) : ?>
				<p>
					<label>
						<?php esc_html_e( 'Assign synced events to:', 'agenticdaisy-calendar' ); ?>
						<select name="webcal_tec_sync_target">
							<option value=""><?php esc_html_e( "Each event's original author", 'agenticdaisy-calendar' ); ?></option>
							<?php foreach ( $shared as $login => $label ) : ?>
								<option value="<?php echo esc_attr( $login ); ?>" <?php selected( $settings['target_login'], $login ); ?>><?php echo esc_html( $label ); ?></option>
							<?php endforeach; ?>
						</select>
					</label>
				</p>
			<?php endif; ?>
			<?php submit_button( __( 'Save sync settings', 'agenticdaisy-calendar' ), 'secondary', 'webcal_tec_sync_save', true ); ?>
		</form>
		<form method="post">
			<?php wp_nonce_field( self::NONCE ); ?>
			<input type="hidden" name="webcal_tec_step" value="sync-now">
			<?php
			submit_button(
				__( 'Sync now', 'agenticdaisy-calendar' ),
				'secondary',
				'webcal_tec_sync_now',
				false,
				array( 'data-webcal-loading' => __( 'Syncing…', 'agenticdaisy-calendar' ) )
			);
			?>
		</form>
		<?php
	}

	private function handle_sync_now(): void {
		check_admin_referer( self::NONCE );
		if ( ! current_user_can( 'webcal_can_import' ) ) {
			wp_die( esc_html__( 'You do not have permission to import.', 'agenticdaisy-calendar' ) );
		}

		try {
			$report = $this->scheduler()->run_now();
		} catch ( \Throwable $e ) {
			$this->render_analysis(
				sprintf(
					/* translators: %s: error detail. */
					__( 'Sync failed; nothing was written: %s', 'agenticdaisy-calendar' ),
					$e->getMessage()
				)
			);
			return;
		}

		echo '<div class="notice notice-success"><p>' . esc_html(
			sprintf(
				/* translators: 1: added, 2: updated, 3: removed, 4: unchanged. */
				__( 'Sync complete: %1$d added, %2$d updated, %3$d removed, %4$d unchanged.', 'agenticdaisy-calendar' ),
				$report['added'],
				$report['updated'],
				$report['removed'],
				$report['unchanged']
			)
		) . '</p></div>';
		$this->render_analysis();
	}

	private function handle_sync_settings(): void {
		check_admin_referer( self::NONCE );
		if ( ! current_user_can( 'webcal_can_import' ) ) {
			wp_die( esc_html__( 'You do not have permission to import.', 'agenticdaisy-calendar' ) );
		}

		// phpcs:ignore WordPress.Security.NonceVerification.Missing -- verified above.
		$enabled = isset( $_POST['webcal_tec_sync_enabled'] );
		// phpcs:ignore WordPress.Security.NonceVerification.Missing -- verified above.
		$interval = isset( $_POST['webcal_tec_sync_interval'] ) && is_string( $_POST['webcal_tec_sync_interval'] ) ? sanitize_text_field( wp_unslash( $_POST['webcal_tec_sync_interval'] ) ) : 'hourly';
		// phpcs:ignore WordPress.Security.NonceVerification.Missing -- verified above.
		$organizer = isset( $_POST['webcal_tec_sync_organizer'] );
		// phpcs:ignore WordPress.Security.NonceVerification.Missing -- verified above.
		$target = isset( $_POST['webcal_tec_sync_target'] ) && is_string( $_POST['webcal_tec_sync_target'] ) ? sanitize_text_field( wp_unslash( $_POST['webcal_tec_sync_target'] ) ) : '';
		// The POST value is forgeable; only accept a real shared calendar.
		$target_login = '' !== $target && isset( $this->shared_calendars()[ $target ] ) ? $target : null;

		try {
			$this->scheduler()->configure( $enabled, $interval, $organizer, $target_login );
		} catch ( \InvalidArgumentException $e ) {
			$this->render_analysis( $e->getMessage() );
			return;
		}

		echo '<div class="notice notice-success"><p>' . esc_html(
			$enabled
				? __( 'Sync is on. WebCalendar will keep mirroring The Events Calendar — keep both plugins active while you compare.', 'agenticdaisy-calendar' )
				: __( 'Sync is off. Mirrored events stay as they are.', 'agenticdaisy-calendar' )
		) . '</p></div>';
		$this->render_analysis();
	}

	private function handle_remove_all(): void {
		check_admin_referer( self::NONCE );
		if ( ! current_user_can( 'webcal_can_import' ) ) {
			wp_die( esc_html__( 'You do not have permission to import.', 'agenticdaisy-calendar' ) );
		}

		// Leaving sync on would re-mirror everything on the next cycle,
		// silently undoing the removal — turn it off first.
		$settings = $this->scheduler()->settings();
		if ( $settings['enabled'] ) {
			$this->scheduler()->configure( false, $settings['interval'], $settings['append_organizer'], $settings['target_login'] );
			echo '<div class="notice notice-info"><p>' . esc_html__( 'Sync was turned off so the removed events do not come back on the next cycle.', 'agenticdaisy-calendar' ) . '</p></div>';
		}

		// The mirror is going away, so the incremental window must go with
		// it: a surviving last_sync would make a later re-enable mirror
		// only what changed in the meantime and miss everything else.
		$this->scheduler()->forget_window();

		$removed = $this->importer->remove_all();
		echo '<div class="notice notice-success"><p>' . esc_html(
			sprintf(
				/* translators: %d: number of removed events. */
				__( 'Removed all %d events imported or synced from The Events Calendar. Categories that were created are kept.', 'agenticdaisy-calendar' ),
				$removed
			)
		) . '</p></div>';
		$this->render_analysis();
	}

	private function handle_run(): void {
		check_admin_referer( self::NONCE );
		if ( ! current_user_can( 'webcal_can_import' ) ) {
			wp_die( esc_html__( 'You do not have permission to import.', 'agenticdaisy-calendar' ) );
		}

		// phpcs:ignore WordPress.Security.NonceVerification.Missing -- verified above.
		$append_organizer = isset( $_POST['webcal_tec_organizer'] );
		// phpcs:ignore WordPress.Security.NonceVerification.Missing -- verified above.
		$target_choice = isset( $_POST['webcal_tec_target'] ) && is_string( $_POST['webcal_tec_target'] ) ? sanitize_text_field( wp_unslash( $_POST['webcal_tec_target'] ) ) : 'author';
		$target_login  = null;
		if ( 'shared' === $target_choice ) {
			// phpcs:ignore WordPress.Security.NonceVerification.Missing -- verified above.
			$target_login = isset( $_POST['webcal_tec_shared_login'] ) && is_string( $_POST['webcal_tec_shared_login'] ) ? sanitize_text_field( wp_unslash( $_POST['webcal_tec_shared_login'] ) ) : '';
			// run_import() validates the login against the shared-calendar
			// list before writing anything (the POST value is forgeable).
		}

		try {
			$report = $this->run_import( $append_organizer, $target_login );
		} catch ( \Throwable $e ) {
			$this->render_analysis(
				sprintf(
					/* translators: %s: error detail. */
					__( 'The import could not be completed and no events were imported: %s', 'agenticdaisy-calendar' ),
					$e->getMessage()
				)
			);
			return;
		}

		?>
		<h2><?php esc_html_e( 'Import Complete', 'agenticdaisy-calendar' ); ?></h2>
		<p>
		<?php
		echo esc_html(
			sprintf(
				/* translators: 1: imported count, 2: duplicate count, 3: created category count, 4: created tag count. */
				__( 'Imported %1$d events (%2$d duplicates skipped), %3$d categories and %4$d tags created.', 'agenticdaisy-calendar' ),
				$report['imported'],
				$report['duplicates'],
				$report['categories'],
				$report['tags']
			)
		);
		?>
		</p>
		<?php if ( $report['instances'] > 0 ) : ?>
			<p>
			<?php
			echo esc_html(
				sprintf(
					/* translators: %d: number of expanded occurrences. */
					__( '%d occurrences of recurring events whose repeat pattern could not be converted were imported as individual events.', 'agenticdaisy-calendar' ),
					$report['instances']
				)
			);
			?>
			</p>
		<?php endif; ?>
		<?php foreach ( $report['warnings'] as $warning ) : ?>
			<div class="notice notice-warning"><p><?php echo esc_html( $warning ); ?></p></div>
		<?php endforeach; ?>
		<?php if ( $this->scheduler()->settings()['enabled'] ) : ?>
			<p>
				<?php esc_html_e( 'The Events Calendar\'s own events were not changed. Sync is on: keep The Events Calendar active while you compare — WebCalendar will mirror its changes. Ready to switch? Turn off sync below, then deactivate The Events Calendar.', 'agenticdaisy-calendar' ); ?>
			</p>
		<?php else : ?>
			<p>
				<?php esc_html_e( 'The Events Calendar\'s own events were not changed. To avoid showing every event twice, deactivate The Events Calendar once you have checked the result — or turn on sync below to run both side by side and compare.', 'agenticdaisy-calendar' ); ?>
				<a href="<?php echo esc_url( admin_url( 'plugins.php' ) ); ?>"><?php esc_html_e( 'Open the Plugins screen', 'agenticdaisy-calendar' ); ?></a>
			</p>
		<?php endif; ?>
		<?php
		$this->render_sync_settings();
		$this->render_previous_runs();
	}

	private function handle_rollback(): void {
		check_admin_referer( self::NONCE );
		if ( ! current_user_can( 'webcal_can_import' ) ) {
			wp_die( esc_html__( 'You do not have permission to import.', 'agenticdaisy-calendar' ) );
		}
		// phpcs:ignore WordPress.Security.NonceVerification.Missing -- verified above.
		$import_id = isset( $_POST['webcal_import_id'] ) && is_scalar( $_POST['webcal_import_id'] ) ? absint( $_POST['webcal_import_id'] ) : 0;
		$removed   = $this->importer->rollback( $import_id );
		echo '<div class="notice notice-success"><p>' . esc_html(
			sprintf(
				/* translators: %d: number of removed events. */
				__( 'Removed %d imported events.', 'agenticdaisy-calendar' ),
				$removed
			)
		) . '</p></div>';
		$this->render_analysis();
	}

	private function render_previous_runs(): void {
		$runs = $this->importer->list_runs();
		if ( array() === $runs ) {
			return;
		}
		?>
		<h3><?php esc_html_e( 'Previous Imports', 'agenticdaisy-calendar' ); ?></h3>
		<p><?php esc_html_e( 'Undo removes every event an import run created, including repeats and category assignments. Categories it created are kept.', 'agenticdaisy-calendar' ); ?></p>
		<table class="widefat striped" style="max-width:500px;">
			<thead>
				<tr>
					<th><?php esc_html_e( 'Date', 'agenticdaisy-calendar' ); ?></th>
					<th><?php esc_html_e( 'Events', 'agenticdaisy-calendar' ); ?></th>
					<th></th>
				</tr>
			</thead>
			<tbody>
				<?php foreach ( $runs as $run ) : ?>
					<tr>
						<td><?php echo esc_html( (string) $run['date'] ); ?></td>
						<td><?php echo esc_html( (string) $run['entries'] ); ?></td>
						<td>
							<form method="post">
								<?php wp_nonce_field( self::NONCE ); ?>
								<input type="hidden" name="webcal_tec_step" value="rollback">
								<input type="hidden" name="webcal_import_id" value="<?php echo esc_attr( (string) $run['import_id'] ); ?>">
								<?php
								submit_button(
									__( 'Undo', 'agenticdaisy-calendar' ),
									'delete small',
									'submit',
									false,
									array( 'onclick' => "return confirm('" . esc_js( __( 'This permanently removes every event this import created. Continue?', 'agenticdaisy-calendar' ) ) . "');" )
								);
								?>
							</form>
						</td>
					</tr>
				<?php endforeach; ?>
			</tbody>
		</table>
		<form method="post" style="margin-top:12px;">
			<?php wp_nonce_field( self::NONCE ); ?>
			<input type="hidden" name="webcal_tec_step" value="remove-all">
			<?php
			submit_button(
				__( 'Remove all TEC events', 'agenticdaisy-calendar' ),
				'delete',
				'webcal_tec_remove_all',
				false,
				array( 'onclick' => "return confirm('" . esc_js( __( 'This permanently removes every event imported or synced from The Events Calendar, across all runs, and turns off sync. The Events Calendar\'s own data is not touched. Continue?', 'agenticdaisy-calendar' ) ) . "');" )
			);
			?>
			<p class="description"><?php esc_html_e( 'Done with the trial? This removes everything imported or synced from The Events Calendar in one step and turns off sync.', 'agenticdaisy-calendar' ); ?></p>
		</form>
		<?php
	}
}