<?php
namespace nur;

use ArrayAccess;
use nur\b\coll\BaseArray;
use nur\b\coll\Flattener;
use nur\b\coll\IArray;
use Traversable;

/**
 * Class A: méthodes utilitaires pour gérer les array
 */
class A {
  static final function with($array): array { return SL::with($array); }
  static final function withn($array): ?array { return SL::withn($array); }

  /**
   * tester si $array est un tableau de type array, BaseArray ou Traversable.
   * tous ces objets peuvent être transformés en array par {@link with()}
   *
   * pour être sûr de pouvoir les parcourir en lecture seule, il faut les
   * transformer en array avec {@link with()}
   */
  static final function is_array($array): bool {
    if ($array === null || $array === false) return false;
    return is_iterable($array) || $array instanceof BaseArray;
  }

  static final function ensure_array(&$array): bool { return SL::ensure_array($array); }
  static final function ensure_narray(&$array): bool { return SL::ensure_narray($array); }

  /**
   * retourner une référence permettant de modifier $array en tant qu'array de
   * préférence ou en tant qu'instance de ArrayAccess au pire.
   */
  static final function &ensure_access(&$array) {
    if (is_array($array)) return $array;
    if ($array instanceof IArray) return $array->array();
    if ($array instanceof ArrayAccess) return $array;
    if ($array instanceof Traversable) $array = iterator_to_array($array);
    elseif ($array === null || $array === false) $array = [];
    else $array = [$array];
    return $array;
  }

  /**
   * s'assurer que $array est un tableau de $size éléments, en complétant avec
   * des occurrences de $default si nécessaire
   *
   * @return bool true si le tableau a été modifié, false sinon
   */
  static final function ensure_size(?array &$array, int $size, $default=null): bool {
    $modified = false;
    if ($array === null) {
      $array = [];
      $modified = true;
    }
    if ($size < 0) return $modified;
    $count = count($array);
    if ($count == $size) return $modified;
    if ($count < $size) {
      # agrandir le tableau
      while ($count++ < $size) {
        $array[] = $default;
      }
      return true;
    }
    # rétrécir le tableau
    $tmparray = [];
    foreach ($array as $key => $value) {
      if ($size-- == 0) break;
      $tmparray[$key] = $value;
    }
    $array = $tmparray;
    return true;
  }

  /** tester si $array contient la clé $key */
  static final function has(?array $array, $key): bool {
    return $array !== null && array_key_exists($key, $array);
  }

  /** retourner $array[$key] ou $default si la clé n'existe pas */
  static final function get(?array $array, $key, $default=null) {
    if ($array === null) return $default;
    elseif (array_key_exists($key, $array)) return $array[$key];
    else return $default;
  }

  /** s'assurer que $array est un array puis spécifier $array[$key] */
  static final function set(&$array, $key, $value): void {
    self::ensure_array($array);
    if ($key === null) $array[] = $value;
    else $array[$key] = $value;
  }

  /** s'assurer que $array est un array puis supprimer $array[$key] */
  static final function del(&$array, $key): void {
    if ($array === null || $array === false) return;
    self::ensure_array($array);
    unset($array[$key]);
  }

  /** retourner le nombre d'éléments de $array */
  static final function count(?array $array): int {
    return $array === null? 0: count($array);
  }

  /** retourner la liste des clés de $array */
  static final function keys(?array $array): array {
    return $array === null? []: array_keys($array);
  }

  static final function join(?array $array, string $sep=" "): string {
    return $array === null? "": implode($sep, $array);
  }

  #############################################################################

  /**
   * tester si $array est un tableau séquentiel.
   *
   * NB: un tableau vide est séquentiel
   */
  static final function is_seq($array): bool {
    if (!is_array($array)) return false;
    $count = count($array);
    if ($count == 0) return true;
    return array_keys($array) === range(0, $count - 1);
  }

  /**
   * tester si $array est un tableau associatif.
   *
   * NB: un tableau vide est associatif
   */
  static final function is_assoc($array): bool {
    if (!is_array($array)) return false;
    $count = count($array);
    if ($count == 0) return true;
    return array_keys($array) !== range(0, $count - 1);
  }

  #############################################################################

  /**
   * s'assurer que $array est un array puis y fusionner tous les autres tableaux
   * avec array_merge(). les clés numériques sont réordonnées, et les clés du
   * tableau destination sont écrasées par les clés correspondantes des tableaux
   * entrants. par exemple:
   * ~~~
   * $a = [10 => "a", 15 => "b",            "x" => "y"];
   * $b = [           15 => "c", 20 => "d", "x" => "z"];
   * A::merge($a, $b);
   * # $a vaut maintenant [0 => "a", 1 => "b", "x" => "z", 2 => "c", 3 => "d"]
   * ~~~
   *
   * parmi les tableaux de $arrays, ignorer les occurrences de null et false
   *
   * NB: dans $arrays, les valeurs scalaires sont traitées comme un singleton
   * [$value]. elles sont donc simplement ajoutées à $array comme avec la
   * commande "$array[] = $value;"
   */
  static final function merge(&$array, ...$arrays): void {
    self::ensure_array($array);
    if ($arrays) {
      $merges = [$array];
      foreach ($arrays as $merge) {
        if ($merge === null || $merge === false) continue;
        $merges[] = self::with($merge);
      }
      $array = array_merge(...$merges);
    }
  }

  /**
   * s'assurer que $array est un array puis y fusionner tous les autres tableaux
   * comme avec {@link merge()} mais sans réordonner les clés numériques. Cela
   * ressemble au comportement de l'opérateur union de PHP, mais la différence
   * est que les clés du tableau destination sont écrasées par les clés
   * correspondantes des tableaux entrants. par exemple:
   * ~~~
   * $a = [10 => "a", 15 => "b",            "x" => "y"];
   * $b = [           15 => "c", 20 => "d", "x" => "z"];
   * A::merge2($a, $b);
   * # $a vaut maintenant [10 => "a", 15 => "c", "x" => "z", 20 => "d"]
   * ~~~
   *
   * parmi les tableaux de $arrays, ignorer les occurrences de null et false
   *
   * NB: dans $arrays, les valeurs scalaires sont traitées comme un singleton
   * [$value]. elles écrasent donc la valeur à la clé '0' si celle-ci existe
   * déjà dans le tableau destination
   */
  static final function merge2(&$array, ...$arrays): void {
    self::ensure_array($array);
    foreach ($arrays as $merge) {
      if ($merge === null || $merge === false) continue;
      foreach (self::with($merge) as $key => $value) {
        $array[$key] = $value;
      }
    }
  }

