//##################################################################################################
//
//   Custom Visualization Core library
//   Copyright (C) 2011-2013 Ceetron AS
//
//   This library may be used under the terms of either the GNU General Public License or
//   the GNU Lesser General Public License as follows:
//
//   GNU General Public License Usage
//   This library is free software: you can redistribute it and/or modify
//   it under the terms of the GNU General Public License as published by
//   the Free Software Foundation, either version 3 of the License, or
//   (at your option) any later version.
//
//   This library is distributed in the hope that it will be useful, but WITHOUT ANY
//   WARRANTY; without even the implied warranty of MERCHANTABILITY or
//   FITNESS FOR A PARTICULAR PURPOSE.
//
//   See the GNU General Public License at <<http://www.gnu.org/licenses/gpl.html>>
//   for more details.
//
//   GNU Lesser General Public License Usage
//   This library is free software; you can redistribute it and/or modify
//   it under the terms of the GNU Lesser General Public License as published by
//   the Free Software Foundation; either version 2.1 of the License, or
//   (at your option) any later version.
//
//   This library is distributed in the hope that it will be useful, but WITHOUT ANY
//   WARRANTY; without even the implied warranty of MERCHANTABILITY or
//   FITNESS FOR A PARTICULAR PURPOSE.
//
//   See the GNU Lesser General Public License at <<http://www.gnu.org/licenses/lgpl-2.1.html>>
//   for more details.
//
//##################################################################################################


#include "cafCeetronNavigation.h"
#include "cafViewer.h"
#include "cvfCamera.h"
#include "cvfScene.h"
#include "cvfModel.h"
#include "cvfViewport.h"
#include "cvfHitItemCollection.h"
#include "cvfRay.h"

#include <QInputEvent>

using cvf::ManipulatorTrackball;

//==================================================================================================
///
/// \class CeetronNavigationPolicy
/// \ingroup Caf
///
/// 
///
//==================================================================================================

//--------------------------------------------------------------------------------------------------
/// 
//--------------------------------------------------------------------------------------------------
caf::CeetronNavigation::CeetronNavigation()
    : m_isRotCenterInitialized(false)
{

}

//--------------------------------------------------------------------------------------------------
/// 
//--------------------------------------------------------------------------------------------------
caf::CeetronNavigation::~CeetronNavigation()
{

}

//--------------------------------------------------------------------------------------------------
/// Repositions and orients the camera to view the rotation point along the 
/// direction "alongDirection". The distance to the rotation point is maintained.
///
//--------------------------------------------------------------------------------------------------
void caf::CeetronNavigation::setView( const cvf::Vec3d& alongDirection, const cvf::Vec3d& upDirection )
{
    m_trackball->setView(alongDirection, upDirection);
    /*
    if (m_camera.isNull()) return;

    Vec3d dir = alongDirection;
    if (!dir.normalize()) return;
    Vec3d up = upDirection;
    if(!up.normalize()) up = Vec3d::Z_AXIS;

    if((up * dir) < 1e-2) up = dir.perpendicularVector();

    Vec3d cToE = m_camera->position() - m_rotationPoint;
    Vec3d newEye = m_rotationPoint - cToE.length() * dir;

    m_camera->setFromLookAt(newEye, m_rotationPoint, upDirection);
    */
}



//--------------------------------------------------------------------------------------------------
/// 
//--------------------------------------------------------------------------------------------------
void caf::CeetronNavigation::init()
{
    m_trackball = new cvf::ManipulatorTrackball;
    m_trackball->setCamera(m_viewer->mainCamera());
    m_isRotCenterInitialized = false;
}

//--------------------------------------------------------------------------------------------------
/// 
//--------------------------------------------------------------------------------------------------
bool caf::CeetronNavigation::handleInputEvent(QInputEvent* inputEvent)
{
    if (! inputEvent) return false;

    switch (inputEvent->type())
    {
    case QEvent::MouseButtonPress:
        mouseMoveEvent(static_cast<QMouseEvent*>( inputEvent));
        break;
    case QEvent::MouseButtonRelease:
        mouseReleaseEvent(static_cast<QMouseEvent*>( inputEvent));
        break;
    case QEvent::MouseMove:
        mouseMoveEvent(static_cast<QMouseEvent*>( inputEvent));
        break;
    case QEvent::Wheel:
        wheelEvent(static_cast<QWheelEvent*> ( inputEvent));
        break;
    }

    return false;
}


//--------------------------------------------------------------------------------------------------
/// 
//--------------------------------------------------------------------------------------------------
void caf::CeetronNavigation::mouseMoveEvent(QMouseEvent* event)
{
    if (!m_viewer->canRender()) return;
    initializeRotationCenter();
    int posX = event->x();
    int posY = m_viewer->height() - event->y();

    ManipulatorTrackball::NavigationType navType = getNavigationTypeFromMouseButtons(event->buttons());
    if (navType != m_trackball->activeNavigation())
    {
        m_trackball->startNavigation(navType, posX, posY);
    }

    bool needRedraw = m_trackball->updateNavigation(posX, posY);
    if (needRedraw)
    {
        m_viewer->navigationPolicyUpdate();
    }

    setCursorFromCurrentState();
}


