// --------------------------------------------------------------------------
// Scadenzario
// fv 24/8/94
// --------------------------------------------------------------------------

#include "pagament.h"
#include "saldacon.h"
#include "utility.h"

#include "cg2102.h"
#include "cg2100.h"
#include "cg21sld.h"

#include <clifo.h>
#include <mov.h>
#include <partite.h>
#include <scadenze.h>   
#include <pagsca.h>   
#include <defmask.h>

TPagamento& TPrimanota_application::pagamento() const
{ 
  CHECK(_pag, "Pagamento nullo");
  return *_pag; 
}

bool TPrimanota_application::pag_notify(TSheet_field& ps, int r, KEY k)
{                            
  TPagamento&    pag = app().pagamento();
  TMask*         msk = &(ps.mask());      
  TString_array& rws = app().pag_rows();                                
                                               
  const int rdiff      = msk->get_int(FS_RDIFFER);
  const bool in_valuta = pag.in_valuta(); 
  const int impos      = in_valuta ? 2 : 1;
  
  // ts contiene la vecchia riga, ns la nuova                                       
  TToken_string ts(128), ns(128);
  TString16 banca;

  bool doit = TRUE, m_impl = FALSE, m_impv = FALSE, m_perc = FALSE, m_pag = FALSE;
  bool m_scad = FALSE, m_tipo = FALSE, m_ulc = FALSE, mod = FALSE, m_implit = FALSE;
  word ahiahi = P_OK;                                
  
  TString news(10), newl(15), newv(15), newp(15), newt(1), newu(1);                                  

  bool recalc = msk->get_bool(FS_RECALC); 
  bool mcomm  = msk->get_bool(FS_MCOMM);
  
  switch (k)
  { 
  case K_SPACE:       
    {                                         
      const bool can = !recalc && pag.n_rate() > 1 && ps.row(r).get_char(13) != 'X';   
      ps.sheet_mask().enable(DLG_DELREC, can);
    }  
    break;
  case K_ENTER:
    ns  = ps.row(r);     
    ts  = rws.row(r);    
    
    news = ns.get(0);           // Data scadenza
    newl = ns.get(1);           // Imponibile (lire)
    newv = ns.get(2);           // Imponibile (valuta)
    newp = ns.get(3);           // Percentuale
    newt = ns.get(4);           // Tipo pagamento                                 
    newu = ns.get(5);           // Ulteriore classificazione 

    
    // qui viene il bello, si fa per dire 
    if (news != ts.get(0))  // modificata data scadenza
      mod = m_scad = TRUE;        
    if (real(newp) != real(ts.get(3)))  // modificata percentuale
      mod = m_perc = TRUE;        
    if (real(newl) != real(ts.get(1)))  // modificato importo lire
    {          
       // se si modifica la percentuale nessun importo viene cagato
      if ((recalc && !m_perc) || (!recalc)) 
        mod = m_impl = TRUE;   
    }
    if (in_valuta && real(newv) != real(ts.get(2)))      
    {
       // se si modifica la percentuale nessun importo viene cagato
      if ((recalc && !m_perc) || (!recalc)) 
        mod = m_impv = TRUE;   
    }
    if (newt != ts.get(4))  // modificato tipo pagamento
      mod = m_tipo = m_ulc = TRUE;      
    
    if (newu != ts.get(5))  // modificata ulteriore classificazione
      mod = m_ulc  = TRUE;
    else if (m_tipo) {
      // forza reset di ulc se si e' modificato il tipo rata
      m_ulc = TRUE;
      newu = "";                                             
    }                                                        
          
    break;
  case K_DEL: 
    doit = !recalc && pag.n_rate() > 1 && ps.row(r).get_char(13) != 'X';   
    if (doit)
    {
      pag.remove_rata(r);
      msk->set(FS_NRATE, pag.n_rate());
    }  
    break;
  case K_INS:   
    // permette aggiunta e cancellazione solo se non c'e' ricalcolo automatico
    doit = !recalc;
    break;
  case K_CTRL+K_INS:                 // Post inserimento
    {                   
      const int prev = r - 1;
      const int gio_scad = pag.scad_rata(prev); 
      TDate data_scad(pag.data_rata(prev));

      pag.add_rata(ZERO, gio_scad, pag.tipo_rata(prev), pag.ulc_rata(prev));
      pag.next_scad(data_scad, gio_scad, pag.mese_commerciale(), r);
      pag.set_datarata(r, data_scad);
//      pag.adjust_fixed_scad();
      pag.set_sheet(ps);
      rws = ps.rows_array();  
    }
    break;
  default:
    break;
  }          

  // settato da recalc_rate se occorre ridefinire lo sheet
  // aggiungendo o togliendo righe
  bool need_recalc = FALSE;      

  if (k == K_ENTER) 
  {
    if (mod && recalc)
    {
      // ricalcola sheet come sai fare tu
      ahiahi = pag.recalc_rate(r, m_perc, 
                               ((m_perc || m_impv) ? 
                                (m_perc ? (const char*)newp : (const char*)newv) : NULL), 
                               (m_impl ? (const char*)newl : NULL), 
                               (m_scad ? (const char*)news : NULL),
                               (m_tipo ? (const char*)newt : NULL),
                               (m_ulc  ? (const char*)newu : NULL), 
                               rdiff, mcomm, need_recalc);   
                               
      // see if rdiff changed                          
      msk->set(FS_RDIFFER, pag.rate_differenziate() ? "1" : "2");
      msk->set(FS_NRATE, pag.n_rate());
    } 
    if (!recalc)
    {                              
      ahiahi = P_OK;
      // put data as they are
      TToken_string& trw = pag.rata(r);
      TToken_string  srw = trw;
      if (m_tipo) trw.add(newt,2); 
      if (m_ulc)
        trw.add(newu, 5);
      if (m_scad)
      {
        trw.add(news,3);
        if (r > 0)
        {             
          TDate d(news);   
          int scd = (int)(d - pag.data_rata(r-1));
          if (pag.mese_commerciale() && (scd % 30) != 0) 
               scd = 30 * ((scd/30)+1);
          trw.add(scd, 0);
        }
      }
      if (m_impl)  
      {
        trw.add(newl,7);
        if (!in_valuta)
        {
         // si ricalcola la percentuale a modifica importo in lire solo
         // se non c'e' l'importo in valuta
          const real p = pag.recalc_percrata(r, FALSE);
          ps.row(r).add(p.string(), 3);                                  
        }
        ps.force_update(r); 
      }
      if (m_impv)  
      {
        trw.add(newv,4);
        const real p = pag.recalc_percrata(r, TRUE);
        ps.row(r).add(p.string(), 3);
        ps.force_update(r); 
      }
      else
       if (m_tipo)
         ps.force_update(r);  
      if (mod) 
        rws.row(r) = ps.row(r);
    }    
      
    if (ahiahi)  // any error? Rimetti le righe com'erano prima
    {         
      if (recalc)
      {            
        TString err(80); pag.strerr(ahiahi,err);
        warning_box(err);
        ps.row(r) = rws.row(r); 
        ps.force_update(r); 
      }  
    } 
    else if (recalc && mod && need_recalc) 
    {                                   
      // ridefinisci lo sheet sulla base delle nuove rate
      pag.set_sheet(ps);
      rws = ps.rows_array();      
    } 
  }
  
  return doit;
}                            

