#include <applicat.h>
#include <isam.h>
#include <progind.h>
#include <recarray.h>
#include <utility.h>
#include <fstream.h>       
#include <relation.h> 
#include <tabutil.h>
#include <text.h>                    

#include "quadrog.h"
#include "quadrogp.h"

#define usage "Errore - uso : 77cnv [0|1|2|3|4|5|6] 0"
#define G_DUMP "quadrog.dmp" // File di scarico del quadro G 
#define CNV_LOG "C770log.txt" // File di log della conversione

class TConvert_app : public TApplication
{      
  int _conv;                          
  TTextfile* _M770_log;
  
protected:
  virtual bool create();      
  
  bool convert_e2() const;
  bool convert_f() const;
  bool convert_f2() const;
  bool dump_quadro_g() const; // Funzioni per convertire quadro G
  bool load_quadro_g() const;  
  bool cnv_ca7_971() const; // conversione causali
  bool cnv_quadroA_971() const; // conversione quadro A
  bool cnv_quadroAB_971() const; // conversione quadro Abis  
  bool cnv_quadroA2_971() const; // conversione quadro A2 
  bool cnv_basebis_971() const; // conversione basebis 

public:
  TConvert_app(int conv) : _conv(conv) { }
  virtual ~TConvert_app() { }
};

bool TConvert_app::create()
{
  // istanza file di log
  _M770_log = new TTextfile(CNV_LOG);  
  
  switch(_conv)
  {
  // Numeri liberi per conversioni di Luciano;          
  case 0 : 
  	cnv_ca7_971();
  	cnv_basebis_971();
  	break; 
  case 1 :
  	cnv_quadroA_971();
  	cnv_quadroAB_971();    
  	cnv_quadroA2_971();
  	break;	
	case 4 : convert_e2(); convert_f(); convert_f2(); break;
	case 5 : dump_quadro_g(); break; // Scarica alcuni campi del quadro G da trasportare sulle righe
	case 6 : load_quadro_g(); break; // Ricarica gli stessi sulle righe del quadro G
	default:break;
  }   
  
  // libera istanza file di log
  delete _M770_log;

  return FALSE;
} 

bool TConvert_app::convert_e2() const
{                      
  TLocalisamfile righe_e2(LF_QUAE2);
  TProgind pi(righe_e2.items(), "Conversione quadro E2", FALSE, TRUE, 60);
  
  TDecoder causali("%CA7");

  TRectype& cur =  righe_e2.curr();
  for (int err = righe_e2.first(); err == NOERR; err = righe_e2.next())
  {                              
    pi.addstatus(1);
    const TString& desc = causali.decode(cur.get("CODCAUS"));
    cur.put("DENCAUS", desc);       
    int ee = righe_e2.rewrite();
    if (ee != NOERR)
    {
      const long ditta = cur.get_long("CODDITTA");
      const int riga = cur.get_int("NUMPROG");
      error_box("Impossibile aggiornare la riga %d del quadro E2\n"
                "della ditta %ld: errore %d", riga, ditta, ee);    
    }            
  }
  
  return TRUE;
}

bool TConvert_app::convert_f() const
{
  TLocalisamfile quadro_f(LF_QUAF);
  TLocalisamfile righe_f(LF_RIGHEF);
  TRectype& cur = righe_f.curr();
  
  TProgind pi(quadro_f.items(), "Conversione quadro F", FALSE, TRUE, 60);
  
  for (int err = quadro_f.first(); err == NOERR; err = quadro_f.next())
  {
    pi.addstatus(1);
    const long ditta = quadro_f.get_long("CODDITTA");
    const real e_aliq = quadro_f.get("E_ALIQUOTA");
    
    if (e_aliq < 0.0)
    {
      // gia' stata convertita!
      continue;
    }
    
    cur.zero();
    cur.put("CODDITTA", ditta);
    for (int e = righe_f.read(_isgteq); e == NOERR; e = righe_f.next())
    {
      if (cur.get_long("CODDITTA") != ditta)
        break;

      const char prosp = toupper(cur.get_char("TIPOPRO"));
      const int riga = cur.get_int("NPROG");

      if (prosp >= 'B' && prosp <= 'D')
      {                        
        const char newprosp = prosp-1;
        cur.put("TIPOPRO", newprosp);
        err = righe_f.write();
        if (err != NOERR)
        {
          error_box("Impossibile creare la riga %d del prospetto %c\n"
                    "della ditta %ld: errore %d", riga, newprosp, ditta, err);    
        }
      }
      cur.put("TIPOPRO", prosp);
      if (err == NOERR)
      {
        int err = righe_f.remove(); 
        if (err != NOERR)
        {
          error_box("Impossibile eliminare la riga %d del prospetto %c\n"
                    "della ditta %ld: errore %d", riga, prosp, ditta, err);    
          break;          
        }
      }
      else
        err = righe_f.reread();
    }
    
    const real e_cambiali = quadro_f.get("E_CAMBIALI");
    const real e_sogrit =   quadro_f.get("E_SOGRIT");
    const real e_rope =     quadro_f.get("E_ROPE");
    if (e_cambiali != ZERO || e_sogrit != ZERO || 
        e_aliq != ZERO || e_rope != ZERO)
    {    
      righe_f.zero();
      righe_f.put("CODDITTA", ditta);
      righe_f.put("TIPOPRO", "D");
      righe_f.put("NPROG", "1");
      righe_f.put("IMPCAMB", e_cambiali);
      righe_f.put("ALIQUOTA", e_aliq);
      righe_f.put("SOGRIT", e_sogrit);
      righe_f.put("ROPE", e_rope);
      int ed = righe_f.write();
      if (ed != NOERR)         
        error_box("Impossibile creare la riga del prospetto D\n"
                  "della ditta %ld: errore %d", ditta, ed);    
    }
    
    const real f_aliq = quadro_f.get("F_ALIQUOTA");
    const real f_sogrit = quadro_f.get("F_SOGRIT");
    const real f_rope =   quadro_f.get("F_ROPE");
    if (f_aliq != ZERO || f_sogrit != ZERO || f_rope != ZERO)
    {
      righe_f.zero();
      righe_f.put("CODDITTA", ditta);
      righe_f.put("TIPOPRO", "E");
      righe_f.put("NPROG", "1");
      righe_f.put("ALIQUOTA", f_aliq);
      righe_f.put("SOGRIT", f_sogrit);
      righe_f.put("ROPE", f_rope);
      int ee = righe_f.write();
      if (ee != NOERR)         
        error_box("Impossibile creare la riga del prospetto E\n"
                  "della ditta %ld: errore %d", ditta, ee);    
    }
    
    // Marca la ditta come convertita
    quadro_f.put("E_ALIQUOTA", -1);
    quadro_f.rewrite();
  }        
  
  return TRUE;
}

