<?php
namespace JVBase\managers;

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

/**
 * Manages HTTP cache timestamps and relationship-based invalidation
 *
 * Data caching: Use wrapper methods or wp_cache_get/set directly
 * HTTP caching: This class manages timestamps for ETag/Last-Modified headers
 */
class CacheManager
{
	private string $prefix = BASE;
	private string $group;
	private int $cache_ttl;
	private static ?bool $use_object_cache = null;
	private static array $instances = []; // Cache instances per type
	private static array $http_timestamps = []; // Request-level memory cache
	private static array $relationships = []; // Type => [related types]
	private static bool $relationships_loaded = false;

	/**
	 * Private constructor - use for() factory method instead
	 */
	private function __construct(string $group, ?int $ttl = null)
	{
		$this->group = jvbNoBase($group);
		$this->cache_ttl = $ttl ?: 3600;

		if (is_null(static::$use_object_cache)) {
			static::$use_object_cache = wp_using_ext_object_cache();
		}
	}

	/**
	 * Get or create a cache manager instance for a content type
	 *
	 * @param string $type Content type (tattoo, style, etc.)
	 * @param int|null $ttl Optional TTL override
	 * @return self Fluent interface
	 */
	public static function for(string $type, ?int $ttl = null): self
	{
		$type = jvbNoBase($type);
		$key = $type . ($ttl ? "_{$ttl}" : '');

		if (!isset(self::$instances[$key])) {
			self::$instances[$key] = new self($type, $ttl);
		}

		return self::$instances[$key];
	}

	/**
	 * Get cache manager for a specific user
	 * Each user gets their own cache group for complete isolation
	 *
	 * @param int $user_id User ID
	 * @param int|null $ttl Optional TTL
	 * @return self
	 */
	public static function forUser(int $user_id, ?int $ttl = null): self
	{
		return self::for("user_{$user_id}", $ttl);
	}

	/**
	 * Get HTTP cache timestamp for content type(s)
	 * Used for ETag and Last-Modified header generation
	 *
	 * @param string|array $types Single type or array of types
	 * @return int Latest timestamp (Unix time)
	 */
	public static function getTimestamp(string|array $types): int
	{
		// Multiple types - return latest
		if (is_array($types)) {
			$latest = 0;
			foreach ($types as $type) {
				$timestamp = self::getTimestamp($type);
				if ($timestamp > $latest) {
					$latest = $timestamp;
				}
			}
			return $latest ?: time();
		}

		$type = jvbNoBase($types);

		// Check request-level cache
		if (isset(self::$http_timestamps[$type])) {
			return self::$http_timestamps[$type];
		}

		// Load from cache (Redis or transient - wp_cache handles it)
		$timestamp = (int)wp_cache_get("http_ts_{$type}", 'jvb_timestamps') ?: time();

		// Cache in memory for this request
		self::$http_timestamps[$type] = $timestamp;

		return $timestamp;
	}

	/**
	 * Update HTTP cache timestamp (marks content as modified)
	 *
	 * @param string $type Content type
	 * @return int The new timestamp
	 */
	public static function updateTimestamp(string $type): int
	{
		$type = jvbNoBase($type);
		$timestamp = time();

		// Store (Redis or transient - wp_cache handles it)
		wp_cache_set("http_ts_{$type}", $timestamp, 'jvb_timestamps', WEEK_IN_SECONDS);

		// Update request cache
		self::$http_timestamps[$type] = $timestamp;

		do_action('jvb_http_timestamp_updated', $type, $timestamp);

		return $timestamp;
	}

	/**
	 * Invalidate cache for a content type with automatic cascade
	 *
	 * @param string $type Content type to invalidate
	 * @param mixed $context Post/Term object or array with relationship data (for cascade)
	 * @param string|array|null $specific_keys Optional specific key(s) to delete without flushing group
	 * @return void
	 */
	public static function invalidateAll(string $type, $context = null, $specific_keys = null): void
	{
		$type = jvbNoBase($type);

		// Update HTTP timestamp
		self::updateTimestamp($type);

		// If specific keys provided, only delete those (don't flush whole group)
		if ($specific_keys !== null) {
			$instance = self::for($type);
			if (is_array($specific_keys)) {
				foreach ($specific_keys as $key) {
					$instance->delete($key);
				}
			} else {
				$instance->delete($specific_keys);
			}
		} else {
			// No specific keys - flush the entire group
			if (function_exists('wp_cache_flush_group')) {
				wp_cache_flush_group($type);
			} else {
				// Fallback for older WP
				wp_cache_flush();
			}
		}

		// Cascade to related types if context provided
		if ($context !== null) {
			self::cascadeInvalidation($type, $context);
		}

		do_action('jvb_cache_invalidated', $type, $context);
	}

