//questo č solo una serie di procedure di interfaccia per il file simula.cpp
//quindi non č da considerarsi un modulo!

#ifndef _konsole_cpp
#define _konsole_cpp

//DICHIARAZIONE DELLA KONSOLE
int konsole(char *what);

//DI SEGUITO L'IMPLEMENTAZIONE DI ALCUNI COMANDI
//-----------------------------------------------------------------------------------------------

//ADDEXAM
//AGGIUNGE UN ATTIVITA ALLA CARRIERA
void AddExam()
{
	int q;		//variabile usata per le domande
	char *codetmp;	//buffer per l'inserimento del codice dell'attivitą
	char *tmp;      //codice dell'attivitą (puntatore temporaneo)
	String *code;   //codice dell'attivitą vero e proprio
	int pos;        //numero dell'attivitą in offerta didattica
	char *year;	//buffer per l'inserimento dell'anno
	int anno;	//anno
	int found;	//variabile per la ricerca
	int delete_old;	//decide se cancellare o meno la vecchia attivitą
	Exam *attivita;	//attivitą comprendente l'attivitą e l'anno
	int ex_errors;	//errori pre aggiunta
	int ex_violations;	//violazioni pre aggiunta

	do	//ciclo per continuare ad aggiungere attivitą
	{
	ex_errors=errors;
	ex_violations=violations;
/////////// CONTROLLO PRELIMINARE PER VEDERE SE POSSO EFFETTIVAMENTE AGGIUNGERE ROBA
	if(activity_list.IsHidden())
	{
		LOG.DEV("ATTENZIONE: impossibile aggiungere altre attivita': offerta didattica esaurita");	//non capitera' mai :p
		return;
	}
////////// CHIEDO SE VOGLIO VISIONARE LA LISTA DI OFFERTA
	q=0;
	if((q=question("Vuoi consultare la lista di attivita' con propedeuticitą completata?"))==1)
	{
		VIDEO.Clear();
		noprop_activity_list.Print("NORMAL");
	}
	if(!q)
		return;
		
	
	codetmp = new char[MAXBUFFERLENGTH];
	VIDEO.Endl();
	LOG.DEV("Inserimento nuova attivitą in carriera...",1,1);
	
////////// INIZIO FORM DI CREAZIONE ATTIVITA				
	VIDEO.Out("Inserire CODICE dell'attivitą o NUMERO corrispondente nella lista delle attivitą con propedeuticitą completata:",1);
	VIDEO.Get(codetmp, MAXBUFFERLENGTH);
	VIDEO.IncPos();
	if(!strlen(codetmp))
	{
		LOG.DEV("Inserimento annullato");
		return;
	}
	tmp = new char[strlen(codetmp)+1];
	strcpy(tmp,codetmp);
	delete [] codetmp;	
	
	if(pos=atoi(tmp))
	{
		delete [] tmp; //questo non mi serve + (e' diventato un numerucolo)
		if(pos < 0||pos > noprop_activity_list.GetLen())
		{
			LOG.DEV("ERRORE: il numero eccede i limiti della lista");
		 	return;
		}
		VIDEO.Out(noprop_activity_list.GetData(pos-1).GetChar(), 1);
		if((q=question("Sicuro di voler aggiungere questa attivitą alla carriera?"))==1)
		{
			//ora riutilizzo codetmp per copiare il codice dall'offerta
			codetmp = new char[strlen(noprop_activity_list.GetData(pos-1).GetCode()->GetItem())+1];
			//e fare la stringa per la nuova attivita'
			strcpy(codetmp, noprop_activity_list.GetData(pos-1).GetCode()->GetItem());
			code = new String(codetmp);
		}
		else
		{
		 	if(!q)
		 	{
		 		LOG.DEV("Inserimento annullato");	
		 		return;
		 	}
		 	AddExam();
		 	return;
		}
	}
	else
	{
 		code = new String(tmp);    //ora tmp e' nelle mani di code
 		if(pos=SearchActivity(code))
 		{
			VIDEO.Out(activity_list.GetData(pos-1).GetChar(), 1);
			if((q=question("Sicuro di voler aggiungere questa attivita' alla carriera?"))==2)
			{
				delete code;
				AddExam();
				return;
			}
			if(!q)
			{
				LOG.DEV("Inserimento annullato");
				return;
			}
		}
		else
		{
			LOG.DEV("ERRORE: attivita' non presente in offerta didattica: ",0);
			LOG.DEV(code->GetChar());
			delete code;
			return;
 		}
 	}
 			
 	delete_old=0;	//di solito non cancello :)
	if(found=SearchExam(code,1))    //controllo se l'attivitą non sia gią stata svolta
	{
		if(!exam_list.GetHide(found-1))
		{
			LOG.DEV("ATTENZIONE: attivitą gią presente in carriera: ",0);
			LOG.DEV(code->GetChar());
			LOG.DEV("Inserimento annullato");
			delete code;
			return;
		}
		else
			delete_old=1;  //prima di inserire devo ricordarmi di cancellare found-1
	}
	
 	year = new char [10];	
	
	VIDEO.Out("Inserire ANNO: ");
	VIDEO.Get(year, 9);	
	VIDEO.IncPos();
	if(!strlen(year))
	{
		LOG.DEV("Inserimento annullato");
		return;
	}
	
	
	if((anno=atoi(year))<= 0)
	{
		delete [] year;
		LOG.DEV("ERRORE: richiesto numero maggiore di zero",1,0);
		delete code;
		return;
	}
	delete [] year; //questo adesso e' solo un numero :p
	attivita = new Exam(code, anno);	
///////// FINE FORM DI CREAZIONE ATTIVITA	
	
////////// MODALITA' DI INSERIMENTO
	q=-1;	//mette in modalita' standard (QUEUE or FAST)
	if(!exam_list.IsEmpty())    //chiedo come inserire solo se la lista non e' vuota
	{
		if(!(q=question("Inserire in coda?")))
		{
			LOG.DEV("Inserimento annullato");
			return;
		}
		if(q==2)
		{
			int q2;
			if((q2=question("Esaminare la carriera?"))==1)
			{
				VIDEO.Clear();
				exam_list.Print("ADVANCED");
			}
			else
			if(!q2)
				return;
				
			VIDEO.Out("Posizione: ");
			if(!(q=Ask4Value()))   //q adesso assume il valore di posizione
			{
				LOG.DEV("Inserimento annullato");
				return;
			}
			q--;	
		}
		else
			q=-1;  	//mette in modalita' standard (QUEUE or FAST)
	}

///////////ora controllo se e' valida
 	if(!ValidActivity(*attivita,0))
 	{
        		LOG.DEV("L'attivita' che si sta tentando di inserire presenta degli errori...");
        		if(question("Inserire ugualmente?")==1)
        		{
        			if(delete_old)
        				exam_list.Del(found-1); //cancello solo prima di inserire la nuova attivitą sostitutiva (scorretta)
        			exam_list.InsertElement(*attivita, q); 	
  				LOG.DEV("Inserimento completato", 1,1);
      				Check();
      			}
      			else
      				delete attivita;		
  	}
  	else
  	{
  	        if(delete_old)
        		exam_list.Del(found-1);  //cancello solo prima di inserire la nuova attivitą sostitutiva (corretta)
  		exam_list.InsertElement(*attivita, q); 	
    		LOG.DEV("Inserimento completato", 1,1);
        	Check();			
  	}
  	
  	if (((errors-ex_errors)>0)||((violations-ex_violations)>0))
  	{
  		LOG.DEV("L'inserimento ha provocato:");
  	
  		if((errors-ex_errors)>1)
  		{
  	 		LOG.DEV(errors-ex_errors,0);
  	 		LOG.DEV(" nuovi errori in carriera");
  	 	}
  	 	else
  	 	if(errors-ex_errors)
  	 		LOG.DEV("un nuovo errore in carriera");
  	 	
  	 	if((violations-ex_violations)>1)
  	 	{
  	 		LOG.DEV(violations-ex_violations,0);
  	 		LOG.DEV(" nuove violazioni dei vincoli in ordinamento");
  	 	}
  	 	else
  	 	if(violations-ex_violations)
  	 		LOG.DEV("una nuova violazione dei vincoli in ordinamento");
  	 		
  	 	if(question("Cancellare l'attivita' appena inserita?")==1)
  	 	{
  	 		exam_list.Del(q);
  			Check();
  		}
  	}
  	
  	}
  	while(question("Aggiungere un'altra attivitą?")==1);
}

