#include <fstream.h>                     
#include <applicat.h>
#include <config.h>
#include <currency.h>
#include <date.h>
#include <execp.h>
#include <recarray.h>
#include <tabutil.h>
#include <utility.h>

#include <clifo.h>
#include <cfven.h>
#include <mov.h>

#include "..\ve\velib.h"
#include "..\cg\cg2103.h"

class TIni2Sql: public TSkeleton_application
{
	TRelation* _clifo;
	TConfig* _configfile;
	TConfig* _inputfile;
	ofstream* _sqlfile;
	TLocalisamfile* _anamag;
	TLocalisamfile* _fcaus;
	TLocalisamfile* _frcaus;
  TCausale * _caus;
	long _firm;
	TDocumento* _doc;
	TDocumento* _dadoc;
	TRiga_documento* _rigadoc;
	TFilename _inputfilename;
	TBill _conto;
	TToken_string* _search_seq;   
                            // Sequenza di ricerca del conto costo/ricavo la correttezza dell'ordinamento
                            // va controllata nel programma di modifica parametri:
                            // "" = fine ordinamento
                            // CF = cliente fornitore
                            // CA = causale
                            // AR = articolo (costo/ricavo)
                            // GM = gruppo merceologico
                            // SM = sottogruppo merceologico
                            // RF = raggruppamento fiscale
                            // CV = categoria di vendita
                            // CC = categoria contabile
                            // Gli utlimi 6 fanno parte della ricerca per costi ricavi, in particolare AR,GM,SM e RF
                            // non possono essere interrotti da CV o CC. Ad es. CA|CF|AR|CV|GM|CC|RF non e' valida come stringa
                            // di ricerca.
	
	  
protected:
  virtual bool create(void);
  virtual void main_loop();
  virtual bool destroy(void);
  virtual const char * extra_modules() const { return "BA"; }
	void process_field(const TString& inputfield, TString& outputstr, int len = -1, const bool apici = TRUE);
	void validate(const TString& elabfield, TString& outputstr);
	void leggidadoc(const TString& elabfield, TString& outputstr);
	void build_paragraph(const TString& paragrafo, TString& outputstr);
	int  build_nriga(const TString& paragrafo);
  int get_tipo_dadoc(const TDocumento& doc) const;
  bool get_fdaric_dadoc(const TDocumento& doc) const;
  long get_protiva(const TDocumento& doc) const;
	bool search_costo_ricavo(TBill& conto, const TRiga_documento& r);
  bool test_swap() const;
	bool test_swap_conto(const int gr, const int co, const char sezione) const;

public:
	void write_sqlinsert();
	void write_sqldelete();
  TIni2Sql() {}
  virtual ~TIni2Sql() {}
};

// restituisce un riferimento all' applicazione
inline TIni2Sql& app() { return (TIni2Sql&) main_app();}

// creazione dell'applicazione        
bool TIni2Sql::create()
{               
  if (argc() > 1)  
  {                        
		_inputfilename = argv()[1];
		if (_inputfilename[0] == '/' || _inputfilename[0] == '-')
			_inputfilename.ltrim(2);
  	if (_inputfilename.exist())
  	{
	  	open_files(LF_MOV, LF_RMOV, LF_RMOVIVA, LF_DOC, LF_RIGHEDOC, LF_CLIFO, LF_PCON, LF_ABPCON, LF_CFVEN, LF_TABCOM, LF_TAB, 0);
			_inputfile = new TConfig(_inputfilename);
			_configfile = new TConfig("crpa.ini");
			_sqlfile = NULL;
			_doc = NULL;
			_dadoc = NULL;
			_rigadoc = NULL;
		  _clifo = new TRelation(LF_CLIFO);
  		_clifo->add(LF_CFVEN,"TIPOCF=TIPOCF|CODCF=CODCF");
		  _anamag = new TLocalisamfile(LF_ANAMAG);
		  _fcaus    = new TLocalisamfile(LF_CAUSALI);
		  _frcaus   = new TLocalisamfile(LF_RCAUSALI);// Per far andare TCausale
	  	return TSkeleton_application::create();
	  }
	  else
	  	error_box("Il file %s non esiste", (const char*) _inputfilename);  
  }
  else
  	error_box("Usage: CRPA0 -i<filename>");  
 	return FALSE;
}

bool TIni2Sql::test_swap_conto(const int gr, const int co, const char sezione) const
{
	TToken_string key;
	key.format("%d|%d", gr, co);
  const int indbil = atoi(cache().get(LF_PCON, key, "INDBIL"));
  return ((indbil == 3) && (sezione == 'A')) || ((indbil == 4) && (sezione == 'D'));
}

bool TIni2Sql::test_swap() const 
{
  bool s = FALSE;
  if (*_caus->codice() > ' ')	// esiste la causale
  {   
	  const char sez = _caus->sezione_clifo(); 
		const TipoIVA iva = _caus->iva();	  
	  const bool vendite = iva == nessuna_iva ? _doc->tipocf() == 'C' : iva == iva_vendite;
		s =  vendite ^ (sez == 'D');	  
  }
  return s;
}

