package ch.epfl.maze.physical;

import java.util.ArrayList;
import java.util.List;
import java.util.stream.Collectors;
import java.util.stream.Stream;

/**
 * Daedalus in which predators hunt preys. Once a prey has been caught by a
 * predator, it will be removed from the daedalus.
 *
 * @author Pacien TRAN-GIRARD
 */
public final class Daedalus extends World {

    private final List<Predator> predators;
    private final List<Predator> predatorHistory;

    private final List<Prey> preys;
    private final List<Prey> preyHistory;

    /**
     * Constructs a Daedalus with a labyrinth structure
     *
     * @param labyrinth Structure of the labyrinth, an NxM array of tiles
     */
    public Daedalus(int[][] labyrinth) {
        super(labyrinth);

        this.predators = new ArrayList<>();
        this.predatorHistory = new ArrayList<>();

        this.preys = new ArrayList<>();
        this.preyHistory = new ArrayList<>();
    }

    @Override
    public boolean isSolved() {
        return this.preys.isEmpty();
    }

    /**
     * Adds a predator to the daedalus.
     *
     * @param p The predator to add
     */
    public void addPredator(Predator p) {
        this.predators.add(p);
        this.predatorHistory.add((Predator) p.copy());
    }

    /**
     * Adds a prey to the daedalus.
     *
     * @param p The prey to add
     */
    public void addPrey(Prey p) {
        this.preys.add(p);
        this.preyHistory.add((Prey) p.copy());
    }

    /**
     * Removes a predator from the daedalus.
     *
     * @param p The predator to remove
     */
    public void removePredator(Predator p) {
        this.predators.remove(p);
    }

    /**
     * Removes a prey from the daedalus.
     *
     * @param p The prey to remove
     */
    public void removePrey(Prey p) {
        this.preys.remove(p);
    }

    @Override
    public List<Animal> getAnimals() {
        return Stream
                .concat(this.predators.stream(), this.preys.stream())
                .collect(Collectors.toList());
    }

    /**
     * Returns a copy of the list of all current predators in the daedalus.
     *
     * @return A list of all predators in the daedalus
     */
    public List<Predator> getPredators() {
        return this.predators;
    }

    /**
     * Returns a copy of the list of all current preys in the daedalus.
     *
     * @return A list of all preys in the daedalus
     */
    public List<Prey> getPreys() {
        return this.preys;
    }

    /**
     * Determines if the daedalus contains a predator.
     *
     * @param p The predator in question
     * @return <b>true</b> if the predator belongs to the world, <b>false</b>
     * otherwise.
     */
    public boolean hasPredator(Predator p) {
        return this.predators.contains(p);
    }

    /**
     * Determines if the daedalus contains a prey.
     *
     * @param p The prey in question
     * @return <b>true</b> if the prey belongs to the world, <b>false</b>
     * otherwise.
     */
    public boolean hasPrey(Prey p) {
        return this.preys.contains(p);
    }

    @Override
    public void reset() {
        this.predators.clear();
        this.predators.addAll(this.predatorHistory);

        this.preys.clear();
        this.preys.addAll(this.preyHistory);
    }

}