  /**
   * s'assurer que $array est un array puis y fusionner tous les autres tableaux
   * un peu comme avec {@link merge()} mais en ne réordonnant *que* les clés
   * séquentielles. par exemple:
   * ~~~
   * $a = ["1st", "2nd",               10 => "a", 15 => "b",            "x" => "y"];
   * $b = [              "3rd", "4th",            15 => "c", 20 => "d", "x" => "z"];
   * A::merge3($a, $b);
   * # $a vaut maintenant ["1st", "2nd", 10 => "a", 15 => "c", "x" => "z", "3rd", "4th", 20 => "d"]
   * ~~~
   *
   * parmi les tableaux de $arrays, ignorer les occurrences de null et false
   */
  static final function merge3(&$array, ...$arrays): void {
    self::ensure_array($array);
    $desti = 0;
    foreach ($array as $key => $value) {
      if ($key === $desti) {
        $desti++;
      }
    }
    foreach ($arrays as $merge) {
      $srci = 0;
      if ($merge === null || $merge === false) continue;
      foreach (self::with($merge) as $key => $value) {
        if ($key === $srci) {
          $srci++;
          $array[$desti++] = $value;
        } else {
          $array[$key] = $value;
        }
      }
    }
  }

  /**
   * comme {@link merge()} mais dans chacun des tableaux sources, ceux de
   * $arrays, ignorer les valeurs null.
   */
  static final function merge_nn(&$array, ...$arrays): void {
    self::ensure_array($array);
    if ($arrays) {
      $merges = [$array];
      foreach ($arrays as $tmp) {
        if ($tmp === false || $tmp === null) continue;
        $merge = [];
        foreach (self::with($tmp) as $key => $value) {
          if ($value === null) continue;
          $merge[$key] = $value;
        }
        $merges[] = $merge;
      }
      $array = array_merge(...$merges);
    }
  }

  /**
   * comme {@link merge2()} mais dans chacun des tableaux sources, ceux de
   * $arrays, ignorer les valeurs null.
   */
  static final function merge_nn2(&$array, ...$arrays): void {
    self::ensure_array($array);
    foreach ($arrays as $merge) {
      if ($merge === false || $merge === null) continue;
      foreach (self::with($merge) as $key => $value) {
        if ($value === null) continue;
        $array[$key] = $value;
      }
    }
  }

  /**
   * comme {@link merge()} mais dans chacun des tableaux sources, ceux de
   * $arrays, ignorer les valeurs null et false.
   */
  static final function merge_nz(&$array, ...$arrays): void {
    self::ensure_array($array);
    if ($arrays) {
      $merges = [$array];
      foreach ($arrays as $tmp) {
        if ($tmp === false || $tmp === null) continue;
        $merge = [];
        foreach (self::with($tmp) as $key => $value) {
          if ($value === null || $value === false) continue;
          $merge[$key] = $value;
        }
        $merges[] = $merge;
      }
      $array = array_merge(...$merges);
    }
  }

  /**
   * comme {@link merge2()} mais dans chacun des tableaux sources, ceux de
   * $arrays, ignorer les valeurs null et false.
   */
  static final function merge_nz2(&$array, ...$arrays): void {
    self::ensure_array($array);
    foreach ($arrays as $merge) {
      if ($merge === false || $merge === null) continue;
      foreach (self::with($merge) as $key => $value) {
        if ($value === null || $value === false) continue;
        $array[$key] = $value;
      }
    }
  }

  /**
   * comme {@link merge()} mais pour chacun des tableaux sources, ceux de
   * $arrays, ne fusionner les valeurs dans la destination $array que si la clé
   * n'y existe pas
   */
  static final function update_nx(&$array, ...$arrays): void {
    self::ensure_array($array);
    if ($arrays) {
      $updates = [$array];
      foreach ($arrays as $tmp) {
        if ($tmp === false || $tmp === null) continue;
        $update = [];
        foreach (self::with($tmp) as $key => $value) {
          if (!array_key_exists($key, $array)) {
            $update[$key] = $value;
          }
        }
        $updates[] = $update;
      }
      $array = array_merge(...$updates);
    }
  }

  /**
   * comme {@link merge2()} mais pour chacun des tableaux sources, ceux de
   * $arrays, ne fusionner les valeurs dans la destination $array que si la clé
   * n'y existe pas
   *
   * NB: il s'agit de la définition du l'opérateur union. l'implémentation fait
   * d'ailleurs usage de cet opérateur
   */
  static final function update_nx2(&$array, ...$arrays): void {
    self::ensure_array($array);
    foreach ($arrays as $update) {
      if ($update === null || $update === false) continue;
      $array += self::with($update);
    }
  }

  /**
   * comme {@link merge()} mais pour chacun des tableaux sources, ceux de
   * $arrays, ne fusionner les valeurs dans la destination $array que si la clé
   * n'y existe pas ou, si elle y existe, que la valeur y est null
   */
  static final function update_n(&$array, ...$arrays): void {
    self::ensure_array($array);
    if ($arrays) {
      $updates = [$array];
      foreach ($arrays as $tmp) {
        if ($tmp === false || $tmp === null) continue;
        $update = [];
        foreach (self::with($tmp) as $key => $value) {
          if (!array_key_exists($key, $array)) {
            $update[$key] = $value;
          } elseif ($array[$key] === null) {
            $update[$key] = $value;
          }
        }
        $updates[] = $update;
      }
      $array = array_merge(...$updates);
    }
  }

  /**
   * comme {@link merge2()} mais pour chacun des tableaux sources, ceux de
   * $arrays, ne fusionner les valeurs dans la destination $array que si la clé
   * n'y existe pas ou, si elle y existe, que la valeur y est null
   */
  static final function update_n2(&$array, ...$arrays): void {
    self::ensure_array($array);
    foreach ($arrays as $update) {
      if ($update === false || $update === null) continue;
      foreach (self::with($update) as $key => $value) {
        if (!array_key_exists($key, $array)) {
          $array[$key] = $value;
        } elseif ($array[$key] === null) {
          $array[$key] = $value;
        }
      }
    }
  }