// legge da documento o da riga il campo indicato (primo carattere = #)
// se occorre usare una funzione dei doc. o delle righe si fa seguire al carattere # la stringa
// ?? !_,<nome elaborazione>
void TIni2Sql::leggidadoc(const TString& elabfield, TString& tmpstr)
{   
	tmpstr="";
	TToken_string s(elabfield, ',') ;
  const TString code(s.get(0));
  const TString field(s.get(1));
  if (code == "!_")
  {
  	if (field == "IMPORTO")
  	{
  		if (_rigadoc != NULL)
  		{                  
  			real importo;
  			if (_doc->tipocf() == 'F')
  			{                     
	  			TString80 codcms = _rigadoc->codice_commessa();
	  			bool lordo = cache().get("CMS", codcms, "S7") == "NR";
	  			const TTipo_riga_documento tiporig = _rigadoc->tipo();
	  			real perc_ind = tiporig.perc_indetraibilita();
	  			if (lordo)
	  				perc_ind = 100.0;
	  			if (perc_ind != ZERO)
	  			{
	  				importo = _rigadoc->importo(TRUE, FALSE);
	  				real imposta = _rigadoc->imposta();
	  				importo = importo + (imposta*perc_ind)/100.0;
	  			}
	  			else	
	  				importo = _rigadoc->importo(TRUE, lordo); 
	  		}
	  		else
  				importo = _rigadoc->importo(TRUE, FALSE); 
    		if (test_swap())
    			importo = importo * (-1);
  			tmpstr = importo.string();	
  		}	
  	}	
  	else if (field == "QTA")
  	{
  		if (_rigadoc != NULL)
  		{
  			real qta;
			  if (_doc->is_evaso())
			  	qta = _rigadoc->qtaevasa();
			  else
			  	qta = _rigadoc->quantita();
			  tmpstr = qta.string();	
  		}
  	}	
  	else if (field == "COMMESSA")
  	{
  		if (_rigadoc != NULL)
  		{
	  		tmpstr = _rigadoc->codice_commessa();
				tmpstr.upper();
				tmpstr.replace('/','_');		
			}	
  	}	
  	else if (field == "FASE")
  	{
  		if (_rigadoc != NULL)
  		{
	  		tmpstr = _rigadoc->fase_commessa();
				tmpstr.upper();
				tmpstr.replace('/','_');		
			}	
  	}	
	  else if (field == "DATACONS")
	  { 
  		if (_rigadoc != NULL)
  		{
		  	TString str = _rigadoc->get(field);
				TDate datactrl(str);
				if (!datactrl.ok())
				{
		  		str = _doc->get(field);
					datactrl = TDate(str);
				}	
				if (datactrl.ok())
			  	tmpstr.format("TO_DATE('%s','dd-mm-yyyy')", (const char*) str);	
			}	  	
		}	
  }	
  else if (code == "DRDOC")
  {    
		if (_rigadoc != NULL)
		{
			TString str = _rigadoc->get(field);
			TDate datactrl(str);
			if (datactrl.ok())
		  	tmpstr.format("TO_DATE('%s','dd-mm-yyyy')", (const char*) str);	
		}  	
	}	
  else if (code == "DOC")
  {
  	if (_doc != NULL)
			tmpstr = _doc->get(field);  	
	}	
	else if (code == "RDOC")        
	{
		if (_rigadoc != NULL)
			tmpstr = _rigadoc->get(field);
	}	
}		

