#include <progind.h>

#include "../ve/velib.h"
#include "../ve/velib04.h"

#include "calib01.h"
#include "calib02.h"
#include "ca3883.h"

#include "movana.h"
#include "rmovana.h"
#include "panapdc.h"
#include "commesse.h"
#include "fasi.h"
#include "saldana.h"
////////////////////////////////////////////////////////////////////////////////////////
// Classe per ricavare l'indicatore di bilancio dei conti analitici riclassificati e non
////////////////////////////////////////////////////////////////////////////////////////
TObject* TIndbil_cache::key2obj(const char* key)
{
	TString80 conto = key;
	if (_usepdcc && conto.len() == 12 && real::is_natural(conto))
	{
		TLocalisamfile panapdc(LF_PANAPDC);
		panapdc.setkey(2);
		const int gr = atoi(conto.left(3));
		const int co = atoi(conto.mid(3,3));
		const long so = atol(conto.mid(6,6));

		TRectype& panapdrec = panapdc.curr();
    int i;
		for (i = 2; i >= 0; i--)
		{
			panapdrec.zero();
			panapdrec.put(PANAPDC_GRUPPO, gr);
			if (i > 0)
				panapdrec.put(PANAPDC_CONTO, co);
			if (i == 2)
				panapdrec.put(PANAPDC_SOTTOCONTO, so);

			//occhio al prefisso!
			panapdrec.put(PANAPDC_CODCONTO, _prefix);

			if (panapdc.read(_isgteq) == NOERR)
			{
				bool found = panapdrec.get_int(PANAPDC_GRUPPO) == gr;
				if (found)
  				found = panapdrec.get_int(PANAPDC_CONTO) == (i > 0 ? co : 0);
			  if (found)
				  found = panapdrec.get_long(PANAPDC_SOTTOCONTO) == (i > 1 ? so : 0L);
				if (found && _prefix.full())
					found = panapdrec.get(PANAPDC_CODCONTO).starts_with(_prefix);

				if (found)
				{
				  conto = panapdrec.get(PANAPDC_CODCONTO);
          if (cache().get(LF_PCONANA, conto).empty())
            error_box(FR("Non esiste piu' il conto %s cui era legato %d %d %ld"), 
                      (const char*)conto, gr, co, so);
          else
				    break;
				}
			}
		}
		//se non trova il corrispondente conto analitico azzera il conto per il prossimo giro
		if (i < 0)
			conto.cut(0);
	}
	//conto analitico
	TAnal_bill bill(conto);
	int indbil = bill.indicatore_bilancio();
	TToken_string* ib = new TToken_string;
	*ib << indbil;
	ib->add(conto);
	return ib;
}

int TIndbil_cache::get_indbil(const TString& conto, TString& conto_anale)
{
  int indicatore = 0;
	TToken_string* ib = (TToken_string*)objptr(conto);
	if (ib != NULL)
  {
	  indicatore = ib->get_int(0);
		ib->get(1, conto_anale);
  }
  return indicatore;
}

void TIndbil_cache::set_prefix(const char* prefix)
{
	if (_prefix != prefix)
	{
		_prefix = prefix;
		destroy();
	}
}

TIndbil_cache::TIndbil_cache()
{
	TConfig& cfg = ca_config();
	_usepdcc = cfg.get_bool("UsePdcc");
}



///////////////////////////////////////////////////////////////////
// roba del recordset
///////////////////////////////////////////////////////////////////
const TFixed_string CMS_DEL_CAZZO("@@@@@@@@@@@@@@@@@@@@");

static int righe_compare(const TObject** o1, const TObject** o2)
{
  TAssoc_array& a1 = *(TAssoc_array*)*o1;
  TAssoc_array& a2 = *(TAssoc_array*)*o2;

  int cmp = 0;

  const int l1 = atoi(*(TString*)a1.objptr("LEVEL"));
  const int l2 = atoi(*(TString*)a2.objptr("LEVEL"));
  cmp = l1 - l2;
  if (cmp == 0)
  {
    const TString& c1 = *(TString*)a1.objptr("CODCMS");
    const TString& c2 = *(TString*)a2.objptr("CODCMS");
    cmp = c1.compare(c2);
    if (cmp == 0)
    {
      const TString& f1 = *(TString*)a1.objptr("FASE");
      const TString& f2 = *(TString*)a2.objptr("FASE");
      cmp = f1.compare(f2);
      if (cmp == 0)
      {
        const TString& d1 = *(TString*)a1.objptr("CDC");
        const TString& d2 = *(TString*)a2.objptr("CDC");
        cmp = d1.compare(d2);
      }
      else
      {
        const int z1 = c1.starts_with("detr_");
        const int z2 = c2.starts_with("detr_");
        if (z1 || z2)
          cmp = z1 - z2;
      }
    }
  }

  return cmp;
}


//////////////////////////////////////////////////////////////////////////////////////
//Classe di recordset speciale per stampe con saldana, rmovana, rdoc (ca3800, ca3900)
//////////////////////////////////////////////////////////////////////////////////////
bool TPrint_saldana_recordset::move_to(TRecnotype pos)
{
	_curr = pos;
	return pos >= 0 && pos < items();
}

void TPrint_saldana_recordset::parse_bill(const TString& bill, TString& conto) const
{
	TConfig& cfg = ca_config();
  const TMultilevel_code_info& pconana_info = ca_multilevel_code_info(LF_PCONANA);
  const int pconana_levels = pconana_info.levels();  
  const int prefix = cfg.get_int("PdcPrefix")-1;

	//lunghezza dell'eventuale prefisso di gruppo e conto
	const int prefix_len = (prefix >= 0) ? pconana_info.total_len(prefix) : 0;
	//quanto e' lungo il codice del conto da considerare? E' il livello - il prefisso
	const int conto_end = pconana_info.total_len(_depth) - prefix_len;

	//stringa con cio' che segue il prefisso ed e' richiesto
	conto = bill.mid(prefix_len, conto_end);
}

