#include <repapp.h>
#include <defmask.h>

#include "../cg/cglib.h"
#include "ca3.h"
#include "ca3883.h"
#include "ca3883a.h"
#include "calib01.h"
#include "calib02.h"
#include "commesse.h"
#include "pconana.h"
#include "cdc.h"
#include "fasi.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);
	
public:
  const TString& get_report_class() const; 

  TPrint_bilancio_cms_mask();
  virtual ~TPrint_bilancio_cms_mask() {}
};

const TString& TPrint_bilancio_cms_mask::get_report_class() const
{
  TString& classe = get_tmp_string();
	const int tipostampa = get_int(F_TIPOSTAMPA);
	const bool sintetica = get_bool(F_STAMPA_SINTETICA);
	
	switch (tipostampa)
  {
  case  4: classe = "ca3800b"; break;
  case  8: classe = "ca3800c"; break;
  default: classe = "ca3800a"; break;
  }   
	if (sintetica)
		classe << "s";
  return classe;
}

bool TPrint_bilancio_cms_mask::on_field_event(TOperable_field& o, TField_event e, long jolly)
{
  switch (o.dlg())
  {
		case F_TIPOSTAMPA:
		case F_STAMPA_SINTETICA:
			if (e == fe_init || e == fe_modify)
				set_report_class();
			break;
		case F_ESERCIZIO:
		case F_FINE_ES:
			if (e == fe_init || e == fe_modify || e == fe_close)
			{
				const int anno = get_int(F_ESERCIZIO);
				if (anno > 0)
				{
					TEsercizi_contabili esc;
					TDate datainiesc, datafinesc;

					esc.code2range(anno, datainiesc, datafinesc);
					const TDate datafine = get(F_FINE_ES);
					if (datafine < datainiesc || datafine > datafinesc)
						set(F_FINE_ES, datafinesc);
					//deve comunque scrivere l'inizio dell'esercizio che ha scelto (anche se esercizio non esiste!)
					set(F_INIZIO_ES, datainiesc);
				}
			}
			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;

	TToken_string codes, descr;
	for (int k = prefix; k < pconana_levels; k++)
	{
		codes.add(k);
		descr.add(pconana_info.prompt(k));
	}

	TList_field& depth_list = lfield(F_DEPTH); 
	depth_list.replace_items(codes, descr);
  
	//Controllo se voglio (e posso) usare il conto analitico come prefisso di quello contabile
  if (use_pdcc && prefix > 0)
  {
    if (pconana_levels >= 2 && prefix < pconana_levels && esistono_riclassificazioni())
    {
    	ca_create_fields(*this, 0, LF_PCONANA, 1, 15, F_PRE1, F_PREDES1, 0x0, PCONANA_CODCONTO);

      // Nascondi i campi che non fanno parte del prefisso
	    for (int i = 0; i < pconana_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();
        }	//if(i<prefix..
      }	//for(int i=0..
    }	//if(levels>=2..
  }	//if(use_pdcc..

  //filtro sui permessi utente (centro di costo e fase)
  if (ca_create_user_select_clause(LF_CDC).full())
    efield(F_CDC).browse()->cursor()->set_filterfunction(ca_filter_function);
  if (ca_create_user_select_clause(LF_FASI).full())
    efield(F_FASE).browse()->cursor()->set_filterfunction(ca_filter_function);
	
  //***ACHTUNG!!!***
  //Questa chiamata serve per generare i campi fase/commessa esattamente come strutturati nella configurazione..
  //..della contabilita' analitica; ma per il magico Adolfo non servono!!!
  //ca_create_fields(*this, 0, LF_FASI, 2, 8, F_FASE1, F_DESCFASE1);
	// 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();
}

///////////////////////////////////////////////////////////////
//	RECORDSET 
///////////////////////////////////////////////////////////////
class TPrint_bilancio_cms_recordset : public TPrint_saldana_recordset
{

public:
  TPrint_bilancio_cms_recordset() : TPrint_saldana_recordset(8) {}
};


////////////////////////////////////////////////////////
//	REPORT
////////////////////////////////////////////////////////
class TPrint_bilancio_cms_rep : public TCRPA_report
{

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

public:
	virtual const char * get_excel_disabled_field() { return "H0.201|H0.202|H0.203|H0.204|H0.205|H0.121|H0.122|B1.171"; }
	void set_filter(const TPrint_bilancio_cms_mask& msk, const char * curr_fase = "", const char * curr_cdc = "");
	TPrint_bilancio_cms_rep(const char* rep_name, const TString& prefix, const int depth, 
                          const bool show_fasi, const bool show_cdc, const bool show_cms_descr, const bool show_cms_date,
													const bool sintetica, const bool intestazione_minima);
};

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

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


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

  //la set_filter del recordset puo' essere chiamata per fase o per centro di costo; se curr_fase_cdc e' vuota..
  //..e' nel caso della stampa principale dettagliata (ca3800a.rep)
  recset->set_filter(msk, curr_fase, curr_cdc);
	TReport::set_recordset(recset);
}

