/* osgVisual test. distortionNG, experimental.
*
*  Permission is hereby granted, free of charge, to any person obtaining a copy
*  of this software and associated documentation files (the "Software"), to deal
*  in the Software without restriction, including without limitation the rights
*  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
*  copies of the Software, and to permit persons to whom the Software is
*  furnished to do so, subject to the following conditions:
*
*  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
*  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
*  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
*  AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
*  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
*  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
*  THE SOFTWARE.
*/

#include "DistortionManipulator.h"

#include<osgViewer/Viewer>
#include<osg/Point>

using namespace osg;
using namespace osgViewer;


DistortionManipulator::DistortionManipulator(DistortionSet* ds)
 : _highlightColor( osg::Vec4(1.0f, 1.0f, 0.0f, 1.0f) ), _distortionSet( ds )
{
	activeSetupMode = DISABLED;
	activeDistortionMode = MESH;
	activeManualSetupMode = DISTORTION;
	activeVisualizationMode = NONE;

	_highlighter = NULL;
	
	createVertexHighlighter();

	_camera = 0;
	//_distortionMesh(distortionMesh)
}

DistortionManipulator::~DistortionManipulator()
{
}

void DistortionManipulator::getUsage(osg::ApplicationUsage& usage) const
{
    usage.addKeyboardMouseBinding("Keypad 7","Show distortion mesh / intensity map / none.");
	usage.addKeyboardMouseBinding("Keypad 8","Save distortion set.");	// via plugin
	usage.addKeyboardMouseBinding("Keypad 4","Toggles Setup Mode between DISABLED, MANUAL & DELEGATED.");
 	usage.addKeyboardMouseBinding("Keypad 5","MANUAL Mode: Toggle between blending & distortion setup.");
	usage.addKeyboardMouseBinding("Keypad 6","MANUAL Mode: Toggle if distortion drags affect mesh or rtt texture coordinates.");	// Defaults to Mesh
	usage.addKeyboardMouseBinding("Keypad 1","Reset distortion.");
	usage.addKeyboardMouseBinding("Keypad 2","Reset intensity blending.");
}

