#include "ProjectionModel.h"
#include <QMessageBox>
#include <QGLPixelBuffer>

#include "Scene.h"
#include "Screen.h"
#include "Channel.h"
#pragma warning(disable: 4003)
#include "gmtl/gmtl.h"
#include "gui/QDesignViewWidget.h"

using namespace projection;
using namespace gmtl;

QDesignViewWidget::QDesignViewWidget(QWidget* pParent, const QGLWidget* pSharedWidget, Qt::WFlags flags)
    : QGLViewerWidget(pParent, pSharedWidget, flags)
{
    m_pModel = NULL;

    m_viewMode = DESIGN_VIEWMODE_PERSPECTIVE;
    m_opMode = DESIGN_OPMODE_PROJECTOR;
    m_transMode = DESIGN_TRANSMODE_LOCAL;

    m_bAxisVisible = true;
    m_bGridVisible = true;
    m_bInfoVisible = true;

    m_gridSize = 2.0f;

    m_infoFont.setFamily("Helvetica");
    m_infoFont.setPointSize(14);

    if (!QGLPixelBuffer::hasOpenGLPbuffers())
        QMessageBox::critical(this, APPLICATION_NAME,
                              tr("%1 requires OpenGL P-Buffer feature.").arg(APPLICATION_NAME));
}

void QDesignViewWidget::init()
{
}

QDesignViewWidget::~QDesignViewWidget()
{
}

void QDesignViewWidget::setModel(ProjectionModel* pModel)
{
    m_pModel = pModel;

    setSceneSize(m_pModel->getScreen()->getSize() * 5.0f);
    setView(Vec3f(),
            makeRot<Quatf>(AxisAnglef(Math::deg2Rad(45.0f), Vec3f(0.0f, 1.0f, 0.0f))) *
            makeRot<Quatf>(AxisAnglef(Math::deg2Rad(-30.0f), Vec3f(1.0f, 0.0f, 0.0f))),
            sceneSize()*0.5f);
}