	/**
	 * Invalidate only specific keys for a type (doesn't flush group or update timestamp)
	 * Use this when you want surgical cache invalidation
	 *
	 * @param string $type Content type
	 * @param string|array $keys Key(s) to delete
	 * @return void
	 */
	public static function invalidateKeys(string $type, string|array $keys): void
	{
		$instance = self::for($type);

		if (is_array($keys)) {
			foreach ($keys as $key) {
				$instance->delete($key);
			}
		} else {
			$instance->delete($keys);
		}
	}

	/**
	 * Fluent instance method to invalidate this cache type
	 * Allows chaining: CacheManager::for('tattoo')->invalidate()->clear()
	 *
	 * @param mixed $context Optional context for cascade
	 * @param string|array|null $specific_keys Optional specific key(s)
	 * @return self For chaining
	 */
	public function invalidate($context = null, $specific_keys = null): self
	{
		self::invalidateAll($this->group, $context, $specific_keys);
		return $this;
	}

	/**
	 * Get the HTTP timestamp for this instance's type
	 *
	 * @return int
	 */
	public function timestamp(): int
	{
		return self::getTimestamp($this->group);
	}

	/**
	 * Update the HTTP timestamp for this instance's type
	 *
	 * @return self For chaining
	 */
	public function touch(): self
	{
		self::updateTimestamp($this->group);
		return $this;
	}

	/**
	 * Get a value from the cache
	 * @param string|array $key The key to look up (auto-generates key from array of key=>values)
	 * @param string|null $group The group to get from. Defaults to current group
	 * @return mixed
	 */
	public function get(string|array $key, ?string $group = null): mixed
	{
		$group = $group ?: $this->group;
		$key = $this->normalizeKey($key);
		$cache_key = $this->buildKey($key);

		return wp_cache_get($cache_key, $group);
	}

	/**
	 * Store a value in cache
	 * @param string|array $key The key to look up (auto-generates key from array of key=>values)
	 * @param mixed $value The Value to set
	 * @param int|null $ttl The ttl (defaults to current set ttl)
	 * @param string|null $group The group to add cache to (defaults to current group))
	 * @return bool
	 */
	public function set(string|array $key, mixed $value, ?int $ttl = null, ?string $group = null): bool
	{
		$ttl = $ttl ?: $this->cache_ttl;
		$group = $group ?: $this->group;
		$key = $this->normalizeKey($key);
		$cache_key = $this->buildKey($key);

		// Update timestamp when setting new data
		self::updateTimestamp($this->group);

		return wp_cache_set($cache_key, $value, $group, $ttl);
	}

	/**
	 * Delete a cached value
	 * @param string|array $key The key to look up (auto-generates key from array of key=>values)
	 * @param string|null $group The group to delete from (defaults to current group)
	 * @return bool
	 */
	public function delete(string|array $key, ?string $group = null): bool
	{
		$group = $group ?: $this->group;
		$key = $this->normalizeKey($key);
		$cache_key = $this->buildKey($key);

		return wp_cache_delete($cache_key, $group);
	}

	/**
	 * Clear all cache for this group
	 * @return bool
	 */
	public function clear(): bool
	{
		try {
			if (function_exists('wp_cache_flush_group')) {
				wp_cache_flush_group($this->group);
				self::updateTimestamp($this->group);
				return true;
			}
			return false;
		} catch (\Exception $e) {
			return false;
		}
	}

	/**
	 * Helper to generateKey from array if applicable
	 * @param string|array $key
	 * @return string
	 */
	private function normalizeKey(string|array $key): string
	{
		return is_array($key) ? $this->generateKey($key) : $key;
	}

	/**
	 * Generate a cache key from parameters
	 * @param array $params An array of key/values that differentiates this cache item from others
	 * @return string
	 */
	public function generateKey(array $params): string
	{
		// Sort params for consistent key generation
		ksort($params);
		return md5(serialize($params));
	}

	/**
	 * The workhorse shorthand of CacheManager. Tests the cache, and calls the callback if nothing is found.
	 * @param string|array $key The key to look up (auto-generates key from array of key=>values)
	 * @param callable $callback The callback to generate the value for this key
	 * @param int|null $ttl The time-to-live for the cache. Defaults to constructor
	 * @param string|null $group The group to save cache to. Defaults to constructor
	 * @return mixed
	 */
	public function remember(string|array $key, callable $callback, ?int $ttl = null, ?string $group = null): mixed
	{
		$group = $group ?: $this->group;
		$ttl = $ttl ?: $this->cache_ttl;
		$key = $this->normalizeKey($key);

		$value = $this->get($key, $group);

		if ($value === false) {
			$value = $callback();
			if ($value !== false && $value !== null) {
				$this->set($key, $value, $ttl, $group);
			}
		}

		return $value;
	}