int TPrint_saldana_recordset::estrai_saldi(const TRectype& saldana, const int indbil, 
																					 TImporto& saldo, TImporto& saldop, const bool cms_detraz,
                                           const bool is_totale) const
{
	int flag = 0;
  saldo.reset();
  saldop.reset();

  //stampa bilancio di commessa ca3800 (_tipo=8)
  if (_tipo == 8)
  {

    switch (_tipostima)
    {
    case 'R': //CostiConsuntivi RicaviConsuntivi (Cc/Rc)  (le detrazioni saranno ovviamente sempre e solo consuntive)
      {
        const TImporto imp_saldo(saldana.get_char(SALDANA_SEZIONE), saldana.get_real(SALDANA_SALDO));
        const TImporto imp_saldop(saldana.get_char(SALDANA_SEZIONEP), saldana.get_real(SALDANA_SALDOP));
        const TImporto imp_saldov(saldana.get_char(SALDANA_SEZIONEV), saldana.get_real(SALDANA_SALDOV));
        if (!imp_saldo.is_zero() || !imp_saldop.is_zero() || !imp_saldov.is_zero())
        {
          if (indbil == 3)  //indbil=3 costi
          {
	          saldo = imp_saldo;
 	          flag = 1;
          }
          else  //indbil=4 ricavi
          {
            //nel caso sia il calcolo di un totale, il totale dei ricavi va sempre preso per budget!
            //Richiesta Adolfo-Enrichettica del 24-03-2011 (prima il totale dei ricavi era sul maturato)
            if (is_totale)
            {
              saldop = imp_saldop;
              saldop += imp_saldov;
            }
            else
            {
              saldop = imp_saldo;
            }
            flag = 2;
          }
        }
      }
      break;

    case 'C': //CostiConsuntivi RicaviPreventivi (Cc/Rp)
      {
        if (indbil == 3)  //costi: sempre e solo consuntivi, sia righe commessa che detrazione
        {
          const TImporto imp_saldo(saldana.get_char(SALDANA_SEZIONE), saldana.get_real(SALDANA_SALDO));
	        saldo = imp_saldo;
	        flag |= saldo.is_zero() ? 0 : 1;
        }
        else  //indbil=4 ricavi: preventivi per righe commessa, consuntivi o preventivi per detrazioni (dipende da scelta utente)
        {
          if (cms_detraz && _detrazioni_consuntive)
          {
            const TImporto imp_saldo(saldana.get_char(SALDANA_SEZIONE), saldana.get_real(SALDANA_SALDO));
            saldo = imp_saldo;
            flag |= saldo.is_zero() ? 0 : 1;
          }
          else
          {
            const TImporto imp_saldop(saldana.get_char(SALDANA_SEZIONEP), saldana.get_real(SALDANA_SALDOP));
		        const TImporto imp_saldov(saldana.get_char(SALDANA_SEZIONEV), saldana.get_real(SALDANA_SALDOV));
		        saldop = imp_saldop;
		        saldop += imp_saldov;
		        flag |= saldop.is_zero() ? 0 : 2;
          }
        }
      }
      break;

    case 'T': //CostiPreventivi RicaviPreventivi (Cc/Rp) = Tempo
      //nel caso stia calcolando le detrazioni di anni precedenti (cms_detraz) va sempre preso il consuntivo!!
      if (cms_detraz && _detrazioni_consuntive)
      {
        const TImporto imp_saldo(saldana.get_char(SALDANA_SEZIONE), saldana.get_real(SALDANA_SALDO));
        saldo = imp_saldo;
        flag |= saldo.is_zero() ? 0 : 1;
      }
      else  //in tutti gli altri casi vanno bene i preventivi
      {       
      	const TImporto imp_saldop(saldana.get_char(SALDANA_SEZIONEP), saldana.get_real(SALDANA_SALDOP));
		    const TImporto imp_saldov(saldana.get_char(SALDANA_SEZIONEV), saldana.get_real(SALDANA_SALDOV));
		    saldop = imp_saldop;
		    saldop += imp_saldov;
		    flag |= saldop.is_zero() ? 0 : 2;
      }
      break;

    } //switch (_tipostima)...

  } //if(_tipo=8...
  // stampa stima ricavi ca3900 (_tipo=9)
  else
  {
    const TImporto imp_saldo(saldana.get_char(SALDANA_SEZIONE), saldana.get_real(SALDANA_SALDO));
		saldo = imp_saldo;
		flag |= saldo.is_zero() ? 0 : 1;

		const TImporto imp_saldop(saldana.get_char(SALDANA_SEZIONEP), saldana.get_real(SALDANA_SALDOP));
		const TImporto imp_saldov(saldana.get_char(SALDANA_SEZIONEV), saldana.get_real(SALDANA_SALDOV));
		saldop = imp_saldop;
		saldop += imp_saldov;
		flag |= saldop.is_zero() ? 0 : 2;

    /* correzione per ottenere la sezione in base all'indicatore di bilancio
    inutile per ora...
    const char sezione_positiva = (indbil == 2 || indbil == 3) ? 'D' : 'A';
    saldo.normalize(sezione_positiva);
    saldop.normalize(sezione_positiva);*/
  }
  return flag;
}

TAssoc_array& TPrint_saldana_recordset::get_row(TAssoc_array& cms, const char* chiave,
																										 const int indice, const TString& codcms, const TString& fase,
																										 const TString& cdc, const TString& descrizione) const
{
	//cerca se la commessa (e l'eventuale fase) esistono gia' nell'assocarray delle commesse
	TAssoc_array* riga_array = (TAssoc_array*)cms.objptr(chiave);
	//se non esiste la crea!
	if (riga_array == NULL)
	{
  	riga_array = new TAssoc_array;

		TString4 str_indice;	//l'indice va stringato per l'assoc_array
	  str_indice << indice;
		
		riga_array->add("LEVEL", str_indice);
		riga_array->add("CODCMS", codcms);
    if (_tipo == 8)
    {
		  riga_array->add("FASE", fase);
      riga_array->add("CDC", cdc);
    }

		riga_array->add("DESCRIZ", descrizione);
    //inizializza i campi importo sicuramente presenti (modifica DECISIVA)
    //senza questa inizializzazione, nel caso trovasse campi nulli (in realta' 0), il bastardo..
    //..anziche' considerarli 0 ci mette l'ultimo valore != che ha in memoria nella stessa posizione..
    //..facendo sballare tutti i conti!
    //bilancio commessa ca3800 (_tipo=8)
    if (_tipo == 8)
    {
      riga_array->add("RICAVI", EMPTY_STRING);
      riga_array->add("COSTI", EMPTY_STRING);
    }
    //stima ricavi ca3900 (_tipo=9)
    else
    {
      riga_array->add("COS_BDG", EMPTY_STRING);
      riga_array->add("COS_MAT", EMPTY_STRING);
      riga_array->add("RIC_BDG", EMPTY_STRING);
      riga_array->add("RIC_MAT", EMPTY_STRING);
    }
		
		//aggiunge la riga all'array-one
		cms.add(chiave, riga_array);
	}
	return *riga_array;
}

//for ca3800 only!
void TPrint_saldana_recordset::aggiorna_importo(TAssoc_array& riga_array, const TString& livello, 
     const int indbil, const TRectype& saldana, const bool is_detrazione, const bool is_totale) const
{
	TString* str_imp = (TString*)riga_array.objptr(livello);
	if (str_imp == NULL)
	{
		str_imp = new TString;
		riga_array.add(livello, str_imp);
	}

	//dare o avere?
	const char sezione = indbil == 3 ? 'D' : 'A';
	TImporto imp(sezione, real(*str_imp));

	//ci sono tutti i tipi di saldo, ma solo quelli che rientrano nei parametri iniziali..
	//..verranno considerati (_tipostima,indbil)
	TImporto imp_saldo, imp_saldop;
  estrai_saldi(saldana, indbil, imp_saldo, imp_saldop, is_detrazione, is_totale);

	if (is_detrazione)  // Se � una detrazione deve sottrarre l'importo = scambia la sezione
	{
  	imp_saldo.swap_section();
	  imp_saldop.swap_section();
	}
  imp += imp_saldo;
	imp += imp_saldop;

	imp.normalize(sezione);
	*str_imp = imp.valore().string();
}

//for ca3800 only!
real TPrint_saldana_recordset::calcola_avanzamento_tempo() const
{
  real avanzamento;

  TDate dataini, datafine;
  const TString& codfase = get("FASE").as_string();
  const TString& codcdc = get("CDC").as_string();

  //fase specificata (si usa l'avanzamento sulla fase solo se questa dipende dalle commesse; se fosse indipendente..
  //..basare l'avanzamento su di essa sarebbe assurdo (le fasi indipendenti non possono avere datainizio e datafine)
  if (codfase.full() && ca_config().get("FathFasi") == "CMS")
  {
	  const TRectype& rec_fasi = cache().get(LF_FASI, codfase);

	  dataini = rec_fasi.get(FASI_DATAINIZIO);
	  datafine = rec_fasi.get(FASI_DATAFINE);
  }
  if (!dataini.ok())
  {
	  const TString& codcms = get("CODCMS").as_string();
	  const TRectype& rec_commesse = cache().get(LF_COMMESSE, codcms);

    ca_durata_commessa(rec_commesse, dataini, datafine);
  }

	//Si prende la data fine (detta _datacalcolo) perch� si vuole la situazione alla data (eventualmente tale data �..
	//..la fine dell'esercizio)
	if (datafine < _datacalcolo)
		avanzamento = CENTO;
	//se invece prosegue anche dopo la data di fine...
	else
	{
		const long time_gone = _datacalcolo - dataini;
		const long durata = datafine - dataini;
		avanzamento = ((real)(time_gone * CENTO) / durata);
	}
  return avanzamento;
}

//for ca3900 only!
void TPrint_saldana_recordset::incrementa_importo(TAssoc_array& riga_array, 
		 const TString& livello, const int indbil, const TImporto& saldo, const bool inverti) const
{
	TString* str_imp = (TString*)riga_array.objptr(livello);
	if (str_imp == NULL)
	{
		str_imp = new TString;
		riga_array.add(livello, str_imp);
	}

	//dare o avere?
	const char sezione = indbil == 3 ? 'D' : 'A';
	TImporto imp(sezione, real(*str_imp));

	if (inverti)  // Devo sottrarre l'importo = gli scambio la sezione
  	imp -= saldo;
	else
    imp += saldo;

	imp.normalize(sezione);
	*str_imp = imp.valore().string();
}