bool TIni2Sql::search_costo_ricavo(TBill& conto, const TRiga_documento& r)
{
  TConfig  conf(CONFIG_DITTA, "ve");
  _search_seq = new TToken_string((const char*)conf.get("RICERCACR","ve"));
  // costruisce la stringa che controlla la ricerca del conto costo/ricavo
  // Attenzione! non esegue alcun controllo di consistenza sulla corretta sequenza
  // presuppone che il programma di configurazione abbia generato correttamente
  // il tutto.
  if (_search_seq->items() == 0)
  {
    error_box("Non e' abilitata alcuna ricerca per il conto di costo/ricavo in configurazione.");
    return FALSE;
  }
  const int items = _search_seq->items();
  TLocalisamfile& cli_file = _clifo->lfile(); // YES, arriva qui dentro quando la relazione e' gia' posizionata
  const bool is_cli = cli_file.get(CLI_TIPOCF) == "C";
  bool skip_art_related = FALSE;
  bool skip_clifo = _clifo->bad();
  TCodiceIVA codiva(r.get(RDOC_CODIVA));
  const char t = r.tipo().tipo();

  // Istanzia la causale del documento corrente...
  const TTipo_documento& tipo = _doc->tipo();
  TString16 codcaus(tipo.causale());
  
  TToken_string  key;
  key.add(_doc->get(DOC_TIPOCF));
  key.add(_doc->get(DOC_CODCF));          
    
  const TRectype & cfven = cache().get(LF_CFVEN, key);              
  const TString16 caus_cli(cfven.get(CFV_CODCAUS)); 
  
  if (caus_cli.not_empty())
    codcaus = caus_cli;
  TDate data = _doc->data(); 
  _caus = new TCausale(codcaus, data.year());

  int gr,co;
  long so;
  
  switch (t)
  {
    case 'O': // righe omaggio come articoli spiaccicato identico (avranno imponibile 0)
    case 'M': // righe di merce
    {
      // posiziona l'anagrafica sull'articolo specificato sulla ..iga
      TString80 codart = r.get(RDOC_CODARTMAG);
      if (codart.blank())
      	codart = r.get(RDOC_CODART);
      _anamag->put(ANAMAG_CODART, codart);
      if (_anamag->read() != NOERR) // se non trova l'articolo saltera' anche gmc,smc,rfa.
        skip_art_related = TRUE;
      
      TString16 tok;
      // Scorre la stringa di ricerca
      for (int i=0;i<items;i++)
      { 
        tok = _search_seq->get(i);
        if (tok == "CF")
        {
          if (skip_clifo) continue;
          gr = cli_file.get_int(CLI_GRUPPORIC);
          co = cli_file.get_int(CLI_CONTORIC);
          so = cli_file.get_long(CLI_SOTTOCRIC);
          conto.set(gr,co,so);
          if (conto.ok()) break; // se lo trova esce (tutti != 0)
        }
        else
        if (tok == "CA")
        {                        
        	
          CHECK(_caus,"Causale documento non valida");
          if (_caus->IVA2bill(codiva,conto)) break; // se lo trova esce
        }
        else
        if (tok == "AR")
        {
          if (skip_art_related) continue;
          gr = _anamag->get_int(is_cli ? ANAMAG_GRUPPOV : ANAMAG_GRUPPOA);
          co = _anamag->get_int(is_cli ? ANAMAG_CONTOV : ANAMAG_CONTOA);
          so = _anamag->get_long(is_cli ? ANAMAG_SOTTOCV : ANAMAG_SOTTOCA);
          conto.set(gr,co,so);
          if (!conto.ok()) // se il conto non c'e' guarda la categoria acquisti/vendite
          {                          
            TTable *t = is_cli ? new TTable("CRA") : new TTable("CAA");
            
            t->put("CODTAB",_anamag->get(is_cli ? ANAMAG_CATCONV : ANAMAG_CATCONA));
            if (t->read() == NOERR)
            {
              gr = atoi(t->get("S1"));
              co = atoi(t->get("S2"));
              so = atol(t->get("S3"));
              conto.set(gr,co,so);
            }
          }
          if (conto.ok()) break;
        }
        else
        if (tok == "GM" || tok == "SM" || tok == "RF")
        {
          if (skip_art_related) continue;
          const bool is_fis = tok == "RF";
          TTable * tab = is_fis ? new TTable("RFA") : new TTable("GMC");
          TString16 codtab(_anamag->get(is_fis ? ANAMAG_RAGGFIS : ANAMAG_GRMERC));
          if (tok == "GM" && codtab.len() > 3)
            codtab.cut(3); // gli ultimi 2 si riferiscono al sottogruppo.
          tab->put("CODTAB",codtab);
          if (tab->read() == NOERR)
          {
            gr = tab->get_int(is_cli ? "I3" : "I0");
            co = tab->get_int(is_cli ? "I4" : "I1");
            so = tab->get_long(is_cli ? "I5" : "I2");
            conto.set(gr,co,so);
          }
          if (conto.ok()) break;
        }
        else
        if (tok == "CV" || tok == "CC")
        {
          const bool is_cve = tok == "CV";
          if (is_cve && !is_cli) continue; // se e' un fornitore salta questa condizione
          TTable* t = is_cve ? new TTable("CVE") : new TTable("CCO");
          TString16 cod(is_cve ? r.doc().get(DOC_CATVEN) : EMPTY_STRING);
          if (cod.empty())
          {
            if (skip_clifo) continue; // se non aveva trovato il cliente salta al prossimo
            cod = _clifo->lfile(LF_CFVEN).get(is_cve ? CFV_CATVEN : CFV_CODCATC);
          }
          t->put("CODTAB",cod);
          if (t->read() == NOERR)
          {
            const bool x =(is_cve || is_cli);
            gr = t->get_int(x ? "I3" : "I0");
            co = t->get_int(x ? "I4" : "I1");                                                                   	
            so = t->get_long(x ? "I5": "I2");
            conto.set(gr,co,so);
          }
          if (conto.ok()) break;
        }
      }
      break; // case 'M'
    }
    case 'P': // righe prestazione 
    case 'S': // righe spese
    {
      TTable*  tab = t == 'P' ? new TTable("PRS") : new TTable("SPP");
      tab->put("CODTAB",r.get(RDOC_CODART));
      if (tab->read()==NOERR)
      {
        gr = tab->get_int(is_cli ? "I0" : "I3");
        co = tab->get_int(is_cli ? "I1" : "I4");
        so = tab->get_long(is_cli ? "I2" : "I5");
        conto.set(gr,co,so);                    
        if (!is_cli && !conto.ok())
        {
          gr = r.get_int("QTAGG1");
          co = r.get_int("QTAGG2");
          so = r.get_long("QTAGG3");
          conto.set(gr,co,so);                    
        }
      }
      
      if (!conto.find() && t == 'P') // Cerca il conto nella stringa di ricerca (solo per prestazioni)
      {
        TString16 tok;
        // Scorre la stringa di ricerca ma solo per causale o CLI/FO
        for (int i=0;i<items;i++)
        { 
          tok = _search_seq->get(i);
          if (tok == "CF")
          {
            if (skip_clifo) continue;
            gr = cli_file.get_int(CLI_GRUPPORIC);
            co = cli_file.get_int(CLI_CONTORIC);
            so = cli_file.get_long(CLI_SOTTOCRIC);
            conto.set(gr,co,so);
            if (conto.ok()) break;
          }
          else
            if (tok == "CA")
            {
              CHECK(_caus,"Causale documento non valida");
              if (_caus->IVA2bill(codiva,conto)) break;
            }
        }
      }
      break;  // case 'P','S'
    }
    case 'C':
      // righe sconti: vengono considerate in adjust_sconto_rows()
    case 'D': // righe descrizioni (saltare)
    default :
      break;
  } // end of switch
  return (conto.ok());
}
                              
