#include <stdlib.h>
#include <stdio.h>

#include <GLUT/glut.h>

void *make_image(unsigned width, unsigned height)
{
    unsigned total_components = width * height * 4;
    GLubyte *pointer = malloc(total_components * sizeof(GLubyte));
    
    GLubyte r = 0;
    GLubyte g = 96;
    GLubyte b = 192;
    
    unsigned i;
    for (i = 0; i < total_components; ++i)
    {
        switch (i & 3)
        {
            case 0: pointer[i] = r++; break;
            case 1: pointer[i] = g++; break;
            case 2: pointer[i] = b++; break;
            case 3: pointer[i] = 255;
        }
    }
    
    return pointer;
}

GLuint texture = 0;

void reload_texture(void)
{
    glDeleteTextures(1, &texture);
    
    glGenTextures(1, &texture);
    glBindTexture(GL_TEXTURE_2D, texture);
    glTexParameteri(GL_TEXTURE_2D, GL_GENERATE_MIPMAP_SGIS, GL_TRUE);
    GLint max_size;
    glGetIntegerv(GL_MAX_TEXTURE_SIZE, &max_size);
    printf("max size is %d\n", (int)max_size);
    unsigned width = rand() % max_size + 1;
    unsigned height = rand() % max_size + 1;
    void *image = make_image(width, height);
    glTexImage2D(
        GL_TEXTURE_2D,
        0,
        GL_RGBA,
        width,
        height,
        0,
        GL_RGBA,
        GL_UNSIGNED_BYTE,
        image);
    free(image);
    
    printf("using %u x %u texture\n", width, height);
}

void display(void)
{
    glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
    
    glBindTexture(GL_TEXTURE_2D, texture);
    glEnable(GL_TEXTURE_2D);
    
    glBegin(GL_QUADS);
    glTexCoord2f(0.0f, 0.0f);
    glVertex2f(-1.0f, -1.0f);
    glTexCoord2f(1.0f, 0.0f);
    glVertex2f( 1.0f, -1.0f);
    glTexCoord2f(1.0f, 1.0f);
    glVertex2f( 1.0f,  1.0f);
    glTexCoord2f(0.0f, 1.0f);
    glVertex2f(-1.0f,  1.0f);
    glEnd();
    
    glDisable(GL_TEXTURE_2D);
    
    static int frame_count = 0;
    ++frame_count;
    
    static int last_fps_time = 0;
    if (last_fps_time == 0)
    {
        last_fps_time = glutGet(GLUT_ELAPSED_TIME);
    }
    int now = glutGet(GLUT_ELAPSED_TIME);
    
    if (now - last_fps_time >= 1000)
    {
        printf("%0.2f fps\n", frame_count / (0.001 * (now - last_fps_time)));
        frame_count = 0;
        last_fps_time = now;
    }
    
    glutSwapBuffers();
    glutReportErrors();
}

void reshape(int width, int height)
{
    glViewport(0, 0, width, height);
}

void idle(void)
{
    glutPostRedisplay();
}

void keyboard(unsigned char k, int x, int y)
{
    switch (k)
    {
        case 't':
            printf("reloading texture: ");
            reload_texture();
            break;
    }
}

int main(int argc, char** argv)
{
    glutInit(&argc, argv);
    
    glutInitDisplayMode(GLUT_RGBA | GLUT_DOUBLE | GLUT_DEPTH);
    glutInitWindowSize(640, 480);
    
    glutCreateWindow("ARB_texture_non_power_of_two test");
    
    if (!gluCheckExtension(
        (const GLubyte *)"GL_ARB_texture_non_power_of_two",
        glGetString(GL_EXTENSIONS)))
    {
        fprintf(stderr, "No ARB_texture_npot support\n");
        return EXIT_FAILURE;
    }
    
    reload_texture();
    
    glutDisplayFunc(display);
    glutReshapeFunc(reshape);
    glutIdleFunc(idle);
    glutKeyboardFunc(keyboard);
    
    glutMainLoop();
    return EXIT_SUCCESS;
}