TPrint_bilancio_cms_rep::TPrint_bilancio_cms_rep(const char* rep_name, const TString& prefix, 
                                                 const int depth, const bool show_fasi, const bool show_cdc,
                                                 const bool show_cms_descr, const bool show_cms_date, const bool sintetica,
																								 const bool intestazione_minima)
												:TCRPA_report(rep_name, prefix, depth, show_fasi, show_cdc, show_cms_descr, show_cms_date, sintetica, intestazione_minima)
{
}

////////////////////////////////////////////////////////
//	APPLICAZIONE
////////////////////////////////////////////////////////
class TPrint_bilancio_cms : public TReport_application
{
  TPrint_bilancio_cms_mask * _mask;
	TReport * _rep;

protected:
	void build_lista_fasi(TString_array & lista_fasi, const TString & fase);
	void build_lista_cdc(TString_array & lista_cdc, const TString &  cdc);
	// @cmember Ritorna il report
	virtual TReport & get_report(const TAutomask & m);
	// @cmember ritorna la maschera
	virtual TAutomask & get_mask();
	virtual void execute_print(TReport_book & book,TAutomask & mask, TReport & rep, export_type & type);

public:
	virtual const char * title() const { return TR("Stampa bilancio di commessa"); }
	virtual const char * output_name(const TAutomask & mask, const TReport & rep) const { return "bilcms"; }
	virtual TTrec * get_dbase_recdesc(TReport & rep, const TAutomask & mask);
	bool user_destroy();

	// @cmember Costruttore
	TPrint_bilancio_cms() : _mask(nullptr), _rep(nullptr) { }
	// @cmember Distruttore
	virtual ~TPrint_bilancio_cms() { }
};

void TPrint_bilancio_cms::build_lista_fasi(TString_array & lista_fasi, const TString & fase)
{
	TString query("USE FASI");
	TString select = ca_create_user_select_clause(LF_FASI);

	if (fase.full())
		lista_fasi.add(fase);
	else
	{
		if (select.full())
			query << "\nSELECT " << select;

		TISAM_recordset file_fasi(query);

		for (TRecnotype j = 0; file_fasi.move_to(j); j++)
		{
			const TString16 curr_fase = file_fasi.get(FASI_CODFASE).as_string();

			if (curr_fase.full() && lista_fasi.find(curr_fase) < 0)
				lista_fasi.add(curr_fase);
		}
		lista_fasi.sort();
	}
}

void TPrint_bilancio_cms::build_lista_cdc(TString_array & lista_cdc, const TString & cdc)
{
	TString query("USE CDC");
	TString select = ca_create_user_select_clause(LF_CDC);

	if (cdc.full())
		lista_cdc.add(cdc);
	else
	{
		if (select.full())
			query << "\nSELECT " << select;

		TISAM_recordset file_cdc(query);

		for (TRecnotype j = 0; file_cdc.move_to(j); j++)
		{
			const TString16 curr_cdc = file_cdc.get(CDC_CODCOSTO).as_string();

			if (curr_cdc.full() && lista_cdc.find(curr_cdc) < 0)
				lista_cdc.add(curr_cdc);
		}
		lista_cdc.sort();
	}
}

