#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, *_clifo;
protected:                            
  virtual void init_query_mode(TMask&); 
  virtual void init_insert_mode(TMask&); 
  virtual void init_modify_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();    
  virtual TMask* get_mask(int mode) {return _msk;}
  virtual bool changing_mask(int mode) {return FALSE;} 
  static bool codval_handler(TMask_field& f, KEY k);
  static bool importo_handler(TMask_field& f, KEY k);
  static bool imp_aut_handler(TMask_field& f, KEY k);
  static bool impdist_notify(TSheet_field& s, int r, KEY key); 
  static bool imp_notify(TSheet_field& s, int r, KEY key);       
  static bool conferma_handler(TMask_field& f, KEY k);
  static bool annulla_handler(TMask_field& f, KEY k); 
  static bool from_data_handler(TMask_field& f, KEY k);
  static bool to_data_handler(TMask_field& f, KEY k);
  static bool ordina_handler(TMask_field& f, KEY k);
  static void calcola_totale(); 
  static void calcola();                    
  static void aggiungi();      
  static void carica_riba();
  static void ord_data();
  static void ord_fatt();
  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();  
  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->enable(F_NUMBER);
  _msk->enable(F_TIPODIST);
  _msk->reset(F_TOTIMP);
  _msk->reset(F_TOTIMPVAL);
}   
  
void TVariazione_distinte::init_insert_mode(TMask&)
{ 
  _msk->reset(F_TOTIMP);
  _msk->reset(F_TOTIMPVAL);
  _msk->enable(F_TOTIMPVAL);
  _msk->enable(F_CODVAL);
  _msk->disable(F_NUMBER);
  _msk->disable(F_TIPODIST);
} 

void TVariazione_distinte::init_modify_mode(TMask&)
{ 
  _msk->disable(F_NUMBER);
  _msk->disable(F_TIPODIST);
} 

//Ritorna il prossimo numero di distanta valido   
const char* TVariazione_distinte::get_next_key()
{ 
  long ndist = 1L;
  TLocalisamfile& effetti = _rel->lfile(); 
  effetti.zero();
  effetti.put("NDIST",ndist); 
  effetti.setkey(4);
  int err = effetti.read(_isgteq);                    
  if ( (err == _iskeynotfound) || (err == _iseof) ) //se non esiste alcuna distinta:
  {                                                 // il numero sarà 1
    err == NOERR;                              
    return format("%d|%ld", F_NUMBER, ndist);
  }
  while (err == NOERR)                              //se esitono già delle distinte:
  {                                                 //  le leggo tutte  e ne prendo il
    effetti.setkey(4);                              //  numero, al verificarsi della fine file
    err = effetti.next();                           //  ho l'ultimo numero utilizzato
    long n = effetti.get_long("NDIST");             //  incrementandolo avrò il numero che cercavo.
    if (n > ndist) 
      ndist = n;
  } 
  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
  {                              //se l'array è vuoto non trova nulla ed esce subito
     TEffetto& eff = (TEffetto&)righedist[i];
     long num_eff = eff.get_long("NPROGTR");
     if (num_eff == num) 
     {
      trovato = TRUE;
      break;// esco quando ho già trovato l'effetto che cercavo
     }   
  }
  return trovato;   
}         

//Metodo che permette di scivere sull'array (in memoria) gli effetti presenti nello sheet
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 prendere i dati dalla maschera e metterli in una TToken_string
//che servirà per passare i dati alla write della distinta
TToken_string* TVariazione_distinte::common_f(const TMask& m)
{ 
  char tipodist = m.get(F_TIPODIST)[0];
  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);
  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(); //resetto l'array che contiene gli effetti nella distinta
    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++) // carico tutti gli effetti della distinta nello sheet
      {
        TEffetto& eff = (TEffetto&)righedist[i]; 
        riga.cut(0);    
        riga.add(' ');
        riga.add(eff.get(EFF_NPROGTR));
        riga.add(eff.get(EFF_DATASCAD));       
        long codcf = eff.get_long(EFF_CODCF); //prendo la ragione sociale del cliente
        _clifo->zero();                       //conoscendone il codice
        _clifo->put("TIPOCF", 'C');
        _clifo->put("CODCF", codcf);
        if (_clifo->read() == NOERR) riga.add(_clifo->get("RAGSOC"));
        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);
        if (i == 0)
        {
          const bool condition = (codval.empty() || codval == "LIT"); 
          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;
}