long TIni2Sql::get_protiva(const TDocumento& doc) const
{          
	long protiva = 0; 
	// solo se é un documento di spesa (chiedere??)
	// e solo se é stato contabilizzato
	if (!doc.tipo().is_generic())
	{                          
		// creo un cursore con
		// tipocf, codcf, datareg = datadoc
		TRelation relmov(LF_MOV);
		TRectype da(LF_MOV);
		da.put(MOV_TIPO, doc.tipocf());
		da.put(MOV_CODCF, doc.codcf());
		da.put(MOV_DATAREG, doc.data());
		TCursor curmov(&relmov, "", 3, &da, &da);
		TString str;
   	const TString& rif = doc.riferimento(str);
    long count = curmov.items();
    curmov = 0;
    while ((curmov.pos() < count) && (protiva == 0))
    {          
    	TString desmov = curmov.curr().get(MOV_DESCR);
    	if (desmov.find(rif) >= 0)
    		protiva = curmov.curr().get_long(MOV_PROTIVA);
    	++curmov;
		}
	}
	return protiva;
}

int TIni2Sql::get_tipo_dadoc(const TDocumento& doc) const
{
  int datipo = 0;
  for (int r = 1; r <= doc.rows(); r++)
  {
    const TRiga_documento& rdoc = doc[r];
    const TString8 dacodnum = rdoc.get(RDOC_DACODNUM);
    if (dacodnum.not_empty())
    {
    	datipo = atoi(cache().get("%NUM", dacodnum, "I1"));
      break;
    }
  }  
  return datipo;
}

bool TIni2Sql::get_fdaric_dadoc(const TDocumento& doc) const
{
  bool daric = FALSE;
  for (int r = 1; r <= doc.rows(); r++)
  {
    const TRiga_documento& rdoc = doc[r];
    const TString8 dacodnum = rdoc.get(RDOC_DACODNUM);
    if (dacodnum.not_empty())
    {
    	daric = cache().get("%NUM", dacodnum).get_bool("B3");
      break;
    }
  }  
  return daric;
}

