#include "python/points.hpp"
#include "python/num_util.hpp"
#include "python/slice.hpp"
#include "util/sorted_model.hpp"
#include "util/errors.hpp"
#include "util/gl_enable.hpp"

#include "wrap_gl.hpp"

#include <vector>
#include <sstream>
#include <algorithm>
#include <set>

namespace cvisual { namespace python {

using boost::python::make_tuple;
using boost::python::object;

points::points()
	: size_units(PIXELS), points_shape(ROUND), size( 5.0)
{
}

void points::set_size( float size) {
	this->size = size;
}

void points::set_points_shape( const std::string& n_type)
{
	if (n_type == "round") {
		points_shape = ROUND;
	}
	else if (n_type == "square") {
		points_shape = SQUARE;
	}
	else
		throw std::invalid_argument( "Unrecognized shape type");
}

std::string points::get_points_shape( void)
{
	switch (points_shape) {
		case ROUND:
			return "round";
		case SQUARE:
			return "square";
		default:
			return "";
	}
}

void points::set_size_units( const std::string& n_type)
{
	if (n_type == "pixels") {
		size_units = PIXELS;
	}
	else if (n_type == "world") {
		size_units = WORLD;
	}
	else
		throw std::invalid_argument( "Unrecognized coordinate type");
}

std::string points::get_size_units( void)
{
	switch (size_units) {
		case PIXELS:
			return "pixels";
		case WORLD:
			return "world";
		default:
			return "";
	}
}

bool
points::degenerate() const {
	return count == 0;
}

struct point_coord
{
	vector center;
	mutable rgb color;
	inline point_coord( const vector& p, const rgb& c)
		: center( p), color(c)
	{}
};

void
points::gl_render( const view& scene)
{
	if (degenerate())
		return;

	std::vector<point_coord> translucent_points;
	typedef std::vector<point_coord>::iterator translucent_iterator;

	std::vector<point_coord> opaque_points;
	typedef std::vector<point_coord>::iterator opaque_iterator;

	const double* pos_i = pos.data();
	const double* pos_end = pos.end();

	const double* color_i = color.data();
	const double* color_end = color.end();

	// Currently points can not be translucent, so comment out all translucent code
	for ( ; pos_i < pos_end && color_i < color_end; pos_i += 3, color_i += 3) {
		opaque_points.push_back( point_coord( vector(pos_i), rgb(color_i)));
	}

	/*
	// First classify each point based on whether or not it is translucent
	if (points_shape == ROUND) { // Every point must be depth sorted
		for ( ; pos_i < pos_end && color_i < color_end; pos_i += 3, color_i += 3) {
			translucent_points.push_back( point_coord( vector(pos_i), rgb(color_i)));
		}
	}
	else { // Only translucent points need to be depth-sorted
		for ( ; pos_i < pos_end && color_i < color_end; pos_i += 3, color_i += 3) {
			if (0) // opacity not done
				translucent_points.push_back( point_coord( vector(pos_i), rgb(color_i)));
			else
				opaque_points.push_back( point_coord( vector(pos_i), rgb(color_i)));
		}
	}
	*/

	// Now conditionally apply transformations for gcf and anaglyph color
// Needs work
//	if (translucent_points.size())
//		renderable::color.opacity = 0.5;
	if (scene.gcf != 1.0 || (scene.gcfvec[0] != scene.gcfvec[1])) {
		for (opaque_iterator i = opaque_points.begin(); i != opaque_points.end(); ++i) {
			i->center = (i->center).scale(scene.gcfvec);
		}
		/*
		for (translucent_iterator i = translucent_points.begin(); i != translucent_points.end(); ++i) {
			i->center = (i->center).scale(scene.gcfvec);
		}
		*/
	}
	if (scene.anaglyph) {
		if (scene.coloranaglyph) {
			for (opaque_iterator i = opaque_points.begin(); i != opaque_points.end(); ++i) {
				i->color = i->color.desaturate();
			}
			/*
			for (translucent_iterator i = translucent_points.begin(); i != translucent_points.end(); ++i) {
				i->color = i->color.desaturate();
			}
			*/
		}
		else {
			for (opaque_iterator i = opaque_points.begin(); i != opaque_points.end(); ++i) {
				i->color = i->color.grayscale();
			}
			/*
			for (translucent_iterator i = translucent_points.begin(); i != translucent_points.end(); ++i) {
				i->color = i->color.grayscale();
			}
			*/
		}
	}
	/*
	// Sort the translucent points
	if (!translucent_points.empty()) {
		std::stable_sort( translucent_points.begin(), translucent_points.end(),
			face_z_comparator(scene.forward));
	}
	*/

	clear_gl_error();

	if (points_shape == ROUND)
		glEnable( GL_POINT_SMOOTH);

	if (size_units == WORLD && scene.glext.ARB_point_parameters) {
		// This is simpler and more robust than what was here before, but it's still
		// a little tacky and probably not perfectly general.  I'm not sure that it
		// should work with stereo frustums, but I can't find a case where it's
		// obviously wrong.
		// However, note that point attenuation (regardless of parameters) isn't a
		// correct perspective calculation, because it divides by distance, not by Z.
		// Points not at the center of the screen will be too small, particularly
		// at high fields of view.  This is in addition to the implementation limits
		// on point size, which will be a problem when points get too big or close.

		tmatrix proj; proj.gl_projection_get();  // Projection matrix

		vector p = (proj * vertex(.5,0,1,1)).project();  // eye coordinates .5,0,1 -> window coordinates

		// At an eye z of 1, a sphere of world-space diameter 1 is p.x * scene.view_width pixels wide,
		// so a sphere of world-space diameter (size*scene.gcf) is
		double point_radius_at_z_1 = size * scene.gcf * p.x * scene.view_width;

		float attenuation_eqn[] =  { 0.0f, 0.0f, 1.0f / (float)(point_radius_at_z_1*point_radius_at_z_1) };
		scene.glext.glPointParameterfvARB( GL_POINT_DISTANCE_ATTENUATION_ARB, attenuation_eqn);
		glPointSize( 1 );
	}
	else if (size_units == PIXELS) {
		// Restore to default (aka, disable attenuation)
		if (scene.glext.ARB_point_parameters) {
			float attenuation_eqn[] = {1.0f, 0.0f, 0.0f};
			scene.glext.glPointParameterfvARB( GL_POINT_DISTANCE_ATTENUATION_ARB, attenuation_eqn);
		}
		if (points_shape == ROUND) {
			glPointSize( size );
		}
		else {
			glPointSize( size );
		}
	}
	// Finish GL state prep
	gl_disable ltg( GL_LIGHTING);
	gl_enable_client v( GL_VERTEX_ARRAY);
	gl_enable_client c( GL_COLOR_ARRAY);

	// Render opaque points (if any)
	if (opaque_points.size()) {
		const std::ptrdiff_t chunk = 256;
		opaque_iterator begin = opaque_points.begin();
		opaque_iterator end = opaque_points.end();
		while (begin < end) {
			std::ptrdiff_t block = std::min( chunk, end - begin);
			glColorPointer( 3, GL_FLOAT, sizeof(point_coord), &begin->color.red);
			glVertexPointer( 3, GL_DOUBLE, sizeof(point_coord), &begin->center.x);
			glDrawArrays( GL_POINTS, 0, block);
			begin += block;
		}
	}

	/*
	// Render translucent points (if any)
	if (!translucent_points.empty()) {
		const std::ptrdiff_t chunk = 256;
		translucent_iterator begin = translucent_points.begin();
		translucent_iterator end = translucent_points.end();
		while (begin < end) {
			std::ptrdiff_t block = std::min( chunk, end - begin);
			glColorPointer( 3, GL_FLOAT, sizeof(point_coord), &begin->color.red);
			glVertexPointer( 3, GL_DOUBLE, sizeof(point_coord), &begin->center.x);
			glDrawArrays( GL_POINTS, 0, block);
			begin += block;
		}
	}
	*/

	if (points_shape == ROUND) {
		glDisable( GL_POINT_SMOOTH);
	}
	check_gl_error();
}

vector
points::get_center() const
{
	if (degenerate() || points_shape != ROUND)
		return vector();
	vector ret;
	const double* pos_i = pos.data();
	for(size_t i=0; i<count; i++, pos_i+=3)
		ret += vector(pos_i);
	ret /= count;
	return ret;
}

void
points::gl_pick_render( const view& scene)
{
	gl_render( scene);
}

void
points::grow_extent( extent& world)
{
	if (degenerate())
		return;
	const double* pos_i = pos.data();
	const double* pos_end = pos.end();
	if (size_units == PIXELS)
		for ( ; pos_i < pos_end; pos_i += 3)
			world.add_point( vector(pos_i));
	else
		for ( ; pos_i < pos_end; pos_i += 3)
			world.add_sphere( vector(pos_i), size);
	world.add_body();
}

void points::outer_render( const view& v ) {
	gl_render(v);  //< no materials
}


} } // !namespace cvisual::python