// FeedService.js - Handles API interactions for the feed block
import cache from '../utils/cache';
class FeedService {
    constructor(apiUrl, nonce) {
        this.apiUrl = apiUrl;
        this.nonce = nonce;
        this.currentRequest = null;
        this.timeoutId = null;
        this.pendingRequests = new Map(); // Track in-flight requests by cache key
    }
    /**
     * Fetch feed data from the API with request deduplication and caching
     * @param {Object} params - Request parameters
     * @param {boolean} resetCache - Whether to bypass cache
     * @returns {Promise<Object>} - Feed data
     */
    async fetchFeed(params, resetCache = false) {
        // Create cache key from params
        const cacheKey = this.createCacheKey(params);
        resetCache = true;
        //TODO: remove default reset
        // Check cache first (unless reset requested)
        if (!resetCache) {
			const cached = cache.get(cacheKey);
			if (cached) {
				return cached;
			}
		}

		// Check if this exact request is already in flight
		if (this.pendingRequests.has(cacheKey)) {
			// Return the existing promise for the in-flight request
			return this.pendingRequests.get(cacheKey);
		}

		// Cancel any existing request for different params
		this.abortCurrentRequest();

		// Create a new request
		try {
			// Create abort controller for this request
			const controller = new AbortController();
			this.currentRequest = controller;

			// Set timeout for request
			this.timeoutId = setTimeout(() => {
				if (this.currentRequest === controller) {
					controller.abort();
				}
			}, 30000); // 30 second timeout


			// Build query parameters
			const queryParams = this.buildQueryParams(params);

			// Add cache busting if needed
			if (resetCache) {
				queryParams.append('_', Date.now());
			}

			const requestUrl = `${this.apiUrl}feed?${queryParams.toString()}`;

			// Create the promise for this request
			const requestPromise = (async () => {
				try {
					const response = await fetch(requestUrl, {
						headers: {
							'X-WP-Nonce': this.nonce
						},
						signal: controller.signal
					});

					// Clear timeout
					if (this.timeoutId) {
						clearTimeout(this.timeoutId);
						this.timeoutId = null;
					}

					// Check for successful response
					if (!response.ok) {
						throw new Error(`HTTP error! status: ${response.status}`);
					}

					// Parse response
					const data = await response.json();


					// Reset error handler retry count on success
					if (this.errorHandler) {
						this.errorHandler.resetRetryCount();
					}

					// Cache the result for 5 minutes (unless it's a reset request)
					if (!resetCache) {
						cache.set(cacheKey, data, 300000);
					}

					return data;
				} finally {
					// Remove from pending requests
					this.pendingRequests.delete(cacheKey);
				}
			})();

			// Store the promise in the pending requests map
			this.pendingRequests.set(cacheKey, requestPromise);

			return requestPromise;

		} catch (error) {
			// Clean up pending request
			this.pendingRequests.delete(cacheKey);

			if (this.errorHandler) {
				return this.errorHandler.handleApiError(
					error,
					{ params },
					() => this.fetchFeed(params, resetCache)
				);
			}

			// Don't throw for aborted requests
			if (error.name === 'AbortError') {
				return null;
			}

			// Re-throw other errors
			throw error;

		} finally {
			this.currentRequest = null;

			if (this.timeoutId) {
				clearTimeout(this.timeoutId);
				this.timeoutId = null;
			}
		}
	}

	/**
	 * Create a cache key from params object
	 * @param {Object} params - Request parameters
	 * @returns {string} - Cache key
	 */
	createCacheKey(params) {
		// Clone to avoid modifying original
		const normalized = JSON.parse(JSON.stringify(params));

		// Sort arrays to ensure consistent keys
		if (normalized.filters) {
			Object.keys(normalized.filters).forEach(key => {
				if (Array.isArray(normalized.filters[key])) {
					normalized.filters[key].sort();
				}
			});
		}

		return `feed_${JSON.stringify(normalized)}`;
	}

	/**
	 * Build query parameters from params object
	 * @param {Object} params - Request parameters
	 * @returns {URLSearchParams} - URL search params
	 */
	buildQueryParams(params) {
		const queryParams = new URLSearchParams();

		// Add page parameter
		queryParams.append('page', params.page || 1);

		// Add context and other metadata
		if (params.context) {
			queryParams.append('context', JSON.stringify(params.context));
		}

		if (params.highlight) {
			queryParams.append('highlight', JSON.stringify(params.highlight));
		}

		// Add source and source type
		if (params.source) {
			queryParams.append('source', params.source);
		}

		if (params.sourceType) {
			queryParams.append('type', params.sourceType);
		}

		// Add filters
		const filterParams = params.filters || {};

		// Ensure content type is explicitly added as a filter
		if (filterParams.content) {
			queryParams.append('filters[content]', filterParams.content);
		}

		// Add remaining filters
		Object.entries(filterParams).forEach(([key, value]) => {
			// Skip content since we added it separately
			if (key === 'content') return;

			if (Array.isArray(value) && value.length > 0) {

				value.forEach(v => {
					queryParams.append(`filters[${key}][]`, v);
				});
			} else if (value !== null && value !== undefined && value !== '') {
				if(typeof value === 'object' && Object.keys(value).length === 0){
					return;
				}
				queryParams.append(`filters[${key}]`, value);
			}
		});

		return queryParams;
	}

