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

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

#include "cglib01.h"
#include "cg7200a.h"

///////////////////////////////////////////////////////////
// Recordset
///////////////////////////////////////////////////////////
class TPrint_x_imponibile_recordset : public TAS400_recordset
{
public:
  TPrint_x_imponibile_recordset();
};

TPrint_x_imponibile_recordset::TPrint_x_imponibile_recordset()
: TAS400_recordset("AS400(512)")
{
  //const char* name, int pos, int len, TFieldtypes t = _alfafld, bool required = false, const TVariant& def = NULL_VARIANT
  //campi da LF_MOV
  create_field("Numreg",    -1, 7, _longfld, true);
  create_field("Datareg",   -1, 8, _datefld, true);
  create_field("Datadoc",   -1, 8, _datefld, true);
  create_field("Numdoc",    -1, 7, _alfafld, true);
  create_field("Tipodoc",   -1, 2, _alfafld, true);
  create_field("Codcaus",   -1, 3, _alfafld, true);
  create_field("Descr",     -1, 50, _alfafld, false);
  create_field("Reg",       -1, 3, _alfafld, true);
  create_field("Protiva",   -1, 6, _longfld, true);
  create_field("Tipo",      -1, 1, _alfafld, true);
  create_field("Codcf",     -1, 6, _longfld, true);
  create_field("Ragsoc",    -1, 50, _alfafld, true);
  create_field("Piva",      -1, 13, _alfafld, false);
  create_field("Cofi",      -1, 16, _alfafld, false);
  create_field("Totdoc",    -1, 18, _realfld, true);
  //campi da LF_RMOVIVA
  create_field("Imponibile",    -1, 18, _realfld, true);
  create_field("Imposta",       -1, 18, _realfld, false);
  create_field("Tipoiva",       -1, 2,  _alfafld, true);
  create_field("Imponibile_no", -1, 18, _realfld, false); //normale
  create_field("Imponibile_ni", -1, 18, _realfld, false); //non imponibile
  create_field("Imponibile_es", -1, 18, _realfld, false); //esente
  create_field("Imponibile_co", -1, 18, _realfld, false); //corrispettivo
  create_field("Imposta_co",    -1, 18, _realfld, false); //imposta corrispettivo
  
}
///////////////////////////////////////////////////////////
// Report
///////////////////////////////////////////////////////////

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

public:
  TPrint_x_imponibile_report();
};

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

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

class TPrint_x_imponibile_mask : public TAutomask
{
protected:
  bool convalida_clifo(const char tipocf, const long codcf);
  bool aggiungi_movimento(const TRectype& rec, TPrint_x_imponibile_recordset& output_recordset); 
  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() {}
};

bool TPrint_x_imponibile_mask::convalida_clifo(const char tipocf, const long codcf)
{
  if (tipocf <= ' ')
    return false;

  TToken_string key_clifo;
  key_clifo.add(tipocf);
  key_clifo.add(codcf);
  const TRectype& rec_clifo = cache().get(LF_CLIFO, key_clifo);
  const int alleg_clifo = rec_clifo.get_int(CLI_ALLEG);
  //solo per clifo esteri (alleg = 5)
  if (alleg_clifo == 5)
  {
    if (tipocf == 'F')  //tutti i fornitori esteri vanno esclusi (importazioni)
      return false;
    else                      //vanno esclusi solo i clienti esteri di stati pirata
    {
      const TString& stato_clifo = rec_clifo.get(CLI_STATOCF);
      const TRectype& rec_sta = cache().get("%STA", stato_clifo);
      if (rec_sta.get_bool("B0")) //cliente in stato a fiscalita' agevolata (stato pirata!) -> non ci va
        return false;
    }
  }

  return true;  //se arriva qui il clifo è da considerare
}

