#if !defined( INCLUDED_DRAGPLANES_H )
#define INCLUDED_DRAGPLANES_H

#include "selectable.h"
#include "selectionlib.h"
#include "math/aabb.h"
#include "math/line.h"

class DragPlanes
{
public:
ObservedSelectable m_selectable_right;   // +x
ObservedSelectable m_selectable_left;   // -x
ObservedSelectable m_selectable_front;   // +y
ObservedSelectable m_selectable_back;   // -y
ObservedSelectable m_selectable_top;   // +z
ObservedSelectable m_selectable_bottom;   // -z
Vector3 m_dragPlanesMin;
Vector3 m_dragPlanesMax;
Vector3 m_dragPlanesOrigin;
Vector3 m_dragPlanesExtents;

DragPlanes( const SelectionChangeCallback& onchanged ) :
	m_selectable_right( onchanged ),
	m_selectable_left( onchanged ),
	m_selectable_front( onchanged ),
	m_selectable_back( onchanged ),
	m_selectable_top( onchanged ),
	m_selectable_bottom( onchanged ){
}
bool isSelected() const {
	return m_selectable_right.isSelected()
		   || m_selectable_left.isSelected()
		   || m_selectable_front.isSelected()
		   || m_selectable_back.isSelected()
		   || m_selectable_top.isSelected()
		   || m_selectable_bottom.isSelected();
}
void setSelected( bool selected ){
	m_selectable_right.setSelected( selected );
	m_selectable_left.setSelected( selected );
	m_selectable_front.setSelected( selected );
	m_selectable_back.setSelected( selected );
	m_selectable_top.setSelected( selected );
	m_selectable_bottom.setSelected( selected );
}
void selectPlanes( const AABB& aabb, Selector& selector, SelectionTest& test, const PlaneCallback& selectedPlaneCallback ){
	Line line( test.getNear(), test.getFar() );
	Vector3 corners[8];
	aabb_corners( aabb, corners );
	Plane3 planes[6];
	aabb_planes( aabb, planes );

	for ( Vector3* i = corners; i != corners + 8; ++i )
	{
		*i = vector3_subtracted( line_closest_point( line, *i ), *i );
	}

	if ( vector3_dot( planes[0].normal(), corners[1] ) > 0
		 && vector3_dot( planes[0].normal(), corners[2] ) > 0
		 && vector3_dot( planes[0].normal(), corners[5] ) > 0
		 && vector3_dot( planes[0].normal(), corners[6] ) > 0 ) {
		Selector_add( selector, m_selectable_right );
		selectedPlaneCallback( planes[0] );
		//globalOutputStream() << "right\n";
	}
	if ( vector3_dot( planes[1].normal(), corners[0] ) > 0
		 && vector3_dot( planes[1].normal(), corners[3] ) > 0
		 && vector3_dot( planes[1].normal(), corners[4] ) > 0
		 && vector3_dot( planes[1].normal(), corners[7] ) > 0 ) {
		Selector_add( selector, m_selectable_left );
		selectedPlaneCallback( planes[1] );
		//globalOutputStream() << "left\n";
	}
	if ( vector3_dot( planes[2].normal(), corners[0] ) > 0
		 && vector3_dot( planes[2].normal(), corners[1] ) > 0
		 && vector3_dot( planes[2].normal(), corners[4] ) > 0
		 && vector3_dot( planes[2].normal(), corners[5] ) > 0 ) {
		Selector_add( selector, m_selectable_front );
		selectedPlaneCallback( planes[2] );
		//globalOutputStream() << "front\n";
	}
	if ( vector3_dot( planes[3].normal(), corners[2] ) > 0
		 && vector3_dot( planes[3].normal(), corners[3] ) > 0
		 && vector3_dot( planes[3].normal(), corners[6] ) > 0
		 && vector3_dot( planes[3].normal(), corners[7] ) > 0 ) {
		Selector_add( selector, m_selectable_back );
		selectedPlaneCallback( planes[3] );
		//globalOutputStream() << "back\n";
	}
	if ( vector3_dot( planes[4].normal(), corners[0] ) > 0
		 && vector3_dot( planes[4].normal(), corners[1] ) > 0
		 && vector3_dot( planes[4].normal(), corners[2] ) > 0
		 && vector3_dot( planes[4].normal(), corners[3] ) > 0 ) {
		Selector_add( selector, m_selectable_top );
		selectedPlaneCallback( planes[4] );
		//globalOutputStream() << "top\n";
	}
	if ( vector3_dot( planes[5].normal(), corners[4] ) > 0
		 && vector3_dot( planes[5].normal(), corners[5] ) > 0
		 && vector3_dot( planes[5].normal(), corners[6] ) > 0
		 && vector3_dot( planes[5].normal(), corners[7] ) > 0 ) {
		Selector_add( selector, m_selectable_bottom );
		//globalOutputStream() << "bottom\n";
		selectedPlaneCallback( planes[5] );
	}

	m_dragPlanesMin = aabb.origin - aabb.extents;
	m_dragPlanesMax = aabb.origin + aabb.extents;
	m_dragPlanesOrigin = aabb.origin;
	m_dragPlanesExtents = aabb.extents;
}
void selectReversedPlanes( const AABB& aabb, Selector& selector, const SelectedPlanes& selectedPlanes ){
	Plane3 planes[6];
	aabb_planes( aabb, planes );

	if ( selectedPlanes.contains( plane3_flipped( planes[0] ) ) ) {
		Selector_add( selector, m_selectable_right );
	}
	if ( selectedPlanes.contains( plane3_flipped( planes[1] ) ) ) {
		Selector_add( selector, m_selectable_left );
	}
	if ( selectedPlanes.contains( plane3_flipped( planes[2] ) ) ) {
		Selector_add( selector, m_selectable_front );
	}
	if ( selectedPlanes.contains( plane3_flipped( planes[3] ) ) ) {
		Selector_add( selector, m_selectable_back );
	}
	if ( selectedPlanes.contains( plane3_flipped( planes[4] ) ) ) {
		Selector_add( selector, m_selectable_top );
	}
	if ( selectedPlanes.contains( plane3_flipped( planes[5] ) ) ) {
		Selector_add( selector, m_selectable_bottom );
	}
}
void translate( const Vector3& translation ){
	if ( m_dragPlanesExtents[0] != 0 ) {
		if ( m_selectable_right.isSelected() ) {
			m_dragPlanesMax[0] += translation[0];
			//globalOutputStream() << "moving right\n";
		}
		if ( m_selectable_left.isSelected() ) {
			m_dragPlanesMin[0] += translation[0];
			//globalOutputStream() << "moving left\n";
		}
	}
	if ( m_dragPlanesExtents[1] != 0 ) {
		if ( m_selectable_front.isSelected() ) {
			m_dragPlanesMax[1] += translation[1];
			//globalOutputStream() << "moving front\n";
		}
		if ( m_selectable_back.isSelected() ) {
			m_dragPlanesMin[1] += translation[1];
			//globalOutputStream() << "moving back\n";
		}
	}
	if ( m_dragPlanesExtents[2] != 0 ) {
		if ( m_selectable_top.isSelected() ) {
			m_dragPlanesMax[2] += translation[2];
			//globalOutputStream() << "moving top\n";
		}
		if ( m_selectable_bottom.isSelected() ) {
			m_dragPlanesMin[2] += translation[2];
			//globalOutputStream() << "moving bottom\n";
		}
	}
}
Matrix4 evaluateTransform() const {
	Vector3 originTransformed( vector3_mid( m_dragPlanesMin, m_dragPlanesMax ) );
	Vector3 scale( vector3_scaled( vector3_subtracted( m_dragPlanesMax, m_dragPlanesMin ), 0.5 ) );

	if ( m_dragPlanesExtents[0] != 0 ) {
		scale[0] /= m_dragPlanesExtents[0];
	}
	else
	{
		scale[0] = 1;
	}
	if ( m_dragPlanesExtents[1] != 0 ) {
		scale[1] /= m_dragPlanesExtents[1];
	}
	else
	{
		scale[1] = 1;
	}
	if ( m_dragPlanesExtents[2] != 0 ) {
		scale[2] /= m_dragPlanesExtents[2];
	}
	else
	{
		scale[2] = 1;
	}

	Matrix4 matrix( matrix4_translation_for_vec3( originTransformed - m_dragPlanesOrigin ) );
	matrix4_pivoted_scale_by_vec3( matrix, scale, m_dragPlanesOrigin );

	return matrix;
}
};

#endif