	/**
	 * Build the cache key
	 * @param string $key
	 * @return string
	 */
	private function buildKey(string $key): string
	{
		return $this->prefix . $key;
	}

	/**
	 * Get instance group name (for debugging)
	 */
	public function getGroup(): string
	{
		return $this->group;
	}

	// ===== RELATIONSHIP MANAGEMENT =====

	/**
	 * Register cache relationship
	 * When $type is invalidated, these related types are also invalidated
	 *
	 * @param string $type Primary type
	 * @param array $config Relationship configuration
	 *   - 'author' => bool - Invalidate user content caches
	 *   - 'taxonomies' => array - List of taxonomy types to invalidate
	 *   - 'content_types' => array - List of content types to invalidate
	 *   - 'related' => array - Generic related types to invalidate
	 *   - 'cascade' => callable - Custom cascade function
	 */
	public static function registerRelationship(string $type, array $config): void
	{
		$type = jvbNoBase($type);

		// Merge with existing relationships
		self::$relationships[$type] = array_merge(
			self::$relationships[$type] ?? [],
			$config
		);

		// Build reverse relationships for bidirectional linking
		self::buildReverseRelationships($type, $config);
	}

	/**
	 * Build reverse relationships (if A relates to B, B should know about A)
	 *
	 * @param string $type The type being registered
	 * @param array $config Its relationship config
	 */
	private static function buildReverseRelationships(string $type, array $config): void
	{
		// If this type relates to taxonomies, those taxonomies should know about this type
		if (!empty($config['taxonomies'])) {
			foreach ($config['taxonomies'] as $taxonomy) {
				$taxonomy = jvbNoBase($taxonomy);
				self::$relationships[$taxonomy]['content_types'] =
					array_unique(array_merge(
						self::$relationships[$taxonomy]['content_types'] ?? [],
						[$type]
					));
			}
		}

		// If this type relates to content_types, those types should know about this taxonomy
		if (!empty($config['content_types'])) {
			foreach ($config['content_types'] as $content_type) {
				$content_type = jvbNoBase($content_type);
				self::$relationships[$content_type]['related'] =
					array_unique(array_merge(
						self::$relationships[$content_type]['related'] ?? [],
						[$type]
					));
			}
		}
	}

	/**
	 * Load relationships from JVB_CONTENT and JVB_TAXONOMY
	 */
	private static function loadRelationships(): void
	{
		if (self::$relationships_loaded) {
			return;
		}

		// Load post type relationships
		if (defined('JVB_CONTENT')) {
			foreach (JVB_CONTENT as $slug => $config) {
				$relationships = [];

				// Author relationship
				if (!($config['no_author'] ?? false)) {
					$relationships['author'] = true;
				}

				// Taxonomy relationships
				if (!empty($config['taxonomies'])) {
					$relationships['taxonomies'] = array_map('jvbNoBase', $config['taxonomies']);
				}

				// Custom relationships from config
				if (!empty($config['cache_relationships'])) {
					$relationships = array_merge($relationships, $config['cache_relationships']);
				}

				if (!empty($relationships)) {
					self::registerRelationship($slug, $relationships);
				}
			}
		}

		// Load taxonomy relationships
		if (defined('JVB_TAXONOMY')) {
			foreach (JVB_TAXONOMY as $slug => $config) {
				$relationships = [];

				// Content type relationships
				if (!empty($config['for_content'])) {
					$relationships['content_types'] = array_map('jvbNoBase', $config['for_content']);
				}

				// Always include generic 'terms' cache
				$relationships['related'] = ['terms'];

				// Custom relationships from config
				if (!empty($config['cache_relationships'])) {
					$relationships = array_merge($relationships, $config['cache_relationships']);
				}

				if (!empty($relationships)) {
					self::registerRelationship($slug, $relationships);
				}
			}
		}

		self::$relationships_loaded = true;

		do_action('jvb_cache_relationships_loaded', self::$relationships);
	}

	/**
	 * Get relationships for a type (for debugging)
	 *
	 * @param string|null $type Specific type or null for all
	 * @return array Relationships
	 */
	public static function getRelationships(?string $type = null): array
	{
		self::loadRelationships();

		if ($type !== null) {
			return self::$relationships[jvbNoBase($type)] ?? [];
		}

		return self::$relationships;
	}