bool TPrimanota_application::pag_sheet_handler(TMask_field& f, KEY key)
{           
  bool ok = TRUE;
  if (key == K_TAB || key == K_ENTER)
  {              
    TMask& m = f.mask();

    TPagamento& pag = app().pagamento();
    const TDate dt(m.get(F_DATADOC));
    
    pag.set_datadoc(dt);
    word err = pag.validate();
    if (m.edit_mode())
      err &= ~(P_RSUM | P_TOTNCLIT | P_TOTNCVAL );    // Ignora totale importi e rate
    if (err != P_OK)
    {
      TString s(256);
      pag.strerr(err, s);
      return f.error_box(s);   
    }  
    
    const bool in_valuta = m.get(SK_VALUTA).not_empty();
    real imp;
    
    if (key == K_ENTER && m.edit_mode())
    {      
      real tot = m.get(in_valuta ? SK_TOTDOCVAL : F_TOTALE);
      for (int r = pag.n_rate()-1; r >= 0; r--)
        imp += in_valuta ? pag.tval_rata(r) : pag.tlit_rata(r); 
      
      imp.round(pag.round(in_valuta));                               
      tot.round(pag.round(in_valuta));                               

      if (imp != tot)  
      {                     
        const char* const pic = in_valuta ? ".3" : ".";                
        const TString is(imp.string(pic));
        const TString ts(tot.string(pic));
        ok = yesno_box("Il totale delle rate e' %s mentre\n"
                       "il totale del documento e' %s.\n"
                       "Si desidera registrare ugualmente?",
                       (const char*)is, (const char*)ts);
      }
    }
      
    if (key == K_ENTER && in_valuta)
    {   
      const real totlit = m.get(F_TOTALE);             
      imp = ZERO;
      for (int r = pag.n_rate()-1; r >= 0; r--)
        imp += pag.tlit_rata(r);
                                         
      imp.round(pag.round(FALSE));

      if (imp != totlit)
      {
        const TString is(imp.string("."));
        const TString ts(totlit.string("."));
        ok = yesno_box("Il totale in lire delle rate e' %s mentre\n"
                       "il totale del documento e' %s.\n"
                       "Si desidera registrare ugualmente?", 
                       (const char*)is, (const char*)ts);
      }
    }
  }
  return ok;
}

bool TPrimanota_application::tipopag_handler(TMask_field& f, KEY key)
{
  if ((key == K_TAB || key == K_ENTER) && f.dirty())
  {                
    TMask& m = f.mask();
    int t = m.get_int(105); 
    if (t <= 0)
    {
      t = 1;  
      f.set("1");
    }
    const char u = m.get(106)[0];
    const TPagamento& pag = app().pagamento();  
    bool ok;
    const char* s = pag.desc_tipo(t, u, &ok);  
    if (!ok) m.reset(106);
    m.set(107, s);
  }
  
  return TRUE;
}

bool TPrimanota_application::codpag_handler(TMask_field& f, KEY key)
{                 
  bool ok = TRUE;              
  
  TMask& m = f.mask();
  TPrimanota_application& a = app();
  const bool set_scad = a.is_fattura() && m.page_enabled(2);   // E' attiva pagina 3
  if (key == K_ENTER)
  {  
    if (set_scad && f.get().empty())
    {
      f.error_box("Il codice di pagamento e' obbligatorio!\n"
                  "Se possibile esso verra' proposto, ma potra'\n"
                  "essere modificato prima di registrare il movimento.");

      const char typ = a.clifo();
      const long cod = m.get_long(typ == 'C' ? F_CLIENTE : F_FORNITORE);
        
      TLocalisamfile clifo(LF_CLIFO);
      clifo.put(CLI_TIPOCF, typ);
      clifo.put(CLI_CODCF, cod);
      if (clifo.read() == NOERR)
      {
        const TString& cp = clifo.get(CLI_CODPAG);
        if (cp.not_empty())
        {
          f.set(cp);
          key = K_TAB;
        }  
      }
      ok = FALSE;
    }
  }   
  
  if (key == K_TAB && f.focusdirty() && m.insert_mode() && set_scad)
    a.set_scadenze(m);

  return ok;
}