void QDesignViewWidget::draw()
{
    if (!isVisible()) return;

    m_pModel->setRenderContext(this);

    m_sceneSize = m_pModel->getScreen()->getSize() * 5.0f;

    glViewport(0, 0, width(), height());

    glEnable(GL_COLOR_MATERIAL);
    glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);

    if (m_pModel->getScene()->getShowInDesignView())
    {
        glPushMatrix();
        glMultMatrixf(invert(m_pModel->getScene()->getCameraMatrix()).getData());
        m_pModel->getScene()->draw();
        glPopMatrix();
    }

    glPushMatrix();
    m_pModel->getScreen()->draw();
    m_pModel->getScreen()->drawFrame();
    for (unsigned int i=0; i<m_pModel->getNumChannels(); ++i)
    {
        if (m_pModel->getChannel(i)->getProjector()->getShowArea())
            m_pModel->getScreen()->draw(PROJECT_SOURCE_PROJECTORAREA, m_pModel->getChannel(i));
        if (m_pModel->getChannel(i)->getView()->getShowArea())
            m_pModel->getScreen()->draw(PROJECT_SOURCE_VIEWAREA, m_pModel->getChannel(i));
        if (m_pModel->getChannel(i)->getShowProjectedScene())
            m_pModel->getScreen()->draw(PROJECT_SOURCE_SCENE, m_pModel->getChannel(i));
        makeCurrent();
    }
    glPopMatrix();

    for (unsigned int i=0; i<m_pModel->getNumChannels(); ++i)
    {
        glPushMatrix();
        m_pModel->getChannel(i)->drawFrustums(m_pModel->getChannel(i)==m_pModel->getSelectedChannel());
        glPopMatrix();
    }

    glPushAttrib(GL_ENABLE_BIT);
    glDisable(GL_LIGHTING);
    for (unsigned int i=0; i<m_pModel->getNumChannels(); ++i)
    {
        if (m_pModel->getChannel(i)->getProjector()->getShow())
        {
            glPushMatrix();
            glMultMatrixf(m_pModel->getChannel(i)->getProjectorTransformMatrix().getMatrix().getData());
            glTranslatef(0.0f, 0.0f, 0.05f);
            renderText(0, 0, 0, m_pModel->getChannel(i)->getName(), m_infoFont, 5000);
            glPopMatrix();
        }
        if (m_pModel->getChannel(i)->getView()->getShow())
        {
            glPushMatrix();
            glMultMatrixf(m_pModel->getChannel(i)->getView()->getTransformMatrix().getMatrix().getData());
            glTranslatef(0.0f, 0.0f, 0.05f);
            renderText(0, 0, 0, m_pModel->getChannel(i)->getName(), m_infoFont, 5000);
            glPopMatrix();
        }
    }
    glPopAttrib();

    if (m_bInfoVisible)
    {
        glDisable(GL_LIGHTING);

        int x = int(m_infoFont.pointSize() * 0.5);
        int y = int(m_infoFont.pointSize() * 1.5);
        int yoffset = int(m_infoFont.pointSize() * 1.5);
        switch (m_viewMode)
        {
        case DESIGN_VIEWMODE_PERSPECTIVE:
            renderText(x, y, QString("View Mode: Perspective"), m_infoFont); y += yoffset; break;
        case DESIGN_VIEWMODE_CENTER:
            renderText(x, y, QString("View Mode: Center"), m_infoFont); y += yoffset; break;
        case DESIGN_VIEWMODE_TOP:
            renderText(x, y, QString("View Mode: Top"), m_infoFont); y += yoffset; break;
        case DESIGN_VIEWMODE_SIDE:
            renderText(x, y, QString("View Mode: Side"), m_infoFont); y += yoffset; break;
        case DESIGN_VIEWMODE_FRONT:
            renderText(x, y, QString("View Mode: Front"), m_infoFont); y += yoffset; break;
        }
        renderText(x, y, QString("Operation Mode: %1").arg(m_opMode==DESIGN_OPMODE_PROJECTOR?"Projector":"View"), m_infoFont); y += yoffset;
        renderText(x, y, QString("Translation Mode: %1").arg(m_transMode==DESIGN_TRANSMODE_LOCAL?"Local":"World"), m_infoFont); y += yoffset;
        if (m_pModel->getSelectedChannel())
            renderText(x, y, QString("Channel: %1").arg(m_pModel->getSelectedChannel()->getName()), m_infoFont); y += yoffset;

#ifdef _DEBUG
        renderText(x, y, QString("UpdateViews: %1").arg(m_pModel->m_updateViewsCount), m_infoFont); y += yoffset;
        renderText(x, y, QString("UpdateOffscreen: %1").arg(m_pModel->m_updateOffscreenCount), m_infoFont); y += yoffset;
#endif // _DEBUG
    }
}

void QDesignViewWidget::setViewMode(DESIGN_VIEWMODE viewMode)
{
    if (m_viewMode == viewMode)
        return;

    if (viewMode == DESIGN_VIEWMODE_PERSPECTIVE)
    {
        setPerspective(true);
        viewAll();
    }
    else if (viewMode == DESIGN_VIEWMODE_CENTER)
    {
        setPerspective(true);
        setView(Vec3f(), Quatf(), 0.0f);
    }
    else
    {
        switch (viewMode)
        {
        case DESIGN_VIEWMODE_TOP:
            setView(Vec3f(), makeRot<Quatf>(AxisAnglef(Math::deg2Rad(-90.0f), Vec3f(1.0f, 0.0f, 0.0f))), 0.0f);
            break;
        case DESIGN_VIEWMODE_SIDE:
            setView(Vec3f(), makeRot<Quatf>(AxisAnglef(Math::deg2Rad(90.0f), Vec3f(0.0f, 1.0f, 0.0f))), 0.0f);
            break;
        case DESIGN_VIEWMODE_FRONT:
            setView(Vec3f(), Quatf(), 0.0f);
            break;
        }
        setPerspective(false);
        viewAll();
    }

    m_viewMode = viewMode;

    updateGL();
}

DESIGN_VIEWMODE QDesignViewWidget::getViewMode() const
{
    return m_viewMode;
}

void QDesignViewWidget::setOpMode(DESIGN_OPMODE opMode)
{
    m_opMode = opMode;
    updateGL();
}

