#include "ledsface.h"
#include "ledsvertex.h"
#include "ledsedgeuse.h"
#include "ledsgeometry.h"

//////////////////////////////////////////////////////////////////////////////
// CLEDSliteFace Class
//

CLEDSliteFace::CLEDSliteFace()
{
  m_pCLEDSGeometry = NULL;
  m_pledsListInner = NULL;
  m_pledsOuterContourEU = NULL;
  m_pExtra = NULL;
}

CLEDSliteFace::~CLEDSliteFace()
{
  Local_Uninit();
}


VOID CLEDSliteFace::Init(CLEDSGeometry *pCLEDSGeometry)
{
  m_pCLEDSGeometry = pCLEDSGeometry;
}

VOID CLEDSliteFace::Init(CListInt *pledsListInner, 
		  CLEDSliteEdgeUse *pledsOuterContourEU,
		  CLEDSGeometry *pCLEDSGeometry)
{
  m_pledsListInner = pledsListInner;
  m_pledsOuterContourEU = pledsOuterContourEU;
  m_pCLEDSGeometry = pCLEDSGeometry;
}

VOID CLEDSliteFace::Local_Uninit()
{
  delete m_pledsListInner;
}

VOID CLEDSliteFace::Uninit()
{
  Local_Uninit();
  m_pledsListInner = NULL;
  CPlanar::Uninit();
}

VOID CLEDSliteFace::Delete()
{
}

BOOL CLEDSliteFace::Valid()
{
  BOOL bCorrect;

  bCorrect = TRUE;

  if ( !CPlanar::Valid() )
    {
      return FALSE;
    }

  // Should do some more checks in here.

  return bCorrect;
}

Vector CLEDSliteFace::GetNormal()
{
  Vector vNormal;
  Vector v1, v2;
  CLEDSliteEdgeUse *eu2nd, *eu3rd;
  
  eu2nd = m_pledsOuterContourEU->GetLEDSNCEdgeUse();
  eu3rd = eu2nd->GetLEDSNCEdgeUse();
  v1 = eu2nd->GetLEDSRootVtx()->GetPoint() -
	m_pledsOuterContourEU->GetLEDSRootVtx()->GetPoint();
  v2 = eu3rd->GetLEDSRootVtx()->GetPoint() -
	eu2nd->GetLEDSRootVtx()->GetPoint();

  vNormal = v1.Cross(v2);
  return vNormal;
}

VOID CLEDSliteFace::Display() const
{
  /*
  cout << "Face:\t"  << "LID " << m_lidLID << " OC EU " << m_lidOuterContourEU;
  cout << endl;
  if (m_pledsOuterContourEU != NULL) {
	cout << " 1st Outer Contour EU :";
	m_pledsOuterContourEU->Display();
  }
  */
}


UINT_32 CLEDSliteFace::GetVertexCount()
{
  return 0;
}

CGeometryIter *CLEDSliteFace::AllocateIter()// const
{
  CLEDSliteFaceIter *pCLEDSFaceIter;

  pCLEDSFaceIter = new CLEDSliteFaceIter;
  ASSERT(pCLEDSFaceIter != NULL );
  pCLEDSFaceIter->Init(this);

  return pCLEDSFaceIter;
}

VOID CLEDSliteFace::FreeIter(CGeometryIter *pCLEDSFaceIter)
{
  delete pCLEDSFaceIter;
}

VOID CLEDSliteFace::Render(BOOL /*bFacetted*/, BOOL /*bTexture*/)
{

}

VOID CLEDSliteFace::RenderNormals(FLOAT /*fMag*/)
{

}

VOID CLEDSliteFace::ResolveType()
{
}

BOOL CLEDSliteFace::CheckReferences()
{
  return TRUE;
}

BOOL CLEDSliteFace::CheckTopology()
{
  return TRUE;
}

//BUG!!! This assumes triangle faces only!!!
VOID CLEDSliteFace::WriteSTL(FILE *fpOutputFile)
{
  CLEDSliteFaceIter *Iter = (CLEDSliteFaceIter *)AllocateIter();
  CVertex *pVtx1, *pVtx2, *pVtx3;

  pVtx1 = Iter->PeekFirstCVertex();
  pVtx2 = Iter->PeekNextCVertex();
  pVtx3 = Iter->PeekNextCVertex();
  WriteSTLTriangle(fpOutputFile, pVtx1->GetPoint(), pVtx2->GetPoint(), pVtx3->GetPoint());
  FreeIter(Iter);
}

VOID CLEDSliteFace::WriteSIF(UINT_32 /*uiLevel*/) const
{
}

VOID CLEDSliteFace::WriteSTL(UINT_32 /*uiLevel*/, const Matrix &/*m*/) const
{
}

VOID CLEDSliteFace::WriteDSG(UINT_32 /*uiLevel*/) const
{
}


