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

// (Steve)
#include <iostream>
using namespace std;

//////////////////////////////////////////////////////////////////////////////
// CLEDSEdgeUse Class
//
CLEDSliteEdgeUse::CLEDSliteEdgeUse()
{
}

VOID CLEDSliteEdgeUse::Init(CLEDSGeometry *pCLEDSGeometry)					 
{
  m_pledsRootVtx = NULL;
  m_pledsNCEdgeUse = NULL;
  m_pledsSiblingEdgeUse = this;
  m_pledsNVEdgeUse = NULL;
  m_pledsFace = NULL;
  m_pExtra = NULL;
  m_pCLEDSGeometry = pCLEDSGeometry;
}

VOID CLEDSliteEdgeUse::Init(CLEDSliteVertex *pledsRootVtx, 
							CLEDSliteEdgeUse *pledsNCEdgeUse, 
							CLEDSliteEdgeUse *pledsSiblingEdgeUse,
							CLEDSliteEdgeUse *pledsNVEdgeUse,
							CLEDSliteFace *pledsFace,
							CLEDSGeometry *pCLEDSGeometry)
{
  m_pledsRootVtx = pledsRootVtx;
  m_pledsNCEdgeUse = pledsNCEdgeUse; 
  m_pledsSiblingEdgeUse = pledsSiblingEdgeUse;
  m_pledsNVEdgeUse = pledsNVEdgeUse;
  m_pledsFace = pledsFace;
  m_pCLEDSGeometry = pCLEDSGeometry;
  m_pExtra = NULL;
}

VOID CLEDSliteEdgeUse::Uninit()
{
  CPlanar::Uninit();
}

CLEDSliteEdgeUse::~CLEDSliteEdgeUse()
{
  //  Uninit();
}

VOID CLEDSliteEdgeUse::Delete()
{

}

FLOAT CLEDSliteEdgeUse::GetLength()
{
 Vector vDiff = (GetLEDSOtherVtx()->GetPoint() - m_pledsRootVtx->GetPoint());
 return vDiff.Magnitude();
}

CLEDSliteEdgeUse *CLEDSliteEdgeUse::GetLEDSPrevCEdgeUse() const
{
  CLEDSliteEdgeUse *pEU, *pEUtemp;
  
  pEU = m_pledsNCEdgeUse;
  while (pEU) {
	if ((pEUtemp = pEU->GetLEDSNCEdgeUse()) == this)
	  return pEU;
	pEU = pEUtemp;
  }
  assert(FALSE);
  return NULL;
}

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

VOID CLEDSliteEdgeUse::RenderNormals(FLOAT /*fMag*/)
{
}

VOID CLEDSliteEdgeUse::WriteSTL(FILE */*fpOutputFile*/)
{
}

VOID CLEDSliteEdgeUse::Display() const
{
  cout << "Edge use w/ root ";
  GetLEDSRootVtx()->Display();
  cout << "and 2nd ";
  GetLEDSOtherVtx()->Display();
  //  cout << "With the following pointers: ";
  //  cout << "\nNCE " << m_pledsNCEdgeUse;
  //  cout << "\nSib "  << m_pledsSiblingEdgeUse << "\nNVE "  << m_pledsNVEdgeUse;
  //  cout  << "\nFace "  << m_pledsFace << endl;

}

UINT_32 CLEDSliteEdgeUse::GetVertexCount()
{
  return 2;
}

//////////////////////////////////////////////////////////////////////////////
// CLEDSEdgeUse Class
//
CLEDSEdgeUse::CLEDSEdgeUse()
{
  m_lidLID = NON_LID;
  m_lidRootVtx = NON_LID;
  m_lidNCEdgeUse = NON_LID;
  m_lidSiblingEdgeUse = NON_LID;
  m_lidNVEdgeUse = NON_LID;
  m_lidFace = NON_LID;
}

CLEDSEdgeUse::~CLEDSEdgeUse()
{
  //  Uninit();
}

VOID CLEDSEdgeUse::Init(LID lidLID, LID lidRootVtx, LID lidNCEdgeUse, 
						LID lidSiblingEdgeUse, LID lidNVEdgeUse, LID lidFace,
						CLEDSGeometry *pCLEDSGeometry)
{

  m_lidLID = lidLID;
  m_lidRootVtx =lidRootVtx;
  m_lidNCEdgeUse = lidNCEdgeUse;
  m_lidSiblingEdgeUse = lidSiblingEdgeUse;
  m_lidNVEdgeUse = lidNVEdgeUse;
  m_lidFace = lidFace;
  m_pCLEDSGeometry = pCLEDSGeometry;

}

VOID CLEDSEdgeUse::Uninit()
{
  CLEDSliteEdgeUse::Uninit();
}

CLEDSEdgeUse *CLEDSEdgeUse::GetSafeLEDSSiblingEdgeUse() const
{
  if (m_pCLEDSGeometry->GetPtrsUpdated() == TRUE) 
	return (CLEDSEdgeUse *)m_pledsSiblingEdgeUse;
  else
	return ((CLEDSEdgeUse *)m_pCLEDSGeometry->GetLIDmapEU()->
			GetPtr(m_lidSiblingEdgeUse));
}


