#include <glad/glad.h>
#include <GLFW/glfw3.h>
#include <glm/glm.hpp>
#include <glm/gtc/matrix_transform.hpp>
#include <glm/gtc/type_ptr.hpp>
#include "Camera.h"
#include "Shader.h"
#define STB_IMAGE_IMPLEMENTATION // 必须在stb_image.h之前定义
#include "stb_image.h"
#include <vector>
#include <iostream>
#include <map>

#define STB_IMAGE_IMPLEMENTATION
using namespace std;

void framebuffer_size_callback(GLFWwindow* window, int width, int height);
void mouse_callback(GLFWwindow* window, double xpos, double ypos);
void scroll_callback(GLFWwindow* window, double xoffset, double yoffset);
void processInput(GLFWwindow* window);
unsigned int loadTexture(const char* path);
unsigned int loadCubemap(vector<std::string> faces);

// 屏幕参数
const unsigned int SCR_WIDTH = 1910;
const unsigned int SCR_HEIGHT = 1050;
// 相机设置
Camera camera(glm::vec3(0.0f, 0.0f, 3.0f));
//指针初始化的位置
float lastX = SCR_WIDTH / 2.0f;
float lastY = SCR_HEIGHT / 2.0f;
//防止第一次移动鼠标产生“跳”的状态量
bool firstMouse = true;
// 时间
float deltaTime = 0.0f;
float lastFrame = 0.0f;


//----------------------------------------------------------------------------------------
int main() {
    //-------------------------------------------------------前置工作----------------------
    glfwInit();
    glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR, 3);
    glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR, 3);
    glfwWindowHint(GLFW_OPENGL_PROFILE, GLFW_OPENGL_CORE_PROFILE);

#ifdef __APPLE__
    glfwWindowHint(GLFW_OPENGL_FORWARD_COMPAT, GL_TRUE);
#endif

    GLFWwindow* window = glfwCreateWindow(SCR_WIDTH, SCR_HEIGHT, "LearnOpenGL", NULL, NULL);
    if (window == NULL)
    {
        std::cout << "Failed to create GLFW window" << std::endl;
        glfwTerminate();
        return -1;
    }

    glfwMakeContextCurrent(window);
    //注册回调函数
    glfwSetFramebufferSizeCallback(window, framebuffer_size_callback);
    glfwSetCursorPosCallback(window, mouse_callback);
    glfwSetScrollCallback(window, scroll_callback);

    //隐藏鼠标指针
    glfwSetInputMode(window, GLFW_CURSOR, GLFW_CURSOR_DISABLED);

    //使用GLAD
    if (!gladLoadGLLoader((GLADloadproc)glfwGetProcAddress))
    {
        std::cout << "Failed to initialize GLAD" << std::endl;
        return -1;
    }

    glEnable(GL_DEPTH_TEST);// 深度测试

    //--------------------------------------------------------------------------------
    //初始化着色器


    //--------------------------------------------------------------------------------
    //数据信息
    


    //--------------------------------------------------------------------------------
    //创建绑定VAO，VBO
    

    //--------------------------------------------------------------------------------
    //加载纹理
    

    //--------------------------------------------------------------------------------
    //渲染循环
    while (!glfwWindowShouldClose(window)) {
        //计算时间差：
        float currentFrame = static_cast<float>(glfwGetTime());
        deltaTime = currentFrame - lastFrame;
        lastFrame = currentFrame;

        //处理输入事件:
        processInput(window);

        glClearColor(0.1f, 0.1f, 0.1f, 1.0f);
        glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
        // ---------------------------------------------------------------------------
        //存储颜色缓冲，作为输出显示在屏幕上：
        glfwSwapBuffers(window);
        //检查有没有触发什么事件
        glfwPollEvents();
    }

    //释放资源
    //释放VAO，VBO，EBO



    //释放GLFW的资源
    glfwTerminate();

    return 0;
}
void processInput(GLFWwindow* window)
{
    if (glfwGetKey(window, GLFW_KEY_ESCAPE) == GLFW_PRESS)
        glfwSetWindowShouldClose(window, true);

    if (glfwGetKey(window, GLFW_KEY_W) == GLFW_PRESS)
        camera.ProcessKeyboard(FORWARD, deltaTime);
    if (glfwGetKey(window, GLFW_KEY_S) == GLFW_PRESS)
        camera.ProcessKeyboard(BACKWARD, deltaTime);
    if (glfwGetKey(window, GLFW_KEY_A) == GLFW_PRESS)
        camera.ProcessKeyboard(LEFT, deltaTime);
    if (glfwGetKey(window, GLFW_KEY_D) == GLFW_PRESS)
        camera.ProcessKeyboard(RIGHT, deltaTime);
    if (glfwGetKey(window, GLFW_KEY_SPACE) == GLFW_PRESS)
        camera.jump();
    if (glfwGetKey(window, GLFW_KEY_LEFT_CONTROL) == GLFW_PRESS)
        camera.down();
}
void framebuffer_size_callback(GLFWwindow* window, int width, int height)
{
    glViewport(0, 0, width, height);
}
void mouse_callback(GLFWwindow* window, double xposIn, double yposIn)
{
    float xpos = static_cast<float>(xposIn);
    float ypos = static_cast<float>(yposIn);

    if (firstMouse)
    {
        lastX = xpos;
        lastY = ypos;
        firstMouse = false;
    }

    float xoffset = xpos - lastX;
    float yoffset = lastY - ypos;

    lastX = xpos;
    lastY = ypos;

    camera.ProcessMouseMovement(xoffset, yoffset);
}