void TPrint_bilancio_cms::execute_print(TReport_book & book, TAutomask & mask, TReport & rep, export_type & type)
{
  const int tipostampa = _mask->get_int(F_TIPOSTAMPA);
  //fasi
  const bool dett_fasi = (tipostampa == 1) || (tipostampa == 3);
  const TString& fase = _mask->get(F_FASE);
  const bool group_fasi = tipostampa == 4;
  const bool show_fasi = dett_fasi && fase.empty();
	const bool intestazione_minima = _mask->get_bool(F_INTESTAZIONE_MINIMA);

  //cdc
  const bool dett_cdc = (tipostampa == 2) || (tipostampa == 3);
  const TString& cdc = _mask->get(F_CDC);
  const bool group_cdc = tipostampa == 8;
  const bool show_cdc = dett_cdc && cdc.empty();


  //descrizioni
  const bool show_cms_descr = _mask->get_bool(F_SHOW_CMS_DESCR);
  const bool show_cms_date = _mask->get_bool(F_SHOW_CMS_DATE);

  //se e' una stampa di tipo fasi riassunte (crpa special edition) deve fare lo scanning di tutte le fasi..
  //..singolarmente e stampare un report per ogni fase.Senno' stampa un solo report

	if (dett_fasi && dett_cdc)
	{
		TString_array lista_fasi;
		TString_array lista_cdc;

		if (fase.blank() && cdc.blank())
		{
			((TPrint_bilancio_cms_rep & ) rep).set_filter(*_mask);
			book.add(rep, type);
		}
		else
		{
			build_lista_fasi(lista_fasi, fase);
			build_lista_cdc(lista_cdc, cdc);		//se la stampa e' con tutte le fasi distinte riassunte (crpa dedicate) fa un rep per fase...
			if (!lista_fasi.empty() && !lista_cdc.empty())
			{
				//per ogni fase crea un report e lo aggiunge al book
				FOR_EACH_ARRAY_ROW(lista_fasi, i, row_fasi)
				{
					TString16 fase = lista_fasi.row(i);

					FOR_EACH_ARRAY_ROW(lista_cdc, j, row_cdc)
					{
						const TString& cdc = lista_cdc.row(j);

						((TPrint_bilancio_cms_rep &)rep).set_filter(*_mask, fase, cdc);
						book.add(rep, type);
						if (rep.page() > 0)
						{
							if (intestazione_minima)
							{
								rep.section('H', 0).hide();
								rep.section('H', 1).hide();
							}
						}
					}
				}
			}
		}
	} //if(group_fasi...
	else
		if (group_fasi || dett_fasi)
		{
			TString_array lista_fasi;

			build_lista_fasi(lista_fasi, fase);
			//se la stampa e' con tutte le fasi distinte riassunte (crpa dedicate) fa un rep per fase...
			if (!lista_fasi.empty())
			{     
				//per ogni fase crea un report e lo aggiunge al book
				FOR_EACH_ARRAY_ROW(lista_fasi, i, row)
				{
					TString16 fase = lista_fasi.row(i);

					((TPrint_bilancio_cms_rep &)rep).set_filter(*_mask, fase);
					book.add(rep, type);
					if (rep.page() > 0)
					{
						if (intestazione_minima)
						{
							rep.section('H', 0).hide();
							rep.section('H', 1).hide();
						}
					}
				}
			}
		} //if(group_fasi...
		else
			if (group_cdc || dett_cdc)
			{
				TString_array lista_cdc;

				build_lista_cdc(lista_cdc, cdc);
				if (!lista_cdc.empty())
				{
					FOR_EACH_ARRAY_ROW(lista_cdc, j, row_cdc)
					{
						const TString& cdc = lista_cdc.row(j);

						((TPrint_bilancio_cms_rep &)rep).set_filter(*_mask, fase, cdc);
						book.add(rep, type);
						if (rep.page() > 0)
						{
							if (intestazione_minima)
							{
								rep.section('H', 0).hide();
								rep.section('H', 1).hide();
							}
						}
					}
				}
		} //if(group_cdc...
		else  //...senno' stampa standard in un giro solo
		{		  
			((TPrint_bilancio_cms_rep &)rep).set_filter(*_mask);
			book.add(rep, type);
		}
  
}

TReport & TPrint_bilancio_cms::get_report(const TAutomask & m)
{

	TString80 prefix;

	for (short id = F_PRE1; id <= F_PRE3 && m.id2pos(id) > 0; id++)
		prefix << m.get(id);

	const int depth = m.get_int(F_DEPTH);
	TString path = m.get(DLG_REPORT);

	const int tipostampa = m.get_int(F_TIPOSTAMPA);
	//fasi
	const bool dett_fasi = (tipostampa == 1) || (tipostampa == 3);
	const TString& fase = m.get(F_FASE);
	const bool group_fasi = tipostampa == 4;
	const bool show_fasi = dett_fasi && fase.empty();
	const bool sintetica = m.get_bool(F_STAMPA_SINTETICA);
	const bool intestazione_minima = m.get_bool(F_INTESTAZIONE_MINIMA);

	//cdc
	const bool dett_cdc = (tipostampa == 2) || (tipostampa == 3);
	const TString& cdc = m.get(F_CDC);
	const bool group_cdc = tipostampa == 8;
	const bool show_cdc = dett_cdc && cdc.empty();


	//descrizioni
	const bool show_cms_descr = m.get_bool(F_SHOW_CMS_DESCR);
	const bool show_cms_date = m.get_bool(F_SHOW_CMS_DATE);

	if (path.empty())
		path = ((TPrint_bilancio_cms_mask &)m).get_report_class();
	//crea il report in base ai parametri (tipo report,struttura,profondita' di stampa)
	safe_delete(_rep);
	_rep = new TPrint_bilancio_cms_rep(path, prefix, depth, show_fasi, show_cdc, show_cms_descr, show_cms_date, sintetica, intestazione_minima);
	return *_rep;
}