  /**
   * comme {@link merge()} mais pour chacun des tableaux sources, ceux de
   * $arrays, ne fusionner les valeurs dans la destination $array que si la clé
   * n'y existe pas ou, si elle y existe, que la valeur y est null ou false
   */
  static final function update_z(&$array, ...$arrays): void {
    self::ensure_array($array);
    if ($arrays) {
      $updates = [$array];
      foreach ($arrays as $tmp) {
        if ($tmp === false || $tmp === null) continue;
        $update = [];
        foreach (self::with($tmp) as $key => $value) {
          if (!array_key_exists($key, $array)) {
            $update[$key] = $value;
          } else {
            $rvalue = $array[$key];
            if ($rvalue === null || $rvalue === false) {
              $update[$key] = $value;
            }
          }
        }
        $updates[] = $update;
      }
      $array = array_merge(...$updates);
    }
  }

  /**
   * comme {@link merge2()} mais pour chacun des tableaux sources, ceux de
   * $arrays, ne fusionner les valeurs dans la destination $array que si la clé
   * n'y existe pas ou, si elle y existe, que la valeur y est null ou false
   */
  static final function update_z2(&$array, ...$arrays): void {
    self::ensure_array($array);
    foreach ($arrays as $tomerge) {
      if ($tomerge === false || $tomerge === null) continue;
      foreach (self::with($tomerge) as $key => $value) {
        if (!array_key_exists($key, $array)) {
          $array[$key] = $value;
        } else {
          $rvalue = $array[$key];
          if ($rvalue === null || $rvalue === false) {
            $array[$key] = $value;
          }
        }
      }
    }
  }

  #############################################################################
  ## get

  /** obtenir le premier élément du tableau */
  static final function first(?array $array, $default=null) {
    if (!$array) return $default;
    else return $array[array_key_first($array)];
  }

  /** obtenir le second élément du tableau */
  static final function second(?array $array, $default=null) {
    if (!$array) return $default;
    $first = true;
    foreach ($array as $value) {
      if ($first) $first = false;
      else return $value;
    }
    return $default;
  }

  /**
   * obtenir le n-ième élément du tableau, en commençant à 0 (i.e 0=premier,
   * 1=second, etc.)
   */
  static final function nth(?array $array, int $index, $default=null) {
    if (!$array) return $default;
    $i = 0;
    foreach ($array as $value) {
      if ($index == $i) return $value;
      $i++;
    }
    return $default;
  }

  /** obtenir la première clé du tableau */
  static final function first_key(?array $array, $default_key=null) {
    if (!$array) return $default_key;
    else return array_key_first($array);
  }

  /** obtenir la seconde clé du tableau */
  static final function second_key(?array $array, $default_key=null) {
    if (!$array) return $default_key;
    $first = true;
    foreach (array_keys($array) as $key) {
      if ($first) $first = false;
      else return $key;
    }
    return $default_key;
  }

  /**
   * obtenir la clé du n-ième élément du tableau, en commençant à 0 (i.e
   * 0=premier, 1=second, etc.)
   */
  static final function nth_key(?array $array, int $index, $default_key=null) {
    if (!$array) return $default_key;
    $i = 0;
    foreach (array_keys($array) as $key) {
      if ($index == $i) return $key;
      $i++;
    }
    return $default_key;
  }

  /** obtenir le dernier élément du tableau */
  static final function last(?array $array, $default=null) {
    if (!$array) return $default;
    else return $array[array_key_last($array)];
  }

  /** obtenir la dernière clé du tableau */
  static final function last_key(?array $array, $default_key=null) {
    if (!$array) return $default_key;
    else return array_key_last($array);
  }

  /**
   * si $array est un tableau séquentiel avec un seul élément, retourner cet élément.
   * si c'est un tableau vide ou null retourner $default
   * sinon retourner le tableau inchangé
   */
  static final function one_or_array(?array $array, $default=null) {
    if (!$array) {
      return $default;
    } elseif (count($array) == 1 && array_key_exists(0, $array)) {
      return $array[0];
    } else {
      return $array;
    }
  }

  /**
   * retourner un tableau avec pour chaque tableau $array de $arrays, la valeur
   * de get($array, $key, $default)
   */
  static final function each_get(?array $arrays, $key, $default=null): array {
    $values = [];
    foreach ($arrays as $index => $array) {
      $values[$index] = self::get($array, $key, $default);
    }
    return $values;
  }

  #############################################################################
  ## set

  /**
   * Mettre à jour la clé $key avec $value si $value !== null
   *
   * si aucune modification ne doit se faire, $array n'est pas modifié
   *
   * Retourner la valeur effective de la clé (qu'elle aie été mise à jour ou
   * non)
   */
  static final function set_nn(&$array, $key, $value) {
    if ($value !== null) {
      self::ensure_array($array);
      self::set($array, $key, $value);
      return $value;
    } else {
      return self::get($array, $key);
    }
  }

  /**
   * Mettre à jour la clé $key avec $array[$key_indirect] si cette valeur ne
   * vaut pas null
   *
   * Retourner la valeur effective de la clé (qu'elle aie été mise à jour ou
   * non)
   */
  static final function set_nn_indirect(&$array, $key, $key_indirect) {
    self::ensure_narray($array);
    $value = self::get($array, $key_indirect);
    return self::set_nn($array, $key, $value);
  }

  /**
   * Mettre à jour la clé $key avec $value si $value ne vaut ni null ni false
   *
   * si aucune modification ne doit se faire, $array n'est pas modifié
   *
   * Retourner la valeur effective de la clé (qu'elle aie été mise à jour ou
   * non)
   */
  static final function set_nz(&$array, $key, $value) {
    if ($value !== false && $value !== null) {
      self::set($array, $key, $value);
      return $value;
    } else {
      return self::get($array, $key);
    }
  }