//Si prendono tutte le righe dello sheet e si controlla il primo campo se e' a true si distrugge
// la riga e si aggiorna il file.
// GLI EFFETTI PRESENTI NELLO SHEET DEVONO GIA ESSERE STATI REGISTRATI NEL FILE.
void TVariazione_distinte::elimina()
{  
    TEffetto eff;
    TLocalisamfile file(LF_EFFETTI); 
    char tipodist = _msk->get(F_TIPODIST)[0];
    long ndist = _msk->get_long(F_NUMBER);
    TDistinta* distinta = app()._distinta;
    TSheet_field& sf = (TSheet_field&)_msk->field(F_SHEET_RIBA);
    bool condition = FALSE, deleted = FALSE;       
    TArray& righedist = distinta->righe();
    for (int i = 0, k = i+1; i < sf.items(); i++, k++)//ciclo sugli elementi dello sheet
    {
       if (deleted) i--; //per posizionarsi correttamente sulla prima riga dello sheet
       if (sf.items() == 1)  
       {
         error_box("IMPOSSIBILE CANCELLARE: La distinta deve contenere almeno un effetto!");
         break;
       }
       TToken_string& row = sf.row(i);   
       condition = *row.get(0) == 'X';
       if (condition)
       {                                 
             long num = row.get_long(1);
             for (int j = 0; j < distinta->items(); j++)//ciclo sugli elementi dell'array
             {
                TEffetto& eff = (TEffetto&)righedist[j];
                long num_eff = eff.get_long("NPROGTR");
                if (num_eff == num)               
                {
                  righedist.destroy(j,TRUE);
                  break;
                }  
             }
             sf.destroy(i); deleted = TRUE;       
             eff.read(file, tipodist, ndist, k);
             eff.zero("TIPODIST");
             eff.zero("NDIST");
             eff.zero("DATADIST");
             eff.zero("NRIGADIST");
             eff.zero("CODABIP");
             eff.zero("CODCABP"); 
             eff.rewrite(file); 
       }    
       else deleted = FALSE;
    }
}          

int TVariazione_distinte::rewrite(const TMask& m)
{
  TSheet_field& sf = righe_sheet();
  bool condition = FALSE;       
  for (int i = 0; i < sf.items(); i++)
  {
    TToken_string& row = sf.row(i);   
    if (condition = *row.get(0) == 'X') break;
  }
  if (condition)  
    if (yesno_box("Vuoi veramete eliminare gli effetti selezionati"))
      elimina(); //elimino gli effetti nello sheet che sono selezionati con la "X"
  int err = _distinta->reset();  //resetto l'array che contiene gli effetti nella distinta
  char tipodist = m.get(F_TIPODIST)[0];
  long ndist =  m.get_long(F_NUMBER); 
  aggiorna();    
  err = _distinta->rewrite(common_f(m));
  if (err == NOERR)             
  {                //riposiziono la relazione              
    _rel->lfile().setkey(4); 
    TRectype& curr = _rel->curr();
    curr.put("TIPODIST", tipodist);
    curr. put("NDIST", ndist);
    curr. put("NRIGADIST", 1);
    _rel->read();
  } 
  return err;  
}

int TVariazione_distinte::write(const TMask& m)
{            
  int err = _distinta->reset();  //resetto l'array che contiene gli effetti nella distinta
  char tipodist = m.get(F_TIPODIST)[0];
  long ndist =  m.get_long(F_NUMBER); 
  aggiorna();    
  err = _distinta->write(TRUE, common_f(m));
  if (err == NOERR)           
  {               //riposiziono la relazione               
    _rel->lfile().setkey(4); 
    TRectype& curr = _rel->curr();
    curr.put("TIPODIST", tipodist);
    curr. put("NDIST", ndist);
    curr. put("NRIGADIST", 1);
    _rel->read();
  } 
  return err;  
}

