#include <applicat.h>
#include <execp.h>
#include <progind.h>
#include <reprint.h>

#include "../cg/cglib01.h"

#include "ca3.h"
#include "ca3800.h"
#include "calib01.h"
#include "calib02.h"
#include "commesse.h"
#include "panapdc.h"
#include "pconana.h"
#include "saldana.h"

////////////////////////////////////////////////////////
//	MASCHERA
////////////////////////////////////////////////////////
class TPrint_bilancio_cms_mask : public TAnal_report_mask
{
protected:
  virtual bool on_field_event(TOperable_field& o, TField_event e, long jolly);
	const TString& get_report_class() const; 
  bool test_compatible_report();
	
public:
  TPrint_bilancio_cms_mask();
  virtual ~TPrint_bilancio_cms_mask() {}
};

const TString& TPrint_bilancio_cms_mask::get_report_class() const
{
  TString& classe = get_tmp_string();
  classe = "ca3800a";
  return classe;
}

bool TPrint_bilancio_cms_mask::test_compatible_report()
{
	const TString& cls = get_report_class();
  const TString& name = get(F_REPORT);
  bool ok = name.not_empty();
  if (ok)
  {
    TReport rep; 
    ok = rep.load(name);
    if (ok)
    {
      const TString& classe = rep.get_class();
      ok = classe == cls;
    }
  }
  if (!ok)
  {
    set(F_REPORT, cls);
		TFilename path = cls;
    path.ext("rep");
    ok = path.custom_path();
  }
  return ok;
}

bool TPrint_bilancio_cms_mask::on_field_event(TOperable_field& o, TField_event e, long jolly)
{
  switch (o.dlg())
  {
  case F_REPORT:
    if (e == fe_button)
    {
      const TString8 lib = get_report_class();
      TFilename path = o.get();
      if (select_custom_file(path, "rep", lib))
      {
        path = path.name();
        path.ext("");
        o.set(path);
      }
    } else
    if (e == fe_close)
    {
      if (!test_compatible_report())
        return error_box(TR("Impossibile trovare un report compatibile"));
    }
    break;
  default: 
		break;
  }
	return TAnal_report_mask::on_field_event(o, e, jolly);
}


TPrint_bilancio_cms_mask::TPrint_bilancio_cms_mask()
								:TAnal_report_mask("ca3800")
{
	TConfig& cfg = ca_config();
	const bool use_pdcc = cfg.get_bool("UsePdcc");

  const TMultilevel_code_info& pconana_info = ca_multilevel_code_info(LF_PCONANA);
  const int pconana_levels = pconana_info.levels();
  
  int prefix = cfg.get_int("PdcPrefix");
  if (prefix >= pconana_levels)
    prefix = pconana_levels-1;

	  // Controllo se voglio (e posso) usare il conto analitico come prefisso di quello contabile
  if (use_pdcc && prefix > 0)
  {
    const TMultilevel_code_info& info = ca_multilevel_code_info(LF_PCONANA);
    const int levels = info.levels();
    if (levels >= 2 && prefix < levels && esistono_riclassificazioni())
    {
    	ca_create_fields(*this, 0, LF_PCONANA, 1, 13, F_PRE1, F_PREDES1, 0x0, PCONANA_CODCONTO);

      // Nascondi i campi che non fanno parte del prefisso
	    for (int i = 0; i < levels; i++)
	    {
        if (i < prefix)
        {
          field(F_PRE1 + i).check_type(CHECK_REQUIRED);
          field(F_PRE1 + i).set_group(6);
          field(F_PREDES1 + i).set_group(6);
        }
        else
        {
          field(F_PRE1 + i).hide();
          field(F_PREDES1 + i).hide();
        }
      }
    }
  }
	
	// setta gli handlers a tutti i campi generati della maschera;senza questa chiamata la on_field_event
	// non puo' funzionare sui campi generati!!!
	set_handlers();
}

///////////////////////////////////////////////////////////////
//	CACHE INDICATORI BILANCIO 
///////////////////////////////////////////////////////////////
const TFixed_string CMS_DEL_CAZZO("@@@@@@@@@@@@@@@@@@@@");


