////////////////////////////////////////////////////////////////////////
//
// Copyright (C) 2000-2024 The Octave Project Developers
//
// See the file COPYRIGHT.md in the top-level directory of this
// distribution or <https://octave.org/copyright/>.
//
// This file is part of Octave.
//
// Octave is free software: you can redistribute it and/or modify it
// under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
//
// Octave is distributed in the hope that it will be useful, but
// WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with Octave; see the file COPYING.  If not, see
// <https://www.gnu.org/licenses/>.
//
////////////////////////////////////////////////////////////////////////

/*
20. Augiust 2000 - Kai Habel: first release
*/

/*
2003-12-14 Rafael Laboissiere <rafael@laboissiere.net>
Added optional second argument to pass options to the underlying
qhull command
*/

#if defined (HAVE_CONFIG_H)
#  include "config.h"
#endif

#include <cstdio>

#include <limits>
#include <string>

#include "Array.h"
#include "boolMatrix.h"
#include "dMatrix.h"
#include "dRowVector.h"
#include "oct-locbuf.h"
#include "unwind-prot.h"

#include "Cell.h"
#include "defun-dld.h"
#include "error.h"
#include "errwarn.h"
#include "ov.h"
#include "ovl.h"

#if defined (HAVE_QHULL)
#  include "oct-qhull.h"
#  if defined (NEED_QHULL_R_VERSION)
char qh_version[] = "__voronoi__.oct 2007-07-24";
#  endif
#endif

OCTAVE_BEGIN_NAMESPACE(octave)

#if defined (HAVE_QHULL)

static void
free_qhull_memory (qhT *qh)
{
  qh_freeqhull (qh, ! qh_ALL);

  int curlong, totlong;
  qh_memfreeshort (qh, &curlong, &totlong);

  if (curlong || totlong)
    warning ("__voronoi__: did not free %d bytes of long memory (%d pieces)",
             totlong, curlong);
}

static bool
octave_qhull_dims_ok (octave_idx_type dim, octave_idx_type n, const char *who)
{
  if (sizeof (octave_idx_type) > sizeof (int))
    {
      int maxval = std::numeric_limits<int>::max ();

      if (dim > maxval || n > maxval)
        error ("%s: dimension too large for Qhull", who);
    }

  return true;
}

#endif