  /**
   * Mettre à jour la clé $key avec $array[$key_indirect] si cette valeur ne
   * vaut ni null ni false
   *
   * Retourner la valeur effective de la clé (qu'elle aie été mise à jour ou
   * non)
   */
  static final function set_nz_indirect(&$array, $key, $key_indirect) {
    self::ensure_narray($array);
    $value = self::get($array, $key_indirect);
    return self::set_nz($array, $key, $value);
  }

  /**
   * Ajouter la valeur avec la clé spécifiée si elle n'existe pas déjà
   *
   * si aucune modification ne doit se faire, $array n'est pas modifié
   *
   * Retourner la valeur effective de la clé (qu'elle aie été mise à jour ou
   * non)
   */
  static final function replace_nx(&$array, $key, $value) {
    if (!is_array($array) || !array_key_exists($key, $array)) {
      self::set($array, $key, $value);
      return $value;
    } else {
      return self::get($array, $key);
    }
  }

  /**
   * Mettre à jour la clé $key avec $value si la clé $key n'existe pas ou si sa
   * valeur actuelle est null.
   *
   * Retourner la valeur effective de la clé (qu'elle aie été mise à jour ou
   * non)
   */
  static final function replace_n(&$array, $key, $value) {
    self::ensure_narray($array);
    $rvalue = self::get($array, $key);
    if ($rvalue === null) {
      self::set($array, $key, $value);
      $rvalue = $value;
    }
    return $rvalue;
  }

  /**
   * Mettre à jour la clé $key avec $array[$key_indirect] si cette clé n'existe
   * pas ou si sa valeur actuelle est null.
   *
   * Retourner la valeur effective de la clé (qu'elle aie été mise à jour ou
   * non)
   */
  static final function replace_n_indirect(&$array, $key, $key_indirect) {
    self::ensure_narray($array);
    $rvalue = self::get($array, $key);
    if ($rvalue === null) {
      $value = self::get($array, $key_indirect);
      self::set($array, $key, $value);
      $rvalue = $value;
    }
    return $rvalue;
  }

  /**
   * Mettre à jour la clé $key avec $value si la clé $key n'existe pas ou si sa
   * valeur actuelle est null ou false.
   *
   * Retourner la valeur effective de la clé (qu'elle aie été mise à jour ou
   * non)
   */
  static final function replace_z(&$array, $key, $value) {
    self::ensure_narray($array);
    $rvalue = self::get($array, $key);
    if ($rvalue === false || $rvalue === null) {
      self::set($array, $key, $value);
      $rvalue = $value;
    }
    return $rvalue;
  }

  /**
   * Mettre à jour la clé $key avec $array[$key_indirect] si cette clé n'existe
   * pas ou si sa valeur actuelle est null ou false.
   *
   * Retourner la valeur effective de la clé (qu'elle aie été mise à jour ou
   * non)
   */
  static final function replace_z_indirect(&$array, $key, $key_indirect) {
    self::ensure_narray($array);
    $rvalue = self::get($array, $key);
    if ($rvalue === false || $rvalue === null) {
      $value = self::get($array, $key_indirect);
      self::set($array, $key, $value);
      $rvalue = $value;
    }
    return $rvalue;
  }

  /**
   * Ajouter $value à la fin de $array
   *
   * Retourner la valeur ajoutée
   */
  static final function append(&$array, $value) {
    self::ensure_array($array);
    $array[] = $value;
    return $value;
  }

  /**
   * Si $value n'est pas null, ajouter $value à la fin de $array
   *
   * si aucune modification ne doit se faire, $array n'est pas modifié
   *
   * Retourner la valeur ajoutée, ou null si la valeur n'a pas été ajoutée
   */
  static final function append_nn(&$array, $value) {
    if ($value !== null) {
      self::ensure_array($array);
      $array[] = $value;
      return $value;
    } else {
      return null;
    }
  }

  /**
   * Si $value ne vaut ni null ni false, ajouter $value à la fin de $array
   *
   * si aucune modification ne doit se faire, $array n'est pas modifié
   *
   * Retourner la valeur ajoutée, ou null si la valeur n'a pas été ajoutée
   */
  static final function append_nz(&$array, $value) {
    if (base::nz($value)) {
      self::ensure_array($array);
      $array[] = $value;
      return $value;
    } else {
      return null;
    }
  }

  /**
   * Insérer $value au début de $array
   *
   * Retourner la valeur insérée
   */
  static final function prepend(&$array, $value) {
    self::ensure_array($array);
    array_unshift($array, $value);
    return $value;
  }

  /**
   * Si $value n'est pas null, insérer $value au début de $array
   *
   * si aucune modification ne doit se faire, $array n'est pas modifié
   *
   * Retourner la valeur ajoutée, ou null si la valeur n'a pas été ajoutée
   */
  static final function prepend_nn(&$array, $value) {
    if ($value !== null) {
      self::ensure_array($array);
      array_unshift($array, $value);
      return $value;
    } else {
      return null;
    }
  }

  /**
   * Si $value ne vaut ni null ni false, insérer $value au début de $array
   *
   * si aucune modification ne doit se faire, $array n'est pas modifié
   *
   * Retourner la valeur ajoutée, ou null si la valeur n'a pas été ajoutée
   */
  static final function prepend_nz(&$array, $value) {
    if (base::nz($value)) {
      self::ensure_array($array);
      array_unshift($array, $value);
      return $value;
    } else {
      return null;
    }
  }

  /**
   * dans le tableau séquentiel $array, insérer $value à la position $index et
   * décaler toutes les autres clés
   *
   * Retourner la valeur insérée
   */
  static final function insert(&$array, $index, $value) {
    self::ensure_array($array);
    $count = count($array);
    if ($count == 0 || $index >= $count) {
      $array[] = $value;
    } else {
      while ($index < 0) $index += $count;
      if ($index == 0) $prefix = [];
      else $prefix = array_slice($array, 0, $index);
      $suffix = array_slice($array, $index);
      $array = array_merge($prefix, [$value], $suffix);
    }
    return $value;
  }

  /** Ajouter une valeur dans le tableau, pour utilisation avec pop() */
  static final function push(&$array, $value): void {
    self::ensure_array($array);
    $array[] = $value;
  }

  /**
   * enlever la dernière valeur ajoutée dans le tableau avec push() et la
   * retourner
   */
  static final function pop(&$array, $default=null) {
    self::ensure_array($array);
    $count = count($array);
    if ($count > 0) {
      $value = array_pop($array);
    } else {
      $value = $default;
    }
    return $value;
  }

