import java.util.concurrent.Semaphore;

/**
 * Represents an instance of the dining philosophers problem. Contains the philosophers, the forks and a set of threads
 * to run the philosophers
 */
public class DiningPhilosophers {
    private final int numberOfPhilosophers; // number of philosophers at table
    private  Philosopher[] philosophers;    // the philosophers
    private  Semaphore[] forks;             // the forks
    private  Thread[] t;                    // the threads that run the philosophers


    /**
     * constructs new instance with given number of philosophers
     * @param numberOfPhilosophers number of philosophers that sit at the table
     */
    public DiningPhilosophers(int numberOfPhilosophers) {
        this.numberOfPhilosophers = numberOfPhilosophers;
        // create the forks
        forks = new Semaphore[numberOfPhilosophers];
        for (int i=0; i <forks.length; i++){
            forks[i] = new Semaphore(1, true);
        }
        // create array for philosophers
        philosophers = new Philosopher[numberOfPhilosophers];
        // create array for threads
        t = new Thread[numberOfPhilosophers];
    }


    /**
     * creates the naive philosophers
     */
    public void createNaivePhilosophers() {
        // create the philosophers
        for (int i=0; i < philosophers.length; i++) {
            philosophers[i] = new NaivePhilosopher(forks[i], forks[(i+1) % forks.length], i);
        }
    }

    /**
     * creates (n-1) naive philosophers and one inverted philosopher (last one)
     */
    public void createAsymmetricPhilosophers() {
        // create the philosophers (n-1) many
        for (int i=0; i < philosophers.length-1; i++) {
            philosophers[i] = new NaivePhilosopher(forks[i], forks[(i+1) % forks.length], i);
        }

        // create inverted philosopher
        int n = philosophers.length-1;
        philosophers[n] = new InvertedPhilosopher(forks[n], forks[(n+1) % forks.length], n);
    }

    /**
     * creates the naive philosophers together with semaphore to restrict access to table
     */
    public void createSittingPhilosophers() {
        // create chairs
        Semaphore chairs = new Semaphore(philosophers.length - 1, true);  // one less chair than there are people
        // create the philosophers and create threads to run them
        for (int i=0; i < philosophers.length; i++) {
            philosophers[i] = new Sittingphilosopher(forks[i], forks[(i+1) % forks.length], chairs, i);
        }
    }


    /**
     * runs simulation for specified amount of seconds
     * @param simulationTime time in seconds that the simulation is run
     * @throws InterruptedException exception if the thread is interrupted while running the simulation
     */
    public void runSimulation(long simulationTime) throws InterruptedException {

        // create threads
        for (int i=0; i < philosophers.length; i++) {
            t[i] = new Thread(philosophers[i]);
        }
        // start threads
        System.out.println("Starting simulation of "+ simulationTime + " seconds.");
        for (int i=0; i < philosophers.length; i++) {
            t[i].start();
        }

        // wait for given amount of seconds (while simulation is running in other threads)
        Thread.sleep(simulationTime * 1000);

        // send stop signal to philosophers
        for (Philosopher p : philosophers) {
            p.setStopSimulating(true);
        }

        // wait for philosophers to finish simulating
        for (int i=0; i < philosophers.length; i++) {
            t[i].join();
        }

        System.out.println("Simulation stopped.");
    }

    /**
     * prints an evaluation of the simulation of the waiting times and numbers of meals
     */
    public void printResults() {
        // print summery
        for (Philosopher p : philosophers) {
            System.out.println("Phil. " + p.ID + " has waited " +
                    p.getWaitingTime() / 1000000 + "s and ate "
                    + p.getHasEaten() + " times.");
        }
    }


}