#include "OpenGLTestFixture.h"

using namespace XCEngine::RHI;

GLFWwindow* OpenGLTestFixture::m_window = nullptr;
bool OpenGLTestFixture::m_contextInitialized = false;
OpenGLDevice* OpenGLTestFixture::m_device = nullptr;

void OpenGLTestFixture::SetUpTestSuite() {
    if (!glfwInit()) {
        GTEST_SKIP() << "Failed to initialize GLFW";
        return;
    }

    glfwWindowHint(GLFW_VISIBLE, GLFW_FALSE);
    glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR, 4);
    glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR, 6);
    glfwWindowHint(GLFW_OPENGL_PROFILE, GLFW_OPENGL_CORE_PROFILE);

    m_window = glfwCreateWindow(640, 480, "OpenGL Tests", nullptr, nullptr);
    if (!m_window) {
        GTEST_SKIP() << "Failed to create GLFW window";
        glfwTerminate();
        return;
    }

    glfwMakeContextCurrent(m_window);
    
    if (!gladLoadGLLoader((GLADloadproc)glfwGetProcAddress)) {
        GTEST_SKIP() << "Failed to initialize GLAD";
        glfwDestroyWindow(m_window);
        m_window = nullptr;
        glfwTerminate();
        return;
    }
    
    m_contextInitialized = true;

    m_device = new OpenGLDevice();
    m_device->CreateRenderWindow(640, 480, "Test Window", false);
}

void OpenGLTestFixture::TearDownTestSuite() {
    if (m_device) {
        delete m_device;
        m_device = nullptr;
    }

    if (m_window) {
        glfwDestroyWindow(m_window);
        m_window = nullptr;
    }
    glfwTerminate();
    m_contextInitialized = false;
}

void OpenGLTestFixture::SetUp() {
    if (!m_window || !m_contextInitialized) {
        GTEST_SKIP() << "OpenGL context not available";
        return;
    }

    glfwMakeContextCurrent(m_window);
    ClearGLErrors();
}

void OpenGLTestFixture::TearDown() {
    GLenum error = glGetError();
    if (error != GL_NO_ERROR) {
    }

    ResetGLState();
}

void OpenGLTestFixture::MakeContextCurrent() {
    if (m_window) {
        glfwMakeContextCurrent(m_window);
    }
}

void OpenGLTestFixture::DoneContextCurrent() {
    glfwMakeContextCurrent(nullptr);
}

void OpenGLTestFixture::ClearGLErrors() {
    while (glGetError() != GL_NO_ERROR);
}

bool OpenGLTestFixture::CheckGLError(const char* file, int line) {
    GLenum error = glGetError();
    if (error != GL_NO_ERROR) {
        ADD_FAILURE() << "OpenGL Error: " << error
                      << " (" << GetGLErrorString(error) << ")"
                      << " at " << file << ":" << line;
        return false;
    }
    return true;
}

const char* OpenGLTestFixture::GetGLErrorString(GLenum error) {
    switch (error) {
        case GL_NO_ERROR: return "GL_NO_ERROR";
        case GL_INVALID_ENUM: return "GL_INVALID_ENUM";
        case GL_INVALID_VALUE: return "GL_INVALID_VALUE";
        case GL_INVALID_OPERATION: return "GL_INVALID_OPERATION";
        case GL_INVALID_FRAMEBUFFER_OPERATION: return "GL_INVALID_FRAMEBUFFER_OPERATION";
        case GL_OUT_OF_MEMORY: return "GL_OUT_OF_MEMORY";
        default: return "Unknown error";
    }
}

void OpenGLTestFixture::ResetGLState() {
    glBindBuffer(GL_ARRAY_BUFFER, 0);
    glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0);
    glBindBuffer(GL_UNIFORM_BUFFER, 0);

    glUseProgram(0);

    glBindVertexArray(0);

    glBindFramebuffer(GL_FRAMEBUFFER, 0);
    glBindRenderbuffer(GL_RENDERBUFFER, 0);

    glActiveTexture(GL_TEXTURE0);
    for (int i = 0; i < 16; ++i) {
        glBindTexture(GL_TEXTURE_2D, 0);
    }

    glDisable(GL_DEPTH_TEST);
    glDisable(GL_STENCIL_TEST);
    glDisable(GL_BLEND);
    glDisable(GL_CULL_FACE);
    glDisable(GL_SCISSOR_TEST);

    glDepthFunc(GL_LESS);
    glStencilFunc(GL_ALWAYS, 0, 0xFF);
    glBlendFunc(GL_ONE, GL_ZERO);
}