  #############################################################################
  ## del

  static final function del_value(&$array, $value, int $max_count=1, bool $strict=false): int {
    if ($array === null || $array === false) return 0;
    self::ensure_array($array);
    $count = 0;
    $rekey = null;
    while ($max_count <= 0 || $count < $max_count) {
      $key = array_search($value, $array, $strict);
      if ($key === false) break;
      # s'il faut supprimer des clés, vérifier d'abord si c'est un tableau
      # séquentiel, afin de refaire la numérotation le cas échéant
      if ($rekey === null) $rekey = self::is_seq($array);
      unset($array[$key]);
      $count++;
    }
    if ($rekey) $array = array_values($array);
    return $count;
  }

  static final function del_first_key(&$array, int $max_count=1): int {
    if ($array === null || $array === false) return 0;
    self::ensure_array($array);
    $count = 0;
    $rekey = null;
    while ($max_count <= 0 || $count < $max_count) {
      $key = array_key_first($array);
      if ($key === null) break;
      # s'il faut supprimer des clés, vérifier d'abord si c'est un tableau
      # séquentiel, afin de refaire la numérotation le cas échéant
      if ($rekey === null) $rekey = self::is_seq($array);
      unset($array[$key]);
      $count++;
    }
    if ($rekey) $array = array_values($array);
    return $count;
  }

  static final function del_last_key(&$array, int $max_count=1): int {
    if ($array === null || $array === false) return 0;
    self::ensure_array($array);
    $count = 0;
    while ($max_count <= 0 || $count < $max_count) {
      $key = array_key_last($array);
      if ($key === null) break;
      unset($array[$key]);
      $count++;
    }
    return $count;
  }

  static final function del_keys(&$array, ...$keys): void {
    if ($array === null || $array === false) return;
    self::ensure_array($array);
    foreach ($keys as $key) {
      unset($array[$key]);
    }
  }

  #############################################################################
  ## getdel

  /**
   * obtenir la valeur correspondant à la clé $key, ou $default si elle n'est
   * pas trouvée. puis supprimer la clé du tableau
   */
  static final function getdel(&$array, $key, $default=null) {
    self::ensure_array($array);
    $value = self::get($array, $key, $default);
    unset($array[$key]);
    return $value;
  }

  /**
   * obtenir les valeurs correspondantes aux clés $keys sous forme de tableau
   * séquentiel. supprimer les clés du tableau
   */
  static final function getdels(&$array, ?array $keys): array {
    self::ensure_array($array);
    $values = [];
    if ($keys !== null) {
      foreach ($keys as $key) {
        $values[] = self::get($array, $key);
        unset($array[$key]);
      }
    }
    return $values;
  }

  #############################################################################
  ## Chemins de clé

  /**
   * vérifier que le chemin $keys fourni sous forme de tableau existe dans le
   * tableau $array
   *
   * si $keys est vide ou null, retourner true
   */
  static final function _phas(?array $array, ?array $keys): bool {
    $first = true;
    foreach($keys as $key) {
      if ($key === "" && $first) {
        # une chaine vide en première position est ignorée
        continue;
      } elseif (is_array($array)) {
        if (!array_key_exists($key, $array)) return false;
        $array = $array[$key];
      } elseif ($array instanceof ArrayAccess) {
        if (!$array->offsetExists($key)) return false;
        $array = $array->offsetGet($key);
      } else {
        return false;
      }
      $first = false;
    }
    return true;
  }

  /**
   * Vérifier que le chemin $keys qui est de la forme key[.keys...] existe
   * dans le tableau $array
   *
   * si $keys === null, retourner true
   */
  static final function phas_s(?array $array, ?string $keys): bool {
    if ($keys === null) return true;
    $keys = explode(".", $keys);
    return self::_phas($array, $keys);
  }

  /**
   * Vérifier que le chemin $keys fourni sous forme de tableau existe dans le
   * tableau $array
   *
   * si $keys est nul ou vide, retourner true
   */
  static final function phas_a(?array $array, ?array $keys): bool {
    if (!$keys) return true;
    $keys = implode(".", $keys);
    $keys = explode(".", $keys);
    return self::_phas($array, $keys);
  }

  /** vérifier que le chemin $keys existe dans le tableau $array */
  static final function phas($array, $keys): bool {
    if ($keys === null) return true;
    elseif (is_array($keys)) return self::phas_a($array, $keys);
    else return self::phas_s($array, strval($keys));
  }

  /**
   * Parcourir les enfants de $array avec le chemin $keys fourni sous forme de
   * tableau et retourner la valeur correspondante
   *
   * si $keys est vide ou null, retourner $default
   */
  static final function _pget(?array $array, ?array $keys, $default=null) {
    if (!$keys) return $default;
    $value = $array;
    $first = true;
    foreach($keys as $key) {
      if ($key === "" && $first) {
        # une chaine vide en première position est ignorée
        continue;
      } elseif (is_array($value)) {
        if (!array_key_exists($key, $value)) return $default;
        $value = $value[$key];
      } elseif ($value instanceof ArrayAccess) {
        if (!$value->offsetExists($key)) return $default;
        $value = $value->offsetGet($key);
      } else {
        return $default;
      }
      $first = false;
    }
    return $value;
  }

  /**
   * Parcourir les enfants de $array avec le chemin $keys qui est de la forme
   * key[.keys...] et retourner la valeur correspondante
   *
   * si $keys === null, retourner $default
   */
  static final function pget_s(?array $array, ?string $keys, $default=null) {
    if ($keys === null) return $default;
    $keys = explode(".", $keys);
    return self::_pget($array, $keys, $default);
  }

  /**
   * Parcourir les enfants de $array avec le chemin $keys fourni sous forme de
   * tableau et retourner la valeur correspondante
   *
   * si $keys est nul ou vide, retourner $default
   */
  static final function pget_a(?array $array, ?array $keys, $default=null) {
    if (!$keys) return $default;
    $keys = implode(".", $keys);
    $keys = explode(".", $keys);
    return self::_pget($array, $keys, $default);
  }

