taskSelectors.ts

import { createDraftSafeSelector } from '@reduxjs/toolkit'

import type { RootState } from '@/store'
import type { KeysWithValsOfType, Task } from '@/types'

import type { TasksState } from './tasksSlice'

const createTypedDraftSafeSelector =
  createDraftSafeSelector.withTypes<RootState>()

export const selectFilteredTasks = createTypedDraftSafeSelector(
  (state) => state.tasks.entities,
  (state) => state.tasks.filters,
  (state) => state.tasks.searchQuery,
  (
    entities: TasksState['entities'],
    filters: TasksState['filters'],
    searchQuery: TasksState['searchQuery'],
  ) => {
    const hasFilters =
      filters &&
      Object.values(filters).some((value) => typeof value !== 'undefined')

    // Optimistic check for performance
    if (!hasFilters && !searchQuery) {
      return entities
    }

    // Select every task that matches each existing filter and search keywords
    return entities.filter(
      (task) => filterTask(task, filters) && searchTask(task, searchQuery),
    )
  },
)

function filterTask<T extends Task>(task: T, filters: Partial<T>): boolean {
  let property: keyof T

  for (property in filters) {
    if (typeof property === 'undefined') {
      continue
    }

    if (task[property] !== filters[property]) {
      return false
    }
  }

  return true
}

function searchTask<T extends Task>(task: T, searchQuery: string): boolean {
  const searchQueryNormalized = searchQuery.trim().toLowerCase()

  if (!searchQueryNormalized) {
    return true
  }

  const propertiesSearchable: KeysWithValsOfType<Task, string>[] = [
    'title',
    'description',
  ]

  // TODO Sensible fuzzy search
  return propertiesSearchable.some((property) =>
    task[property].toLowerCase().includes(searchQuery),
  )
}

export const selectTotalCount = createTypedDraftSafeSelector(
  (state) => state.tasks.entities,
  (entities: TasksState['entities']) => entities.length,
)

export const selectFilterCount = createTypedDraftSafeSelector(
  (state) => state.tasks.filters,

  // Include search query as a filter
  (state) => state.tasks.searchQuery,

  (filters: TasksState['filters'], searchQuery: TasksState['searchQuery']) => {
    const filterCount = Object.values(filters).filter(
      (filterValue) => typeof filterValue !== 'undefined',
    ).length

    const searchQueryModifier = Number(searchQuery.trim().length > 0)

    return filterCount + searchQueryModifier
  },
)