DEFUN_DLD (__voronoi__, args, ,
           doc: /* -*- texinfo -*-
@deftypefn  {} {@var{C}, @var{F} =} __voronoi__ (@var{caller}, @var{pts})
@deftypefnx {} {@var{C}, @var{F} =} __voronoi__ (@var{caller}, @var{pts}, @var{options})
@deftypefnx {} {@var{C}, @var{F}, @var{Inf_Pts} =} __voronoi__ (@dots{})
Undocumented internal function.
@end deftypefn */)
{
#if defined (HAVE_QHULL)

  int nargin = args.length ();

  if (nargin < 2 || nargin > 3)
    print_usage ();

  std::string caller = args(0).xstring_value ("__voronoi__: CALLER must be a string");

  octave_value_list retval;

  Matrix points = args(1).matrix_value ();
  const octave_idx_type dim = points.columns ();
  const octave_idx_type num_points = points.rows ();

  if (! octave_qhull_dims_ok (dim, num_points, "__voronoi__"))
    return ovl (0.0);

  points = points.transpose ();

  std::string options;

  if (dim <= 3)
    options = " Qbb";
  else
    options = " Qbb Qx";

  if (nargin == 3)
    {
      octave_value opt_arg = args(2);

      if (opt_arg.is_string ())
        options = ' ' + opt_arg.string_value ();
      else if (opt_arg.isempty ())
        ; // Use default options.
      else if (opt_arg.iscellstr ())
        {
          options = "";

          Array<std::string> tmp = opt_arg.cellstr_value ();

          for (octave_idx_type i = 0; i < tmp.numel (); i++)
            options += ' ' + tmp(i);
        }
      else
        error ("%s: OPTIONS must be a string, cell array of strings, or empty",
               caller.c_str ());
    }

  boolT ismalloc = false;

  // Set the outfile pointer to stdout for status information.
  FILE *outfile = nullptr;
  FILE *errfile = stderr;

  qhT context = { };
  qhT *qh = &context;

  std::string cmd = "qhull v" + options;

  int exitcode = qh_new_qhull (qh, dim, num_points, points.fortran_vec (),
                               ismalloc, &cmd[0], outfile, errfile);

  unwind_action free_memory ([qh] () { free_qhull_memory (qh); });

  if (exitcode)
    error ("%s: qhull failed", caller.c_str ());

  // Calling findgood_all provides the number of Voronoi vertices
  // (sets qh->num_good).

  qh_findgood_all (qh, qh->facet_list);

  octave_idx_type num_voronoi_regions
    = qh->num_vertices - qh_setsize (qh, qh->del_vertices);

  octave_idx_type num_voronoi_vertices = qh->num_good;

  // Find the voronoi centers for all facets.

  qh_setvoronoi_all (qh);

  facetT *facet;
  vertexT *vertex;
  octave_idx_type k;

  // Find the number of Voronoi vertices for each Voronoi cell and
  // store them in NI so we can use them later to set the dimensions
  // of the RowVector objects used to collect them.

  FORALLfacets
  {
    facet->seen = false;
  }

  OCTAVE_LOCAL_BUFFER (octave_idx_type, ni, num_voronoi_regions);
  for (octave_idx_type i = 0; i < num_voronoi_regions; i++)
    ni[i] = 0;

  k = 0;

  FORALLvertices
  {
    if (qh->hull_dim == 3)
      qh_order_vertexneighbors (qh, vertex);

    bool infinity_seen = false;

    facetT *neighbor, * *neighborp;

    FOREACHneighbor_ (vertex)
    {
      if (neighbor->upperdelaunay)
        {
          if (! infinity_seen)
            {
              infinity_seen = true;
              ni[k]++;
            }
        }
      else
        {
          neighbor->seen = true;
          ni[k]++;
        }
    }

    k++;
  }

  // If Qhull finds fewer regions than points, we will pad the end
  // of the at_inf and C arrays so that they always contain at least
  // as many elements as the given points array.

  // FIXME: is it possible (or does it make sense) for
  // num_voronoi_regions to ever be larger than num_points?

  octave_idx_type nr = (num_points > num_voronoi_regions
                        ? num_points : num_voronoi_regions);

  boolMatrix at_inf (nr, 1, false);

  // The list of Voronoi vertices.  The first element is always
  // Inf.
  Matrix F (num_voronoi_vertices+1, dim);

  for (octave_idx_type d = 0; d < dim; d++)
    F(0, d) = numeric_limits<double>::Inf ();

  // The cell array of vectors of indices into F that represent the
  // vertices of the Voronoi regions (cells).

  Cell C (nr, 1);

  // Now loop through the list of vertices again and store the
  // coordinates of the Voronoi vertices and the lists of indices
  // for the cells.

  FORALLfacets
  {
    facet->seen = false;
  }

  octave_idx_type i = 0;
  k = 0;

  FORALLvertices
  {
    if (qh->hull_dim == 3)
      qh_order_vertexneighbors (qh, vertex);

    bool infinity_seen = false;

    octave_idx_type idx = qh_pointid (qh, vertex->point);

    octave_idx_type num_vertices = ni[k++];

    // Qhull seems to sometimes produces regions with a single
    // vertex.  Is that a bug?  How can a region have just one
    // vertex?  Let's skip it.

    if (num_vertices == 1)
      continue;

    RowVector facet_list (num_vertices);

    octave_idx_type m = 0;

    facetT *neighbor, * *neighborp;

    FOREACHneighbor_(vertex)
    {
      if (neighbor->upperdelaunay)
        {
          if (! infinity_seen)
            {
              infinity_seen = true;
              facet_list(m++) = 1;
              at_inf(idx) = true;
            }
        }
      else
        {
          if (! neighbor->seen)
            {
              i++;
              for (octave_idx_type d = 0; d < dim; d++)
                F(i, d) = neighbor->center[d];

              neighbor->seen = true;
              neighbor->visitid = i;
            }

          facet_list(m++) = neighbor->visitid + 1;
        }
    }

    C(idx) = facet_list;
  }

  retval = ovl (F, C, at_inf);

  return retval;

#else

  octave_unused_parameter (args);

  std::string caller
    = (args.length () > 0
       ? args(0).xstring_value ("__voronoi__: CALLER must be a string")
       : "__voronoi__");

  err_disabled_feature (caller, "Qhull");

#endif
}

/*
## No test needed for internal helper function.
%!assert (1)
*/

OCTAVE_END_NAMESPACE(octave)