#include <relapp.h>
#include <msksheet.h>
#include <sheet.h>
#include <utility.h>
#include <lffiles.h>
#include <effetti.h>
#include <reffetti.h>
#include <cession.h>
#include "ef0.h"
#include "ef0300.h"
#include "ef0301.h"

//Classe per la gestione di distinte (inserimento, modifica, cancellazione) 
//  e per la creazione automatica di distinte per importi.
class TVariazione_distinte: public TRelation_application
{
  TMask *_msk, *_m2;
  TDistinta *_distinta;
  TRelation *_rel;                                                    
  TLocalisamfile *_reff, *_cession;
protected:                            
  virtual void init_query_mode(TMask&); 
  virtual void init_insert_mode(TMask&);
  virtual const char* get_next_key();  
  virtual int read(TMask& m);
  virtual int rewrite(const TMask& m);
  virtual int write(const TMask& m);
  virtual bool remove(char tipodist, long ndist);    
  virtual TMask* get_mask(int mode) {return _msk;}
  virtual bool changing_mask(int mode) {return FALSE;}
  static bool aggiungi_handler(TMask_field& f, KEY k);
  static bool elimina_handler(TMask_field& f, KEY k); 
  static bool impdist_notify(TSheet_field& s, int r, KEY key);      
  static bool m2_handler(TMask& m, KEY key);
  static bool conferma_handler(TMask_field& f, KEY k);
  static bool annulla_handler(TMask_field& f, KEY k); 
  static void calcola_totale();                          
  static void carica_riba();
  TSheet_field& righe_sheet() const;
  TSheet_field& righe_sel_sheet() const;
  bool cerca(long num);
  bool user_create();
  bool user_destroy();
  void aggiorna();
  void elimina(TString16 tipodist, long ndist) ;
  TToken_string* common_f(const TMask& m);
public:
  virtual TRelation* get_relation() const {return _rel;}
  TVariazione_distinte() {};
  virtual ~TVariazione_distinte() {};
};

inline TVariazione_distinte& app()
{
  return (TVariazione_distinte&)main_app();
}

void TVariazione_distinte::init_query_mode(TMask&) 
{ 
  _msk->reset(F_TOTIMP);
  _msk->reset(F_TOTIMPVAL);
}   
  
void TVariazione_distinte::init_insert_mode(TMask&)
{ 
  _msk->reset(F_TOTIMP);
  _msk->reset(F_TOTIMPVAL);
  TToken_string riga("|||||||||||");
  righe_sheet().row(0)= riga;
  righe_sheet().set_dirty();
  righe_sel_sheet().row(0)= riga;
  righe_sel_sheet().set_dirty();
} 

//Ritorna il prossimo numero valido di chiave   
const char* TVariazione_distinte::get_next_key()
{       
  TLocalisamfile& effetti = _rel->lfile();;
  long ndist=1L;    
  if ( !effetti.empty() )
  {
    effetti.zero();
    effetti.setkey(4);
    effetti.last();
    if ( effetti.good() )
      ndist+=effetti.get_long(EFF_NDIST);
  }
  return format("%d|%ld",F_NUMBER,ndist);
}

//Ritorna un riferimento allo sheet degli effetti (righe) nella distinta 
TSheet_field& TVariazione_distinte::righe_sheet() const
{
  TSheet_field& r_sheet = (TSheet_field&)_msk->field(F_SHEET_RIBA);
  return r_sheet;
}

//Ritorna un riferimento allo sheet delle righe 
TSheet_field& TVariazione_distinte::righe_sel_sheet() const
{
  TSheet_field& r_sheet = (TSheet_field&)_m2->field(F_SHEET);
  return r_sheet;
}

//Ritorna TRUE se trovo nel'array delle righe distinta l'effetto passato
bool TVariazione_distinte::cerca(long num)
{
  bool trovato = FALSE;
  int items = _distinta->items(); 
  TArray& righedist = _distinta->righe();
  for (int i = 0; i < items; i++)//ciclo sugli elementi dell'array
  {
     TEffetto& eff = (TEffetto&)righedist[i];
     long num_eff = eff.get_long("NPROGTR");
     if (num_eff == num) 
     {
      trovato = TRUE;
      continue;
     } 
  }
  return trovato;   
}         

//Metodo che permette di scivere sull'array gli effetti presenti nello sheet
//  comune a write e rewrite
void TVariazione_distinte::aggiorna()
{       
  TSheet_field& shrighe = righe_sheet();
  int items = shrighe.items();
  for (int i = 0; i < items; i++)
  {                   
    TToken_string& row = shrighe.row(i);                
    row.restart();               
    long num = row.get_long(1);
    if (!cerca(num))
    {
      TLocalisamfile eff(LF_EFFETTI);
      TRectype rec = eff.curr();
      eff.setkey(1);
      rec.zero();
      rec.put(EFF_NPROGTR, num);
      int err = eff.read();      
      TEffetto* effetto= new TEffetto(rec);
      TArray& righedist = _distinta->righe();
      righedist.add(effetto);
    }
  }  
}