bool TPrint_x_imponibile_mask::aggiungi_movimento(const TRectype& rec, TPrint_x_imponibile_recordset& output_recordset)
{
  //controlla se il clifo è da considerare o meno nella stampa
  const char tipocf = rec.get_char(MOV_TIPO);
  const long codcf = rec.get_long(MOV_CODCF);
  if (!convalida_clifo(tipocf, codcf))
    return false;

  //se il cliente ha superato l'esame di ammissione si parte!
  //vanno esclusi gli scontrini anteriori al 30-04-2011 (evadete finchè potete...)
  const TString4 tipodoc = rec.get(MOV_TIPODOC);
  if (tipodoc == "SC" && rec.get_date(MOV_DATAREG) <= TDate(30, 4, 2011))
    return false;


  const TString& keytok = rec.get(MOV_NUMREG);
  TRecord_array righe_iva(keytok, LF_RMOVIVA);

  real tot_imponibile, tot_impon_no, tot_impon_ni, tot_impon_es, tot_impon_co;
  real tot_imposta, tot_imposta_co;
  TString4 tipoiva;   //dichiarata qui perchè serve nella scrittura dell' output_recordset

  //calcolo di imponibile ed imposta di tutte le righe iva del movimento
  for (int r = righe_iva.last_row(); r > 0; r = righe_iva.pred_row(r))
  {
    const TRectype& rmi = righe_iva.row(r);
    real imponibile = rmi.get_real(RMI_IMPONIBILE);
    real imposta = rmi.get_real(RMI_IMPOSTA);
    const TString& codiva = rmi.get(RMI_CODIVA);
    TCodiceIVA ci(codiva);

    //caso speciale degli scontrini (corrispettivi?)
    if (tipodoc == "SC")
    {
      if (imposta.is_zero())  //se l'imposta non è specificata..
      {
        imposta = ci.scorpora(imponibile);  //questo metodo crea l'imposta e riduce l'imponibile!
      }
      tot_impon_co += imponibile;
      tot_imposta_co += imposta;
    }
    else
    {
      tipoiva = ci.get("S1");
      //operazioni oggetto di comunicazione obbligatoria all'anagrafe tributaria (es: bollette luce)
      //ricordare all'utonto che il flag va attivato nella tabella IVA del codice corrispondente
      const bool com_obbl = ci.get_bool("B6");
      //non ci vanno manco quelli soggetti all'articolo 8 (del dpr 26/10/1972)
      const bool art_8 = ci.get("S2") == "20" && ci.get("S3") == "1";

      if (com_obbl || art_8)
        imponibile = imposta = ZERO;
      else
      {
        if (tipoiva == "NI" || tipoiva == "NS")
          tot_impon_ni += imponibile;
        else 
          if (tipoiva == "ES")
            tot_impon_es += imponibile;
          else
            tot_impon_no += imponibile;
      }
    }
    
    tot_imponibile += imponibile;
    tot_imposta += imposta;
  }

  if (tot_imponibile > get_real(F_LIMITE))
  {
    output_recordset.new_rec("");

    output_recordset.set("Numreg", rec.get_long(MOV_NUMREG));
    output_recordset.set("Datareg", rec.get_date(MOV_DATAREG));
    output_recordset.set("Datadoc", rec.get_date(MOV_DATADOC));
    output_recordset.set("Numdoc", rec.get_long(MOV_NUMDOC));
    output_recordset.set("Tipodoc", tipodoc);
    output_recordset.set("Codcaus", rec.get(MOV_CODCAUS));
    output_recordset.set("Descr", rec.get(MOV_DESCR));
    output_recordset.set("Reg", rec.get(MOV_REG));
    output_recordset.set("Protiva", rec.get_long(MOV_PROTIVA));
    output_recordset.set("Tipo", rec.get(MOV_TIPO));
    output_recordset.set("Codcf", codcf);
    TString80 ragsoc;
    TString16 piva, cofi;
    const TString16 ocfpi = rec.get(MOV_OCFPI);   //è uno stupido cliente occasionale?
    if (ocfpi.full())
    {
      const TRectype& rec_occas = cache().get(LF_OCCAS, ocfpi);
      ragsoc = rec_occas.get(OCC_RAGSOC);
      piva = rec_occas.get(OCC_PAIV);
      cofi = rec_occas.get(OCC_COFI);
    }
    else
    {
      TToken_string key_clifo;
      key_clifo.add(rec.get(MOV_TIPO));
      key_clifo.add(codcf);
      const TRectype& rec_clifo = cache().get(LF_CLIFO, key_clifo);
      ragsoc = rec_clifo.get(CLI_RAGSOC);
      piva = rec_clifo.get(CLI_PAIV);
      cofi = rec_clifo.get(CLI_COFI);
    }
    output_recordset.set("Ragsoc", ragsoc);
    output_recordset.set("Piva", piva);
    output_recordset.set("Cofi", cofi);
    output_recordset.set("Totdoc", rec.get_real(MOV_TOTDOC));
    output_recordset.set("Imponibile", tot_imponibile);
    output_recordset.set("Imposta", tot_imposta);
    output_recordset.set("Tipoiva", tipoiva);
    output_recordset.set("Imponibile_no", tot_impon_no);
    output_recordset.set("Imponibile_ni", tot_impon_ni);
    output_recordset.set("Imponibile_es", tot_impon_es);
    output_recordset.set("Imponibile_co", tot_impon_co);
    output_recordset.set("Imposta_co", tot_imposta_co);
  }

  return false;
}