//metodo usato solo per la stima ricavi ca3900 (_tipo=9)
void TPrint_saldana_recordset::aggiorna_importi(TAssoc_array& riga_array, 
		         const int indbil, const TRectype& saldana, const int tempo) const
{
  const bool is_detrazione = tempo < 0;
  const bool is_prev_futuro = tempo > 0;
  const bool inverti = is_detrazione;

	TString8 livello;

	TImporto imp_saldo, imp_saldop;

  estrai_saldi(saldana, indbil, imp_saldo, imp_saldop, false, false);

  //richiesta Dinamica-Crpa: nelle detrazioni comandano sempre i maturati (quindi i saldo); i preventivi..
  //..vengono posti uguali ai maturati d'ufficio
  if (is_detrazione)
    imp_saldop = imp_saldo;
  else
  {
    if (is_prev_futuro)
      imp_saldo.reset();
  }

	//saldi normali:Maturato
	if (!imp_saldo.is_zero())
	{
	  livello.format("%s_MAT", indbil == 3 ? "COS" : "RIC");
		incrementa_importo(riga_array, livello, indbil, imp_saldo, inverti);
	}
	//saldi preventivi:Budget
	if (!imp_saldop.is_zero())
	{
	  livello.format("%s_BDG", indbil == 3 ? "COS" : "RIC");
		incrementa_importo(riga_array, livello, indbil, imp_saldop, inverti);
	}
}


//trova la sezione del report in cui ricade in base alle date
int TPrint_saldana_recordset::ricava_sezione_di_stampa(const TRectype& rec_commesse, 
                                                       const TDate& datainiesc, const TDate& datafinesc) const
{
  int indice = -1;

  //data iniziale commessa
	TDate dataini, datafine;
  ca_durata_commessa(rec_commesse, dataini, datafine);

  //Le commesse vengono suddivise in varie sezioni in base alle loro date di inizio/fine/proroga..
  //..e al fatto che possono essere di appoggio (Adolf rikiesten!) secondo lo schema:
  //  _ 0 terminano nell'anno selezionato / iniziate nel passato
  //  _ 1 terminano nell'anno selezionato / iniziate nell'anno selezionato
  //  _ 2 terminano nel futuro / iniziate nel passato
  //  _ 3 terminano nel futuro / iniziate nell'anno selezionato
  //  _ 4 di appoggio / terminano nell'anno selezionato / iniziate nell'anno selezionato 
  //      (indice 1 ma di appoggio in pratica)
	
  //e' inutile considerare le commesse terminate prima dell'esercizio selezionato..
	//..cioe' nel passato oppure che iniziano nel futuro!
	if (datafine >= datainiesc && dataini <= datafinesc)
	{
    //indice e' il parametro che stabilisce in quale sezione del report viene stampata la commessa
    //se la commessa termina prima della fine dell'esercizio selezionato -> indice 0, altrimenti..
    //..indice 2
		indice = datafine <= datafinesc ? 0 : 2;
    //se poi la commessa inizia dopo la data inizio esercizio selezionato -> l'indice va incrementato..
    //..di una unita' (viene spostata nella sezione di stampa successiva)
		if (dataini >= datainiesc)
			indice++;

    //controlla se la commessa e' di appoggio e di indice 1 (inizia e finisce nell'anno selezionato)
    //in questo caso la commessa ha indice 4 e va nella sezione distaccata in fondo al report (Adolf!)
    if (indice == 1)
    {
      const bool cms_appoggio = rec_commesse.get_bool(COMMESSE_APPOGGIO);
      if (cms_appoggio)
        indice = 4;
    }
  }
  return indice;
}

void TPrint_saldana_recordset::ricava_chiave_cdc_fase(const TString& codcms, const TString& fase, const TString& cdc, TString& chiave) const
{
  //ci sono filtri o raggruppamenti per fase o centro di costo?
  chiave = codcms;
  //selezione fasi solo su bilancio commessa (_tipo=8)
  if (_tipo == 8 && (_tipostampa >= 1 && _tipostampa <= 3))
  {
    //se vuole entrambi i livelli di dettaglio occorre sapere chi e' il babbo delle fasi o dei cdc
    if (_tipostampa == 3)
    {
      //le fasi sono figlie dei cdc?
      if (ca_multilevel_code_info(LF_FASI).parent() == LF_CDC)
        chiave << '|' << cdc << '|' << fase;
      else  //in ogni altro caso (figlie delle commesse o di nessuno...)
		    chiave << '|' << fase << '|' << cdc;
    }
    else  //livelli di dettaglio semplici
    {
      if (_tipostampa == 1)
		    chiave << '|' << fase;    //dettaglia x fase
      else
        chiave << '|' << cdc;     //dettaglia x cdc
    }
  }
}


const TDate TPrint_saldana_recordset::calcola_min_datacomp(const TDate& datainiesc, const TDate& datafinesc) const
{
  TDate data_min_comp = datainiesc;
  TISAM_recordset recset("USE COMMESSE");
  const TRectype& rec_commessa = recset.cursor()->curr();
  for (bool ok = recset.move_first(); ok; ok = recset.move_next())
  {
    TDate dataini, datafine;
    ca_durata_commessa(rec_commessa, dataini, datafine);
    if (datafine >= datainiesc && dataini < data_min_comp)
      data_min_comp = dataini;
  }
  return data_min_comp;
}


const TString& TPrint_saldana_recordset::crea_select(const int logicnum)
{
  TString select = ca_create_user_select_clause(logicnum);
  //void ca_append_and(TString& query, const TString& clause)
  switch (_tipostampa)
  {
  case 0: break;
  case 1:
  case 4:
    if (_fase.full())
    {
      TString clause;
      clause << ca_dollar2fieldname(logicnum, "$(FAS)") << "=\"" << _fase << "\"";
      ca_append_and(select, clause);
    }
    break;
  case 2:
  case 8:
    if (_cdc.full())
    {
      TString clause;
      clause << ca_dollar2fieldname(logicnum, "$(CDC)") << "=\"" << _cdc << "\"";
      ca_append_and(select, clause);
    }
    break;
  case 3:
    if (_fase.full() || _cdc.full())
    {
      TString clause;
      if (_fase.full() && _cdc.full())
        clause << "(" << ca_dollar2fieldname(logicnum, "$(FAS)") << "=\"" << _fase
               << "\")&&(" << ca_dollar2fieldname(logicnum, "$(CDC)") << "=\"" << _cdc << "\")";
      else
      {
        if (_fase.full())
          clause << ca_dollar2fieldname(logicnum, "$(FAS)") << "=\"" << _fase << "\"";
        else
          clause << ca_dollar2fieldname(logicnum, "$(CDC)") << "=\"" << _cdc << "\"";
      }
      ca_append_and(select, clause);
    }      
    break;
  }

  return get_tmp_string() = select;
}


//crea la query base per la scansione dei SALDANA; si usa nelle parse_saldana e parse_saldana_futuri
const TString& TPrint_saldana_recordset::crea_query_saldana()
{
  const TString& select = crea_select(LF_SALDANA);

  TString query;
	query = "USE SALDANA";

  if (select.full())
    query << " SELECT " << select;

  return get_tmp_string() = query;
}


