<?php
/**
 * Hooks into WordPress events and fills the care log.
 *
 * @package QuietAdmin
 */

namespace QuietAdmin;

defined( 'ABSPATH' ) || exit;

/**
 * Class Tracker.
 *
 * Passively collects data that later substantiates the care report and the "green light":
 * core/plugin/theme updates, spam comments, failed
 * logins, backups (if a backup plugin is detectable).
 *
 * @since 0.1.0
 */
class Tracker {

	/**
	 * Register hooks.
	 *
	 * @since 0.1.0
	 *
	 * @return void
	 */
	public function register() {
		// Updates.
		add_action( 'upgrader_process_complete', array( $this, 'track_upgrader' ), 10, 2 );
		add_action( '_core_updated_successfully', array( $this, 'track_core_update' ) );
		add_action( 'automatic_updates_complete', array( $this, 'track_auto_updates' ) );

		// Spam and comments.
		add_action( 'transition_comment_status', array( $this, 'track_comment_status' ), 10, 3 );
		add_action( 'akismet_spam_caught', array( $this, 'track_akismet_spam' ) );
		add_action( 'comment_post', array( $this, 'track_comment_post' ), 10, 2 );

		// Failed logins (security indicator).
		add_action( 'wp_login_failed', array( $this, 'track_failed_login' ) );
		add_action( 'wp_login', array( $this, 'track_login' ), 10, 2 );

		// Detect backups of known plugins.
		// Public interface for arbitrary backup tools.
		add_action( 'quietadmin_backup_completed', array( $this, 'track_backup' ) );
		add_action( 'updraftplus_post_backup', array( $this, 'track_backup' ) );
		add_action( 'backwpup_job_done', array( $this, 'track_backup' ) );
		add_action( 'wpvivid_backup_completed', array( $this, 'track_backup' ) );
		add_action( 'duplicator_post_package_build', array( $this, 'track_backup' ) );

		// Content activity (for the report, not visible to the client in detail).
		// transition_post_status instead of publish_post: the latter fires on every
		// update of an already published post, not only on publishing.
		add_action( 'transition_post_status', array( $this, 'track_publish' ), 10, 3 );

		// Public interface for error reports from backup/monitoring code.
		add_action( 'quietadmin_failure', array( __CLASS__, 'log_failure' ), 10, 2 );

		/**
		 * Attach custom tracking hooks.
		 *
		 * Example:
		 * `add_action( 'quietadmin_track', function( $type, $event, $title, $meta ) { ... } );`
		 *
		 * @since 0.1.0
		 */
		do_action( 'quietadmin_tracker_registered', $this );
	}

	/**
	 * Logs an event (public API for third-party code).
	 *
	 * @since 0.1.0
	 *
	 * @param string $type  Event_Log type.
	 * @param string $event Machine-readable key.
	 * @param string $title Description.
	 * @param array  $meta  Additional data.
	 * @return int|false
	 */
	public static function log( $type, $event, $title = '', $meta = array() ) {
		/**
		 * Disable tracking entirely.
		 *
		 * @since 0.1.0
		 *
		 * @param bool $track True to track.
		 */
		if ( ! apply_filters( 'quietadmin_enable_tracking', true ) ) {
			return false;
		}

		return Event_Log::add( $type, $event, $title, $meta );
	}

	/**
	 * Logs a failure (update, backup, external monitoring).
	 *
	 * The status traffic light evaluates these events. Backup or
	 * monitoring code can report them via the action `quietadmin_failure`:
	 *
	 *     do_action( 'quietadmin_failure', 'backup_failed', 'Backup failed' );
	 *
	 * The keys from the filter `quietadmin_failure_events` are allowed;
	 * unknown keys are stored as `external_problem`.
	 * Only one entry is written per key and hour.
	 *
	 * @since 0.1.2
	 *
	 * @param string $event Event key, e.g. 'backup_failed'.
	 * @param string $title Description (shown to the agency team).
	 * @return void
	 */
	public static function log_failure( $event, $title = '' ) {
		$event   = sanitize_key( (string) $event );
		$allowed = (array) apply_filters( 'quietadmin_failure_events', StatusLights::default_failure_events() );

		if ( ! in_array( $event, $allowed, true ) ) {
			$event = 'external_problem';
		}

		$throttle_key = 'quietadmin_fail_' . $event;

		if ( get_transient( $throttle_key ) ) {
			return;
		}

		set_transient( $throttle_key, 1, HOUR_IN_SECONDS );

		self::log(
			Event_Log::TYPE_MAINTENANCE,
			$event,
			'' !== (string) $title ? (string) $title : __( 'A maintenance task failed', 'oms-quietadmin' )
		);
	}

