/*
 * Copyright 2006-2007, 2023, Haiku.
 * Distributed under the terms of the MIT License.
 *
 * Authors:
 *		Stephan Aßmus <superstippi@gmx.de>
 *		Zardshard
 */


#include "PerspectiveTransformer.h"

#include <new>
#include <stdio.h>

#include <agg_basics.h>
#include <agg_bounding_rect.h>
#include <Message.h>

#include "Shape.h"


_USING_ICON_NAMESPACE
using std::nothrow;


PerspectiveTransformer::PerspectiveTransformer(VertexSource& source, Shape* shape)
	: Transformer("Perspective"),
	  PathTransformer(source),
	  Perspective(source, *this),
	  fShape(shape)
#ifdef ICON_O_MATIC
	, fInverted(false)
#endif
{
#ifdef ICON_O_MATIC
	if (fShape != NULL) {
		fShape->AcquireReference();
		fShape->AddObserver(this);
		ObjectChanged(fShape); // finish initialization
	}
#endif
}


PerspectiveTransformer::PerspectiveTransformer(
		VertexSource& source, Shape* shape, BMessage* archive)
	: Transformer(archive),
	  PathTransformer(source),
	  Perspective(source, *this),
	  fShape(shape)
#ifdef ICON_O_MATIC
	, fInverted(false)
#endif
{
	double matrix[9];
	for (int i = 0; i < 9; i++) {
		if (archive->FindDouble("matrix", i, &matrix[i]) != B_OK)
			matrix[i] = 0;
	}
	load_from(matrix);

#ifdef ICON_O_MATIC
	if (fShape != NULL) {
		fShape->AcquireReference();
		fShape->AddObserver(this);
		ObjectChanged(fShape); // finish initialization
	}
#endif
}


PerspectiveTransformer::PerspectiveTransformer(const PerspectiveTransformer& other)
#ifdef ICON_O_MATIC
	: Transformer(other.Name()),
#else
	: Transformer(""),
#endif
	  PathTransformer(*other.fSource),
	  Perspective(*fSource, *this),
	  fShape(other.fShape)
#ifdef ICON_O_MATIC
	, fInverted(other.fInverted),
	  fFromBox(other.fFromBox),
	  fToLeftTop(other.fToLeftTop),
	  fToRightTop(other.fToRightTop),
	  fToLeftBottom(other.fToLeftBottom),
	  fToRightBottom(other.fToRightBottom),
	  fValid(other.fValid)
#endif
{
	double matrix[9];
	other.store_to(matrix);
	load_from(matrix);

#ifdef ICON_O_MATIC
	if (fShape != NULL) {
		fShape->AcquireReference();
		fShape->AddObserver(this);
	}
#endif
}


PerspectiveTransformer::~PerspectiveTransformer()
{
#ifdef ICON_O_MATIC
	if (fShape != NULL) {
		fShape->RemoveObserver(this);
		fShape->ReleaseReference();
	}
#endif
}


// #pragma mark -


Transformer*
PerspectiveTransformer::Clone() const
{
	return new (nothrow) PerspectiveTransformer(*this);
}


// #pragma mark -


void
PerspectiveTransformer::rewind(unsigned path_id)
{
	Perspective::rewind(path_id);
}


unsigned
PerspectiveTransformer::vertex(double* x, double* y)
{
#ifdef ICON_O_MATIC
	if (fValid)
		return Perspective::vertex(x, y);
	else
		return agg::path_cmd_stop;
#else
	return Perspective::vertex(x, y);
#endif
}


void
PerspectiveTransformer::SetSource(VertexSource& source)
{
	PathTransformer::SetSource(source);
	Perspective::attach(source);

#ifdef ICON_O_MATIC
	ObjectChanged(fShape);
#endif
}


double
PerspectiveTransformer::ApproximationScale() const
{
	return fSource->ApproximationScale() * scale();
}


// #pragma mark -


void
PerspectiveTransformer::Invert()
{
#ifdef ICON_O_MATIC
	fInverted = !fInverted;

	// TODO: degenerate matrices may not be adequately handled
	bool degenerate = !invert();
	fValid = fValid && !degenerate;
#else
	invert();
#endif
}


// #pragma mark -


#ifdef ICON_O_MATIC