//aggiorna l'arrayone cms con i saldana
void TPrint_saldana_recordset::parse_saldana(TAssoc_array* cms, const TDate& datainiesc, const TDate& datafinesc)
{
  TString query;

  //se ca3800...
  if (_tipo == 8)
  {
    query = crea_query_saldana();

    //stampa standard non a vita intera per la 3800
    if (!_vitaintera)
    {
      TEsercizi_contabili esc;
	    TDate datainiesc, datafinesc;
	    esc.code2range(_anno, datainiesc, datafinesc);
      query << "\nTO ANNO=";
      //ACHTUNG! Se non si sceglie l'intero esercizio corrente i saldi sono quelli finali dell'esercizio precedente!
      //Saranno poi integrati dai saldi volanti creati da movana e doc
      if (_datacalcolo == datafinesc)
	      query << _anno;
      else
        query << (_anno - 1);
    }
  } //if(_tipo==8..


  if (_tipo == 9)
  {
    //non vanno considerati saldi di esercizi futuri a quello scelto!!!
	  query = "USE SALDANA";
  }

  TISAM_recordset saldana_set(query);
  const TRectype& saldana = saldana_set.cursor()->curr();

	const long saldana_items = saldana_set.items();

	TProgind pi(saldana_items, "Scansione saldi correnti...", true, true);

	for (bool ok = saldana_set.move_first(); ok; ok = saldana_set.move_next())
	{
		//progind tanto per gradire
    if (!pi.addstatus(1))
      break;

		const TString& codconto = saldana.get(SALDANA_CONTO);
		//trova l'indicatore di bilancio
		TString80 conto_anale;

    const int indbil = _indicatori.get_indbil(codconto, conto_anale);
		//solo i Costi(3) ed i Ricavi(4) devono essere considerati per la stampa
		if (indbil == 3 || indbil == 4)
		{
      //gruppo e conto servono solo per il caso _tipo=8 ma vanno dichiarati e ricavati..
      //..qui in modo che siano a disposizione delle commesse del cazzo poco sotto
      const char* gruppo = indbil == 3 ? "COSTI" : "RICAVI";
      TString80 conto;
		  parse_bill(conto_anale, conto);

      //estrae i dati di commessa e le date relative;le date servono successivamente per stabilire...
      //..le sezioni in cui compariranno le commesse nella stampa
    	const TString80 codcms = saldana.get(SALDANA_COMMESSA);
      const TRectype& rec_commesse = cache().get(LF_COMMESSE, codcms);
      //indice: indica la sezione di report in cui apparariranno i valori!
      const int indice = ricava_sezione_di_stampa(rec_commesse, datainiesc, datafinesc);
      //anno sul record di saldana;serve un p� dappertutto sotto
      const int anno_saldo = saldana.get_int(SALDANA_ANNO);
			
      //e' inutile considerare le commesse terminate prima dell'esercizio selezionato..
			//..cioe' nel passato oppure che iniziano nel futuro! Solo le commesse con indice non..
      //..negativo sopravvivono!
			if (indice >= 0)
			{
        //ci sono filtri o raggruppamenti per fase o centro di costo?
        const TString80 fase = saldana.get(SALDANA_FASE);
        const TString80 cdc = saldana.get(SALDANA_COSTO);
        //ricava la chiave completa per l'assoc_array comprendendo eventuali fasi e/o cdc
        TString80 chiave;
        ricava_chiave_cdc_fase(codcms, fase, cdc, chiave);

				//riempie le righe degli array da mandare poi in stampa
				//dapprima le righe normali..
        //bilancio di commessa ca3800 (_tipo=8)
        if (_tipo == 8)
        {
          TAssoc_array& riga_array = get_row(cms[indice], chiave, indice, codcms, fase, cdc,
																					   rec_commesse.get(COMMESSE_DESCRIZ));

				  //aggiunge gli importi e normalizza
				  aggiorna_importo(riga_array, gruppo, indbil, saldana);
				  aggiorna_importo(riga_array, conto, indbil, saldana);

          //aggiorna totali della commessa (importi per codcms senza tener conto di fase o cdc)
          TAssoc_array& riga_tot = get_row(_totali[indice], codcms, indice, codcms, EMPTY_STRING, EMPTY_STRING,
																					 gruppo);
#ifdef DBG
          if (codcms == "FP10VB22388OP" && indbil == 4)
            int cazzone = 1;
#endif
				  aggiorna_importo(riga_tot, gruppo, indbil, saldana, false, true);
        }
        //stima ricavi ca3900 (_tipo=9)
        else
        {
          TAssoc_array& riga_array = get_row(cms[indice], chiave, indice, codcms, EMPTY_STRING, EMPTY_STRING, 
																					   rec_commesse.get(COMMESSE_DESCRIZ));
          //aggiunge gli importi e normalizza
          if (anno_saldo > _anno) // gestione saldo nel futuro
          {
            if (indice > 1) // considera i saldop solo se � una commessa che termina nel futuro!
              aggiorna_importi(riga_array, indbil, saldana, anno_saldo - _anno);
          }
          else
  		      aggiorna_importi(riga_array, indbil, saldana, 0); // gestione saldo passato e presente

        } //if(tipo==8)

			}	//if (datafine >= datainiesc &&...


  		//RIGHE COMMESSA DETRAZIONE: esistono solo se la commessa e' iniziata prima dell'anno
			//selezionato e se ha a che fare con quello in corso,quindi l'indice e' 0 o 2
      //indice � stato ricavato un tot di righe addietro...
      if (indice == 0 || indice == 2)
			{
				//aggiorna il record speciale con la somma dei saldi con anno anteriore a quello..
				//..selezionato sulla maschera (CRPA request)
				if (anno_saldo < _anno)
				{
					TString16 cazzo_cod; cazzo_cod.format("detr_al_%04d", _anno - 1);  
					TString cazzo_descr = "DETRAZIONE PER COMPETENZA FINO AL ";
					cazzo_descr << (_anno - 1);
          TAssoc_array& riga_array = get_row(cms[indice], CMS_DEL_CAZZO, indice, cazzo_cod, 
																						 EMPTY_STRING, EMPTY_STRING, cazzo_descr);
          if (_tipo == 8)
          {
            //calcolo delle detrazioni (is_detrazione = true)
					  aggiorna_importo(riga_array, gruppo, indbil, saldana, true);
					  aggiorna_importo(riga_array, conto, indbil, saldana, true);
          }
          else
          {
					  aggiorna_importi(riga_array, indbil, saldana, anno_saldo - _anno);
          }
				} //if(anno<_anno...
			}	//if(indice...

		}	//if (indbil == 3 ||...
	} //for(bool ok=saldana.move_first()..
}


//aggiorna l'arrayone cms con i saldana
void TPrint_saldana_recordset::parse_saldana_futuri()
{
  //calcola i saldi futuri per avere i totali da cui ricavare gli avanzamenti
  TString query = crea_query_saldana();

  TEsercizi_contabili esc;
  TDate datainiesc, datafinesc;
  esc.code2range(_anno, datainiesc, datafinesc);
  int anno = _anno;

  //se la datacalcolo coincide con la data finale dell'esercizio i saldi futuri partono dall'anno successivo
  if (_datacalcolo == datafinesc)
    anno++;

  query << "\nFROM ANNO=" << anno;

  TISAM_recordset saldana_set(query);
  const TRectype& saldana = saldana_set.cursor()->curr();

	const long saldana_items = saldana_set.items();

	TProgind pi(saldana_items, "Scansione saldi futuri...", true, true);

	for (bool ok = saldana_set.move_first(); ok; ok = saldana_set.move_next())
	{
		//progind tanto per gradire
    if (!pi.addstatus(1))
      break;

		const TString& codconto = saldana.get(SALDANA_CONTO);
		//trova l'indicatore di bilancio
		TString80 conto_anale;

    const int indbil = _indicatori.get_indbil(codconto, conto_anale);
		//solo i Costi(3) ed i Ricavi(4) devono essere considerati per la stampa
		if (indbil == 3 || indbil == 4)
		{
      //gruppo e conto servono solo per il caso _tipo=8 ma vanno dichiarati e ricavati..
      //..qui in modo che siano a disposizione delle commesse del cazzo poco sotto
      const char* gruppo = indbil == 3 ? "COSTI" : "RICAVI";
      TString80 conto;
		  parse_bill(conto_anale, conto);

			TImporto saldo, saldop;

			const int flag = estrai_saldi(saldana, indbil, saldo, saldop, false, true);

      //estrae i dati di commessa e le date relative;le date servono successivamente per stabilire...
      //..le sezioni in cui compariranno le commesse nella stampa
    	const TString& codcms = saldana.get(SALDANA_COMMESSA);
      const TRectype& rec_commesse = cache().get(LF_COMMESSE, codcms);
      //indice: indica la sezione di report in cui apparariranno i valori!
      const int indice = ricava_sezione_di_stampa(rec_commesse, datainiesc, datafinesc);
			
      //e' inutile considerare le commesse terminate prima dell'esercizio selezionato..
			//..cioe' nel passato oppure che iniziano nel futuro! Solo le commesse con indice non..
      //..negativo sopravvivono!
			if (indice >= 0)
			{
        //ci sono filtri o raggruppamenti per fase o centro di costo?
        const TString& fase = saldana.get(SALDANA_FASE);
        const TString& cdc = saldana.get(SALDANA_COSTO);
        //ricava la chiave completa per l'assoc_array comprendendo eventuali fasi e/o cdc
        TString80 chiave;
        ricava_chiave_cdc_fase(codcms, fase, cdc, chiave);

        //aggiorna totali della commessa (importi per codcms senza tener conto di fase o cdc)
        TAssoc_array& riga_tot = get_row(_totali[indice], codcms, indice, codcms, EMPTY_STRING, EMPTY_STRING,
																				 gruppo);
			  aggiorna_importo(riga_tot, gruppo, indbil, saldana, false, true);
      }
    }
  }
}

