import { vtkObject } from './../../interfaces';
import { Bounds, Vector3 } from './../../types';
import vtkPoints from './../Core/Points';
/**
 *
 */
export interface IIncrementalOctreeNodeInitialValues {
  pointIdSet?: number[];
  minBounds?: Bounds;
  maxBounds?: Bounds;
  minDataBounds?: Bounds;
  maxDataBounds?: Bounds;
  parent?: vtkIncrementalOctreeNode;
  children?: vtkIncrementalOctreeNode[];
}

export interface vtkIncrementalOctreeNode extends vtkObject {
  /**
   * Create a list object for storing point indices.
   */
  createPointIdSet(): void;

  /**
   * Set the spatial bounding box of the node. This function sets a default
   * data bounding box.
   *
   * @param {Number} x1
   * @param {Number} x2
   * @param {Number} y1
   * @param {Number} y2
   * @param {Number} z1
   * @param {Number} z2
   */
  setBounds(
    x1: number,
    x2: number,
    y1: number,
    y2: number,
    z1: number,
    z2: number
  ): void;

  /**
   * Get the spatial bounding box of the node. The values are returned via
   * an array in order of: x_min, x_max, y_min, y_max, z_min, z_max.
   *
   * @param {Bounds} bounds
   */
  getBounds(bounds: Bounds): void;

  /**
   * @param {Vector3} point
   */
  getChildIndex(point: Vector3): number;

  /**
   * @param {Vector3} point
   */
  containsPoint(point: Vector3): boolean;

  /**
   * @param {Vector3} point
   */
  containsPointByData(point: Vector3): boolean;

  /**
   * Given a point inserted to either this node (a leaf node) or a descendant
   * leaf (of this node --- when this node is a non-leaf node), update the
   * counter and the data bounding box for this node only. The data bounding box
   * is considered only if updateData is non-zero. The returned value indicates
   * whether (1) or not (0) the data bounding box is actually updated. Note that
   * argument nHits must be 1 unless this node is updated with a number (nHits)
   * of exactly duplicate points as a whole via a single call to this function.
   *
   * @param {Vector3} point
   * @param {Number} nHits
   * @param {Boolean} updateData
   */
  updateCounterAndDataBounds(
    point: Vector3,
    nHits: number,
    updateData: boolean
  ): boolean;

  /**
   * Given a point inserted to either this node (a leaf node) or a descendant
   * leaf (of this node --- when this node is a non-leaf node), update the
   * counter and the data bounding box recursively bottom-up until a specified
   * node. The data bounding box is considered only if updateData is non-zero.
   * The returned value indicates whether (true) or not (false) the data bounding box
   * is actually updated. Note that argument nHits must be 1 unless this node
   * is updated with a number (nHits) of exactly duplicate points as a whole
   * via a single call to this function.
   *
   * @param {Vector3} point
   * @param {Number} nHits
   * @param {Boolean} updateData
   * @param {vtkIncrementalOctreeNode} endNode
   */
  updateCounterAndDataBoundsRecursively(
    point: Vector3,
    nHits: number,
    updateData: boolean,
    endNode: vtkIncrementalOctreeNode
  ): boolean;

  /**
   * Given a point, determine whether (true) or not (false) it is an exact duplicate
   * of all the points, if any, maintained in this node. In other words, to
   * check if this given point and all existing points, if any, of this node
   * are exactly duplicate with one another.
   *
   * @param {Vector3} point
   */
  containsDuplicatePointsOnly(point: Vector3): boolean;

  /**
   * Determine whether or not this node is a leaf.
   */
  isLeaf(): boolean;

  /**
   * Get the child at the given index i.
   * i must be an int between 0 and 7.
   *
   * @param {Number} i
   */
  getChild(i: number): vtkIncrementalOctreeNode;

  /**
   * Given a number (>= threshold) of all exactly duplicate points (accessible
   * via points and pntIds, but with exactly the same 3D coordinate) maintained
   * in this leaf node and a point (absolutely not a duplicate any more, with
   * pntIdx storing the index in points)) to be inserted to this node, separate
   * all the duplicate points from this new point by means of usually recursive
   * node sub-division such that the former points are inserted to a descendant
   * leaf while the new point is inserted to a sibling of this descendant leaf.
   * Argument ptMode specifies whether the point is not inserted at all but only
   * the point index is provided upon 0, the point is inserted via vtkPoints::
   * InsertPoint() upon 1, or this point is instead inserted through vtkPoints::
   * InsertNextPoint() upon 2.
   *
   * @param {vtkPoints} points
   * @param {Number[]} pntIds
   * @param {Vector3} newPnt
   * @param {Number} pntIdx
   * @param {Number} maxPts
   * @param {Number} ptMode
   */
  separateExactlyDuplicatePointsFromNewInsertion(
    points: vtkPoints,
    pntIds: number[],
    newPnt: Vector3,
    pntIdx: number,
    maxPts: number,
    ptMode: number
  ): void;