void RemoveExam()
{
	int q;
	int pos;
	char *tmp;
	char *which;
	String *s;
	Exam *undo_exam;
	int ex_errors=errors;	//errori pre aggiunta
	int ex_violations=violations;	//violazioni pre aggiunta
	
	do
	{
/////////// CONTROLLO PRELIMINARE PER VEDERE SE POSSO EFFETTIVAMENTE RIMUOVERE ATTIVITA'	
	if(!exam_list.GetLen())
	{
		LOG.DEV("ATTENZIONE: impossibile eliminare attivita': carriera vuota");	
		return;
	}
	
////////// CHIEDO SE VOGLIO VISIONARE LA LISTA DI OFFERTA
	q=0;
	if((q=question("Vuoi consultare la lista di attivita' in carriera?"))==1)
	{
		VIDEO.Clear();
		exam_list.Print("ADVANCED");
	}
			
	if(!q)
		return;
		
	tmp= new char[MAXBUFFERLENGTH];
	VIDEO.Endl();
	LOG.DEV("Rimozione attivitą dalla carriera...",1,1);
	VIDEO.Out("Digitare CODICE dell'attivitą o NUMERO corrispondente nella carriera:",1);
	VIDEO.Get(tmp, MAXBUFFERLENGTH);
	VIDEO.IncPos();
	if(!strlen(tmp))
	{
		LOG.DEV("Cancellazione annullata");
		return;
	}
	
	which = new char[strlen(tmp)+1];
	strcpy(which, tmp);
	delete [] tmp;
	
	if(pos=atoi(which))
	{
		delete [] which;
		if(pos < 0||pos >exam_list.GetLen())
		{
			LOG.DEV("ERRORE: il numero eccede i limiti della lista");
			LOG.DEV("Cancellazione annullata");
		 	return;
		}
		LOG.DEV(exam_list.GetData(pos-1).GetChar());
		if((q=question("Sicuro di voler eliminare questa attivitą dalla carriera?"))==1)
		{
		      	//tengo una copia dell'attivita' per poterla inserire alla fine
			s = s->Create(exam_list.GetData(pos-1).GetName()->GetChar());
			undo_exam=new Exam(s, exam_list.GetData(pos-1).GetYear() );
			exam_list.Del(pos-1);
		}
		else
		if(!q) 	//cancel
		{
		 	LOG.DEV("Cancellazione annullata");
		 	return;
		}
		else	//no
		{
			RemoveExam();
			return;
		}		
	}
	else
	{
		s = new String(which);
		if(pos=SearchExam(s))
		{
			delete s;
			LOG.DEV(exam_list.GetData(pos-1).GetChar());
			if((q=question("Sicuro di voler eliminare questa attivitą dalla carriera?"))==1)
			{
				//tengo una copia dell'attivita' per poterla inserire alla fine
		        	s = s->Create(exam_list.GetData(pos-1).GetName()->GetChar());
				undo_exam=new Exam(s, exam_list.GetData(pos-1).GetYear());
				exam_list.Del(pos-1);   //si
			}
			else
			if(!q)	//cancel
			{
			 	LOG.DEV("Cancellazione annullata");
			 	return;
			}
			else  //no
			{
				RemoveExam();
				return;
			}
		}
		else
		{
			delete s;
			LOG.DEV("ATTENZIONE: impossibile trovare l'attivitą indicata", 1,0);
			LOG.DEV("Cancellazione annullata");
			return;
		}
	}
	
	LOG.DEV("Rimozione completata",1,1);
	Check();
	
	if ((errors-ex_errors)>0)
  	{
  		LOG.DEV("La rimozione ha provocato:");
  	
  		if((errors-ex_errors)>1)
  		{
  	 		LOG.DEV(errors - ex_errors,0);
  	 		LOG.DEV(" nuovi errori in carriera");
  	 	}
  	 	else
  	 		LOG.DEV("un nuovo errore in carriera");
  	 		
  	 	if(question("Reinserire l'attivita' appena cancellata?")==1)
  	 	{
  	 		exam_list.InsertElement(*undo_exam,pos-1);
  	 		Check();
  	 	}
  	 	else
  	 	if(undo_exam!=NULL)
  	 		delete undo_exam;
  	}
  	else
  		if(undo_exam!=NULL)
  			delete undo_exam;
	
	}
  	while(question("Rimuovere un'altra attivitą")==1);
  	
}