// esegue l'elaborazione indicata
void TIni2Sql::validate(const TString& elabfield, TString& str)
{   
	TString tmpstr = "";
	str="";    
	TToken_string s(elabfield, ',') ;
  const TString code(s.get(0));
  if (code == "_D") // campo da trasformare in data
  {                                             
		tmpstr = _inputfile->get((s.get()));
		TDate datactrl(tmpstr);
		if (datactrl.ok())
	  	str.format("TO_DATE('%s','dd-mm-yyyy')", (const char*) tmpstr);	
  }	
  else if (code == "_T") // campo da tagliare alla lunghezza indicata
  {
  	int len = atoi(s.get(1));
  	tmpstr = s.get(2);
  	process_field(tmpstr, str, len, FALSE);
  	
  }
  else if (code == "_DATAORA") // campo che contiene data e ora del momento
  {	                              
  	TDate today(TODAY);
  	char time[128];
  	_strtime(time);
  	str.format("TO_DATE('%s %s','dd-mm-yyyy hh24:mi:ss')", today.string(), time);	
  	
  }
  else if (code == "_FIRM") // campo ditta (01, 02, ...)
  {
  	tmpstr = s.get();
  	if (tmpstr.empty())
  		str.format("%02ld", _firm);
  	else
  		str.format("%02ld%s", _firm, (const char*) tmpstr);
  }	
  else if (code == "_UNICMOV") // campo UNICARCH nel caso di movimenti
  	str.format("%s-%s-%ld", (const char*) _inputfile->get("CODCAUS","23"), (const char*) _inputfile->get("ANNOES", "23"), _inputfile->get_long("NUMREG", "23"));
  else if (code == "_UNICDOC") // campo UNICARCH nel caso di documenti
  	str.format("%s-%s-%s", (const char*) _inputfile->get("CODNUM", "33"), (const char*) _inputfile->get("ANNO", "33"), (const char*) _inputfile->get("NDOC", "33"));
	else if (code == "_CODVAL") // campo codice valuta
	{
		tmpstr = _inputfile->get("CODVAL");
		if ((tmpstr[0] == '"') || (tmpstr.empty()))
		{
			TExchange e;
			tmpstr = e.get_value();
		}		
		str = _configfile->get(tmpstr, "Codice valuta");
	}
  else if (code == "_ELSPESAMOV" || code == "_ELSPESADOC") // campo ELSPESA
  {                                        
  	TToken_string key;
  	if (code == "_ELSPESAMOV") // per righe movimenti
  	{
	  	key = _inputfile->get("GRUPPO");
	  	key.add(_inputfile->get("CONTO"));
	  	key.add(_inputfile->get("SOTTOCONTO"));
  	}
  	else											// per righe documenti
  		key.format("%d|%d|%ld", _conto.gruppo(), _conto.conto(), _conto.sottoconto());
	  if (!key.empty_items())
	  {
	    key = cache().get(LF_PCON, key, "CODCBL");
  	  str = cache().get(LF_ABPCON, key, "DESCRIZ").left(6);
  	  str.upper();
  	}
  	else
  	  str.cut(0);
  }
  else if (code == "_DESRMOV") // campo DESART per righe movimenti          
  {
  	process_field("DESCR", tmpstr, -1, FALSE);
  	str.format("%s-%s", (const char*) _inputfile->get("CODCAUS","23"), (const char*) tmpstr);
  }	
  else if (code == "_DESMOV") // campo DESART per movimenti
  {
  	process_field("DESCR", tmpstr, -1, FALSE);
  	str.format("%s (%s)", (const char*) tmpstr, (const char*) _inputfile->get("PROTIVA"));
  }	
  else if (code == "_CODART") // campo CODART per movimenti
  	str.format("%s-%s-%s", (const char*) _inputfile->get("GRUPPO"), (const char*) _inputfile->get("CONTO"), (const char*) _inputfile->get("SOTTOCONTO"));
  else if (code == "_IMPORTORMOV") // campo importo per righe movimenti
  {                             
		real importo(_inputfile->get("IMPORTO"));
		const int gruppo = atoi(_inputfile->get("GRUPPO"));
		const int conto = atoi(_inputfile->get("CONTO"));
		str = _inputfile->get("SEZIONE");
		const char sezione = str[0];
  	if (test_swap_conto(gruppo, conto, sezione))
			importo = importo * (-1);
		str = importo.string();	
  }
  else if (code == "_SEZIONERMOV") // campo sezione per righe movimenti
  {        
		const int gruppo = atoi(_inputfile->get("GRUPPO"));
		const int conto = atoi(_inputfile->get("CONTO"));
		str = _inputfile->get("SEZIONE");
		const char sezione = str[0];
  	if (test_swap_conto(gruppo, conto, sezione))
  	{
  		if (sezione == 'D')
  			str = "A";
  		else if (sezione == 'A')
  			str = "D";
  	}
  }
  else if (code == "_DESDOC") // campo DESDOC per documenti
  {
  	TString16 key = _doc->numerazione();
  	TString desnum = cache().get("%NUM", key, "S0");
		key = _inputfile->get("TIPOCF");
		key << '|' << _inputfile->get("CODCF");
		TString ragsoc = cache().get(LF_CLIFO, key, "RAGSOC");
		long protiva = get_protiva(*_doc);  	
  	str.format("%s-%s",(const char*) desnum, (const char*) ragsoc);
  	if (protiva != 0)
  		str << '(' << protiva << ')';
    TString16 tipodoc = _doc->tipo().codice();
  	TToken_string descrizioni = _configfile->get(tipodoc, "Descrizioni");
  	TString16 separatore = _configfile->get("SEPARATORE", "Descrizioni");
  	TString80 cod;
  	FOR_EACH_TOKEN(descrizioni,tok)
  	{
 			cod = tok;
  		int virgola = cod.find(',');
  		if (virgola > -1)
  		{           
  			TString80 prompt = cod.sub(0,virgola);
  			TString80 campo = cod.sub(virgola+1);
  			str << separatore;
  			str << prompt;
  			str << _doc->get(campo);
  		}
  	}
  }	
	else if (code == "_TIPODOC") // campo TIPDOC
	{
		if (_doc != NULL)
		{   
  		const int tipodoc = atoi(cache().get("%NUM", _doc->numerazione(), "I1"));
  		if (tipodoc == 3) // ordine      
  			tmpstr = "O";
  		else if (tipodoc == 1) // bolla
  		{
				// restituisce il tipo documento origine della prima riga che ha un doc. di origine	  		
  			const int datipodoc = get_tipo_dadoc(*_doc); // si assume che sia il tipo documento di origine per tutto il documento
				tmpstr = (datipodoc == 3) ? "BO" : "B";  			
  		}																
  		else if (tipodoc == 2) // fattura	
  		{
				const bool daricevere = cache().get("%NUM", _doc->numerazione()).get_bool("B3");
				if (daricevere)
					tmpstr = "FR";
				else
				{
  				const int datipodoc = get_tipo_dadoc(*_doc);
  				if (datipodoc == 1)
  					tmpstr = "FB";
  				else if	(datipodoc == 3)
  					tmpstr = "FO";
  				else
					{
						const bool daric = get_fdaric_dadoc(*_doc);
						if (daric)
  						tmpstr = "FF";	
						else
							tmpstr = "F";
					}
				}
  		}
  		str = _configfile->get(tmpstr, "Tipo documento");
		}			
	}
  else if ((code == "_RIFORD") || (code == "_RIFBOL")) // campi RIFORD e RIFBOL
  { 
  	if (_dadoc != NULL)
  	{                                                                   
  		const int ord_bol = atoi(cache().get("%NUM", _dadoc->numerazione(), "I1"));
  		if (((ord_bol == 3) && (code == "_RIFORD")) || ((ord_bol == 1) && (code == "_RIFBOL")))
  		{
  			str << _dadoc->numerazione() << '-';
  			str << _dadoc->anno() << '-';
  			str << _dadoc->numero();
  		}	
  		if ((ord_bol == 1) && (code == "_RIFORD"))
  		{     
  		}	
  	}	                                                              
  }
}

