import { useState , TState , getState, IState, listStates } from "thorium-states";
import { uuid , _HUID , ParentSegementId } from 'thorium-huid';

export type TStoreStateToken = `${string}-${string}-${string}-${string}-${string}`;

/** 
 * La variable `StoreStack` est une structure de données de type Map qui agit comme un registre central.
   Cette structure permet de stocker des contextes de magasins (store contexts) et d'y accéder
   efficacement. Les contextes de magasins contiennent des données organisées sous forme d'étiquettes
   et de valeurs, et peuvent être utilisés pour gérer des états dans une application.

   Exemple :
   Imaginez `StoreStack` comme un grand registre qui peut stocker des boîtes. Chaque boîte représente
   un contexte de magasin et contient des objets de données. Chaque boîte a une étiquette unique qui
   la distingue des autres. Grâce à ce registre, on peut facilement ajouter de nouvelles boîtes (créer
   de nouveaux contextes de magasins), récupérer des boîtes existantes (accéder aux contextes de magasins),
   ou retirer des boîtes (supprimer des contextes de magasins) en utilisant leurs étiquettes respectives
   (TStoreUUID). 
*/
const StoreStack:Map<TStoreUUID , IStoreContext> = new Map();

/** L'interface `IStoreState<T>` définit la structure d'un état d'un magasin. */
export interface IStoreState<T>{

  /** La propriété `token: TStoreStateToken;` dans l'interface `IStoreState<T>` est utilisée pour identifier de manière unique
  un objet d'état du magasin. Chaque objet d'état aura un jeton différent, permettant ainsi de les identifier et de les récupérer facilement.
  Par exemple, un jeton pourrait être un identifiant unique pour un utilisateur. */
  token:TStoreStateToken;

  /** La propriété `key: string;` dans l'interface `IStoreState<T>` est utilisée pour identifier un objet d'état spécifique au sein d'un contexte de magasin.
  Chaque objet d'état aura une clé unique, permettant ainsi de le repérer, de le mettre à jour ou de le supprimer dans le contexte du magasin.
  Par exemple, une clé pourrait être "utilisateurCourant". */
  key:string;

  /** La propriété `state: State<T>` dans l'interface `IStoreState<T>` est utilisée pour stocker la valeur d'un objet d'état du magasin.
  Le type `State<T>` représente la valeur actuelle et permet de s'abonner aux changements de cette valeur.
  Par exemple, cette propriété pourrait contenir l'état actuel d'un utilisateur, tel que ses informations personnelles. */
  state:TState<T>;

  /** La propriété `value: T;` dans l'interface `IStoreState<T>` est utilisée pour stocker la valeur actuelle de
  l'état dans un objet d'état de magasin. Elle représente le type de la valeur d'état, et permet d'accéder et de mettre à jour cette valeur dans le
  contexte du magasin. Par exemple, cette propriété pourrait contenir le nom d'un utilisateur. */
  value:T;

  /** La propriété `setter` dans l'interface `IStoreState<T>` est une fonction qui prend une valeur de type
  `T` et renvoie une valeur de type `T`. Elle est utilisée pour mettre à jour la valeur d'un objet d'état du magasin.
  Par exemple, vous pouvez utiliser cette fonction pour modifier les informations d'un utilisateur en fournissant de nouvelles informations. */
  setter(value:T):T;

  /** La ligne `subscribe: State<T>['subscribe'];` définit la propriété `subscribe` dans l'interface
  `IStoreState<T>`. Il fait référence à la méthode `subscribe` du type `State<T>`. 
  Par exemple, vous pouvez utiliser cette méthode pour vous abonner aux changements de l'état d'un utilisateur 
  et être notifié lorsque des modifications sont apportées. */
  subscribe:TState<T>['subscribe'];

  /** La ligne `unsubscribe: State<T>['unsubscribe'];` dans l'interface `IStoreState<T>` définit la
  propriété `unsubscribe`. Il fait référence à la méthode `unsubscribe` du type `State<T>`. 
  Par exemple, vous pouvez utiliser cette méthode pour annuler votre abonnement aux changements de 
  l'état d'un utilisateur si vous n'avez plus besoin de recevoir des notifications. */
  unsubscribe:TState<T>['unsubscribe'];

