#pragma hdrstop
#include "DXFLoader.h"

// DXFObject의 생성자와 소멸자 정의
DXFObject::DXFObject()
{
	_process = DXF_NULL;
	_dataText = NULL;
  _tokenText = new wslist<char*>(SEQUENCE);
  _unitBox = new wstree<DXFUnit*>(REFERENCE);
}
DXFObject::~DXFObject()
{
	if(_dataText)	delete [] _dataText;
	_dataText = NULL;
  _tokenText->Destroy();
  delete _tokenText;
  _unitBox->DestroyChild();
  delete _unitBox;
}

// LoadDXFFile: 파일 이름을 인자로 받아 데이터 불러오기
bool		DXFObject::LoadDXFFile(const char* fileName)
{
	// 파일 이름을 인자로 받아 열기
	FILE* fp = NULL;
	fp = fopen(fileName, "r");
	// 파일을 열 수 없는 경우 오류 처리
	if(fp == NULL)
	{
		this->_errorText = "DXF 파일을 열 수 없습니다";
		return false;
	}

	// 파일 사이즈 얻기
	fseek(fp, 0, SEEK_END);
	int filesize = ftell (fp);
	rewind (fp);

	// 데이터 버퍼 초기화
	_dataText = new char[filesize + 1];
	memset(_dataText, 0, filesize+1);
	_dataText[filesize] = EOF;

	// 파일 데이터를 읽어 데이터 추출 후 파일 닫기
	fread(_dataText, sizeof(char), filesize, fp);
	fclose(fp);

	_process = DXF_LOAD;
	return true;
}

// ClearDXFFile: 파일 정보를 초기화
void		DXFObject::ClearDXFFile()
{
	if(_dataText)	delete [] _dataText;
	_dataText = NULL;

	// Token 리스트에 있는 내용을 모두 삭제
	_tokenText->Destroy();
	// Unit 리스트에 있는 내용을 모두 삭제
	_unitBox->DestroyChild();
	_process = DXF_NULL;
}

// AddNewToken: 새로운 토큰 문자열을 추가
void		DXFObject::AddNewToken(const char* text)
{ _tokenText->Insert((char*)text); }
// SetCenter: 중앙 지점을 새로 설정
void		DXFObject::SetCenter(wstree<DXFUnit*>* polyline, double centerX)
{
	DXFVertex* current = 0;
	for(int i = polyline->Length()-1; i >= 0; i--)
  {
  	current = (DXFVertex*)((*polyline)[i]->Get());
    if(current->pointX <= centerX)
    {
    	polyline->RemoveChild(current);
      polyline->CreateChildAt(0, current);
    }
    else return;
  }
}

// GetCurrentState: 현재 진행 상태 값을 반환
DXFVALID	DXFObject::GetCurrentState()	{ return _process; }
// GetDataText: DXF 파일 내용을 반환
char*		DXFObject::GetDataText()		{ return _dataText; }
// GetLastError: 가장 최근의 Error에 대한 로그를 반환
char*		DXFObject::GetLastError()		{ return _errorText; }

// DXFObject의 생성자와 소멸자 정의
DXFParser::DXFParser(DXFObject* object)		{ _object = object; _simplicity = -0.99; }
DXFParser::~DXFParser()										{ if(_object) delete _object; _object = NULL; }

// TrimText: 앞뒤 공백 문자를 모두 제거
char*		DXFParser::TrimText(const char* text)
{
	int length = (int)strlen(text);
	int offset = 0;
	int limit = length;

	// 앞쪽에 있는 공백 문자 제거하도록 index 설정
	for(int i = 0; i < length; i++)
	{
		if(text[i] == ' ')			offset++;
		else if(text[i] == '\t')	offset++;
		else						break;
	}
	// 뒤쪽에 있는 공백 문자 제거하도록 index 설정
	for(int i = length-1; i >= offset; i--)
	{
		if(text[i] == ' ')			limit--;
		else if(text[i] == '\t')	limit--;
		else						break;
	}

	// 새로운 문자열을 생성하여 공백 제거된 문자열 대입
	char* trim = new char[limit-offset+1];
	memset(trim, 0, (limit-offset+1)*sizeof(char));
	for(int i = 0; i < limit-offset; i++)
		trim[i] = text[offset+i];
	return trim;
}

