case CSPARISFIER_STATUS_CONNECT : 

					if (_DEBUG_)
						printf("[CONNECT]\n");

					if ((status == CSPARISFIER_STATUS_CONNECT) || (status == CSPARISFIER_STATUS_END)) {
						if (find(sparseNeighbors.begin(), sparseNeighbors.end(), sender_address) != sparseNeighbors.end())
							send_CONNECT(sender_address);
					}
					
					break;
					
			}
			
			break;
            
        default:
            break;
    }
	
}

//
// Invia un messaggio di "Candidatura" ovvero la lista di vicini che
// il nodo propone.
//
void
CSPARSIFIER_Agent::send_CANDIDATE(NodeAddress to) 
{		
    Packet* p = allocpkt();
    
    struct hdr_c_sparsifier * csparsifierh = HDR_CSPARSIFIER(p);
    
    csparsifierh->msg_type = CSPARSIFIER_CANDIDATE;
    csparsifierh->sender_address = myAddress;
    csparsifierh->destination_address = to;

	csparsifierh->selectedNodes = &candidateNeighbors;

	if (_DEBUG_) {
		printf("%d send CANDIDATE: (", myAddress);
		for (NodeList::iterator node = candidateNeighbors.begin(); node != candidateNeighbors.end(); node++)
			printf("%d  ", *node);
		printf("\n");
	}

	sendDown(p, sizeof(CSparsifierMessageType) + sizeof(nsaddr_t) * (2 + CSPARSIFIER_Agent::virtual_neighbors), to, CSPARSIFIER_Agent::max_delay);
}

//
// Invia un messaggio di "Candidatura" ovvero la lista di vicini che
// il nodo propone.
//
void
CSPARSIFIER_Agent::send_CONNECT(NodeAddress to) 
{		
    Packet* p = allocpkt();
    
    struct hdr_c_sparsifier * csparsifierh = HDR_CSPARSIFIER(p);
    
    csparsifierh->msg_type = CSPARSIFIER_CONNECT;
    csparsifierh->sender_address = myAddress;
    csparsifierh->destination_address = to;

	if (_DEBUG_)
		printf("%d send CONNECT to %d\n", myAddress, to);

	sendDown(p, sizeof(CSparsifierMessageType) + sizeof(nsaddr_t) * (2), to, CSPARSIFIER_Agent::max_delay);
}

//
// Funzione richiamata allo scadere di un timeout per un certo tipo di messaggio:
// Il nodomanda la richiesta del dato al vicino interessato.
//
void
CSPARSIFIER_Agent::timeout(NodeAddress from, CSparsifierTimeoutType timeout)
{
	switch (timeout) {
	
		case TIMEOUT_CONNECT :
			if (_DEBUG_)
				printf("%d timeout connect\n", myAddress);
			send_REQUEST(from, CSPARSIFIER_CONNECT);
			break;
				
		case TIMEOUT_CANDIDATE :
			if (_DEBUG_)
				printf("%d timeout candidate\n", myAddress);
			send_REQUEST(from, CSPARSIFIER_CANDIDATE);
			break;
	}
}

//
// Funzione richiamata allo scadere dell'ultimo timeout.
//
void
CSPARSIFIER_Agent::lastTimeout(NodeAddress from, CSparsifierTimeoutType timeout)
{
	// TODO
	/*
    switch(type) {
        case CSPARISFIER_STATUS_HELLO : 
            if (_DEBUG_)
                printf("%d LAST TIMEOUT (HELLO) from %d (%f)\n", myAddress, from, Scheduler::instance().clock());
            break;

        case CSPARISFIER_STATUS_FIRST_DECISION : 
            if (_DEBUG_)
                printf("%d LAST TIMEOUT (FIRST_DECISION) from %d (%f)\n", myAddress, from, Scheduler::instance().clock());
            break;

        case CSPARISFIER_STATUS_LAST_DECISION : 
            if (_DEBUG_)
                printf("%d LAST TIMEOUT (LAST DECISION) from %d (%f)\n", myAddress, from, Scheduler::instance().clock());
            break;
    }
	*/
}