bool TConvert_app::convert_f2() const
{                      
  TLocalisamfile righe_f2(LF_RIGHEF2);
  TProgind pi(righe_f2.items(), "Conversione quadro F2", FALSE, TRUE, 60);
  
  TDecoder causali("%CA7");

  TRectype& cur =  righe_f2.curr();
  for (int err = righe_f2.first(); err == NOERR; err = righe_f2.next())
  {
    pi.addstatus(1);
    const long ditta = cur.get_long("CODDITTA");
    
    const char oldtipo = cur.get_char("TIPOPRO");
    if (oldtipo != 'A')
    {                                   
      const int riga = cur.get_int("NPROG");

      cur.put("TIPOPRO", "A");
      const TString& desc = causali.decode(cur.get("CODCAUS"));
      cur.put("DENCAUS", desc);       
      int ee = righe_f2.write();
      if (ee == NOERR)
      {   
        cur.put("TIPOPRO", oldtipo);
        ee = righe_f2.remove();   
        if (ee != NOERR)
        {
          error_box("Impossibile eliminare la riga %d del quadro F2\n"
                    "della ditta %ld: errore %d", riga, ditta, ee);    
        }
      }
      else
      {                       
          error_box("Impossibile creare la riga %d del quadro F2\n"
                    "della ditta %ld: errore %d", riga, ditta, ee);    
      }
    }
  }
  
  return TRUE;
}

/////////////////////////////////////////////////////////////////////////////////
// Scarico dei campi del prospetto 1 sez I e II da riportare sulle righe quadro G
/////////////////////////////////////////////////////////////////////////////////
bool TConvert_app::dump_quadro_g() const 
{
  TFilename f;
  TLocalisamfile quadrog(LF_QUAG);
  TToken_string t;
  TString16 fld1,fld2,fld3,fld4;
  TString s1,s2,s3,s4;
  int err;

  f.tempdir();
  f << "/" << G_DUMP;
  ofstream ofs(f);
  
  TProgind pi(quadrog.items(), "Conversione quadro G - Scarico dati in corso...", FALSE, TRUE, 60);
  for (err = quadrog.first(); err == NOERR; err = quadrog.next())
  {
    pi.addstatus(1);
    const long ditta = quadrog.get_long("CODDITTA");
    int riga_1 = 1, riga_2 = 1;
    fld3 = "P1AMMQx"; fld4 = "P1AMMx";
    for (int i = 1; i<=4; i++)
    {
      fld1 = "P1DATADx"; fld2 = "P1NUMQx";      // Prospetto 1 sez I
      fld1.rtrim(1);  fld1 << i;
      fld2.rtrim(1);  fld2 << i;
      fld3.rtrim(1);  fld3 << i;
      fld4.rtrim(1);  fld4 << i;
      s1 = quadrog.get(fld1);
      s2 = quadrog.get(fld2);
      s3 = quadrog.get(fld3);
      s4 = quadrog.get(fld4); 
      if (s1.not_empty() || s2.not_empty() || s3.not_empty() || s4.not_empty())
      { // Se tutti vuoti non scrive la riga
        t = "";
        t.add(ditta);
        t.add("1"); t.add("1");t.add(riga_1++);
        t.add(s1);
        t.add(s2);
        t.add(s3);
        t.add(s4);
        t << "\n";
        ofs << t;
      }
      
      if (i < 4)
      {
        fld1 = "P2DESCx"; fld2 = "P2VALx"; // Prospetto 1 sez II
        fld1.rtrim(1);  fld1 << i;
        fld2.rtrim(1);  fld2 << i;
        s1 = quadrog.get(fld1);
        s2 = quadrog.get(fld2);
        if (s1.not_empty() || s2.not_empty())
        { // Se tutti vuoti non scrive la riga
          t = "";
          t.add(ditta);
          t.add("1"); t.add("2");t.add(riga_2++);
          t.add(s1);
          t.add(s2);
          t << "\n";
          ofs << t;
        }
      }
    }
  }
  return TRUE;
}

