package cz.davza.studentadventure.base;

import cz.davza.studentadventure.enums.CommandState;
import cz.davza.studentadventure.interfaces.IObservable;
import cz.davza.studentadventure.interfaces.IObserver;

import java.util.HashMap;
import java.util.HashSet;
import java.util.Map;
import java.util.Set;

// DU Z 12. CVIČENÍ - Návrhový vzor Observer, který se zejména využívá pro sledování ukončení hry

/**
 * Base implementation of the Observer pattern for game state events.
 *
 * <p>Maintains a map of {@link CommandState} keys to sets of registered
 * {@link IObserver} listeners. Any class that needs to broadcast state-change
 * events (e.g. {@link cz.davza.studentadventure.objects.Game},
 * {@link cz.davza.studentadventure.objects.GameMap}) can extend this class and
 * call {@link #notifyObservers(CommandState)} when the relevant state occurs.</p>
 *
 * <p>Multiple observers can be registered for the same state. Observers are stored
 * in a {@link HashSet}, so duplicate registrations of the same instance are ignored.</p>
 *
 * @see IObservable
 * @see IObserver
 */
public class ObservableBase implements IObservable {

    private final Map<CommandState, Set<IObserver>> observers = new HashMap<>();
    /**
     * Registers an observer to be notified when the given state is fired.
     *
     * <p>If no observer set exists for {@code registeringState} yet, one is
     * created automatically. Registering the same observer instance twice for
     * the same state has no effect (set semantics).</p>
     *
     * @param registeringState the event state this observer wants to listen for
     * @param newObserver      the observer to register
     */
    @Override
    public void addObserver(CommandState registeringState,IObserver newObserver) {
        if  (!observers.containsKey(registeringState)) observers.put(registeringState, new HashSet<>());
        observers.get(registeringState).add(newObserver);
    }

    /**
     * Notifies all observers registered for the given state.
     *
     * <p>If no observers are registered for {@code notifiedState}, the call is
     * silently ignored. Each registered observer's {@link IObserver#update()} method
     * is called in an unspecified order.</p>
     *
     * @param notifiedState the state event that has occurred
     */
    @Override
    public void notifyObservers(CommandState notifiedState) {
    if   (!observers.containsKey(notifiedState)) return;

    for (IObserver observer : observers.get(notifiedState)) {
        observer.update();
    }
    }
}