//
// Procedura di partenza per l'algoritmo di clustering.
// 
void
CSPARSIFIER_Agent::startModule() 
{
    // Inizializza le informazioni comuni.
    ClusteringModule::startModule();
	    
    // Stato dell'agente
    status = CSPARISFIER_STATUS_CANDIDATE;

	// Svuota la lista dei vicini.
	neighbors.clear();

	// Svuota il buffer dei nodi che sono connessi.
	connect_nodes.clear();

	//
	// Carica la lista dei vicini
	//
	GridKeeper * gk = GridKeeper::instance();
	MobileNode **output = new MobileNode *[gk->size_];
	
	if (gk != NULL) {
		
		int num_neighbors = gk->get_neighbors(myMobileNode, output);
		for (int i = 0; i < num_neighbors; i++) {
			MobileNode * current = output[i];
			
			// Initialize neighbor's info
			NodeAddress neighborAddress = current->address();
			neighbors.insert(neighborAddress);
		}

	}
	
	delete[] output;
	
	if (neighbors.size() == 0)
		printf("CIAO");
	
	// Svuota la lista dei candidati.
	candidateNeighbors.clear();
	
	// Sceglie in maniera random: "NUM_VICINI" vicini oppure tutti (se sono di meno).
	NodeList::iterator node = neighbors.begin();
	for (int i = 0; i < (neighbors.size() < CSPARSIFIER_Agent::virtual_neighbors ? neighbors.size() : CSPARSIFIER_Agent::virtual_neighbors); i++) {
		candidateNeighbors.insert(*node);
		node++;
	}
	
	// Svuota la mappa delle preferenze dei vicini.
	selectedNodes.clear();
	
    // Invia un messaggio di CONNESSIONE ai vicini.
	send_CANDIDATE(-1);
	
    // Inizializza i timeout per i messaggi CANDIDATE.
    timer->launchCandidateTimeouts(neighbors);
}

//
// Procedura richiamata alla fine dell'algoritmo di clustering.
//
void
CSPARSIFIER_Agent::endModule()
{
	// L'algoritmo termina: il nodo puo'memorizzare il proprio clusterHead.
	status = CSPARISFIER_STATUS_END;

	if (utility)
		((CSparsifierUtility*)utility)->setNeighbors(myAddress, sparseNeighbors);

	if (_DEBUG_) {
		printf("END SPARSIFIER: %d ha vicini: ", myAddress);
		for (NodeList::iterator i = sparseNeighbors.begin(); i != sparseNeighbors.end(); i++)
			printf("%d  ", *i);
		printf("\n");
	}

    // Segnala la conclusione del processo di clustering.
    ClusteringModule::endModule();

	// Start upper module
	if (upTarget)
		Separator::instance().endCurrentModule(myAddress);
}

//
// Procedura di ricezione dei messaggi HELLO.
//
void
CSPARSIFIER_Agent::receive_CANDIDATE(NodeAddress from, NodeList & selected)
{

	// Memorizza la lista dei vicini scelta dal vicino.
	selectedNodes[from] = selected;
}

NodeList &
CSPARSIFIER_Agent::getNeighbors()
{
	return sparseNeighbors;
}

void 
CSPARSIFIER_Agent::send_REQUEST(NodeAddress to, CSparsifierMessageType type)
{
    Packet* p = allocpkt();
    
    struct hdr_c_sparsifier * csparsifierh = HDR_CSPARSIFIER(p);
    
    csparsifierh->msg_type = CSPARSIFIER_REQUEST;
    csparsifierh->sender_address = myAddress;
    csparsifierh->destination_address = to;
	
	csparsifierh->request = type;

	if (_DEBUG_)
		printf("%d send REQUEST %s to %d\n", myAddress, (type == CSPARSIFIER_CANDIDATE ? "CANDIDATE" : "CONNECT"), to);

	sendDown(p, sizeof(CSparsifierMessageType) * 2 + sizeof(nsaddr_t) * (2), to, CSPARSIFIER_Agent::max_delay);
}

// Verifica che un pacchetto sia di tipo DATA.
bool 
CSPARSIFIER_Agent::isDataPacket(Packet * p)
{
    struct hdr_c_sparsifier *csparsifierh = HDR_CSPARSIFIER(p);    
	return (csparsifierh->msg_type == CSPARSIFIER_DATA);
}
		
// 
// Preparazione all'invio di un messaggio al layer inferiore
//
void 
CSPARSIFIER_Agent::prepareSendDataDown(Packet * p)
{
    struct hdr_c_sparsifier *csparsifierh = HDR_CSPARSIFIER(p);
    hdr_ip* iph = hdr_ip::access(p);

	// Marca il nodo come dato.
	csparsifierh->msg_type = CSPARSIFIER_DATA;
}

/**
 * Query if algorithm support a particular protocol:
 * that method is probably called before a getData
 * method.
 */
bool 
CSPARSIFIER_Agent::supportProtocol(string protocol)
{
	if (protocol == "sparsification")
		return true;
	return false;
}

/**
 * That method is used to get data from an algorithm
 * that was check to implements a particular protocol
 */
void * 
CSPARSIFIER_Agent::getData(string data)
{
	if (data == "neighbors") {
		return &sparseNeighbors;
	}
	return ClusteringModule::getData(data);
}