//BIND
//ASSEGNA AD UNA STRINGA UN COMANDO SPECIFICO
void Bind(char *something)
{
	char *what = NULL;
	char *c;
	int pos = 0;
	c = GetWord(something, pos);
	
	if(pos) //SE SIAMO IN MEZZO AL VETTORE VUOL DIRE CHE C'E' ALTRA ROBA ;P
		what = GetWord(something, pos, -1);
	else
	{
	 	LOG.DEV("ATTENZIONE: non e' stato assegnato un comando alla stringa");
	 	return;
	}
	
	int i = 0;
	int inserted = 0;
	
	//CERCA UN BIND ESISTENTE
	while(i<command_list.GetLen())
	{
		if(!strcmp(c,command_list.GetData(i).GetCommand()))
		{
			command_list.GetData(i).SetValue(what);
			inserted = 1;
		}
	 	i++;
	}
	
	//CREA UN NUOVO BIND
	if(!inserted)
	{
		Command *tmp = new Command(c, what);
		command_list.InsertElement(*tmp);
	}
	
	delete [] c;
	if(what != NULL)
		delete [] what;
}

//EXEC
//ESEGUE UN FILE CIOE' PRENDE OGNI LINEA DEL FILE E LA MANDA COME COMANDO ALLA KONSOLE
void Exec(char *filename)
{
	//controllo per chiamare il log file
  	if(!strcmp(filename, "simula.log"))
	{
	 	LOG.DEV("ATTENZIONE: ",0);
	 	LOG.DEV(filename,0);
	 	LOG.DEV(" e' un file riservato del programma");
	 	return;
	}

	//controllo per evitare chiamate ricorsive
	if(currentfile!=NULL)
		if(!strcmp(filename, currentfile))
		{
	 		LOG.DEV("ATTENZIONE: chiamata ricorsiva a ", 0);
	 		LOG.DEV(currentfile);
	 		return;
		}
	
	Fileman exec_file(filename);
	
	//controllo esistenza
	if(!exec_file.Exists())
	{
	 	LOG.DEV("ATTENZIONE: impossibile trovare il file ", 0);
	 	LOG.DEV(filename);
	}
	
	int start;
	
	//immetto il valore del file corrente per evitare la ricorsione
	if(currentfile!=NULL)
	{
		delete [] currentfile;
		currentfile = NULL;
	}
	currentfile = new char[strlen(filename)+1];
	strcpy(currentfile, filename);
	
	//lettura ed esecuzione
	while(exec_file.ReadLine())
	{
		start=0;
		if(exec_file.buffer[0]!='#')
			konsole(exec_file.buffer);
	}		
	if(currentfile!=NULL)
	{
		delete [] currentfile;
		currentfile = NULL;
	}
}

