// All commands this XP provides should be listed here, separated by the NULL-character
char CList[] = "DDPOLY\0\0";

// This list contains the actual functions called by the CC3+ commands. It should always start
// with the About function, then followed by the functions the commands should call in the same
// order as the command list above.
PCMDPROC PList[] = { About, DDPoly };

// These three variables will be used to build up the polygon as the
// user click points. I've assumed 1024 points is enough here. Could
// have used a dynamic data structure like a vector instead, but this
// part will change in a future part anyway.
// Note that the 1024 limit here is for each shape added, not for the
// total composite floor we will end up with, so it is probably overkill.
GPOINT2 tempPoint;
GPOINT2 pointList[1024];
int nodecounter = 0;


// Define the prompt for the first node
FORMST(startNode, "Place start node: \0")

// Define the data request for the first node.
// Note that the data type we ask for is RD_2DC, which is a x,y coordinate pair. The user 
// can click these points int he drawing, or type them in on the command line
// The data returned from the request will be stored in the tempPoint variable and the 
// function DDPolyGetNode() will be called.
RDATA FirstPolyPointReq =
{ sizeof(RDATA), RD_2DC, NULL, RDF_C, (DWORD*)&tempPoint,
(DWORD*)&startNode,RDC_XH, DDPolyGetNode, NULL, NULL, 0, NULL, 0 };


// This is the entry point for the DDPOLY command
// We reset the node counter back to zero each time we begin a new shape
// and then fire of the request for the first point
void XPCALL DDPoly() {

	nodecounter = 0;

	ReqData(&FirstPolyPointReq);

}



// Prompt and request used for all remaining nodes. The only real difference
// is the prompt text itself, and that instead of a crosshair cursor, we use a rubberband
// cursor to show a line from the previous point.
FORMST(nextNode, "Place next node (right click to finish): \0")
RDATA NextPolyPointReq =
{ sizeof(RDATA), RD_2DC, NULL, RDF_C, (DWORD*)&tempPoint,
(DWORD*)&nextNode,RDC_RBAND, DDPolyGetNode, NULL, NULL, 0, NULL, 0 };


// This function handles the callback for each node the user creates
void XPCALL DDPolyGetNode(int Result, int Result2, int Result3) {

	// Right Click during a request is what CC3+ considers accepting the default value for
	// the prompt. In our case, this means we are done placing nodes, and wish to finish. 
	// So, we call the DDDrawPoly() function to handle the actual drawing
	if (Result == X_DFLT) { DDDrawPoly(); return; }

	// If the user supplied an invalid value, which includes hitting Esc to abort, we just 
	// abort the drawing and end the command.
	if (Result != X_OK) { CmdEnd(); return; }

	// Sets up the origin for the rubberband cursor
	NewCsrOrg(tempPoint.x, tempPoint.y);

	// Adds the last node supplied to our array of nodes
	pointList[nodecounter++] = tempPoint;

	// Fires of the data request. Since the request specifies this function, we will 
	// basically repeat this function as long as the user supplies nodes.
	ReqData(&NextPolyPointReq);

}


// This function creates the actual CC3+ entity for the polygon and draws it on screen
void DDDrawPoly() {

	// We need to know the length of the entity record to be able to allocate the correct 
	// amount of memory for this entity. The correct size is the size of the PATH2 structure
	// plus the size of the nodes, which is obviously the size of a single node (GPOINT2) 
	// multiplied by the number of nodes
	const auto len = static_cast<int>(sizeof(PATH2) + sizeof(GPOINT2) * nodecounter);
	
	// Here we create a vector of chars of the appropriate size to hold our entity. We're 
	// actually not interested in the vector itself, but the vector is great since it cleans
	// up the memory when it falls out of scope at the end of the function. We could instead
	// have reserved memory with malloc, but would also have needed to remember to free it 
	// too or we would end up with a memory leak
	std::vector<char> buffer(len);

	// Grab the data area from the vector and treat it like an entity record.
	auto p = reinterpret_cast<pENTREC>(buffer.data());

	// We set up the entity record with the basic settings. Here we just ensure that all the 
	// variables are set to 0 since we don't know what was in the memory area we grabbed. We 
	// also set the entity record length which is important for CC3+ to know when it does 
	// it's own memory allocation and the type of entity. 
	// The entity type here is ET_PATH2 which is used for both paths and polygons, since 
	// polygons are just closed paths.
	p->CStuff = { len, ET_PATH2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0.0, 0 };

	// We set up our path to be closed. This weird double access to "Path" happens because 
	// we are working with an entity record and not a path type directly.
	p->Path.Path.Flags = NL_CLS;
	
	// SParm and EParm are used to trim entities. To ensure the entity is not trimmed, SParm 
	// should be 0 (start of entity) and EParm be equal to the number of nodes (for 
	// polygons, paths should have number of nodes minus one. Polys need that one extra 
	// because of the closing line between the last node and the first)
	p->Path.Path.SParm = 0;
	p->Path.Path.EParm = (float)nodecounter;
	

	// Need to tell CC3+ how many nodes we have
	p->Path.Path.Count = nodecounter;

	// This loop simply fetches all the nodes from our temporary storage and puts them into 
	// the entity node list
	for (; nodecounter > 0; nodecounter--) {
		p->Path.Path.Nodes[nodecounter - 1] = pointList[nodecounter - 1];
	}

	// Get the current settings in CC3+ (such as layer, fill style, line style, etc) and 
	// populates the entity with them
	GetCStuff(p);

	// We are adding something to our drawing list which the user may wish to undo. Placing
	// an undo marker here. MarkUndoAdd() are used when setting up undo point for things
	// not requiring a selection, such as when adding new entities to the drawing.
	MarkUndoAdd();

	// Insert the entity into the main drawing list.
	pENTREC ent = DLApnd(NULL, p);

	// Draw our new entity out to screen
	EDraw(ent);

	// Telling CC3+ that our command is done. This is important.
	CmdEnd();
	
}