//Metodo che permette di eliminare il collegamento tra effetto e distinta per gli
//effetti che non fanno parte dell'array
void TVariazione_distinte::elimina(TString16 tipodist, long ndist)
{
  TLocalisamfile eff(LF_EFFETTI);
  eff.put("TIPODIST",tipodist);
  eff.put("NDIST",ndist);
  eff.read(_isgteq);  
  TString16 t = eff.get("TIPODIST");
  long n = eff.get_long("NDIST");   
  long num =eff.get_long("NPROGTR");
  while ((t==tipodist)&&(n==ndist)) 
  {         
    if (!cerca(num))
    {
      eff.zero("TIPODIST");
      eff.zero("NDIST");
      eff.zero("DATADIST");
      eff.zero("NRIGADIST");
      eff.zero("CODABIP");
      eff.zero("CODCABP");
      eff.rewrite();
    }
    eff.next();
    t = eff.get_char("TIPODIST");
    n = eff.get_long("NDIST");  
  }
}  

//Metodo che permette di scivere su file i dati inseriti nella maschera;
//  comune a write e rewrite 
TToken_string* TVariazione_distinte::common_f(const TMask& m)
{ 
  TString16 tipodist = m.get(F_TIPODIST);
  long ndist = m.get_long(F_NUMBER);
  TDate datadist = (TDate)m.get(F_DATA);
  long codabi = m.get_long(F_CODABIP);
  long codcab = m.get_long(F_CODCABP);
  elimina(tipodist, ndist);
  m.autosave(*_rel);     
  TToken_string* datidist= new TToken_string;    
  datidist->cut(0);    
  datidist->add(tipodist);
  datidist->add(ndist);
  datidist->add(datadist);
  datidist->add(codabi);
  datidist->add(codcab);
  return datidist;
}

int TVariazione_distinte::read(TMask& m)
{ 
  m.autoload(*_rel);          
  int err = _rel->status();
  if (err == NOERR)
  {                           
    err = _distinta->reset();
    err = _distinta->read(_rel->curr());
    if (err == NOERR)
    { 
      TToken_string riga(80);
      TSheet_field& shrighe = righe_sheet();
      shrighe.reset();  
      int items = _distinta->items();
      TArray& righedist = _distinta->righe();
      for (int i = 0; i < items; i++)
      {
        TEffetto& eff = (TEffetto&)righedist[i]; 
        riga.cut(0);    
        riga.add(FALSE);
        riga.add(eff.get(EFF_NPROGTR));
        riga.add(eff.get(EFF_DATASCAD));
        riga.add(eff.get(EFF_CODCF));
        if (eff.rows_r() == 1)         //se l'effetto contiene solo una riga metto i
        {                              //riferimenti al documento ed al numero di rata
          const TRectype& rec_r = eff.row_r(1); 
          riga.add(rec_r.get(REFF_NFATT));
          riga.add(rec_r.get(REFF_DATAFATT));
          riga.add(rec_r.get(REFF_NRATA));
        }
        else                          //se l'effetto contiene pił di una riga  non metto i
        {                             //riferimenti al documento ed al numero di rata
          riga.add(("Varie"));
          riga.add(("Varie"));
          riga.add(("Varie"));   
        }
        TString codval(3);           //gestisco il controllo sulla presenza o meno di una valuta
        codval = eff.get(EFF_CODVAL);
        const bool condition = (codval.empty()); 
        m.enable(F_CODVAL, !condition);
        m.enable(F_TOTIMPVAL, !condition);
        if (!condition) 
          m.set(F_CODVAL, codval);
        riga.add(codval);
        riga.add(eff.get(EFF_IMPORTO));
        riga.add(eff.get(EFF_IMPORTOVAL));
        shrighe.row(i) = riga;
      }
    }
  }
  return err;
}

int TVariazione_distinte::rewrite(const TMask& m)
{
  aggiorna();        
  return _distinta->rewrite(common_f(m));
}

int TVariazione_distinte::write(const TMask& m)
{            
  aggiorna();
  return _distinta->write(TRUE, common_f(m));
}
 
bool TVariazione_distinte::remove(char tipodist, long ndist) 
{                                           
  return _distinta->remove(tipodist, ndist) == NOERR;
}

 
bool TVariazione_distinte::user_create()
{
  _msk = new TMask("ef0300a");  
  _m2 = new TMask("ef0300c");
  _rel = new TRelation(LF_EFFETTI);
  _reff = new TLocalisamfile(LF_REFFETTI);
  _cession = new TLocalisamfile(LF_CESS);  
  _distinta = new TDistinta;  
  set_search_field(F_NUMBER);
  _msk->set_handler(B_AGGIUNGI, aggiungi_handler);
  _msk->set_handler(B_ELIMINA, elimina_handler); 
  _m2->set_handler(DLG_OK, conferma_handler);
  _m2->set_handler(DLG_CANCEL, annulla_handler); 
  _m2->set_handler(m2_handler);
  righe_sheet().set_notify(impdist_notify); 
  return TRUE;
}

bool TVariazione_distinte::user_destroy()
{
  delete _msk;  
  delete _m2;
  delete _rel;                          
  delete _reff;
  delete _cession;
  delete _distinta;
  return TRUE;
}