/////////////////////////////////////////////////////////////////////////////////
// Carico dei campi del prospetto 1 sez I e II da riportare sulle righe quadro G
/////////////////////////////////////////////////////////////////////////////////
bool TConvert_app::load_quadro_g() const
{
  TFilename f;
  f.tempdir();
  f << "/" << G_DUMP;
  if (fexist(f))
  {
    TLocalisamfile quadrogp(LF_QUAGP);
    TToken_string t;
    char buffer[256];
    ifstream ifs(f);
    int err;
    TProgind pi(1, "Conversione quadro G - Caricamento righe in corso...", FALSE, FALSE, 60);
    while (ifs.good())
    {
      ifs.getline(buffer,256,'\n');
      t = buffer;
      if (t.empty_items()) break;
      quadrogp.zero();
      quadrogp.put(QGP_CODDITTA,t.get(0));
      quadrogp.put(QGP_PROSPETTO,t.get(1));
      const char sez = t.get_char(2);
      quadrogp.put(QGP_SEZIONE,sez);
      quadrogp.put(QGP_NPROG,t.get(3));
      if (sez ==  '1')
      {
        quadrogp.put(QGP_DATADEL,t.get(4));
        quadrogp.put(QGP_NUMQUOTE,t.get(5));
        quadrogp.put(QGP_UTILI1S,t.get(6));
        quadrogp.put(QGP_UTILI2S,t.get(7));
      }
      else
      {
        quadrogp.put(QGP_DESCRBENI,t.get(4));
        quadrogp.put(QGP_UTILI1S,t.get(5));
      }
      err = quadrogp.write();
      if (err == _isreinsert)
        err = quadrogp.rewrite();
      if (err != NOERR)
        error_box("Errore %d cercando di caricare le righe del quadro G.",err);
    }
  }
  remove(f); // Let's ignore if the file exists or not
  return TRUE;
}


