#include <cstring>

#include <string>

#include <limits>

#include "display/curve.h"

#include "xml/repr.h"

#include "sp-conn-end.h"

#include "sp-path.h"

#include "uri.h"

#include "document.h"

#include "sp-item-group.h"

#include "2geom/path.h"

#include "2geom/pathvector.h"

#include "2geom/path-intersection.h"

static void change_endpts(SPCurve *const curve, double const endPos[2]);

SPConnEnd::SPConnEnd(SPObject *const owner) :

ref(owner),

href(NULL),

// Default to center connection endpoint

type(ConnPointDefault),

id(4),

_changed_connection(),

_delete_connection(),

_transformed_connection()

{

}

static SPObject const *

get_nearest_common_ancestor(SPObject const *const obj, SPItem const *const objs[2]) {

SPObject const *anc_sofar = obj;

for (unsigned i = 0; i < 2; ++i) {

if ( objs[i] != NULL ) {

anc_sofar = anc_sofar->nearestCommonAncestor(objs[i]);

}

}

return anc_sofar;

}

static bool try_get_intersect_point_with_item_recursive(Geom::PathVector& conn_pv, SPItem* item,

const Geom::Affine& item_transform, double& intersect_pos) {

double initial_pos = intersect_pos;

// if this is a group...

if (SP_IS_GROUP(item)) {

SPGroup* group = SP_GROUP(item);

// consider all first-order children

double child_pos = 0.0;

for (GSList const* i = sp_item_group_item_list(group); i != NULL; i = i->next) {

SPItem* child_item = SP_ITEM(i->data);

try_get_intersect_point_with_item_recursive(conn_pv, child_item,

item_transform * child_item->transform, child_pos);

if (intersect_pos < child_pos)

intersect_pos = child_pos;

}

return intersect_pos != initial_pos;

}

// if this is not a shape, nothing to be done

if (!SP_IS_SHAPE(item)) return false;

// make sure it has an associated curve

SPCurve* item_curve = SP_SHAPE(item)->getCurve();

if (!item_curve) return false;

// apply transformations (up to common ancestor)

item_curve->transform(item_transform);

const Geom::PathVector& curve_pv = item_curve->get_pathvector();

Geom::CrossingSet cross = crossings(conn_pv, curve_pv);

// iterate over all Crossings

//TODO: check correctness of the following code: inner loop uses loop variable

// with a name identical to the loop variable of the outer loop. Then rename.

for (Geom::CrossingSet::const_iterator i = cross.begin(); i != cross.end(); ++i) {

const Geom::Crossings& cr = *i;

for (Geom::Crossings::const_iterator i = cr.begin(); i != cr.end(); ++i) {

const Geom::Crossing& cr_pt = *i;

if ( intersect_pos < cr_pt.ta)

intersect_pos = cr_pt.ta;

}

}

item_curve->unref();

return intersect_pos != initial_pos;

}

static bool try_get_intersect_point_with_item(SPPath* conn, SPItem* item,

const Geom::Affine& item_transform, const Geom::Affine& conn_transform,

const bool at_start, double& intersect_pos) {

// Copy the curve and apply transformations up to common ancestor.

SPCurve* conn_curve = conn->_curve->copy();

conn_curve->transform(conn_transform);

Geom::PathVector conn_pv = conn_curve->get_pathvector();

// If this is not the starting point, use Geom::Path::reverse() to reverse the path

if (!at_start)

{

// connectors are actually a single path, so consider the first element from a Geom::PathVector

conn_pv[0] = conn_pv[0].reverse();

}

// We start with the intersection point at the beginning of the path

intersect_pos = 0.0;

// Find the intersection.

bool result = try_get_intersect_point_with_item_recursive(conn_pv, item, item_transform, intersect_pos);

if (!result)

// No intersection point has been found (why?)

// just default to connector end

intersect_pos = 0;

// If not at the starting point, recompute position with respect to original path

if (!at_start)

intersect_pos = conn_pv[0].size() - intersect_pos;

// Free the curve copy.

conn_curve->unref();

return result;

}

static void

sp_conn_get_route_and_redraw(SPPath *const path,

const bool updatePathRepr = true)

{

// Get the new route around obstacles.

bool rerouted = path->connEndPair.reroutePathFromLibavoid();

if (!rerouted) {

return;

}

SPItem *h2attItem[2] = {0};

path->connEndPair.getAttachedItems(h2attItem);

SPObject const *const ancestor = get_nearest_common_ancestor(path, h2attItem);

Geom::Affine const path2anc(i2anc_affine(path, ancestor));

// Set sensible values incase there the connector ends are not

// attached to any shapes.

Geom::PathVector conn_pv = path->_curve->get_pathvector();

double endPos[2] = { 0.0, static_cast<double>(conn_pv[0].size()) };

SPConnEnd** _connEnd = path->connEndPair.getConnEnds();

for (unsigned h = 0; h < 2; ++h) {

if (h2attItem[h] && _connEnd[h]->type == ConnPointDefault && _connEnd[h]->id == ConnPointPosCC) {

Geom::Affine h2i2anc = i2anc_affine(h2attItem[h], ancestor);

try_get_intersect_point_with_item(path, h2attItem[h], h2i2anc, path2anc,

(h == 0), endPos[h]);

}

}

change_endpts(path->_curve, endPos);

if (updatePathRepr) {

path->updateRepr();

path->requestDisplayUpdate(SP_OBJECT_MODIFIED_FLAG);

}

}