//Permette di gestire lo sheet per la selezione delle riba da aggiungere alla distinta
void TVariazione_distinte::carica_riba()
{                          
  TLocalisamfile f(LF_EFFETTI);
  TRectype rec = f.curr();
  f.setkey(4);
  f.put("TIPODIST","");
  f.put("NDIST",0);
  f.put("NRIGADIST",0);
  f.read(_isgteq);  
  TString16 t = rec.get("TIPODIST");
  long n = rec.get_long("NDIST");   
  
  int i = 0;
  while ((t.empty())&&(n==0)) 
  {     
    TToken_string riga(80);           
    TMask* m2 = app()._m2;     
    TSheet_field& sf = (TSheet_field&)m2->field(F_SHEET);
    sf.reset();  
    riga.cut(0);
    riga.add(FALSE);
    riga.add(rec.get(EFF_NPROGTR));
    riga.add(rec.get(EFF_DATASCAD));
    riga.add(rec.get(EFF_CODCF));
    TEffetto eff(rec);
    if (eff.rows_r() == 1)         //se l'effetto contiene solo una riga metto i
    {                              //riferimenti al documento ed al numero di rata
       const TRectype& rec_r = eff.row_r(1); 
       riga.add(rec_r.get(REFF_NFATT));
       riga.add(rec_r.get(REFF_DATAFATT));
       riga.add(rec_r.get(REFF_NRATA));
    }
    else                          //se l'effetto contiene pił di una riga  non metto i
    {                             //riferimenti al documento ed al numero di rata
       riga.add(("Varie"));
       riga.add(("Varie"));
       riga.add(("Varie"));   
    }
    riga.add(rec.get(EFF_CODVAL));
    riga.add(rec.get(EFF_IMPORTO));
    riga.add(rec.get(EFF_IMPORTOVAL));
    sf.row(i) = riga;
    
    f.next();
    t = rec.get("TIPODIST");
    n = rec.get_long("NDIST");  
    i++;
  } 
}

//handler per gestire la pressione del bottone aggiungi della maschera principale(ef0300a)
bool TVariazione_distinte::aggiungi_handler(TMask_field& f, KEY k)
{ 
  if (k==K_SPACE)
    {
      TMask &m = f.mask();
      m.close();
      TMask* m2 = app()._m2;   
      m2->open();
    }
  return TRUE;
} 
  
//handler per gestire la pressione del bottone elimina della maschera principale(ef0300a)
bool TVariazione_distinte::elimina_handler(TMask_field& f, KEY k)
{  
  if (k==K_SPACE)  
        f.yesno_box("Vuoi veramente eliminare gli effetti");
  // SE SI ELIMINARE DALLO SHEET GLI EFFETTI SELEZIONATI (LA RIMOZIONE FISICA SARA' FATTA AL
  // MOMENTO DELLA REGISTRAZIONE, SE NO NON FACCIO NULLA
  return TRUE;  
}             

//handler per gestire la pressione del bottone conferma della maschera per l'aggiunta delle riba(ef0300c)
bool TVariazione_distinte::conferma_handler(TMask_field& f, KEY k)
{ 
  if (k==K_ENTER)
  { 
    TMask &m = f.mask();
    TMask* m2 = app()._msk;   
    m.close();                
    m2->open();
  }
  return TRUE;  
}             

//handler della maschera per l'aggiunta delle riba(ef0300c)
bool TVariazione_distinte::m2_handler(TMask& m, KEY k)
{             
  if (k==K_ENTER)
    carica_riba();
  return TRUE;
}

//handler per gestire la pressione del bottone annulla della maschera per l'aggiunta delle riba(ef0300c)
bool TVariazione_distinte::annulla_handler(TMask_field& f, KEY k)
{    
  TMask &m = f.mask();
  TMask* m2 = app()._msk;   
  m.close();
  m2->open();
  return TRUE;  
}             

//Calcola i totali relativi alla distinta (totale in lire e totale in valuta(se presente)) 
void TVariazione_distinte::calcola_totale()
{ 
  TMask* m = app()._msk;
  TSheet_field& sf = (TSheet_field&)m->field(F_SHEET_RIBA);
  int items = sf.items();         
  real imp, impval, impdist, impdistval;  
  for (int i = 0; i < items; i++)
  {
     TToken_string& row = sf.row(i);   
     imp = row.get(8);
     impdist += imp;
     impval = row.get(9);
     impdistval += impval;
  }
  m->set(F_TOTIMP, impdist);
  m->set(F_TOTIMPVAL, impdistval);   
}  

//Notify per il calcolo dei totali relativi alla distinta  
bool TVariazione_distinte::impdist_notify(TSheet_field& s, int r, KEY key)
{            
  if (s.to_check(key, TRUE)) 
    calcola_totale();
  if (key == K_DEL && s.items()==1)
  {
    error_box("IMPOSSIBILE CANCELLARE: La distinta deve contenere almeno un effetto!");
    return FALSE;
  }
  return TRUE;
}

int ef0300(int argc, char* argv[])
{
  TVariazione_distinte a ;
  a.run(argc, argv, "Gestione Distinte");
  return 0;
}