// TrimVertex: 일정 각도를 기준으로 vertex 정리
void		DXFParser::TrimVertex(wstree<DXFUnit*>* polyline)
{
	DXFVertex*	prev = NULL;
	DXFVertex*	now = NULL;
	DXFVertex*	next = NULL;

	// 2차원 vector 구조체 정의
	struct Line		{ int x; int y; double length; };
	Line u = { 0, 0, 0 };
	Line v = { 0, 0, 0 };

	// 연속된 3개의 vertex의 각도에 따라 중간 vertex 제거
	for(int i = 0; i < polyline->CountChild(); i++)
	{
		// vertex가 아니면 무시
		if(((DXFUnit*)(polyline->GetChild(i)->Get()))->unitType != DXFTYPE_VERTEX)
			continue;

		prev = now;
		now = next;
		next = (DXFVertex*)(polyline->GetChild(i)->Get());

		// 3개의 vertex 값이 모두 있는 경우
		if(prev && now && next)
		{
			// 3개의 vertex를 두 개의 2차원 vector로 변환
			u.x = prev->pointX - now->pointX;
			u.y = prev->pointY - now->pointY;
			v.x = next->pointX - now->pointX;
			v.y = next->pointY - now->pointY;
			u.length = sqrt(pow((double)u.x,2) + pow((double)u.y,2));
			v.length = sqrt(pow((double)v.x,2) + pow((double)v.y,2));

			// 두 개의 vector 각도 비교 후 필요한 경우 삭제
			double cosine = ((u.x * v.x) + (u.y * v.y))/(u.length * v.length);
			if(cosine < _simplicity)
			{
				polyline->RemoveChild(polyline->GetChild(i-1)->Get());
        i--;
				now = prev;
				prev = NULL;
			}
		}
	}
}
// SetBlockEnv: block의 위치 정보 및 크기 정보 저장
void		DXFParser::SetBlockEnv(wstree<DXFUnit*>* block)
{
	// 기본적으로 사용할 변수들 정의
	wstree<DXFUnit*>* current = block;
	DXFVertex*	vertex = 0;
	int minX = DXF_COORDINATE_MAX_X;
	int maxX = DXF_COORDINATE_MIN_X;
	int minY = DXF_COORDINATE_MAX_Y;
	int maxY = DXF_COORDINATE_MIN_Y;
  int bottomMinX = DXF_COORDINATE_MAX_Y;
  int bottomMaxX = DXF_COORDINATE_MIN_Y;

	// vertex들을 돌며 X, Y에 대한 최대값과 최소값 찾기
	for(int i = 0; i < current->CountChild(); i++)
	{
		current = (*current)[i];
		// vertex level loop
		for(int j = 0; j < current->CountChild(); j++)
		{
			current = (*current)[j];
			vertex = (DXFVertex*)current->Get();

			if(vertex->pointX > DXF_COORDINATE_MAX_X)	vertex->pointX = DXF_COORDINATE_MAX_X;
			if(vertex->pointX < DXF_COORDINATE_MIN_X)	vertex->pointX = DXF_COORDINATE_MIN_X;
			if(vertex->pointY > DXF_COORDINATE_MAX_Y)	vertex->pointY = DXF_COORDINATE_MAX_Y;
			if(vertex->pointY < DXF_COORDINATE_MIN_Y)	vertex->pointY = DXF_COORDINATE_MIN_Y;

      //밑단의 left와 right 찾기
      if(vertex->pointY <= minY)
      {
        if(vertex->pointX < bottomMinX) bottomMinX = vertex->pointX;
        if(vertex->pointX > bottomMaxX) bottomMaxX = vertex->pointX;
      }

			if(vertex->pointX < minX)	minX = vertex->pointX;
			if(vertex->pointX > maxX)	maxX = vertex->pointX;
			if(vertex->pointY < minY)	minY = vertex->pointY;
			if(vertex->pointY > maxY)	maxY = vertex->pointY;

			current = current->GetParent();
		}
		current = current->GetParent();
	}
	// block의 위치 및 크기 정보 저장
	DXFBlock* blockData = (DXFBlock*)current->Get();
	blockData->blockX = minX;
	blockData->blockY = minY;
	blockData->width = maxX - minX;
	blockData->height = maxY - minY;
  blockData->bottomLeft = bottomMinX;
  blockData->bottomRight = bottomMaxX;
  blockData->centerX = (bottomMinX + bottomMaxX) / 2;
}