  /**
   * Divide this LEAF node into eight child nodes as the number of points
   * maintained by this leaf node has reached the threshold maxPts while
   * another point newPnt is just going to be inserted to it. The available
   * point-indices pntIds are distributed to the child nodes based on the
   * point coordinates (available through points). Note that this function
   * can incur recursive node-division to determine the specific leaf node
   * for accepting the new point (with pntIdx storing the index in points)
   * because the existing maxPts points may fall within only one of the eight
   * child nodes to make a radically imbalanced layout within the node (to
   * be divided). Argument ptMode specifies whether the point is not inserted
   * at all but instead only the point index is provided upon 0, the point is
   * inserted via vtkPoints.InsertPoint() upon 1, or the point is inserted by
   * vtkPoints.InsertNextPoint() upon 2. The returned value of this function
   * indicates whether pntIds needs to be destroyed (1) or just unregistered
   * from this node as it has been attached to another node (0).
   * numberOfNodes in the tree is updated with new created nodes
   *
   * @param {vtkPoints} points
   * @param {Number[]} pntIds
   * @param {Vector3} newPnt
   * @param {Number} pntIdx
   * @param {Number} maxPts
   * @param {Number} ptMode
   * @param {Number} numberOfNodes
   */
  createChildNodes(
    points: vtkPoints,
    pntIds: number[],
    newPnt: Vector3,
    pntIdx: number,
    maxPts: number,
    ptMode: number,
    numberOfNodes: number
  ): { success: boolean; numberOfNodes: number; pointIdx: number };

  /**
   * This function is called after a successful point-insertion check and
   * only applies to a leaf node. Prior to a call to this function, the
   * octree should have been retrieved top-down to find the specific leaf
   * node in which this new point (newPt) will be inserted. The actual index
   * of the new point (to be inserted to points) is stored in pntId. Argument
   * ptMode specifies whether the point is not inserted at all but instead only
   * the point index is provided upon 0, the point is inserted via vtkPoints.
   * insertPoint() upon 1, or it is inserted via vtkPoints.insertNextPoint()
   * upon 2. For case 0, pntId needs to be specified. For cases 1 and 2, the
   * actual point index is returned via pntId. Note that this function always
   * returns 1 to indicate the success of point insertion.
   * numberOfNodes is the number of nodes present in the tree at this time.
   * it is used to assign an ID to each node which can be used to associate
   * application specific information with each node. It is updated if new nodes
   * are added to the tree.
   *
   * @param {Number} points
   * @param {Number} newPnt
   * @param {Number} maxPts
   * @param {Number} pntId
   * @param {Number} ptMode
   * @param {Number} numberOfNodes
   */
  insertPoint(
    points: number,
    newPnt: number,
    maxPts: number,
    pntId: number,
    ptMode: number,
    numberOfNodes: number
  ): { numberOfNodes: number; pointIdx: number };

  /**
   * Compute the minimum squared distance from a point to this node, with all
   * six boundaries considered. The data bounding box is checked if checkData
   * is non-zero. The closest on-boundary point is returned via closest.
   *
   * @param {Vector3} point
   * @param {Vector3} closest
   * @param {Boolean} innerOnly
   * @param {vtkIncrementalOctreeNode} rootNode
   * @param {Boolean} checkData
   * @returns {Number}
   */
  getDistance2ToBoundary(
    point: Vector3,
    closest: Vector3,
    innerOnly: boolean,
    rootNode: vtkIncrementalOctreeNode,
    checkData: boolean
  ): number;

  /**
   * Given a point inside this node, get the minimum squared distance to all
   * inner boundaries. An inner boundary is a node's face that is shared by
   * another non-root node.
   *
   * @param {Vector3} point
   * @param {vtkIncrementalOctreeNode} rootNode
   */
  getDistance2ToInnerBoundary(
    point: Vector3,
    rootNode: vtkIncrementalOctreeNode
  ): number;
}

// ----------------------------------------------------------------------------
// Static API
// ----------------------------------------------------------------------------

/**
 * Method use to decorate a given object (publicAPI+model) with vtkIncrementalOctreeNode characteristics.
 *
 * @param publicAPI object on which methods will be bounds (public)
 * @param model object on which data structure will be bounds (protected)
 * @param {object} [initialValues] (default: {})
 */
export function extend(
  publicAPI: object,
  model: object,
  initialValues?: object
): void;

// ----------------------------------------------------------------------------

/**
 * Method use to create a new instance of vtkIncrementalOctreeNode
 * @param {IIncrementalOctreeNodeInitialValues} [initialValues] for pre-setting some of its content
 */
export function newInstance(
  initialValues?: IIncrementalOctreeNodeInitialValues
): vtkIncrementalOctreeNode;

/**
 * vtkIncrementalOctreeNode
 */
export declare const vtkIncrementalOctreeNode: {
  newInstance: typeof newInstance;
  extend: typeof extend;
};

export default vtkIncrementalOctreeNode;