//Metodo che permette di eliminare una distinta, l'eliminazione consiste nell'andare a togliere
// dagli effetti i dati ad essa relativi.
bool TVariazione_distinte::remove() 
{                                           
  TMask* m = app()._msk;
  char tipodist = m->get(F_TIPODIST)[0];
  long ndist =  m->get_long(F_NUMBER);    
  int err = _distinta->remove(tipodist, ndist) == NOERR;
  return err;  
}

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);  
  _clifo = new TLocalisamfile(LF_CLIFO); 
  _distinta = new TDistinta;  
  set_search_field(F_NUMBER); //setto il campo di ricerca della distinta
  _msk->set_handler(F_CODVAL, codval_handler); 
  _msk->set_handler(F_IMP, importo_handler);
  _m2->set_handler(F_TOTIMPDIST, imp_aut_handler);
  _m2->set_handler(DLG_OK, conferma_handler);
  _m2->set_handler(DLG_CANCEL, annulla_handler);
  _m2->set_handler(F_DADATA, from_data_handler);
  _m2->set_handler(F_ADATA, to_data_handler);
  _m2->set_handler(F_TIPORD, ordina_handler);
  righe_sheet().set_notify(impdist_notify);  
  righe_sel_sheet().set_notify(imp_notify); 
  return TRUE;
}

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

//Permette di caricare lo sheet per la selezione delle riba da aggiungere alla distinta:
// vengono presi tutti gli effetti sul file LF_EFFETTI che non hanno ancora un riferimento ad
// una distinta
void TVariazione_distinte::carica_riba()
{                                     
  char tipodist = 0;                       
  long ndist = 0;
  long nrigadist = 0; 
  TEffetto eff;     
  TLocalisamfile f(LF_EFFETTI);             
  TLocalisamfile * clifo = app()._clifo;
  TToken_string riga(80);           
  TMask* m2 = app()._m2;              
  m2->reset();
  TSheet_field& sf = (TSheet_field&)m2->field(F_SHEET);
  sf.reset();                    
  int err, i = 0;
  err = eff.read(f, tipodist, ndist, nrigadist);           
  while ( (err == NOERR) && (tipodist == 0) ) 
  {                        //carico tutti gli effetti che soddisfano alla condizione nello sheet
    riga.cut(0);
    riga.add(' ');
    riga.add(eff.get(EFF_NPROGTR));
    riga.add(eff.get(EFF_DATASCAD)); 
    long codcf = eff.get_long(EFF_CODCF);
    clifo->zero();
    clifo->put("TIPOCF", 'C');
    clifo->put("CODCF", codcf);
    if (clifo->read() == NOERR) riga.add(clifo->get("RAGSOC"));
    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(eff.get(EFF_CODVAL));
    riga.add(eff.get(EFF_IMPORTO));
    riga.add(eff.get(EFF_IMPORTOVAL));
    sf.row(i) = riga;
    i++;
    f.setkey(4);
    err = eff.next(f);
    tipodist = eff.get("TIPODIST")[0];
  } 
}

//Handler che permette il controllo sulla abilitazione dei campi collegati 
// al codice valuta
bool TVariazione_distinte::codval_handler(TMask_field& f, KEY k)
{ 
  TMask &m = f.mask(); 
  TString val(f.get()); 
  if (f.to_check(k, TRUE))
  {
      const bool condition = (val == "LIT" || val.empty());
      m.enable(F_TOTIMPVAL,!condition);  
      if (condition)
        m.reset(F_TOTIMPVAL);
  } 
  return TRUE;
}

//Handler per gestire il caricamento degli effetti nella distinta in automatico
// relativamente ad un importo fissato (per la maschera princiapale)
bool TVariazione_distinte::importo_handler(TMask_field& f, KEY k)
{ 
  TMask& m = f.mask();        
  TSheet_field& sf_riba = (TSheet_field&)m.field(F_SHEET_RIBA);
  if (f.to_check(k, TRUE))
  {
    const int mode = m.mode();
    if( mode == MODE_INS || mode == MODE_MOD )
    {     
      TMask* m2 = app()._m2;
      long imp_pres = m.get_long(F_TOTIMP);
      long imp = m.get_long(F_IMP);
      long impdist = imp - imp_pres;
      if (impdist > 0)
      { 
        app().begin_wait();
        carica_riba();     
        app().end_wait();
        m2->reset(F_TOTIMPDIST);
        m2->reset(F_IMPSEL);
        m2->set(F_TOTIMPDIST, impdist);
        m2->run();
      }
      if (impdist < 0)
        error_box("Il valore di presentazione non può superare l'importo della distinta");        
    }
  }                                        
  sf_riba.force_update();
  sf_riba.set_dirty();    
  return TRUE;
}
    