  /** obtenir la valeur correspondant au chemin $keys dans $array */
  static final function pget($array, $keys, $default=null) {
    if ($keys === null) return $default;
    elseif (is_array($keys)) return self::pget_a($array, $keys, $default);
    else return self::pget_s($array, strval($keys), $default);
  }

  /**
   * Modifier la valeur au chemin $keys fourni sous forme de tableau
   *
   * utiliser la clé "" (chaine vide) en dernière position pour rajouter à la fin, e.g
   * - _pset($array, [""], $value) est équivalent à $array[] = $value
   * - _pset($array, ["a", "b", ""], $value) est équivalent à $array["a"]["b"][] = $value
   * la clé "" n'a pas de propriété particulière quand elle n'est pas en dernière position
   *
   * si $keys est vide ou null, $array est remplacé par $value
   */
  static final function _pset(&$array, ?array $keys, $value): void {
    if (!$keys) {
      $array = $value;
      return;
    }
    self::ensure_array($array);
    $current =& $array;
    $last = count($keys) - 1;
    $i = 0;
    foreach ($keys as $key) {
      if ($i == $last) break;
      if ($current instanceof ArrayAccess) {
        if (!$current->offsetExists($key)) $current->offsetSet($key, []);
        $current =& $current->offsetGet($key);
        if ($current === null) {
          $current = [];
        } elseif (!is_array($current) && !($current instanceof ArrayAccess)) {
          $current = [$current];
        }
      } else {
        self::ensure_array($current[$key]);
        $current =& $current[$key];
      }
      $i++;
    }

    if ($key === "") $current[] = $value;
    else $current[$key] = $value;
  }

  /**
   * Modifier la valeur au chemin $keys qui est de la forme key[.keys...]
   *
   * utiliser la clé "" (chaine vide) en dernière position pour rajouter à la fin, e.g
   * - pset($array, "", $value) est équivalent à $array[] = $value
   * - pset($array, "a.b.", $value) est équivalent à $array["a"]["b"][] = $value
   * la clé "" n'a pas de propriété particulière quand elle n'est pas en dernière position
   *
   * si $keys est null, $array est remplacé par $value
   */
  static final function pset_s(&$array, ?string $keys, $value): void {
    if ($keys === null) {
      $array = $value;
    } else {
      $keys = explode(".", $keys);
      self::_pset($array, $keys, $value);
    }
  }

  /**
   * Modifier la valeur au chemin $keys fourni sous forme de tableau
   *
   * utiliser la clé "" (chaine vide) en dernière position pour rajouter à la fin, e.g
   * - pset($array, "", $value) est équivalent à $array[] = $value
   * - pset($array, "a.b.", $value) est équivalent à $array["a"]["b"][] = $value
   * la clé "" n'a pas de propriété particulière quand elle n'est pas en dernière position
   *
   * si $keys est null, $array est remplacé par $value
   */
  static final function pset_a(&$array, ?array $keys, $value): void {
    if (!$keys) {
      $array = $value;
    } else {
      $keys = implode(".", $keys);
      $keys = explode(".", $keys);
      self::_pset($array, $keys, $value);
    }
  }

  /** modifier la valeur au chemin de clé $keys dans le tableau $array */
  static final function pset(&$array, $keys, $value): void {
    if ($keys === null) $array = $value;
    elseif (is_array($keys)) self::pset_a($array, $keys, $value);
    else self::pset_s($array, strval($keys), $value);
  }

  /**
   * supprimer la valeur au chemin $keys fourni sous forme de tableau
   *
   * si $array vaut null ou false, sa valeur est inchangée.
   * $keys est vide ou null, $array devient null
   */
  static final function _pdel(&$array, ?array $keys): void {
    if ($array === false || $array === null) return;
    if (!$keys) {
      $array = null;
      return;
    }
    self::ensure_array($array);
    $current =& $array;
    $last = count($keys) - 1;
    $i = 0;
    foreach ($keys as $key) {
      if ($i == $last) break;
      if ($current instanceof ArrayAccess) {
        if (!$current->offsetExists($key)) break;
      } elseif (is_array($current)) {
        if (!self::has($current, $key)) break;
      } else {
        break;
      }
      $current =& $current[$key];
      $i++;
    }
    if ($i == $last) {
      if ($current instanceof ArrayAccess) {
        $current->offsetUnset($key);
      } elseif (is_array($current)) {
        unset($current[$key]);
      }
    }
  }

  /**
   * supprimer la valeur au chemin $keys qui est de la forme key[.keys...]
   *
   * si $array vaut null ou false, sa valeur est inchangée.
   * si $keys est null, $array devient null
   */
  static final function pdel_s(&$array, ?string $keys): void {
    if ($array === false || $array === null) return;
    if ($keys === null) {
      $array = null;
    } else {
      $keys = explode(".", $keys);
      self::_pdel($array, $keys);
    }
  }

  /**
   * supprimer la valeur au chemin $keys fourni sous forme de tableau
   *
   * si $array vaut null ou false, sa valeur est inchangée.
   * si $keys est vide ou null, $array devient null
   */
  static final function pdel_a(&$array, ?array $keys): void {
    if ($array === false || $array === null) return;
    if (!$keys) {
      $array = null;
    } else {
      $keys = implode(".", $keys);
      $keys = explode(".", $keys);
      self::_pdel($array, $keys);
    }
  }

  /** supprimer la valeur au chemin de clé $keys dans $array */
  static final function pdel(&$array, $keys): void {
    if ($array === false || $array === null) return;
    if ($keys === null) $array = null;
    elseif (is_array($keys)) self::pdel_a($array, $keys);
    else self::pdel_s($array, strval($keys));
  }

  #############################################################################
  ## map

  static final function map(?array $array, callable $func): ?array {
    if ($array === null) return null;
    return array_map($func, $array);
  }

  #############################################################################
  ## filter

  static final function filter_n(?array $array): ?array { return SL::filter_n($array); }
  static final function filter_z(?array $array): ?array { return SL::filter_z($array); }
  static final function filter_f(?array $array): ?array { return SL::filter_f($array); }
  static final function filter_f2(?array $array): ?array { return SL::filter_pf($array); }

  #############################################################################
  ## Tests sur les valeurs