status_t
PerspectiveTransformer::Archive(BMessage* into, bool deep) const
{
	status_t ret = Transformer::Archive(into, deep);

	into->what = archive_code;

	double matrix[9];
	store_to(matrix);

	for (int i = 0; i < 9; i++) {
		if (ret == B_OK)
			ret = into->AddDouble("matrix", matrix[i]);
	}

	return ret;
}


// #prama mark -


void
PerspectiveTransformer::ObjectChanged(const Observable* object)
{
	if (fInverted) {
		printf("calculating the validity or bounding box of an inverted "
			"perspective transformer is currently unsupported.");
		return;
	}

	uint32 pathID[1];
	pathID[0] = 0;
	double left, top, right, bottom;
	agg::bounding_rect(*fSource, pathID, 0, 1, &left, &top, &right, &bottom);
	BRect newFromBox = BRect(left, top, right, bottom);

	// Stop if nothing we care about has changed
	// TODO: Can this be done earlier? It would be nice to avoid having to
	// recalculate the bounding box before realizing nothing needs to be done.
    if (fFromBox == newFromBox)
		return;

	fFromBox = newFromBox;

	_CheckValidity();

	double x = fFromBox.left; double y = fFromBox.top;
	Transform(&x, &y);
	fToLeftTop = BPoint(x, y);

	x = fFromBox.right; y = fFromBox.top;
	Transform(&x, &y);
	fToRightTop = BPoint(x, y);

	x = fFromBox.left; y = fFromBox.bottom;
	Transform(&x, &y);
	fToLeftBottom = BPoint(x, y);

	x = fFromBox.right; y = fFromBox.bottom;
	Transform(&x, &y);
	fToRightBottom = BPoint(x, y);
}


// #pragma mark -


void
PerspectiveTransformer::TransformTo(
	BPoint leftTop, BPoint rightTop, BPoint leftBottom, BPoint rightBottom)
{
	fToLeftTop = leftTop;
	fToRightTop = rightTop;
	fToLeftBottom = leftBottom;
	fToRightBottom = rightBottom;

	double quad[8] = {
		fToLeftTop.x, fToLeftTop.y,
		fToRightTop.x, fToRightTop.y,
		fToRightBottom.x, fToRightBottom.y,
		fToLeftBottom.x, fToLeftBottom.y
	};

	if (!fInverted) {
		rect_to_quad(
			fFromBox.left, fFromBox.top,
			fFromBox.right, fFromBox.bottom, quad);
	} else {
		quad_to_rect(quad,
			fFromBox.left, fFromBox.top,
			fFromBox.right, fFromBox.bottom);
	}

	_CheckValidity();
	Notify();
}


// #pragma mark -


void
PerspectiveTransformer::_CheckValidity()
{
	// Checks that none of the points are too close to the camera. These tend to
	// lead to very big numbers or a divide by zero error. Also checks that all
	// points are on the same side of the camera. Transformations with points on
	// different sides of the camera look weird and tend to cause crashes.

	fValid = true;
	double w;
	bool positive;

	if (!fInverted) {
		w = fFromBox.left * w0 + fFromBox.top * w1 + w2;
		fValid &= (fabs(w) > 0.00001);
		positive = w > 0;

		w = fFromBox.right * w0 + fFromBox.top * w1 + w2;
		fValid &= (fabs(w) > 0.00001);
		fValid &= (w>0)==positive;

		w = fFromBox.left * w0 + fFromBox.bottom * w1 + w2;
		fValid &= (fabs(w) > 0.00001);
		fValid &= (w>0)==positive;

		w = fFromBox.right * w0 + fFromBox.bottom * w1 + w2;
		fValid &= (fabs(w) > 0.00001);
		fValid &= (w>0)==positive;
	} else {
		w = fToLeftTop.x * w0 + fToLeftTop.y * w1 + w2;
		fValid &= (fabs(w) > 0.00001);
		positive = w > 0;

		w = fToRightTop.x * w0 + fToRightTop.y * w1 + w2;
		fValid &= (fabs(w) > 0.00001);
		fValid &= (w>0)==positive;

		w = fToLeftBottom.x * w0 + fToLeftBottom.y * w1 + w2;
		fValid &= (fabs(w) > 0.00001);
		fValid &= (w>0)==positive;

		w = fToRightBottom.x * w0 + fToRightBottom.y * w1 + w2;
		fValid &= (fabs(w) > 0.00001);
		fValid &= (w>0)==positive;
	}
}

#endif // ICON_O_MATIC