#include <applicat.h>
#include <automask.h>
#include <execp.h>
#include <progind.h>
#include <recarray.h>
#include <recset.h>
#include <reprint.h>

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

#include "ammce.h"
#include "movce.h"
#include "salce.h"
#include "celib.h"

#include "ce3.h"
#include "ce3900.h"

////////////////////////////////////////////////////////
//	MASCHERA
////////////////////////////////////////////////////////
class TStampa_sintetica_mask : public TAutomask
{
protected:
  bool on_field_event(TOperable_field& o, TField_event e, long jolly);

public:
  TStampa_sintetica_mask();
  virtual ~TStampa_sintetica_mask() {}
};


bool TStampa_sintetica_mask::on_field_event(TOperable_field& o, TField_event e, long jolly)
{ 
  bool ok = true;
  switch (o.dlg())
  {
  case F_FROM_CAT:
  case F_D_FROM_CAT:
  case F_TO_CAT:
  case F_D_TO_CAT:
    {
      TDitta_cespiti& dc = ditta_cespiti();
      ok = dc.on_category_event(o, e, jolly);
    }
    break;

	case F_ESERCIZIO:
  case F_GRUPPO:
  case F_SPECIE:
    if (e == fe_init || e == fe_modify)
    {
      const TString& esercizio = get(F_ESERCIZIO);
      const TString& gruppo = get(F_GRUPPO);
      const TString& specie = get(F_SPECIE);
      TString16 key; key << esercizio << gruppo << specie;
      TRelation ccb("CCB");
      ccb.curr().put("CODTAB", key);
      if (ccb.read() == NOERR)
        autoload(ccb);
    }
    break;
  default: break;
  }
  return ok;
}


TStampa_sintetica_mask::TStampa_sintetica_mask()
								:TAutomask("ce3900")
{}


///////////////////////////////////////////////////////////////
//	RECORDSET
///////////////////////////////////////////////////////////////

class TStampa_sintetica_recordset : public TISAM_recordset
{
public:
  void set_filter(const TStampa_sintetica_mask& msk);
  TStampa_sintetica_recordset(const TString& sql) : TISAM_recordset(sql) { }
};

static const TStampa_sintetica_recordset* myself = NULL;

//metodo per caricare i valori nel recordset dalla maschera...fighissimo!!
void TStampa_sintetica_recordset::set_filter(const TStampa_sintetica_mask& msk)
{
	const TString& dacat = msk.get(F_FROM_CAT);
	const TString& acat = msk.get(F_TO_CAT);
	TString query = "USE CESPI";
	if (dacat.full() || acat.full())
	{
		query << " SELECT ";
		if (dacat == acat)
		{
			query << "CODCAT==" << dacat;
		}
		else
		{
			if (dacat.full())
				query << "(CODCAT>=" << dacat << ")";
			if (acat.full())
			{
				if (dacat.full())
					query << "&&";
				query << "(CODCAT<=" << acat << ")";
			}
		}
	}
	query << "\nBY CODCAT|IDCESPITE";
	set(query);	//setta la nuova query nel report (che avrebbe solo USE CESPI)
}

////////////////////////////////////////////////////////
//	REPORT
////////////////////////////////////////////////////////
class TStampa_sintetica_rep : public TReport
{
	int _anno;
protected:
	virtual bool get_usr_val(const TString& name, TVariant& var) const;
public:
	void set_filter(const TStampa_sintetica_mask& msk);
};

void TStampa_sintetica_rep::set_filter(const TStampa_sintetica_mask& msk)
{
  _anno = msk.get_int(F_ESERCIZIO);
	((TStampa_sintetica_recordset*) recordset())->set_filter(msk);
}