/////////////////////////////////////////////
//    RIGHE MOVIMENTI ANALITICI
/////////////////////////////////////////////
//elabora realmente la riga analitica che gli viene passata (serve sia per le rmovana pure (chiamata dalla parse_rmovava())..
//..che per quelle create contabilizzando un documento (chiamata dalla parse_rdoc_ordini())
void TPrint_saldana_recordset::elabora_rmovana(TAssoc_array* cms, const TDate& datainiesc, const TDate& datafinesc, 
                                               const TRectype& movana, const TRectype& rmovana)
{
  const char tipomov = movana.get_char(MOVANA_TIPOMOV);
  //la data iniziale � la datacomp sulla testata per tutte le righe
  const TDate datacomp = movana.get_date(MOVANA_DATACOMP);

  const TString& codcms = rmovana.get(RMOVANA_CODCMS);
  const TRectype& rec_commesse = cache().get(LF_COMMESSE, codcms);
  const int indice = ricava_sezione_di_stampa(rec_commesse, datainiesc, datafinesc);

  //solo le righe con commessa buona (indice >= 0) vengono considerate
  if (indice >= 0)
  {
    //ci sono filtri o raggruppamenti per fase o centro di costo?
    const TString& fase = rmovana.get(RMOVANA_CODFASE);
    const TString& cdc = rmovana.get(RMOVANA_CODCCOSTO);
    //se la riga � risultata buona ricava la chiave completa per l'assoc_array comprendendo eventuali..
    //..fasi e/o cdc
    TString80 chiave;
    ricava_chiave_cdc_fase(codcms, fase, cdc, chiave);

    //calcola la "durata complessiva" della riga, ovvero l'intervallo di tempo per cui essa risulta valida
    //la data fine ci fa sudare un p�
    //di base � pari a datafcomp di testata (che � sempre esistente, mal che vada � uguale a datacomp)
    TDate datafcomp = movana.get_date(MOVANA_DATAFCOMP);
    //se invece � un movimento cazzuto con il calcolo automatico della data di morte (dataexpire)...
    if (movana.get_bool(MOVANA_AUTOFCOMP))
    {
      //data del cazzo che serve per non rovinare datacomp, che � la data sulla riga, non quella iniziale di cms
      TDate datainicms;   
      ca_durata_commessa(rec_commesse, datainicms, datafcomp);
    }
    //se siamo in presenza di un movimento senza datafcomp (inserito precdentemente alla nascita di datafcomp..
    //..per tutti i movimenti, come nel gestore dei movana mette datafcomp = datacomp;
    if (!datafcomp.ok())
      datafcomp = datacomp;

    //Attenzionissima! Se il movimento presenta una data fine competenza anteriore all'inizio dell'esercizio considerato..
    //..va scartato perch� sar� incluso nei saldi finali dell'esercizio precedente!
    if (datafcomp < datainiesc)
      return;

    //finalmente la tanto agognata vita della riga di movana!
    //si aggiunge 1 perch� se un movimento ha datacomp=datafcomp (come in generale accade) in realt�..
    //..il poveretto vive un giorno, non 0
    const long vita_totale_riga = datafcomp - datacomp + 1;

    //riproporzionamento dell'importo di riga in base alla frazione di vita di riga interessata
    real importo = rmovana.get_real(RMOVANA_IMPORTO);

    if (vita_totale_riga > 1)
    {
      //trova la frazione di vita della riga che interessa l'esercizio corrente
      const TDate inizio_inter = fnc_max(datainiesc, datacomp);
      const TDate fine_inter = fnc_min(_datacalcolo, datafcomp);
      //si aggiunge anche qui 1 per gli stessi motivi della vita_totale
      const long vita_frazione_riga = fine_inter - inizio_inter + 1;

      //il riproporzionamento vale solo per i movimenti che durano pi� di 1 giorno e con una vita_frazione..
      //..< vita_totale (il contrario sarebbe un errore!). I movimenti tutti nel futuro risultano con..
      //..vita_frazione negativa e quindi non sono considerati
      //Anche le commesse tutte nel futuro rispetto a datacalcolo danno origine a una vita_frazione negativa..
      //..parando il culo al povero programma
      if (vita_frazione_riga > 1 && vita_frazione_riga < vita_totale_riga)
      {
        importo = vita_frazione_riga * importo / vita_totale_riga;
        importo.round(2);
      }
    }

    //dopo tutto sto panegirico sul riproporzionamento finalmente si passa ad aggiornare gli array di stampa..
    //..con gli importi aggiustati
    if (!importo.is_zero())
    {
#ifdef DBG
      if (codcms == "")
        const int cazzone = 1;
#endif
      const TString& codconto = rmovana.get(RMOVANA_CODCONTO);
      //trova l'indicatore di bilancio
      TString80 conto_anale;

      const int indbil = _indicatori.get_indbil(codconto, conto_anale);
      //solo i Costi(3) ed i Ricavi(4) devono essere considerati per la stampa
      if (indbil == 3 || indbil == 4)
      {
        //gruppo e conto servono solo per il caso _tipo=8 ma vanno dichiarati e ricavati..
        //..qui in modo che siano a disposizione delle commesse del cazzo poco sotto
        const char* gruppo = indbil == 3 ? "COSTI" : "RICAVI";
        TString80 conto;
        parse_bill(conto_anale, conto);

        //importo della riga gi� eventualmente riproporzionato prima (e sicuramente > 0)
        const TImporto importo_riga(rmovana.get_char(RMOVANA_SEZIONE), importo);
        //riga array da aggiungere agli arrayoni da mandare in stampa
        TAssoc_array& riga_array = get_row(cms[indice], chiave, indice, codcms, fase, cdc,
																           rec_commesse.get(COMMESSE_DESCRIZ));

        TRectype saldana(LF_SALDANA);
        saldana.put(SALDANA_ANNO, _anno);
        saldana.put(SALDANA_CONTO, conto_anale);
        saldana.put(SALDANA_COSTO, cdc);
        saldana.put(SALDANA_COMMESSA, codcms);
        saldana.put(SALDANA_FASE, fase);

        switch(tipomov)
        {
        case 'P':
          saldana.put(SALDANA_SEZIONEP, importo_riga.sezione());
          saldana.put(SALDANA_SALDOP, importo_riga.valore());
          break;
        case 'V':
          saldana.put(SALDANA_SEZIONEV, importo_riga.sezione());
          saldana.put(SALDANA_SALDOV, importo_riga.valore());
          break;
        default:
          saldana.put(SALDANA_SEZIONE, importo_riga.sezione());
          saldana.put(SALDANA_SALDO, importo_riga.valore());

#ifdef DBG
          if (codcms == "")
          {
            ofstream movimenti("C:/temp/movimenti.txt", ios::app);
            movimenti << rmovana.get(RMOVANA_NUMREG) << '\t'
                   << rmovana.get(RMOVANA_DATACOMP) << '\t'
                   << rmovana.get(RMOVANA_IMPORTO) << '\t'
                   << rmovana.get(RMOVANA_SEZIONE) << '\t'
                   << importo_riga.valore() << '\t'
                   << importo_riga.sezione() << endl;
          }
#endif

          break;
        }

        //aggiunge gli importi e normalizza
        aggiorna_importo(riga_array, gruppo, indbil, saldana);
        aggiorna_importo(riga_array, conto, indbil, saldana);
      }
    }
  } //if(indice>=0)...
 
}


//aggiorna l'arrayone cms con le rmovana presenti nel periodo di calcolo dell'ultimo esercizio
void TPrint_saldana_recordset::parse_rmovana(TAssoc_array* cms, const TDate& datainiesc, const TDate& datafinesc)
{
  const TDate min_datacomp = calcola_min_datacomp(datainiesc, datafinesc);

  //cerca tutte le rmovana che soddisfano gli innumerevoli parametri
  TString query;
  query << "USE RMOVANA KEY 3\n";

  const TString& select = crea_select(LF_RMOVANA);
  if (select.full())
    query << " SELECT " << select;

  query << "\nJOIN MOVANA INTO NUMREG==NUMREG"
        << "\nFROM DATACOMP=#MINDATACOMP"
        << "\nTO DATACOMP=#DATACALCOLO";
  TISAM_recordset recset(query);
  recset.set_var("#DATACALCOLO", _datacalcolo);
  recset.set_var("#MINDATACOMP", min_datacomp);

  const TRecnotype recset_items = recset.items();
  //se ci sono movana che non expirano prima dell'inizio esercizio e la cui datacomp � anteriore a datacalcolo... 
  if (recset_items > 0)
  {
    //record correntemente in esame di rmovana e movana
    const TRectype& rmovana = recset.cursor()->curr();
    const TRectype& movana = recset.cursor()->curr(LF_MOVANA);

    //simpatica progind per intrattenere l'utonto
    TProgind pi(recset_items, "Scansione movimenti...", true, true);

#ifdef DBG
    {
      ofstream movimenti("C:/temp/movimenti.txt");
      movimenti << endl;
    }
#endif

    for (bool ok = recset.move_first(); ok; ok = recset.move_next())    //giro sui vari rmovana...
    {
      //aggiornamento progind intrattenitiva
      if (!pi.addstatus(1))
        break;

      //metodo per generare i saldi alla data della riga analitica in base alla vita della riga
      elabora_rmovana(cms, datainiesc, datafinesc, movana, rmovana);

   } //for(bool ok=recset.move_first()...
  } //if(recset_items>0...
}


