import javafx.animation.AnimationTimer;
import javafx.application.Application;
import javafx.scene.Group;
import javafx.scene.Scene;
import javafx.scene.canvas.Canvas;
import javafx.scene.canvas.GraphicsContext;
import javafx.scene.paint.Color;
import javafx.stage.Stage;

import java.util.Arrays;
import java.util.Random;

import static java.lang.Math.round;
import static java.lang.Math.sqrt;
import static java.lang.System.*;

/*
 *  Program to simulate segregation.
 *  See : http://nifty.stanford.edu/2014/mccown-schelling-model-segregation/
 *
 * NOTE:
 * - JavaFX first calls method init() and then method start() far below.
 * - To test uncomment call to test() first in init() method!
 *
 */
// Extends Application because of JavaFX (just accept for now)

public class Neighbours extends Application {

    Random rand = new Random();


    class Actor {
        final Color color;        // Color an existing JavaFX class
        boolean isSatisfied;      // false by default

        Actor(Color color) {      // Constructor to initialize
            this.color = color;
        }
    }
    // A class to keep track of the index of a null. Much simpler solution than working with matrix.
    class Node{
        int i;
        int j;
        Node(int i, int j){
            this.i = i;
            this.j = j;
        }
    }

    // Below is the *only* accepted instance variable (i.e. variables outside any method)
    // This variable may *only* be used in methods init() and updateWorld()
    Actor[][] world;              // The world is a square matrix of Actors

    // This is the method called by the timer to update the world
    // (i.e move unsatisfied) approx each 1/60 sec.
    void updateWorld() {
        // % of surrounding neighbours that are like me
        // Resets all of the actors to not be satisfied.
        for (int i = 0; i < world.length; i++){
            for (int j = 0; j < world.length; j++){
                if (world[i][j] != null){
                    world[i][j].isSatisfied = false;
                }
            }
        }
        double threshold = 0.7;
        // Finds all nulls in the world array
        Node[] nullArray = findNulls(world);
        // Finds all the satisfied actors and sets isSatisfied = true
        findSatisfied(world, threshold);
        // Shuffles the null array
        shuffleArray(nullArray);
        // Switches an unsatisfied actor to an empty slot.
        switchPlaces(world,nullArray);




        // TODO update world
    }

    // This method initializes the world variable with a random distribution of Actors
    // Method automatically called by JavaFX runtime
    // That's why we must have "@Override" and "public" (just accept for now)
    @Override
    public void init() {
        //test();    // <---------------- Uncomment to TEST!

        // %-distribution of RED, BLUE and NONE
        double[] dist = {0.25, 0.25, 0.50};
        // Number of locations (places) in world (must be a square)
        int nLocations = 90000;   // Should also try 90 000

        // TODO initialize the world
        Actor[] worldArr = generateDistribution(nLocations,dist);
        world = toMatrix(worldArr);
        // Should be last
        fixScreenSize(nLocations);
    }

    // ---------------  Methods ------------------------------

    // TODO Many ...


    void switchPlaces(Actor[][] world, Node[] nullArray){
        int count = 0;
        for (int i = 0; i < world.length; i++){
            for (int j = 0; j < world.length; j++){
                // Switches if the current actor != null and it isnt satisfied. Also makes sure count doesn't
                // go out of bounds.

                if (world[i][j] != null && !world[i][j].isSatisfied && nullArray[count] != null){
                    // Gets the indexes of the empty spot
                    int x = nullArray[count].j;
                    int y = nullArray[count].i;
                    // Code for switching the spots
                    world[y][x] = world[i][j];
                    // Sets the current actor to satisfied so that the code doesn't switch its place again
                    // in the current update. It should only be switched once per update.
                    world[y][x].isSatisfied = true;
                    world[i][j] = null;
                    count++;
                } else if (nullArray[count] == null){
                    count++;
                }
            }
        }
    }