  /** La propriété `delete: State<T>['delete'];` est utilisée pour supprimer un objet d'état du magasin. Elle fait référence
  à la méthode `delete` du type `State<T>`. Par exemple, si vous souhaitez supprimer complètement l'état d'un utilisateur du contexte du magasin,
  vous pouvez utiliser cette méthode en fournissant la clé de l'utilisateur comme argument. */
  delete:TState<T>['delete'];
  
}

/** Le type `TStoreContextEvent` est une union de chaînes de caractères ('add', 'update', 'delete')
 * qui représente les événements possibles dans un contexte de magasin (store context). Ces événements
 * sont utilisés pour notifier les changements sur les données stockées dans le contexte du magasin.
 * Par exemple, lorsque de nouvelles données sont ajoutées ('add'), existantes sont mises à jour ('update'),
 * ou supprimées ('delete').
 *
 * ## Exemple :
 * ```typescript
 * const event: TStoreContextEvent = 'add';
 * ```
*/
export type TStoreContextEvent = 'add' | 'update' | 'delete';

/** L'interface `IStoreContext` définit la structure et les méthodes qu'un objet contexte de magasin devrait avoir. */
export interface IStoreContext{

  /** 
   * La propriété `uuid:TStoreUUID;` définit une propriété appelée `uuid` dans l'interface `IStoreContext`. Le type
   * de cette propriété est `TStoreUUID`, qui est une chaîne de caractères. Cette propriété est utilisée pour identifier
   * de manière unique un objet contexte de magasin.
  */
  uuid:TStoreUUID;

  /** 
   * La propriété `huid:_HUID;` définit une propriété appelée `huid` dans l'interface `IStoreContext`. Le type
   * de cette propriété est `_HUID`, qui est un identifiant unique hiérarchique. 
  */
  huid:_HUID;

  /** 
   * La propriété `unid:string;` définit une propriété appelée `unid` dans l'interface `IStoreContext`. Cette propriété
   * est une chaîne de caractères et est utilisée comme identifiant unique pour le contexte de magasin. Elle se compose
   * du `huid` et du `name`. 
  */
  unid:string;

  /** 
   * La propriété `name:string;` définit une propriété appelée `name` dans l'interface `IStoreContext`. Cette propriété
   * est une chaîne de caractères et représente le nom du contexte de magasin. 
  */
  name:string;

  /** 
   * La propriété `root:IStoreContext;` définit une propriété appelée `root` dans l'interface `IStoreContext`. Cette propriété
   * est de type `IStoreContext` et représente le contexte racine du magasin. 
  */
  root:IStoreContext;

  /** 
   * La propriété `states:IStoreState<any>[]` définit une propriété appelée `states` dans l'interface `IStoreContext`. Cette
   * propriété est un tableau d'objets de type `IStoreState<any>` et représente les états stockés dans le contexte de magasin. 
  */
  states:IStoreState<any>[]

  /** 
   * La méthode `keyList` dans l'interface `IStoreContext` est une fonction qui renvoie un tableau de chaînes de caractères. Cette
   * méthode est utilisée pour récupérer la liste de toutes les clés ou identifiants des valeurs d'état dans un contexte de magasin. Chaque
   * valeur d'état dans le contexte de magasin est associée à un jeton unique, et cette méthode vous permet d'obtenir toutes ces clés.
  */
  tokenList():TStoreStateToken[];

  /** 
   * La méthode `keyList` dans l'interface `IStoreContext` est une fonction qui renvoie un tableau de chaînes de caractères. Cette
   * méthode est utilisée pour récupérer la liste de toutes les clés ou identifiants des valeurs d'état dans un contexte de magasin. Chaque
   * valeur d'état dans le contexte de magasin est associée à une clé unique, et cette méthode vous permet d'obtenir toutes ces clés.
  */
  keyList():string[];

  /** 
   * La méthode `values` dans la classe `StoreContext` est une fonction qui renvoie un tableau d'objets `IStoreState<any>`. 
  */
  values():IStoreState<any>[];

  /** 
   * La méthode `set` dans la classe `StoreContext` est une méthode générique qui prend une `clé` de type `string` et une `valeur` de type `T`.
   * Elle est utilisée pour ajouter une nouvelle valeur d'état au contexte de magasin.
  */
  set<T>(key:string , value:T):IStoreState<T>;

