#include <applicat.h>
#include <automask.h>
#include <recarray.h>
#include <relation.h>
#include <report.h>

#include <mov.h>
#include <rmoviva.h>
#include "../ba/ba8500.h"

#include "../cg/cg7200a.h"

///////////////////////////////////////////////////////////
// Recordset
///////////////////////////////////////////////////////////
class TPrint_x_imponibile_recordset : public TISAM_recordset
{
  static real _limite;

protected:
  static bool filtro(const TRelation* rel);
  virtual void set_custom_filter(TCursor& cursor) const;

public:
  TPrint_x_imponibile_recordset(const TString& sql) : TISAM_recordset(sql) {} 
};

real TPrint_x_imponibile_recordset::_limite;

bool TPrint_x_imponibile_recordset::filtro(const TRelation* rel)
{
  const TRectype& rec = rel->curr();
  
  const TString& keytok = rec.get(MOV_NUMREG);
  TRecord_array righe_iva(keytok, LF_RMOVIVA);

  real tot_imponibile;
  for (int r = righe_iva.last_row(); r > 0; r = righe_iva.pred_row(r))
    tot_imponibile += righe_iva.row(r).get_real(RMI_IMPONIBILE);

  return tot_imponibile > _limite;
}

void TPrint_x_imponibile_recordset::set_custom_filter(TCursor& cursor) const
{
  _limite = get("#LIMITE").as_real();
  cursor.set_filterfunction(filtro);
}

///////////////////////////////////////////////////////////
// Report
///////////////////////////////////////////////////////////

class TPrint_x_imponibile_report : public TReport
{
protected:
  virtual bool use_mask() { return false; }

public:
  virtual bool set_recordset(const TString& sql);
  TPrint_x_imponibile_report();
};

bool TPrint_x_imponibile_report::set_recordset(const TString& sql)
{
  TPrint_x_imponibile_recordset* recset = new TPrint_x_imponibile_recordset(sql);
  return TReport::set_recordset(recset);
}

TPrint_x_imponibile_report::TPrint_x_imponibile_report()
{
  load("cg7200a");
}

///////////////////////////////////////////////////////////
// Maschera
///////////////////////////////////////////////////////////

class TPrint_x_imponibile_mask : public TAutomask
{
protected:
  virtual bool on_field_event(TOperable_field& o, TField_event e, long jolly);

public:
  void elabora();
  TPrint_x_imponibile_mask();
  virtual ~TPrint_x_imponibile_mask() {}
};


void TPrint_x_imponibile_mask::elabora()
{
  const char tipodate = get(F_TIPODATE)[0];
  const char tipoelenco = get(F_TIPOELENCO)[0];
  const long codcf = get_long(F_CODCF);
  const int anno = get_int(F_ANNO);
  const TDate dataini = get_date(F_DATAINI);
  const TDate datafin = get_date(F_DATAFIN);
  const real limite = get_real(F_LIMITE);
  const real limite_farlocco = limite * 0.60;

  TString query;

  query << "USE MOV KEY 3";
  query << "\nSELECT (TOTDOC>=" << limite_farlocco.integer() << ")";
  if (tipodate == 'R')  //per data di 'R'egistrazione
  {
    if (codcf <= 0L)
      query << "&&(BETWEEN(DATAREG," << dataini.date2ansi() << "," << datafin.date2ansi() << "))";

    query << "\nFROM TIPO=" << tipoelenco;
    if (codcf > 0L)
    {
      query << " CODCF=" << codcf;
      query << " DATAREG=" << dataini.date2ansi();
    }

    query << "\nTO TIPO=" << tipoelenco;
    if (codcf > 0L)
    {
      query << " CODCF=" << codcf;
      query << " DATAREG=" << datafin.date2ansi();
    }
  }
  else      //per data 'D'ocumento
  {
    query << "&&(BETWEEN(DATADOC," << dataini.date2ansi() << "," << datafin.date2ansi() << "))";
    query << "\nBY CODCF DATADOC";
    query << "\nFROM TIPO=" << tipoelenco;
    if (codcf > 0L)
      query << " CODCF=" << codcf;

    query << "\nTO TIPO=" << tipoelenco;
    if (codcf > 0L)
      query << " CODCF=" << codcf;
  }

  TPrint_x_imponibile_report rep;
  rep.set_recordset(query);
  rep.mask2report(*this);
  rep.preview();

}

bool TPrint_x_imponibile_mask::on_field_event(TOperable_field& o, TField_event e, long jolly)
{
  switch (o.dlg())
  {
  case F_ANNO:
    if (e == fe_modify)
    {
      //in base all'anno varia il limite dell'imponibile da considerare
      const int anno = o.get_long();
      if (anno <= 2010)
        set(F_LIMITE, "25000");
      else
        set(F_LIMITE, "3000");

      //cambiando l'anno propone in automatico il dadata adata
      const TDate ini_anno(1, 1, anno);
      set(F_DATAINI, ini_anno);
      const TDate fine_anno(31, 12, anno);
      set(F_DATAFIN, fine_anno);
    }
    break;
  case F_DATAINI:
  case F_DATAFIN:
    if (e == fe_modify || e == fe_close)
    {
      const TDate data = get_date(o.dlg());
      const int anno = get_int(F_ANNO);
      if (data.year() != anno)
        return error_box("La data deve appartenere all'anno selezionato!");
    }
    break;
  default:
    break;
  }
  return true;
}

TPrint_x_imponibile_mask::TPrint_x_imponibile_mask() : TAutomask("cg7200a")
{
}


///////////////////////////////////////////////////////////
// Applicazione
///////////////////////////////////////////////////////////

class TPrint_x_imponibile : public TKlarkKent_app
{
protected:
  
public:
  virtual void main_loop();
};


void TPrint_x_imponibile::main_loop()
{
 TPrint_x_imponibile_mask mask;
  
  while (mask.run() == K_ENTER)
  {
    mask.elabora();
  }
}

int cg7200(int argc, char* argv[])
{     
  TPrint_x_imponibile app;
  app.run(argc, argv, TR("Lista fatture per imponibile"));
  return 0;
}