static void

sp_conn_end_shape_move(Geom::Affine const */*mp*/, SPItem */*moved_item*/,

SPPath *const path)

{

if (path->connEndPair.isAutoRoutingConn()) {

path->connEndPair.tellLibavoidNewEndpoints();

}

}

sp_conn_reroute_path(SPPath *const path)

{

if (path->connEndPair.isAutoRoutingConn()) {

path->connEndPair.tellLibavoidNewEndpoints();

}

}

sp_conn_reroute_path_immediate(SPPath *const path)

{

if (path->connEndPair.isAutoRoutingConn()) {

bool processTransaction = true;

path->connEndPair.tellLibavoidNewEndpoints(processTransaction);

}

// Don't update the path repr or else connector dragging is slowed by

// constant update of values to the xml editor, and each step is also

// needlessly remembered by undo/redo.

bool const updatePathRepr = false;

sp_conn_get_route_and_redraw(path, updatePathRepr);

}

void sp_conn_redraw_path(SPPath *const path)

{

sp_conn_get_route_and_redraw(path);

}

static void

change_endpts(SPCurve *const curve, double const endPos[2])

{

// Use Geom::Path::portion to cut the curve at the end positions

if (endPos[0] > endPos[1])

{

// Path is "negative", reset the curve and return

curve->reset();

return;

}

const Geom::Path& old_path = curve->get_pathvector()[0];

Geom::PathVector new_path_vector;

new_path_vector.push_back(old_path.portion(endPos[0], endPos[1]));

curve->set_pathvector(new_path_vector);

}

static void

sp_conn_end_deleted(SPObject *, SPObject *const owner, unsigned const handle_ix)

{

// todo: The first argument is the deleted object, or just NULL if

// called by sp_conn_end_detach.

g_return_if_fail(handle_ix < 2);

char const * const attr_strs[] = {"inkscape:connection-start", "inkscape:connection-start-point",

"inkscape:connection-end", "inkscape:connection-end-point"};

owner->getRepr()->setAttribute(attr_strs[2*handle_ix], NULL);

owner->getRepr()->setAttribute(attr_strs[2*handle_ix+1], NULL);

/* I believe this will trigger sp_conn_end_href_changed. */

}

sp_conn_end_detach(SPObject *const owner, unsigned const handle_ix)

{

sp_conn_end_deleted(NULL, owner, handle_ix);

}

SPConnEnd::setAttacherHref(gchar const *value, SPPath* /*path*/)

{

if ( value && href && ( strcmp(value, href) == 0 ) ) {

/* No change, do nothing. */

}

else

{

if (!value)

{

ref.detach();

g_free(href);

href = NULL;

}

else

{

bool validRef = true;

href = g_strdup(value);

// Now do the attaching, which emits the changed signal.

try {

ref.attach(Inkscape::URI(value));

} catch (Inkscape::BadURIException &e) {

/* TODO: Proper error handling as per

g_warning("%s", e.what());

validRef = false;

}

if ( !validRef )

{

ref.detach();

g_free(href);

href = NULL;

}

}

}

}

SPConnEnd::setAttacherEndpoint(gchar const *value, SPPath* /*path*/)

{

/* References to the connection points have the following format

bool changed = false;

ConnPointType newtype = type;

if (!value)

{

// Default to center endpoint

type = ConnPointDefault;

id = 4;

}

else

{

switch (value[0])

{

case 'd':

if ( newtype != ConnPointDefault )

{

newtype = ConnPointDefault;

changed = true;

}

break;

case 'u':

if ( newtype != ConnPointUserDefined)

{

newtype = ConnPointUserDefined;

changed = true;

}

break;

default:

g_warning("Bad reference to a connection point.");

}

int newid = (int) g_ascii_strtod( value+1, 0 );

if ( id != newid )

{

id = newid;

changed = true;

}

// We have to verify that the reference to the

// connection point is a valid one.

if ( changed )

{

// Get the item the connector is attached to

SPItem* item = ref.getObject();

if ( item )

{

if (!item->avoidRef->isValidConnPointId( newtype, newid ) )

{

g_warning("Bad reference to a connection point.");

}

else

{

type = newtype;

id = newid;

}

/* // Update the connector

}

}

}

}

sp_conn_end_href_changed(SPObject */*old_ref*/, SPObject */*ref*/,

SPConnEnd *connEndPtr, SPPath *const path, unsigned const handle_ix)

{

g_return_if_fail(connEndPtr != NULL);

SPConnEnd &connEnd = *connEndPtr;

connEnd._delete_connection.disconnect();

connEnd._transformed_connection.disconnect();

if (connEnd.href) {

SPObject *refobj = connEnd.ref.getObject();

if (refobj) {

connEnd._delete_connection

= refobj->connectDelete(sigc::bind(sigc::ptr_fun(&sp_conn_end_deleted),

path, handle_ix));

connEnd._transformed_connection

= SP_ITEM(refobj)->connectTransformed(sigc::bind(sigc::ptr_fun(&sp_conn_end_shape_move),

path));

}

}

}