  /** 
   * La méthode `get` dans la classe `StoreContext` prend un `identificateur` de type `string|TStoreStateToken` et renvoie un objet `IStoreState<T>`. 
  */
  get<T>( identificateur:string|TStoreStateToken ):IStoreState<T>;

  /** La méthode `update` dans la classe `StoreContext` prend un `identificateur` de type `string|TStoreStateToken` et une `valeur` de type `any`. */
  update( identificateur:string|TStoreStateToken , value:any ):any;

  /** La méthode `remove` dans la classe `StoreContext` prend un `identificateur` de type `string|TStoreStateToken`. */
  remove(identificateur:string|TStoreStateToken):any;

  /** 
   * La méthode `on` dans la classe `StoreContext` est utilisée pour enregistrer des écouteurs d'événements pour des
   * événements spécifiques dans le contexte de magasin. Elle prend deux paramètres : `event` et `callback`.
  */
  on(event:TStoreContextEvent , callback:(oldValue:any , newValue:any) => void):void;

  /** La méthode `extends` dans la classe `StoreContext` permet d'étendre le contexte de magasin actuel en créant un nouveau contexte avec le nom spécifié. */
  extends( contextName:string , options?:StoreContextOptions ):IStoreContext;

  /** La méthode `destroy` dans la classe `StoreContext` renvoie un booléen pour indiquer si la destruction du contexte a réussi. */
  destroy():boolean;

}

export interface StoreContextOptions{

  /** La propriété `parentStoreId?: _HUID;` est une option qui permet de spécifier l'identifiant du magasin parent, s'il existe. */
  parentStoreId?:_HUID;

  /** 
   * La propriété `ondelete?: (storeContext: IStoreContext, stateDeletionResult: boolean[]) => void;` est une option qui permet
   * de spécifier une fonction de rappel qui sera appelée lors de la suppression du contexte de magasin ou de ses états. Cette fonction
   * prend le contexte de magasin en cours et un tableau de résultats de suppression d'états en tant que paramètres.
  */
  ondelete?( storeContext:IStoreContext , stateDeletionResult:boolean[] ):void;

}

/** The `StoreContext` class is an implementation of the `IStoreContext` interface in TypeScript,
providing methods for managing a store of state values. */
// export class StoreContext implements IStoreContext{

//   /** The line `#_id:TStoreId = crypto.randomUUID();` is initializing a private instance variable `#_id`
//   with a randomly generated unique identifier using the `crypto.randomUUID()` function. The
//   `crypto.randomUUID()` function generates a random UUID (Universally Unique Identifier) string,
//   which is a 128-bit value that is guaranteed to be unique across all devices and time. The
//   `TStoreId` type represents the type of the unique identifier. By assigning the result of
//   `crypto.randomUUID()` to `#_id`, each instance of the `StoreContext` class will have a unique
//   identifier associated with it. */
//   #_id:TStoreId = crypto.randomUUID();
//   get id(){
//     return this.#_id;
//   };
//   #_huid = uuid.NIL;
//   get huid(){ return this.#_huid };
//   get parent(){ return storeContext().getParentContext( this.huid ) }
//   get children(){ return storeContext().getChildrenContext( this.huid ) }

//   get isDetatch(){ return ( !this.parent ? true : false ) }
//   get isRoot(){ return (this.huid == uuid.NIL ? true : false) }
//   get root(){ 
//     if(this.isRoot || this.isDetatch)return this;
//     else return this.parent.root;
//   }

//   /** The `#_events` property is a private instance variable in the `StoreContext` class. It is of type
//   `Record<TStoreContextEvent, ((x, y) => void) | null>`, which is a TypeScript type that represents
//   an object with keys of type `TStoreContextEvent` (which can be either `'add'`, `'update'`, or
//   `'delete'`) and values that are either a function that takes two parameters `(x, y)` and returns
//   `void`, or `null`. */
//   #_events:Record<TStoreContextEvent , ((x,y) => void) | null> = {
//     add : null,
//     update : null,
//     delete : null
//   };