CLEDSVertex *CLEDSEdgeUse::GetSafeLEDSRootVtx() const
{
  if (m_pCLEDSGeometry->GetPtrsUpdated() == TRUE) 
	return (CLEDSVertex *)m_pledsRootVtx;
  else 
	return ((CLEDSVertex *)m_pCLEDSGeometry->GetLIDmapVtx()->
			GetPtr(m_lidRootVtx));
}

CLEDSVertex *CLEDSEdgeUse::GetSafeLEDSOtherVtx() const
{
  fprintf(stdout, "Warning: untested function GetSafeLEDSOtherVtx called.\n");
  CLEDSEdgeUse *pNCEU;
  LID lidVtx;

  if (m_pCLEDSGeometry->GetPtrsUpdated() == TRUE) 
	return  (CLEDSVertex *)GetLEDSNCEdgeUse()->GetLEDSRootVtx();
  else {
	pNCEU = (CLEDSEdgeUse *)m_pCLEDSGeometry->
	  GetLIDmapEU()->GetPtr(m_lidNCEdgeUse);
	lidVtx =  pNCEU->GetRootVtx();
	return ((CLEDSVertex *)m_pCLEDSGeometry->GetLIDmapVtx()->GetPtr(lidVtx));
/*			((*CLEDSEdgeUse)m_pCLEDSGeometry->
			 GetLIDmap()->GetPtr(m_lidNCEdgeUse))
			->GetRootVtx()); */
  }
}


CLEDSEdgeUse *CLEDSEdgeUse::GetSafeLEDSNCEdgeUse() const
{
  if (m_pCLEDSGeometry->GetPtrsUpdated() == TRUE) 
	return (CLEDSEdgeUse *)m_pledsNCEdgeUse;
  else 
	return ((CLEDSEdgeUse *)m_pCLEDSGeometry->GetLIDmapEU()->
			GetPtr(m_lidNCEdgeUse));
}

CLEDSEdgeUse *CLEDSEdgeUse::GetSafeLEDSNVEdgeUse() const
{
  if (m_pCLEDSGeometry->GetPtrsUpdated() == TRUE) 
	return (CLEDSEdgeUse *)m_pledsNVEdgeUse;
  else 
	return ((CLEDSEdgeUse *)m_pCLEDSGeometry->GetLIDmapEU()->
			GetPtr(m_lidNVEdgeUse));
}

CLEDSFace *CLEDSEdgeUse::GetSafeLEDSFace() const
{
  if (m_pCLEDSGeometry->GetPtrsUpdated() == TRUE) 
	return (CLEDSFace *)m_pledsFace;
  else
	return ((CLEDSFace *)m_pCLEDSGeometry->GetLIDmapFace()->
			GetPtr(m_lidFace));
}


// This is lame; I had to define it cause I subclassed EdgeUse off of
// planar while it should be off of some PathPlanar thing (e.g. an edge)
// which hadn't been defined yet.
CGeometryIter *CLEDSliteEdgeUse::AllocateIter()// const
{
  CGeometryIter *pCLEDSEdgeUseIter;

  pCLEDSEdgeUseIter = new CGeometryIter;
  ASSERT(pCLEDSEdgeUseIter != NULL );
  pCLEDSEdgeUseIter->Init(this);

  return pCLEDSEdgeUseIter;
}

VOID CLEDSliteEdgeUse::FreeIter(CGeometryIter *pCLEDSEdgeUseIter)
{
  delete pCLEDSEdgeUseIter;
}

VOID CLEDSEdgeUse::Display() const
{
  cout << "lid " << m_lidLID << "\tVtx " << m_lidRootVtx;
  cout << "\tNCE " << m_lidNCEdgeUse;
  cout << "\tSib "  << m_lidSiblingEdgeUse << "\tNVE "  << m_lidNVEdgeUse;
  cout  << "\tFace "  << m_lidFace << endl;
}