// prende nome campo di input indicato nel file crpa.ini (puo' essere un campo o una elaborazione) 
// e mi restituisce il valore da inserire in VALUES
void TIni2Sql::process_field(const TString& inputfield, TString& tmpstr, int len, const bool apici)
{                        
	tmpstr.cut(0);
	if (inputfield.not_empty())
	{
		// campo elaborato
		if (inputfield[0] == '!') 
			validate(inputfield.sub(1), tmpstr);
	  // valore fisso
		else if (inputfield[0] == ':') 
			tmpstr = inputfield.sub(1);
		// il campo va letto dai documenti o dalle righe	
		else if (inputfield[0] == '#')	
			leggidadoc(inputfield.sub(1), tmpstr);
		// campo da leggere dal file di input
		else if (inputfield == "CODVAL")
		{
			tmpstr = _inputfile->get(inputfield);
			if ((tmpstr[0] == '"') || (tmpstr.empty()))
			{
				TExchange e;
				tmpstr = e.get_value();
				tmpstr = tmpstr.sub(0,2);
			}		
		}
		else if (inputfield == "CODCMS")
		{
			tmpstr = _inputfile->get(inputfield);
			tmpstr.upper();
			tmpstr.replace('/','_');		
		}
		else if (inputfield == "FASCMS")
		{
			tmpstr = _inputfile->get(inputfield);
			tmpstr.upper();
			tmpstr.replace('/','_');		
		}
		else if (inputfield == "CODCF")
		{
			long codcf = _inputfile->get_long(inputfield);
			if (codcf != 0)
			{
				if (_firm == 2)
					codcf+=100000;
				tmpstr.format("%ld", codcf);
			}	
		}
		else 
			tmpstr = _inputfile->get(inputfield);
		tmpstr.trim();	
		if (tmpstr.not_empty())
		{
			if ((tmpstr.sub(0,7) != "TO_DATE") && apici)
      {
				int l = tmpstr.find("'");	
				while (l >= 0)
				{
					tmpstr.insert("'",l);
					l = tmpstr.find("'",l+2);	
				}
			}
			int l = tmpstr.len();
			if ((tmpstr[0] == '"') && (tmpstr[l-1] == '"'))
				tmpstr = tmpstr.sub(1,l-1);
			tmpstr.trim();
			if (len >= 0)
				tmpstr.cut(len);
			if (apici && tmpstr.not_empty() && (tmpstr.sub(0,7) != "TO_DATE"))
			{
				tmpstr.insert("'"); tmpstr << '\'';
			}	
		}		
	}	
}

// distruzione dell'applicazione
bool TIni2Sql::destroy()
{     
  delete _fcaus;
  delete _frcaus;
	delete _anamag;
	delete _clifo;
  delete _inputfile;
  delete _configfile;
  if (_sqlfile != NULL)
  	delete _sqlfile;
  if (_doc != NULL)
  	delete _doc;
  if (_dadoc != NULL)
  	delete _doc;
  if (_rigadoc != NULL)
  	delete _doc;
  return TSkeleton_application::destroy();
}

void TIni2Sql::build_paragraph(const TString& paragrafo, TString& output)
{
  output = paragrafo;
	const int posvirgola = output.find(',');
	if (posvirgola > 0)
		output.cut(posvirgola);
}

int TIni2Sql::build_nriga(const TString& paragrafo)
{
	int nriga = 0;
	const int posvirgola = paragrafo.find(',');
	if (posvirgola > 0)
		 nriga = atoi(paragrafo.sub(posvirgola+1));
	return nriga;	
}


