package gameEngine.views;
import gameEngine.ConnectionManager;
import gameEngine.GameEditor;
import gameEngine.SwingGameEditor;
import gameEngine.Time;
import gameEngine.entites.Entity;
import gameEngine.entites.GameObject;
import gameEngine.entites.gameComponents.*;
import gameEngine.input.*;
import gameEngine.scenes.*;

import org.lwjgl.*;
import org.lwjgl.glfw.*;
import org.lwjgl.opengl.*;
import org.lwjgl.system.*;

import java.nio.*;
import java.util.HashMap;

import static org.lwjgl.glfw.Callbacks.*;
import static org.lwjgl.glfw.GLFW.*;
import static org.lwjgl.opengl.GL11.*;
import static org.lwjgl.system.MemoryStack.*;
import static org.lwjgl.system.MemoryUtil.*;

public class Window {
    private static Window window;
    private static Scene currentScene;
    public int width;
    public int height;
    private String title;
    private long glfwWindow;

    private EditorScene editorScene ;

    private Window() {
        this.width = 1200;
        this.height = 900;
        this.title = "HelloWorld";
        init();
        editorScene = new EditorScene(width, height);
    }

    public static void changeScene(int newScene) {
        switch (newScene) {
            case 0:  // EditorScene
                currentScene = window.editorScene;
                break;
            case 1:  // GameScene
                EditorScene editorScene = (EditorScene) currentScene;
                if(editorScene != null && editorScene.editorEntities != null){
                    currentScene = new GameScene(new HashMap<>(editorScene.editorEntities));
                }
                else currentScene = new GameScene();
                break;
            default:
                assert false : "Unknown Scene [" + newScene + "]";
                break;
        }
    }

    public static Window get() {
        if (window == null) {
            window = new Window();
        }

        return window;
    }

    public void runFromEditor() {
        Window.changeScene(0);
        run();
    }

    public void runFromDTRAM() {
        Window.changeScene(1);
        run();
    }

    private void run() {
        System.out.println("Hello LWJGL " + Version.getVersion() + "!");
        loop();
        glfwFreeCallbacks(glfwWindow);
        glfwDestroyWindow(glfwWindow);
        glfwTerminate();
        glfwSetErrorCallback(null).free();
    }

    private void init() {
        GLFWErrorCallback.createPrint(System.err).set();
        if ( !glfwInit() ) {
            throw new IllegalStateException("Unable to initialize GLFW");
        }

        //Configure GLFW
        glfwDefaultWindowHints();
        glfwWindowHint(GLFW_VISIBLE, GLFW_FALSE);
        glfwWindowHint(GLFW_RESIZABLE, GLFW_FALSE);
        glfwWindowHint(GLFW_MAXIMIZED, GLFW_FALSE);

        glfwWindow = glfwCreateWindow(this.width, this.height, this.title, NULL, NULL);
        if ( glfwWindow == NULL ) {
            throw new RuntimeException("Failed to create the GLFW window");
        }

        glfwSetCursorPosCallback(glfwWindow, MouseInput::mousePosCallback);
        glfwSetMouseButtonCallback(glfwWindow, MouseInput::mouseButtonCallback);
        glfwSetScrollCallback(glfwWindow, MouseInput::mouseScrollCallBack);
        glfwSetKeyCallback(glfwWindow, KeyInput::keyCallback);

        // Get the thread stack and push a new frame
        try ( MemoryStack stack = stackPush() ) {
            IntBuffer pWidth = stack.mallocInt(1); // int*
            IntBuffer pHeight = stack.mallocInt(1); // int*

            // Get the window size passed to glfwCreateWindow
            glfwGetWindowSize(glfwWindow, pWidth, pHeight);

            // Get the resolution of the primary monitor
            GLFWVidMode vidmode = glfwGetVideoMode(glfwGetPrimaryMonitor());

            // Center the window
            glfwSetWindowPos(
                    glfwWindow,
                    (vidmode.width() - pWidth.get(0)) / 2,
                    (vidmode.height() - pHeight.get(0)) / 2
            );
        }

        glfwMakeContextCurrent(glfwWindow);
        glfwSwapInterval(1);
        glfwShowWindow(glfwWindow);
        GL.createCapabilities();
    }

    private void loop() {
        while (!glfwWindowShouldClose(glfwWindow)) {
            glfwPollEvents();
            glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
            float dt = Time.deltaTime;

            if (dt >= 0) {
                resetScene();

                // シーン全体の update を呼び出す
                currentScene.update(dt);
                currentScene.processTasks();

                MouseInput.endFrame();
                KeyInput.endFrame();
            }
            glfwSwapBuffers(glfwWindow);
            Time.update();
        }
    }

    //Gameシーン開始時にタイマーをリセット、Editorシーン戻ったときにフラグをfalseにする
    private boolean startGameScene = false;
    private void resetScene() {
        boolean isGameScene = currentScene instanceof GameScene;
        if (isGameScene && !startGameScene) {
            Time.reset();
            startGameScene = true;
        }
        if (!isGameScene) startGameScene = false;
    }

    public Scene getScene(){
        return currentScene;
    }

}