#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;
	void genera_righe_tributi(const TMovimentoPN& movpn) const;

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

};


//crea il documento che contiene la riga che gli viene passata,cerca la riga generata ed in base al risultato della ricerca chiama..
//..il metodo adatto
void TCertificazioni::scrivi_csv(const TRectype& prima_riga, TCertificazioni_csv_recordset& csv) 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)
	{
		genera_righe_tributi(movpn);
	} 
}

void TCertificazioni::genera_righe_tributi(const TMovimentoPN& movpn) const
{
}


//metodo di base per la ricerca delle righe movimento che soddisfano le condizioni
void TCertificazioni::elabora(const TMask& mask) const
{
  //Tanto per cominciare stabilisce il range di date...
  const TDate dataini = mask.get_date(F_DADATA);
  const TDate datafin = mask.get_date(F_ADATA);
  
  //Adesso tocca al codice articolo in base alla specie CONAI
  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
  //cerca le righe con numerazione e tipo indicate nello sheet;prende sia le righe che generano CONAI (per avere il codice conai,..
  //..le quantita' etc) e le righe generate da CONAI (per avere i prezzi)
  TString query;
  query << "USE RMOV KEY 1\n";
  query << "SELECT (NUM(ANSI(23.DATAMOV))>=NUM(ANSI(#DADATA)))&&(NUM(ANSI(23.DATAMOV))<=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";

  TISAM_recordset rmov(query);

	rmov.set_var("#DADATA", dataini);
	rmov.set_var("#ADATA", datafin);

  //creazione del csv recordset che verra' riempito dai record del recordset rdoc
  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
  FOR_EACH_SHEET_ROW(sf, r, row)
  {
    //estrazione definitiva dei record che soddisfano il casino di parametri richiesti
    rmov.set_var("#GRUPPO", TVariant(row->get(0)));
    rmov.set_var("#CONTO", TVariant(row->get(1)));
    rmov.set_var("#SOTTOCONTO", TVariant(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();
      if (nmov != last_nmov)
      {
        scrivi_csv(rmov.cursor()->curr(), *csv);
        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()
{
  if (!has_module(DCAUT))
    return error_box(TR("Modulo non autorizzato"));

	return TSkeleton_application::create();
}

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