// scrive il file che contiene il comando insert completo dei record da inserire
void TIni2Sql::write_sqlinsert()
{        
	TString_array lp;
	if (_inputfile->list_paragraphs(lp) > 0)
	{   
		bool almenounariga = FALSE;                              
		TString insert, colonne, valori;
		_firm = _inputfile->get_int("Firm", "Transaction");
		TString16 firm = "";
		firm.format("%ld", _firm);
		if (_configfile->get((const char*)firm, "Ditte")[0] == 'S')
		{
			if (_firm != get_firm())
				set_firm(_firm);	
		  FOR_EACH_ARRAY_ROW(lp, p, paragrafo)
	  	{ 
				if (*paragrafo == "Transaction")
				{
				}
				else
				{ 
					TString strpar;
					build_paragraph(*paragrafo, strpar);
					insert.format("INSERT INTO %s", (const char*) _configfile->get("TABLE", strpar));
					colonne = NULL;
					valori = NULL;
	  			_inputfile->set_paragraph(*paragrafo);
					bool ok = TRUE; // se e' una riga va passata solo ad alcune condizioni
					if (strpar == "33") // creo subito il TDocumento per usare tutti i metodi offerti gratis
					{
						if (_doc == NULL)
						{
				  		const TString16 codnum = _inputfile->get("CODNUM");
							const char provv = _inputfile->get("PROVV")[0];
							const int anno = atoi(_inputfile->get("ANNO"));
							const long numdoc = atol(_inputfile->get("NDOC"));
							_doc = new TDocumento(provv, anno, codnum, numdoc);
							_clifo->lfile().put(CLI_TIPOCF, _doc->tipocf());
							_clifo->lfile().put(CLI_CODCF, _doc->codcf());
							_clifo->read();
						}					               
					}
					// se riga movimento deve avere gruppo inserito nel pragrafo gruppi di crpa.ini
					if (strpar == "24")
					{               
						const TString8 gruppo = _inputfile->get("GRUPPO");
						ok = _configfile->get_bool(gruppo, "Gruppi");
					}
					// vecchia condizione: se riga documento deve avere codice iva oppure essere tipo riga spesa e avere gruppo 4 o 5 (andare su anamag con codart o )
					// se riga documento preocedo come la contabilizzazione per cercare il gruppo-conto-sottoconto, che deve essere presente in crpa.ini
					if (strpar == "34")
					{
						const TString8 codiva = _inputfile->get("CODIVA");
						const TString8 tiporiga = _inputfile->get("TIPORIGA");
						const char tiporigatab = cache().get("%TRI", tiporiga, "S7")[0];
						ok = (codiva.not_empty()) || (tiporigatab == 'S');
						if (ok)
						{   
							const int nriga = build_nriga(*paragrafo); 
							if (nriga <= _doc->rows())
							{ 
								_rigadoc = new TRiga_documento((*_doc)[nriga]);
						  /*
							TString8 gruppoa = "";
							TString8 gruppov = "";
							
							TString80 codart;
							if (tiporigatab == 'M') 
							  codart = _inputfile->get(RDOC_CODARTMAG);    
							if (codart.blank())
							  codart = _inputfile->get(RDOC_CODART);    
							
							switch (tiporigatab)
							{
							case 'P':
								{              
		 							const TRectype& prs = cache().get("PRS", codart);
									gruppov = prs.get("I0");
									gruppoa = prs.get("I3");
								}
								break;
							case 'S':
								{              
		 							const TRectype& spp = cache().get("SPP", codart);
									gruppov = spp.get("I0");
									gruppoa = spp.get("I3");
								}
								break;
							default:
								{                                             
								  const TRectype& anamag = cache().get(LF_ANAMAG, codart);
									gruppoa = anamag.get("GRUPPOA");
									gruppov = anamag.get("GRUPPOV");
								}	
								break;
							}              
							*/                                          
								ok = search_costo_ricavo(_conto, (*_rigadoc));
								if (ok)                 
								{	
									TString8 gruppos;
									int gruppo = _conto.gruppo();
									gruppos.format("%d", _conto.gruppo());
									ok = (_configfile->get_bool(gruppos, "Gruppi"));
								}	
								//ok = (_configfile->get_bool(gruppoa, "Gruppi")) || (_configfile->get_bool(gruppov, "Gruppi"));
							}	
						}
					} 
					// verifico che la riga abbia una commessa
					if ((ok) && (strpar == "24" || strpar == "34"))
					{                     
						TString80 codcms;
						if (strpar == "24") 
							codcms = _inputfile->get("CODCMS");
						if (strpar == "34")
						{
							if (_rigadoc != NULL)
								codcms = _rigadoc->codice_commessa();
						}						
						ok = codcms.not_empty();
					}	
					if (ok)
					{   
						if ((strpar=="24") || (strpar=="34"))
							almenounariga =TRUE;
						if ((strpar== "34") && (_rigadoc != NULL))
						{
				  		TString16 codnum = _rigadoc->get("DACODNUM");
							const char provv = _rigadoc->get("DAPROVV")[0];
							const int anno = _rigadoc->get_int("DAANNO");
							const long numdoc = _rigadoc->get_long("DANDOC");
				  		if (codnum.not_empty())
								_dadoc = new TDocumento(provv, anno, (const char*) codnum, numdoc);
						}	
		    		TString_array lv;
		    		_configfile->list_variables(lv, TRUE, strpar);
		    		TString16 key;
		    		TString str;
		    		TString risultato;
		    		FOR_EACH_ARRAY_ROW(lv, r, row)
		    		{                 
	  					_inputfile->set_paragraph(*paragrafo);
		    			key = row->get(0);
			    		str = row->get();
		    			if (strcmp(key,"TABLE") == 0)
		    			{
		    			}
							else
							{            
								process_field(str, risultato);
								if (risultato.not_empty())
								{	
									if (colonne.len()>0)
										colonne << ", ";                             	
									colonne << key;	
									if (valori.len()>0)
										valori << ", ";
									valori << risultato;
								}	
							}	
		    		}                        
		    		if (_rigadoc != NULL)
		    			_rigadoc =NULL;
					  if (_dadoc != NULL)
					  	_dadoc = NULL;
		    	}	
			  }
	  		if (colonne.len() > 0)
				{    
					colonne.insert(" ("); colonne << ") ";
					valori.insert(" VALUES ("); valori << ") ";
					
					_sqlfile->write(insert, insert.len());
					*_sqlfile << endl;
					_sqlfile->write(colonne, colonne.len());
					*_sqlfile << endl;
					_sqlfile->write(valori, valori.len());
					*_sqlfile << endl;
					_sqlfile->put('æ');
					*_sqlfile << endl;
				}	
			}                      
			if (!almenounariga)
			{                   
				if (_sqlfile != NULL)
					delete _sqlfile;
				_sqlfile = new ofstream("crpa.sql");
				_sqlfile->write("",0);
				write_sqldelete();
			}	
		}	
	}
}