//INLIST
//CONTROLLO SE UN ELEMENTO SI TROVA GIA IN LISTA
template<class T> int InList(List<T> &where, T &what)
{
	for(int i=0; i < where.GetLen(); i++)
	{
		if(what==where.GetData(i)) return 1;
	}
	return 0;
}

//LOAD
//CARICA IN MEMORIA UN FILE QUALSIASI
//(LA FASE DI SELEZIONE DEL FILE VIENE FATTA DIRETTAMENTE DA KONSOLE)
//SECONDO IL PRINCIPIO PER CUI SE NON E' SPECIFICATO IL NOME CARICA IL FILE STANDARD PER QUELLA LISTA
template<class T> int  Load(char *filename, List<T>& list, int checkdupes=1, char* id="")
{
	if(filename==NULL)
	{
		LOG.DEV("ERRORE INTERNO: nome file non specificato: impossibile caricare");
		return 0;
	}
	
	int newfile=0;
	int the_end=0;
	if(!strcmp(filename, "%?"))
	{
		newfile=1;
		filename = Ask4File();
	}	

	if(!strlen(filename))
	{
		LOG.DEV("Caricamento annullato",1,1);
		return 0;
	}
	
	if(!strcmp(filename, "simula.log"))
	{
		LOG.DEV("ATTENZIONE");
	 	LOG.DEV(filename,0);
	 	LOG.DEV(" e' un file riservato del programma");
	 	return 0;
	}
	
	Fileman file(filename);
	
	if(!file.Exists())
	{

	 	LOG.DEV("ATTENZIONE: impossibile trovare il file: ", 0);
	 	LOG.DEV(filename);
	 	return 0;
	}
	
	if(strlen(id))
	if(!file.WaitFor(id))
	{
		LOG.DEV("ATTENZIONE: impossibile trovare",0);
		LOG.DEV(id,0);
		LOG.DEV(" in ", 0);
	   	LOG.DEV(filename);
	   	return 0;	
	}
	
	if(!file.WaitFor("INIZIO"))
	{
	   	LOG.DEV("ATTENZIONE: impossibile trovare INIZIO in ", 0);
	   	LOG.DEV(filename);
	   	return 0;
	}
	
	if(list.GetLen()) 	//se la lista e' gia' stata caricata si vuole cancellare o cosa
	{
		int q;
	 	LOG.DEV("ATTENZIONE: questa lista č gią stata caricata",1,0);
	 	if((q=question("Rimuovere la lista gią caricata?"))==1)
	 		list.DelList();
	 	else
	 	if(q==0)
	 		return 0;
	}
	
	T *obj;
	
	while(file.ReadLine())
	{
		if(!strcmp(file.buffer, "FINE"))
		{
			the_end=1;
			break;
		}
		obj = obj->Create(file.buffer, file.GetCurrent(), file.GetPath());
		VIDEO.Out(".",0);
		if(obj!=NULL)
		{
			//controllo se e' gią in lista (altrimenti inserisco e basta)
			if(!InList(list, *obj)||!checkdupes)	
				list.InsertElement(*obj);
			else
			{
				LOG.DEV(list.name,0,2);
				LOG.DEV(": ATTENZIONE: elemento gia' in lista: ",0,2);
				LOG.DEV(*obj->GetChar(),1,2);
			}
		}
	}
	
	VIDEO.Endl();
	
	if(!the_end)
	{
		LOG.DEV("ATTENZIONE: impossibile trovare FINE in ",0);
		LOG.DEV(filename);
		if(question("Proseguire ugualmente?")==2)
		{
			list.DelList();
			return 0;
		}
		
	}
	
	if(!list.GetLen())
	{
		LOG.DEV("ATTENZIONE: nessun elemento valido trovato in questo file");
		return 0;
	}	
	
	LOG.DEV("Caricamento completato",1,1);
	
	list.modified=0;
	if(newfile)
		delete filename;
	return 1;
}