void TPrint_x_imponibile_mask::elabora()
{
  const char tipodate = get(F_TIPODATE)[0];
  const TString& tipoelenco = get(F_TIPOELENCO);
  const long codcf = get_long(F_CODCF);
  const bool clifo_spec = codcf > 0L;
  const int anno = get_int(F_ANNO);
  const TDate dataini = get_date(F_DATAINI);
  const TDate datafine = get_date(F_DATAFIN);
  const real limite = get_real(F_LIMITE);

  TString query;

  query << "USE MOV KEY 2";
  query << "\nSELECT (TIPO=#TIPO)";
  if (clifo_spec)
    query << "&&(CODCF=#CODCF)";
  if (tipodate == 'D')  //per data 'D'ocumento
  {
    query << "&&(BETWEEN(DATADOC,#DATAINI,#DATAFINE))";
    query << "\nBY TIPO CODCF NUMREG";
    query << "\nFROM DATAREG=#DATAINI";
    TDate datadoc_fine = datafine;
    datadoc_fine.addyear(2);
    query << "\nTO DATAREG=" << datadoc_fine;
  }
  else  //per data 'R'egistrazione
  {
    query << "\nBY TIPO CODCF NUMREG";
    query << "\nFROM DATAREG=#DATAINI";
    query << "\nTO DATAREG=#DATAFINE";
  }
  //recordset con tutti i movimenti contabili di campo che soddisfano la query
  TISAM_recordset movimenti_recset(query);

  movimenti_recset.set_var("#TIPO", tipoelenco);
  movimenti_recset.set_var("#CODCF", codcf);
  
  movimenti_recset.set_var("#DATAINI", dataini);
  movimenti_recset.set_var("#DATAFINE", datafine);

  const long movimenti_recset_items = movimenti_recset.items();
  //recordset di output su cui scrivere i record validi da mandare in stampa!
  TPrint_x_imponibile_recordset* output_recordset = new TPrint_x_imponibile_recordset;
  //solita progind per intrattenere l'utonto
  TProgind pi(movimenti_recset_items, TR("Scansione movimenti in corso..."), true, true);

  //giro su tutti i movimenti contabili che soddisfano la query
  for (bool ok = movimenti_recset.move_first(); ok; ok = movimenti_recset.move_next())
  {
    if (!pi.addstatus(1))
      break;

    //metodo che decide se aggiungere i dati di un movimento all'output recordset
    //al suo interno ci sono tutti i filtri di legge!
    aggiungi_movimento(movimenti_recset.cursor()->curr(), *output_recordset); 
  }

#ifdef DBG
  output_recordset->save_as("D:/dati/crpa/cazzone.xls", fmt_html);
#endif

  //appiccia il recordset al report
  TPrint_x_imponibile_report rep;
  rep.set_recordset(output_recordset);
  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 movimenti per imponibile"));
  return 0;
}