//Handler per gestire il caricamento degli effetti nella distinta in automatico
// relativamente ad un importo fissato (per la maschera secondaria)
bool TVariazione_distinte::imp_aut_handler(TMask_field& f, KEY k)
{ 
  TMask& m2 = f.mask();
  if (f.to_check(k, TRUE))
  {
    TMask* m = app()._msk; 
    TSheet_field& sf = (TSheet_field&)m2.field(F_SHEET);
    TSheet_field& sf_riba = (TSheet_field&)m->field(F_SHEET_RIBA); 
    long impdist = m->get_long(F_IMP) - m->get_long(F_TOTIMP);
    long tot_imp_dist = m2.get_long(F_TOTIMPDIST), impsel = 0;
    if (tot_imp_dist != 0 && impdist != 0)  
    {
      TString val = m->get(F_CODVAL);
      int items = sf.items();                       
      for(int i = 0; i < items; i++)
      {
        TToken_string& row = sf.row(i);
        TString codval = row.get(7);
        if (codval == " " || codval == "LIT")//se la valuta non appare o è lire
          codval.trim();     //faccio in modo che vengano presi gli effetti con valuta inesistente 
        long imp = row.get_long(8);  
        if ((imp <= tot_imp_dist) && ((impsel+imp) <= tot_imp_dist)) 
        {  
           if ((sf_riba.items() == 0) && (val.empty()|| val == "LIT"))//se non è stata specificata una valuta si prende quella del
           {                                      //primo effetto che si carica nella distinta
              m->set(F_CODVAL, codval);    
              val = m->get(F_CODVAL);
           }
           if (codval == val)
           {
              row.add('X',0);//seleziono l'effetto poichè soddisfa alle condizione richieste  
              impsel += imp;
           }
        } 
        if (impsel <= tot_imp_dist) continue;
        else break;     
      }
      sf.force_update();
      calcola();      
    }  
  }
  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)
{  
  TMask* msk = app()._msk;
  TSheet_field& sf_riba = (TSheet_field&)msk->field(F_SHEET_RIBA);    
  if (k==K_ENTER)
  { 
    TMask& m = f.mask();
    m.close();
    TSheet_field& sf = (TSheet_field&)m.field(F_SHEET);
    int items = sf.items();  
    bool condition = FALSE;       
    for (int i = 0; i < items; i++)
    {
       TToken_string& row = sf.row(i);   
       condition = *row.get(0)== 'X';
       if (condition) 
       { 
         row[0] = ' ';
         sf_riba.row(-1) = row;
       }  
    }                  
  }   
  sf_riba.force_update();
  calcola_totale();
  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();
  m.close();  
  return TRUE;  
}             

//Handler per gestire la scelta per data
bool TVariazione_distinte::from_data_handler(TMask_field& f, KEY k)
{
  if (k == K_TAB)
  {                   
   TMask& m = f.mask();
   if (!f.get().empty())
   {                                        
      bool deleted = FALSE;    
      TDate data = m.get_date(F_DADATA);
      TSheet_field& sf = (TSheet_field&)m.field(F_SHEET);
      for(int i = 0; i < sf.items(); i++)
      {
          if (deleted) i--;
          TToken_string& row = sf.row(i);
          TDate data_sh = (TDate)row.get(2);
          if (data_sh < data)               
          {
             sf.destroy(i); 
             deleted = TRUE; 
          }
          else deleted = FALSE;   
      }   
   }
  }
  return TRUE;  
}
                     
//Handler per gestire la scelta per data
bool TVariazione_distinte::to_data_handler(TMask_field& f, KEY k)
{              
  if (k == K_TAB)
  {        
   TMask& m = f.mask();                         
   if (!f.get().empty())
   {                             
      bool deleted = FALSE;    
      TDate data = m.get_date(F_ADATA);
      TSheet_field& sf = (TSheet_field&)m.field(F_SHEET);
      for(int i = 0; i < sf.items(); i++)
      {
          if (deleted) i--;
          TToken_string& row = sf.row(i);
          TDate data_sh = (TDate)row.get(2);
          if (data_sh > data)               
          {
             sf.destroy(i); 
             deleted = TRUE; 
          }
          else deleted = FALSE;  
      }   
   }
  }  
  return TRUE; 
}  
//COMPARE FUNCTION per l'ordinamento per data degli effetti presenti nello sheet
HIDDEN int confronta_data(const TObject** o1, const TObject** o2)
{
  int val;
  TToken_string* s1 = (TToken_string*) *o1; 
  TToken_string* s2 = (TToken_string*) *o2;   
  TDate data1 = s1->get(2);
  TDate data2 = s2->get(2);
  if (data1 == data2)
    val = 0;
  else
   val = (data1 > data2) ? +1 : -1; 
  return val;  
}