//SAVE
//SALVA LA CARRIERA
//potrebbe salvare qualsiasi tipo di file se GetChar dell'oggetto fosse formalmente corretto
//template <class T> void Save (char* filename, List<T>& list)
//{...
//file.Write(list.GetData(i)->GetChar());
//...}
void Save(char *filename, List<Exam>& list)
{
	if(filename==NULL)
	{
		LOG.DEV("ERRORE INTERNO: nome file non specificato: impossibile salvare");
		return;
	}
	
	int newfile=0;
	if(errors||violations)
		if(question("CARRIERA NON CORRETTA: salvare ugualmente?")!=1)
			return;
	
	if(!strcmp(filename, "%?"))
	{
		filename = Ask4File();
	}

	if(!strlen(filename))
	{
		LOG.DEV("Salvataggio annullato",1,1);
		return;
	}
	
 	if(!strcmp(filename, "simula.log"))
	{
		LOG.DEV("ATTENZIONE: ", 0);
	 	LOG.DEV(filename,0);
	 	LOG.DEV(" e' un file riservato del programma");
	 	return;
	}

 	Fileman file(filename);
 	
 	if(file.Exists()&&strcmp(filename, exam_file))
 	{
		VIDEO.Out(filename);
 		int ok=question(": file esistente: sovrascrivere?");
		if(!ok) return;	//cancel
		if(ok==2)       //no
		{
			char *ftmp = Ask4File();
			Save(ftmp, list);
			delete [] ftmp;
		        return;
		}		
 	}	
 	
 	if(!file.Write("INIZIO", 1, 1))
 	{
 		LOG.DEV("ATTENZIONE: impossibile scrivere sul file selezionato: ",0);
 		LOG.DEV(filename);
 		return;
 	}
 	
 	Exam *obj;
 	
 	for(int i=0; i < list.GetLen(); i++)
 	{
 		obj = &list.GetData(i);            	//questa e' la sintassi di un file carriera
 		file.Write(obj->GetName()->GetItem(), 0);
 		file.Write(" , ",0);
 		file.Write(obj->GetYear(), 0);
 		file.Write(" ;");
 		VIDEO.Out(".",0);
 	}	
 		
 	VIDEO.Endl();
 			
 	file.Write("FINE", 0);
 	LOG.DEV(file.GetPath(),0, 1);
 	LOG.DEV(" salvato",1,1);
 	
 	delete [] exam_file;        //vogliamo mantenere il nome di salvataggio come nome standard
	exam_file = new char[strlen(file.GetPath())+1];
	strcpy(exam_file, file.GetPath());
 	
 	list.modified=0;
 	if(newfile)
		delete filename;
}


// 8<-----------------------------------------------------------------
//SAVE
//SALVA SU FILE UNA LISTA DI STRINGHE (test only)
void Save(char *filename, List<String>& list)
{
 	if(!strcmp(filename, "simula.log"))
	{
	 	LOG.DEV("ATTENZIONE: ", 0);
	 	LOG.DEV(filename,0);
	 	LOG.DEV(" e' un file riservato del programma");
	 	return;
	}
	
 	Fileman file(filename);
 	
 	if(file.Exists())
 	{
		VIDEO.Out(filename);
 		int ok=question(": file esistente: sovrascrivere?");
		if(!ok) return;	//cancel
		if(ok==2)
		{
			char *ftmp = Ask4File();
			Save(ftmp, list);
			delete [] ftmp;
		        return;
		}		
 	}
 	
 	if(!file.Write("INIZIO", 1, 1))
 	{
 		LOG.DEV("ATTENZIONE: impossibile scrivere sul file selezionato: ",0);
 		LOG.DEV(filename);
 		return;
 	}
 	
 	String *obj;

 	for(int i=0; i < list.GetLen(); i++)
 	{
 		obj = &list.GetData(i);
 		file.Write(obj->GetItem());
 		VIDEO.Out(".",0);
 	}	
 		
 	VIDEO.Endl();
 			
 	file.Write("FINE", 0);
 	LOG.DEV(file.GetPath(),0,1);
 	LOG.DEV(" salvato",1,1);
	return;
}
//----------------------------------------------------------------------------->8


//CMDLIST
//STAMPA LA LISTA DEI COMANDI ESEGUIBILI DA KONSOLE
void CmdList()
{
	VIDEO.Out("addexam",1);
	VIDEO.Out("bind <string> <value>",1);
	VIDEO.Out("cmdlist",1);
	VIDEO.Out("check",1);
	VIDEO.Out("checkcarrier",1);
	VIDEO.Out("checkoffer",1);
	VIDEO.Out("checkorder",1);
	VIDEO.Out("clearcarrier",1);
	VIDEO.Out("delactivitylist",1);
	VIDEO.Out("delexam <value>",1);
	VIDEO.Out("delexamlist",1);
	VIDEO.Out("delmenu",1);
	VIDEO.Out("delrulelist",1);
	VIDEO.Out("delstring <value>",1);
	VIDEO.Out("delstringlist",1);
	VIDEO.Out("echo <string>",1);
	VIDEO.Out("exec <file>",1);
	VIDEO.Out("exit",1);
	VIDEO.Out("loadactivitylist [<file>]",1);
	VIDEO.Out("loadexamlist [<file>]",1);
	VIDEO.Out("loadmenu <file>",1);	
	VIDEO.Out("loadrulelist [<file>]",1);
	VIDEO.Out("loadstringlist <file>",1);
	VIDEO.Out("pause",1);
	VIDEO.Out("printactivitylist [<print_option>]",1);
	VIDEO.Out("printbindlist [<print_option>]",1);
	VIDEO.Out("printexamlist [<print_option>]",1);
	VIDEO.Out("printnoproplist [<print_option>]",1);
	VIDEO.Out("printrulelist [<print_option>]",1);
	VIDEO.Out("printstringlist [<print_option>]",1);
	VIDEO.Out("removeexam",1);
	VIDEO.Out("saveexamlist [<file>]",1);
	VIDEO.Out("savestringlist <file>",1);
	VIDEO.Out("setlevel <value>",1);
	VIDEO.Out("setlog <value>",1);
	VIDEO.Out("setpausize <value>",1);
	VIDEO.Out("showchr",1);
	VIDEO.Out("stop",1);
	VIDEO.Out("sysinfo",1);
}

