#include "stdafx.h"
#include "Path.h"
#include <cmath>
#include <vector>
#include <queue>
#include <map>
#include <iostream>
#include <fstream>
#include <sstream>
using namespace std;

// 使用链表存储通道数据结构，BundleNode是链表节点
struct BundleNode
{
	Clip *pc;				// 指向卡箍
	BranchPoint *pb;		// 指向分支点
	Connector *pcn;			// 指向连接器
	int type;				// 0代表卡箍，1代表分支点,2代表连接器
	BundleNode *pre, *next; // 链表中的上下节点
	int inOut;				// 卡箍方向是正向为0，反向为1
	int rev;				// 通道节点自创建起是否反向过
	int bundleID;			// BundleNode所属的BundleID
	int id;					// BundleNode自身的id
	vector<int> vb;			// 指向属于本通道段的分支点集合

	BundleNode()
	{
		pre = next = NULL;
		pc = NULL;
		pb = NULL;
		pcn = NULL;
		type = 0;
		inOut = 0;
		bundleID = 0;
		id = 0;
	}

	P coord()
	{
		if (type == 0)
			return pc->coord;
		return pb->coord;
	}
} bdNode[MAXPointNum];
int bdNodeNum = 0; // 用数组维护BundleNode信息

// 包含线束捆（通道）信息
struct Bundle
{

	int id;					 // bundle的编号
	int length;				 // 总点数
	bool abandoned;			 // 代表这个bundle已经被合并
	BundleNode *head, *tail; // 通道的头尾节点

	void init()
	{
		length = 0;
		abandoned = false;
		head = tail = NULL;
	}
	Bundle()
	{
		init();
	}

	// 创建一个分支点,初始化其除了链表指针外的其他信息
	static BundleNode *createBundleNode(P &tp, int inOut, int bundleID)
	{
		bdNodeNum++;
		BundleNode *pbn = &bdNode[bdNodeNum];
		pbn->id = bdNodeNum;
		pbn->bundleID = bundleID;
		pbn->inOut = inOut;
		pbn->rev = 0;
		pbn->pre = NULL;
		pbn->next = NULL;

		if (tp.type == 0)
		{ // 点是卡箍

			pbn->type = 0;
			pbn->pc = clipSet.getClipPointer(tp.ref, bdNodeNum);
		}
		else if (tp.type == 1 || tp.type == 2)
		{ // 点是分支点
			pbn->type = 1;
			pbn->pb = branchPointSet.getBranchPointPointer(tp.ref);
		}
		else if (tp.type == 3)
		{
			pbn->type = 2;
			pbn->pcn = &connectors[tp.ref];
			connectors[tp.ref].bundleNodeID = bdNodeNum;
		}
		return pbn;
	}

	// 根据简单路径构建一个Bundle
	Bundle(Path &path, int bundleID)
	{
		init();
		this->id = bundleID;
		this->length = path.size();
		BundleNode *pre;
		for (int i = 0; i < path.size(); i++)
		{
			P tp = path.points[i];
			BundleNode *pbn = Bundle::createBundleNode(tp, path.inOut[i], bundleID);
			if (i == path.size() - 1)
				this->tail = pbn;
			if (i == 0)
				this->head = pbn;
			else
			{
				pre->next = pbn;
				pbn->pre = pre;
			}
			pre = pbn;
		}
	}

	// 如果首个节点是分支点，返回分支点的标号，否则返回0
	int startBranchPoint()
	{
		if (head == NULL)
			return 0;
		if (head->type == 0 || head->type == 2)
			return 0;
		return head->pb->id;
	}

	// 如果尾部节点是分支点，返回分支点的标号，否则返回0
	int endBranchPoint()
	{
		if (tail == NULL)
			return 0;
		if (tail->type == 0 || tail->type == 2)
			return 0;
		return tail->pb->id;
	}

	// 更新输出信息
	void updateOutput(vector<vector<pair<int, int>>> &resClip,
					  vector<vector<int>> &resBranchPoint,
					  vector<int> &startBranchPoint,
					  vector<int> &endBranchPoint, bool basic = false)
	{

		if (head == NULL)
			return;
		BundleNode *pbn = head;

		vector<pair<int, int>> partClip;
		vector<int> partBranchPoint;
		int partStart = this->startBranchPoint();
		int partEnd = this->endBranchPoint();
		while (pbn != NULL)
		{
			if (pbn->type == 0)
			{ // 卡箍
				int cid = pbn->pc->id;
				if ((pbn->pc->used == true) || basic)
				{
					partClip.push_back(make_pair(cid, pbn->inOut));
					for (int i = 0; i < pbn->vb.size(); i++)
					{
						int bid = pbn->vb[i];
						BranchPoint *pb = branchPointSet.getBranchPointPointer(bid);
						if ((pb->used == true) || basic)
							partBranchPoint.push_back(bid);
					}
				}
				else
				{
					if (partClip.size() != 0)
					{
						resClip.push_back(partClip);
						resBranchPoint.push_back(partBranchPoint);
						startBranchPoint.push_back(partStart);
						endBranchPoint.push_back(partEnd);
					}
					partClip.clear();
					partBranchPoint.clear();
				}
			}
			else if (pbn->type == 2)
			{ // 连接器
				int cnid = pbn->pcn->ID;
				partClip.push_back(make_pair(cnid, -1));
			}
			pbn = pbn->next;
		}

		if (!basic)
		{

			if (partClip.size() != 0)
			{
				resClip.push_back(partClip);
				resBranchPoint.push_back(partBranchPoint);
				startBranchPoint.push_back(partStart);
				endBranchPoint.push_back(partEnd);
			}
		}
		else
		{
			if (partClip.size() > 5)
			{
				resClip.push_back(partClip);
				resBranchPoint.push_back(partBranchPoint);
				startBranchPoint.push_back(partStart);
				endBranchPoint.push_back(partEnd);
			}
		}
	}
};