DESIGN_OPMODE QDesignViewWidget::getOpMode() const
{
    return m_opMode;
}

void QDesignViewWidget::setTransMode(DESIGN_TRANSMODE transMode)
{
    m_transMode = transMode;
    updateGL();
}

DESIGN_TRANSMODE QDesignViewWidget::getTransMode() const
{
    return m_transMode;
}

void QDesignViewWidget::setInfoVisible(bool bVisible)
{
    if (m_bInfoVisible != bVisible)
    {
        m_bInfoVisible = bVisible;
        updateGL();
        infoVisibilityChanged(bVisible);
    }
}

bool QDesignViewWidget::isInfoVisible() const
{
    return m_bInfoVisible;
}

void QDesignViewWidget::keyReleaseEvent(QKeyEvent* pEvent)
{
    QGLViewerWidget::keyReleaseEvent(pEvent);

    switch (pEvent->key())
    {
    case Qt::Key_I:
        setInfoVisible(!isInfoVisible());
        break;
    case Qt::Key_F1:
        setViewMode(DESIGN_VIEWMODE_PERSPECTIVE);
        break;
    case Qt::Key_F2:
        setViewMode(DESIGN_VIEWMODE_CENTER);
        break;
    case Qt::Key_F3:
        setViewMode(DESIGN_VIEWMODE_TOP);
        break;
    case Qt::Key_F4:
        setViewMode(DESIGN_VIEWMODE_SIDE);
        break;
    case Qt::Key_F5:
        setViewMode(DESIGN_VIEWMODE_FRONT);
        break;
    case Qt::Key_Space:
        m_pModel->selectNextChannel();
        break;
    default:
        break;
    }

    if (!m_pModel->getSelectedChannel())
        return;

    processChannelKeyEvent(m_pModel->getSelectedChannel(), pEvent);
}