void SysInfo()
{
	VIDEO.Out("Develop level: ");
	VIDEO.Out(LOG.level,1);
	VIDEO.Out("Develop logon: ");
	VIDEO.Out(LOG.logon);
	if(LOG.locked)
		VIDEO.Out(" [locked]",1);
	else
		VIDEO.Endl();
	VIDEO.Out("Develop file: ");
	VIDEO.Out(LOG.GetFile(),1);
	VIDEO.Out("Display pausize: ");
	VIDEO.Out(VIDEO.pausize,1);
	VIDEO.Out("Display maxy: ");
	VIDEO.Out(getmaxy(stdscr),1);
	VIDEO.Out("Display maxx: ");
	VIDEO.Out(getmaxx(stdscr), 1);
	VIDEO.Out("rule_file: ");
	VIDEO.Out(rule_file,1);
	VIDEO.Out("activity_file: ");
	VIDEO.Out(activity_file,1);
	VIDEO.Out("exam_file: ");
	VIDEO.Out(exam_file,1);	
	VIDEO.Out("currentfile: ");
	VIDEO.Out(currentfile,1);
	VIDEO.Out("# rule_list: ");
	VIDEO.Out(rule_list.GetLen(),1);
	VIDEO.Out("# activity_list: ");
	VIDEO.Out(activity_list.GetLen(),1);
	VIDEO.Out("# exam_list: ");
	VIDEO.Out(exam_list.GetLen(),1);
	VIDEO.Out("# noprop_activity_list: ");
	VIDEO.Out(noprop_activity_list.GetLen(),1);
	VIDEO.Out("# menu_list: ");
	VIDEO.Out(menu_list.GetLen(),1);
	VIDEO.Out("# command_list: ");
	VIDEO.Out(command_list.GetLen(),1);
	VIDEO.Out("# string_list: ");
	VIDEO.Out(string_list.GetLen(),1);
	VIDEO.Out("# errors: ");
	VIDEO.Out(errors,1);
	VIDEO.Out("# violations: ");
	VIDEO.Out(violations,1);	
}

//--------------------------------------------------------------------------FINE IMPLEMENTAZIONE COMANDI

