#include <stdlib.h>
#include <time.h>

#include <GL/gl.h>
#include <GL/glu.h>

#include "Spin.h"

static const float directions[][3] = {
    {0, 0, 1}, {0, 0, -1}, {0, 1, 0}, {0, -1, 0}, {1, 0, 0}, {-1, 0, 0}
};

Spin::Spin()
{
    m_num_monitors = 1;
    m_monitor_info = new monitor_info_t[m_num_monitors];
    m_last_ticks = 0;
    srand(time(NULL));
    initMonitorInfo();
}

Spin::~Spin()
{
    delete[] m_monitor_info;
}

bool Spin::expose (GnomeScreensaver & gs)
{
    if (m_last_ticks == 0)
        m_last_ticks = gs.getTicks();
    else for (int i = 0; i < m_num_monitors; i++)
    {
        if (gs.getTicks() - m_monitor_info[i].last_switch_ticks
                > m_monitor_info[i].switch_time)
        {
            m_monitor_info[i].direction = getRandomDirection();
            m_monitor_info[i].switch_time = getRandomSwitchTime();
            m_monitor_info[i].last_switch_ticks = gs.getTicks();
        }
    }

    int width = gs.getWidth() / m_num_monitors;
    glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);

    for (int monitor_num = 0; monitor_num < m_num_monitors; monitor_num++)
    {
        glViewport(width * monitor_num, 0, width, gs.getHeight());

        glLoadMatrixf(&m_monitor_info[monitor_num].rotation[0]);

        int direction = m_monitor_info[monitor_num].direction;
        glRotatef((gs.getTicks() - m_last_ticks) / 1000.0 * 360.0 / 4.0,
                directions[direction][0],
                directions[direction][1],
                directions[direction][2]);
        glGetFloatv(GL_MODELVIEW_MATRIX,
                &m_monitor_info[monitor_num].rotation[0]);

        m_logobox.draw();
    }
    m_last_ticks = gs.getTicks();

    return true;
}

bool Spin::configure (GnomeScreensaver & gs)
{
    glMatrixMode(GL_PROJECTION);
    glLoadIdentity();
    gluPerspective(60.0, gs.getAspectRatio() / gs.getNumMonitors(),
            0.01, 1000.0);

    glMatrixMode(GL_MODELVIEW);
    glLoadIdentity();
    gluLookAt(0, 0, 10, 0, 0, 0, 0, 1, 0);

    m_num_monitors = gs.getNumMonitors();
    delete[] m_monitor_info;
    m_monitor_info = new monitor_info_t[m_num_monitors];
    initMonitorInfo();

    return true;
}

bool Spin::update (GnomeScreensaver & gs)
{
    return true;
}

void Spin::initMonitorInfo()
{
    for (int i = 0; i < m_num_monitors; i++)
    {
        m_monitor_info[i].direction = getRandomDirection();
        glGetFloatv(GL_MODELVIEW_MATRIX, &m_monitor_info[i].rotation[0]);
        m_monitor_info[i].switch_time = getRandomSwitchTime();
        m_monitor_info[i].last_switch_ticks = 0;
    }
}

int Spin::getRandomDirection()
{
    int direction = (int) (rand() / (double)RAND_MAX *
            sizeof(directions) / sizeof(directions[0]));
    if (direction >= sizeof(directions) / sizeof(directions[0]))
        direction = 0;
    return direction;
}

uint32_t Spin::getRandomSwitchTime()
{
    return 3000u + (uint32_t) (rand() / (double)RAND_MAX * 3000.0);
}