void QDesignViewWidget::processChannelKeyEvent(Channel* pChannel, QKeyEvent* pEvent)
{
#if 1
		Q_UNUSED(pChannel);
		Q_UNUSED(pEvent);
#else
    if (!pChannel)
        return;

    bool bShift = (pEvent->modifiers() & Qt::ShiftModifier);
#ifdef WIN32
    bShift = (GetAsyncKeyState(VK_SHIFT)<0);
#endif // WIN32
    bool bCtrl = (pEvent->modifiers() & Qt::ControlModifier);
//  bool bAlt = (pEvent->modifiers() & Qt::AltModifier);
    bool bKeypad = (pEvent->modifiers() & Qt::KeypadModifier);
#ifdef WIN32
    bool bCapsLock = false; // <-- Careful, bCapsLock is not used.
    bCapsLock = (GetAsyncKeyState(VK_CAPITAL) < 0);
#endif // WIN32

    float step = 1.0f;
    if (bShift && bCtrl)
        step = 0.01f;
    else if (bShift || bCtrl)
        step = 0.1f;

    Frustum* pFrustum = pChannel->getProjector();
    if (m_opMode == DESIGN_OPMODE_VIEW)
        pFrustum = pChannel->getView();

    ProjectionMatrix projMatrix = pFrustum->getProjectionMatrix();
    TransformMatrix xformMatrix = pFrustum->getTransformMatrix();
    gmtl::Vec3f pos = xformMatrix.getPosition();
    gmtl::Vec3f rot = xformMatrix.getRotation();
    gmtl::Quatf quatRot = gmtl::makeRot<gmtl::Quatf>(xformMatrix.getMatrix());

    if (bKeypad)
    {
        switch (pEvent->key())
        {
        case Qt::Key_8:
        case Qt::Key_Up:
            if (m_transMode == DESIGN_TRANSMODE_WORLD)
                xformMatrix.setPosition(gmtl::Vec3f(pos[0], pos[1], pos[2]-0.1f*step));
            else
                xformMatrix.setPosition(pos + quatRot * gmtl::Vec3f(0.0f, 0.0f, -0.1f*step));
            pFrustum->setTransformMatrix(xformMatrix);
            break;
        case Qt::Key_2:
        case Qt::Key_Down:
            if (m_transMode == DESIGN_TRANSMODE_WORLD)
                xformMatrix.setPosition(gmtl::Vec3f(pos[0], pos[1], pos[2]+0.1f*step));
            else
                xformMatrix.setPosition(pos + quatRot * gmtl::Vec3f(0.0f, 0.0f, 0.1f*step));
            pFrustum->setTransformMatrix(xformMatrix);
            break;
        case Qt::Key_6:
        case Qt::Key_Right:
            if (m_transMode == DESIGN_TRANSMODE_WORLD)
                xformMatrix.setPosition(gmtl::Vec3f(pos[0]+0.1f*step, pos[1], pos[2]));
            else
                xformMatrix.setPosition(pos + quatRot * gmtl::Vec3f(0.1f*step, 0.0f, 0.0f));
            pFrustum->setTransformMatrix(xformMatrix);
            break;
        case Qt::Key_4:
        case Qt::Key_Left:
            if (m_transMode == DESIGN_TRANSMODE_WORLD)
                xformMatrix.setPosition(gmtl::Vec3f(pos[0]-0.1f*step, pos[1], pos[2]));
            else
                xformMatrix.setPosition(pos + quatRot * gmtl::Vec3f(-0.1f*step, 0.0f, 0.0f));
            pFrustum->setTransformMatrix(xformMatrix);
            break;
        case Qt::Key_9:
        case Qt::Key_PageUp:
            if (m_transMode == DESIGN_TRANSMODE_WORLD)
                xformMatrix.setPosition(gmtl::Vec3f(pos[0], pos[1]+0.1f*step, pos[2]));
            else
                xformMatrix.setPosition(pos + quatRot * gmtl::Vec3f(0.0f, 0.1f*step, 0.0f));
            pFrustum->setTransformMatrix(xformMatrix);
            break;
        case Qt::Key_3:
        case Qt::Key_PageDown:
            if (m_transMode == DESIGN_TRANSMODE_WORLD)
                xformMatrix.setPosition(gmtl::Vec3f(pos[0], pos[1]-0.1f*step, pos[2]));
            else
                xformMatrix.setPosition(pos + quatRot * gmtl::Vec3f(0.0f, -0.1f*step, 0.0f));
            pFrustum->setTransformMatrix(xformMatrix);
            break;
        case Qt::Key_Plus:
            projMatrix.setOffaxisY(projMatrix.getOffaxisY()-0.01f*step);
            pFrustum->setProjectionMatrix(projMatrix);
            break;
        case Qt::Key_Minus:
            projMatrix.setOffaxisY(projMatrix.getOffaxisY()+0.01f*step);
            pFrustum->setProjectionMatrix(projMatrix);
            break;
        case Qt::Key_Asterisk:
            projMatrix.setOffaxisX(projMatrix.getOffaxisX()+0.01f*step);
            pFrustum->setProjectionMatrix(projMatrix);
            break;
        case Qt::Key_Slash:
            projMatrix.setOffaxisX(projMatrix.getOffaxisX()-0.01f*step);
            pFrustum->setProjectionMatrix(projMatrix);
            break;
        }
    }
    else
    {
        switch (pEvent->key())
        {
        case Qt::Key_PageUp:
            xformMatrix.setPosition(gmtl::Vec3f(pos[0], pos[1]+0.1f*step, pos[2]));
            pFrustum->setTransformMatrix(xformMatrix);
            break;
        case Qt::Key_PageDown:
            xformMatrix.setPosition(gmtl::Vec3f(pos[0], pos[1]-0.1f*step, pos[2]));
            pFrustum->setTransformMatrix(xformMatrix);
            break;
        case Qt::Key_Left:
            xformMatrix.setRotation(gmtl::Vec3f(rot[0]+1.0f*step, rot[1], rot[2]));
            pFrustum->setTransformMatrix(xformMatrix);
            break;
        case Qt::Key_Right:
            xformMatrix.setRotation(gmtl::Vec3f(rot[0]-1.0f*step, rot[1], rot[2]));
            pFrustum->setTransformMatrix(xformMatrix);
            break;
        case Qt::Key_Up:
            xformMatrix.setRotation(gmtl::Vec3f(rot[0], rot[1]+1.0f*step, rot[2]));
            pFrustum->setTransformMatrix(xformMatrix);
            break;
        case Qt::Key_Down:
            xformMatrix.setRotation(gmtl::Vec3f(rot[0], rot[1]-1.0f*step, rot[2]));
            pFrustum->setTransformMatrix(xformMatrix);
            break;
        case Qt::Key_Home:
            xformMatrix.setRotation(gmtl::Vec3f(rot[0], rot[1], rot[2]-1.0f*step));
            pFrustum->setTransformMatrix(xformMatrix);
            break;
        case Qt::Key_End:
            xformMatrix.setRotation(gmtl::Vec3f(rot[0], rot[1], rot[2]+1.0f*step));
            pFrustum->setTransformMatrix(xformMatrix);
            break;
        case Qt::Key_Comma:
            projMatrix.setFOV(projMatrix.getFOV()-1.0f*step);
            pFrustum->setProjectionMatrix(projMatrix);
            break;
        case Qt::Key_Period:
            projMatrix.setFOV(projMatrix.getFOV()+1.0f*step);
            pFrustum->setProjectionMatrix(projMatrix);
            break;
        case Qt::Key_Q:
            if (m_opMode == DESIGN_OPMODE_PROJECTOR)
                setOpMode(DESIGN_OPMODE_VIEW);
            else
                setOpMode(DESIGN_OPMODE_PROJECTOR);
            break;
        case Qt::Key_T:
            if (m_transMode == DESIGN_TRANSMODE_LOCAL)
                setTransMode(DESIGN_TRANSMODE_WORLD);
            else
                setTransMode(DESIGN_TRANSMODE_LOCAL);
            break;
        }
    }
#endif
}