//INTERPRETE DEI COMANDI INSERITI-----------------------------------------------------------------------
int konsole(char *entry)
{
		if(!strlen(entry))
			return 2;

		char *cmd = NULL;
		char *value = NULL;

		int pos = 0;
		cmd = GetWord(entry, pos);

		//SE pos == -1 SIGNIFICA CHE NON C'E' value
		if(pos>-1) 
			value = GetWord(entry, pos, -1);
				
   		if(!strcasecmp(cmd, "addexam"))
		{
			AddExam();
		}
		else	
		if(!strcmp(cmd, "bind"))
		{
			Bind(value);
		}
		else
		if(!strcmp(cmd, "cmdlist"))
		{
			CmdList();
		}
		else
		if(!strcmp(cmd, "check"))
		{
			Check();
		}
		else
		if(!strcmp(cmd, "checkcarrier"))
		{
			CheckCarrier();
		}
		else
		if(!strcmp(cmd, "checkoffer"))
		{
			CheckOffer();
		}
		else
		if(!strcmp(cmd, "checkorder"))
		{
			CheckOrder();
		}
		else
		if(!strcmp(cmd, "clearcarrier"))
		{
			ClearCarrier();
		}
		else
		if(!strcmp(cmd, "delactivitylist"))
		{
			LOG.DEV("Cancellazione lista attivitą in offerta",1,1);
			if(question("Sicuro di voler cancellare tutti gli elementi dell'offerta?")==1)
				activity_list.DelList();
			CheckCarrier();
		}
		else
		if(!strcmp(cmd, "delexam"))
		{
			LOG.DEV("Cancellazione attivitą dalla carriera",1,1);
			if(value==NULL)
			{
			 	VIDEO.Out("Valore mancante",1);
			 	delete [] cmd;
			 	return 1;
			}
			exam_list.Del(atoi(value)-1);
			CheckCarrier();
			CheckOrder();
		}
		else
		if(!strcmp(cmd, "delexamlist"))
		{
			LOG.DEV("Cancellazione lista attivitą in carriera",1,1);
			if(question("Sicuro di voler cancellare tutti gli elementi della carriera?")==1)
				exam_list.DelList();
			CheckCarrier();
			CheckOrder();
		}
		else
		if(!strcmp(cmd, "delmenu"))
		{
			LOG.DEV("Cancellazione menu",1,1);
			if(question("Sicuro di voler cancellare il menu?")==1)
				menu_list.DelList();
		}
		else
		if(!strcmp(cmd, "delrulelist"))
		{
			LOG.DEV("Cancellazione lista regole in ordinamento",1,1);
			if(question("Sicuro di voler cancellare tutti gli elementi dell'ordinamento?")==1)
				rule_list.DelList();
		}
		else
		if(!strcmp(cmd, "delstring"))
		{
			LOG.DEV("Cancellazione stringa",1,1);
			if(value==NULL)
			{
			 	VIDEO.Out("Valore mancante",1);
			 	delete [] cmd;
			 	return 1;
			}
			string_list.Del(atoi(value)-1);
		}
		else
		if(!strcmp(cmd, "delstringlist"))
		{
			LOG.DEV("Cancellazione lista stringhe",1,1);
			string_list.DelList();
		}
		else
		if(!strcmp(cmd, "echo"))
		{
			if(value!=NULL)
				VIDEO.Out(value,1);
			else
				VIDEO.Endl();
		}
		else
		if(!strcmp(cmd, "exec"))
		{
			LOG.DEV("Esecuzione file <script>",1,1);
			if(value==NULL)
			{
				VIDEO.Out("Valore mancante",1);
			 	delete []cmd;
				return 1;
			}
			if(!strcmp(value, "%?"))
			{
				delete [] value;
				value = Ask4File();
			}
			Exec(value);
		}
		else
		if(!strcmp(cmd, "exit"))
		{
			delete [] cmd;
			if(value!=NULL) delete [] value;
			return 0;
		}
		else
		if(!strcmp(cmd, "loadactivitylist"))
		{
			LOG.DEV("Caricamento <offerta>",1,1);
			int r;
			if(value==NULL)
			{
				if(activity_file==NULL)
				{
					LOG.DEV("ATTENZIONE: nessun file offerta specificato");
					return 1;
				}
				r=Load(activity_file, activity_list, 1, "OFFERTA_DIDATTICA");
			}
			else
			{
				if(!strcmp(value, "%?"))
				{
					delete [] value;
					value = Ask4File();
				}
				r=Load(value, activity_list);
				if(r)
				{      //cambia il nome del file solo se il caricamento ha avuto successo
					delete [] activity_file;
					activity_file = new char[strlen(value)+1];
					strcpy(activity_file, value);	
				}
			}
			if(r)
				Check();
		}
		else
		if(!strcmp(cmd, "loadexamlist"))
		{
			LOG.DEV("Caricamento <carriera>",1,1);
			int r;
			if(value==NULL)
			{
				if(exam_file==NULL)
				{
					LOG.DEV("ATTENZIONE: nessun file carriera specificato");
					return 1;
				}
				r=Load(exam_file, exam_list);
			}
			else
			{
				if(!strcmp(value, "%?"))   //nel caso di Exam devo memorizzare il nome del file in exam_file
				{
					delete [] value;
					value = Ask4File();
				}
				r=Load(value, exam_list);
				if(r)
				{      //cambia il nome del file carriera solo se il caricamento ha avuto successo
					delete [] exam_file;
					exam_file = new char[strlen(value)+1];
					strcpy(exam_file, value);	
				}	
				
			}
			
			if(r)  //se il caricamento ha avuto successo fa il controllo
				Check();
		}
		else
  	 	if(!strcmp(cmd, "loadmenu"))
		{
			LOG.DEV("Caricamento <menu>",1,1);
			if(value==NULL)
			{
				VIDEO.Out("Nome del file mancante",1);
				delete [] cmd;
			 	return 1;
			}
			Load(value, menu_list, 0);
		}
		else
		if(!strcmp(cmd, "loadrulelist"))
		{
			LOG.DEV("Caricamento <ordinamento>",1,1);
			int r;
			if(value==NULL)
			{
				if(rule_file==NULL)
				{
					LOG.DEV("ATTENZIONE: nessun file ordinamento specificato");
					return 1;
				}
				r=Load(rule_file, rule_list,1,"ORDINAMENTO");
			}
			else
			{
				if(!strcmp(value, "%?"))
				{
					delete [] value;
					value = Ask4File();
				}
				r=Load(value, rule_list);
				if(r)
				{      //cambia il nome del file solo se il caricamento ha avuto successo
					delete [] rule_file;
					rule_file = new char[strlen(value)+1];
					strcpy(rule_file, value);	
				}
			}
			if(r)
				Check();
		}
		else
  	 	if(!strcmp(cmd, "loadstringlist"))
		{
			LOG.DEV("Caricamento file <stringa>",1,1);
			if(value==NULL)
			{
				VIDEO.Out("Nome del file mancante",1);
				delete [] cmd;
			 	return 1;
			}
			Load(value, string_list);
		}
		else
  	 	if(!strcmp(cmd, "pause"))
		{
				VIDEO.Pause();
		}
		else
		if(!strcmp(cmd, "printactivitylist"))
		{
			LOG.DEV("Stampa lista attivita' (offerta didattica)",1,1);
			if(value==NULL)
				activity_list.Print();
			else
				activity_list.Print(value);
		}
		else
		if(!strcmp(cmd, "printbindlist"))
		{
			LOG.DEV("Stampa lista comandi",1,1);
			if(value==NULL)
				command_list.Print();
			else
				command_list.Print(value);
		}
		else
		if(!strcmp(cmd, "printexamlist"))
		{
			LOG.DEV("Stampa lista attivita' (carriera)", 1,1);	
			if(value==NULL)
				exam_list.Print();
			else
				exam_list.Print(value);
		}
		else
		if(!strcmp(cmd, "printnoproplist"))
		{
			LOG.DEV("Stampa lista attivita' con propedeuticitą completata", 1,1);
			if(value==NULL)
				noprop_activity_list.Print();
			else
				noprop_activity_list.Print(value);
		}
		else
		if(!strcmp(cmd, "printrulelist"))
		{
			LOG.DEV("Stampa lista regole (ordinamento didattico)",1,1);
			if(value==NULL)
				rule_list.Print();
			else
				rule_list.Print(value);
		}
		else
		if(!strcmp(cmd, "printstringlist"))
		{
			LOG.DEV("Stampa lista stringhe",1,1);
			if(value==NULL)
				string_list.Print();
			else
				string_list.Print(value);
		}
		else
		if(!strcmp(cmd, "removeexam"))
		{
			RemoveExam();
		}
		else
		if(!strcmp(cmd, "saveexamlist"))
		{
			LOG.DEV("Salvataggio carriera...",1,1);
			if(value==NULL)
			{
				if(exam_file==NULL)
				{
					delete [] exam_file;
					exam_file = Ask4File();
				}
				Save(exam_file, exam_list);
			}
			else
			{
	 			Save(value, exam_list);
			}
		}
		else
		if(!strcmp(cmd, "savestringlist"))
		{
			LOG.DEV("Salvataggio lista <string>...", 1,1);
			if(value==NULL)
			{
				VIDEO.Out("Nome del file mancante",1);
				delete [] cmd;
	 			return 1;
			}
	 		Save(value, string_list);
		}
		else
		if(!strcmp(cmd, "setlevel"))
		{	
			LOG.DEV("Settaggio livello di output",1,1);
			if(value==NULL)
			{
				VIDEO.Out("Valore mancante",1);
				delete [] cmd;
			 	return 1;
			}
			if(!strcmp(value,"%?"))
				LOG.SetLevel(Ask4Value());
			else
				LOG.SetLevel(atoi(value));
		}
		else
		if(!strcmp(cmd, "setlog"))
		{	
			LOG.DEV("Settaggio modalitą di output",1,1);
			if(value==NULL)
			{
				VIDEO.Out("Valore mancante",1);
				delete [] cmd;
			 	return 1;
			}
			if(!strcmp(value,"%?"))
				LOG.SetLog(Ask4Value());
			else
				LOG.SetLog(atoi(value));
		}
		else
		if(!strcmp(cmd, "setpausize"))
		{
			LOG.DEV("Settaggio valore di pausa",1,1);
			if(value==NULL)
			{
				VIDEO.Out("Valore mancante",1);
				delete [] cmd;
			 	return 1;
			}
			VIDEO.SetPausize(atoi(value));
		}
		else
		if(!strcmp(cmd, "showchr"))
		{	
			VIDEO.Showchr();
		}
		else
		if(!strcmp(cmd, "stop"))
		{	
			LOG.DEV("",-1);
		}
		else
		if(!strcmp(cmd, "sysinfo"))
		{	
			SysInfo();	
		}
		else

		if(!strcmp(cmd, "konsole"))
		{
			delete [] cmd;
			if(value!=NULL) delete [] value;
		    	return 2;
		}
		else
		{
			VIDEO.Out("Comando di konsole sconosciuto: ");
			VIDEO.Out(entry,1);
		}
				
		delete [] cmd;
		if(value!=NULL) delete [] value;
		return 1;
}
//----------------------------------------------------------------------FINE INTERPRETE