///////////////////////////////////////////////////////////
// Conversione tabella causali versione 971
///////////////////////////////////////////////////////////
bool TConvert_app::cnv_ca7_971() const
{  
  // titolo log                                    
  char now[9];
  TDate today(TODAY);  
  TString log_title("[Log Conversione Causali : ");
  log_title << today << " " << _strtime(now) << "]  Prassi SpA";               
  _M770_log->append(log_title);	
  TString log_space(" ");
  _M770_log->append(log_space);	

  // conversione tabella
  TTable ca7("%CA7");  
  TProgind pi(ca7.items(), "Conversione tabella causali", FALSE, FALSE, 60);
  for (ca7.first(); ca7.good(); ca7.next())
  {    
    // lettura campi soggetti a modifica
    TString old_cod = ca7.get("CODTAB"); 
    TString cod_qua = ca7.get("S1");// codice quadro
    bool fl_Inps = ca7.get_bool("B4");// soggetto contributo Inps     
    bool fl_CT = ca7.get_bool("B2");// flag C.T.
    bool fl_TS = ca7.get_bool("B3");// flag T.S.
    char caus_C = ca7.get_char("S6");// causale quadro C
    char caus_D = ca7.get_char("S2");// causale quadro D
    char caus_D1 = ca7.get_char("S3");// causale quadro D1
    char caus_DB = ca7.get_char("S7");// causale quadro DB    
    char caus_E = ca7.get_char("S8");// causale quadro E    
    char caus_E1 = ca7.get_char("S9");// causale quadro E1
    real ass_imp_Inps = ca7.get_real("R2");// assoggettamento imponibile Inps
    
    // conversione causale quadro D
    switch(caus_D)
    {
    	case 'A':
    		if (fl_Inps)
    		{
    			cod_qua = "DB";
    			caus_DB = 'A';
    			caus_D = ' ';
    		}
    		break;
    	case 'T':
    		if (fl_Inps)
    		{
    			cod_qua = "DB";
    			caus_DB = 'T';
    			caus_D = ' ';
    		}
    		break;		
    	case 'E':
    		if (!fl_Inps)    		
    			caus_D = 'M';  
    		else   
    		{
    			TString log_line;	
    			log_line << old_cod << ": ";
    			log_line << "causale quadro D: -E- con flag contributo Inps";
    			_M770_log->append(log_line);	
    		}
    		break;
    	case 'G':
    		if (!fl_Inps)    		
    			caus_D = 'B';
    		else   
    		{
    			TString log_line;	
    			log_line << old_cod << ": ";
    			log_line << "causale quadro D: -G- con flag contributo Inps";
    			_M770_log->append(log_line);	
    		}	
    		break;
    	case 'H':
    		if (!fl_Inps)    		
    			caus_D = 'C';
    		else   
    		{
    			TString log_line;	
    			log_line << old_cod << ": ";
    			log_line << "causale quadro D: -H- con flag contributo Inps";
    			_M770_log->append(log_line);	
    		}
    		break;			
    	case 'I':
    		if (!fl_Inps)    		
    			caus_D = 'D';
    		else   
    		{
    			TString log_line;	
    			log_line << old_cod << ": ";
    			log_line << "causale quadro D: -I- con flag contributo Inps";
    			_M770_log->append(log_line);	
    		}
    		break;			 
    	case 'L':
    		if (!fl_Inps)    		
    			caus_D = 'E';
    		else   
    		{
    			TString log_line;	
    			log_line << old_cod << ": ";
    			log_line << "causale quadro D: -L- con flag contributo Inps";
    			_M770_log->append(log_line);	
    		}
    		break;	     
    	case 'M':
    		if (!fl_Inps)    		
    			caus_D = 'F';
    		else   
    		{
    			TString log_line;	
    			log_line << old_cod << ": ";
    			log_line << "causale quadro D: -M- con flag contributo Inps";
    			_M770_log->append(log_line);	
    		}
    		break;	     
    	case 'P':
    		if (!fl_Inps)    		
    			caus_D = 'G';
    		else   
    		{
    			TString log_line;	
    			log_line << old_cod << ": ";
    			log_line << "causale quadro D: -P- con flag contributo Inps";
    			_M770_log->append(log_line);	
    		}
    		break;	     
    	case 'Q':
    		if (!fl_Inps)    		
    			caus_D = 'H';
    		else   
    		{
    			TString log_line;	
    			log_line << old_cod << ": ";
    			log_line << "causale quadro D: -Q- con flag contributo Inps";
    			_M770_log->append(log_line);	
    		}
    		break;	     
    	case 'R':
    		if (!fl_Inps)    		
    			caus_D = 'N';
    		else   
    		{
    			TString log_line;	
    			log_line << old_cod << ": ";
    			log_line << "causale quadro D: -R- con flag contributo Inps";
    			_M770_log->append(log_line);	
    		}
    		break;	       
    	case 'S':
    		if (!fl_Inps)    		
    			caus_D = 'I';
    		else   
    		{
    			TString log_line;	
    			log_line << old_cod << ": ";
    			log_line << "causale quadro D: -S- con flag contributo Inps";
    			_M770_log->append(log_line);	
    		}
    		break;	     
    	case 'F':
    		cod_qua = "DB";
    		caus_DB = 'E';
        caus_D = ' '; 
        fl_Inps = TRUE;     
        ass_imp_Inps = ZERO;
    		break;
    	case 'N':
    		cod_qua = "DB";
    		caus_DB = 'F';
        caus_D = ' '; 
        fl_Inps = TRUE;
        ass_imp_Inps = ZERO;
    		break;
    	case 'B':
    		cod_qua = "DB";
    		caus_DB = 'B';
        caus_D = ' '; 
        fl_Inps = TRUE;
        ass_imp_Inps = ZERO;
    		break;
    	case 'C':
    		cod_qua = "DB";
    		caus_DB = 'C';
        caus_D = ' '; 
        fl_Inps = TRUE;
        ass_imp_Inps = ZERO;
    		break;			
    	case 'D':
    		cod_qua = "DB";
    		caus_DB = 'D';
        caus_D = ' '; 
        fl_Inps = TRUE;
        ass_imp_Inps = ZERO;
    		break;		  
    }		                           
    
    // conversione causale quadro D1
    switch(caus_D1)
    {
    	case 'F':        
    		cod_qua = "DB";
    		caus_DB = 'F';
        caus_D1 = ' '; 
        fl_Inps = TRUE;
        ass_imp_Inps = ZERO;
    		break;
    }				                        
    
    // flag C.T.
    if (fl_CT)	
    	caus_C = 'A';
    	             
    // flag T.S.
    if (fl_TS)	
    {	
    	fl_TS = FALSE;
			TString log_line;	
			log_line << old_cod << ": ";
			log_line << "era indicato il flag T.S.";
			_M770_log->append(log_line);	
    }
    	
    	
    // clear campi eliminati
    ca7.zero("B0");
    ca7.zero("B2");         
    
    // update campi modificati
    ca7.put("S1",cod_qua);// codice quadro	
    ca7.put("B4",fl_Inps);// soggetto contributo Inps
    ca7.put("B3",fl_TS);// flag T.S.
    ca7.put("S6",caus_C);// causale quadro C
    ca7.put("S2",caus_D);// causale quadro D
    ca7.put("S3",caus_D1);// causale quadro D1
    ca7.put("S7",caus_DB);// causale quadro DB    
    ca7.put("S8",caus_E);// causale quadro E    
    ca7.put("S9",caus_E1);// causale quadro E1
    ca7.put("R2",ass_imp_Inps);// assoggettamento imponibile Inps
    
    // riscrittura record 
    ca7.rewrite();
  }
  // fine log
  _M770_log->append(log_space);  
  
  return TRUE;              
}                               
                                                           
                                                           
///////////////////////////////////////////////////////////
// Conversione quadro A 770 versione 971
///////////////////////////////////////////////////////////
bool TConvert_app::cnv_quadroA_971() const
{
  // titolo log
  char now[9];
  TDate today(TODAY);  
  TString log_title("[Log Conversione quadro A : ");
  log_title << today << " " << _strtime(now) << "]  Prassi SpA";               
  _M770_log->append(log_title);	
  TString log_space(" ");
  _M770_log->append(log_space);	
  
  TLocalisamfile dip(LF_DIPEND);
  TLocalisamfile qa(LF_QUAA); 
  TProgind pi(qa.items(), "Conversione quadro A", FALSE, TRUE, 60);
  for (qa.first(); qa.good(); qa.next())
  {                                            
    pi.addstatus(1);
  
    // lettura campi soggetti a modifica
    long cod_ditta = qa.get_long("CODDITTA"); 
    long cod_dip = qa.get_long("CODDIP");
    int A18 = qa.get_int("CAUSA");// causa
    real A29 = qa.get_real("DENARO");// retribuzioni e pensioni       
    real EX_A21 = qa.get_real("NATURA");// ex in denaro  
    real A21 = qa.get_real("COBBDIP");// contr.prev.obblig.lav.dip.
    real EX_A25 = qa.get_real("IACOBBCD");// ex contr.obbl.carico lav.dip.            
    real A24 = qa.get_real("NORIT");// somme a valori non assogg. a rit.
    real EX_A27 = qa.get_real("TOTIMP");// ex totale imponibile 
    real EX_A50 = qa.get_real("SVNASSRI");// ex altre somme e valori non ass.rit.
    int A11 = qa.get_int("QAQUALIF");// qualifica
    
    // lettura campi dall'anagrafica dipendenti
    int ana_qualifica = 0;// qualifica anagrafica
    dip.setkey(1);
    dip.zero();
    dip.put("CODDITTA",cod_ditta); 
    dip.put("CODDIP",cod_dip);
    if (dip.read() == NOERR)
    	ana_qualifica = dip.get_int("QUALIFICA"); 
    else 
    {	
    	TString log_line;  
    	log_line.format("Anagrafica inesistente per il dipendente :%06ld, della ditta :%05ld",cod_dip,cod_ditta);
    	_M770_log->append(log_line);
    }		
    
    // conversione causa
    switch(A18)
    {
    	case 6:
    		A18 = 0;
    		break;
    	case 7:
    		A18 = 0;
    		break;		  
    }		                           
    
    // retribuzioni e pensioni
    A29 = A29 + EX_A21 - A21 + EX_A27;
    
    // contributi previd.assist.obbl.lav.dip.
    A21 = A21 + EX_A25;
    
    // somme e valori non assoggettati a ritenuta
    A24 = A24 + EX_A50;
    	
    // qualifica
    A11 = ana_qualifica;
    
    // update campi modificati
    qa.put("CAUSA",A18);// causa
    qa.put("DENARO",A29);// retribuzioni e pensioni        
    qa.put("COBBDIP",A21);// contr.prev.obblig.lav.dip. 
    qa.put("NORIT",A24);// somme a valori non assogg. a rit.
    qa.put("QAQUALIF",A11);// qualifica
    
    // riscrittura record 
    qa.rewrite();
  }
  // fine log
  _M770_log->append(log_space);
  
  return TRUE;              
}