class TIndbil_cache : public TCache
{
	bool _usepdcc;
	TString80 _prefix;

protected:
	virtual TObject* key2obj(const char* key);

public:
	int get_indbil(const TString& conto, TString& conto_anale);
	void set_prefix(const char* prefix);
	int get_prefix_length() const { return _prefix.len(); }
	TIndbil_cache();

};

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();
		for (int 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);
				  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)
{
	TToken_string* ib = (TToken_string*)objptr(conto);
	if (ib != NULL)
		ib->get(1, conto_anale);
	return ib ? ib->get_int(0) : 0;
}

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");
}

///////////////////////////////////////////////////////////////
//	RECORDSET 
///////////////////////////////////////////////////////////////
class TPrint_bilancio_cms_recordset : public TRecordset
{
	TArray _righe;
	TRecnotype _curr;
	TArray _colonne;
	TIndbil_cache _indicatori;

private:
	int _anno;
	bool _vitaintera, _use_fasi;
	char _tipostima;

protected:
	virtual TRecnotype items() const { return _righe.items(); }
  virtual bool move_to(TRecnotype pos);
  virtual TRecnotype current_row() const { return _curr; }
  virtual void requery();
  virtual const TString& query_text() const { return EMPTY_STRING; }
	virtual unsigned int columns() const { return _colonne.items(); }
  virtual const TRecordset_column_info& column_info(unsigned int column) const { return (TRecordset_column_info&) _colonne[column]; }
  virtual const TVariant& get(unsigned int column) const;
	virtual const TVariant& get(const char* column_name) const;

	void parse_bill(const TString& bill, TString& gruppo, TString& conto) const;
	void aggiorna_importo(TAssoc_array& riga_array, const TString& livello, 
											const int indbil, const TRecordset& saldana, const bool inverti = false) const;
	TAssoc_array& get_row(TAssoc_array& cms, const char* chiave,
												const int indice, const TString& codcms, const TString& fase,
												const TString& descrizione, const real& avanzamento);

public:
  virtual void set_filter(const TPrint_bilancio_cms_mask& msk);
};


bool TPrint_bilancio_cms_recordset::move_to(TRecnotype pos)
{
	_curr = pos;
	return pos >= 0 && pos < items();
}


void TPrint_bilancio_cms_recordset::parse_bill(const TString& bill, TString& gruppo, 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;
	const int gruppo_len = pconana_info.len(prefix + 1);
	const int conto_len = pconana_info.len(prefix + 2);

	//stringhe con gruppo e conto da mettere nel record dell'assoc_array
	gruppo = bill.mid(prefix_len, gruppo_len);
	conto = bill.mid(prefix_len, gruppo_len + conto_len);
}

void TPrint_bilancio_cms_recordset::aggiorna_importo(TAssoc_array& riga_array, 
		 const TString& livello, const int indbil, const TRecordset& saldana, 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));

	//ci sono tutti i tipi di saldo, ma solo quelli che rientrano nei parametri iniziali..
	//..verranno considerati (_tipostima,indbil)
	const TImporto imp_saldo(saldana.get(SALDANA_SEZIONE).as_string()[0], 
														saldana.get(SALDANA_SALDO).as_real());
	const TImporto imp_saldop(saldana.get(SALDANA_SEZIONEP).as_string()[0], 
		                        saldana.get(SALDANA_SALDOP).as_real());
	const TImporto imp_saldov(saldana.get(SALDANA_SEZIONEV).as_string()[0], 
														saldana.get(SALDANA_SALDOV).as_real());

	if (inverti)
	{
		if (_tipostima == 'C' && indbil == 3)	//stima Costi e indbil=Costo
			imp -= imp_saldo;
		if (_tipostima == 'T' || (_tipostima == 'C' && indbil == 4))	//stima Tempo o (Costi e indbil=ricavo)
		{
			imp -= imp_saldop;
			imp -= imp_saldov;
		}
	}
	else
	{
		if (_tipostima == 'C' && indbil == 3)
			imp += imp_saldo;
		if (_tipostima == 'T' || (_tipostima == 'C' && indbil == 4))
		{
			imp += imp_saldop;
			imp += imp_saldov;
		}
	}

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


