import { Injectable } from '@angular/core';
import { BehaviorSubject, Observable } from 'rxjs';
import { StorageService } from './storage.service';

/**
 * Service unifié de gestion des événements
 * Fusionne EventService, EventService et EventService
 */
@Injectable({
  providedIn: 'root',
})
export class EventService {
  // ========== Section courante (ancien EventService) ==========
  public current_section$ = new BehaviorSubject<string>('');

  // ========== Navigation contextuelle (ancien EventService) ==========
  public level$ = new BehaviorSubject<number>(1);

  // ========== Simulations (ancien EventService) ==========
  public volume_simulation$ = new BehaviorSubject<number>(0);
  public isChangeFromParent$ = new BehaviorSubject<boolean>(false);
  public current_form$ = new BehaviorSubject<Object>({});
  public simulations_ids$ = new BehaviorSubject<Object>({});

  constructor(public storage: StorageService) {}

  // ========== Méthodes pour section courante ==========

  /**
   * Définit la section courante
   */
  setCurrentSection(section: string): void {
    this.current_section$.next(section);
  }

  /**
   * Obtient la section courante
   */
  getCurrentSection(): string {
    return this.current_section$.value;
  }

  /**
   * Observable de la section courante
   */
  getCurrentSection$(): Observable<string> {
    return this.current_section$.asObservable();
  }

  // ========== Méthodes pour niveau contextuel ==========

  /**
   * Obtient la valeur actuelle du niveau de manière synchrone
   */
  getCurrentLevel(): number {
    return this.level$.value;
  }

  /**
   * Initialise le niveau à une valeur spécifique
   */
  initializeLevel(level: number): void {
    this.level$.next(level);
  }

  /**
   * Incrémente le niveau actuel
   */
  incrementLevel(): void {
    const currentLevel = this.getCurrentLevel();
    this.level$.next(currentLevel + 1);
  }

  /**
   * Décrémente le niveau actuel (minimum 1)
   */
  decrementLevel(): void {
    const currentLevel = this.getCurrentLevel();
    const newLevel = currentLevel <= 1 ? 1 : currentLevel - 1;
    this.level$.next(newLevel);
  }

  /**
   * Réinitialise le niveau à 1
   */
  resetLevel(): void {
    this.level$.next(1);
  }

  // ========== Méthodes pour simulations ==========

  /**
   * Définit le volume de simulation
   */
  setVolumeSimulation(volume: number): void {
    this.volume_simulation$.next(volume);
  }

  /**
   * Obtient le volume de simulation
   */
  getVolumeSimulation(): number {
    return this.volume_simulation$.value;
  }

  /**
   * Marque un changement depuis le parent
   */
  setChangeFromParent(value: boolean): void {
    this.isChangeFromParent$.next(value);
  }

  /**
   * Définit le formulaire courant
   */
  setCurrentForm(form: Object): void {
    this.current_form$.next(form);
  }

  /**
   * Obtient le formulaire courant
   */
  getCurrentForm(): Object {
    return this.current_form$.value;
  }

  /**
   * Définit les IDs de simulation
   */
  setSimulationsIds(ids: Object): void {
    this.simulations_ids$.next(ids);
  }

  /**
   * Obtient les IDs de simulation
   */
  getSimulationsIds(): Object {
    return this.simulations_ids$.value;
  }

  /**
   * Réinitialise toutes les données de simulation
   */
  resetSimulations(): void {
    this.volume_simulation$.next(0);
    this.isChangeFromParent$.next(false);
    this.current_form$.next({});
    this.simulations_ids$.next({});
  }
}
