<?php
namespace nur;

use nur\b\ValueException;

/**
 * Class SV: gestion de valeurs scalaires
 */
class SV {
  /** tester si $value vaut null ou false */
  static final function z($value): bool {
    return $value === false || $value === null;
  }

  /** tester si $value ne vaut ni null ni false */
  static final function nz($value): bool {
    return $value !== false && $value !== null;
  }

  /** tester si $value vaut null */
  static final function n($value): bool {
    return $value === null;
  }

  /** tester si $value n'est pas null */
  static final function nn($value): bool {
    return $value !== null;
  }

  /** tester si $value est vraie (y compris la chaine "0") */
  static final function t($value): bool {
    return $value || $value === "0";
  }
  
  /** tester si $value est fausse (cela n'inclue pas la chaine "0") */
  static final function f($value): bool {
    return !$value && $value !== "0";
  }

  /** tester si $value est vraie selon les règles de PHP. */
  static final function pt($value): bool {
    return boolval($value);
  }

  /** tester si $value est fausse selon les règles de PHP. */
  static final function pf($value): bool {
    return !$value;
  }

  /**
   * contruire une fonction qui retourne vrai si on lui passe en argument une
   * valeur égale à $value
   */
  static final function equals($value): callable {
    return function ($arg) use($value) { return $arg == $value; };
  }

  /**
   * contruire une fonction qui retourne vrai si on lui passe en argument une
   * valeur qui n'est pas égale à $value
   */
  static final function not_equals($value): callable {
    return function ($arg) use($value) { return $arg != $value; };
  }

  /**
   * contruire une fonction qui retourne vrai si on lui passe en argument une
   * valeur strictement égale à $value
   */
  static final function same($value): callable {
    return function ($arg) use($value) { return $arg === $value; };
  }

  /**
   * contruire une fonction qui retourne vrai si on lui passe en argument une
   * valeur qui n'est pas strictement égale à $value
   */
  static final function not_same($value): callable {
    return function ($arg) use($value) { return $arg !== $value; };
  }

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

  /** mettre à jour $dest avec $value si $cond($value) est vrai */
  static final function set_if(&$dest, $value, callable $cond) {
    if ($cond($value)) $dest = $value;
    return $dest;
  }
  static final function set_z(&$dest, $value) { return self::set_if($dest, $value, [self::class, "z"]);}
  static final function set_nz(&$dest, $value) { return self::set_if($dest, $value, [self::class, "nz"]);}
  static final function set_n(&$dest, $value) { return self::set_if($dest, $value, [self::class, "n"]);}
  static final function set_nn(&$dest, $value) { return self::set_if($dest, $value, [self::class, "nn"]);}
  static final function set_t(&$dest, $value) { return self::set_if($dest, $value, [self::class, "t"]);}
  static final function set_f(&$dest, $value) { return self::set_if($dest, $value, [self::class, "f"]);}
  static final function set_pt(&$dest, $value) { return self::set_if($dest, $value, [self::class, "pt"]);}
  static final function set_pf(&$dest, $value) { return self::set_if($dest, $value, [self::class, "pf"]);}

  #~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

  /** mettre à jour $dest avec $value si $cond($dest) est vrai */
  static final function update_if(&$dest, $value, callable $cond) {
    if ($cond($dest)) $dest = $value;
    return $dest;
  }
  static final function update_z(&$dest, $value) { return self::update_if($dest, $value, [self::class, "z"]);}
  static final function update_nz(&$dest, $value) { return self::update_if($dest, $value, [self::class, "nz"]);}
  static final function update_n(&$dest, $value) { return self::update_if($dest, $value, [self::class, "n"]);}
  static final function update_nn(&$dest, $value) { return self::update_if($dest, $value, [self::class, "nn"]);}
  static final function update_t(&$dest, $value) { return self::update_if($dest, $value, [self::class, "t"]);}
  static final function update_f(&$dest, $value) { return self::update_if($dest, $value, [self::class, "f"]);}
  static final function update_pt(&$dest, $value) { return self::update_if($dest, $value, [self::class, "pt"]);}
  static final function update_pf(&$dest, $value) { return self::update_if($dest, $value, [self::class, "pf"]);}

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

  /** retourner $value si elle est vraie (y compris la chaine "0"), false sinon */
  static final function vf($value) {
    return $value || $value === "0"? $value: false;
  }

  /** retourner $value si elle est vraie (y compris la chaine "0"), null sinon */
  static final function vn($value) {
    return $value || $value === "0"? $value: null;
  }

  /**
   * retourner la première valeur vraie (y compris la chaine "0")
   *
   * si toutes les valeurs sont fausses, retourner la dernière valeur de la
   * liste, ou null si la liste est vide
   */
  static final function firstv(...$values) {
    $value = null;
    foreach ($values as $value) {
      if ($value || $value === "0") return $value;
    }
    return $value;
  }

  /**
   * retourner la première valeur vraie selon les règles de PHP.
   *
   * si toutes les valeurs sont fausses, retourner la dernière valeur de la
   * liste, ou null si la liste est vide
   */
  static final function firstpv(...$values) {
    $value = null;
    foreach ($values as $value) {
      if ($value) return $value;
    }
    return $value;
  }

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

  /** vérifier si $value est un booléen, sinon retourner null */
  static final function check_bool($value): ?bool {
    return is_bool($value)? $value: null;
  }

  /** vérifier si $value est un integer, sinon retourner null */
  static final function check_int($value): ?int {
    return is_int($value)? $value: null;
  }

  /** vérifier si $value est un string, sinon retourner null */
  static final function check_string($value): ?string {
    return is_string($value)? $value: null;
  }

  /** vérifier si $value est un array, sinon retourner null */
  static final function check_array($value): ?array {
    return is_array($value)? $value: null;
  }

  /**
   * retourner [$int, $string] initialisés chacun en fonction du type de $value.
   * lever une exception si $value n'est d'aucun de ces types
   */
  static final function check_key($value, ?string $prefix=null, bool $throw_exception=true): array {
    $int = is_int($value)? $value : null;
    $string = is_string($value)? $value : null;
    if ($int === null && $string === null && $throw_exception) {
      throw ValueException::invalid_value($value, "key", $prefix);
    } else {
      return [$int, $string];
    }
  }

  /**
   * retourner [$bool, $string, $array] initialisés chacun en fonction du type
   * de $value. lever une exception si $value n'est d'aucun de ces types
   */
  static final function check_bsa($value, ?string $prefix=null, bool $throw_exception=true): array {
    $bool = is_bool($value)? $value : null;
    $string = is_string($value)? $value : null;
    $array = is_array($value)? $value : null;
    if ($bool === null && $string === null && $array === null && $throw_exception) {
      throw ValueException::invalid_value($value, "value", $prefix);
    } else {
      return [$bool, $string, $array];
    }
  }

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

  /** retourner -1, 0 ou 1 en fonction de l'ordre relatif entre $a et $b */
  static final function compare($a, $b): int {
    if ($a === $b) return 0;
    if ($a < $b) return -1;
    if ($a > $b) return 1;
    return 0;
  }

  /** comparer la longueur de $a et $b */
  static final function complen($a, $b): int {
    if (is_array($a)) $la = count($a);
    else $la = strlen(strval($a));
    if (is_array($b)) $lb = count($b);
    else $lb = strlen(strval($b));
    return SV::compare($la, $lb);
  }
}