app/services/utils/arrayUtils.ts

import type { AnyJson, ResourceTree, ResourceTreeContent } from '~/types/data'

const ArrayUtils = {
  /**
   * Trie un tableau
   *
   * @param array
   * @param reverse
   */
  sort(
    array: Array<object | string | number>,
    reverse: boolean = false,
  ): Array<object | string | number> {
    return array.sort((a, b) => {
      return (a < b ? -1 : a > b ? 1 : 0) * (reverse ? -1 : 1)
    })
  },

  /**
   * Trie un tableau d'objets selon une propriété commune
   *
   * @param array Une array d'objets
   * @param property Le nom d'une propriété possédée par tous les objets
   * @param reverse
   */
  sortObjectsByProp<T extends AnyJson>(
    array: Array<T>,
    property: string,
    reverse: boolean = false,
  ): Array<T> {
    return array.sort((a: T, b: T) => {
      return (
        (a[property] < b[property] ? -1 : a[property] > b[property] ? 1 : 0) *
        (reverse ? -1 : 1)
      )
    })
  },

  /**
   * Sort the different levels of a resource tree's content
   * @param tree
   */
  sortResourceTree(tree: ResourceTreeContent): ResourceTreeContent {
    // Si c'est un tableau simple (premier niveau)
    if (Array.isArray(tree)) {
      return [...tree].sort()
    }

    // Si c'est un objet (deuxième ou troisième niveau)
    const sortedTree: Record<string, any> = {}

    // Trier les clés du premier niveau
    const sortedKeys = Object.keys(tree).sort()

    for (const key of sortedKeys) {
      const value = tree[key]

      // Si la valeur est un tableau (deuxième niveau)
      if (Array.isArray(value)) {
        sortedTree[key] = [...value].sort()
      }

      // Si la valeur est un objet (troisième niveau)
      else if (typeof value === 'object' && value !== null) {
        const sortedSubTree: Record<string, string[]> = {}
        const sortedSubKeys = Object.keys(value).sort()

        for (const subKey of sortedSubKeys) {
          const subValue = value[subKey]
          if (Array.isArray(subValue)) {
            sortedSubTree[subKey] = [...subValue].sort()
          }
        }

        sortedTree[key] = sortedSubTree
      }
    }

    return sortedTree
  },

  *iterate(array: Array<string> | object): Generator<string> {
    if (Array.isArray(array)) {
      for (const item of array) {
        yield item
      }
    } else if (typeof array === 'object') {
      for (const key in array) {
        yield key
      }
    } else {
      throw new Error('Invalid array or object')
    }
  }
}

export default ArrayUtils