Coverage Summary for Class: OrderLogicCard (it.polimi.ingsw.gc14.Model)

 package it.polimi.ingsw.gc14.Model;
 
 import it.polimi.ingsw.gc14.Model.Orders.OrderPlayer;
 
 import java.io.Serializable;
 import java.util.*;
 
 /**
  * Abstract base class for all order logic cards.
  *
  * <p>An order logic card manages the turn order of the players and defines
  * the behavior used to update the order during the game.
  */
 public abstract class OrderLogicCard implements Serializable {
 
     /**
      * The queue of {@link Player Players} associated with this order logic card.
      */
     private final Queue<Player> players;
 
     /**
      * The list of {@link OrderPlayer} entries tracking turn order and played status.
      * Protected so subclasses can read it for display purposes (e.g., {@link #toString()}).
      */
     protected final List<OrderPlayer> playerList;
 
     /**
      * Returns an unmodifiable view of the player order list.
      *
      * @return the list of {@link OrderPlayer} entries in turn order.
      */
     public List<OrderPlayer> getPlayerList() {
         return Collections.unmodifiableList(playerList);
     }
 
 
 
     /**
      * Creates an order logic card with the specified list of players.
      *
      * <p>The input list is shuffled in place to establish a random initial turn order.
      * This is intentional: the caller's list (typically {@code Game.playersList}) is
      * reordered so that the game's canonical player sequence reflects the randomized order.
      *
      * @param players the list of players associated with this order logic card.
      *                <strong>The list is mutated (shuffled) by this constructor.</strong>
      */
     public OrderLogicCard(ArrayList<Player> players) {
         Collections.shuffle(players);
         this.players = new LinkedList<>(players);
         this.playerList = new ArrayList<>(players.stream().map(x -> new OrderPlayer(x, false)).toList());
     }
 
     /**
      * Applies the effect associated with the current queue position of the player
      * and then adds the player to the end of the queue.
      *
      * @param player the player to be pushed into the queue.
      */
     public void push(Player player) {
         effect(player, players.size());
         if (players.isEmpty()) {
             playerList.clear();
         }
         playerList.add(new OrderPlayer(player, false));
         players.add(player);
     }
 
     /**
      * Moves the specified player to the end of the queue without applying effects.
      *
      * <p>Any previous occurrence of the player is removed from both the queue
      * and the order list before the player is added again.
      *
      * @param player the player to be pushed into the queue.
      */
     public void pushNoEffect(Player player) {
         players.removeIf(x -> player.getUserName().equals(x.getUserName()));
         playerList.removeIf(x -> player.getUserName().equals(x.getPlayer().getUserName()));
         playerList.add(new OrderPlayer(player, false));
         players.add(player);
     }
 
     /**
      * Removes and returns the first player in the queue.
      *
      * <p>The first order entry that has not yet been marked as played
      * is marked as played before removing the player from the queue.
      *
      * @return the first player in the queue, or {@code null} if the queue is empty.
      */
     public Player pull() {
         for (OrderPlayer p : playerList) {
             if (!p.isPlayed()) {
                 p.markAsPlayed();
                 break;
             }
         }
         return players.poll();
     }
 
     /**
      * Returns the first player in the queue without removing it.
      *
      * @return the first player in the queue, or {@code null} if the queue is empty.
      */
     public Player getFirst()
     {
         return players.peek();
     }
 
     /**
      * Applies the effect associated with the specified player and queue position.
      *
      * @param player the player to whom the effect is applied.
      * @param index the queue position index associated with the effect.
      * @throws IndexOutOfBoundsException if the specified index is not valid.
      */
     protected abstract void effect(Player player, int index) throws IndexOutOfBoundsException;
 
     /**
      * Applies the building-related effect to the specified player.
      * For each building card owned by the player with effect id equal to 3,
      * the player gains 1 Food.
      *
      * @param player the player to whom the building effect is applied.
      */
     protected void buildingEffect(Player player) {
         long count = player.getBuildingCards().stream().filter(x -> x.getEffectId() == 3).count();
         player.addFood((int) count);
     }
 
     /**
      * Returns whether the given player is currently present in the turn queue.
      *
      * @param player the player to look up.
      * @return {@code true} if the player is in the queue; {@code false} otherwise.
      */
     public boolean containsInQueue(Player player) {
         return players.contains(player);
     }
 
     /**
      * Removes the given player from both the turn queue and the order list.
      * No-op if the player is not present.
      *
      * @param player the player to remove.
      */
     public void removeFromQueue(Player player) {
         players.removeIf(x -> x.equals(player));
         playerList.removeIf(x -> x.getPlayer().equals(player));
     }
 
     /**
      * Returns the position of the player associated with the specified username
      * within the current order list.
      *
      * @param username the username of the player whose position is requested.
      * @return the player's position, or {@code -1} if no player with the specified
      *         username is present in the order list.
      * @see Player
      */
     public int getPosition(String username) {
         int pos = 0;
         for (OrderPlayer p : playerList) {
             if (p.getPlayer().getUserName().equals(username))
                 return pos;
             pos++;
         }
         return -1;
     }
 
 
 }