#ifndef __LEDSGEOMETRY_H__
#define __LEDSGEOMETRY_H__


#include "ledstables.h" // need templated classes
#include "datalib.h"

class Point;
class CLEDSEdgeUse;
class CLEDSFace;
class CLEDSVertex;
class CLEDSliteEdgeUse;
class CLEDSliteFace;
class CLEDSliteVertex;
class CComponent;

//////////////////////////////////////////////////////////////////////////////
// CLEDSGeometry Class
//
enum BrepType {tNonManifold = 0, tManifold, tPseudoManifold};

class CLEDSGeometry //: public CGeometry
{
  //////////////////////////////////////////////////
  // Friends
  //
  //////////////////////////////////////////////////
  // Initialization
  //
public:
  CLEDSGeometry();
   ~CLEDSGeometry();
  VOID Init(BOOL bPrevPtrs = FALSE);
  VOID Uninit();

//////////////////////////////////////////////////
// Geometric Computations
//
public:
  BOOL Check2Manifold();
  BrepType CheckPseudo2Manifold(BOOL);
  VOID CleanupManifoldTesting();
  VOID Slice(FLOAT, Vector, INT_32, FLOAT);
  VOID TestStuff();
//  BOOL Analyze(CListInt *pListUnmatchedVerts, FLOAT fEpsilon);
  BOOL Analyze(DataFile<CLEDSliteVertex *> *pListUnmatchedVerts, 
			   FLOAT fEpsilon);
private:
//  FLOAT AnalyzeEdges(CListInt *pListUnmatchedVerts);
  FLOAT AnalyzeEdges(DataFile<CLEDSliteVertex *> *pListUnmatchedVerts);
  VOID AnalyzeFaces();
  VOID AnalyzeVertices(FLOAT *pfMinX, FLOAT *pfMinY, FLOAT *pfMinZ, 
					   FLOAT *pfMaxX, FLOAT *pfMaxY, FLOAT *pfMaxZ);
					   
//  UINT_32 MergeVertices(CListInt *pListUnmatchedVerts, FLOAT fEps,
  UINT_32 MergeVertices(DataFile<CLEDSliteVertex *> *pListUnmatchedVerts, 
						FLOAT fEps,
						FLOAT fMinX, FLOAT fMinY, FLOAT fMinZ, 
						FLOAT fMaxX, FLOAT fMaxY, FLOAT fMaxZ);
  BrepType SortCheckEdges(BOOL);
  VOID SetNonmanifoldEdge(CLEDSliteEdgeUse *);
  VOID DivideEdges();
  BOOL CheckAlternatingFaceNormals(CLEDSliteEdgeUse *pEdge);
  VOID RelinkSibs(CLEDSliteEdgeUse *pEUref, 
				  CList<CLEDSliteEdgeUse *, DOUBLE> *pCListA,
				  CList<CLEDSliteEdgeUse *, DOUBLE> *pCListB); 

  //////////////////////////////////////////////////
  // Rendering
  //

//////////////////////////////////////////////////
// Output Functions
//
public:
  VOID WriteSTL(FILE *);
//////////////////////////////////////////////////
// Accessor Functions
//
public:
  LIDmap *GetLIDmapEU() {return m_pLIDmapEU;};
  LIDmap *GetLIDmapVtx() {return m_pLIDmapVtx;};
  LIDmap *GetLIDmapFace() {return m_pLIDmapFace;};
  BOOL GetPtrsUpdated() {return m_boolPtrsUpdated;};
  CList<CLEDSliteEdgeUse *, UINT_8> *GetCListEdges() {return m_pCListEdges;};
  CList<CLEDSliteVertex *, UINT_8> *GetCListVertices(){return m_pCListVertices;};
  CList<CLEDSliteEdgeUse *, UINT_8> *GetCListEUs() {return m_pCListEUs;};     
  CList<CLEDSliteFace *, UINT_8> *GetCListFaces() {return m_pCListFaces;};   

