<?php
/**
 * PHP error log integration.
 *
 * Captures PHP runtime errors and fatal shutdowns and ingests them as
 * activity events. Optionally tails the WP debug.log file via cron so
 * errors triggered by other code paths are also visible in the timeline.
 *
 * @package ActivityPilot
 */

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

final class APWPM_Error_Integration {

	/**
	 * Maximum length to keep for error messages.
	 */
	const MAX_MESSAGE = 500;

	/**
	 * Throttle window per (file:line) — avoid flooding when the same
	 * notice fires hundreds of times on a single request.
	 */
	const THROTTLE_KEY = 'apwpm_err_seen';

	private static $seen_this_request = array();

	public static function init() {
		$settings = (array) get_option( 'apwpm_settings', array() );
		if ( empty( $settings['enable_error_log'] ) ) {
			return;
		}

		register_shutdown_function( array( __CLASS__, 'handle_shutdown' ) );

		add_action( 'apwpm_tail_debug_log', array( __CLASS__, 'tail_debug_log' ) );
		if ( ! wp_next_scheduled( 'apwpm_tail_debug_log' ) ) {
			wp_schedule_event( time() + 5 * MINUTE_IN_SECONDS, 'hourly', 'apwpm_tail_debug_log' );
		}
	}

	/**
	 * Custom error handler. Returns false so WordPress's own handler
	 * also runs (keeps debug.log behavior intact).
	 */
	public static function handle_error( $errno, $errstr, $errfile = '', $errline = 0 ) {
		// Respect the current configured error_reporting level.
		$reporting_level = (int) ini_get( 'error_reporting' );
		if ( 0 === ( $reporting_level & $errno ) ) {
			return false;
		}

		$severity = self::mapwpm_severity( $errno );
		if ( null === $severity ) {
			return false;
		}

		$key = $errfile . ':' . $errline . ':' . $errno;
		if ( isset( self::$seen_this_request[ $key ] ) ) {
			return false;
		}
		self::$seen_this_request[ $key ] = true;

		self::record(
			$severity,
			$errstr,
			$errfile,
			(int) $errline,
			$errno
		);

		return false;
	}

	/**
	 * Shutdown handler — captures uncaught fatals.
	 */
	public static function handle_shutdown() {
		$err = error_get_last();
		if ( ! $err ) {
			return;
		}
		$fatals = array( E_ERROR, E_PARSE, E_CORE_ERROR, E_COMPILE_ERROR, E_USER_ERROR );
		if ( ! in_array( $err['type'], $fatals, true ) ) {
			return;
		}
		self::record(
			'critical',
			$err['message'],
			$err['file'],
			(int) $err['line'],
			$err['type']
		);
	}

	/**
	 * Tail debug.log to import error lines emitted outside the request
	 * cycle. Stores the byte offset so we never re-import the same lines.
	 */
	public static function tail_debug_log() {
		$path = defined( 'WP_DEBUG_LOG' ) && is_string( WP_DEBUG_LOG )
			? WP_DEBUG_LOG
			: WP_CONTENT_DIR . '/debug.log';

		if ( ! is_string( $path ) || ! file_exists( $path ) || ! is_readable( $path ) ) {
			return;
		}

		$size   = (int) filesize( $path );
		$offset = (int) get_option( 'apwpm_debug_log_offset', 0 );

		// Log rotated → restart from beginning.
		if ( $offset > $size ) {
			$offset = 0;
		}
		if ( $offset === $size ) {
			return;
		}

		$max_read = 256 * 1024; // cap each pass at 256 KB
		$contents = (string) file_get_contents( $path, false, null, $offset, $max_read );
		$new_pos  = min( $size, $offset + strlen( $contents ) );

		if ( '' === $contents ) {
			update_option( 'apwpm_debug_log_offset', $size, false );
			return;
		}

		$lines = preg_split( '/\r?\n/', $contents );
		$count = 0;
		foreach ( (array) $lines as $line ) {
			$line = trim( (string) $line );
			if ( '' === $line || $count >= 200 ) {
				continue;
			}
			if ( ! preg_match( '/PHP\s+(Fatal|Parse|Warning|Notice|Deprecated|Strict)/i', $line, $m ) ) {
				continue;
			}
			$kind     = strtolower( $m[1] );
			$severity = in_array( $kind, array( 'fatal', 'parse' ), true ) ? 'critical' : ( 'warning' === $kind ? 'warning' : 'error' );

			APWPM_Logger::log(
				array(
					'action_type'  => 'php_log_entry',
					'object_type'  => 'error',
					'object_title' => 'debug.log',
					'description'  => substr( $line, 0, self::MAX_MESSAGE ),
					'severity'     => $severity,
					'context'      => array( 'source' => 'debug.log' ),
				)
			);
			$count++;
		}

		update_option( 'apwpm_debug_log_offset', (int) $new_pos, false );
	}

	/* ---------------------------------------------------------------- */

	protected static function mapwpm_severity( $errno ) {
		switch ( $errno ) {
			case E_ERROR:
			case E_CORE_ERROR:
			case E_COMPILE_ERROR:
			case E_USER_ERROR:
			case E_PARSE:
				return 'critical';
			case E_WARNING:
			case E_CORE_WARNING:
			case E_COMPILE_WARNING:
			case E_USER_WARNING:
			case E_RECOVERABLE_ERROR:
				return 'error';
			case E_NOTICE:
			case E_USER_NOTICE:
			case E_DEPRECATED:
			case E_USER_DEPRECATED:
				// Only record notices when WP_DEBUG is on — too noisy otherwise.
				return ( defined( 'WP_DEBUG' ) && WP_DEBUG ) ? 'warning' : null;
			default:
				return null;
		}
	}

	protected static function record( $severity, $message, $file, $line, $errno ) {
		APWPM_Logger::log(
			array(
				'action_type'  => 'php_' . $severity,
				'object_type'  => 'error',
				'object_title' => basename( (string) $file ) . ( $line ? ':' . $line : '' ),
				'description'  => substr( (string) $message, 0, self::MAX_MESSAGE ),
				'severity'     => $severity,
				'context'      => array(
					'file'  => (string) $file,
					'line'  => (int) $line,
					'errno' => (int) $errno,
				),
			)
		);
	}
}