  static final function any_v(?array $array, $value, bool $strict=true): bool {
    if ($strict) return SL::any_same($array, $value);
    else return SL::any_equals($array, $value);
  }
  static final function all_v(?array $array, $value, bool $strict=true): bool {
    if ($strict) return SL::all_same($array, $value);
    else return SL::all_equals($array, $value);
  }
  static final function any_nv(?array $array, $value, bool $strict=true): bool {
    if ($strict) return SL::any_not_same($array, $value);
    else return SL::any_not_equals($array, $value);
  }
  static final function all_nv(?array $array, $value, bool $strict=true): bool {
    if ($strict) return SL::all_not_same($array, $value);
    else return SL::all_not_equals($array, $value);
  }
  static final function any_z(?array $array): bool { return SL::any_z($array); }
  static final function all_z(?array $array): bool { return SL::all_z($array); }
  static final function any_nz(?array $array): bool { return SL::any_nz($array); }
  static final function all_nz(?array $array): bool { return SL::all_nz($array); }
  static final function any_n(?array $array): bool { return SL::any_n($array); }
  static final function all_n(?array $array): bool { return SL::all_n($array); }
  static final function any_nn(?array $array): bool { return SL::any_nn($array); }
  static final function all_nn(?array $array): bool { return SL::all_nn($array); }
  static final function any_f(?array $array): bool { return SL::any_f($array); }
  static final function all_f(?array $array): bool { return SL::all_f($array); }
  static final function any_t(?array $array): bool { return SL::any_t($array); }
  static final function all_t(?array $array): bool { return SL::all_t($array); }
  static final function any_f2(?array $array): bool { return SL::any_pf($array); }
  static final function all_f2(?array $array): bool { return SL::all_pf($array); }
  static final function any_t2(?array $array): bool { return SL::any_pt($array); }
  static final function all_t2(?array $array): bool { return SL::all_pt($array); }

  #############################################################################
  ## Fonctions avancées

  /** dans le tableau $array, "renommer" les clés selon le tableau $key_map */
  static function map_keys(?array &$array, ?array $key_map): void {
    if ($array === null || $key_map === null) return;
    foreach ($key_map as $from => $to) {
      if (array_key_exists($from, $array)) {
        $array[$to] = $array[$from];
        unset($array[$from]);
      }
    }
  }

  private static $flattener;

  /**
   * Applatir le tableau $array
   *
   * Pour chaque élément avec une clé séquentielle:
   * - si c'est un tableau, l'applatir puis rajouter ses éléments tels quels au
   * résultat
   * - sinon ajouter l'élément tel quel
   *
   * Pour chaque élément avec une clé associative:
   * - si la valeur n'existe pas déjà, elle est rajoutée telle quelle
   * - si la valeur source est null ou false, la valeur destination n'est pas
   * modifiée
   * - sinon, les deux valeurs sont transformées en tableau le cas échéant.
   * si $flattenValue == true, alors le tableau source est applati au préalable.
   * puis cette nouvelle valeur est fusionnée avec array_merge() dans la valeur
   * précédente.
   */
  static final function flatten(?array &$array, bool $flattenValue=true): void {
    if (self::$flattener === null) self::$flattener = new Flattener();
    self::$flattener->flatten($array, $flattenValue);
  }

  /** retourner le tableau $array applati */
  static final function flattened(?array $array, bool $flattenValue=true): array {
    self::flatten($array, $flattenValue);
    return $array;
  }

  /**
   * Extraire d'un tableau les clés séquentielles
   *
   * Retourner $seq où $seq est un tableau avec uniquement les valeurs des clés
   * séquentielles. S'il n'existe aucune clé séquentielle retourner $default.
   *
   * Par exemple: extract_seq(["a", "b" => "c"]) retourne ["a"]
   */
  static final function extract_seq(?array $array, ?array $default=null): ?array {
    $seq = null;
    if ($array !== null) {
      $index = 0;
      foreach ($array as $key => $value) {
        if ($key === $index) {
          $seq[] = $value;
          $index++;
        }
      }
    }
    if ($seq === null) $seq = $default;
    return $seq;
  }

  /**
   * Extraire d'un tableau les clés associatives
   *
   * Retourner une liste $assoc où $assoc est un tableau avec uniquement les
   * valeurs des clés associatives. S'il n'existe aucune clé associative,
   * retourner $default.
   *
   * Par exemple: split_assoc(["a", "b" => "c"]) retourne ["b" => "c"]
   */
  static final function extract_assoc(?array $array, ?array $default=null): ?array {
    $assoc = null;
    if ($array !== null) {
      $index = 0;
      foreach ($array as $key => $value) {
        if ($key === $index) $index++;
        else $assoc[$key] = $value;
      }
    }
    if ($assoc === null) $assoc = $default;
    return $assoc;
  }

  /**
   * Extraire d'un tableau les clés séquentielles et les clés associatives
   *
   * Retourner une liste [$seq, $assoc] où $seq est un tableau avec uniquement
   * les valeurs des clés séquentielles et $assoc est un tableau avec uniquement
   * les valeurs des clés associatives. S'il n'existe aucune clé séquentielle
   * (resp. aucune clé associative), $seq (resp. $assoc) vaut null.
   *
   * Par exemple: split_assoc(["a", "b" => "c"]) retourne [["a"], ["b" => "c"]]
   */
  static final function split_assoc(?array $array): array {
    $seq = null;
    $assoc = null;
    if ($array !== null) {
      $i = 0;
      foreach ($array as $key => $value) {
        if ($key === $i) {
          $seq[] = $value;
          $i++;
        } else {
          $assoc[$key] = $value;
        }
      }
    }
    return [$seq, $assoc];
  }

  /**
   * Joindre en un seul tableau un tableau avec des clés séquentielles et un
   * tableau avec des clés associatives.
   *
   * Si $seq_first==true, les clés séquentielles arrivent d'abord, ensuite les
   * clés associatives. Sinon, ce sont les clés associatives qui arrivent d'abord
   */
  static final function merge_assoc(?array &$array, ?array $seq, ?array $assoc, bool $seq_first=false): void {
    if ($seq === null && $assoc === null) $array = [];
    elseif ($seq === null) $array = $assoc;
    elseif ($assoc === null) $array = $seq;
    elseif ($seq_first) $array = array_merge($seq, $assoc);
    else $array = array_merge($assoc, $seq);
  }

