type Provider<T> = (manager: DependencyManager) => Promise<T> | T;

type Modules = Map<string, {
  provider: Provider<any>;
  instance?: any;
}>;

export class DependencyManager {
  private modules: Modules = new Map();
  private resolving: Set<string> = new Set();

  // Enregistrer un module avec son initialisateur
  register<T>(name: string, provider: Provider<T>): void {
    if (this.modules.has(name)) {
      throw new Error(`Module ${name} is already registered.`);
    }
    this.modules.set(name, { provider });
  }

  // Résoudre un module et ses dépendances
  async resolve<T>(name: string): Promise<T> {
    const module = this.modules.get(name);
    if (!module) {
      throw new Error(`Module ${name} is not registered.`);
    }

    if (module.instance) {
      return module.instance;
    }

    if (this.resolving.has(name)) {
      throw new Error(`Circular dependency detected for module ${name}.`);
    }

    this.resolving.add(name);

    try {
      module.instance = await module.provider(this);
      return module.instance;
    } finally {
      this.resolving.delete(name);
    }
  }
}