	/**
	 * Cascade invalidation to related types based on relationships
	 *
	 * @param string $type Primary type being invalidated
	 * @param mixed $context Context with relationship data
	 */
	/**
	 * Cascade invalidation to related types based on relationships
	 */
	private static function cascadeInvalidation(string $type, $context): void
	{
		self::loadRelationships();

		$relationships = self::$relationships[$type] ?? [];
		if (empty($relationships)) {
			return;
		}

		$data = self::extractContext($context);

		// Author relationship - SIMPLIFIED
		if (!empty($relationships['author'])) {
			$user_ids = self::extractUserIds($data, $relationships['author']);

			foreach ($user_ids as $user_id) {
				// Single clean call - handles content, profile, everything
				self::invalidateAll("user_{$user_id}");
			}
		}

		// Taxonomy relationships
		if (!empty($relationships['taxonomies']) && !empty($data['ID'])) {
			foreach ($relationships['taxonomies'] as $taxonomy) {
				$taxonomy_full = jvbCheckBase($taxonomy);
				$terms = wp_get_post_terms($data['ID'], $taxonomy_full, ['fields' => 'ids']);

				if (!empty($terms) && !is_wp_error($terms)) {
					self::updateTimestamp($taxonomy);
					wp_cache_flush_group($taxonomy);
				}
			}
		}

		// Content type relationships (for taxonomies)
		if (!empty($relationships['content_types'])) {
			foreach ($relationships['content_types'] as $content_type) {
				self::updateTimestamp($content_type);
				wp_cache_flush_group($content_type);
			}
		}

		// Generic related caches
		if (!empty($relationships['related'])) {
			foreach ($relationships['related'] as $related_type) {
				self::updateTimestamp($related_type);
				wp_cache_flush_group($related_type);
			}
		}

		// Custom cascade function
		if (!empty($relationships['cascade']) && is_callable($relationships['cascade'])) {
			call_user_func($relationships['cascade'], $type, $data);
		}
	}

	/**
	 * Extract user IDs from context based on relationship config
	 * Supports multiple authors, contributors, etc.
	 *
	 * @param array $data Context data
	 * @param mixed $config Author relationship config (bool or array)
	 * @return array User IDs to invalidate
	 */
	private static function extractUserIds(array $data, $config): array
	{
		$user_ids = [];

		// Simple case: 'author' => true
		if ($config === true) {
			if (!empty($data['post_author'])) {
				$user_ids[] = $data['post_author'];
			}
			return array_filter($user_ids);
		}

		// Advanced case: 'author' => ['post_author', 'contributors', 'linked_user']
		if (is_array($config)) {
			foreach ($config as $field) {
				// Handle meta fields
				if (str_starts_with($field, 'meta:') && !empty($data['ID'])) {
					$meta_key = substr($field, 5);
					$value = get_post_meta($data['ID'], BASE . $meta_key, true);

					if (is_array($value)) {
						$user_ids = array_merge($user_ids, $value);
					} elseif ($value) {
						$user_ids[] = $value;
					}
				}
				// Handle direct data fields
				elseif (!empty($data[$field])) {
					if (is_array($data[$field])) {
						$user_ids = array_merge($user_ids, $data[$field]);
					} else {
						$user_ids[] = $data[$field];
					}
				}
			}
		}

		// Callable: 'author' => function($data) { return [...user_ids]; }
		if (is_callable($config)) {
			$result = call_user_func($config, $data);
			if (is_array($result)) {
				$user_ids = array_merge($user_ids, $result);
			} elseif ($result) {
				$user_ids[] = $result;
			}
		}

		return array_unique(array_filter(array_map('intval', $user_ids)));
	}

	/**
	 * Extract context data from various formats
	 * Converts WP objects to arrays with relevant data
	 *
	 * @param mixed $context Post/Term object, array, or ID
	 * @return array Normalized context data
	 */
	private static function extractContext($context): array
	{
		if (is_array($context)) {
			return $context;
		}

		if ($context instanceof \WP_Post) {
			return [
				'ID' => $context->ID,
				'post_author' => $context->post_author,
				'post_type' => $context->post_type,
				'post_status' => $context->post_status,
			];
		}

		if ($context instanceof \WP_Term) {
			return [
				'term_id' => $context->term_id,
				'taxonomy' => $context->taxonomy,
				'parent' => $context->parent,
			];
		}

		if (is_numeric($context)) {
			$post = get_post($context);
			if ($post) {
				return self::extractContext($post);
			}
		}

		return [];
	}
}