// SetSimplicity: DXF 파일의 단순화 등급 지정
void		DXFParser::SetSimplicity(double value)
{ _simplicity = value; }

// ParseDXFText: DXF 파일 내용을 파싱
void		DXFParser::ParseDXFText()
{
	// 원본 데이터에 대한 정보를 가져옴
	char*	data = _object->GetDataText();
	int		length = (int)strlen(_object->GetDataText());

	// parsing 결과 token에 대한 변수
	int		offset = 0;
	int		count = 0;

	// parsing 과정을 통해 data tokenize
	for(int i = 0; i < length; i++)
	{
		// tokenize할 문자가 등장하면 지금까지 내용을 추출
		if(data[i] == DXF_PARSER_LINE_SPLITTER)
		{
			char* token = new char[count+1];
			token[count] = 0;
			for(int j = offset; j < offset+count; j++)
				token[j-offset] = data[j];
			_object->AddNewToken(TrimText(token));
			delete [] token;
			
			// token 정보 초기화
			offset = i+1;
			count = 0;
		}
		else	count++;
	}
}

// AnalyzeDXFText: DXF 파일 parsing 결과를 분석하여 unitBox에 저장
bool		DXFParser::AnalyzeDXFText()
{
	// DXF Unit 객체를 담는 변수 선언
	DXFUnit*	unit = NULL;
	// 현재 처리되고 있는 group code 정보
	int				group = DXF_GROUP_S_NONE;
	// 현재 처리되고 있는 내용이 comment인지에 대한 정보
	bool			comment = false;

	// 데이터를 형식에 따라 분류하여 DXF Unit 목록에 추가
	wstree<DXFUnit*>*	current = _object->GetUnits();
	wstree<DXFUnit*>*	child = NULL;
	int					polyLineID = 0;
  // block이 layer에 추가되었는지 여부
  bool				blockEnv = false;

  // 임시 레이어 추가
  unit = new DXFLayer();
  ((DXFLayer*)unit)->layerName = "0";
	(*current) << unit;
  unit = NULL;

	for(int i = 0; i < _object->LengthToken(); i++)
	{
		char* token = _object->GetToken(i);

		// 주석인 경우 무시하도록 처리
		//if((strlen(token) > 0) && (token[0] == '#'))	continue;
		if(comment == true)						{ comment = false; continue; }
		else if(strcmp(token, "999") == 0)		{ comment = true; continue; }

		// group code 인식 처리
		if(group == DXF_GROUP_S_NONE)			group = strtol(token, 0, 10);
		// group value 인식 처리
		else
		{
			if(strcmp(token, "TABLE") == 0)		{ unit = NULL; }
			else if(strcmp(token,"ENDTAB") == 0){ unit = NULL; }

			// 새로운 layer에 대한 처리
			else if(strcmp(token, "LAYER") == 0)
			{
      	// 부모 트리가 0이 아니면 (현재 트리가 root가 아니면) 오류
      	if(current->GetParent() != 0)
        	return false;

				// 새로운 layer를 생성하여 unit box에 추가
				unit = new DXFLayer();
				(*current) << unit;
				polyLineID = 0;
			}

			// 새로운 block에 대한 처리
			else if(strcmp(token, "BLOCK") == 0)
      {
				unit = new DXFBlock();
        blockEnv = true;
      }
			else if(strcmp(token, "ENDBLK") == 0)
			{
				// 이곳에서 block의 위치 및 크기 정보 저장
				SetBlockEnv(current);
				// 기존 정보 초기화 및 root로 돌아감
        if(blockEnv) current = current->GetParent()->GetParent();
        else delete unit;
        unit = NULL;
        polyLineID = 0;
			}

			// 새로운 polyline에 대한 처리
			else if(strcmp(token, "POLYLINE") == 0)
			{
      	// 부모의 값이 없으면 POLYLINE 없음
      	if(current->Get() == NULL)
        	continue;

      	// 부모 트리가 block이 아니면 오류
        if(((DXFUnit*)(current->Get()))->unitType != DXFTYPE_BLOCK)
        	return false;

				unit = new DXFPolyline();
				((DXFPolyline*)unit)->polylineID = polyLineID++;
				(*current) << unit;
				current = current->GetChild(current->CountChild() - 1);
			}
			else if(strcmp(token, "SEQEND") == 0 || strcmp(token, "ENDSEQ") == 0)
			{
				unit = NULL;
				// 필요없는 vertex들을 선별해서 제거
				TrimVertex(current);
				current = current->GetParent();
			}

			// 새로운 vertex에 대한 처리
			else if(strcmp(token, "VERTEX") == 0)
			{
	      // 부모의 값이 없으면 VERTEX 없음
      	if(current->Get() == NULL)
        	continue;

      	// 부모 트리가 polyline이 아니면 오류
        if(((DXFUnit*)(current->Get()))->unitType != DXFTYPE_POLYLINE)
        	return false;

				// 새로운 vertex를 생성하여 unit box에 추가
				unit = new DXFVertex();
				(*current) << unit;
			}

			// value에 대한 데이터 입력 처리
			else if(unit)
			{
				switch(unit->unitType)
				{
				// layer 데이터 값 갱신
				case DXFTYPE_LAYER:
					// layer 이름
					if(group == DXF_GROUP_S_NAME)
						((DXFLayer*)unit)->layerName = token;
					break;

				// block 데이터 값 갱신
				case DXFTYPE_BLOCK:
					// layer 이름
					if(group == DXF_GROUP_S_LAYER_NAME)
					{
						for(int i = 0; i < current->CountChild(); i++)
						{
							child = current->GetChild(i);
              DXFLayer* layer = (DXFLayer*)child->Get();

              // LAYER 이름이 없으면 무시
              if(layer->layerName == 0)
              	continue;

							// 현재 child가 layer인 경우 해당 layer에 block을 추가
							if((layer->unitType == DXFTYPE_LAYER) && (strcmp(layer->layerName, token) == 0))
							{
                // 부모의 값이 없으면 BLOCK 없음
      					if(child->Get() == NULL)
        					break;
                current = child;

                // 부모 트리가 layer가 아니면 오류
				        if(((DXFUnit*)(current->Get()))->unitType != DXFTYPE_LAYER)
				        	return false;
								(*current) << unit;
								current = current->GetChild(current->CountChild() - 1);
                blockEnv = true;
								break;
							}
						}
					}
					// block 이름
					if(group == DXF_GROUP_S_NAME)
						((DXFBlock*)unit)->blockName = token;
					break;

				// polyline 데이터 값 갱신
				case DXFTYPE_POLYLINE:
					if(group == DXF_GROUP_S_LAYER_NAME)
						((DXFPolyline*)unit)->layerName = token;

				// vertex 데이터 값 갱신
				case DXFTYPE_VERTEX:
					// vertex의 x 좌표
					if(group == DXF_GROUP_F_PRIMARY_X)
						((DXFVertex*)unit)->pointX = (int)strtol(token,0,10);
					// vertex의 y 좌표
					if(group == DXF_GROUP_F_PRIMARY_Y)
						((DXFVertex*)unit)->pointY = (int)strtol(token,0,10);
					// vertex의 z 좌표
					if(group == DXF_GROUP_F_PRIMARY_Z)
						((DXFVertex*)unit)->pointZ = (int)strtol(token,0,10);
					break;
				}
			}

			// group code를 다시 읽도록 처리
			group = DXF_GROUP_S_NONE;
		}
	}

  // block이 없으면 오류
  current = _object->GetUnits();
  int blockCount = 0;
  for(int i = 0; i < current->Length(); i++)
  {
	  current = current->GetChild(i);
    // child가 block인지 검사
    /*
    for(int j = 0; j < current->Length(); j++)
    {
    	current = current->GetChild(j);
    	if(((DXFUnit*)current->Get())->unitType == DXFTYPE_BLOCK)
      	blockCount++;
      current = current->GetParent();
    }
    */
    blockCount += current->Length();
    current = current->GetParent();
  }
  if(blockCount == 0)
  	return false;
  return true;
}

#pragma package(smart_init)