	/**
	 * Plugin/theme updates via the upgrader.
	 *
	 * @since 0.1.0
	 *
	 * @param \WP_Upgrader $upgrader Upgrader instance.
	 * @param array        $hook_extra Action details.
	 * @return void
	 */
	public function track_upgrader( $upgrader, $hook_extra ) {
		unset( $upgrader );

		if ( empty( $hook_extra['type'] ) || 'update' !== ( isset( $hook_extra['action'] ) ? sanitize_key( $hook_extra['action'] ) : '' ) ) {
			return;
		}

		$type  = sanitize_key( $hook_extra['type'] ); // Possible values: plugin, theme, core.

		// Core updates have their own hook with version information. Translation
		// updates are not plugin updates and are therefore deliberately omitted.
		if ( ! in_array( $type, array( 'plugin', 'theme' ), true ) ) {
			return;
		}
		$count = 1;

		if ( ! empty( $hook_extra['plugins'] ) && is_array( $hook_extra['plugins'] ) ) {
			$count = count( $hook_extra['plugins'] );
		} elseif ( ! empty( $hook_extra['themes'] ) && is_array( $hook_extra['themes'] ) ) {
			$count = count( $hook_extra['themes'] );
		}

		$label = 'theme' === $type
			/* translators: %d: number of themes. */
			? sprintf( _n( '%d theme updated', '%d themes updated', $count, 'oms-quietadmin' ), $count )
			/* translators: %d: number of plugins. */
			: sprintf( _n( '%d plugin updated', '%d plugins updated', $count, 'oms-quietadmin' ), $count );

		self::log(
			Event_Log::TYPE_MAINTENANCE,
			$type . '_updated',
			$label,
			array(
				'count'  => $count,
				'items'  => isset( $hook_extra[ $type . 's' ] ) ? array_slice( (array) $hook_extra[ $type . 's' ], 0, 25 ) : array(),
				'action' => isset( $hook_extra['action'] ) ? sanitize_key( $hook_extra['action'] ) : '',
			)
		);
	}

	/**
	 * Core update.
	 *
	 * @since 0.1.0
	 *
	 * @param string $version New WordPress version.
	 * @return void
	 */
	public function track_core_update( $version ) {
		self::log(
			Event_Log::TYPE_MAINTENANCE,
			'core_updated',
			sprintf(
				/* translators: %s: WordPress version. */
				__( 'WordPress updated to %s', 'oms-quietadmin' ),
				sanitize_text_field( (string) $version )
			),
			array( 'version' => (string) $version )
		);
	}

	/**
	 * Automatic updates.
	 *
	 * @since 0.1.0
	 *
	 * @param array $data Result of the automatic updates.
	 * @return void
	 */
	public function track_auto_updates( $data ) {
		$done   = 0;
		$failed = 0;

		foreach ( array( 'core', 'plugin', 'theme', 'translation' ) as $group ) {
			if ( ! empty( $data[ $group ] ) && is_array( $data[ $group ] ) ) {
				foreach ( $data[ $group ] as $item ) {
					if ( ! is_array( $item ) || ! array_key_exists( 'result', $item ) ) {
						continue;
					}

					if ( ! empty( $item['result'] ) && ! is_wp_error( $item['result'] ) ) {
						++$done;
					} else {
						++$failed;
					}
				}
			}
		}

		if ( $failed > 0 ) {
			self::log_failure(
				'auto_update_failed',
				sprintf(
					/* translators: %d: number of failed automatic updates. */
					_n( '%d automatic update failed', '%d automatic updates failed', $failed, 'oms-quietadmin' ),
					$failed
				)
			);
		}

		// Successful plugin, theme and core updates are already recorded by the
		// dedicated upgrader hooks. Logging the aggregate here would count them
		// twice in care reports. This hook is retained for failure detection.
	}

	/**
	 * Count spam comments.
	 *
	 * @since 0.1.0
	 *
	 * @param string      $new_status New status.
	 * @param string      $old_status Old status.
	 * @param \WP_Comment $comment   Comment.
	 * @return void
	 */
	public function track_comment_status( $new_status, $old_status, $comment ) {
		unset( $comment );

		if ( 'spam' !== $new_status || 'spam' === $old_status ) {
			return;
		}

		self::log( Event_Log::TYPE_SECURITY, 'spam_blocked', __( 'Spam comment blocked', 'oms-quietadmin' ) );
	}

