// FilterService.js - Service for processing and managing filters
import cache from '../utils/cache';

class FilterService {
	constructor(options = {}) {
		this.options = {
			taxonomyMap: {},
			contentTypeMap: {},
			initialFilters: {},
			...options
		};

		this.termCache = {
			terms: new Map(),
			timestamp: Date.now()
		};
	}

	/**
	 * Build query parameters from filters
	 * @param {Object} filters - Filter state
	 * @param {Object} context - Context data
	 * @param {number} page - Page number
	 * @param {Object} highlight - Highlighted item
	 * @returns {URLSearchParams} - URL search params
	 */
	buildQueryParams(filters, context, page = 1, highlight = null) {
		const params = new URLSearchParams();

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

		// Add context if present
		if (context) {
			params.append('context', JSON.stringify(context));
		}

		// Add highlight if present
		if (highlight) {
			params.append('highlight', JSON.stringify(highlight));
		}

		// Add filters
		if (filters) {
			Object.entries(filters).forEach(([key, value]) => {
				if (Array.isArray(value)) {
					value.forEach(v => {
						params.append(`filters[${key}][]`, v);
					});
				} else if (value !== null && value !== undefined) {
					params.append(`filters[${key}]`, value);
				}
			});
		}

		return params;
	}

	/**
	 * Update URL based on current filters
	 * @param {Object} filters - Current filters
	 */
	updateURL(filters) {
		const params = new URLSearchParams();

		// Add content type
		if (filters.content && filters.content !== 'all') {
			params.set('type', filters.content);
		}

		// Add order and direction
		if (filters.order) {
			params.set('order', filters.order);
			if (filters.direction) {
				params.set('direction', filters.direction);
			}
		}

		// Add taxonomy filters
		Object.entries(filters).forEach(([key, value]) => {
			if (Array.isArray(value) && value.length > 0) {
				value.forEach(v => {
					params.append(key, v);
				});
			}
		});

		// Add favourites filter
		if (filters.favouritesOnly) {
			params.set('favourites', '1');
		}

		// Update URL without reloading page
		const newUrl = `${window.location.pathname}${params.toString() ? '?' + params.toString() : ''}`;
		history.pushState({ filters }, '', newUrl);
	}

	/**
	 * Parse filters from URL parameters
	 * @returns {Object} - Parsed filters
	 */
	parseFiltersFromURL() {
		const params = new URLSearchParams(window.location.search);
		const filters = {};

		// Get content type
		const type = params.get('f_content');
		if (type) {
			filters.content = type;
		}

		// Get order and direction
		const order = params.get('f_order');
		if (order) {
			filters.order = order;
		}

		const direction = params.get('f_direction');
		if (direction) {
			filters.direction = direction;
		}

		// Get favourites flag
		if (params.get('f_favourites') === '1') {
			filters.favouritesOnly = true;
		}

		// Process all potential taxonomy parameters
		// Look for parameters with f_ prefix
		for (const [key, value] of params.entries()) {
			if (key.startsWith('f_') && key !== 'f_content' &&
				key !== 'f_order' && key !== 'f_direction' &&
				key !== 'f_favourites') {

				const taxName = key.replace('f_', '');

				// Add to filters as array if not already
				if (!filters[taxName]) {
					filters[taxName] = [];
				}

				// Multiple values could exist for same taxonomy
				if (!filters[taxName].includes(value)) {
					filters[taxName].push(value);
				}
			}
		}

		return filters;
	}

	/**
	 * Get applicable taxonomies for a content type
	 * @param {string} contentType - Content type
	 * @returns {Array} - Applicable taxonomies
	 */
	getApplicableTaxonomies(contentType) {
		const taxonomies = [];

		Object.entries(this.options.taxonomyMap).forEach(([taxonomy, info]) => {
			if (info.types && info.types.includes(contentType)) {
				taxonomies.push(taxonomy);
			}
		});

		return taxonomies;
	}

	/**
	 * Fetch taxonomy terms
	 * @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 based on parameters
		const cacheKey = `terms_${taxonomy}_${search}_${page}`;

		// Try to get from cache first
		const cachedTerms = cache.get(cacheKey);
		if (cachedTerms) {
			return cachedTerms;
		}

		// If not in cache, fetch from API
		try {
			const params = new URLSearchParams({
				search,
				page
			});

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

			if (!response.ok) {
				throw new Error(`Failed to fetch terms: ${response.status}`);
			}

			const data = await response.json();

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

			// Update term cache
			if (!this.termCache.terms.has(taxonomy)) {
				this.termCache.terms.set(taxonomy, new Map());
			}

			Object.entries(data.terms).forEach(([id, term]) => {
				this.termCache.terms.get(taxonomy).set(parseInt(id), term);
			});

			return data;

		} catch (error) {
			console.error(`Error fetching terms for ${taxonomy}:`, error);
			throw error;
		}
	}

	/**
	 * Get term details from cache
	 * @param {string} taxonomy - Taxonomy name
	 * @param {number} id - Term ID
	 * @returns {Object|null} - Term details or null if not found
	 */
	getTermDetails(taxonomy, id) {
		if (!this.termCache.terms.has(taxonomy)) {
			return null;
		}

		return this.termCache.terms.get(taxonomy).get(parseInt(id)) || null;
	}

	/**
	 * Get a formatted term path
	 * @param {number} termId - Term ID
	 * @param {string} taxonomy - Taxonomy name
	 * @returns {string} - Formatted path
	 */
	async getTermPath(termId, taxonomy) {
		// Try to get from term cache first
		const termDetails = this.getTermDetails(taxonomy, termId);
		if (termDetails && termDetails.path) {
			return termDetails.path;
		}

		// If not in cache, fetch from server
		try {
			const response = await fetch(`${window.feedSettings?.apiUrl}terms/${taxonomy}/${termId}`, {
				headers: {
					'X-WP-Nonce': window.feedSettings?.nonce || ''
				}
			});

			if (!response.ok) {
				throw new Error(`Failed to fetch term: ${response.status}`);
			}

			const data = await response.json();

			// Update term cache
			if (!this.termCache.terms.has(taxonomy)) {
				this.termCache.terms.set(taxonomy, new Map());
			}

			this.termCache.terms.get(taxonomy).set(termId, data);

			return data.path || data.name;

		} catch (error) {
			console.error(`Error fetching term path for ${termId} in ${taxonomy}:`, error);
			return '';
		}
	}

	/**
	 * Pre-load common terms for a taxonomy
	 * @param {string} taxonomy - Taxonomy name
	 * @param {Object} terms - Terms data
	 */
	preloadTerms(taxonomy, terms) {
		if (!this.termCache.terms.has(taxonomy)) {
			this.termCache.terms.set(taxonomy, new Map());
		}

		Object.entries(terms).forEach(([id, term]) => {
			this.termCache.terms.get(taxonomy).set(
				parseInt(id),
				typeof term === 'string' ? { id, name: term } : term
			);
		});
	}

	/**
	 * Get highlighted item from URL
	 * @returns {Object|null} - Highlight object or null if none
	 */
	getHighlightFromURL() {
		const params = new URLSearchParams(window.location.search);
		const contentTypes = ['tattoo', 'piercing', 'artwork'];

		for (const type of contentTypes) {
			if (params.has(type)) {
				return { [type]: params.get(type) };
			}
		}

		return null;
	}
}

export default FilterService;