    // Code to find all the neighbours around one actor. Then checks if the actor is satisfied with
    // its current placement. If it is the actors isSatified boolean turns true.
    void findSatisfied(Actor[][] world, double threshold){
        for (int i = 0; i < world.length; i++){
            for (int j = 0; j < world[i].length; j++){
                if (world[i][j] != null){
                    Actor[] tmp = new Actor[8];
                    int tmpCount = 0;
                    // Code to check the neighbours. Wrote this before I found the isValidPlacement method.
                    if (i - 1 >= 0){
                        tmp[tmpCount] = world[i - 1][j];
                        tmpCount++;
                        if (j + 1 < world.length){
                            tmp[tmpCount] = world[i - 1][j + 1];
                            tmpCount++;
                        }
                        if (j - 1 >= 0){
                            tmp[tmpCount] = world[i - 1][j - 1];
                            tmpCount++;
                        }
                    }
                    if (i + 1 < world.length) {
                        tmp[tmpCount] = world[i + 1][j];
                        tmpCount++;
                        if (j - 1 >= 0){
                            tmp[tmpCount] = world[i + 1][j - 1];
                            tmpCount++;
                        }
                        if (j + 1 < world.length){
                            tmp[tmpCount] = world[i + 1][j + 1];
                            tmpCount++;
                        }
                    }
                    if (j + 1 < world.length){
                        tmp[tmpCount] = world[i][j + 1];
                        tmpCount++;
                    }
                    if (j - 1 >= 0){
                        tmp[tmpCount] = world[i][j - 1];
                        tmpCount++;
                    }
                    // Uses method getNeighbourPercent to find out the percent of neighbours
                    // that has the same color as current actor.
                    double percent = getNeighbourPercent(tmp, world[i][j].color);
                    if (percent >= threshold){
                        world[i][j].isSatisfied = true;
                    }
                }
            }
        }
    }

    // Checks 8 actors in a list, then calculates the amount in percent. The percentage of which
    // color is decided by the color you put in when calling the method.
    double getNeighbourPercent(Actor[] neigh, Color color){
        int redAmount = 0;
        int blueAmount = 0;
        int totalColor = neigh.length;
        double totalColorPercent;
        for (int i = 0; i < neigh.length; i++){
            if (neigh[i] == null){
                totalColor--;
            } else if (neigh[i].color == Color.RED){
                redAmount++;
            } else if (neigh[i].color == Color.BLUE){
                blueAmount++;
            }
        }
        // To not get divided by zero
        if (totalColor == 0){
            return 0.0;
        }
        if (color == Color.RED){
            totalColorPercent = (double) redAmount / totalColor;
        } else {
            totalColorPercent = (double) blueAmount / totalColor;
        }
        return totalColorPercent;
    }
    // Shuffles an array of nodes. It generates a random number, then switches
    // the current Node with the one at the random number index. Can change it
    // to void.
    Node[] shuffleArray(Node[] oldList){
        for (int i = 0; i < oldList.length; i++){
            int randomIndexToSwap = rand.nextInt(oldList.length);
            Node temp = oldList[randomIndexToSwap];
            oldList[randomIndexToSwap] = oldList[i];
            oldList[i] = temp;
        }
        return oldList;
    }
    // Finds the nulls in the world array and creates a Node array, each node having the index of
    // one of the nulls.
    Node[] findNulls(Actor[][] world){
        int worldLength = world.length * world.length;
        Node[] nodeArr = new Node[(int) worldLength];
        int tmp = 0;
        for (int i = 0; i < world.length; i++){
            for (int j = 0; j < world[i].length; j++){
                if (world[i][j] == null){
                    nodeArr[tmp] = new Node(i,j);
                    tmp++;
                }
            }
        }
        return nodeArr;
    }
    // Same as the other shuffleArray, only this one takes an Actor array.
    Actor[] shuffleArray(Actor[] oldList){

        for (int i = 0; i < oldList.length; i++){
            int randomIndexToSwap = rand.nextInt(oldList.length);
            Actor temp = oldList[randomIndexToSwap];
            oldList[randomIndexToSwap] = oldList[i];
            oldList[i] = temp;
        }

        return oldList;
    }
    // Generates the distribution of the world. It creates an array with
    // (for example) 25% red 25% blue 50% nulls. First all the reds, then blue and then nulls.
    // After that it shuffles the array to get a somewhat equal spread across the world.
    Actor[] generateDistribution(int length, double[] doubArr){

        Actor[] newArray = new Actor[length];
        int amountBlue = 0;
        int amountRed = 0;
        int amountNull = 0;
        for (int i = 0; i < newArray.length; i++) {
            if (amountRed < (int) (doubArr[0] * length)){
                newArray[i] = new Actor(Color.RED);
                amountRed++;
            } else if (amountBlue < (int) (doubArr[1] * length)){
                newArray[i] = new Actor(Color.BLUE);
                amountBlue++;
            } else if (amountNull < (int) (int) (doubArr[2] * length)){
                newArray[i] = null;
                amountNull++;
            }
        }
        shuffleArray(newArray);
        return  newArray;
    }