bool TPrimanota_application::annorif_handler(TMask_field& f, KEY key)
{
  bool ok = TRUE;
  if (f.to_check(key)) 
  {   
    const TMask& m = f.mask();
    if (!m.get(F_NUMRIF).blank() && f.get().empty())
    {
      const TString& anno = m.get(F_DATADOC).right(4);
      f.set(anno);
      ok = error_box("L'anno di riferimento partita e' obbligatorio!\n"
                     "Se possibile esso verra' proposto, ma potra'\n"
                     "essere modificato prima di registrare il movimento.");
    }                 
  } 
  return ok;
}

bool TPrimanota_application::numrif_handler(TMask_field& f, KEY key)
{
  bool ok = TRUE;
  
  if (f.to_check(key, TRUE))
  {              
    TPrimanota_application& a = app();
    TMask& m = f.mask();
    
    bool required = m.insert_mode() && a.is_fattura();
    required     &= key == K_ENTER || f.focusdirty();
    required     &= !(m.get_bool(F_SOLAIVA) || m.field(F_OCCASEDIT).active());

    if (required && f.get().blank())
    {                                                                
      if (m.get(F_CODPAG).empty())
      {
        TMask_field& clifo = m.field(a.iva() == iva_vendite ? F_CLIENTE : F_FORNITORE);
        clifo.set_dirty();
        clifo.on_hit();
      }

      TMask_field& anno = m.field(F_ANNORIF);
      if (m.get(F_ANNORIF).empty())
        m.set(F_ANNORIF, m.get(F_DATADOC).right(4));

      f.set(m.get(a._npart_is_prot ? F_PROTIVA : F_NUMDOC));
      key = K_TAB; // Forza la successiva activate_numrif
      
      ok = f.error_box("Il numero di riferimento partita e' obbligatorio!\n"
                       "Se possibile esso verra' proposto, ma potra'\n"
                       "essere modificato prima di registrare il movimento.");
    }
    
    if (key == K_TAB && a.is_fattura())
      a.activate_numrif(TRUE);

    if (ok && key == K_ENTER && m.edit_mode())
    {
      const TPartita* old = a.partite().first();
      if (old && old->ok() && f.get().blank())   // Se esisteva una partita ma ora non piu'
      { 
        const KEY k = yesnocancel_box("Attenzione la fattura della partita %d %s verra' eliminata.\n"
                                      "Premere SI per cancellarla, NO per ripristinarla, ANNULLA per modificarla",
                                      old->anno(), (const char*)old->numero());
        switch (k)
        {
        case K_NO:
          f.set(old->numero());
          if (m.get(F_ANNORIF).empty())
            m.set(F_ANNORIF, old->anno());
          break;
        case K_ESC:
          ok = FALSE;
          break;
        default:
          break;
        }
      }
    }  
  }
  return ok;
}

bool TPrimanota_application::valuta_handler(TMask_field& f, KEY key)
{
  if (key == K_TAB && f.to_check(key, TRUE))
  {           
    TMask& m = f.mask();
    const TString val = f.get();
    const bool full = val.not_empty();
    
    if (full)
    {   
      TMask_field& dc = m.field(SK_DATACAMBIO);
      if (dc.get().empty())      // Inizializza data cambio se assente
        dc.set(m.get(F_DATADOC));
      if (f.focusdirty())
      {
        dc.set_dirty(); 
        dc.check(RUNNING_CHECK); // Forza ricerca cambio
        dc.on_hit();             // Forza messaggi (eventuale copia a pag. 3)
      }  
    }
    else
    {
      m.set(SK_CAMBIO, "", TRUE); 
      m.set(SK_TOTDOCVAL, "", TRUE);
    }  
    m.enable(SK_CAMBIO, full); 
    m.enable(SK_TOTDOCVAL, full);
    
    if (app().is_fattura())  
      m.set(FS_VALUTA, val);                 // Copia a pagina 3
  }
  return TRUE;
}

bool TPrimanota_application::datacambio_handler(TMask_field& f, KEY key)
{
  if (key == K_TAB && f.to_check(key, TRUE))
  {                                         
    if (app().is_fattura())
      f.mask().set(FS_DATACAMBIO, f.get());               // Copia a pagina 3
  }
  return TRUE;
}

bool TPrimanota_application::cambio_handler(TMask_field& f, KEY key)
{
  if (key == K_TAB && f.to_check(key, TRUE))
  {                   
    TMask& m = f.mask();
    TPrimanota_application& a = app();
 
    bool update = a.is_fattura();         // Devo ricopiarmi a pagina 3?
    if (f.focusdirty())
    {                                                       
      // Forza il ricalcolo del totale in lire se necessario
      a.gioca_cambi(m.insert_mode() ? 0x1 : 0x0);  
    }  
    else
      update &= !m.is_running();
    
    if (update)
      m.set(FS_CAMBIO, f.get());            // Copia a pagina 3
  }
  return TRUE;
}

bool TPrimanota_application::reset_handler(TMask_field& f, KEY key)
{                                 
  if (key == K_SPACE)
  {                  
    TMask& m = f.mask();
    app().reset_pagamento();     
    app().set_scadenze(m);
  }
  return TRUE;
}