TAutomask & TPrint_bilancio_cms::get_mask()
{
	if (_mask == nullptr)
		_mask = new TPrint_bilancio_cms_mask;
	return *_mask;
}

TTrec * TPrint_bilancio_cms::get_dbase_recdesc(TReport & rep, const TAutomask & mask)
{
	TTrec * desc = new TTrec;
	TToken_string def;
	TRectype cms(LF_COMMESSE);
	TRectype fasi(LF_FASI);
	TRectype cdc(LF_CDC);

	const int tipostampa = mask.get_int(F_TIPOSTAMPA);
	const bool show_cms_descr = mask.get_bool(F_SHOW_CMS_DESCR);
	const bool show_cms_date = mask.get_bool(F_SHOW_CMS_DATE);
	const bool dett_fasi = (tipostampa == 1) || (tipostampa == 3);
	const bool dett_cdc = (tipostampa == 2) || (tipostampa == 3);
	const bool sintetica = mask.get_bool(F_STAMPA_SINTETICA);

	if (sintetica)
		desc->add_fielddef("COD", _alfafld, 4);

	desc->add_fielddef(cms.rec_des(), COMMESSE_CODCMS);
	desc->set_name("COMMESSA");
	if (show_cms_descr)
	{
		desc->add_fielddef(cms.rec_des(), COMMESSE_DESCRIZ);
		desc->set_name("TITOLO");
	}
	if (show_cms_date)
	{
		desc->add_fielddef("INIZIO", _datefld);
		desc->add_fielddef("FINE", _datefld);
	}
	if (dett_fasi)
		desc->add_fielddef(fasi.rec_des(), FASI_CODFASE);
	if (dett_cdc)
		desc->add_fielddef(cdc.rec_des(), CDC_CODCOSTO);
	desc->add_fielddef("PERCAV", _realfld, 6, 2);
	desc->add_fielddef("RICAVI", _realfld, 18, 2);
	desc->add_fielddef("INCARICHI", _realfld, 18, 2);
	desc->add_fielddef("CONSULENZE", _realfld, 18, 2);
	desc->add_fielddef("ALTRICOSTI", _realfld, 18, 2);
	desc->add_fielddef("MATERIALI", _realfld, 18, 2);
	desc->add_fielddef("GENINDIST", _realfld, 18, 2);
	desc->add_fielddef("DIPENDENTI", _realfld, 18, 2);
	desc->add_fielddef("COSTI", _realfld, 18, 2);
	desc->add_fielddef("MARGINE", _realfld, 18, 2);
	desc->add_fielddef("MPCT", _realfld, 6, 2);

	TString keydef = "COMMESSA";

	if (dett_fasi)
		keydef << '+' << FASI_CODFASE;
	if (dett_cdc)
		keydef << '+' << CDC_CODCOSTO;
	desc->add_keydef(keydef, true);
	if (show_cms_descr)
		desc->add_keydef("TITOLO", true);
	return desc;
}

bool TPrint_bilancio_cms::user_destroy()
{
	safe_delete(_mask);
	safe_delete(_rep);
	return TReport_application::user_destroy();
}

int ca3800(int argc, char* argv[])
{
  TPrint_bilancio_cms a;
  a.run(argc, argv, a.title());
  return 0;
}

//  LEVEL
//  _ 0 terminano nell'anno selezionato / iniziate nel passato														CTAP
//  _ 1 terminano nell'anno selezionato / iniziate nell'anno selezionato									CTAC
//  _ 2 terminano nel futuro / iniziate nel passato																				CCAP
//  _ 3 terminano nel futuro / iniziate nell'anno selezionato															CCAC
//  _ 4 di appoggio / terminano nell'anno selezionato / iniziate nell'anno selezionato		CTGG

//Istruzioni per i programmi ca3800 e ca3900
//------------------------------------------
// CA_3800
// Gestore maschera ca3800 (Analisi Bilancio di Commessa)
// Creatore del report e dell'applicazione

// CA_3801
// Gestore dei report a colonne variabili (stampa in base a struttura scelta per il PCONANA). Serve solo per ca3800.

// CA_3883
// Gestore del recordset per il calcolo dei valori da mettere sulle stampe (è il nucleo dei programmi ca3800 e ca3900)

// CA_3900
// Gestore maschera ca3900 (Stima ricavi di competenza)
// Creatore del report e dell'applicazione