// scrive il file che contiene il comando delete completo dei record da cancellare
void TIni2Sql::write_sqldelete()
{        
	TString_array lp;
	if (_inputfile->list_paragraphs(lp) > 0)
	{                                 
		TString cancella, condizione;
		_firm = _inputfile->get_int("Firm", "Transaction");
  	
  	TString strpar, risultato;
		
		// Vado all'indietro per cancellare prima le righe e poi la testata
	  FOR_EACH_ARRAY_ROW_BACK(lp, p, paragrafo)
  	{ 
			build_paragraph(*paragrafo, strpar);
			const int numpar = atoi(strpar);
			const int numrig = build_nriga(*paragrafo);
			
			condizione.cut(0);
			if ( 
			     (numpar == 23 || numpar == 33) ||               // Inizialmente era richiesto di cancellare solo le testate ...
			     ((numpar == 24 || numpar == 34) && numrig == 1) // ... ovviamente ora non più   
			   )
			{  
				cancella.format("DELETE FROM %s", (const char*) _configfile->get("TABLE", strpar));
  			_inputfile->set_paragraph(*paragrafo);
				
				process_field(_configfile->get("ARCH"), risultato);
				if (risultato.not_empty())
					condizione << "(ARCH=" << risultato << ')';	
				
				process_field(_configfile->get("UNICARCH"), risultato);
				if (risultato.not_empty())
				{	
					if (condizione.not_empty())
						condizione << " AND ";
					condizione << "(UNICARCH=" << risultato << ')';	
				}	
			}	
  		
  		if (condizione.not_empty())
			{                                                                 
				condizione.insert(" WHERE ("); condizione << ") ";
				
				_sqlfile->write(cancella, cancella.len());
				_sqlfile->write(condizione, condizione.len());
				*_sqlfile << endl;
				_sqlfile->put('æ');
				*_sqlfile << endl;
			}	
		}                      
	}
}

// carica la maschera 
void TIni2Sql::main_loop()
{ 
	_sqlfile = new ofstream("crpa.sql");
	_sqlfile->write("",0);

	TString16 action = _inputfile->get("Action", "Transaction");
	action.upper();
	switch (action[0])
	{
		case 'I':
 			write_sqlinsert();
 		break;	
		case 'D':
 			write_sqldelete();
 		break;	
		case 'M':        
		{
 			write_sqldelete();
 			write_sqlinsert();
 		}	
 		break;	      
 		
 	}	              
 	if (_sqlfile != NULL)
 	{
	 	_sqlfile->flush();
 		delete _sqlfile;  
 		_sqlfile = NULL;
 		if (_configfile->get("Run", "Oracle") == "OK")
 		{                                            
 		
 			TString rigapar;              
 			if ((_inputfilename[0] != '.') && (_inputfilename[1] != ':'))
 				_inputfilename.insert("./", 0);
 			rigapar << "crpa.exe crpa.sql " << _inputfilename;
 			TExternal_app esegui_sql(rigapar);
 			esegui_sql.run();
 		}	
 	}	                                                                           
 	// non devo scrivere niente nelle tavole oracle
 	// ma devo comunque segnalare come eseguita la transazione altrimenti rimane nel postino
 	else 
 	{
		_inputfile->set("Result", "OK", "Transaction"); 		
		_inputfile->set("Error", "0", "Transaction"); 		
 	}
}

int main(int argc, char** argv)
{
  TIni2Sql a;
  a.run(argc, argv, "Trasferimento dati da EuroCampo");
  return 0;
}