	/**
	 * Fetch taxonomy terms with caching
	 * @param {string} taxonomy - Taxonomy name
	 * @param {string} search - Search query
	 * @param {number} page - Page number
	 * @returns {Promise<Object>} - Terms data
	 */
	async fetchTerms(taxonomy, search = '', page = 1) {
		// Create cache key
		const cacheKey = `terms_${taxonomy}_${search}_${page}`;

		// Check cache first
		const cached = cache.get(cacheKey);
		if (cached) {
			return cached;
		}

		try {
			const params = new URLSearchParams({
				search,
				page
			});

			const response = await fetch(`${this.apiUrl}terms/${taxonomy}?${params.toString()}`, {
				headers: {
					'X-WP-Nonce': this.nonce
				}
			});

			if (!response.ok) {
				throw new Error(`HTTP error! status: ${response.status}`);
			}

			const data = await response.json();

			// Cache for 5 minutes
			cache.set(cacheKey, data, 300000);

			return data;

		} catch (error) {
			console.error('Error fetching terms:', error);
			throw error;
		}
	}

	/**
	 * Fetch taxonomy terms specific to a content type
	 * @param {string} taxonomy - Taxonomy name
	 * @param {string} contentType - Content type
	 * @param {string} search - Search query
	 * @param {number} page - Page number
	 * @returns {Promise<Object>} - Terms data
	 */
	async fetchTermsForContentType(taxonomy, contentType, search = '', page = 1) {
		// Create cache key
		const cacheKey = `terms_${contentType}_${taxonomy}_${search}_${page}`;

		// Check cache first
		const cached = cache.get(cacheKey);
		if (cached) {
			return cached;
		}

		try {
			const params = new URLSearchParams({
				search,
				page,
				per_page: 20,
				min_count: 1
			});

			const response = await fetch(`${this.apiUrl}terms/for/${contentType}/${taxonomy}?${params.toString()}`, {
				headers: {
					'X-WP-Nonce': this.nonce
				}
			});

			if (!response.ok) {
				throw new Error(`HTTP error! status: ${response.status}`);
			}

			const data = await response.json();

			// Cache for 5 minutes
			cache.set(cacheKey, data, 300000);

			return data;

		} catch (error) {
			console.error('Error fetching terms for content type:', error);
			throw error;
		}
	}
	/**
	 * Fetch popular terms
	 * @param {string} taxonomy - Taxonomy name
	 * @returns {Promise<Object>} - Popular terms data
	 */
	async fetchPopularTerms(taxonomy) {
		// Create cache key
		const cacheKey = `popular_terms_${taxonomy}`;

		// Check cache first
		const cached = cache.get(cacheKey);
		if (cached) {
			return cached;
		}

		try {
			const response = await fetch(`${this.apiUrl}terms/popular/${taxonomy}?limit=10`, {
				headers: {
					'X-WP-Nonce': this.nonce
				}
			});

			if (!response.ok) {
				throw new Error(`HTTP error! status: ${response.status}`);
			}

			const data = await response.json();

			// Cache for 1 hour
			cache.set(cacheKey, data, 3600000);

			return data;

		} catch (error) {
			console.error('Error fetching popular terms:', error);
			throw error;
		}
	}

	/**
	 * Fetch related terms
	 * @param {string} taxonomy - Taxonomy name
	 * @param {number} termId - Term ID
	 * @returns {Promise<Object>} - Related terms data
	 */
	async fetchRelatedTerms(taxonomy, termId) {
		// Create cache key
		const cacheKey = `related_terms_${taxonomy}_${termId}`;

		// Check cache first
		const cached = cache.get(cacheKey);
		if (cached) {
			return cached;
		}

		try {
			const response = await fetch(`${this.apiUrl}terms/related/${taxonomy}/${termId}`, {
				headers: {
					'X-WP-Nonce': this.nonce
				}
			});

			if (!response.ok) {
				throw new Error(`HTTP error! status: ${response.status}`);
			}

			const data = await response.json();

			// Cache for 1 hour
			cache.set(cacheKey, data, 3600000);

			return data;

		} catch (error) {
			console.error('Error fetching related terms:', error);
			throw error;
		}
	}

	/**
	 * Abort the current request if it exists
	 */
	abortCurrentRequest() {
		if (this.currentRequest) {
			this.currentRequest.abort();
			this.currentRequest = null;
		}

		if (this.timeoutId) {
			clearTimeout(this.timeoutId);
			this.timeoutId = null;
		}
	}

	/**
	 * Clear feed cache
	 * @param {string} contentType - Optional content type to clear cache for
	 */
	clearCache(contentType = null) {
		if (contentType) {
			// Find and delete cache entries for specific content type
			Object.keys(cache.storage).forEach(key => {
				if (key.startsWith('feed_') && key.includes(`"content":"${contentType}"`)) {
					cache.remove(key.replace(cache.options.namespace, ''));
				}
			});
		} else {
			// Clear all feed-related cache entries
			Object.keys(cache.storage).forEach(key => {
				if (key.startsWith(cache.options.namespace + 'feed_')) {
					cache.remove(key.replace(cache.options.namespace, ''));
				}
			});
		}
	}
}

export default FeedService;