/*
CLEDSEdgeUsePrev *CLEDSEdgeUsePrev::GetLEDSPrevCEdgeUse() const
{
  if (m_pledsPrevCEdgeUse)
	return m_pledsPrevCEdgeUse;

  CLEDSEdgeUsePrev *pEU, *pEUnext;
  
  pEU = (CLEDSEdgeUsePrev *)m_pledsNCEdgeUse;
  while (pEU) {
	pEUnext = (CLEDSEdgeUsePrev *)pEU->GetLEDSNCEdgeUse();
	pEUnext->m_pledsPrevCEdgeUse = pEU;
	if (pEUnext == this) {
	  return (CLEDSEdgeUsePrev *)pEU;
	}
	pEU = pEUnext;
  }
  assert(FALSE);
  return NULL;
}

*/
CLEDSliteEdgeUse *CLEDSEdgeUsePrev::GetLEDSPrevCEdgeUse() const
{
  if (m_pledsPrevCEdgeUse)
	return m_pledsPrevCEdgeUse;

  CLEDSEdgeUsePrev *pEU, *pEUnext;
  //CLEDSliteEdgeUse *pEU, *pEUnext;

  pEU = (CLEDSEdgeUsePrev *)m_pledsNCEdgeUse;
  //  pEU->m_pledsPrevCEdgeUse = this;
  pEU->m_pledsPrevCEdgeUse = (CLEDSEdgeUsePrev *)this;
  while (pEU) {
	pEUnext = (CLEDSEdgeUsePrev *)(pEU->GetLEDSNCEdgeUse());
	pEUnext->m_pledsPrevCEdgeUse = pEU;
	if (pEUnext == this) {
	  return pEU;
	}
	pEU = pEUnext;
  }
  assert(FALSE);
  return NULL;
}

/*
VOID CLEDSEdgeUsePrev::Display() const
{
}
*/
/*

//////////////////////////////////////////////////////////////////////////////
// CLEDSEdgeUseIter Class
//

CLEDSEdgeUseIter::CLEDSEdgeUseIter()
{
  m_lidEdgeIter = NON_LID;
}

CLEDSEdgeUseIter::~CLEDSEdgeUseIter()
{
}

VOID CLEDSEdgeUseIter::Init(const CLEDSFace *pCLEDSFace)
{
  //  CTriangleIter::Init(pCLEDSFace);

  m_lidEdgeIter = pCLEDSFace->GetOuterContourEU();
}

VOID CLEDSEdgeUseIter::Uninit()
{
  m_lidEdgeIter = NON_LID;

  //  CTriangleIter::Uninit();
}

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

    return (m_lidEdgeIter != NON_LID);
}
*/

//////////////////////////////////////////////////////////////////////////////
// CLEDSContourIter Class
//

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

CLEDSliteContourIter::~CLEDSliteContourIter()
{
}

VOID CLEDSliteContourIter::Init(CLEDSliteEdgeUse *pCLEDSEdgeUse)
{
  m_pCGeometry = pCLEDSEdgeUse;
  m_pledsEdgeIter = pCLEDSEdgeUse;
}

VOID CLEDSliteContourIter::Uninit()
{
  m_pCGeometry = NULL;
}

BOOL CLEDSliteContourIter::Valid()
{
    return (m_pledsEdgeIter != NULL);
}

CLEDSliteEdgeUse *CLEDSliteContourIter::PeekNextContourEU()
{
  m_pledsEdgeIter = m_pledsEdgeIter->GetLEDSNCEdgeUse();
  return (m_pledsEdgeIter);
}


/***/
//////////////////////////////////////////////////////////////////////////////
// CLEDSContourIter Class
//

CLEDSContourIter::CLEDSContourIter()
{
}

CLEDSContourIter::~CLEDSContourIter()
{
}

CLEDSliteEdgeUse *CLEDSContourIter::PeekNextContourEU()
{
  m_pledsEdgeIter = ((CLEDSEdgeUse *)m_pledsEdgeIter)->GetSafeLEDSNCEdgeUse();
  return (m_pledsEdgeIter);
}



//////////////////////////////////////////////////////////////////////////////
// CLEDSliteSiblingIter Class
//

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

CLEDSliteSiblingIter::~CLEDSliteSiblingIter()
{
}

VOID CLEDSliteSiblingIter::Init(CLEDSliteEdgeUse *pCLEDSEdgeUse)
{
  m_pCGeometry = pCLEDSEdgeUse;
  m_pledsEdgeIter = pCLEDSEdgeUse;
}

VOID CLEDSliteSiblingIter::Uninit()
{
  m_pCGeometry = NULL;
}

BOOL CLEDSliteSiblingIter::Valid()
{
    return (m_pledsEdgeIter != NULL);
}

CLEDSliteEdgeUse *CLEDSliteSiblingIter::PeekFirstSiblingEU()
{
  return PeekNextSiblingEU();
}

CLEDSliteEdgeUse *CLEDSliteSiblingIter::PeekNextSiblingEU()
{
  m_pledsEdgeIter = m_pledsEdgeIter->GetLEDSSiblingEdgeUse();
  return (m_pledsEdgeIter);
}


//////////////////////////////////////////////////////////////////////////////
// CLEDSSiblingIter Class
//

CLEDSSiblingIter::CLEDSSiblingIter()
{
}

CLEDSSiblingIter::~CLEDSSiblingIter()
{
}

CLEDSliteEdgeUse *CLEDSSiblingIter::PeekFirstSiblingEU()
{
  return PeekNextSiblingEU();
}

CLEDSliteEdgeUse *CLEDSSiblingIter::PeekNextSiblingEU()
{
  m_pledsEdgeIter = ((CLEDSEdgeUse *)m_pledsEdgeIter)->GetSafeLEDSSiblingEdgeUse();
  return (m_pledsEdgeIter);
}