#include <simplexD2linked.h>
#include <d3tess.h>

#include <d3minrecursive.h>

d3minrecursive::d3minrecursive(d3tess & _tess, d3minoperator * _minimizer)
  : tess(_tess), minimizer(_minimizer)
{
}


d3minrecursive::~d3minrecursive()
{
  delete minimizer;
  minimizer=0;
}

bool const d3minrecursive::minimizesimplex(uintc a)
{
  simplexD2linked & A(tess.vi[a]);

  bool res;

  uint nb;
  for (uint i=0; i<3; ++i)
  {
    nb = A.ni[i]; 
    res = minimizer->eval(a,nb);
    if (res)
    {
      process.push_back(nb);
      process.push_back(a);
      return true;
    }
  }

  return false;
}


bool const d3minrecursive::eval(uintc a)
{
  assert(a!=0);
  assert(a<tess.vi.size());

  process.clear();

  bool res = minimizesimplex(a);

  uint sz=process.size();
  if (sz==0)
    return res;

  for (uint b; sz!=0; )
  {
    b = process[sz-1];
    process.pop_back();

    minimizesimplex(b);

    sz = process.size();
  }

  return true;
}

d3minrecursiveoperator::d3minrecursiveoperator
(
  d3tess & _tess, 
  d3minoperator * _minimizer
)
  : d3minoperator(_tess), x(_tess,_minimizer)
{
}
  
bool const d3minrecursiveoperator::eval(uintc a, uintc b)
{
//cout << "d3minrecursiveoperator::eval:  " << a << " " << b << endl;
  bool res(false);

  if (x.eval(a))
    res=true;

  if (x.eval(b))
    res=true;
  
  return res;
}

d3minrecursiveoperator::~d3minrecursiveoperator()
{
}