//Handler per gestire l'ordinamento per data degli effetti presenti nello sheet 
void TVariazione_distinte::ord_data()
{     
  TMask* m = app()._m2;
  TSheet_field& sf = (TSheet_field&)m->field(F_SHEET);
  TArray& effetti = sf.rows_array();
  app().begin_wait();
  effetti.sort(confronta_data);
  app().end_wait();
  sf.force_update();
}

//COMPARE FUNCTION per l'ordinamento per numero e data fattura degli effetti presenti nello sheet
HIDDEN int confronta_fatt(const TObject** o1, const TObject** o2)
{ 
  int val;
  TToken_string* s1 = (TToken_string*) *o1; 
  TToken_string* s2 = (TToken_string*) *o2;
  long num1 = s1->get_long(4);
  long num2 = s2->get_long(4);
  TDate data1 = s1->get(5);
  TDate data2 = s2->get(5);
  if (num1 != num2)     
  {
    val = (num1 > num2) ? +1 : -1;
    return val;
  }  
  if (data1 == data2)
  {
    val = 0; 
    return val;
  }  
  else 
  {
    val = (data1 > data2) ? +1 : -1;
    return val;  
  }
}
                     
//Handler per gestire l'ordinamento per numero e data fattura degli effetti presenti nello sheet   
void TVariazione_distinte::ord_fatt()
{
  TMask* m = app()._m2;
  TSheet_field& sf = (TSheet_field&)m->field(F_SHEET);
  TArray& effetti = sf.rows_array();
  app().begin_wait();
  effetti.sort(confronta_fatt);
  app().end_wait();
  sf.force_update();
}
                  
//Handler per gestire i diversi ordinamenti 
bool TVariazione_distinte::ordina_handler(TMask_field& f, KEY k)
{              
  if (f.to_check(k, TRUE))
  {
    char ord = f.get()[0];
    if (ord == 'S')//ordino gli effetti nello sheet per data
      ord_data();
    if (ord == 'F')
      ord_fatt();//ordino gli effetti nello sheet per fattura   
  }
  return TRUE; 
}

//Metodo che 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);   
     bool condition = *row.get(0) == 'X';
     if (condition)
     {
       imp = row.get(8);
       impdist -= imp;
       impval = row.get(9);
       impdistval -= impval;
     }
     imp = row.get(8);
     impdist += imp;
     impval = row.get(9);
     impdistval += impval; 
  }
  m->set(F_TOTIMP, impdist);
  m->set(F_TOTIMPVAL, impdistval);   
  m->set(F_IMP, impdist);
}  

//Metodo che calcola i totali relativi alla selezione effetti per la distinta  
void TVariazione_distinte::calcola()
{ 
  TMask* m2 = app()._m2;                   
  TMask* m = app()._msk;   
  TSheet_field& sf = (TSheet_field&)m2->field(F_SHEET);
  int items = sf.items();         
  real imp, impsel;                  
  long imp_pres = m->get_long(F_TOTIMP);
  long importo = m->get_long(F_IMP);
  long impdist = importo - imp_pres;
  if (impdist == 0)
    m2->set(F_TOTIMPDIST, importo);
  for (int i = 0; i < items; i++)
  {
     TToken_string& row = sf.row(i);   
     bool condition = *row.get(0) == 'X';
     if (condition)
     {
       imp = row.get(8);
       impsel += imp;
       m2->set(F_IMPSEL, impsel);
       if (impdist == 0 && imp_pres == 0)
         m2->set(F_TOTIMPDIST, impsel);  
       /*if (impdist != 0 && imp_pres != 0)
         m2->set(F_TOTIMPDIST, imp_pres+impsel);*/
     }        
  }
}  

//Handler per il calcolo dei totali relativi alla selezione effetti per la distinta  
bool TVariazione_distinte::imp_notify(TSheet_field& s, int r, KEY key)
{            
  if (s.to_check(key, TRUE)) 
    calcola();
  return TRUE;
}

//Metodo che permette di aggiungere effetti alla distinta caricandoli tra quelli non ancora assegnati 
void TVariazione_distinte::aggiungi()
{
    TMask* m2 = app()._m2;   
    app().begin_wait();
    carica_riba();     
    app().end_wait();
    m2->reset(F_TOTIMPDIST);
    m2->reset(F_IMPSEL);
    m2->run();
}

//Handler 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_INS)
    aggiungi();  
  return TRUE;
}

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