package electrosphere;

import java.io.File;
import java.io.IOException;
import java.nio.file.Files;
import java.nio.file.Paths;
import java.util.Scanner;
import java.util.concurrent.TimeUnit;

import org.joml.Vector3i;

import electrosphere.render.GLFWContext;
import electrosphere.render.Mesh;

/**
 *
 */
public class Main {


    

    public static void main(String args[]){

        int dim = 2;
        int i = 0;
        long time = 0;
        long lastTime = 0;
        Scanner scan = new Scanner(System.in);

        try {

            GLFWContext.init();

            //init shader program
            Mesh.initShaderProgram();


            FluidSim[][][] simArray = initFluidSim(dim,1,1);
            
            Mesh[][][] meshArray = initMeshes(dim,1,1,simArray);



            while(true){
                try {
                    TimeUnit.MILLISECONDS.sleep(2);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                //
                //Transfer data
                //
                lastTime = System.currentTimeMillis();
                //
                //Simulate
                //
                FluidSim.simChunks(simArray,i,0.001f);
                time = time + (System.currentTimeMillis() - lastTime);
                //
                //Remesh
                //
                for(int x = 0; x < simArray.length; x++){
                    for(int y = 0; y < simArray[0].length; y++){
                        for(int z = 0; z < simArray[0][0].length; z++){
                            meshArray[x][y][z].remesh();
                        }
                    }
                }
                //redraw
                GLFWContext.redraw(meshArray);
                i++;
                if(i == 1000){
                    System.out.println(time / 1000.0);
                }
                if(i > 3){
                    // scan.next();
                }
            }
        } catch(Throwable ex){
            ex.printStackTrace(System.err);
        }
    }

    private static FluidSim[][][] initFluidSim(int dimx, int dimy, int dimz){
        FluidSim[][][] simArray = new FluidSim[dimx][dimy][dimz];
        for(int x = 0; x < simArray.length; x++){
            for(int y = 0; y < simArray[0].length; y++){
                for(int z = 0; z < simArray[0][0].length; z++){
                    simArray[x][y][z] = new FluidSim();
                    simArray[x][y][z].setup(new Vector3i(x,y,z));
                }
            }
        }
        //set sim adjacencies
        for(int x = 0; x < simArray.length; x++){
            for(int y = 0; y < simArray[0].length; y++){
                for(int z = 0; z < simArray[0][0].length; z++){
                    FluidSim current = simArray[x][y][z];

                    for(int i = -1; i < 2; i++){
                        for(int j = -1; j < 2; j++){
                            for(int k = -1; k < 2; k++){
                                if(i == j && j == k && k == 0){
                                    continue;
                                }
                                if(
                                    0 <= x + i && x + i < simArray.length &&
                                    0 <= y + j && y + j < simArray[0].length &&
                                    0 <= z + k && z + k < simArray[0][0].length
                                ){
                                    current.setNeighbor(i+1,j+1,k+1,simArray[x+i][y+j][z+k]);
                                }
                            }
                        }
                    }

                }
            }
        }
        return simArray;
    }

    private static Mesh[][][] initMeshes(int dimx, int dimy, int dimz, FluidSim[][][] simArray){
        Mesh[][][] meshArray = new Mesh[dimx][dimy][dimz];
        for(int x = 0; x < simArray.length; x++){
            for(int y = 0; y < simArray[0].length; y++){
                for(int z = 0; z < simArray[0][0].length; z++){
                    meshArray[x][y][z] = new Mesh(simArray[x][y][z], new Vector3i(z * 16, y * 16, x * 16));
                    meshArray[x][y][z].meshInitially();
                }
            }
        }
        return meshArray;
    }

}