void AdvancedKonsole()
{
	char entry[100];
	VIDEO.Endl();
	VIDEO.Out("KONSOLE ATTIVATA (cmdlist per la lista dei comandi)",1);
 	do
 	{
 	 	if(strlen(entry))
 	 		VIDEO.Out("> ");
 	 	VIDEO.Get(entry, 100);
 	 	konsole(entry);
 	 	if(currentfile!=NULL)
 		{
 		  	delete [] currentfile;
 		  	currentfile = NULL;
 		}
 	}while(strcmp(entry, "exit"));
 	
}

void InterfaceKonsole()
{
	char ch[100];
	char *what;
	int pos;
	int go_on;
	Command *elem;
	int i;
	
	do
	{
		if(menu_list.IsEmpty())
		{
			LOG.DEV("ATTENZIONE: menu non caricato");
			AdvancedKonsole();
	        }
	        else
	        {
			if(VIDEO.GetPosition()>0)
				VIDEO.Pause();
			//cerca di impedire che vengano fatte interruzioni prima della fine della lista
			
			menu_list.Print("SIMPLE");
	
			//ASPETTA UNA STRINGA E POI CERCA IN LISTA SE LO TROVA E LO ESEGUE
			VIDEO.Out("   [> ");
			VIDEO.Get(ch, 100);
			
		        VIDEO.Clear();
			
		        if(strlen(ch))
		        {
			for(i=0; i<command_list.GetLen(); i++)
			{
		 		elem = &command_list.GetData(i);
		 		what = elem->GetCommand();
		 		if(!strcmp(what,ch))
		 		break;
			}
			if(i < command_list.GetLen())
			{
				go_on = konsole(elem->GetValue());
				if(go_on==2)
					AdvancedKonsole();
			}
			else
			{
				LOG.DEV("ATTENZIONE: comando non assegnato: ", 0, 1);
		 		LOG.DEV(ch,1,1);
			}
			}//strlen(ch)
		}
	}while(go_on);	
	VIDEO.Clear();
}

#endif