//   /** The line `#_list:Map<TStoreStateToken , IStoreState<any>> = new Map();` is initializing a private
//   instance variable `#_list` with a new Map object. The Map object is a built-in data structure in
//   TypeScript that allows you to store key-value pairs. In this case, the keys are of type
//   `TStoreStateToken` and the values are of type `IStoreState<any>`. */
//   #_list:Map<TStoreStateToken , IStoreState<any>> = new Map();

//   constructor( options:StoreContextOptions = {} ){

//     if(options.parentStoreId)this.#_huid = options.parentStoreId.extend();

//   }

//   set = <T>(key:string , value:any):IStoreState<T> | void => {

//     if(this.keyList().includes(key)){
//       console.error(`${key} already existing in store`);
//       return ;
//     }

//     let [ state , setState ] = useState<T>(value);

//     let stateToken = crypto.randomUUID();

//     if(this.#_events['add'])this.#_events['add'](null , state.value);

//     this.#_list.set( stateToken , {
//       token:stateToken,
//       key,
//       state,
//       get value(){return state.value},
//       set value(value:T){setState(value)},
//       setter : ( value:T ) => { 
//         if(this.#_events['update'])this.#_events['update']( state.value , value);
//         return setState( value ) 
//       },
//       subscribe : state.subscribe,
//       unsubscribe : state.unsubscribe,
//     } )

//     return this.#_list.get(stateToken);

//   };

//   get = <T>( identificateur:string|TStoreStateToken ):IStoreState<T> => {

//     if(this.#_list.has(identificateur as TStoreStateToken)){
//       return this.#_list.get(identificateur as TStoreStateToken);
//     }
//     else{
//       return [...this.#_list.values()].reduce((result:IStoreState<any> , storeState:IStoreState<any>) => {

//         if(storeState.key == identificateur)result = storeState;
//         return result;

//       } , null);
//     }

//   };

//   update = ( identificateur:string|TStoreStateToken , value:any ) => {

//     if(this.#_list.has(identificateur as TStoreStateToken))return [this.#_list.set(identificateur as TStoreStateToken , value)];
//     else return [...this.#_list.values()].reduce((arr:IStoreState<any>[] , storeState:IStoreState<any>) => {

//       if(storeState.key == identificateur)arr.push((this.#_list as any).set(storeState.token as TStoreStateToken , value));
//       return arr;

//     } , []);

//   };

//   remove = (identificateur:string|TStoreStateToken) => {
//     if(this.#_list.has(identificateur as TStoreStateToken))return [this.#_list.delete(identificateur as TStoreStateToken)];
//     else{
//       return [...this.#_list.values()].reduce((arr:boolean[] , storeState:IStoreState<any>) => {

//         if(storeState.key == identificateur)arr.push((this.#_list as any).delete(storeState.token as TStoreStateToken));
//         return arr;

//       } ,  [])
//     }
//   };

//   tokenList = () => {
//     return [...this.#_list.keys()]
//   };

//   keyList = () => {
//     return this.values().reduce((arr:string[] , value:{key:string}) => {
//       arr.push(value.key);
//       return arr;
//     } , []) as string[];
//   };

//   values = () => {
//     return [...this.#_list.values()];
//   };
  
//   on = (event:TStoreContextEvent , callback:(oldValue:any , newValue:any) => void) => {
//     if(event in this.#_events)this.#_events[event] = callback;
//   };

//   extends(){
//     return storeContext().create( this.huid );
//   }

//   delete(){

//     console.log({ action : 'delete' , data : this , parent : storeContext().getParentContext( this.huid ) })

//   }

// }