//metodo per il calcolo dei campi da calcolare (ma va'!) nel report
bool TStampa_sintetica_rep::get_usr_val(const TString& name, TVariant& var) const
{
	const TRecordset& recset = *recordset();
	const TString& idcespite = recset.get("IDCESPITE").as_string();
	if (name == "#DESCAT")	//categoria (descrizione della categoria corrente)
	{		
		const int gruppo = recset.get("CODCGRA").as_int();
		const TString& specie = recset.get("CODSPA").as_string();
		const int categoria = recset.get("CODCAT").as_int();
		const TRectype& rec_cac = ditta_cespiti().categoria(gruppo, specie, categoria);
		var = rec_cac.get("S0");
		return true;
	}
	if (name == "#ALIENAZ")	//movimenti di vendita
	{
		//cerca tutti i movimenti di vendita relativi al cespite corrente all'interno dell'esercizio.. 
		//..selezionato sulla maschera;somma i loro importi in modo da ricavare l'importo complessivo..
		//..di tutti
		TString query;

		TEsercizi_contabili esc;
    const TDate& dataini = esc[_anno].inizio();
		const TDate& datafine = esc[_anno].fine();

		query.format("USE MOVCE KEY 2 SELECT NUM(ANSI(DTMOV)>=%ld)&&NUM(ANSI(DTMOV)<=%ld)\nFROM IDCESPITE=%s\nTO IDCESPITE=%s",
								 dataini.date2ansi(), datafine.date2ansi(), (const char*)idcespite, (const char*)idcespite);
		TISAM_recordset isam(query);
		real somma_vendite;
		for (TRecnotype i = 0; isam.move_to(i); i++)
		{
			const real vendita = isam.get(MOVCE_IMPVEN).as_real();
			somma_vendite += vendita;
		}
		var = somma_vendite;

		return true;
	}
	if (name == "#COSTO")	//costo
	{
		TToken_string key;
		key = idcespite;	//cespite
		key.add(_anno);		//esercizio
		key.add(1);				//tiposaldo finale
		const TRectype& rec_salce = cache().get(LF_SALCE, key);
		const real costo = rec_salce.get_real(SALCE_CSTO);
		var = costo;
		return true;
	}
	if (name == "#PERCAMM")	//percentuale ammortamento
	{
		TToken_string key;
		key = idcespite;
		key.add(_anno);
		key.add(2);			//tiposaldo finale
		key.add(1);			//tipoamm fiscale
		const TRectype& rec_ammce = cache().get(LF_AMMCE, key);
		const real percamm = rec_ammce.get_real(AMMCE_PNOR) + rec_ammce.get_real(AMMCE_PACC) + rec_ammce.get_real(AMMCE_PANT);
		var = percamm;
		return true;
	}
	if (name == "#QAMM")	//fondo ammortamento esercizio corrente
	{
		TToken_string key;
		key = idcespite;
		key.add(_anno);
		key.add(2);			//tiposaldo finale
		key.add(1);			//tipoamm fiscale
		const TRectype& rec_ammce = cache().get(LF_AMMCE, key);
		const real quotamm = rec_ammce.get_real(AMMCE_QNOR) + rec_ammce.get_real(AMMCE_QACC) + rec_ammce.get_real(AMMCE_QANT);
		var = quotamm;
		return true;
	}
	if (name == "#FAMM")	//fondo ammortamento alla fine dell'esercizio precedente
	{
		TToken_string key;
		key = idcespite;
		key.add(_anno);
		key.add(1);			//tiposaldo iniziale
		key.add(1);			//tipoamm fiscale
		const TRectype& rec_ammce = cache().get(LF_AMMCE, key);
		const real quotamm = rec_ammce.get_real(AMMCE_QNOR) + rec_ammce.get_real(AMMCE_QACC) + rec_ammce.get_real(AMMCE_QANT);
		var = quotamm;
		return true;
	}

	return TReport::get_usr_val(name, var);
}

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


void TStampa_sintetica::main_loop()
{
	TStampa_sintetica_mask mask;
  while (mask.run() == K_ENTER)
  {
		//report e book dei report
		TReport_book book;
		TStampa_sintetica_rep rep;
		rep.load("ce3900a");

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

		book.print_or_preview();	//stampa il book dei report
	}
}

int ce3900(int argc, char* argv[])
{
  TStampa_sintetica a;
  a.run(argc, argv, TR("Stampa sintetica cespiti"));
  return 0;
}