bool DistortionManipulator::handle(const osgGA::GUIEventAdapter& ea, osgGA::GUIActionAdapter& aa, osg::Object* obj, osg::NodeVisitor* nv)
{
	switch(ea.getEventType())
    {
        case(osgGA::GUIEventAdapter::MOVE): break;
        case(osgGA::GUIEventAdapter::DRAG):
		{
			if ( activeSetupMode == MANUAL)
			{
				osg::notify(osg::ALWAYS)<<std::endl<<"Drag:"<<std::endl<<"ea.getGraphicsContext()="<<ea.getGraphicsContext()<<std::endl;
				osg::notify(osg::ALWAYS)<<"ea.getXnormalized()="<<ea.getXnormalized()<<std::endl;
				osg::notify(osg::ALWAYS)<<"ea.getYnormalized()="<<ea.getYnormalized()<<std::endl;
				osg::notify(osg::ALWAYS)<<"ea.getX()="<<ea.getX()<<std::endl;
				osg::notify(osg::ALWAYS)<<"ea.getXin()="<<ea.getXmin()<<std::endl;
				osg::notify(osg::ALWAYS)<<"ea.getXmax()="<<ea.getXmax()<<std::endl;
				osg::notify(osg::ALWAYS)<<"ea.getY()="<<ea.getY()<<std::endl;
				osg::notify(osg::ALWAYS)<<"ea.getYin()="<<ea.getYmin()<<std::endl;
				osg::notify(osg::ALWAYS)<<"ea.getYmax()="<<ea.getYmax()<<std::endl;

				return true;	// true means event handled: not forwarded to the camera manipulator;
			}
			break;

		}
        case(osgGA::GUIEventAdapter::PUSH):
		{
			OSG_ALWAYS<<"mouse click!"<<std::endl;
			if ( activeSetupMode == MANUAL && ea.getModKeyMask()&osgGA::GUIEventAdapter::MODKEY_CTRL && ea.getButton() == osgGA::GUIEventAdapter::LEFT_MOUSE_BUTTON )
			{
				osgViewer::View* viewer = dynamic_cast<osgViewer::View*>(&aa);
				if ( viewer )
				{
					osg::notify(osg::ALWAYS)<<std::endl<<"Intersection:"<<std::endl<<"ea.getX()="<<ea.getX()<<std::endl;
					osg::notify(osg::ALWAYS)<<"ea.getY()="<<ea.getY()<<std::endl;
					osg::ref_ptr<osgUtil::LineSegmentIntersector> intersector = new osgUtil::LineSegmentIntersector(osgUtil::Intersector::PROJECTION, ea.getX(), ea.getY());
					osgUtil::IntersectionVisitor iv( intersector.get() );
					_distortionSet->getDistortionCamera()->accept( iv );
			        
					if ( intersector->containsIntersections() )
					{
						osgUtil::LineSegmentIntersector::Intersection& result = *(intersector->getIntersections().begin());
						computeSelectedVertex( result );
					}
				}
			}
			break;
		}
        case(osgGA::GUIEventAdapter::RELEASE): break;
        case(osgGA::GUIEventAdapter::KEYDOWN):
		{
			if (ea.getKey()==osgGA::GUIEventAdapter::KEY_KP_End)	// KP 1: reset distortion
			{
				resetDistortion();
				return(true);
			}
			if (ea.getKey()==osgGA::GUIEventAdapter::KEY_KP_Down)	// KP 2: reset intensity map
			{
				resetIntensityMap();
				return(true);
			}
			if (ea.getKey()==osgGA::GUIEventAdapter::KEY_KP_Left)	// KP 4: Toggles Setup Mode between DISABLED, MANUAL & DELEGATED.
			{
				switch(activeSetupMode)
				{
					case DISABLED : 
					{
						activeSetupMode = MANUAL;
						OSG_ALWAYS<<"SetupMode MANUAL activated"<<std::endl;
						_distortionSet->getDistortionInternals()->setValue(1, true); // per definition #0 = mesh, #1 = highlighter
						break;
					}
					case MANUAL :
					{
						activeSetupMode = DELEGATED;
						_distortionSet->getDistortionInternals()->setValue(1, false); // per definition #0 = mesh, #1 = highlighter
						OSG_ALWAYS<<"SetupMode DELEGATED activated"<<std::endl;
						break;
					}
					case DELEGATED :
					{
						activeSetupMode = DISABLED;
						_distortionSet->getDistortionInternals()->setValue(1, false); // per definition #0 = mesh, #1 = highlighter
						OSG_ALWAYS<<"SetupMode DISABLED activated"<<std::endl;
						break;
					}
				}

				return(true);
			}
			if (ea.getKey()==osgGA::GUIEventAdapter::KEY_KP_Begin)	// KP 5: MANUAL Mode: Toggle between blending & distortion setup.
			{

				activeManualSetupMode = (activeManualSetupMode==DISTORTION?BLENDING:DISTORTION);
				OSG_ALWAYS<<"KEY_KP_5 : activeManualSetupMode is now "<<activeManualSetupMode<<std::endl;
				return(true);
			}
			if (ea.getKey()==osgGA::GUIEventAdapter::KEY_KP_Right)	// KP 6: MANUAL Mode: Toggle if distortion drags affect mesh or rtt texture coordinates -> defaults to Mesh
			{
				activeDistortionMode = (activeDistortionMode==MESH?TEXCOORDINATES:MESH);
				OSG_ALWAYS<<"KEY_KP_6 : activeDistortionMode is now "<<activeDistortionMode<<std::endl;
				return(true);
			}
			if (ea.getKey()==osgGA::GUIEventAdapter::KEY_KP_Home)	// KP 7: Show distortion mesh / intensity map / none.
			{
				switch(activeVisualizationMode)
				{	
					case DISTORTION_MESH : 
					{
						activeVisualizationMode = INTENSITY_MAP;
						showDistortionMesh(true);
						showIntensityMap(false);
						break;
					}
					case INTENSITY_MAP :
					{
						activeVisualizationMode = NONE;
						showDistortionMesh(false);
						showIntensityMap(true);
						break;
					}
					case NONE : 
					{
						activeVisualizationMode = DISTORTION_MESH;
						showDistortionMesh(false);
						showIntensityMap(false);
						break;
					}
				}


				OSG_ALWAYS<<"KEY_KP_7 : activeVisualizationMode is now "<<activeVisualizationMode<<std::endl<<std::endl;
				return(true);
			}
			if (ea.getKey()==osgGA::GUIEventAdapter::KEY_KP_Up)	// KP 8: Save distortion set	 via plugin
			{
				OSG_ALWAYS<<"KEY_KP_8 : todo: Save DistortionContainer"<<std::endl;
				return(true);
			}
			

			return false;	// Event ignored
		}
        case(osgGA::GUIEventAdapter::KEYUP): break;
		case(osgGA::GUIEventAdapter::FRAME):
		{
			//OSG_ALWAYS<<"FRAME!"<<std::endl;
			break;
		}
        case (osgGA::GUIEventAdapter::RESIZE):	// todo: adapt distortion mesh to new screen size
		{
			OSG_ALWAYS<<"RESIZE!"<<std::endl;
			break;
		}

        default:
            return false;
    }
    return false;
}

void DistortionManipulator::resetIntensityMap()
{
	if(!_distortionSet.valid())
		return;

	osg::ref_ptr<osg::Image> image = _distortionSet->getIntensityMap();

	OSG_ALWAYS<<"Reseting IntensityMap Blending."<<std::endl;

	if (!image->isDataContiguous())
	{
		OSG_WARN<<"Warning: DistortionManipulator does not support working with non contiguous imagery as blendmaps!"<<std::endl;
		return;
	}

	// Fill intensity map with 255 
	unsigned char* dataPtr = image->data(); 
	for(unsigned int i=0;i<image->getTotalSizeInBytes();i++)
	{
		*dataPtr++ = 255; 
	}
	image->dirty();
}

