FireFighters.java

package model;

import util.Position;

import java.util.*;

public class FireFighters implements ModelElement {

    private List<Position> fireFightersPositions;
    private int rowCount;
    private int columnCount;

    private final Random randomGenerator = new Random();

    public FireFighters() {
    }


    public void add(Position position){
        fireFightersPositions.add(position);
    }

    public List<Position> getFireFightersPositions() {
        return fireFightersPositions;
    }


   /* public void initializeElements(int initialCount, int rowCount, int columnCount) {
        this.rowCount=rowCount;
        this.columnCount=columnCount;
        initializeElements(initialCount);
    }*/

    public void initializeElements(int initialFirefighterCount, int rowCount, int columnCount) {
        this.rowCount=rowCount;
        this.columnCount=columnCount;
        fireFightersPositions = new ArrayList<>();
        for (int index = 0; index < initialFirefighterCount; index++)
            fireFightersPositions.add(randomPosition());
    }

    @Override
    public Position randomPosition() {
        if (rowCount <= 0 || columnCount <= 0) {
            throw new IllegalArgumentException("Les limites doivent être positives");
        }
        return new Position(randomGenerator.nextInt(rowCount), randomGenerator.nextInt(columnCount));

    }
    private List<Position> neighbors(Position position) {
        List<Position> list = new ArrayList<>();
        if (position.row() > 0) list.add(new Position(position.row() - 1, position.column()));
        if (position.column() > 0) list.add(new Position(position.row(), position.column() - 1));
        if (position.row() < rowCount - 1) list.add(new Position(position.row() + 1, position.column()));
        if (position.column() < columnCount - 1) list.add(new Position(position.row(), position.column() + 1));
        return list;
    }
    public List<Position> updateFirefighters(Set<Position> firePositions) {
        List<Position> result = new ArrayList<>();
        List<Position> firefighterNewPositions = new ArrayList<>();
        for (Position firefighterPosition : fireFightersPositions) {
            Position newFirefighterPosition = neighborClosestToFire(firefighterPosition,firePositions);
            firefighterNewPositions.add(newFirefighterPosition);
            extinguish(newFirefighterPosition, firePositions);
            result.add(firefighterPosition);
            result.add(newFirefighterPosition);
            List<Position> neighborFirePositions = neighbors(newFirefighterPosition).stream()
                    .filter(firePositions::contains).toList();
            for(Position firePosition : neighborFirePositions)
                extinguish(firePosition,firePositions);
            result.addAll(neighborFirePositions);
        }
        fireFightersPositions = firefighterNewPositions;
        return result;
    }

    private void extinguish(Position position,Set<Position> firePositions ) {
        firePositions.remove(position);
    }

    private Position neighborClosestToFire(Position position, Set<Position> firePositions) {
        Set<Position> seen = new HashSet<>();
        HashMap<Position, Position> firstMove = new HashMap<>();
        Queue<Position> toVisit = new LinkedList<>(neighbors(position));
        for (Position initialMove : toVisit)
            firstMove.put(initialMove, initialMove);
        while (!toVisit.isEmpty()) {
            Position current = toVisit.poll();
            if (firePositions.contains(current))
                return firstMove.get(current);
            for (Position adjacent : neighbors(current)) {
                if (seen.contains(adjacent)) continue;
                toVisit.add(adjacent);
                seen.add(adjacent);
                firstMove.put(adjacent, firstMove.get(current));
            }
        }
        return position;
    }


}