// Required includes for boost
#include <boost/geometry/geometry.hpp>
#include <boost/geometry/geometries/point_xy.hpp>
#include <boost/geometry/geometries/polygon.hpp>
#include <boost/geometry/io/wkt/wkt.hpp>


// Main entry point for the DDMERGE command. Don't forget to update CList and PList
void XPCALL DDMerge() {

	// Call a custom functions that looks up a sheet by name and return the entity record
	// for that sheet. If we don't get a valid entity record back, we immediately terminate
	pENTREC sheet = FindSheet("FLOORS");
	if (!sheet) { CmdEnd(); return; }

	// To find entities on a sheet, we need the sublist for the sheet. This command
	// retrieves it, and if it doesn't have a sublist, we terminate
	hDLIST hSubL = DLGetSubList(sheet);
	if (hSubL == NULL) { CmdEnd(); return; }

	// We scan the sublist belonging to the sheet looking for the fist polygon we can find
	// The job of actually checking for polygon is handled by the callback function
	// DDMergeFindEntity. If we don't get a valid entity record back, we terminate
	// We also cast the DWORD, which is a memory address, to a pointer to an entity record
	DWORD firstEntity = DLScan(hSubL, DDMergeFindEntity, DLS_Std, NULL, NULL);
	if(firstEntity == 0) { CmdEnd(); return; }
	pENTREC fe = (pENTREC)firstEntity;

	// Now looking for the second polygon on the sheet. Only difference from above is that we
	// send the first entity record as a parameter so this scan can skip that one so we don't
	// get the same twice.
	DWORD secondEntity = 
			DLScan(hSubL, DDMergeFindEntity, DLS_Std, (pENTREC)firstEntity, NULL);
	if (secondEntity == 0) { CmdEnd(); return; }
	pENTREC se = (pENTREC)secondEntity;

	// Casting the entity records returned earlier to PATH2 entities. If any of them turns
	// out to not be a valid PATH2 entity, we terminate.
	const auto poly1 = XP_PATH2_CAST(fe);
	const auto poly2 = XP_PATH2_CAST(se);
	if(!(poly1 && poly2)) { CmdEnd(); return; }


	// defines a neater type name for the boost type we need
	typedef 
	 boost::geometry::model::polygon<boost::geometry::model::d2::point_xy<double> > polygon;

	// declares two boost polygons
	polygon p1, p2;

	// Fills in the coordinates from CC3+ into the boost polygons.
	// We are using a helper method, BuildWKTString(), to convert the Path stored
	// in the entity record into a properly formatted text string
	boost::geometry::read_wkt(
		BuildWKTString(&(poly1->Path))
		, p1);

	boost::geometry::read_wkt(
		BuildWKTString(&(poly2->Path))
		, p2);

	// These lines just ensures the data is properly normalized for boost (order of nodes)
	boost::geometry::correct(p1);
	boost::geometry::correct(p2);
	if (boost::geometry::area(p1) < 0) boost::geometry::reverse(p1);
	if (boost::geometry::area(p2) < 0) boost::geometry::reverse(p2);

	// Define a vector to store the combined polygon
	std::vector<polygon> combined;

	// Have boost combine our two polygons and place the result in our vector. We're only
	// going to get one result back if the polygons overlap.
	// We are currently not handling the situation where they don't overlap, resulting
	// in the new polygon simply being erased if it don't overlap the old one.
	boost::geometry::union_(p1, p2, combined);

	// We're going to be changing entities now. Setting up an undo point for the user
	MarkUndoAdd();

	// This creates a clone of our existing entity for editing. The original entity is
	// marked as deleted so it is removed from the drawing, but still retriavable via undo.
	pENTREC editEntity = DLClone(fe);

	// Figuring out the number of nodes in our combined polygon
	const int numNodes = boost::geometry::num_points(combined[0]);

	// Calculates new entity record length based on the new node count
	const auto len = static_cast<int>(sizeof(PATH2) + sizeof(GPOINT2) * numNodes);
	
	// Resize the entity to the new length. We MUST do this before adding the new nodes
	// or we would start writing into memory occupied by other entities, corrupting the
	// drawing
	editEntity = DLResize(editEntity, len);

	// For simplicity, lets us handle it as a PATH2 entity
	const auto editPoly = XP_PATH2_CAST(editEntity);

	// Sets the number of nodes in the entity to the new number
	editPoly->Path.Count = numNodes;

	// And also updates EParm as well so we can see the new nodes added
	editPoly->Path.EParm = (float)numNodes;

	// Grabs the nodes from our boost poly and feeds them into the CC3+ entity.
	// Note that we overwrite the entire node list, since some of the original nodes may be
	// gone. Trying to figure out which nodes to insert is useless and error-prone work.
	for (int i = 0; i < numNodes; i++) {
		editPoly->Path.Nodes[i].x = combined[0].outer()[i].x();
		editPoly->Path.Nodes[i].y = combined[0].outer()[i].y();
	}


	// We erase the second entity from the drawing. Since the original entity have been
	// updated to be a combined entity, the newly drawn entity shouldn't hang around anymore
	DLErase(se);

	// Update the screen with the edited entity.
	EDraw(editEntity);

	// Properly terminate the command
	CmdEnd();

}