bool TPrimanota_application::recalc_handler(TMask_field& f, KEY key)
{                       
  TPrimanota_application& a = app();
  if (key == K_SPACE && a.is_fattura())
  {
    TMask& m = f.mask();
    TSheet_field& ps = (TSheet_field&)m.field(FS_RATESHEET);
    TPagamento& pag = a.pagamento();

    const bool recalc_aut = f.get().not_empty();
    
    if (!recalc_aut && pag.tipo_prima_rata() > 3)
    {
      // SE CAMBIANO I SIGNIFICATI DEL TIPO PRIMA RATA BISOGNA RIFARE TUTTO
      pag.set_tipo_prima_rata(pag.tipo_prima_rata() - 3);  
      m.set(FS_TIPOPR, pag.desc_tpr());
      pag.set_tpr4(TRUE);      
    }
    else if (recalc_aut && pag.was_tpr4())
    {
      // SE CAMBIANO I SIGNIFICATI DEL TIPO PRIMA RATA BISOGNA RIFARE TUTTO
      pag.set_tpr4(FALSE);  
      bool yak = pag.tlit_rata(0) != pag.importo_da_non_dividere(FALSE);
      if (pag.in_valuta()) yak |= (pag.tval_rata(0) != pag.importo_da_non_dividere(TRUE));    
      if (yak)
      {
        if (yesno_box("L'importo della prima rata e' stato modificato. "
                      "Con il ricalcolo automatico esso non sara' piu'"
                      " modificabile. Si desidera "
                      "riportare le rate alle condizioni iniziali?"))
         {
           pag.set_tipo_prima_rata(pag.tipo_prima_rata() + 3); 
           m.set(FS_TIPOPR, pag.desc_tpr());
           a.reset_pagamento();
           a.set_scadenze(m);
         }
         else warning_box("Il tipo prima rata e' stato modificato in \"%s\" per "
                          "poter mantenere la rateazione scelta e la possibilita' di "
                          "ricalcolo automatico",
                          pag.desc_tpr());
          }
      else
      {
        pag.set_tipo_prima_rata(pag.tipo_prima_rata() + 3); 
        m.set(FS_TIPOPR, pag.desc_tpr());
      }      
    }
    
    const bool on = pag.tipo_prima_rata() < 4 || !recalc_aut;
    ps.enable_cell(0, 1, on);
    ps.enable_cell(0, 2, on); 
    ps.enable_cell(0, 3, on);

    ps.enable_column(3, recalc_aut);
    ps.sheet_mask().enable(DLG_DELREC, !recalc_aut); 
  }
  
  return TRUE;
}

bool TPrimanota_application::nrate_handler(TMask_field& f, KEY key)
{                                 
  if (key == K_TAB && f.focusdirty())
  {
    TPagamento& pag = app().pagamento();
    pag.set_numero_rate(atoi(f.get()));
    if (pag.dirty())
    {
      TMask& m = f.mask();
      TSheet_field& ps = (TSheet_field&)m.field(FS_RATESHEET);
      pag.set_sheet(ps);  
      app().pag_rows() = ps.rows_array();        
    }
    f.set(format("%d", pag.n_rate()));  
  }
  return TRUE;
}

bool TPrimanota_application::codcab_handler(TMask_field& f, KEY key)
{
  if (key == K_TAB && f.focusdirty())
  {
    const TMask& m = f.mask();
    const short id = f.dlg() == FS_NSCAB ? FS_NSABI : FS_VSABI;
    const int pos = id == FS_NSABI ? 7 : 9; // Posizione codici ABI sullo sheet
    const TString16 abi = m.get(id);
    const TString16 cab = m.get(id+1);
    TSheet_field& ps = (TSheet_field&)m.field(FS_RATESHEET);
    for (int i = ps.items()-1; i >= 0; i--) // Setta la banca in tutte le righe
    {
      TToken_string& row = ps.row(i);
      row.add(abi, pos);
      row.add(cab, pos+1);
    }
    ps.force_update();
  }
  
  return TRUE;
}

bool TPrimanota_application::ratalit_handler(TMask_field& f, KEY key)
{ 
  if (key == K_F8 || (key == K_TAB && f.get().empty()))   
  {
    const TPagamento& pag = app().pagamento();
    if (pag.in_valuta())
    {
      const TValuta v(app().curr_mask(), FS_VALUTA, FS_DATACAMBIO, FS_CAMBIO); 
      const real other(f.mask().get(103));
      const char* s = v.val2lit(other).string();
      f.set(s);    
    }                        
  }
  return TRUE;
}

bool TPrimanota_application::rataval_handler(TMask_field& f, KEY key)
{
  if (key == K_F8 || (key == K_TAB  && f.get().empty()))   
  {
    TPagamento& pag = app().pagamento();
    if (pag.in_valuta())
    {           
      const TValuta v(app().curr_mask(), FS_VALUTA, FS_DATACAMBIO, FS_CAMBIO); 
      const real other(f.mask().get(102));
      TString16 s(v.lit2val(other).string());
      f.set(s);
    }
  }
  return TRUE;
}

void TPrimanota_application::reset_pagamento()
{    
  TPagamento& pag = pagamento();
  pag.read(); 
  pag.set_rate_auto(); 
}
                         
void TPrimanota_application::recalc_scadenze(const TDate& d)
{
  TPagamento& pag = pagamento();
  pag.set_inizio(d); 
  // ridefinisci lo sheet sulla base delle nuove rate
  TSheet_field& ps = pags(); 
  TString_array& rws = pag_rows();                                
 
  pag.set_sheet(ps);
  rws = ps.rows_array();  
}
                           
void TPrimanota_application::set_pagamento(const char* c, const char* d)
{ 
  if (_pag != NULL) 
  {
    delete _pag;
    _pag = NULL;  
  }  
  if (c != NULL || d != NULL)
  {
    if (!TDate::isdate(d))
      d = "";
    _pag = new TPagamento(c, d);
  }  
} 

void TPrimanota_application::set_totale_pagamento(bool update)
{
  const TMask& m = curr_mask();
  TPagamento& pag = pagamento();        
  
  const real imposta    = m.get_real(F_IMPOSTE); 
  const real imponibile = m.get_real(F_TOTALE) - imposta;
  const real spese      = ZERO;        
  
  const TValuta cambio(m, SK_VALUTA, SK_DATACAMBIO, SK_CAMBIO); 
  if (cambio.in_valuta())
  { 
    const real imposval = cambio.lit2val(imposta);
    const real imponval = m.get_real(SK_TOTDOCVAL) - imposval;   
    pag.set_total_valuta(imponval, imposval, spese, cambio.cambio(), 
                         imponibile, imposta, spese);
  }
  else
  {
    pag.set_total(imponibile, imposta, spese);
  }  
  
  if (update)
  {        
    TSheet_field& ps = (TSheet_field&)m.field(FS_RATESHEET);
    pagamento().set_sheet(ps);        // Aggiorna lo sheet
    pag_rows() = ps.rows_array();     // copia sheet       
  }
}