void QDesignViewWidget::initFromDOMElement(const QDomElement& element)
{
    QGLViewerWidget::initFromDOMElement(element);

    QDomElement display = element.firstChildElement("Display");
    if (!display.isNull()) {
        QString viewMode = display.attribute("viewMode", "projector");
        if (viewMode == "perspective")
            m_viewMode = DESIGN_VIEWMODE_PERSPECTIVE;
        else if (viewMode == "center")
            m_viewMode = DESIGN_VIEWMODE_CENTER;
        else if (viewMode == "top")
            m_viewMode = DESIGN_VIEWMODE_TOP;
        else if (viewMode == "side")
            m_viewMode = DESIGN_VIEWMODE_SIDE;
        else if (viewMode == "front")
            m_viewMode = DESIGN_VIEWMODE_FRONT;
        if (display.attribute("opMode", "projector")=="projector")
            m_opMode = DESIGN_OPMODE_PROJECTOR;
        else
            m_opMode = DESIGN_OPMODE_VIEW;
        if (display.attribute("transMode", "local")=="local")
            m_transMode = DESIGN_TRANSMODE_LOCAL;
        else
            m_transMode = DESIGN_TRANSMODE_WORLD;
        m_bInfoVisible = (display.attribute("info", "true")=="true");
    }
}

QDomElement QDesignViewWidget::domElement(QDomDocument& doc) const
{
    QDomElement de = QGLViewerWidget::domElement("DesignView", doc);
    QDomElement display = de.firstChildElement("Display");
    if (!display.isNull()) {
        switch (m_viewMode) {
        case DESIGN_VIEWMODE_PERSPECTIVE: display.setAttribute("viewMode", "perspective"); break;
        case DESIGN_VIEWMODE_CENTER:      display.setAttribute("viewMode", "center"); break;
        case DESIGN_VIEWMODE_TOP:         display.setAttribute("viewMode", "top"); break;
        case DESIGN_VIEWMODE_SIDE:        display.setAttribute("viewMode", "side"); break;
        case DESIGN_VIEWMODE_FRONT:       display.setAttribute("viewMode", "front"); break;
        }
        display.setAttribute("opMode", m_opMode==DESIGN_OPMODE_PROJECTOR?"projector":"view");
        display.setAttribute("transMode", m_transMode==DESIGN_TRANSMODE_LOCAL?"local":"world");
        display.setAttribute("info", m_bInfoVisible?"true":"false");
    }
    return de;
}