// This function is used when we scan the drawing list for polygons. It simply return the
// first polygon it finds, unless it matches the one sent in as parm1, is so it skips
// over that one and looks for the next.
// Note that this functions is called once for every entity in the drawing list, it's job
// is simply to check if the entity it gets fits our criteria. If it does, we return
// the entity, if not, we return 0 which tells DLScan to continue processing the 
// Drawing Lsit and call this function again with the next entity, if any.
pENTREC XPCALL DDMergeFindEntity(hDLIST list, pENTREC entity, const DWORD parm1,
	                                                                          DWORD parm2) {
	
	// Cast parm1 to a pointer to an entity record and compares it with the current one
	// If they match, this means we don't want it, since that's the one returned from
	// the first scan.
	pENTREC another = (pENTREC)parm1;
	if (entity == another) return 0;

	// Cast the entity to a PATH2. This cast only succeeds if the entity represents a 
	// PATH2 type entity. Remember that PATH2 covers both paths and polygons
	// Right now, we don't actually do any more checking to figure out if it is really
	// a polygon and not a path, perhaps we should?
	const auto poly = XP_PATH2_CAST(entity);

	// If the call above succeeded, we return the entity.
	if (poly) {
		return entity;
	}

	// This is not the the entity you are looking for. Move along.
	return 0;
}




// Helper function for finding a sheet by name
pENTREC FindSheet(std::string sheetName) {

	// We scan the drawing list with DLS_SHEET flag set, so we see the sheets instead of the
	// entities they contain. The name we are looking for are sent as a parameter for use in
	// the callback function
	DWORD result = DLScan(NULL, FindSheetCallback, DLS_SHEET, &sheetName, NULL);

	// Return the entity record for the sheet. If the sheet wasn't found the return value 
	// will be 0. This needs to be handled by the caller.
	return (pENTREC)result;


}

// Callback for our sheet scan
pENTREC XPCALL FindSheetCallback(void* hDList, const pENTREC pEntRec, const DWORD parm1,
	                                                                          DWORD parm2) {

	// Tries to cast any received entity to a SHEET type entity. Will fail if the entity
	// isn't a sheet
	const auto sheet = XP_SHEET_CAST(pEntRec);

	// If we succeeded above, we can now check the sheet name. If it matches we return the
	// entity record for the sheet.
	if (sheet) {

		std::string* sname = (std::string*)parm1;

		if (strcmp(sheet->SName, sname->c_str()) == 0) {
			return pEntRec;

		}

	}

	// Nothing to see here. Move along.
	return 0;

}


// Helper function to build a WKT string for input to the boost geometry functions
// A WKT string looks like this:
// POLYGON(( X1 Y1, X2 Y2, X3 Y3, ...))
// (They can be far more complex, but this is what we need now.)
std::string BuildWKTString(GPATH2 * path) {

	std::string buff = "POLYGON((";
	for (int i = 0; i < path->Count; i++) {
	    buff.append(
	        std::to_string(path->Nodes[i].x) + " " + std::to_string(path->Nodes[i].y) + ", "
	    );
	}
	buff.append("))");

	return buff;

}