<?php
/**
 * URL Tracker Controller - Captures and logs front-end page URLs.
 *
 * @package advanced-analytics
 * @subpackage controllers
 * @since 4.9.0
 */

declare(strict_types=1);

namespace ADVAN\Controllers;

use ADVAN\Helpers\Settings;
use ADVAN\Entities\Urls_Log_Entity;
use ADVAN\Controllers\Controller_Init_Trait;

// Exit if accessed directly.
if ( ! defined( 'ABSPATH' ) ) {
	exit;
}

if ( ! class_exists( '\ADVAN\Controllers\URL_Tracker' ) ) {
	/**
	 * Responsible for tracking front-end URLs and storing them for analytics.
	 *
	 * This controller focuses on:
	 * - Detecting only front-end page URLs (not resources)
	 * - Parsing URLs properly (scheme, host, path, query)
	 * - Using SQL increments for performance
	 * - Following WordPress best practices
	 *
	 * @since 4.9.0
	 */
	class URL_Tracker {

		use Controller_Init_Trait;

		/**
		 * File extensions to exclude (resources).
		 *
		 * @var array
		 *
		 * @since 4.9.0
		 */
		private static $excluded_extensions = array(
			// Images.
			'jpg',
			'jpeg',
			'png',
			'gif',
			'webp',
			'svg',
			'ico',
			'bmp',
			'tiff',
			// Stylesheets.
			'css',
			// Scripts.
			'js',
			// Fonts.
			'woff',
			'woff2',
			'ttf',
			'eot',
			'otf',
			// Media.
			'mp4',
			'mp3',
			'avi',
			'mov',
			'wmv',
			'flv',
			'wav',
			'ogg',
			// Documents (usually downloads, not pages).
			'pdf',
			'doc',
			'docx',
			'xls',
			'xlsx',
			'ppt',
			'pptx',
			'zip',
			'rar',
			'tar',
			'gz',
			// Other.
			'xml',
			'json',
			'txt',
		);

		/**
		 * Inits the class and hooks.
		 *
		 * @return void
		 *
		 * @since 4.9.0
		 */
		public static function init() {
			if ( Settings::get_option( 'urls_module_enabled' ) ) {
				static::conditional_init(
					'advana_urls_enable',
					function() {
						// Track on the 'wp' hook to ensure WordPress is fully loaded.
						\add_action( 'wp', array( __CLASS__, 'track_current_url' ), 10 );
					}
				);
			}
		}

		/**
		 * Tracks the current URL if it's a valid front-end page.
		 *
		 * @return void
		 *
		 * @since 4.9.0
		 */
		public static function track_current_url() {
			// Only track front-end pages.
			if ( \is_admin() || \wp_doing_ajax() || \wp_doing_cron() ) {
				return;
			}

			// Get the current URL.
			$url = self::get_current_url();

			// Validate and filter the URL.
			if ( ! self::should_track_url( $url ) ) {
				return;
			}

			// Parse the URL into components.
			$url_data = self::parse_url_data( $url );

			if ( ! $url_data ) {
				return;
			}

			// Log the URL to the database.
			Urls_Log_Entity::log_url( $url_data );
		}

		/**
		 * Gets the current full URL from the server variables.
		 *
		 * @return string The current URL.
		 *
		 * @since 4.9.0
		 */
		private static function get_current_url(): string {
			// Validate and sanitize server variables.
			$https = isset( $_SERVER['HTTPS'] ) ? \sanitize_text_field( \wp_unslash( $_SERVER['HTTPS'] ) ) : '';
			$host  = isset( $_SERVER['HTTP_HOST'] ) ? \sanitize_text_field( \wp_unslash( $_SERVER['HTTP_HOST'] ) ) : '';
			$uri   = isset( $_SERVER['REQUEST_URI'] ) ? \esc_url_raw( \wp_unslash( $_SERVER['REQUEST_URI'] ) ) : '';

			// Determine scheme.
			$scheme = ( ! empty( $https ) && 'off' !== strtolower( $https ) ) ? 'https' : 'http';

			// Build the full URL.
			$url = sprintf( '%s://%s%s', $scheme, $host, $uri );

			return \esc_url_raw( $url );
		}

		/**
		 * Determines if a URL should be tracked.
		 *
		 * @param string $url The URL to check.
		 *
		 * @return bool True if should track, false otherwise.
		 *
		 * @since 4.9.0
		 */
		private static function should_track_url( string $url ): bool {
			if ( empty( $url ) ) {
				return false;
			}

			// Parse the URL.
			$parsed = \wp_parse_url( $url );
			if ( ! $parsed || ! isset( $parsed['path'] ) ) {
				return true; // Homepage without path is valid.
			}

			$path = $parsed['path'];

			// Check if the path ends with a resource extension.
			$extension = pathinfo( $path, PATHINFO_EXTENSION );
			if ( ! empty( $extension ) && in_array( strtolower( $extension ), self::$excluded_extensions, true ) ) {
				return false;
			}

			// Exclude common WordPress admin/system paths on front-end.
			$excluded_paths = array(
				// '/wp-admin/',
				'/wp-login.php',
				'/wp-cron.php',
				'/xmlrpc.php',
				'/wp-json/',
			);

			foreach ( $excluded_paths as $excluded ) {
				if ( strpos( $path, $excluded ) === 0 ) {
					return false;
				}
			}

			/**
			 * Filters whether a URL should be tracked.
			 *
			 * @param bool   $should_track Whether to track the URL.
			 * @param string $url          The URL being checked.
			 *
			 * @since 4.9.0
			 */
			return apply_filters( 'advan_url_tracker_should_track', true, $url );
		}

		/**
		 * Parses URL data into structured components.
		 *
		 * @param string $url The URL to parse.
		 *
		 * @return array|null Parsed URL data or null on failure.
		 *
		 * @since 4.9.0
		 */
		private static function parse_url_data( string $url ): ?array {
			$parsed = \wp_parse_url( $url );

			if ( ! $parsed ) {
				return null;
			}

			// Extract components.
			$scheme   = $parsed['scheme'] ?? 'http';
			$host     = $parsed['host'] ?? '';
			$port     = $parsed['port'] ?? null;
			$path     = $parsed['path'] ?? '/';
			$query    = $parsed['query'] ?? '';
			$fragment = $parsed['fragment'] ?? '';

			// Reconstruct clean full URL (without fragment as it's client-side).
			$clean_url = $scheme . '://' . $host;
			if ( $port && ( ( 'http' === $scheme && 80 !== $port ) || ( 'https' === $scheme && 443 !== $port ) ) ) {
				$clean_url .= ':' . $port;
			}
			$clean_url .= $path;
			if ( ! empty( $query ) ) {
				$clean_url .= '?' . $query;
			}

			// Parse query string into array.
			$query_params = array();
			if ( ! empty( $query ) ) {
				parse_str( $query, $query_params );
			}

			// Get page type (post, page, archive, etc.).
			$page_type = self::get_page_type();

			// Get page ID if applicable.
			$page_id = self::get_page_id();

			return array(
				'url'          => $clean_url,
				'scheme'       => $scheme,
				'host'         => $host,
				'path'         => $path,
				'query_string' => $query,
				'query_params' => \wp_json_encode( $query_params ),
				'page_type'    => $page_type,
				'page_id'      => $page_id,
			);
		}

		/**
		 * Determines the current page type.
		 *
		 * @return string The page type.
		 *
		 * @since 4.9.0
		 */
		private static function get_page_type(): string {
			if ( \is_front_page() ) {
				return 'front_page';
			}

			if ( \is_home() ) {
				return 'blog_home';
			}

			if ( \is_single() ) {
				return 'single_post';
			}

			if ( \is_page() ) {
				return 'page';
			}

			if ( \is_category() ) {
				return 'category';
			}

			if ( \is_tag() ) {
				return 'tag';
			}

			if ( \is_tax() ) {
				return 'taxonomy';
			}

			if ( \is_author() ) {
				return 'author';
			}

			if ( \is_date() ) {
				return 'date_archive';
			}

			if ( \is_archive() ) {
				return 'archive';
			}

			if ( \is_search() ) {
				return 'search';
			}

			if ( \is_404() ) {
				return '404';
			}

			if ( \is_attachment() ) {
				return 'attachment';
			}

			return 'other';
		}

		/**
		 * Gets the current page/post ID if applicable.
		 *
		 * @return int The page ID or 0.
		 *
		 * @since 4.9.0
		 */
		private static function get_page_id(): int {
			$queried_object = \get_queried_object();

			if ( $queried_object && isset( $queried_object->ID ) ) {
				return (int) $queried_object->ID;
			}

			if ( \in_array( self::get_page_type(), array( 'category', 'tag', 'taxonomy', 'attachment' ) ) && isset( $queried_object->cat_ID ) ) {
				return (int) $queried_object->cat_ID;
			}

			return 0;
		}

		/**
		 * Gets trackable URL statistics.
		 *
		 * @return array Statistics about tracked URLs.
		 * @since 4.9.0
		 */
		public static function get_statistics(): array {
			$stats = Urls_Log_Entity::get_row(
				'SELECT 
					COUNT(*) as total_urls,
					SUM(visit_count) as total_visits,
					MAX(visit_count) as max_visits,
					AVG(visit_count) as avg_visits'
			);

			return array(
				'total_urls'   => (int) ( $stats['total_urls'] ?? 0 ),
				'total_visits' => (int) ( $stats['total_visits'] ?? 0 ),
				'max_visits'   => (int) ( $stats['max_visits'] ?? 0 ),
				'avg_visits'   => (float) ( $stats['avg_visits'] ?? 0 ),
			);
		}
	}
}