void DistortionManipulator::resetDistortion()
{
	if(!_distortionSet.valid())
		return;

	OSG_ALWAYS<<"ToDo: resetDistortion()"<<std::endl;
}

void DistortionManipulator::showDistortionMesh(bool show)
{
	OSG_ALWAYS<<"ToDo: showDistortionMesh(bool) is now "<<show<<std::endl;

	// Todo: Stateset muss das von der MeshGeode sein.

   /* osg::PolygonMode* polyModeObj = dynamic_cast<osg::PolygonMode*>(_stateset->getAttribute(osg::StateAttribute::POLYGONMODE));
    if (!polyModeObj)
    {
        polyModeObj = new osg::PolygonMode;
        _stateset->setAttribute(polyModeObj);
    }
 
	if(show)
		polyModeObj->setMode(osg::PolygonMode::FRONT_AND_BACK,osg::PolygonMode::LINE);
	else
		polyModeObj->setMode(osg::PolygonMode::FRONT_AND_BACK,osg::PolygonMode::FILL);*/
}

void DistortionManipulator::showIntensityMap(bool show)
{
		OSG_ALWAYS<<"ToDo: showIntensityMap(bool) is now "<<show<<std::endl;

		if(_distortionSet.valid())
			_distortionSet->setShowIntensityMapOnly(show);
}

void DistortionManipulator::createVertexHighlighter()
{
	osg::ref_ptr<osg::Vec4Array> colors = new osg::Vec4Array(1);
	(*colors)[0] = _highlightColor;

	_highlighter = new osg::Geometry;
	_highlighter->setDataVariance( osg::Object::DYNAMIC );
	_highlighter->setUseDisplayList( false );
	_highlighter->setUseVertexBufferObjects( true );
	_highlighter->setVertexArray( new osg::Vec3Array(1) );	// The highlighter vertex is updated by computeSelectedVertex(..)
	_highlighter->setColorArray( colors.get() );
	_highlighter->setColorBinding( osg::Geometry::BIND_OVERALL );
	_highlighter->addPrimitiveSet( new osg::DrawArrays(GL_POINTS, 0, 1) );

	
	osg::ref_ptr<osg::Geode> geode = new osg::Geode;
	geode->addDrawable( _highlighter.get() );
	geode->getOrCreateStateSet()->setAttributeAndModes( new osg::Point(8.0f) );
	geode->getOrCreateStateSet()->setMode( GL_LIGHTING, osg::StateAttribute::OFF );
	geode->setCullingActive(false);	// disable the culling for the selector, otherwise the selector is culled away on the edge.

	_distortionSet->getDistortionInternals()->addChild(geode, false);
}

void DistortionManipulator::computeSelectedVertex( osgUtil::LineSegmentIntersector::Intersection& result )
{
	osg::Geometry* geom = dynamic_cast<osg::Geometry*>( result.drawable.get() );
	if ( !geom || geom==_highlighter )
		return;

	osg::Vec3Array* vertices = dynamic_cast<osg::Vec3Array*>( geom->getVertexArray() );
	osg::Vec3Array* selVertices = dynamic_cast<osg::Vec3Array*>( _highlighter->getVertexArray() );
	if ( !vertices || !selVertices )
		return;
	
	OSG_NOTIFY(osg::ALWAYS)<<"size of vertices="<<vertices->size()<<std::endl;
	OSG_NOTIFY(osg::ALWAYS)<<"size of selVertices="<<selVertices->size()<<std::endl;

	osg::Vec3 point = result.getWorldIntersectPoint();
	osg::Matrix matrix = osg::computeLocalToWorld( result.nodePath );	// To compute the intersection vertices in world coordinates not in model coordinates
	OSG_NOTIFY(osg::ALWAYS) << "Intersection-indices: Size=" << result.indexList.size() << std::endl;
	const std::vector<unsigned int>& selIndices = result.indexList;
	{
		double maxRatio = 0.0;
		int closestVertexIndex = 0;
		for ( unsigned int i=0; i<3 && i<result.ratioList.size(); i++ )	//iterate through rations and search for maxRation=nearestVertex
		{
			if(result.ratioList[i] > maxRatio)
			{
				maxRatio = result.ratioList[i];
				closestVertexIndex = result.indexList[i];
			}
			OSG_NOTIFY(osg::ALWAYS)<<"maxRatio="<<maxRatio<<std::endl;
			OSG_NOTIFY(osg::ALWAYS)<<"closestVertexIndex="<<closestVertexIndex<<std::endl;
		}
		OSG_NOTIFY(osg::ALWAYS)<<"nearest vertex: X="<<(*vertices)[closestVertexIndex].x()<<" Y="<<(*vertices)[closestVertexIndex].y()<<" Z="<<(*vertices)[closestVertexIndex].z()<<std::endl;
		osg::Vec3 vertex = (*vertices)[closestVertexIndex] * matrix;

		selVertices->front() = vertex;		
		OSG_NOTIFY(osg::ALWAYS)<<"selected vertice: X="<<vertex.x()<<" Y="<<vertex.y()<<" Z="<<vertex.z()<<std::endl;
	}
	selVertices->dirty();
	_highlighter->dirtyBound(); 
}