#include "pg0214100a.h"

#include <applicat.h>
#include <automask.h>
#include <modaut.h>
#include <progind.h>
#include <recarray.h>
#include <relation.h>
#include <reprint.h>
#include <reputils.h> 
#include <textset.h>

#include "../cg/cg2103.h"
#include "../cg/cglib02.h"
#include "../cg/cgsaldac.h"
#include "../ve/velib.h"

#include "clifo.h"
#include "comuni.h"

#include <causali.h>
#include <mov.h>
#include <pconti.h>
#include <rmov.h>
#include <rmoviva.h>


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

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

TCertificazioni_mask::TCertificazioni_mask() : TAutomask("pg0214100a")
{
}

bool TCertificazioni_mask::on_field_event(TOperable_field& o, TField_event e, long jolly)
{
  return true;
}

/////////////////////////////////////////////////////////////
//  REPORT
/////////////////////////////////////////////////////////////
class TCertificazioni_report : public TReport
{
protected:
virtual bool use_mask() { return false; }
public:
  TCertificazioni_report() {}
};

/////////////////////////////////////////////////////////////
//	CSV RECORDSET
/////////////////////////////////////////////////////////////

class TCertificazioni_csv_recordset : public TCSV_recordset
{
protected:
public:
	TCertificazioni_csv_recordset();
};

TCertificazioni_csv_recordset::TCertificazioni_csv_recordset() 
: TCSV_recordset("CSV(,)\n")
{
}


///////////////////////////////////////////////////////////
// APPLICAZIONE
///////////////////////////////////////////////////////////

class TCertificazioni : public TSkeleton_application
{

	virtual bool check_autorization() const {return false;}
	virtual const char * extra_modules() const {return "cg";}

protected:
  void elabora(const TMask& mask) const;
  void scrivi_csv(const TRectype& prima_riga, TCertificazioni_csv_recordset& csv, const int gruppo, const int conto, const long sottoconto) const;

public:
	virtual bool create();
  virtual void main_loop();

};

// scorre le righe di movimento e fa i calcoli per stampare la riga di report 
void TCertificazioni::scrivi_csv(const TRectype& prima_riga, TCertificazioni_csv_recordset& csv, const int gruppo, const int conto, const long sottoconto) const
{
	long numreg = prima_riga.get_long(RMV_NUMREG);
 
	TMovimentoPN movpn;
	movpn.lfile().setkey(1);
	TRectype& mov = movpn.curr();
	mov.put(MOV_NUMREG, numreg);
	if (movpn.read() == NOERR)
	{
    csv.new_rec("");
		real importo = ZERO;
		for (int i=0; i<movpn.cg_items(); i++)
		{
			TRectype& rmov = movpn.cg(i);
			const int gr = rmov.get_int(RMV_GRUPPO);
			const int co = rmov.get_int(RMV_CONTO);
			const long so = rmov.get_long(RMV_SOTTOCONTO);
			const char sez = rmov.get(RMV_SEZIONE)[0];
			if (sez =='A')
			{
				if ((gr==gruppo) && (co==conto) && (so==sottoconto)) // ritenuta
			    csv.set(5, (TVariant)rmov.get_real(RMV_IMPORTO)); // ritenuta
				else
			    csv.set(3, (TVariant)rmov.get_real(RMV_IMPORTO)); // imponibile
			}
			else
					importo += rmov.get_real(RMV_IMPORTO);
		}
		if (importo != ZERO)
			csv.set(0, (TVariant)importo); // compenso lordo
	}
}


//metodo di base per la ricerca delle righe movimento che soddisfano le condizioni
void TCertificazioni::elabora(const TMask& mask) const
{
	// date
  const TDate dataini = mask.get_date(F_DADATA);
  const TDate datafin = mask.get_date(F_ADATA);
  
  TConfig ditta_ini(CONFIG_DITTA, "ve");

  //Adesso prende i conti da verificare
  TSheet_field& sf = mask.sfield(F_CONTI);

  //la query e' sulle righe movimento
  TString query;
  query << "USE RMOV KEY 2\n";
  query << "SELECT (NUM(ANSI(23.DATACOMP))>=NUM(ANSI(#DADATA)))&&(NUM(ANSI(23.DATACOMP))<=NUM(ANSI(#ADATA)))\n";
  query << "JOIN MOV INTO NUMREG==NUMREG\n";
  query << "FROM GRUPPO=#GRUPPO CONTO=#CONTO SOTTOCONTO=#SOTTOCONTO\n";
  query << "TO GRUPPO=#GRUPPO CONTO=#CONTO SOTTOCONTO=#SOTTOCONTO\n";
  query << "BY MOV.CODCF\n";

  TISAM_recordset rmov(query);

	// filtro per date
	rmov.set_var("#DADATA", dataini);
	rmov.set_var("#ADATA", datafin);

  //creazione del csv recordset che verra' riempito dalla elaborazione
  TCertificazioni_csv_recordset* csv = new TCertificazioni_csv_recordset;

  //quante righe dello sheet processa?
  const long tot_items = sf.items();

  //Visto che e' possibile avere una secchiata di conti, gli tocca fare un giro per ogni conto
	// in realta' secondo me si potrebbe avere un conto solo (quello delle ritenute)
  FOR_EACH_SHEET_ROW(sf, r, row)
  {
    //estrazione definitiva dei record che soddisfano il casino di parametri richiesti
    rmov.set_var("#GRUPPO", row->get(0));
    rmov.set_var("#CONTO", row->get(1));
    rmov.set_var("#SOTTOCONTO", row->get(2));

    //quanti record validi ha trovato?
    const long items = rmov.items();

    //E crea pure la progind..
    TProgind pi(tot_items, TR("Generazione righe..."), true, true);

    long last_nmov = 0;

    //Scansione del recordset trovato
    for (bool ok = rmov.move_first(); ok; ok = rmov.move_next())
	  {
      if (!pi.addstatus(1))
        break;
      
      const long nmov = rmov.get(RMV_NUMREG).as_int();
			const int gruppo = rmov.get(RMV_GRUPPO).as_int();
			const int conto = rmov.get(RMV_CONTO).as_int();
			const long sottoconto = rmov.get(RMV_SOTTOCONTO).as_int();
      if (nmov != last_nmov)
      {
        scrivi_csv(rmov.cursor()->curr(), *csv, gruppo, conto, sottoconto);
        last_nmov = nmov;
      }

    } //for(bool ok = rmov.move_first(..

  } //FOR_EACH...
  
  
  //creazione del report di stampa
	TCertificazioni_report rep;
	bool ok = rep.load("pg0214100a");
  //setta il recordset...
  //deve settare almeno un campo manualmente perche' funzioni la mask2report
  csv->set_var("#EMAIL", TVariant("Manca la email"), true);
  rep.set_recordset(csv);
  //..e poi carica i valori sulla maschera nel report!!!!
  rep.mask2report(mask);

	if (ok)
	{
		TReport_book book;
		ok = book.add(rep);
		if (ok)
			book.print_or_preview();
  }
}

void TCertificazioni::main_loop()
{
  TCertificazioni_mask mask;
  mask.field(F_CODDITTA).check(RUNNING_CHECK);
  while (mask.run() == K_ENTER)
  {
    elabora(mask);
  }
} 

bool TCertificazioni::create()
{
 	return TSkeleton_application::create();
}

int pg0214100(int argc, char* argv[])
{
  TCertificazioni dc;
  dc.run(argc, argv, TR("Stampa certificazioni"));
  return 0;
}