<?php
namespace nulib\schema\_scalar;

use nulib\cl;
use nulib\ref\schema\ref_schema;
use nulib\ValueException;
use nulib\schema\Schema;
use nulib\schema\Wrapper;

/**
 * Class ScalarSchema
 */
class ScalarSchema extends Schema {
  /**
   * indiquer si $definition est une définition de schéma scalaire que
   * {@link normalize_definition()} pourrait normaliser
   */
  static function isa_definition($definition): bool {
    # chaine ou null
    if ($definition === null) return true;
    if (is_string($definition)) return true;
    if (!is_array($definition)) return false;
    # nature explicitement spécifiée
    if (array_key_exists("", $definition)) {
      $nature = $definition[""];
      if ($nature === "scalar") return true;
      if (is_array($nature)
        && array_key_exists(0, $nature)
        && $nature[0] === "scalar") {
        return true;
      }
      return false;
    }
    # un unique élément chaine à l'index 0
    $count = count($definition);
    $haveIndex0 = array_key_exists(0, $definition);
    if ($count == 1 && $haveIndex0
      && ($definition[0] === null || is_string($definition[0]))) {
      return true;
    }
    # un élément à l'index 0, et d'autres éléments
    return $haveIndex0 && $count > 1;
  }

  static function normalize_definition($definition, $definitionKey=null): array {
    $natureMetaschema = array_merge(ref_schema::NATURE_METASCHEMA, ref_schema::SCALAR_NATURE_METASCHEMA);
    self::_normalize_definition($definition, $definitionKey, $natureMetaschema);
    self::_ensure_nature($definition, "scalar");
    return $definition;
  }

  function __construct($definition=null, $definitionKey=null, bool $normalize=true) {
    if ($definition === null) $definition = static::SCHEMA;
    if ($normalize) {
      $definition = self::normalize_definition($definition, $definitionKey);
      $this->_definition = $definition;
      self::_ensure_type($definition);
      self::_ensure_schema_instances($definition);
    } else {
      # ici, $definition contient un schema déjà instancié, mais c'est le mieux
      # qu'on puisse faire
      $this->_definition = $definition;
    }
    $this->definition = $definition;
  }

  const KEYS = [];

  function getKeys(): array {
    return self::KEYS;
  }

  function getSchema($key=false): Schema {
    if ($key === false || $key === null || $key === "") return $this;
    throw ValueException::invalid_key($key);
  }

  protected function newWrapper(): ScalarWrapper {
    return new ScalarWrapper($this);
  }

  function getWrapper(&$value=null, $valueKey=null, ?array $params=null, ?Wrapper &$wrapper=null): ScalarWrapper {
    # si pas de valeur ni de wrapper, pas de vérification et donc pas d'exception
    # cf le code similaire dans ScalarWrapper::__construct()
    $dontAnalyze = $value === null && $wrapper === null;
    if (!($wrapper instanceof ScalarWrapper)) $wrapper = $this->newWrapper();

    # la nature du schéma peut contenir des paramètres par défaut
    $nature = $this->definition[""];
    foreach (array_keys(ref_schema::SCALAR_PARAMS_SCHEMA) as $paramKey) {
      $paramValue = $nature[$paramKey] ?? null;
      if ($paramValue !== null) $params[$paramKey] = $paramValue;
    }
    if ($params !== null) $wrapper->resetParams($params);

    return $wrapper->reset($value, $valueKey, $dontAnalyze? ["analyze" => false]: null);
  }
}