///////////////////////////////////////////////////////////
// Conversione quadro Abis 770 versione 971
///////////////////////////////////////////////////////////
bool TConvert_app::cnv_quadroAB_971() const
{
  // titolo log
  char now[9];
  TDate today(TODAY);  
  TString log_title("[Log Conversione quadro Abis : ");
  log_title << today << " " << _strtime(now) << "]  Prassi SpA";               
  _M770_log->append(log_title);	
  TString log_space(" ");
  _M770_log->append(log_space);	
  
  // istanza file basebis per riporto flag quadro compilato
  TLocalisamfile bb(LF_BASEBIS);
  
  // istanza file Abis e prepara chiave precedente
  // per rilevamento rottura del dipendente 
  TLocalisamfile qab(LF_QUAAB);  
  qab.setkey(1);
  qab.zero();
  TRectype prevkey(qab.curr());
  int prog = 0;
  
  // istanza conta rettifica di conguaglio
  int count_RettA = 0; 
  int count_RettB = 0;  
  int count_RettC = 0; 
  int	count_RettX = 0;                    
  
  // istanza record per scrittura rettifica A
  TRectype rec_RettA(qab.curr());
  
  // elaborazione quadri A
  TLocalisamfile qa(LF_QUAA);
  TProgind pi(qa.items(), "Conversione quadro Abis", FALSE, TRUE, 60);
  for (qa.first(); qa.good(); qa.next())
  {
    pi.addstatus(1);
    
    // lettura campi da copiare su Abis
    long cod_ditta = qa.get_long("CODDITTA");// codice ditta 
    long cod_dip = qa.get_long("CODDIP");// codice dipendente 
    int rigo = qa.get_int("NPROG");// progressivo rigo
    char EX_A52 = qa.get_char("CONEFF");// conguagli non effettuati
    real EX_A53 = qa.get_real("IMPVERS");// imposta trattenuta
    real EX_A54 = qa.get_real("INTERE");// interessi
    real EX_A55 = qa.get_real("CSSN95CV");// contributo trattenuto
    real EX_A56 = qa.get_real("INTERE2");// interessi              
    char EX_A57 = qa.get_char("CNEFF");// conguagli non effettuati
    char EX_A58 = qa.get_char("RETCON");// rettifica conguaglio    
    real EX_A59 = qa.get_real("IMPRIMB");// imposta rimborsata
    real EX_A60 = qa.get_real("IMPVER");// imposta trattenuta                           
    real EX_A61 = qa.get_real("INTIRPEF");// interessi
    real EX_A62 = qa.get_real("IMPVER2");// imposta trattenuta
    real EX_A63 = qa.get_real("INTER");// interessi               
    real EX_A64 = qa.get_real("STSIRPEF");// soprattasse su Irpef
    real EX_A65 = qa.get_real("CONRIMB");// contributo a rimborso
    real EX_A66 = qa.get_real("CONVER");// contributo trattenuto
    real EX_A67 = qa.get_real("INTER2");// interessi              
    real EX_A68 = qa.get_real("CONVER2");// contributo trattenuto
    real EX_A69 = qa.get_real("INTER3");// interessi              
    real EX_A70 = qa.get_real("STSCSSN70");// soprattasse su Cssn
    int  EX_A71 = qa.get_int("M730NLIQ");// Mod.730 non liquidabile
    long EX_A72 = qa.get_long("CODCAAF");// codice CAAF
    
    real tot =ZERO;
    tot = tot+EX_A53+EX_A54+EX_A55+EX_A56+EX_A59+EX_A60+EX_A61+EX_A62;
    tot = tot+EX_A63+EX_A64+EX_A65+EX_A66+EX_A67+EX_A68+EX_A69+EX_A70;
    
    if (tot==ZERO && EX_A52==' ' && EX_A57==' ' && EX_A58==' ' && !EX_A71)
    	continue;
    
    // preparazione chiave quadro Abis e istanza nuovo record per scrittura 
    qab.zero();
    qab.put("CODDITTA",cod_ditta); 
    qab.put("CODDIP",cod_dip);
    TRectype key(qab.curr());  
    TRectype newrec(qab.curr());      
    
    // controllo rottura dipendente 
    if (key > prevkey)
    {
    	// creo record rettifica A + valori operazioni di conguaglio
    	if (count_RettA)
    	{
    		long ditta_RettA = rec_RettA.get_long("CODDITTA");
    		long dip_RettA = rec_RettA.get_long("CODDIP");
    		rec_RettA.put("NPROG",++prog);
    		qab.write(rec_RettA); 
    		TString log_line;  
    		log_line.format("Unificato quadro rettifica A con rettifica B per il dipendente :%06ld, della ditta :%05ld",dip_RettA,ditta_RettA);
    		_M770_log->append(log_line);  
    		// set flag quadro compilato
    		bb.zero();
    		bb.put("CODDITTA",ditta_RettA);
    		if (bb.read() == NOERR)
    		{
    			TString qcomp(bb.get("QCOMP"));
          TString newqcomp;
          newqcomp.spaces(29);
          newqcomp.overwrite(qcomp,0);
    			newqcomp[26] = 'X';
    			bb.put("QCOMP",newqcomp);
    			bb.rewrite();
    		}		
    	}	
    	// reimposto variabili di controllo
    	prevkey = key;
    	count_RettA = 0; 
    	count_RettB = 0;  
    	count_RettC = 0; 
    	count_RettX = 0; 
    	// inizializzo record rettifica A
    	rec_RettA = key;          
    }
    
    // reperisce ultimo progressivo assegnato 
    prog = 0;
  	for (qab.read(_isgteq); qab.good() && qab.curr() == key; qab.next())
    	prog = qab.get_int("NPROG");
   
    // non posso riportare un record con rettifica C,D,E oppure F,
    // se ho già riportato un qualsiasi altro record 
    if ((EX_A58 == 'C' || EX_A58 == 'D' || EX_A58 == 'E' || EX_A58 == 'F') && count_RettX > 0)
    {	
    	TString log_line;  
    	log_line.format("Non riportato quadro per il dipendente :%06ld, della ditta :%05ld, rigo :%03d",cod_dip,cod_ditta,rigo);
    	_M770_log->append(log_line);
    	log_line.format("- era un quadro con rettifica %c, ed erano già stati riportati altri quadri",EX_A58);
    	_M770_log->append(log_line);
    	continue; 
    }	
    
    // se già riportato record con rettifica C,D,E oppure F
    // deve esistere solo quest'ultimo
    if (count_RettC)
    {	                           
    	TString log_line;  
    	log_line.format("Non riportato quadro per il dipendente :%06ld, della ditta :%05ld, rigo :%03d",cod_dip,cod_ditta,rigo);
    	_M770_log->append(log_line);
    	log_line.format("- erano già stati riportati quadri C,D,E oppure F");
    	_M770_log->append(log_line);
    	continue;                  
    }	
    
    // deve esistere un solo record con rettifica A 
    if (EX_A58 == 'A' && count_RettA)
    {	
    	TString log_line;  
    	log_line.format("Non riportato quadro per il dipendente :%06ld, della ditta :%05ld, rigo :%03d",cod_dip,cod_ditta,rigo);
    	_M770_log->append(log_line);
    	log_line.format("- era un quadro con rettifica %c, ed era già stato riportato un quadro A",EX_A58);
    	_M770_log->append(log_line);
    	continue;                                     
    }
    
    // deve esistere un solo record con rettifica B 
    if (EX_A58 == 'B' && count_RettB)
    {	
    	TString log_line;  
    	log_line.format("Non riportato quadro per il dipendente :%06ld, della ditta :%05ld, rigo :%03d",cod_dip,cod_ditta,rigo);
    	_M770_log->append(log_line);
    	log_line.format("- era un quadro con rettifica %c, ed era già stato riportato un quadro B",EX_A58);
    	_M770_log->append(log_line);
    	continue;
    }
                                                    
    // riporto valori su Abis
    switch (EX_A58)
    {
    	// per record con rettifica A memorizzo valori su record rettifica A
    	case 'A':
		    rec_RettA.put("CONEFF",EX_A52);// conguagli non effettuati
		    rec_RettA.put("IMPVERS",EX_A53);// imposta trattenuta
		    rec_RettA.put("INTERE",EX_A54);// interessi
		    rec_RettA.put("CSSN95CV",EX_A55);// contributo trattenuto
		    rec_RettA.put("INTERE2",EX_A56);// interessi              
		    rec_RettA.put("CNEFF",EX_A57);// conguagli non effettuati
		    rec_RettA.put("RETCON",EX_A58);// rettifica conguaglio    
		    rec_RettA.put("IMPRIMB",EX_A59);// imposta rimborsata
		    rec_RettA.put("IMPVER",EX_A60);// imposta trattenuta                           
		    rec_RettA.put("INTIRPEF",EX_A61);// interessi
		    rec_RettA.put("IMPVER2",EX_A62);// imposta trattenuta
		    rec_RettA.put("INTER",EX_A63);// interessi               
		    rec_RettA.put("STSIRPEF",EX_A64);// soprattasse su Irpef
		    rec_RettA.put("CONRIMB",EX_A65);// contributo a rimborso
		    rec_RettA.put("CONVER",EX_A66);// contributo trattenuto
		    rec_RettA.put("INTER2",EX_A67);// interessi              
		    rec_RettA.put("CONVER2",EX_A68);// contributo trattenuto
		    rec_RettA.put("INTER3",EX_A69);// interessi              
		    rec_RettA.put("STSCSSN70",EX_A70);// soprattasse su Cssn
		    rec_RettA.put("M730NLIQ",EX_A71);// Mod.730 non liquidabile	              
      	break;
      // per record con rettifica B memorizzo valori su record rettifica A
      case 'B':
				rec_RettA.put("QABRCB19",EX_A62); 
				rec_RettA.put("QABRCB20",EX_A63); 
				rec_RettA.put("QABRCB21",EX_A64);
				rec_RettA.put("QABRCB22",EX_A65);
				rec_RettA.put("QABRCB23",EX_A66);
				rec_RettA.put("QABRCB24",EX_A67);
				rec_RettA.put("QABRCB25",EX_A68);
	      rec_RettA.put("QABRCB26",EX_A69);
	      break;
      // per gli altri creo record Abis
    	default:
	    	newrec.put("NPROG",++prog);
		    newrec.put("CONEFF",EX_A52);// conguagli non effettuati
		    newrec.put("IMPVERS",EX_A53);// imposta trattenuta
		    newrec.put("INTERE",EX_A54);// interessi
		    newrec.put("CSSN95CV",EX_A55);// contributo trattenuto
		    newrec.put("INTERE2",EX_A56);// interessi              
		    newrec.put("CNEFF",EX_A57);// conguagli non effettuati
		    newrec.put("RETCON",EX_A58);// rettifica conguaglio    
		    newrec.put("IMPRIMB",EX_A59);// imposta rimborsata
		    newrec.put("IMPVER",EX_A60);// imposta trattenuta                           
		    newrec.put("INTIRPEF",EX_A61);// interessi
		    newrec.put("IMPVER2",EX_A62);// imposta trattenuta
		    newrec.put("INTER",EX_A63);// interessi               
		    newrec.put("STSIRPEF",EX_A64);// soprattasse su Irpef
		    newrec.put("CONRIMB",EX_A65);// contributo a rimborso
		    newrec.put("CONVER",EX_A66);// contributo trattenuto
		    newrec.put("INTER2",EX_A67);// interessi              
		    newrec.put("CONVER2",EX_A68);// contributo trattenuto
		    newrec.put("INTER3",EX_A69);// interessi              
		    newrec.put("STSCSSN70",EX_A70);// soprattasse su Cssn
		    newrec.put("M730NLIQ",EX_A71);// Mod.730 non liquidabile  
		    qab.write(newrec);                                      
		    // set flag quadro compilato
    		bb.zero();
    		bb.put("CODDITTA",cod_ditta);
    		if (bb.read() == NOERR)
    		{
    			TString qcomp(29);
    			qcomp = bb.get("QCOMP");
    			qcomp[27] = 'X';
    			bb.put("QCOMP",qcomp);
    			bb.rewrite();
    		}		
	  }  
    
    // aggiorno conta rettifica di conguaglio
    switch (EX_A58)
    {
    	case 'A': 
    		++count_RettA;                       
    		++count_RettX;                             
    		break;
    	case 'B':
    		++count_RettB;
    		++count_RettX;
    		break;        
    	case 'C':
    		++count_RettC;
    		++count_RettX;
    		break;	
    	case 'D':
    		++count_RettC;
    		++count_RettX;
    		break;
    	case 'E':
    		++count_RettC;
    		++count_RettX;
    		break;       
    	case 'F':
    		++count_RettC;
    		++count_RettX;
    		break;	
    	default:   
    		++count_RettX;
    }						
  }
  // fine log
  _M770_log->append(log_space);  
  
  return TRUE;            
}                                                           
                                                           