TAssoc_array& TPrint_bilancio_cms_recordset::get_row(TAssoc_array& cms, const char* chiave,
																										 const int indice, const TString& codcms, const TString& fase,
																										 const TString& descrizione, const real& avanzamento)
{
	//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);
		riga_array->add("FASE", fase);
		riga_array->add("DESCRIZ", descrizione);
		const TString str_avanz = avanzamento.string();
		riga_array->add("AVANZAMENTO", str_avanz);
		
		//aggiunge la riga all'array-ino
		cms.add(chiave, riga_array);
	}
	return *riga_array;
}



void TPrint_bilancio_cms_recordset::requery()
{
	//prende le date di inizio e fine dell'eserizio selezionato sulla maschera
	TEsercizi_contabili esc;
	TDate datainiesc, datafinesc;
	esc.code2range(_anno, datainiesc, datafinesc);

	//deve procedere al confronto tra le date inizio-fine esercizio e quelle inizio-fine commessa..
	//..per spostare il record in esame nell'array corretto
	TAssoc_array cms[4];

	TString query;
	query = "USE SALDANA";
	//stampa standard non a vita intera
	if (!_vitaintera)
		query << "\nTO ANNO=" << _anno;

	TISAM_recordset saldana(query);

	const long saldana_items = saldana.items();

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

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

		const TString& codconto = saldana.get(SALDANA_CONTO).as_string();
		//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)
		{
			//solo i record con saldi non nulli devono essere considerati
			const bool has_saldop = (saldana.get(SALDANA_SALDOP).as_real() + 
															 saldana.get(SALDANA_SALDOV).as_real()) != ZERO;
			const bool has_saldo = saldana.get(SALDANA_SALDO).as_real() != ZERO;

			//se stima per Tempo -> usa solo saldop e saldov
			//se stima per Costi -> se costi -> usa solo saldo
			//se stima per Costi -> se ricavi -> usa solo saldop e saldov
			if ((_tipostima == 'T' && has_saldop)||
				  (_tipostima == 'C' && indbil == 3 && has_saldo)||
				  (_tipostima == 'C' && indbil == 4 && has_saldop))
			{
				const TString& codcms = saldana.get(SALDANA_COMMESSA).as_string();
				const TString& fase = saldana.get(SALDANA_FASE).as_string();

				const TRectype& rec_commesse = cache().get(LF_COMMESSE, codcms);

				const TDate dataini = rec_commesse.get(COMMESSE_DATAINIZIO);
				const TDate datafine = rec_commesse.get(COMMESSE_DATAFINE);
				//e' inutile considerare le commesse terminate prima dell'esercizio selezionato..
				//..cioe' nel passato oppure che iniziano nel futuro!
				if (datafine >= datainiesc && dataini <= datafinesc)
				{
					int indice = datafine <= datafinesc ? 0 : 2;
					if (dataini >= datainiesc)
						indice++;

					//Calcola lo stato di avanzamento della commessa
					real avanzamento;
					//Si prende SOLO la Fine Esercizio come riferimento di avanzamento (in realta' si..
					//..potrebbe usare today al posto di datafinesc se si volesse la situazione ad oggi,..
					//..ma i calcoli degli importi sarebbero da rivedere). Quindi:
					//se la commessa finisce prima della fine dell'esercizio 
					if (datafine < datafinesc)
						avanzamento = CENTO;
					//se invece prosegue anche dopo la fine dell'esercizio...
					else
					{
						const long time_gone = datafinesc - dataini;
						const long durata_cms = datafine - dataini;
						avanzamento = ((real)(time_gone * CENTO) / durata_cms);
						avanzamento.round(0);
					}

					TString80 chiave = codcms;
					if (_use_fasi)
						chiave << '|' << fase;

					//riempie le righe degli array da mandare poi in stampa
					//dapprima le righe normali..
					TAssoc_array& riga_array = get_row(cms[indice], chiave, indice, codcms, fase, 
																						rec_commesse.get(COMMESSE_DESCRIZ), avanzamento);
					//aggiunge gli importi e normalizza
					TString80 gruppo, conto;
					parse_bill(conto_anale, gruppo, conto);
					aggiorna_importo(riga_array, gruppo, indbil, saldana);
					aggiorna_importo(riga_array, conto, indbil, saldana);

					//..poi le righe speciali,che esistono solo se la commessa e' iniziata prima dell'anno
					//selezionato,quindi se l'indice e' 0 o 2
					if (indice %2 == 0)
					{
						//aggiorna il record speciale con la somma dei saldi con anno anteriore a quello..
						//..selezionato sulla maschera (CRPA request)
						const int anno = saldana.get(SALDANA_ANNO).as_int();
						if (anno < _anno)
						{
							TString cazzo_cod; cazzo_cod.format("DETR_%02d", _anno - 1);  
							TString cazzo_descr = "DETRAZIONE PER COMPETENZA ";
							cazzo_descr << (_anno - 1);
							TAssoc_array& riga_array = get_row(cms[indice], CMS_DEL_CAZZO, indice, cazzo_cod, 
																								EMPTY_STRING, cazzo_descr, CENTO);
							aggiorna_importo(riga_array, gruppo, indbil, saldana, true);
							aggiorna_importo(riga_array, conto, indbil, saldana, true);
						}
					}	//if(indice...

				}	//if (datafine >= datainiesc &&...
			}	//if (saldop != ZERO..
		}	//if (indbil == 3 ||...

	}
	//merging dei 4 arrayini cms nell'arrayone _righe da mandare in stampa
	_righe.destroy();
	for (int i = 0; i < 4; 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...
}

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