void TPrimanota_application::set_scadenze(TMask& m)
{                                                                  
  const TString cp(m.get(F_CODPAG));
  const TString dt(m.get(F_DATADOC));
  set_pagamento(cp, dt);   
  set_totale_pagamento(FALSE);
  
  TPagamento& pag = pagamento();
  if (m.field(FS_RECALC).enabled())
  {
    m.set(FS_RDIFFER, pag.rate_differenziate() ? "1" : "2");
    m.set(FS_NAMEPAG, pag.name());
    m.set(FS_TIPOPR,  pag.desc_tpr());
    m.set(FS_MCOMM,   pag.mese_commerciale() ? "X" : "");
    m.set(FS_RECALC,  m.insert_mode() ? "X" : "", TRUE);
    m.set(FS_NRATE,   pag.n_rate());
  }

  pag.set_rate_auto();          
  TSheet_field& ps = (TSheet_field&)m.field(FS_RATESHEET);
  pag.set_sheet(ps);               // prepara lo sheet
  _pag_rows = ps.rows_array();     // copia sheet       
}

bool TPrimanota_application::read_scadenze(TMask& m)
{                                                                  
  const int anno = m.get_int(F_ANNORIF);
  const TString16 numpart(m.get(F_NUMRIF));

  if (anno <= 0 || numpart.blank())         // Partita vuota
    return FALSE;                           
  
  TBill clifo; cerca_conto_cf(clifo);          
  const TPartita& part = partite().partita(clifo, anno, numpart);

  const TRectype& testa = _rel->curr();    
  const long nreg       = testa.get_long(MOV_NUMREG);
  const TDate datadoc   = testa.get_date(MOV_DATADOC);
  
  const int npart = part.prima_fattura(nreg);
  if (npart <= 0)                           // Non esiste una riga per questo movimento
  {
    partite().destroy();
    return FALSE;         // Non dovrebbe succedere mai, in quanto gia' beccato sopra!
  }  
  
  // Determino il codice pagamento dalla riga di fattura  
  TString codpag;                           
  const TRiga_partite& partita = part.riga(npart);                   
  if (partita.rate() > 0)
  {
    const TRiga_scadenze& primarata = partita.rata(1);
    codpag = primarata.get(SCAD_CODPAG);
  }  
  set_pagamento(codpag, datadoc.string());
  TPagamento& pag = pagamento();        

  const bool in_valuta = m.get(SK_VALUTA).not_empty();
  
  const real totale = m.get(in_valuta ? SK_TOTDOCVAL : F_TOTALE);
  if (totale != partita.importo(in_valuta).valore() ||
      m.get_real(F_IMPOSTE) != partita.get_real(PART_IMPOSTA))
  {
    warning_box("Gli importi delle scadenze non corrispondono al totale documento");
  }
 
  set_totale_pagamento(FALSE);

  TSheet_field& ps = (TSheet_field&)m.field(FS_RATESHEET);
  
  const int protette = partita.ultima_rata_con_abbuoni_diffcam();
      
  pag.zap_rate();                              // Azzera pagamento
  for (int i = 1; i <= partita.rate(); i++)    // E' necessario andare in avanti!!!
  { 
    const TRiga_scadenze& scadenza = partita.rata(i);
    real  importo       = scadenza.get(SCAD_IMPORTO); 
    const TDate scad    = scadenza.get(SCAD_DATASCAD);
    const int tipop     = scadenza.get_int(SCAD_TIPOPAG);     
    const bool prot     = i <= protette;       // Non cancellabile
    const TString16 ulc = scadenza.get(SCAD_ULTCLASS);                       
    if (in_valuta)
    {                                                        
      const real impval(scadenza.get(SCAD_IMPORTOVAL));
      pag.set_rata(i-1, impval, importo, scad, tipop, ulc, prot);
    }
    else
      pag.set_rata(i-1, ZERO, importo, scad, tipop, ulc, prot);
        
    TToken_string& str = ps.row(i-1);
    str.add(scadenza.get(SCAD_CODABIPR), 7);
    str.add(scadenza.get(SCAD_CODCABPR), 8);
    str.add(scadenza.get(SCAD_CODABI),   9);
    str.add(scadenza.get(SCAD_CODCAB),   10);    
    if (i == 1)
    {
      m.set(FS_NSABI, str.get(7));
      m.set(FS_NSCAB, str.get(8));
      m.set(FS_VSABI, str.get(9));
      m.set(FS_VSCAB, str.get(10));
      m.set(FS_AGENTE, scadenza.get(SCAD_CODAG));
    }    
    str.add(scadenza.get(SCAD_DESCR),    11);    
    str.add(scadenza.get(SCAD_BLOCCATA), 12);    
    str.add(prot ? "X" : " ",            13);    
  } 
  m.set(FS_RDIFFER, pag.rate_differenziate() ? "1" : "2");
  m.set(FS_NAMEPAG, pag.name());
  m.set(FS_TIPOPR,  pag.desc_tpr());
  m.set(FS_MCOMM,   pag.mese_commerciale() ? "X" : "", TRUE);
  m.set(FS_RECALC,  m.insert_mode() ? "X" : "", TRUE);
  m.set(FS_NRATE,   pag.n_rate());

  pag.set_sheet(ps);
  _pag_rows = ps.rows_array();
  
  return TRUE;
}