	/**
	 * Akismet hits.
	 *
	 * @since 0.1.0
	 *
	 * @return void
	 */
	public function track_akismet_spam() {
		self::log( Event_Log::TYPE_SECURITY, 'spam_blocked', __( 'Spam blocked', 'oms-quietadmin' ) );
	}

	/**
	 * Comments marked as spam directly (comment_post with status 'spam').
	 *
	 * @since 0.1.0
	 *
	 * @param int        $comment_id Comment ID.
	 * @param int|string $status     Approval status (0, 1 or 'spam').
	 * @return void
	 */
	public function track_comment_post( $comment_id, $status ) {
		if ( 'spam' !== $status ) {
			return;
		}

		self::log(
			Event_Log::TYPE_SECURITY,
			'spam_blocked',
			__( 'Suspicious comment blocked', 'oms-quietadmin' ),
			array( 'comment_id' => (int) $comment_id )
		);
	}

	/**
	 * Failed login.
	 *
	 * @since 0.1.0
	 *
	 * @param string $username Attempted username.
	 * @return void
	 */
	public function track_failed_login( $username ) {
		unset( $username );

		/**
		 * Maximum number of logged failed attempts per hour.
		 *
		 * Protects the log table during brute-force waves. A value of 0
		 * disables logging of failed logins.
		 *
		 * @since 0.1.2
		 *
		 * @param int $limit Entries per hour (default 60).
		 */
		$limit = (int) apply_filters( 'quietadmin_failed_login_log_limit', 60 );

		if ( $limit < 1 ) {
			return;
		}

		$bucket = 'quietadmin_fl_' . gmdate( 'YmdH' );
		$count  = (int) get_transient( $bucket );

		if ( $count >= $limit ) {
			return;
		}

		set_transient( $bucket, $count + 1, 2 * HOUR_IN_SECONDS );

		$meta = array();

		/**
		 * Whether to record additional details (truncated IP address).
		 *
		 * By default, no personal data (IP address,
		 * username) is stored. Anyone who needs it must enable this
		 * deliberately and adapt the privacy policy.
		 *
		 * @since 0.1.2
		 *
		 * @param bool $log_details True = store anonymized IP.
		 */
		if ( apply_filters( 'quietadmin_log_login_details', false ) && isset( $_SERVER['REMOTE_ADDR'] ) ) {
			$meta['ip'] = wp_privacy_anonymize_ip( sanitize_text_field( wp_unslash( $_SERVER['REMOTE_ADDR'] ) ) );
		}

		self::log(
			Event_Log::TYPE_SECURITY,
			'login_failed',
			__( 'Failed login attempt recorded', 'oms-quietadmin' ),
			$meta
		);
	}

	/**
	 * Successful login of the client (for the "last activity" info).
	 *
	 * @since 0.1.0
	 *
	 * @param string   $user_login Username.
	 * @param \WP_User $user       User.
	 * @return void
	 */
	public function track_login( $user_login, $user ) {
		unset( $user_login );

		if ( ! $user instanceof \WP_User || ! Roles::is_client( $user ) ) {
			return;
		}

		update_user_meta( $user->ID, 'quietadmin_last_login', time() );

		self::log(
			Event_Log::TYPE_AGENCY,
			'client_login',
			__( 'Client logged in', 'oms-quietadmin' ),
			array( 'client_id' => $user->ID )
		);
	}

	/**
	 * Backup detected.
	 *
	 * @since 0.1.0
	 *
	 * @param mixed $data Plugin-specific data (unused).
	 * @return void
	 */
	public function track_backup( $data = null ) {
		unset( $data );

		// Avoid duplicate entries within 5 minutes.
		if ( get_transient( 'quietadmin_backup_logged' ) ) {
			return;
		}

		set_transient( 'quietadmin_backup_logged', 1, 5 * MINUTE_IN_SECONDS );

		self::log( Event_Log::TYPE_BACKUP, 'backup_created', __( 'Backup created', 'oms-quietadmin' ) );
	}

	/**
	 * Count publications (only on transition to "published").
	 *
	 * @since 0.1.0
	 *
	 * @param string   $new_status Neuer Status.
	 * @param string   $old_status Alter Status.
	 * @param \WP_Post $post       Post object.
	 * @return void
	 */
	public function track_publish( $new_status, $old_status, $post ) {
		if ( 'publish' !== $new_status || 'publish' === $old_status ) {
			return;
		}

		if ( ! $post instanceof \WP_Post || ! is_post_type_viewable( $post->post_type ) ) {
			return;
		}

		self::log(
			Event_Log::TYPE_AGENCY,
			'content_published',
			__( 'New content published', 'oms-quietadmin' ),
			array( 'post_id' => (int) $post->ID )
		);
	}
}