unsigned int VAO, VBO;
glGenVertexArrays(1, &VAO);
glGenBuffers(1, &VBO);

glBindVertexArray(VAO);
glBindBuffer(GL_ARRAY_BUFFER, VBO);
glBufferData(GL_ARRAY_BUFFER, sizeof(vertices), vertices, GL_STATIC_DRAW);

glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 5 * sizeof(float), (void*)0);
glEnableVertexAttribArray(0);
glVertexAttribPointer(1, 2, GL_FLOAT, GL_FALSE, 5 * sizeof(float), (void*) (3 * sizeof(float)));
glEnableVertexAttribArray(1);

unsigned int VBO, VAO, EBO;
glGenVertexArrays(1, &VAO);
glGenBuffers(1, &VBO);
glGenBuffers(1, &EBO);

glBindVertexArray(VAO);

glBindBuffer(GL_ARRAY_BUFFER, VBO);
glBufferData(GL_ARRAY_BUFFER, sizeof(vertices), vertices, GL_STATIC_DRAW);

glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, EBO);
glBufferData(GL_ELEMENT_ARRAY_BUFFER, sizeof(indices), indices, GL_STATIC_DRAW);

glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 5 * sizeof(float), (void*)0);
glEnableVertexAttribArray(0);
glVertexAttribPointer(1, 2, GL_FLOAT, GL_FALSE, 5 * sizeof(float), (void*)(3 * sizeof(float)));
glEnableVertexAttribArray(1);

// 创建一个纹理
unsigned int textureID;
glGenTextures(1, &textureID);
// 绑定这个纹理
glBindTexture(GL_TEXTURE_2D, textureID);
// 为纹理绑定数据
glTexImage2D(GL_TEXTURE_2D, 0, format, width, height, 0, format, GL_UNSIGNED_BYTE, data);
glGenerateMipmap(GL_TEXTURE_2D);// 为当前绑定的纹理自动生成所有需要的多级渐远纹理。
// 为纹理设置一些条件
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR_MIPMAP_LINEAR);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);

glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB, width, height, 0, GL_RGB, GL_UNSIGNED_BYTE, data);

glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);

// 先将着色器的纹理设置对应的值后才可以进行下面的绑定纹理单元的操作
ourShader.use(); // 不要忘记在设置uniform变量之前激活着色器程序！
glUniform1i(glGetUniformLocation(ourShader.ID, "texture1"), 0); // 手动设置

//使用glActiveTexture激活纹理单元
glActiveTexture(GL_TEXTURE0); // 在绑定纹理之前先激活纹理单元
//glBindTexture函数调用会绑定这个纹理到当前激活的纹理单元
glBindTexture(GL_TEXTURE_2D, texture);

//纹理单元GL_TEXTURE0默认总是被激活，所以我们在前面的例子里当我们使用glBindTexture的时候，无需激活任何纹理单元。

lStencilMask(0xFF); // 每一位写入模板缓冲时都保持原样
glStencilMask(0x00); // 每一位在写入模板缓冲时都会变成0（禁用写入）

glStencilFunc(GLenum func, GLint ref, GLuint mask)一共包含三个参数：
// 描述了OpenGL应该对模板缓冲内容做什么

glStencilFunc(GL_EQUAL, 1, 0xFF)

glStencilOp(GLenum sfail, GLenum dpfail, GLenum dppass);
// 如何更新缓冲

 glEnable(GL_STENCIL_TEST);  // 模板测试
 glStencilFunc(GL_NOTEQUAL, 1, 0xFF);    // 模板测试函数
 glStencilOp(GL_KEEP, GL_KEEP, GL_REPLACE);  // 对深度测试和模板测试的情况采取的策略

// 渲染循环：
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT | GL_STENCIL_BUFFER_BIT);// 清空缓存
// 渲染地板：
// 像平常一样画地板，但不把地板写到模板缓冲区，我们只关心容器的情况。我们把它的掩码设置为0x00，不写到缓冲区。
glStencilMask(0x00);
// 绘制物体：
 // 第1个渲染通道，像往常一样绘制物体，写到模板缓冲区。
glStencilFunc(GL_ALWAYS, 1, 0xFF);
glStencilMask(0xFF);
// 第2次渲染：现在绘制稍有比例的对象，这次是禁用模版的书写。
// 因为现在模版缓冲区被几个1填满了。缓冲区中1的部分没有被画出来，因此只能画出物体的大小差异，使其看起来像边框。
glStencilFunc(GL_NOTEQUAL, 1, 0xFF);
glStencilMask(0x00);
glDisable(GL_DEPTH_TEST);
// 恢复：
glStencilFunc(GL_ALWAYS, 0, 0xFF);
glEnable(GL_DEPTH_TEST);