int TPrimanota_application::cerca_conto_cf(TBill& bill) const
{
  const char tipocf = clifo();
  const long codcf  = curr_mask().get_long(tipocf == 'C' ? F_CLIENTE : F_FORNITORE);
  
  TString_array& a = cgs().rows_array();
  for (int r = 0; r < a.items(); r++)
  {             
    TToken_string& row = a.row(r);
    bill.get(row, 2, 0x1);
    if (bill.tipo() == tipocf && bill.codclifo() == codcf)
      return r;
  }

  bill.set(0, 0, codcf, tipocf);
  return -1;
}

void TPrimanota_application::write_scadenze(const TMask& m)
{                    
  const long nreg = m.get_long(F_NUMREG);
  const int anno  = m.get_int(F_ANNORIF);
  const TString numpart(m.get(F_NUMRIF));
  
  TPartita* oldgame = partite().first();
  TPartita* newgame = NULL;
  
  int nuova_riga = 0;

  if (anno > 0 && !numpart.blank() && m.page_enabled(2))
  {
    const int tmov = causale().tipomov();
    const TString desc(m.get(F_DESCR));
    const TString codpag(m.get(F_CODPAG));
    const TString codcaus(causale().codice()); 
    const TValuta cambio(m, SK_VALUTA, SK_DATACAMBIO, SK_CAMBIO); 
    const TString agente(m.get(FS_AGENTE)); 
    const char sezione = get_cgs_imp(0).sezione();        // Dare/Avere
 
    TBill clifo; 
    const int riga_clifo = cerca_conto_cf(clifo);
    CHECK(riga_clifo >= 0, "Impossibile generare la fattura senza gruppo/conto cliente");
    newgame = new TPartita(clifo, anno, numpart);
  
    const int row = newgame->prima_fattura(nreg);         // Riga fattura di questo movimento
    TRiga_partite& partita = row <= 0 ? newgame->new_row() : newgame->riga(row);
    nuova_riga = partita.get_int(PART_NRIGA);
    
    TPagamento& pag = pagamento();                      
                          
    // put data on partita
    partita.put(PART_TIPOMOV,   tmov);
    partita.put(PART_NREG,      nreg);
    partita.put(PART_NUMRIG,    riga_clifo+1);
    partita.put(PART_DATAREG,   m.get(F_DATAREG)); 
    partita.put(PART_DATADOC,   m.get(F_DATADOC));
    partita.put(PART_NUMDOC,    m.get(F_NUMDOC));
    partita.put(PART_DESCR,     desc);
    partita.put(PART_CODCAUS,   codcaus);
    partita.put(PART_REG,       causale().reg().name());
    partita.put(PART_PROTIVA,   m.get_long(F_PROTIVA));
    partita.put(PART_SEZ,       sezione);
    
    const TImporto totdoc = get_cgs_imp(riga_clifo);
    partita.put(PART_IMPTOTDOC, totdoc.valore());
    
    cambio.put(partita);
    const bool in_valuta = cambio.in_valuta();

    real imponibile, imponibile_val;   
    for (int i = pag.n_rate()-1; i >= 0; i--)
    {            
      if (in_valuta)
        imponibile_val += pag.tval_rata(i);
      imponibile += pag.tlit_rata(i);
    }

    partita.put(PART_IMPORTO, imponibile);
    partita.put(PART_IMPORTOVAL, imponibile_val);
    partita.put(PART_IMPOSTA, m.get(F_IMPOSTE));
    partita.put(PART_SPESE, pag.spese());
  
    TSheet_field& ps = (TSheet_field&)m.field(FS_RATESHEET);
    
    partita.elimina_rata(-1);                    // Elimina tutte le rate eventuali
    for (i = 0; i < ps.items(); i++)
    {    
      TToken_string& row = ps.row(i);
      
      TRiga_scadenze& scadenza = partita.new_row(); 

      scadenza.put(SCAD_CODPAG,     codpag);     // Codice pagamento
      scadenza.put(SCAD_CODAG,      agente);     // Codice agente

      scadenza.put(SCAD_DATASCAD,   row.get(0)); // 0 = Data scadenza
      scadenza.put(SCAD_IMPORTO,    row.get());  // 1 = Importo
      scadenza.put(SCAD_IMPORTOVAL, row.get());  // 2 = Importo in valuta
      row.get();                                 // 3 = Percentuale
      scadenza.put(SCAD_TIPOPAG,    row.get());  // 4 = Tipo pagamento
      scadenza.put(SCAD_ULTCLASS,   row.get());  // 5 = Ulteriore classificazione
      row.get();                                 // 6 = Descrizione pagamento
      scadenza.put(SCAD_CODABIPR,   row.get());  // 7 = Ns ABI  
      scadenza.put(SCAD_CODCABPR,   row.get());  // 8 = Ns CAB  
      scadenza.put(SCAD_CODABI,     row.get());  // 9 = Vs ABI  
      scadenza.put(SCAD_CODCAB,     row.get());  //10 = Vs CAB 
      scadenza.put(SCAD_DESCR,      row.get());  //11 = Note  
      scadenza.put(SCAD_BLOCCATA,   row.get());  //12 = Non pagabile  
    }
  }

  if (oldgame != NULL)
  {
    const int rigafatt = oldgame->prima_fattura(nreg);
    if (rigafatt > 0)
    {
      if (newgame == NULL || *oldgame != *newgame)
      {        
        bool sposta = newgame != NULL;
        if (sposta)
        {                   
          sposta = (oldgame->conto().sottoconto() == newgame->conto().sottoconto());
          if (sposta)
            sposta = yesno_box("Si desidera spostare la fattura e gli eventuali\n"
                               "pagamenti relativi nella partita %d %s?", anno, (const char*)numpart);
        }  
        if (sposta)                        
        {
          oldgame->sposta_riga(rigafatt, *newgame, nuova_riga);
        }  
        else  
        {
          oldgame->scollega_pagamenti(rigafatt);
          oldgame->rimuovi_riga(rigafatt);
        }  
        oldgame->rewrite();
      }
      else
      {     
        oldgame->sposta_riga(rigafatt, *newgame, nuova_riga);
      }
    }  
  } 
  
  if (newgame != NULL)           // Se non ho cancellato il numero partita ...
  {                    
    newgame->write();            // Salva nuova partita
    delete newgame;
  }  
}