  VOID BeginSTLlidInfo();
  VOID EndSTLlidInfo();
// These 2 can be derived for simple triangulated input
//  inline VOID STLlidAddEUFace(LID, LID);
//  inline VOID STLlidAddEUNextContEU(LID, LID);
#ifndef CHANGE_TWO
  inline UINT_32 STLlidAddVertex(Point *);
  inline VOID STLlidAddEdge(LID, UINT_32, UINT_32);
#else
  inline VOID STLlidAddEdge(LID, Point *, Point *);
#endif
  inline VOID STLlidAddFaceOC(LID, LID);
// STL has no inner face contours!
//  inline VOID STLlidAddFaceIC(LID, LID);

  VOID BeginSTLOneStageInfo();
  VOID EndSTLOneStageInfo();
  VOID STLOneStageAddEdge(CLEDSliteEdgeUse *, Point *, Point *);

  VOID BeginSIFOneStageInfo();
  VOID EndSIFOneStageInfo();
  VOID SIFOneStageAddEdge(CLEDSliteEdgeUse *, UINT_32, UINT_32);
  VOID SIFOneStageInitVertexList(UINT_32 uiNumVertices);
  VOID SIFOneStageInitTriangleList(UINT_32 uiNumTriangles);
  VOID SIFOneStageAddVertex(UINT_32, FLOAT, FLOAT, FLOAT, FLOAT);

  inline VOID OneStageAddEUFace(CLEDSliteEdgeUse *, CLEDSliteFace *);
  inline VOID OneStageAddEUNextContEU(CLEDSliteEdgeUse *, CLEDSliteEdgeUse *);
  inline VOID OneStageAddFaceOC(CLEDSliteFace *, CLEDSliteEdgeUse *);
  VOID OneStageAddFaceIC(CLEDSliteFace *, CLEDSliteEdgeUse *);

  CLEDSliteFace *GetNewFace();
  CLEDSliteEdgeUse *GetNewEU();
  inline VOID SetListComponents(CList<CComponent *, UINT_8> *pListComponents)
	{m_pListComponents = pListComponents;};
  inline CList<CComponent *, UINT_8> *GetListComponents()
	{return m_pListComponents;};
  inline BOOL GetCurLayerEmpty() {return m_bCurLayerEmpty;};
  inline VOID SetCurLayerEmpty(BOOL bInput) {m_bCurLayerEmpty = bInput;};
protected:
#ifdef RESORTABLE
  VOID UpdateLEDSPtrs();
#endif
  VOID TestIterators();

//////////////////////////////////////////////////
// Class Variables
//
public:
  /*
static LIDmap *ms_pLIDmap;
static BOOL ms_boolPtrsUpdated;
static CListInt *ms_pCListEdges;
static CListInt *ms_pCListVertices; // contains ptrs to CLEDSVertex's
static CListInt *ms_pCListEUs;      // contains ptrs to CLEDSEdgeUse's
static CListInt *ms_pCListFaces;    // contains ptrs to CLEDSFace's
static CListInt *ms_pCListEdgeHashTables;
*/
//////////////////////////////////////////////////
// Member Variables
//
public:
  LIDmap *m_pLIDmapEU;
  LIDmap *m_pLIDmapVtx;
  LIDmap *m_pLIDmapFace;
  BOOL m_boolPtrsUpdated;

  CList<CLEDSliteEdgeUse *, UINT_8> *m_pCListEdges;
  CList<CLEDSliteVertex *, UINT_8> *m_pCListVertices;
  CList<CLEDSliteEdgeUse *, UINT_8> *m_pCListEUs; 
  CList<CLEDSliteFace *, UINT_8> *m_pCListFaces;    

private:
  CList<CLEDSliteEdgeUse *, UINT_8> *m_pCListOddEdges;      // 
  CList<CLEDSliteEdgeUse *, UINT_8> *m_pCListPairedUnmatchedEdges;      // 
  CList<CLEDSliteEdgeUse *, UINT_8> *m_pCListGreater2Edges;      // 
  CLEDSTables<Triple<FLOAT, FLOAT, FLOAT> > *m_pCLEDSTablesSTL;
  CLEDSliteEdgeUse *m_pEUs;
  CLEDSliteFace *m_pFaces;
  CLEDSliteVertex *m_pVtxs;
  BOOL m_bPrevPtrs;  