export const StoreContextFactory = ( contextName:string , options:StoreContextOptions = {} ) => {

  let storeId = crypto.randomUUID();

  /** The `StoreContext` class is an implementation of the `IStoreContext` interface in TypeScript,
  providing methods for managing a store of state values. */
  return {
    storeId,
    store : class StoreContext implements IStoreContext{
  
      #_uuid:TStoreUUID = storeId;
      get uuid(){
        return this.#_uuid;
      };
      #_huid = uuid.NIL;
      get huid(){ return this.#_huid };
      get parent(){ return storeContext().getParentContext( this.huid ); }
      get children(){ return storeContext().getChildrenContext( this.huid ); }
      get name(){ return contextName; }
      get unid(){ return `${this.huid}-${this.name}`; }
    
      get isDetatch(){ return ( !this.parent ? true : false ) }
      get isRoot(){ return (this.huid == uuid.NIL ? true : false) }
      get root(){ 
        if(this.isRoot || this.isDetatch)return this;
        else return this.parent.root;
      }

      get states(){
        return Array.from( this.tokenList() , ( token ) => {
          return this.get<any>( token );
        } )
      }
    
      /** 
       * La propriété `#_events` est une variable privée de type `Record<TStoreContextEvent, ((x, y) => void) | null>`.
       * Cela signifie qu'elle représente un ensemble d'événements possibles dans le contexte du magasin, tels que 'add', 'update' ou 'delete'.
       * Chaque événement peut avoir une fonction de rappel qui prend deux paramètres `(x, y)` et retourne `void`, ou être nulle (null) s'il n'y a pas de rappel pour cet événement.
      */
      #_events:Record<TStoreContextEvent , ((x,y) => void) | null> = {
        add : null,
        update : null,
        delete : null
      };
      get events(){ return this.#_events }
    
     /** 
      * La variable privée `#_list` est initialisée avec une nouvelle instance de la structure de données Map.
      * En TypeScript, Map est un objet qui permet de stocker des données sous forme de paires clé-valeur.
      * Dans ce contexte, les clés sont de type `TStoreStateToken` et les valeurs sont de type `IStoreState<any>`.
      * Cette Map est utilisée pour stocker les états du magasin.
     */
      #_list:Map<TStoreStateToken , IStoreState<any>> = new Map();
      get list(){  return this.#_list; }
    
      constructor( ){
    
        if(options.parentStoreId)this.#_huid = options.parentStoreId.extend();
    
      }
    
      set<T>(key:string , value:any):IStoreState<T>{

        console.log('start set');
    
        if(this.keyList().includes(key)){
          console.error(`${key} already existing in store`);
          return ;
        }

        console.log('A');
    
        let [ state , setState ] = useState<T>(value);
        console.log({ state });
    
        let stateToken = (state.id as any);

        console.log('B');
    
        if(this.events['add'])this.events['add'](null , state.value);

        console.log('C');
    
        this.list.set( stateToken , {
          get token(){ return this.state.id },
          key,
          state,
          get value(){return state.value},
          set value(value:T){setState(value)},
          setter : ( value:T ) => { 
            if(this.events['update'])this.events['update']( state.value , value);
            return setState( value ) 
          },
          subscribe : state.subscribe,
          unsubscribe : state.unsubscribe,
          delete : () => { 
            this.list.delete( stateToken );
            state.delete( ) 
          }
        } )

        console.log('end set');
    
        return this.list.get(stateToken);
    
      };
    
      get<T>( identificateur:string|TStoreStateToken ):IStoreState<T>{
    
        if(this.#_list.has(identificateur as TStoreStateToken)){
          return this.#_list.get(identificateur as TStoreStateToken);
        }
        else{
          return [...this.#_list.values()].reduce((result:IStoreState<any> , storeState:IStoreState<any>) => {
    
            if(storeState.key == identificateur)result = storeState;
            return result;
    
          } , null);
        }
    
      };
    
      update( identificateur:string|TStoreStateToken , value:any ){
    
        if(this.#_list.has(identificateur as TStoreStateToken))return [this.#_list.set(identificateur as TStoreStateToken , value)];
        else return [...this.#_list.values()].reduce((arr:IStoreState<any>[] , storeState:IStoreState<any>) => {
    
          if(storeState.key == identificateur)arr.push((this.#_list as any).set(storeState.token as TStoreStateToken , value));
          return arr;
    
        } , []);
    
      };
    
      remove(identificateur:string|TStoreStateToken){
        if(this.#_list.has(identificateur as TStoreStateToken))return [this.#_list.delete(identificateur as TStoreStateToken)];
        else{
          return [...this.#_list.values()].reduce((arr:boolean[] , storeState:IStoreState<any>) => {
    
            if(storeState.key == identificateur)arr.push((this.#_list as any).delete(storeState.token as TStoreStateToken));
            return arr;
    
          } ,  [])
        }
      };
    
      tokenList(){
        return [...this.#_list.keys()]
      };
    
      keyList(){
        return this.values().reduce((arr:string[] , value:{key:string}) => {
          arr.push(value.key);
          return arr;
        } , []) as string[];
      };
    
      values(){
        return [...this.list.values()];
      };
      
      on(event:TStoreContextEvent , callback:(oldValue:any , newValue:any) => void){
        if(event in this.#_events)this.#_events[event] = callback;
      };
    
      extends( contextName:string , options:StoreContextOptions = {} ){

        return storeContext().create( contextName , { ...options , parentStoreId : this.huid } );

      }
    
      destroy(){

        let clear = Array.from( this.states , ( state ) => {
          return state.delete()
        });

        (options.ondelete ? options.ondelete( this , clear ) : null);

        return StoreStack.delete( this.uuid )

      }
    
    }
  }

}

export type TStoreUUID = `${string}-${string}-${string}-${string}-${string}`;

export interface IStoreContextAPI{

  /**
   * Crée un nouveau contexte de magasin avec le nom spécifié et les options facultatives.
   * @param contextName Le nom du contexte de magasin.
   * @param options (Facultatif) Les options pour la création du contexte.
   * @returns Le nouveau contexte de magasin créé.
   * ## Example
   * ```typescript
   * const newContext = storeContext().create("NouveauContext");
   * ```
  */
  create( contextName:string , options?:StoreContextOptions):TStoreContext;

  /**
   * Supprime un contexte de magasin existant avec l'UUID spécifié.
   * @param storeUuid L'UUID du contexte de magasin à supprimer.
   * @returns Vrai si le contexte de magasin a été supprimé avec succès, sinon faux.
   * ## Example
   * ```typescript
   * const uuidToDelete = "xxxxxxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx"; // Remplacez par l'UUID du contexte à supprimer.
   * const deleted = storeContext().delete(uuidToDelete);
   * ```
  */
  delete(storeUuid:TStoreUUID):boolean;

  /**
   * Récupère un contexte de magasin par son UUID.
   * @param storeUuid L'UUID du contexte de magasin à récupérer.
   * @returns Le contexte de magasin correspondant à l'UUID, ou null s'il n'existe pas.
   * ## Example
   * ```typescript
   * const uuidToRetrieve = "xxxxxxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx"; // Remplacez par l'UUID du contexte à récupérer.
   * const retrievedContext = storeContext().getContextById(uuidToRetrieve);
   * ```
  */
  getContextById( storeUuid:TStoreUUID  ):IStoreContext;

  /**
   * Récupère un contexte de magasin par son HUID (Hierarchical Unique Identifier).
   * @param storeHuid L'HUID du contexte de magasin à récupérer.
   * @returns Le contexte de magasin correspondant à l'HUID, ou null s'il n'existe pas.
   * ## Example
   * ```typescript
   * const huidToRetrieve = new _HUUID("xxxxxxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx") // Remplacez par l'HUID du contexte à récupérer.
   * const retrievedContext = storeContext().getContextByHuid(huidToRetrieve);
   * ```
  */
  getContextByHuid( storeHuid:_HUID ):IStoreContext;

  /**
   * Récupère un contexte de magasin par son UNID (Unique Identifier).
   * @param storeUnid L'UNID du contexte de magasin à récupérer.
   * @returns Le contexte de magasin correspondant à l'UNID, ou null s'il n'existe pas.
   * ## Example
   * ```typescript
   * const unidToRetrieve = "xxxxxxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx-MyContext"; // Remplacez par l'UNID du contexte à récupérer.
   * const retrievedContext = storeContext().getContextByUnid(unidToRetrieve);
   * ```
  */
  getContextByUnId( storeUnid:string ):IStoreContext;

  /**
   * Récupère tous les contextes de magasin avec le nom spécifié.
   * @param contextName Le nom des contextes de magasin à récupérer.
   * @returns Un tableau de tous les contextes de magasin correspondant au nom.
   * ## Example
   * ```typescript
   * const nameToRetrieve = "MyContext"; // Remplacez par le nom du contexte à récupérer.
   * const retrievedContexts = storeContext().getContextByName(nameToRetrieve);
   * ```
  */
  getContextByName( contextName:string):IStoreContext[];

  /**
   * Récupère le contexte parent d'un contexte de magasin par son HUID.
   * @param storeHuid L'HUID du contexte de magasin pour lequel vous souhaitez trouver le contexte parent.
   * @returns Le contexte parent correspondant à l'HUID, ou null s'il n'existe pas.
   * ## Example
   * ```typescript
   * const huidToFindParent = new _HUUID('xxxxxxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx'); // Remplacez par l'HUID du contexte fils.
   * const parentContext = storeContext().getParentContext(huidToFindParent);
   * ```
  */
  getParentContext( storeHuid:_HUID ):IStoreContext;

  /**
   * Récupère les contextes enfants d'un contexte de magasin par son HUID.
   * @param storeHuid L'HUID du contexte de magasin pour lequel vous souhaitez trouver les contextes enfants.
   * @returns Un tableau de contextes enfants correspondant à l'HUID.
   * ## Example
   * ```typescript
   * const huidToFindChildren = new _HUUID('xxxxxxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx'); // Remplacez par l'HUID du contexte parent.
   * const childrenContexts = storeContext().getChildrenContext(huidToFindChildren);
   * ```
  */
  getChildrenContext( storeHuid:_HUID ):IStoreContext[];

}

/** La fonction `storeContext` retourne une instance de l'interface `IStoreContextAPI` qui permet d'interagir avec les contextes de magasin. */
export function storeContext():IStoreContextAPI{

  return {
    create( contextName:string , options:StoreContextOptions = {}):TStoreContext{
      let { store , storeId } = StoreContextFactory( contextName , options );
      StoreStack.set( storeId , new store() as any );
      return (StoreStack as any).get( storeId );
    },
    delete(storeUuid:TStoreUUID){

      return StoreStack.has(storeUuid) ? (() => {

        let store = StoreStack.get( storeUuid );
        return store.destroy();

      })() : false;

    },
    getContextById( storeUuid:TStoreUUID ){
      return ( StoreStack.has( storeUuid ) ? StoreStack.get( storeUuid ) : null );
    },
    getContextByHuid( storeHuid ){

      return [...StoreStack.values()].reduce(( result , store:IStoreContext ) => {
        if( store.huid == storeHuid)result = store;
        return result;
      } , null);

    },
    getContextByUnId( storeUnid ){

      return [...StoreStack.values()].reduce(( result , store:IStoreContext ) => {
        if( store.unid == storeUnid)result = store;
        return result;
      } , null);

    },
    getContextByName( contextName ){

      return [...StoreStack.values()].reduce(( result , store:IStoreContext ) => {
        if( store.name == contextName)result.push(store);
        return result;
      } , []);

    },
    getParentContext( storeHuid ){

      let { parentId , componentId } = storeHuid;

      return [...StoreStack.values()].reduce(( result , store:IStoreContext ) => {
        if( store.huid.componentId == parentId && store.huid.componentId != componentId )result = store;
        return result;
      } , null)

    },
    getChildrenContext( storeHuid ){

      let { componentId } = storeHuid;

      let result = [...StoreStack.values()].reduce(( result:IStoreContext[] , store:IStoreContext ) => {
        if(store.huid.parentId == componentId )result.push( store );
        return result;
      } , []) as IStoreContext[];

      return result;

    }
  }

}

/** La fonction `listContext` affiche la liste des contextes de magasin sous forme de tableau dans la console. Elle extrait les valeurs de tous les contextes de magasin disponibles dans `StoreStack` et les affiche sous forme tabulaire. */
export function listContext(){
  console.table( [ ...StoreStack.values() ] );
}

console.log({ listContext })

export const createStoreContext = storeContext().create;
export const deleteStoreContext = storeContext().delete;

export type TStoreContext = IStoreContext;

function getTypeDeRetour<T extends string[]>(liste: T): T[number] {
  return liste[0]; // Remplacez par votre propre logique
}

const liste1 = ["option1", "option2", "option3", "option4"];
const resultat1: string = getTypeDeRetour( liste1 );

const liste2 = ["choixA", "choixB", "choixC"];
const resultat2: string = getTypeDeRetour(liste2);