///////////////////////////////////////////////////////////
// Gestione pagamenti
///////////////////////////////////////////////////////////

bool TPrimanota_application::showpartite_handler(TMask_field& f, KEY k)
{          
  bool ok = TRUE;
  TMask& m = f.mask();
  TPrimanota_application& a = app();
  TMask& cm = a.curr_mask();
  
  const char tipo = m.get(CG_ROWTYPE)[0];                      
  const bool is_nota = tipo == 'T' && a.causale().tipomov() == 2 && cm.field(F_NUMRIF).active();
  const bool tras = a._as400 && a.causale().tipomov() > 1 && m.get(CG_TIPO).not_empty();
  
  if (tipo == 'K' || is_nota || tras)
  {
    TSheet_field& s = *m.get_sheet();   
    const int riga = s.selected();

    if (k == K_SPACE)
    {
      const bool ok = a.edit_partite(m, riga);
      if (ok && riga < s.items())
        k = K_ENTER;
    } 
    
    if (k == K_ENTER)
    {                                
      const long curreg = cm.get_long(F_NUMREG);
      const TImporto importo(a.get_cgs_imp(riga));
      const TImporto speso(a.partite().importo_speso(curreg, riga+1));

      if (tipo == 'K' && !speso.is_zero())
      {
        a.disable_cgs_cells(riga, 'K');
        a.cgs().force_update(riga);
      }  

      if (importo != speso)
      { 
        TString msg(128);
        msg << "L'importo sul saldaconto della riga " << (riga+1) << " e' " 
            << speso.valore().string("."); 
        if (!speso.is_zero())    
          msg << (speso.sezione() == 'A' ? " Avere" : " Dare");
        return f.error_box(msg);
      }
    }  
  }
  return ok;
}


// deleting significato
//  -1      sto cancellando tutto
//   0      non sto cancellando nulla
//   1      sto cancellando la prima riga contabile
//   n      sto cancellando la ennesima riga contabile

bool TPrimanota_application::notify_edit_pagamento(TPartita& p, TRectype& new_pag, 
                                                   const TValuta& valuta, int deleting)
{   
  const int nriga = new_pag.get_int(PAGSCA_NRIGA);       // Riga fattura
  const int nrata = new_pag.get_int(PAGSCA_NRATA);       // Numero rata
  const int nrigp = new_pag.get_int(PAGSCA_NRIGP);       // Riga pagamento
  const TRectype& old_pag = p.pagamento(nriga, nrata, nrigp);
  const TRiga_partite& somma = p.riga(nrigp);
  const int riga_contabile = somma.get_int(PART_NUMRIG); // Riga movimento
  TSheet_field& sheet = cgs();
  
  if (_as400) 
    deleting = -1;                                       // Ignora contropartite

  if (deleting >= 0)
  {
    const char sez = somma.sezione();                    // Sezione importo e ritenute
    const char controsez = sez == 'A' ? 'D' : 'A';       // Sezione contropartita

    // Aggiornamento contopartita
    const TImporto old_importo(controsez, old_pag.get_real(PAGSCA_IMPORTO));
    TBill old_conto; old_conto.get(old_pag, TRUE);

    const TImporto new_importo(controsez, new_pag.get_real(PAGSCA_IMPORTO));   
    TBill new_conto; new_conto.get(new_pag, TRUE);
    
    if (old_importo != new_importo || old_conto != new_conto)
    {
      const int old_riga = bill2pos(old_conto, 'I');
      if (old_riga >= 0)
      {
        const bool empty = sub_cgs_imp(old_riga, old_importo);
        if (empty && (new_importo.is_zero() || new_conto != old_conto))
          sheet.destroy(old_riga);
      }  
      
      // Importo della contropartita
      if (!new_importo.is_zero() && new_conto.ok())
      {
        const int new_riga = bill2pos(new_conto, 'I');
        if (new_riga < 0)
        {                                 
          const int tp = somma.get_int(PART_TIPOPAG);
          const int da = p.tipopag2causale(tp);
          const TString descagg(causale().desc_agg(da));
          set_cgs_row(new_riga, new_importo, new_conto, descagg, 'I');
        }  
        else
          add_cgs_imp(new_riga, new_importo);  
      }    
    }
    
    // Aggiornamento ritenute
    const real old_ritenute(old_pag.get(PAGSCA_RITENUTE));
    const real new_ritenute(new_pag.get(PAGSCA_RITENUTE));    
    if (old_ritenute != new_ritenute)
    { 
      const TImporto grow_ritenute(controsez, new_ritenute-old_ritenute); 
      const riga = type2pos('F');
      if (riga < 0)
      {
        TBill conto_rit; causale().bill(RIGA_RITENUTE, conto_rit);
        const TString desc(causale().desc_agg(RIGA_RITENUTE));
        set_cgs_row(riga, grow_ritenute, conto_rit, desc, 'F');
      }
      else 
      {
        const bool empty = add_cgs_imp(riga, grow_ritenute);
        if (empty) sheet.destroy(riga);
      }  
    }
  }      // if (deleting >= 0)
  
  char old_ap, new_ap;
  TImporto old_abbuono, new_abbuono, old_diffcam, new_diffcam;
  const bool empty = p.modifica_pagamento(new_pag, valuta,
                                          old_ap, old_abbuono, old_diffcam, 
                                          new_ap, new_abbuono, new_diffcam, TRUE);
  
  if (deleting >= 0)
  {
    // Se c'e' differenza negli abbuoni
    if (old_abbuono != new_abbuono || old_ap != new_ap) 
    {
      if (old_ap != ' ')   // Se c'era un abbuono ...
      { 
        const int riga_abb = type2pos(old_ap);
        CHECK(riga_abb >= 0, "Chiss'e' fregato gli abbuoni?");
        const bool empty = add_cgs_imp(riga_abb, old_abbuono);       
        if (empty && new_ap != old_ap)
          sheet.destroy(riga_abb);
        
        if (deleting != riga_contabile)
        {
          // Sottrae l'abbuono con la sezione invertita dalla riga contabile
          sub_cgs_imp(riga_contabile-1, old_abbuono); 
        }  
      }                     
      if (new_ap != ' ')                            // Se ci sono abbuoni
      {                                       
        const riga_abb = type2pos(new_ap);

        new_abbuono.swap_section();
        new_abbuono.normalize();

        if (riga_abb < 0)
        {                           
          const int rc = new_ap == 'A' ? RIGA_ABBUONI_ATTIVI : RIGA_ABBUONI_PASSIVI;
          TBill conto_abb; causale().bill(rc, conto_abb);
          const TString desc(causale().desc_agg(rc));
          app().set_cgs_row(riga_abb, new_abbuono, conto_abb, desc, new_ap);
        }
        else
          add_cgs_imp(riga_abb, new_abbuono);
        
        if (deleting != riga_contabile)
        {
          // Aggiunge l'abbuono con la sezione invertita
           sub_cgs_imp(riga_contabile-1, new_abbuono);     
        }  
      }  
    }
    
    // Se c'e' variazione nella differenza cambi
    if (old_diffcam != new_diffcam)                 
    {
      const int riga_diffcam = type2pos('C');
      TImporto grow_diffcam(old_diffcam); 
      grow_diffcam -= new_diffcam;
      grow_diffcam.normalize();
      
      if (riga_diffcam < 0)
      {
        TBill conto_diffcam; causale().bill(RIGA_DIFFCAM, conto_diffcam);
        const TString desc(causale().desc_agg(RIGA_DIFFCAM));
        set_cgs_row(riga_diffcam, grow_diffcam, conto_diffcam, desc, 'C');
      }
      else
      {
        const bool empty = add_cgs_imp(riga_diffcam, grow_diffcam);
        if (empty) 
          sheet.destroy(riga_diffcam);
      }  
      
      if (deleting != riga_contabile)
      {
        // Aggiunge la differenza con la sezione invertita
        sub_cgs_imp(riga_contabile-1, grow_diffcam);  
      }  
    }
  }     // if (deleting >= 0)
  
  return empty;
}