    // Turns an array to a matrix. (2d array)
    Actor[][] toMatrix(Actor[] arr){
        int size = (int) StrictMath.sqrt(arr.length);
        Actor[][] m = new Actor[size][size];
        int temp = -1;
        for(int i = 0;i<arr.length;i++){
            int l = i%size;
            if(l == 0){
                temp++;
            }
            m[temp][l] = arr[i];
        }
        return m;
    }
    // Turns a 2d array to a regular array.
    Actor[] toArr(Actor[][] m){
        int size = m.length*m.length;
        Actor[] temp = new Actor[size];
        int count = 0;
        for(int i = 0; i < m.length; i++){
            for(int n = 0; n<m.length;n++){
                temp[count] = m[i][n];
                count++;
            }
        }
        return temp;
    }

    // Check if inside world
    boolean isValidLocation(int size, int row, int col) {
        return 0 <= row && row < size && 0 <= col && col < size;
    }

    // ----------- Utility methods -----------------

    // TODO (general method possible reusable elsewhere)

    // ------- Testing -------------------------------------

    // Here you run your tests i.e. call your logic methods
    // to see that they really work. Important!!!!
    void test() {
        // A small hard coded world for testing
        Actor[][] testWorld = new Actor[][]{
                {   new Actor(Color.RED),   new Actor(Color.RED),    null},
                {   null,                   new Actor(Color.BLUE),   null},
                {   new Actor(Color.RED),   null,                    new Actor(Color.BLUE)}
        };
        double th = 0.5;   // Simple threshold used for testing

        int size = testWorld.length;
        /*
        out.println(isValidLocation(size, 0, 0));
        out.println(!isValidLocation(size, -1, 0));
        out.println(!isValidLocation(size, 0, 3));
        */
        findSatisfied(testWorld,th);
        for (int i = 0; i < testWorld.length; i++){
            for (int j = 0; j < testWorld.length; j++){
                if (testWorld[i][j] != null){
                    out.println(testWorld[i][j].isSatisfied);
                }
            }
        }


        // TODO


        exit(0);
    }
    void testMethod(Actor[][] world){
        world[0][0].isSatisfied = true;
    }
    // ******************** NOTHING to do below this row, it's JavaFX stuff  **************

    double width = 500;   // Size for window
    double height = 500;
    final double margin = 50;
    double dotSize;

    void fixScreenSize(int nLocations) {
        // Adjust screen window
        dotSize = 9000 / nLocations;
        if (dotSize < 1) {
            dotSize = 2;
        }
        width = sqrt(nLocations) * dotSize + 2 * margin;
        height = width;
    }

    long lastUpdateTime;
    final long INTERVAL = 450_000_000;


    @Override
    public void start(Stage primaryStage) throws Exception {

        // Build a scene graph
        Group root = new Group();
        Canvas canvas = new Canvas(width, height);
        root.getChildren().addAll(canvas);
        GraphicsContext gc = canvas.getGraphicsContext2D();

        // Create a timer
        AnimationTimer timer = new AnimationTimer() {
            // This method called by FX, parameter is the current time
            public void handle(long now) {
                long elapsedNanos = now - lastUpdateTime;
                if (elapsedNanos > INTERVAL) {
                    updateWorld();
                    renderWorld(gc);
                    lastUpdateTime = now;
                }
            }
        };

        Scene scene = new Scene(root);
        primaryStage.setScene(scene);
        primaryStage.setTitle("Simulation");
        primaryStage.show();

        timer.start();  // Start simulation
    }


    // Render the state of the world to the screen
    public void renderWorld(GraphicsContext g) {
        g.clearRect(0, 0, width, height);
        int size = world.length;
        for (int row = 0; row < size; row++) {
            for (int col = 0; col < size; col++) {
                int x = (int) (dotSize * col + margin);
                int y = (int) (dotSize * row + margin);
                if (world[row][col] != null) {
                    g.setFill(world[row][col].color);
                    g.fillOval(x, y, dotSize, dotSize);
                }
            }
        }
    }

    public static void main(String[] args) {
        launch(args);
    }

}