//aggiorna l'arrayone cms con le righedoc non ancora contabilizzate
void TPrint_saldana_recordset::parse_rdoc_ordini(TAssoc_array* cms, const TDate& datainiesc, const TDate& datafinesc)
{
  //solo le numerazioni con almeno un tipo documento ordine interessano
  TString_array num_ordini, tip_ordini;
  const int numerazioni_tipo_ordine = numerazioni_ordini(num_ordini, tip_ordini);

#ifdef DBG
  //file di controllo degli ordini elaborati
  ofstream ordini("c:/temp/ordini.txt");
  ofstream mov_da_ordini("c:/temp/mov_da_ordini.txt");
#endif

  for (int n = 0; n < numerazioni_tipo_ordine; n++)
  {
    const TString4 codnum = num_ordini.row(n);

    //cerca tutte le righe documento che soddisfano i numerosi (fin troppo) parametri
    //joina DOC perch� abbiamo un decisivo filtro sul range di date
    TString query;
    query << "USE RDOC KEY 1\n";
    query << "SELECT (BETWEEN(DOC.DATADOC,#DATAINIES,#DATACALCOLO))&&(RIGAEVASA!=\"X\")";

    //filtro su cdc/cms/fasi (fatto come per saldi e rmovana; in tutti i files..
    //..i nomi dei campi sono diversi! -> tentiamo con il metodo automaggico
    const TString& select = crea_select(LF_RIGHEDOC);
    if (select.full())
    {
      query << "&&(" << select << ")";
    }

    query << "\nJOIN DOC INTO PROVV==PROVV ANNO==ANNO CODNUM==CODNUM NDOC==NDOC"
          << "\nFROM CODNUM=#CODNUM ANNO=#ANNO PROVV=D"
          << "\nTO CODNUM=#CODNUM ANNO=#ANNO PROVV=D";
    TISAM_recordset recset(query);
    recset.set_var("#ANNO", (long)_datacalcolo.year());
    recset.set_var("#CODNUM", TVariant(codnum));
    recset.set_var("#DATAINIES", datainiesc);
    recset.set_var("#DATACALCOLO", _datacalcolo);

    const TRecnotype recset_items = recset.items();

    //simpatica progind per intrattenere l'utonto
    TProgind pi(recset_items, "Scansione ordini inevasi...", true, true);

    //memorizza l'ultimo doc per evitare doppioni in caso di doc con pi� righe (rielaborerebbe..
		//..lo stesso documento tante volte quante sono le sue righe!)
		TString old_key;
    //misterioso oggetto necessario per contabilizzare il documento in osservazione
    TContabilizzazione_analitica cont_anal;

    for (bool ok = recset.move_first(); ok; ok = recset.move_next())    //giro sulle varie rdoc...
    {
      //aggiornamento progind intrattenitiva
      if (!pi.addstatus(1))
        break;

      const TRectype& curr_doc = recset.cursor()->curr(LF_DOC);

      //controlla se il documento contenente la riga � davvero un ordine ricontrollando il suo tipo nell'array..
      //..con i tipi validi; se non lo fosse...ciao ciao rigadocumento!
      const TString& tipodoc = curr_doc.get(DOC_TIPODOC);
      if (tip_ordini.find(tipodoc) < 0)
        continue;

      //ovviamente non � finita qui...
      //la riga documento non deve risultare contabilizzata! infatti, se lo fosse, i suoi valori apparirebbero..
      //..nella sezione delle rmovana
      const long numregca = curr_doc.get_long(DOC_NUMREGCA);
      //se la rigadoc non � stata contabilizzata..
      if (numregca == 0)
      {
        //magico trucco per non dover ricontabilizzare lo stesso documento tante volte quante sono le righe consecutive
      	const TString curr_key = curr_doc.build_key();
				if (curr_key == old_key)
					continue;
				else
					old_key = curr_key;

        //crea il documento virtuale in memoria; se non � ordine oppure lo � ma � gi� evaso, lo saltiamo!!! ole'! 
        TDocumento doc(curr_doc);
        if (!doc.is_ordine() || doc.is_evaso())
           continue;

        //il documento virtuale � adesso un ordine non evaso
        //tarocchiamo il documento prendendo solo le righe non evase (almeno una ci sar�, perch� la query del recordset..
        //..richiedeva che la rigadoc fosse non evasa, quindi quella riga nel doc esiste, magari in compagnia di altre)

        bool mov_da_ord = false;

        for (int r = doc.body().last_row(); r > 0; r = doc.body().pred_row(r))
        {
          TRiga_documento& rigadoc = doc[r];
          //trattamento delle righe non evase di tipo merce o prestazione
          if (rigadoc.is_merce() || rigadoc.is_prestazione())
          {
            if (!rigadoc.is_evasa())
            {
              //trasforma tutte le righe a valore, assegnando al prezzo il valore del residuo
              const real valore = rigadoc.valore(true, false, AUTO_DECIMALS);
              const real residuo = rigadoc.valore(false, false, AUTO_DECIMALS);
              //ovviamente questo � vero se il residuo � > 0; se fosse nullo sarebbe evasa in pratica
              //..se fosse maggiore sarebbe riga del cazzo
              if (residuo > ZERO)
              {
                rigadoc.put(RDOC_QTA, UNO);
                rigadoc.put(RDOC_PREZZO, residuo);

#ifdef DBG
                //file di controllo in output
                TString80 cdc = rigadoc.get(RDOC_CODCOSTO);
                TString80 cms = rigadoc.get(RDOC_CODCMS);
                if (cdc.empty())
                  cdc = doc.get(DOC_CODCOSTO);
                if (cms.empty())
                  cms = doc.get(DOC_CODCMS);
                if (cdc == "" && cms == "")
                {
                  ordini << rigadoc.get(RDOC_PROVV) << '\t'
                         << rigadoc.get(RDOC_ANNO) << '\t'
                         << rigadoc.get(RDOC_CODNUM) << '\t'
                         << rigadoc.get(RDOC_NDOC) << '\t'
                         << rigadoc.get(RDOC_NRIGA) << '\t'
                         << rigadoc.get(RDOC_CODART) << '\t'
                         << rigadoc.get(RDOC_TIPORIGA) << '\t'
                         << valore.stringa() << '\t'
                         << residuo.stringa() << endl;
                  mov_da_ord = true;
                }
#endif
              }
              else
                doc.body().destroy_row(r, true);  //righe a residuo 0 ma non flaggate come evase (errori)
            }
            else
              doc.body().destroy_row(r, true);  //se la riga fosse evasa la salta e compatta il documento
          }
        }

        //movana nevessario per la contabilizzazione analitica del documento
        TAnal_mov movana;
			  //finalmente contabilizza il documento in memoria
        cont_anal.elabora(doc, 0, NULL, false, movana, false);
        movana.put(MOVANA_TIPOMOV, ' ');

      	//controlla che la riga in esame abbia realmente la cms/cdc/fas indicata nel filtro;
				//procedimento necessario per evitare di prendere righe appartenenti a docs elaborati
				//perch� contenenti 1 riga con cms corretta ed altre righe con cms sbagliate
    		for (int j = 1; j <= movana.rows(); j++)
				{
					const TRectype& rmovana = movana.body()[j];

					if (_cdc.not_empty() && rmovana.get(RMOVANA_CODCCOSTO) != _cdc)
						continue;
					if (_fase.not_empty() && rmovana.get(RMOVANA_CODFASE) != _fase)
						continue;

          //metodo per il calcolo importo riga riproporzionato
          //metodo per generare i saldi alla data della riga analitica in base alla vita della riga
          elabora_rmovana(cms, datainiesc, datafinesc, movana, rmovana);

#ifdef DBG
          //file di controllo in output
          if (mov_da_ord)
          {
            mov_da_ordini << movana.get(MOVANA_DANNO) << '\t'
                          << movana.get(MOVANA_DCODNUM) << '\t'
                          << movana.get(MOVANA_DNDOC) << '\t'
                          << rmovana.get(RMOVANA_CODCMS) << '\t'
                          << rmovana.get(RMOVANA_CODCCOSTO) << '\t'
                          << rmovana.get(RMOVANA_SEZIONE) << '\t'
                          << rmovana.get_real(RMOVANA_IMPORTO).stringa() << endl;
          }
#endif
				}	//for int j...
      }
    } //for (bool ok = recset....

  } //for (int n = 0; n < numerazioni...

}