// Scorre tutte le righe della partita ed azzera i pagamenti relativi a alla riga contabile
// cancellata e decrementa i numeri riga superiori a numrig
bool TPrimanota_application::notify_cgline_deletion(TPartita& partita, long nreg, int numrig)
{                    
  bool found = FALSE;
  
  // Al primo "giro" elimino i pagamenti dalla rate
  for (int p = partita.last(); p > 0; p = partita.pred(p))
  {
    TRiga_partite& part = partita.riga(p);
    if (part.is_fattura())
    {
      for (int r = part.rate(); r > 0; r--)
      {
        const TRiga_scadenze& scad = part.rata(r);
        for (int s = scad.last(); s > 0; s = scad.pred(s))
        {
          const TRiga_partite& sum = partita.riga(s);
          if (sum.get_long(PART_NREG) == nreg && 
              (numrig <= 0 || sum.get_int(PART_NUMRIG) == numrig))
          {
            TRectype nul_pag(scad.row(s));
            nul_pag.zero(PAGSCA_IMPORTO);
            nul_pag.zero(PAGSCA_IMPORTOVAL);
            nul_pag.zero(PAGSCA_RITENUTE);               
            nul_pag.put(PAGSCA_ACCSAL, 'A');
            const TValuta val;           // Non cambiare valuta
            notify_edit_pagamento(partita, nul_pag, val, numrig);
            found = TRUE;
          }
        }
      }
    } 
  }
    
  // Alla fine del "giro" elimino i pagamenti non assegnati
  TRecord_array& unas = partita.unassigned();
  for (int u = unas.last_row(); u > 0; u = unas.pred_row(u))
  {
    const TRiga_partite& sum = partita.riga(u);
    if (sum.get_long(PART_NREG) == nreg && 
        (numrig <= 0 || sum.get_int(PART_NUMRIG) == numrig))
    {
      TRectype nul_pag(unas.row(u, FALSE));
      nul_pag.zero(PAGSCA_IMPORTO);
      nul_pag.zero(PAGSCA_IMPORTOVAL);
      nul_pag.zero(PAGSCA_RITENUTE);               
      nul_pag.put(PAGSCA_ACCSAL, 'A');   // Inutile, ma l'ho copiato da sopra
      const TValuta val;                 // Non cambiare valuta
      notify_edit_pagamento(partita, nul_pag, val, numrig);
      found = TRUE;
    }
  }
  
  // Al secondo "giro" decremento NRIGP dalle righe di pagamento
  if (numrig > 0)
  {
    for (p = partita.last(); p > 0; p = partita.pred(p))
    {
      TRiga_partite& part = partita.riga(p);
      if (!part.is_fattura())
      {
        if (part.get_long(PART_NREG) == nreg)
        {
          const int nr = part.get_int(PART_NUMRIG);
          if (nr > numrig)
            part.put(PART_NUMRIG, nr-1);
        }   
      }    
    }
  }
  
  return found;
}

bool TPrimanota_application::notify_cgline_deletion(int numrig)
{                           
  bool found = FALSE;
  
  const long nreg = curr_mask().get_long(F_NUMREG);
  partite().add_numreg(nreg);
  for (TPartita* game = partite().first(); game; game = partite().next())
    found |= notify_cgline_deletion(*game, nreg, numrig);
  
  return found;
}