///////////////////////////////////////////////////////////
// Conversione quadro A2 770 versione 971
///////////////////////////////////////////////////////////
bool TConvert_app::cnv_quadroA2_971() const
{
  // titolo log
  char now[9];
  TDate today(TODAY);  
  TString log_title("[Log Conversione quadro A2 : ");
  log_title << today << " " << _strtime(now) << "]  Prassi SpA";               
  _M770_log->append(log_title);	
  TString log_space(" ");
  _M770_log->append(log_space);	
  
  // istanza file A2 e prepara chiave precedente
  // per rilevamento rottura del dipendente 
  TLocalisamfile qa2(LF_QUAA2);  
  qa2.setkey(1);
  qa2.zero();
  TRectype prevkey(qa2.curr());
  int prog = 0;
  
  // istanza conta rettifica di conguaglio
  int count_RettA = 0; 
  int count_RettB = 0;  
  int count_RettC = 0; 
  int	count_RettX = 0;                    
  
  // istanza record per scrittura rettifica A
  TRectype rec_RettA(qa2.curr());
  
  // istanza cursore per scansione quadri A2
  TRelation rA2(LF_QUAA2);
  TCursor	cA2(&rA2);
  
  // elaborazione quadri A2 (frizzati) 
  cA2.freeze();      
  cA2 = 0L;  
  TRectype& rc = cA2.curr();
  TRecnotype items = cA2.items();  
  TProgind pi(items, "Conversione quadro A2", FALSE, TRUE, 60);
  for (int i = 0; i < items; i++,++cA2)
  {
    pi.addstatus(1);
    
    // lettura campi da copiare su A2
    long cod_ditta = rc.get_long("CODDITTA");// codice ditta 
    long cod_dip = rc.get_long("CODDIP");// codice dipendente 
    int rigo = rc.get_int("NPROG");// progressivo rigo
    char A2_9 = rc.get_char("RETCON");// rettifica conguaglio    
    real A2_10 = rc.get_real("SIRPEFRIMB");
    real A2_11 = rc.get_real("VIRPEF");
    real A2_12 = rc.get_real("INTIRPEF");
    real A2_13 = rc.get_real("AIRPEFIV");
    real A2_14 = rc.get_real("AIRPEFINT");
    real A2_15 = rc.get_real("STASSA15");
    real A2_16 = rc.get_real("CONTR16");
    real A2_17 = rc.get_real("CONTRVER");
    
    // preparazione chiave quadro A2
    qa2.zero();
    qa2.put("CODDITTA",cod_ditta); 
    qa2.put("CODDIP",cod_dip);
    TRectype key(qa2.curr());
    
    // controllo rottura dipendente 
    if (key > prevkey)
    {
    	// aggiorno record rettifica A + valori operazioni di conguaglio
    	if (count_RettA)
    	{
    		long ditta_RettA = rec_RettA.get_long("CODDITTA");
    		long dip_RettA = rec_RettA.get_long("CODDIP");
    		qa2.rewrite(rec_RettA); 
    		TString log_line;  
    		log_line.format("Unificato quadro rettifica A con rettifica B per il dipendente :%06ld, della ditta :%05ld",dip_RettA,ditta_RettA);
    		_M770_log->append(log_line);
    	}	
    	// reimposto variabili di controllo
    	prevkey = key;
    	count_RettA = 0; 
    	count_RettB = 0;  
    	count_RettC = 0; 
    	count_RettX = 0;
    }
   
    // non posso riportare un record con rettifica C,D,E oppure F,
    // se ho già riportato un qualsiasi altro record 
    if ((A2_9 == 'C' || A2_9 == 'D' || A2_9 == 'E' || A2_9 == 'F') && count_RettX > 0)
    {	
    	qa2.remove(rc);
    	TString log_line;  
    	log_line.format("Eliminato quadro per il dipendente :%06ld, della ditta :%05ld, rigo :%03d",cod_dip,cod_ditta,rigo);
    	_M770_log->append(log_line);
    	log_line.format("- era un quadro con rettifica %c, ed erano già presenti altri quadri",A2_9);
    	_M770_log->append(log_line);
    	continue; 
    }	
    
    // se già riportato record con rettifica C,D,E oppure F
    // deve esistere solo quest'ultimo
    if (count_RettC)
    {	                           
    	qa2.remove(rc);
    	TString log_line;  
    	log_line.format("Eliminato quadro per il dipendente :%06ld, della ditta :%05ld, rigo :%03d",cod_dip,cod_ditta,rigo);
    	_M770_log->append(log_line);
    	log_line.format("- erano già presenti quadri C,D,E oppure F");
    	_M770_log->append(log_line);
    	continue;                  
    }	
    
    // deve esistere un solo record con rettifica A 
    if (A2_9 == 'A' && count_RettA)
    {	
    	qa2.remove(rc);
    	TString log_line;  
    	log_line.format("Eliminato quadro per il dipendente :%06ld, della ditta :%05ld, rigo :%03d",cod_dip,cod_ditta,rigo);
    	_M770_log->append(log_line);
    	log_line.format("- era un quadro con rettifica %c, ed era già presente un quadro A",A2_9);
    	_M770_log->append(log_line);
    	continue;                                     
    }
    
    // deve esistere un solo record con rettifica B 
    if (A2_9 == 'B' && count_RettB)
    {	
    	qa2.remove(rc);
    	TString log_line;  
    	log_line.format("Eliminato quadro per il dipendente :%06ld, della ditta :%05ld, rigo :%03d",cod_dip,cod_ditta,rigo);
    	_M770_log->append(log_line);
    	log_line.format("- era un quadro con rettifica %c, ed era già presente un quadro B",A2_9);
    	_M770_log->append(log_line);
    	continue;
    }
                                                    
    // riporto valori su A2
    switch (A2_9)
    {
    	// per record con rettifica A memorizzo valori su record rettifica A
    	case 'A':   
    		rec_RettA = rc;	              
      	break;
      // per record con rettifica B memorizzo valori su record rettifica A  
      // ed elimino il record
      case 'B':
				rec_RettA.put("QA2RCB10",A2_10); 
				rec_RettA.put("QA2RCB11",A2_11); 
				rec_RettA.put("QA2RCB12",A2_12);
				rec_RettA.put("QA2RCB13",A2_13);
				rec_RettA.put("QA2RCB14",A2_14);
				rec_RettA.put("QA2RCB15",A2_15);
				rec_RettA.put("QA2RCB16",A2_16);
	      rec_RettA.put("QA2RCB17",A2_17);
	      qa2.remove(rc);
	      break;
      // per gli altri non fò nulla
    	default:  
    		break;
	  }  
    
    // aggiorno conta rettifica di conguaglio
    switch (A2_9)
    {
    	case 'A': 
    		++count_RettA;                       
    		++count_RettX;                             
    		break;
    	case 'B':
    		++count_RettB;
    		++count_RettX;
    		break;        
    	case 'C':
    		++count_RettC;
    		++count_RettX;
    		break;	
    	case 'D':
    		++count_RettC;
    		++count_RettX;
    		break;
    	case 'E':
    		++count_RettC;
    		++count_RettX;
    		break;       
    	case 'F':
    		++count_RettC;
    		++count_RettX;
    		break;	
    	default:   
    		++count_RettX;
    }						
  }
  // fine log
  _M770_log->append(log_space); 
  
  return TRUE;             
}                                                           