//aggiorna l'arrayone cms con le righedoc non ancora contabilizzate
void TPrint_saldana_recordset::parse_rdoc_fatture(TAssoc_array* cms, const TDate& datainiesc, const TDate& datafinesc)
{
  //solo le numerazioni con almeno un tipo documento fattura interessano
  TString_array num_fatture, tip_fatture;
  const int numerazioni_tipo_fattura = numerazioni_fatture(num_fatture, tip_fatture);

#ifdef DBG
  ofstream fatture("c:/temp/fatture.txt", ios::app);
#endif

  for (int n = 0; n < numerazioni_tipo_fattura; n++)
  {
    const TString4 codnum = num_fatture.row(n);

    //cerca tutte le righe documento che soddisfano i numerosi (fin troppo) parametri
    //joina DOC perch� abbiamo un decisivo filtro sul range di date
    TString query;
    query << "USE DOC"
          << "\nSELECT (STR(NUMREGCA=0))&&(BETWEEN(DATADOC,#DATAINIES,#DATACALCOLO))"
          << "\nFROM PROVV=D ANNO=#ANNO CODNUM=#CODNUM"
          << "\nTO PROVV=D ANNO=#ANNO CODNUM=#CODNUM";
    TISAM_recordset recset(query);
    recset.set_var("#ANNO", (long)_datacalcolo.year());
    recset.set_var("#CODNUM", TVariant(codnum));
    recset.set_var("#DATAINIES", datainiesc);
    recset.set_var("#DATACALCOLO", _datacalcolo);

    const TRecnotype recset_items = recset.items();

    //simpatica progind per intrattenere l'utonto
    TProgind pi(recset_items, "Scansione altri documenti da contabilizzare...", true, true);

    //misterioso oggetto necessario per contabilizzare il documento in osservazione
    TContabilizzazione_analitica cont_anal;

    for (bool ok = recset.move_first(); ok; ok = recset.move_next())    //giro sulle varie rdoc...
    {
      //aggiornamento progind intrattenitiva
      if (!pi.addstatus(1))
        break;

      const TRectype& curr_doc = recset.cursor()->curr();

      //controlla se il documento contenente la riga � davvero un ordine ricontrollando il suo tipo nell'array..
      //..con i tipi validi; se non lo fosse...ciao ciao rigadocumento!
      const TString& tipodoc = curr_doc.get(DOC_TIPODOC);
      if (tip_fatture.find(tipodoc) < 0)
        continue;

      //crea il documento virtuale in memoria;
      TDocumento doc(curr_doc);
      //se il documento non ha una numerazione valida per la contabilizzazione analitica lo deve saltare
      //E' il caso di quelle fatture figlie di FDR che sono gi� state contabilizzate in quel momento (come FDR)..
      //..e quindi non devono essere ricontabilizzate come fatture vere e proprie (es. FAQ)
      const int num_rows = doc.physical_rows();
      bool is_fdr = false;
      for (int k = 1; k <= num_rows && !is_fdr; k++)
      {
        const TRiga_documento& riga = doc[k];
        const TRectype* riga_babbo = riga.find_original_rdoc();
        if (riga_babbo != NULL && riga_babbo->get(RDOC_PROVV).not_empty())
        {
          const TString& key(riga_babbo->get(RDOC_CODNUM)); 
          const TCodice_numerazione& num = TDocumento::codice_numerazione(key);
          if (num.fattura_emettere_ricevere())
            is_fdr = true;
        }
      }
      if (is_fdr)
        continue;

      //movana nevessario per la contabilizzazione analitica del documento
      TAnal_mov movana;
		  //finalmente contabilizza il documento in memoria
      cont_anal.elabora(doc, 0, NULL, false, movana, false);
      movana.put(MOVANA_TIPOMOV, ' ');

    	//controlla che la riga in esame abbia realmente la cms/cdc/fas indicata nel filtro;
			//procedimento necessario per evitare di prendere righe appartenenti a docs elaborati
			//perch� contenenti 1 riga con cms corretta ed altre righe con cms sbagliate
  		for (int j = 1; j <= movana.rows(); j++)
			{
				const TRectype& rmovana = movana.body()[j];

				if (_cdc.not_empty() && rmovana.get(RMOVANA_CODCCOSTO) != _cdc)
					continue;
				if (_fase.not_empty() && rmovana.get(RMOVANA_CODFASE) != _fase)
					continue;
        
        //ulteriore controllo in base ai permessi utente! se il record non rispetta i permessi viene saltato!
        if (!ca_filter_record(rmovana))
          continue;

        //metodo per il calcolo importo riga riproporzionato
        //metodo per generare i saldi alla data della riga analitica in base alla vita della riga
        elabora_rmovana(cms, datainiesc, datafinesc, movana, rmovana);

#ifdef DBG
        //file di controllo in output
        if (rmovana.get(RMOVANA_CODCMS) == "")
        {
          fatture << movana.get(MOVANA_DANNO) << '\t'
                  << movana.get(MOVANA_DCODNUM) << '\t'
                  << movana.get(MOVANA_DNDOC) << '\t'
                  << rmovana.get(RMOVANA_CODCMS) << '\t'
                  << rmovana.get(RMOVANA_CODCCOSTO) << '\t'
                  << rmovana.get(RMOVANA_SEZIONE) << '\t'
                  << rmovana.get_real(RMOVANA_IMPORTO).stringa() << endl;
        }
#endif
			}	//for int j...
    } //for (bool ok = recset....

  } //for (int n = 0; n < numerazioni...

}

//metodo principale di riempimento degli array da mandare in stampa
void TPrint_saldana_recordset::create_lines_to_print()
{
  //ricava date limite di esercizio
  TEsercizi_contabili esc;
  TDate datainiesc, datafinesc;
  esc.code2range(_anno, datainiesc, datafinesc);

  //array con le commesse divise sui vari livelli di sezione di stampa
	TAssoc_array cms[NUM_LEVELS];

  //  1)
  //    calcolo dei saldi come sono in SALDANA
  //    1_a) calcolo dei saldi alla data fine esercizio (vale per entrambi i tipi di stampa, ovvero _tipo=8 e _tipo=9)
  parse_saldana(cms, datainiesc, datafinesc);
  //    1_b) calcolo dei saldi futuri, ovvero con esercizio futuro a quello scelto per il calcolo dei saldi
  if (_tipo == 8)
    parse_saldana_futuri();

  //  2) 
  //    calcolo dei saldi ad una data diversa da una data di fine esercizio (saldi alla data di adolfica richiesta)
  //    serve solo per il bilancio di commessa (_tipo = 8)
  if (_tipo == 8)
  {
    if ((_datacalcolo < datafinesc) && !_vitaintera)
    {
      // 2_a) calcolo dei saldi da righe movimenti analitici e quindi senza saldana
      parse_rmovana(cms, datainiesc, datafinesc);
    } //if((_datacalcolo<datafinesc...

    // 2_b) calcolo dei saldi da documenti non ancora contabilizzati e quindi senza movana e saldana
    //      si fa solo se l'utente Adolfo lo ha deciso sulla maschera
    if (_include_documenti)
    {
      parse_rdoc_ordini(cms, datainiesc, datafinesc);
      parse_rdoc_fatture(cms, datainiesc, datafinesc);
    }
  } //if(_tipo==8)...


	//  3)
  //    merging dei 5 arrayini cms nell'arrayone _righe da mandare in stampa
	_righe.destroy();
	for (int i = 0; i < 5; i++)
	{
		TAssoc_array& a = cms[i];
		TObject* cazzo_cms = NULL;
    
		FOR_EACH_ASSOC_OBJECT(a, h, k, r)
		{
      TObject* obj = h->remove_obj();
			if (strcmp(k, CMS_DEL_CAZZO) == 0)
        cazzo_cms = obj;
			else
			  _righe.add(obj); // Copia nella destinazione la riga corrente e la toglie dall'originale
		}
    if (cazzo_cms != NULL)
			_righe.add(cazzo_cms);
	}	//for(int...
  _righe.sort(righe_compare);  //sorting delle commesse
}