  /**
   * Construire un sous-ensemble du tableau $array en sélectionnant les clés
   * mentionnées dans $keys
   * .. si $keys === null, retourner $array
   * .. sinon, $keys est un tableau avec des clés séquentielles ou associatives.
   * chacune des clés séquentielles est prise telle quelle. les clés associatives
   * permettent de renommer les clés
   *
   * soit $array = ["a" => 1, "b" => 2, "c" => 3]
   * alors select($array, ["a", "b" => "x"])
   * retourne ["a" => 1, "x" => 2]
   */
  static final function select(?array $array, ?array $keys, $default=null): array {
    if ($array === null) $array = [];
    if ($keys === null) return $array;

    $index = 0;
    $result = [];
    foreach ($keys as $key => $tkey) {
      if ($key === $index) {
        # clé séquentielle
        $value = self::get($array, $tkey, $default);
        $index++;
      } else {
        # clé associative
        $value = self::get($array, $key, $default);
      }
      $result[$tkey] = $value;
    }
    return $result;
  }

  /**
   * construire un sous-ensemble du tableau $array en sélectionnant les clés
   * mentionnées dans $keys.
   * .. si $keys === null, retourner $array
   * .. sinon, $keys est un tableau avec des clés séquentielles ou associatives.
   * pour chacune des clés séquentielles, la valeur est une clé pour récupérer
   * la valeur dans $array
   * pour chacune des clés associatives, la valeur est celle fournie
   */
  static final function select_replace(?array $array, ?array $keys, $default=null): array {
    if ($array === null) $array = [];
    if ($keys === null) return $array;

    $index = 0;
    $result = [];
    foreach ($keys as $key => $value) {
      if ($key === $index) {
        # clé séquentielle
        $result[$value] = self::get($array, $value, $default);
        $index++;
      } else {
        # clé associative
        $result[$key] = $value;
      }
    }
    return $result;
  }

  /**
   * comme {@link select_replace()} mais $keys est applati d'abord
   *
   * par exemple:
   * ~~~php
   * $src = ["a" => 1, "b" => 2, "c" => 3];
   * $dest = A::select($src, ["a", "x" => 9, ["z" => 8, "c"], "d"]);
   * # $dest === ["a" => 1, "x" => 9, "z" => 8, "c" => 3, "d" => null]
   * ~~~
   */
  static final function select_replace2(?array $array, ?array $keys, $default=null): array {
    if ($array === null) $array = [];
    if ($keys === null) return $array;
    self::flatten($keys);
    return self::select_replace($array, $keys, $default);
  }

  /**
   * construire un sous-ensemble du tableau $array en sélectionnant les clés
   * mentionnées dans $keys.
   * .. si $keys === null, retourner $array
   * .. sinon, $keys est un tableau avec des clés séquentielles ou associatives.
   * pour chacune des clés séquentielles, la valeur est une clé pour récupérer
   * la valeur dans $array
   * pour chacune des clés associatives, la valeur fournie est prise par défaut
   * si la valeur correspondante n'existe pas ou vaut false dans $array
   */
  static final function select_default(?array $array, ?array $keys, $default=null): array {
    if ($array === null) $array = [];
    if ($keys === null) return $array;

    $index = 0;
    $result = [];
    foreach ($keys as $key => $value) {
      if ($key === $index) {
        # clé séquentielle
        $result[$value] = self::get($array, $value, $default);
        $index++;
      } else {
        # clé associative
        if (array_key_exists($key, $array)) {
          $arrayValue = $array[$key];
          if ($arrayValue !== false) $value = $arrayValue;
        }
        $result[$key] = $value;
      }
    }
    return $result;
  }

  /**
   * comme {@link select_default()} mais $keys est applati d'abord
   *
   * par exemple:
   * ~~~php
   * $src = ["a" => 1, "b" => 2, "c" => 3];
   * $dest = A::select($src, ["a", "x" => 9, ["z" => 8, "c"], "d"]);
   * # $dest === ["a" => 1, "x" => 9, "z" => 8, "c" => 3, "d" => null]
   * ~~~
   */
  static final function select_default2(?array $array, ?array $keys, $default=null): array {
    if ($array === null) $array = [];
    if ($keys === null) return $array;
    self::flatten($keys);
    return self::select_default($array, $keys, $default);
  }

  /**
   * Construire un sous-ensemble du tableau $array en sélectionnant les clés
   * mentionnées dans $includes et pas mentionnées dans $excludes
   *
   * soit $array = ["a" => 1, "b" => 2, "c" => 3, "d" => 4]
   * alors xselect($array, ["a", "b" => "x"], ["d"])
   * retourne ["a" => 1, "x" => 2]
   */
  static final function xselect_keys(?array $array, ?array $includes, ?array $excludes, $default=null): array {
    if ($array === null) $array = [];
    if ($includes === null) {
      if ($excludes === null) return $array;
      else $includes = array_keys($array);
    }

    $index = 0;
    $result = [];
    foreach ($includes as $fromkey => $tokey) {
      if ($fromkey === $index) {
        # clé séquentielle
        $index++;
        $fromkey = $tokey;
      }
      if ($excludes !== null && in_array($fromkey, $excludes)) continue;
      $value = self::get($array, $fromkey, $default);
      $result[$tokey] = $value;
    }
    return $result;
  }

  /**
   * Construire un sous-ensemble du tableau $array en sélectionnant les valeurs
   * mentionnées dans $includes et pas mentionnées dans $excludes
   *
   * soit $array = ["a" => 1, "b" => 2, "c" => 3, "d" => 4]
   * alors xselect($array, ["a", "b" => "x"], ["d"])
   * retourne ["a" => 1, "x" => 2]
   */
  static final function xselect(?array $array, ?array $includes, ?array $excludes, $default=null): array {
    if ($array === null) $array = [];
    if ($includes === null && $excludes === null) return $array;

    $result = [];
    foreach ($array as $key => $value) {
      if ($excludes !== null && in_array($value, $excludes)) continue;
      if ($includes !== null && !in_array($value, $includes)) continue;
      $result[$key] = $value;
    }
    return $result;
  }
}