  // for SIF input where number of vertices per shell specified up front
  Point *m_pPointBuffer;

  //  For OneStage build
  COpenHashTable<CLEDSliteVertex *, Triple<FLOAT, FLOAT, FLOAT> > *m_pVtxHashTable;
  COpenHashTable<CLEDSliteEdgeUse *, Pair<UINT_32, UINT_32> > *m_pEUHashTable;
#ifdef LISTARRAY
  CLEDSliteFace *pFaceBuffer;
  UINT_32 uiFaceNum;
  CLEDSliteEdgeUse *pEUBuffer;
  UINT_32 uiEUNum;
#endif  
  CLEDSliteVertex *m_pVertexBuffer;
  UINT_32 m_uiVertexNum;

  // for slicing
  CList<CComponent *, UINT_8> *m_pListComponents;
  BOOL m_bCurLayerEmpty;
  UINT_32 m_uiGenus;
};

// non-member functions
UINT_32 Hash(Pair<Point, Point> & ptPr);
UINT_32 Hash(Triple<FLOAT, FLOAT, FLOAT> & floatTrip);

//////////////////////////////////////////////////////////////////////////////
// Inlined Functions
//
/*
inline VOID CLEDSGeometry::STLlidAddEUFace(LID lidEU, LID lidFace)
{
	m_pCLEDSTablesSTL->AddEUFace(lidEU, lidFace);
}

inline VOID CLEDSGeometry::STLlidAddEUNextContEU(LID lidEU, LID lidNextContEU)
{
  m_pCLEDSTablesSTL->AddEUNextContEU(lidEU, lidNextContEU);
}
*/

#ifndef CHANGE_TWO 
inline UINT_32 CLEDSGeometry::STLlidAddVertex(Point *pvid)
{

  Triple<FLOAT, FLOAT, FLOAT> Triple;
  Triple.SetTriple((*pvid)(X), (*pvid)(Y), (*pvid)(Z));


  return (m_pCLEDSTablesSTL->AddVertex(&Triple));

}

inline VOID CLEDSGeometry::STLlidAddEdge(LID lidEU, 
										 UINT_32 uiVtx1, UINT_32 uiVtx2)
{
  m_pCLEDSTablesSTL->AddEdge(lidEU, uiVtx1, uiVtx2);

}
#else
inline VOID CLEDSGeometry::STLlidAddEdge(LID lidEU, Point *pPt1, Point *pPt2)
										 
{
  Triple<FLOAT, FLOAT, FLOAT> Triple1, Triple2;
  Triple1.SetTriple((*pPt1)(X), (*pPt1)(Y), (*pPt1)(Z));
  Triple2.SetTriple((*pPt2)(X), (*pPt2)(Y), (*pPt2)(Z));

  m_pCLEDSTablesSTL->AddEdge(lidEU, &Triple1, &Triple2);
}
#endif

inline VOID CLEDSGeometry::STLlidAddFaceOC(LID lidFace, LID lidEU)
{
  m_pCLEDSTablesSTL->AddFaceOC(lidFace, lidEU);
}

/*
// STL has no inner face contours!
inline VOID CLEDSGeometry::STLlidAddFaceIC(LID lidFace, LID lidEU)
{
  m_pCLEDSTablesSTL->AddFaceIC(lidFace, lidEU);
}
*/

inline VOID CLEDSGeometry::OneStageAddEUFace(CLEDSliteEdgeUse *pEU, CLEDSliteFace *pFace)
{
  pEU->SetLEDSFace(pFace);
}

inline VOID CLEDSGeometry::OneStageAddEUNextContEU(CLEDSliteEdgeUse *pEU1, 
											 CLEDSliteEdgeUse *pEU2)
{
  pEU1->SetLEDSNCEdgeUse(pEU2);
}

inline VOID CLEDSGeometry::OneStageAddFaceOC(CLEDSliteFace *pFace, 
									   CLEDSliteEdgeUse *pEU)
{
  pFace->SetLEDSOuterContourEU(pEU);
}

#endif // __LEDSGEOMETRY_H__