/**
 * Assignment 6 -- Prisoner's Dilemma -- 2ip90
 * part PlayingField
 *
 * @author Stefan Adrian Robu, 1449044
 * @author Silvia Garcia Cabaces, 1446304
 * assignment group 28
 *
 * assignment copyright Kees Huizing
 */

import java.awt.*;
import java.awt.event.*;
import java.util.*;
import javax.swing.*;
import javax.swing.Timer;

class PlayingField extends JPanel implements ActionListener /* possible implements ... */ {
    private int freqv;
    private boolean alternativeRule = false;
    private static int GRID_SIZE= 50;
    private final static int[] xP = new int[]{1, -1, 0, 0, 1, -1, 1, -1}; //x coordinates for neighbours
    private final static int[] yP = new int[]{0, 0, 1, -1, 1, -1, -1, 1}; //y coordinates for neighbours
    private Patch[][] grid;
    private boolean[][] tempGrid;
    private double alpha; // defection award factor
    private Timer timer;
    private GridLayout gridLayout;
    // random number generator
    private static final long SEED = 37L; // seed for random number generator; any number goes
    public static final Random random = new Random( SEED );

PlayingField(int gridSize){
    this.timer= new Timer(1000, (e) -> step());
    int GRID_SIZE = gridSize;
    grid = new Patch[GRID_SIZE][GRID_SIZE];
    for (int x = 0 ;x<GRID_SIZE;x++) {
    for(int y =0;y<GRID_SIZE;y++){
        grid[x][y] = new Patch();
    }
    }
}
    // we generate the grid here
public void gridCreate() {
    for (int x = 0; x < GRID_SIZE; x++) {
        for (int y = 0; y < GRID_SIZE; y++) {
            grid[x][y].setCooperating(random.nextBoolean());
        }
    }
}
    // we generate the neighbours List Here
    public void setNeighbour() {
        for (int i = 0; i < GRID_SIZE; i++) {
            for (int j = 0; j < GRID_SIZE; j++) {
                ArrayList<Patch> neighboursList = new ArrayList<>();
                for (int n = 0; n < 8; n++) {
                    neighboursList.add(grid[(i + xP[n] + GRID_SIZE) % GRID_SIZE][(j + yP[n] + GRID_SIZE) % GRID_SIZE]);
                    grid[i][j].setNeighbour(neighboursList);

                }
            }
        }
    }

/**
     * calculate and execute one step in the simulation
     */

    public void step () {
        for (int x = 0; x < grid.length; x++) {
            for (int y = 0; y < grid[0].length; y++) {
                grid[x][y].setScore(this.alpha);//returns the score of the patch
            }
        }
        //we compare the score of the neighbours
        for (int x = 0; x < grid.length; x++) {
            for (int y = 0; y < grid[0].length; y++) {
                ArrayList<Patch> results = new ArrayList<>();
                double highestScore = grid[x][y].getScore();
                for (Patch i : grid[x][y].getNeighbours())
                    if (i.getScore() > highestScore) {
                        highestScore = i.getScore();
                    }
                for (Patch i : grid[x][y].getNeighbours()) {
                    if (i.getScore() == highestScore) {
                        results.add(i);
                    }
                    if ((grid[x][y].getScore() == highestScore)) {
                        results.add(grid[x][y]);
                    }
                    if (highestScore == grid[x][y].getScore() && alternativeRule) { // checks if extra rule is in play
                        grid[x][y].isCooperating();
                    }
                }
                results.get(PlayingField.random.nextInt(results.size())).isCooperating();
            }
        }

    }
    public void setAlpha(double alpha){
            this.alpha= alpha;
    }
    public double getAlpha() {
        return this.alpha;
    }
    public void setAlternativeRule(boolean alternativeRule) {
        alternativeRule = alternativeRule;
    }

    public void setFrequency(int freq){
        freqv = freq;

        if(!timer.isRunning()){
            timer= new Timer(1000 / freqv, (e) -> step());
        }
        else{
            timer = new Timer (1000 / freqv, (e) -> step());
            timer.start();
        }
    }
    @Override
    protected void paintComponent(Graphics g){
        for(int x  =0; x < grid.length; x++){
            for(int y = 0; y < grid.length; y++){
                if(grid[x][y].isCooperating()){
                    g.setColor(Color.blue);

                }
                else {
                    g.setColor(Color.red);
                }

                g.fillRect(x*10+40,y*10+20,9,9);
            }
        }
    }

    // return grid as 2D array of booleans
    // true for cooperators, false for defectors
    // precondition: grid is rectangular, has non-zero size and elements are non-null
    public boolean[][] getGrid() {
        boolean[][] resultGrid = new boolean[grid.length][grid[0].length];
        for (int x = 0; x < grid.length; x++ ) {
            for (int y = 0; y < grid[0].length; y++ ) {
                resultGrid[x][y] = grid[x][y].isCooperating();
            }
        }

        return resultGrid;
    }
    // sets grid according to parameter inGrid
    // a patch should become cooperating if the corresponding
    // item in inGrid is true
    public void setGrid( boolean[][] inGrid) {
         for (int x = 0; x < grid.length; x++ ) {
            for (int y = 0; y < grid[0].length; y++ ) {
                grid[x][y].setCooperating(inGrid[x][y]);
            }
        }
    }

    public void timeStart(){
            if(!timer.isRunning()) {
                timer.start();
            }
            else{
                timer.stop();
            }
    }
    public void stop(){
            timer.stop();
    }

    @Override
    public void actionPerformed(ActionEvent e){
        if(e.getSource() == timer){
            step();
        }
    }
}