//--------------------------------------------------------------------------------------------------
/// 
//--------------------------------------------------------------------------------------------------
void caf::CeetronNavigation::mousePressEvent(QMouseEvent* event)
{
    if (!m_viewer->canRender()) return;
    initializeRotationCenter();
    int posX = event->x();
    int posY = m_viewer->height() - event->y();

    ManipulatorTrackball::NavigationType navType = getNavigationTypeFromMouseButtons(event->buttons());
    m_trackball->startNavigation(navType, posX, posY);

    setCursorFromCurrentState();
}


//--------------------------------------------------------------------------------------------------
/// 
//--------------------------------------------------------------------------------------------------
void caf::CeetronNavigation::mouseReleaseEvent(QMouseEvent* event)
{

    if (!m_viewer->canRender()) return;
    initializeRotationCenter();
    ManipulatorTrackball::NavigationType navType = getNavigationTypeFromMouseButtons(event->buttons());
    m_trackball->startNavigation(navType, event->x(), event->y());

    setCursorFromCurrentState();
}



//--------------------------------------------------------------------------------------------------
/// 
//--------------------------------------------------------------------------------------------------
void caf::CeetronNavigation::wheelEvent(QWheelEvent* event)
{
    if (!m_viewer->canRender()) return;
    if (!m_viewer->mainCamera()) return;
    initializeRotationCenter();
    int vpHeight = m_viewer->mainCamera()->viewport()->height();
    if (vpHeight <= 0) return;

    int navDelta = vpHeight/5;
    if (event->delta() < 0) navDelta *= -1;

    int posY = m_viewer->height() - event->y();

    m_trackball->startNavigation(ManipulatorTrackball::WALK, event->x(), posY);

    m_trackball->updateNavigation(event->x(), posY + navDelta);
    m_trackball->endNavigation();

    m_viewer->updateParallelProjectionHeightFromMoveZoom( m_pointOfInterest);

    m_viewer->navigationPolicyUpdate();

    event->accept();
}


//--------------------------------------------------------------------------------------------------
/// 
//--------------------------------------------------------------------------------------------------
ManipulatorTrackball::NavigationType caf::CeetronNavigation::getNavigationTypeFromMouseButtons(Qt::MouseButtons mouseButtons)
{
    if (mouseButtons == Qt::LeftButton)
    {
        return ManipulatorTrackball::PAN;
    }
    else if (mouseButtons == Qt::RightButton)
    {
        return ManipulatorTrackball::ROTATE;
    }
    else if (mouseButtons == Qt::MidButton || mouseButtons == (Qt::LeftButton | Qt::RightButton))
    {
        return ManipulatorTrackball::WALK;
    }
    else
    {
        return ManipulatorTrackball::NONE;
    }
}



//--------------------------------------------------------------------------------------------------
/// 
//--------------------------------------------------------------------------------------------------
void caf::CeetronNavigation::setCursorFromCurrentState()
{
    ManipulatorTrackball::NavigationType navType = m_trackball->activeNavigation();
    switch (navType)
    {
    case ManipulatorTrackball::PAN:         
        //m_viewer->setCursor(RiuCursors::get(RiuCursors::PAN));
        return;
    case ManipulatorTrackball::WALK:     
        //m_viewer->setCursor(RiuCursors::get(RiuCursors::WALK));        
        return;
    case ManipulatorTrackball::ROTATE:     
        //m_viewer->setCursor(RiuCursors::get(RiuCursors::ROTATE));    
        return;
    default:
        break;
    }

    // m_viewer->setCursor(RiuCursors::get(RiuCursors::PICK));
}

//--------------------------------------------------------------------------------------------------
/// 
//--------------------------------------------------------------------------------------------------
void caf::CeetronNavigation::initializeRotationCenter()
{
    if (m_isRotCenterInitialized
        || m_trackball.isNull()
        || !m_viewer->currentScene()->boundingBox().isValid())
    {
        return;
    }

   cvf::Vec3d pointOfInterest = m_viewer->currentScene()->boundingBox().center();

   this->setPointOfInterest(pointOfInterest);
}

//--------------------------------------------------------------------------------------------------
/// 
//--------------------------------------------------------------------------------------------------
cvf::Vec3d caf::CeetronNavigation::pointOfInterest()
{
    initializeRotationCenter();
    return m_pointOfInterest;
}

//--------------------------------------------------------------------------------------------------
/// 
//--------------------------------------------------------------------------------------------------
void caf::CeetronNavigation::setPointOfInterest(cvf::Vec3d poi)
{
    m_pointOfInterest = poi;
    m_trackball->setRotationPoint(poi);
    m_isRotCenterInitialized = true;
    m_viewer->updateParallelProjectionCameraPosFromPointOfInterestMove(m_pointOfInterest);

}