void TPrint_saldana_recordset::requery()
{
  //***Metodo principale per la creazione della intera stampa***
  //Messo nella requery perch� sempre chiamata qualsiasi sia il tipo di stampa
  create_lines_to_print();
}


const TVariant& TPrint_saldana_recordset::get(unsigned int column) const
{
  return NULL_VARIANT;
}

const TVariant& TPrint_saldana_recordset::get(const char* column_name) const
{
	if (_curr >= 0 && _curr < items())
	{
		if (*column_name == '#')
			column_name++;
		
  	TVariant& var = get_tmp_var();
		if (strcmp(column_name, "ANNO") == 0)
		{
			var.set(_anno);
		}
		else
		if (strcmp(column_name, "TIPOSTIMA") == 0)
		{
      switch (_tipostima)
      {
      case 'T':
        var.set("T");
        break;
      case 'C':
        var.set("C");
        break;
      case 'R':
        var.set("R");
        break;
      default:
        break;
      }
		}
		else
		if (strcmp(column_name, "DEPTH") == 0)
		{
      var.set(_depth);
		}
    else
    if (strcmp(column_name, "DETRCONS") == 0)
    {
      var.set(_detrazioni_consuntive == true ? "X" : "");
    }
    else
    if (strcmp(column_name, "VITAINTERA") == 0)
		{
      var.set(_vitaintera  == true ? "SI" : "NO");
		}
		else
    if (strcmp(column_name, "STAMPAFASI") == 0)
		{
      var.set((_tipostampa == 1 || _tipostampa == 3) ? "X" : "");
		}
		else
		if (strcmp(column_name, "FASESPEC") == 0)
		{
      if (_tipostampa == 1 || _tipostampa == 3 || _tipostampa == 4)
			  var.set(_fase);
      else
        var.set(EMPTY_STRING);
		}
    else
    if (strcmp(column_name, "STAMPACDC") == 0)
		{
      var.set((_tipostampa  == 2 || _tipostampa == 3) ? "X" : "");
		}
    else
    if (strcmp(column_name, "CDCSPEC") == 0)
		{
      if (_tipostampa == 2 || _tipostampa == 3 || _tipostampa == 8)
			  var.set(_cdc);
      else
        var.set(EMPTY_STRING);
		}
		else
    if (strcmp(column_name, "DATAINI") == 0)
    {
      const TString& codcms = get("CODCMS").as_string();
      const TRectype& rec_commesse = cache().get(LF_COMMESSE, codcms);
      var.set(rec_commesse.get(COMMESSE_DATAINIZIO));
    }
    else
    if (strcmp(column_name, "DATAFINE") == 0)
    {
      const TString& codcms = get("CODCMS").as_string();
      const TRectype& rec_commesse = cache().get(LF_COMMESSE, codcms);
      TDate datafine = rec_commesse.get(COMMESSE_DATAPROR);
      if (!datafine.ok())
        datafine = rec_commesse.get(COMMESSE_DATAFINE);
      var.set(datafine);
    }
    else
		if (strcmp(column_name, "AVANZAMENTO") == 0)
		{
      //RICAVI
      //------
			//Calcola lo stato di avanzamento della commessa in caso di stima x Tempo
      //In questo caso i ricavihanno una % di avanzamento legata alla durata della commessa (prorogata ecc.)..
      //..rispetto al momento della stampa
			real avanzamento;
			if (_tipostima == 'T')
			{
        avanzamento = calcola_avanzamento_tempo();
			}
			else	//se stima e' di tipo Costi/Ricavi invece....Allah!!
			{
        //In caso di stampa Ricavi nei casi _tipostime = 'C' o 'R', l'avanzamento � calcolato in base agli importi.
        //Caso 'C': valore_preventivo / totale_preventivo
        //Caso 'R': valore_consuntivo / totale_preventivo (!) richiesta specifica Adolfo-Enrichetta 24-03-2011
    		TAssoc_array& riga = (TAssoc_array&)_righe[_curr];
        const real val = get("RICAVI").as_real();
			  if (!val.is_zero())
        {
          const int indice = get("LEVEL").as_int();
     	    const TString& codcms = get("CODCMS").as_string();
#ifdef DBG
          if (codcms == "FP10VB22388OP")
            const int cazzone = 1;
#endif
          TAssoc_array& riga_tot = get_row((TAssoc_array&)_totali[indice], codcms, indice, codcms, EMPTY_STRING, EMPTY_STRING,
																				   "RICAVI");
          const TString* stric = (const TString*)riga_tot.objptr("RICAVI");
          if (stric && stric->full())
          {
            const real totric = *stric;
            if (!totric.is_zero())
              avanzamento = val * CENTO / totric;
          }
        }
			}
			var.set(avanzamento);
		}
		else	//if(strcmp(column_name,AVANZAMENTO...
		{
  		TAssoc_array& riga = (TAssoc_array&)_righe[_curr];
      if (strncmp(column_name, "RECORD.", 7) == 0)
        column_name += 7;
 
      //COSTI
      //-----
      if (strcmp(column_name, "COS_PERC") == 0)
      {
        const int indice = get("LEVEL").as_int();
        if (indice == 4)
          int cazzone = 100;
        //la % dei costi, in caso si forzi il maturato (considerare finite le commesse che terminano nell'esercizio selezionato)..
        //..viene posta artificialmente pari a 100% nelle sezioni delle commesse che terminano nell'esercizio selezionato (sez. 0 e 1)..
        //..e nella sezione delle commesse di supporto (sez. 4). Richiesta Adolfica del 08/03/2011
        if (_forza_maturato && (indice <= 1 || indice == 4))
          var.set(CENTO);
        else
        {     
          const TString* val_bdg = (TString*)riga.objptr("COS_BDG");
          if (val_bdg == NULL || real::is_null(*val_bdg))
            var.set(CENTO);
          else
          {
            const TString* val_mat = (TString*)riga.objptr("COS_MAT");
            if (val_mat == NULL || real::is_null(*val_mat))
              var.set(ZERO);
            else
            {
              const real bdg(*val_bdg);
              const real mat(*val_mat);
              real perc = mat * CENTO / bdg;
              perc.round(2);
              var.set(perc);
            }
          }
        }
      }
      else
      {
			  const TString* val = (TString*)riga.objptr(column_name);
			  if (val)
			    var.set(*val);
			  else
				  var.set_null();
      }
		}
  	return var;
	}
  return NULL_VARIANT;
}

void TPrint_saldana_recordset::set_filter(const TMask& msk, const TString& curr_sublevel)
{
  _fase = _cdc = "";
  _forza_maturato = false;

	//tira su un po' di parametri dalla maschera...
	_anno = msk.get_int(F_ESERCIZIO);
  _datacalcolo = msk.get_date(F_FINE_ES);
	//prende anche il prefix
	TString80 prefix;
	for (short id = F_PRE1; id <= F_PRE3 && msk.id2pos(id) > 0; id++)
		prefix << msk.get(id);
	_indicatori.set_prefix(prefix);

  //solo per ca3800
  if (_tipo == 8)
  {
    _tipostima = msk.get(F_TIPOSTIMA)[0];
	  _vitaintera = msk.get_bool(F_VITAINTERA);
    _include_documenti = msk.get_bool(F_INCLUDE_DOCUMENTI);
    _depth = msk.get_int(F_DEPTH);
    _tipostampa = msk.get_int(F_TIPOSTAMPA);
    _detrazioni_consuntive = msk.get_bool(F_DETR_CONS);

    //in base al tipo di stampa selezionata setta un po' di parametri
    switch (_tipostampa)
    {
    case 1:
      _fase = msk.get(F_FASE);
      _cdc.cut(0);
      break;
    case 2:
      _cdc = msk.get(F_CDC);
      _fase.cut(0);
      break;
    case 3:
      _fase = msk.get(F_FASE);
      _cdc = msk.get(F_CDC);
      break;
    case 4:
      _fase = curr_sublevel;
      break;
    case 8:
      _cdc = curr_sublevel;
      break;
    default:
      break;
    }
  } //if(tipo==8..
  if (_tipo == 9)
  {
    _forza_maturato = msk.get_bool(F_FORZA_MATURATO);
  }
}