const TVariant& TPrint_bilancio_cms_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)
		{
			var.set(_tipostima == 'T' ? "T" : "C");
		}
		else
		{
  		TAssoc_array& riga = (TAssoc_array&)_righe[_curr];
			const TString* val = (TString*)riga.objptr(column_name);
			if (val)
			  var.set(*val);
			else
				var.set_null();
		}
  	return var;
	}
  return NULL_VARIANT;
}


void TPrint_bilancio_cms_recordset::set_filter(const TPrint_bilancio_cms_mask& msk)
{
	//tira su un po' di parametri dalla maschera...
	_anno = msk.get_int(F_ESERCIZIO);
	_tipostima = msk.get(F_TIPOSTIMA)[0];
	_vitaintera = msk.get_bool(F_VITAINTERA);
	_use_fasi = msk.get_bool(F_FASI);
	//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);
}

////////////////////////////////////////////////////////
//	REPORT
////////////////////////////////////////////////////////
class TPrint_bilancio_cms_rep : public TAnal_report
{

protected:
	virtual bool set_recordset();
	virtual bool get_usr_val(const TString& name, TVariant& var) const;

public:
	void set_filter(const TPrint_bilancio_cms_mask& msk);
};

bool TPrint_bilancio_cms_rep::get_usr_val(const TString& name, TVariant& var) const
{
	return TAnal_report::get_usr_val(name, var);
}

bool TPrint_bilancio_cms_rep::set_recordset()
{
  TPrint_bilancio_cms_recordset* rs = new TPrint_bilancio_cms_recordset();
  return TAnal_report::set_recordset(rs);
}

void TPrint_bilancio_cms_rep::set_filter(const TPrint_bilancio_cms_mask& msk)
{
	TPrint_bilancio_cms_recordset* recset = new TPrint_bilancio_cms_recordset(); 

  recset->set_filter(msk);
	TAnal_report::set_recordset(recset);
}

////////////////////////////////////////////////////////
//	APPLICAZIONE
////////////////////////////////////////////////////////
class TPrint_bilancio_cms : public TSkeleton_application
{
public:
  virtual void main_loop();
};

void TPrint_bilancio_cms::main_loop()
{
  TPrint_bilancio_cms_mask mask;
  while (mask.run() == K_ENTER)
  {
		//report e book dei report
		TReport_book book;
		TString path = mask.get(F_REPORT);
		if (path.empty())
			path = "ca3800a";
		TPrint_bilancio_cms_rep rep;
		rep.load(path);

		rep.set_filter(mask);	
		book.add(rep);
		book.print_or_preview();
	}
}

int ca3800(int argc, char* argv[])
{
  TPrint_bilancio_cms a;
  a.run(argc, argv, TR("Stampa bilancio di commessa"));
  return 0;
}