/** E` un grafo (non orientato) immerso nel piano cartesiano. I nodi sono
	 quindi punti (classe Point). In ogni istante ci possono essere nodi
	 selezionati. */
import java.awt.Point;
import java.util.*;

public class Model {

	 private static final int initialDim = 10;
	 private static final double EPSILON = 4;
	 /** Numero di nodi. */
	 private int n;
	 /** Nodi. */
	 private Point nodes[];
	 /** Matrice di adiacenza. */
	 private boolean adj[][];
	 /** Selezionati. */
	 private boolean selected[];


	 public Model() {
		  n = 0;
		  nodes = new Point[ initialDim ];
		  adj = new boolean[ initialDim ][ initialDim ];
		  selected = new boolean[ initialDim ];
	 }


	 /** Aggiunge un nodo (non selezionato) alla fine dell'array. 
	  *  @param p Il punto in cui si trova il nuovo nodo.
	  */
	 public void addNode( Point p ) {
		  if ( n == nodes.length ) {
				Point newnodes[] = new Point[ 2*n ];
				boolean newadj[][] = new boolean[ 2*n ][ 2*n ];
				boolean newselected[] = new boolean[ 2*n ];
				System.arraycopy( nodes, 0, newnodes, 0, n );
				for ( int i = 0; i < n; i++ )
					 System.arraycopy( adj[i], 0, newadj[i], 0, n );
				System.arraycopy( selected, 0, newselected, 0, n );
				nodes = newnodes;
				adj = newadj;
				selected = newselected;
		  }
		  nodes[n] = p;
		  selected[n] = false;
		  for ( int i = 0; i <= n; i++ ) 
				adj[ i ][ n ] = adj[ n ][ i ] = false;
		  n++;
	 }

	 /** Restituisce l'indice del nodo pių vicino al punto p. 
	  *  @param p Il punto vicino cui cercare.
	  *  @return L'indice del nodo pių vicino (o -1 se non ci sono nodi).
	  */
	 private int nearest( Point p ) {
		  int minindex = -1;
		  for ( int i = 0; i < n; i++ ) 
				if ( minindex < 0 || p.distance( nodes[i] ) 
					  < p.distance( nodes[minindex] ) )
					 minindex = i;
		  return minindex;
	 }

	 /** Restituisce l'indice del nodo pių vicino al punto p, se la
	  *  distanza č minore di EPSILON. Altrimenti restituisce -1.
	  *  @param p Il punto vicino cui cercare.
	  *  @return L'indice del nodo pių vicino (o -1 se non ci sono nodi).
	  */
	 public int isThereANode( Point p ) {
		  int i = nearest( p );
		  if ( i < 0 || p.distance( nodes[i] ) >= EPSILON ) return -1;
		  else return i;
	 }

	 /** Cambia lo stato di selezione del nodo i. 
	  *  @param i L'indice del nodo di cui cambiare lo stato.
	  */
	 public void changeSelectionState( int i ) {
		  if ( i >= 0 ) 
				selected[ i ] = ! selected[ i ];
	 }

	 /** Cancella tutto il gravo. 
	  */
	 public void clearAll() {
		  n = 0;
		  nodes = new Point[ initialDim ];
		  adj = new boolean[ initialDim ][ initialDim ];
		  selected = new boolean[ initialDim ];
	 }

	 /** Rende non selezionati tutti i nodi. 
	  */
	 public void clearSelection() {
		  Arrays.fill( selected, false );
	 }


	 /** Cambia l'adiacenza per ogni coppia di nodi selezionati */
	 public void changeAdjacency() {
		  for ( int i = 0; i < n; i++ ) 
				if ( selected[ i ] )
					 for ( int j = i+1; j < n; j++ )
						  if ( selected[ j ] )
								adj[ i ][ j ] = adj[ j ][ i ] = ! adj[ i ][ j ];
	 }

	 /** Restituisce il numero di nodi. */
	 public int size() {
		  return n;
	 }

	 /** Restituisce il punto del nodo i.
	  *  @param i Il nodo.
	  *  @return Il punto in cui si trova il nodo.
	  */
	 public Point node( int i ) {
		  return nodes[ i ];
	 }

	 /** Restituisce true se il nodo i č selezionato.
	  *  @param i Il nodo.
	  *  @return true se il nodo č selezionato.
	  */
	 public boolean isSelected( int i ) {
		  return selected[ i ];
	 }
	 /** Restituisce true se i e j sono adiacenti.
	  *  @param i Il primo nodo.
	  *  @param j Il secondo nodo.
	  *  @return true se i e j sono adiacenti.
	  */
	 public boolean areAdj( int i, int j ) {
		  return adj[ i ][ j ];
	 }
}