///////////////////////////////////////////////////////////
// Conversione basebis 770 versione 971
///////////////////////////////////////////////////////////
bool TConvert_app::cnv_basebis_971() const
{
	// titolo log
  char now[9];
  TDate today(TODAY);  
  TString log_title("[Log Conversione base : ");
  log_title << today << " " << _strtime(now) << "]  Prassi SpA";               
  _M770_log->append(log_title);	
  TString log_space(" ");
  _M770_log->append(log_space);	

  TLocalisamfile bb(LF_BASEBIS);
  TProgind pi(bb.items(), "Conversione modello base", FALSE, TRUE, 60);
  for (bb.first(); bb.good(); bb.next())
  {
    pi.addstatus(1);
    
    // lettura campi soggetti a modifica
    TString qcomp = bb.get("QCOMP"); 
    
    // sistemazione flag quadri compilati come flag quadri inviati/ricevuti
    const int Lpos = 19;
    TString newqcomp;
    newqcomp.spaces(29);
    int nchar = qcomp.len() < Lpos ? qcomp.len() : Lpos;
    for (int i=0; i<nchar; i++)
    	newqcomp[i] = qcomp[i];    	 
    for (i=Lpos; i<qcomp.len(); i++)
    	if ((i+1)<newqcomp.len())
    		newqcomp[i+1] = qcomp[i];	
    
		// update campi modificati
    bb.put("QCOMP",newqcomp);// flag quadri compilati
    
    // riscrittura record 
    bb.rewrite();
  }
  // fine log
  _M770_log->append(log_space);  
  
  return TRUE;            
}

///////////////////////////////////////////////////////////
// Programma di conversione archivi 770
///////////////////////////////////////////////////////////

int main(int argc,char** argv)
{
  const int r = (argc > 1) ? abs(atoi(argv[1])) : -1;
  
  if (r < 0 || r > 6)
  {
    error_box(usage);
    exit(1);
  }
  else
  {
    const int f = (argc > 2) ? atoi(argv[2]) : -1;
    if (f == 0)
    {
      TConvert_app a(r) ;
      a.run(argc, argv, "Conversione archivi 770");
    }
    else
      exit(0);
  }

  return 0;
}