import type { Article } from '@/types/nostr'
import type { ArticleFilters, SortOption } from '@/components/ArticleFilters'

/**
 * Filter articles based on search query
 */
export function filterArticlesBySearch(articles: Article[], searchQuery: string): Article[] {
  if (!searchQuery.trim()) {
    return articles
  }

  const query = searchQuery.toLowerCase().trim()

  return articles.filter((article) => {
    const titleMatch = article.title.toLowerCase().includes(query)
    const previewMatch = article.preview.toLowerCase().includes(query)
    const contentMatch = article.content.toLowerCase().includes(query)

    return titleMatch || previewMatch || contentMatch
  })
}

/**
 * Filter articles based on filters (author, price)
 */
export function filterArticles(articles: Article[], filters: ArticleFilters): Article[] {
  let filtered = articles

  // Filter by author
  if (filters.authorPubkey) {
    filtered = filtered.filter((article) => article.pubkey === filters.authorPubkey)
  }

  // Filter by min price
  if (filters.minPrice !== null) {
    filtered = filtered.filter((article) => article.zapAmount >= filters.minPrice!)
  }

  // Filter by max price
  if (filters.maxPrice !== null) {
    filtered = filtered.filter((article) => article.zapAmount <= filters.maxPrice!)
  }

  return filtered
}

/**
 * Sort articles based on sort option
 */
export function sortArticles(articles: Article[], sortBy: SortOption): Article[] {
  const sorted = [...articles]

  switch (sortBy) {
    case 'newest':
      return sorted.sort((a, b) => b.createdAt - a.createdAt)

    case 'oldest':
      return sorted.sort((a, b) => a.createdAt - b.createdAt)

    case 'price-low':
      return sorted.sort((a, b) => a.zapAmount - b.zapAmount)

    case 'price-high':
      return sorted.sort((a, b) => b.zapAmount - a.zapAmount)

    default:
      return sorted.sort((a, b) => b.createdAt - a.createdAt)
  }
}

/**
 * Apply all filters and sorting to articles
 */
export function applyFiltersAndSort(
  articles: Article[],
  searchQuery: string,
  filters: ArticleFilters
): Article[] {
  let result = articles

  // First apply search filter
  result = filterArticlesBySearch(result, searchQuery)

  // Then apply other filters
  result = filterArticles(result, filters)

  // Finally apply sorting
  result = sortArticles(result, filters.sortBy)

  return result
}