/*

Vector CLEDSFace::GetNormal()
{
  return m_vNormal;
}

Point CLEDSFace::GetCentroid()
{
  return m_ptCentroid;
}
*/



//////////////////////////////////////////////////////////////////////////////
// CLEDSFace Class
//

CLEDSFace::CLEDSFace()
{
  m_plidListInner = NULL;
  m_lidOuterContourEU = NON_LID;
  m_lidLID = NON_LID;
}

CLEDSFace::~CLEDSFace()
{
  Local_Uninit();
}

VOID CLEDSFace::Init(LID lidFace, LID lidOuterContourEU, 
					 CLEDSGeometry *pCLEDSGeometry,
					 CListInt *plidListInner = NULL)
					
{
  ASSERT((lidFace != NON_LID) && (lidOuterContourEU  != NON_LID));

    m_plidListInner = plidListInner;
	m_lidOuterContourEU =  lidOuterContourEU;
	m_lidLID = lidFace;

	m_pCLEDSGeometry = pCLEDSGeometry;
  //  VERIFY( CalculateNormal(m_vNormal) );
  //  CalculateCentroid(m_ptCentroid);
}


VOID CLEDSFace::Local_Uninit()
{
  delete m_plidListInner;
}

VOID CLEDSFace::Uninit()
{
  Local_Uninit();
  m_plidListInner = NULL;
  m_lidOuterContourEU = NON_LID;
  m_lidLID = NON_LID;
  CLEDSliteFace::Uninit();
}


CLEDSEdgeUse *CLEDSFace::GetSafeLEDSOuterContourEU() const
{
  if (m_pCLEDSGeometry->GetPtrsUpdated() == TRUE) 
	return ((CLEDSEdgeUse *)m_pledsOuterContourEU);
  else
	return ((CLEDSEdgeUse *)m_pCLEDSGeometry->GetLIDmapEU()->
			GetPtr(m_lidOuterContourEU));
}

VOID CLEDSFace::Display() const
{
  cout << "Face:\t"  << "LID " << m_lidLID << " OC EU " << m_lidOuterContourEU;
  cout << endl;
  if (m_pledsOuterContourEU != NULL) {
	cout << " 1st Outer Contour EU :";
	m_pledsOuterContourEU->Display();
  }
}




//////////////////////////////////////////////////////////////////////////////
// CLEDSliteFaceIter Class
//

CLEDSliteFaceIter::CLEDSliteFaceIter()
{
  m_pledsEdgeIter = NULL;
  m_pCGeometry = NULL;
}

CLEDSliteFaceIter::~CLEDSliteFaceIter()
{
}

VOID CLEDSliteFaceIter::Init(const CLEDSliteFace *pCLEDSFace)
{
  m_pCGeometry = (CGeometry*) pCLEDSFace;
}

VOID CLEDSliteFaceIter::Uninit()
{
  m_pCGeometry = NULL;
  CPlanarIter::Uninit();
}

BOOL CLEDSliteFaceIter::Valid()
{
  if ( !CPlanarIter::Valid() )
    {
      return FALSE;
    }

    return (m_pCGeometry != NULL);
}


CVertex *CLEDSliteFaceIter::PeekFirstCVertex()
{
  m_pledsEdgeIter = ((CLEDSliteFace*)m_pCGeometry)->GetLEDSOuterContourEU();
  return (m_pledsEdgeIter->GetLEDSRootVtx());

}

CVertex *CLEDSliteFaceIter::PeekNextCVertex()
{
  m_pledsEdgeIter = m_pledsEdgeIter->GetLEDSNCEdgeUse();
  return (m_pledsEdgeIter->GetLEDSRootVtx());

}


// These functions are costly in LEDS.  
CVertex *CLEDSliteFaceIter::PeekLastCVertex()
{
  return NULL;
}

CVertex *CLEDSliteFaceIter::PeekPrevCVertex()
{
  return NULL;
}


//////////////////////////////////////////////////////////////////////////////
// CLEDSFaceIter Class
//

CLEDSFaceIter::CLEDSFaceIter()
{
}

CLEDSFaceIter::~CLEDSFaceIter()
{
}

CVertex *CLEDSFaceIter::PeekFirstCVertex()
{
  m_pledsEdgeIter = ((CLEDSFace*)m_pCGeometry)->GetSafeLEDSOuterContourEU();
  return ((CLEDSEdgeUse *)m_pledsEdgeIter)->GetSafeLEDSRootVtx();

}

CVertex *CLEDSFaceIter::PeekNextCVertex()
{
  m_pledsEdgeIter = ((CLEDSEdgeUse *)m_pledsEdgeIter)->GetSafeLEDSNCEdgeUse();
  return ((CLEDSEdgeUse *)m_pledsEdgeIter)->GetSafeLEDSRootVtx();

}