// cg0500.cpp  - Tabella causali

#include <applicat.h>
#include <msksheet.h>
#include <relapp.h>
#include <tabutil.h>
#include <config.h>
#include <utility.h>

#include <clifo.h>
#include <pconti.h>
#include <causali.h>
#include <rcausali.h>

#include "cglib.h"
#include "cg2103.h"
#include "cg0500.h"

#define SS_TIPOCF 102           
#define SS_GRUPPO 103
#define SS_CONTO  104

////////////////////////////////////////////////////////////////////////////
// Funzioni legate ai parametri ditta
////////////////////////////////////////////////////////////////////////////
HIDDEN bool salda_conto() 
{ 
  static bool _saldaconto = 2;

  if (_saldaconto == 2)
  {
    TConfig conf(CONFIG_DITTA);
    _saldaconto = conf.get_bool("GesSal");
  }
  return _saldaconto; 
}

HIDDEN bool gestione_valuta() 
{ 
  static bool _gest_val = 2;
  
  if (_gest_val == 2)
  {
    TConfig conf(CONFIG_DITTA);
    _gest_val = conf.get_bool("GesVal"); 
  }
  return _gest_val;  
}

HIDDEN int anno_iva() 
{ 
  static int _anno_iva = 0;
  if (_anno_iva == 0)
  {
    TConfig conf(CONFIG_DITTA);
    _anno_iva = (int)conf.get_long("AnLiIv", "cg"); 
    if (_anno_iva < 1900)
    {
      _anno_iva = TDate(TODAY).year();
      error_box("Anno liquidazione IVA non specificato: assumo %d", _anno_iva);
    }
  }  
  return _anno_iva; 
}

////////////////////////////////////////////////////////////////////////////
// 
// Le righe di causale: 
//
// Righe_rcaus e' un array di Riga_rcaus. 
//
// - NB -  Contiene solo le descrizioni fisse!
//
// I dati letti dal file sono memorizzati direttamente nello spreadsheet 
// Quando cambiano i campi tipodoc, codreg, tpm della testata le nuove
// descrizioni vengono caricate in questo array e poi ricopiate (solo le
// descrizioni) nello spreadsheet. 
//
////////////////////////////////////////////////////////////////////////////
class Riga_rcaus : public TToken_string
{
public:
  const TString& operator = (const TString& s) 
  {return TToken_string::operator=(s);}

  Riga_rcaus (TConto& tc,                // il conto
              const char *df="",         // descrizione fissa
              char tipocf=' ',           // tipo C/F
              char sezione=' ',          // dare/avere
              const char * des="",       // descrizione del conto
              const char * desagg="",    // codice descr. aggiuntiva
              bool rigaiva=' ',          // se e' una riga iva
              const char * codiva="");   // codice iva
};

Riga_rcaus::Riga_rcaus (TConto& tc,const char * df, char tipocf, char sez,
                        const char * des, const char * desagg,
                        bool rigaiva, const char * codiva)
: TToken_string(128)
{
  add(df);  add(tipocf);
  //  add(tc.tipo());
  if (tc.ok()) {
    add((long)tc.gruppo());  add((long)tc.conto());  
    add((long)tc.sottoconto());  
  }
  else {
    add("");  add("");  add("");  
  }
  add(sez);  add(des);  add(desagg); 
  add((char)rigaiva);  add(codiva);  
}

class TRighe_rcaus : public TArray
{
public:
  void set_descr (int numrig=-1, const char * descr="", char tipocf=' ');
  void clear(int riga); // pulisce una riga in seguito ad Azzera
  void ClearDescr();    // cancella solo le descrizioni fisse
  void CaricaRigheLibere();
  void CausaleIncassoPagamento();
  void CausaleRitenutaOccas ();
  void CausaleVendite ();
  void CausaleAcquisti();
  TRighe_rcaus() : TArray(20) {}
};

void TRighe_rcaus::ClearDescr() 
{                             
  for (int i=0; i < items(); i++) 
  {
    Riga_rcaus *r = (Riga_rcaus*)objptr(i);
    if (r) r->add("", 0);
  }
}

void TRighe_rcaus::clear(int row) 
{
  Riga_rcaus *r = (Riga_rcaus*)objptr(row);
  
  if (r) 
  {
    r->add("", 1); r->add(0, 2); r->add(0, 3);
    r->add(0L, 4); r->add("", 5); r->add("", 6);
    r->add("", 7); r->add("", 8); r->add("", 9);  
  }
}

void TRighe_rcaus::set_descr(int i, const char * dfi, char tipocf)
{
  Riga_rcaus *r = (Riga_rcaus*)objptr(i);
  TConto tc;

  if (r == NULL) 
  {
    //    r = new Riga_rcaus (tc,dfi,tipocf);
    r = new Riga_rcaus (tc,dfi);
    add(r,i); 
  }
  r->add(dfi, 0);
  //  r->add(tipocf, 1);
}

bool filtra_reg(const TRelation * r);

typedef enum { acquisto, vendita, incasso_pagamento, 
               ritenuta_occas, incasso_pagamento_gesval } tipo_descr;

               class CG0500_application : public TRelation_application
{
  int           _filtro;        // tipo di filtro su tab. reg.
  // 1 vendite senza corrisp
  // 2 vendite con corrisp
  // 3 acquisti
  // 4 sia acquisti che vendite

  friend bool filtra_reg(const TRelation * r);

  static bool tipocf_hndl (TMask_field& f, KEY k);
  static bool cod_reg_hndl (TMask_field& f, KEY k);
  static bool tipodoc_hndl (TMask_field& f, KEY k);
  static bool tipomov_hndl (TMask_field& f, KEY k);
  static bool conto_hndl (TMask_field& f, KEY k);
  static bool sottoconto_hndl (TMask_field& f, KEY k);
  static bool codcausim_hndl (TMask_field& f, KEY k);
  static bool m770_hndl (TMask_field& f, KEY k);
  static bool leggi_riga (int r, KEY k);

  TRelation    * _rel;
  TMask        * _msk;
  TLocalisamfile * _conti;
  int _mode;              // Modo maschera corrente
  int _items;

  // Bitarray delle righe lette da file all'inizio. 
  // Quando leggo dal file la riga n setto il bit n.
  TBit_array                            _righe_gia_presenti;
  
  void togli_dal_file(const TString&);

  void   read_rcaus(TMask&);
  bool   descr2array(TMask&, bool fromHandler = TRUE);
  bool   fill_sheet(TMask&);

protected:
  virtual bool user_create();
  virtual bool user_destroy();

  virtual TRelation*   get_relation() const { return _rel; }
  virtual TMask*       get_mask(int mode)   { return _msk; }
  virtual bool         changing_mask(int mode) {return FALSE; }
  virtual bool         remove();
  
  void init_mask(TMask&);
  virtual void init_query_mode(TMask&);
  virtual void init_insert_mode(TMask&);
  virtual void init_modify_mode(TMask&);
  virtual int rewrite(const TMask& m);
  virtual int write(const TMask& m);
  int re_write (const TMask& m, bool rewrite=FALSE);
  virtual int read(TMask& m);
  //  int cancella(long items);

public:
  bool          _forcedCopy;
  TRighe_rcaus  _righe_rcaus; // Array delle descrizioni delle righe
  tipo_descr    _tipo_des;        // Il tipo di causale corrente
  int _riga;                  // Riga corrente dello sheet (set_notify)

  void compilaarray (const TString&, int, int, int);
  void array2sheet();         // Copia le descrizioni dall'array allo sheet

  TMask*        main_mask() const { return _msk; }
  TMask&        ss_mask()   const { return ss().sheet_mask(); }
  TSheet_field& ss()        const { return (TSheet_field&)_msk->field(F_SHEET_GCS);}
  void          add_riga (int numrig, char cf, char sz, TString& d, TString& da, 
                          bool riva, TString& civa, TConto& tc);
  bool          MostraCampi(TMask_field& f);           
  TLocalisamfile & conti() { return *_conti; }

  CG0500_application() {}
};

HIDDEN CG0500_application * app() { return (CG0500_application*) MainApp(); }

// Per sapere su che riga sono dello spreadsheet. v. set_notify piu' sotto
// e per pulire la sezione Dare/avere in caso di riga azzerata
bool CG0500_application::leggi_riga(int r, KEY k)
{
  if (k == K_SPACE) app()->_riga = r;

  if (k == K_ENTER)
  {
    TToken_string &riga = app()->ss().row(r);
    const int g  = riga.get_int(2); 
    if (g == 0)  // riga azzerata  
    {
      riga.add("", 1);  // pulisco tipo C/F
      riga.add("", 5);  // pulisco Dare/Avere
      app()->_righe_rcaus.clear(r);  // pulisco la riga anche nell'array
      app()->ss().force_update(r);
    }
  } 
  return TRUE;
}

bool filtra_reg(const TRelation * r)
{
  const TString codtab(r->lfile().get("CODTAB"));
  int   tiporeg = r->lfile().get_int("I0");
  bool  corrisp = r->lfile().get_bool("B0");

  const int anno = atoi(codtab.left(4));

  switch (app()->_filtro)
  {
  case 1:
    if (anno == anno_iva() && tiporeg == 1)
      return TRUE;
    break;
  case 2:
    if (anno == anno_iva() && tiporeg == 1 && corrisp)
      return TRUE;
    break;
  case 3:
    if (anno == anno_iva() && tiporeg == 2)
      return TRUE;
    break;
  case 4:  // tiporeg 1 senza corrisp OPPURE 2 (NC ST ND AF)
    if (anno == anno_iva())
      if ( (tiporeg == 1 && !corrisp) || tiporeg == 2 )
        return TRUE;
    break;
  default:
    return FALSE;
  }
  return FALSE;
}


////////////////////////////////////////////////////////////////////////////
// Handler della maschera principale
////////////////////////////////////////////////////////////////////////////
/************
  se m770==6 le descrizioni devono essere
  1. conto
  2. cassa/banca
  3. erario
  ************/
bool CG0500_application::m770_hndl (TMask_field& f, KEY k)
{
  if (k == K_SPACE)
  {
    TMask& m = f.mask();
    const int m770 = m.get_int(F_M_770);
    if (m770 == 6) app()->fill_sheet(m);  
  }
  return TRUE;
}

bool CG0500_application::tipodoc_hndl (TMask_field& f, KEY k)
{
  // Testo K_TAB perche' il controllo deve scattare anche all'inizio
  // per vedere, per es., se il registro scritto nella causale esiste ancora
  if (k == K_TAB)
  {
    const TString16 val(f.get());
    TEdit_field& field_reg = (TEdit_field&)f.mask().field(F_COD_REG);

    if (val.not_empty() && val != "IN" && val != "PG" && val != "AN")
    { 
      //      if (f.to_check(k)) {
      f.mask().hide(F_TIPO_MOV_2);      
      if (salda_conto()) f.mask().show(F_TIPO_MOV_1);
      //      }

      f.mask().enable(F_COD_REG);
      field_reg.check_type(CHECK_REQUIRED);
      
      TipoIVA i = nessuna_iva;
      TTable tabtpd("%TPD");
      tabtpd.put("CODTAB", val);

      if (tabtpd.read() == NOERR)
      {
        i = (TipoIVA)tabtpd.get_int("I0"); // IVA acquisti, vendite, generica
        bool corrisp = tabtpd.get_bool("B0");

        if (i == 1)   // vendite
        {
          if (corrisp) {   // vendite con corrispettivi
            app()->_filtro = 2;
            field_reg.browse()->cursor()->set_filterfunction(filtra_reg);
          }
          else {     // vendite senza corrispettivi
            app()->_filtro = 1;
            field_reg.browse()->cursor()->set_filterfunction(filtra_reg);
          }
        } else      
          if ( i == 2 )   // acquisti
          {
            app()->_filtro = 3;
            field_reg.browse()->cursor()->set_filterfunction(filtra_reg);
          } else 
            if ( i == 9 )  // sia acquisti che vendite
            {
              app()->_filtro = 4;
              field_reg.browse()->cursor()->set_filterfunction(filtra_reg);
            }
      }
    }
    else         // TIPODOC vuoto || IN || PG || AN
    {
      // Devo poter rivedere tutti i registri se ho cancellato il campo TIPODOC
      field_reg.check_type(CHECK_NORMAL);
      f.mask().set(F_COD_REG,"");
      f.mask().disable(F_COD_REG);

      //      if (f.to_check(k)) {
      f.mask().hide(F_TIPO_MOV_1);
      if (salda_conto()) f.mask().show(F_TIPO_MOV_2);      
      //      }
    }
    
    // Ma davvero esiste il registro ?
    TString16 codreg(f.mask().get(F_COD_REG));
    if (codreg.not_empty())
    {
      TRegistro registro(codreg, anno_iva());  
      if (!registro.read(codreg, anno_iva()))
        return f.warning_box("Non esiste il registro %s per l'anno %d", 
                             (const char *)codreg, anno_iva());
    }    
    
    app()->MostraCampi(f);  
    //    if (f.focusdirty()) 
    app()->fill_sheet(f.mask());
  }
  return TRUE;
}

bool CG0500_application::tipomov_hndl (TMask_field& f, KEY k)
{
  if (k == K_SPACE) 
  {
    app()->MostraCampi(f);
    if (f.focusdirty()) 
      app()->fill_sheet(f.mask());
  }
  return TRUE;
}

// Il codice causale per incasso immediato, se specificato, deve
// essere puramente contabile (= codreg vuoto e tpm = Nessuno
bool CG0500_application::codcausim_hndl (TMask_field& f, KEY k)
{
  if (f.to_check(k)) 
  {
    TString16 causim(f.get());
    TLocalisamfile& caus = app()->_rel->lfile(LF_CAUSALI);
    caus.zero();
    caus.put(CAU_CODCAUS, causim);
    if (caus.read() == NOERR)
    {
      const int tpm       = caus.get_int(CAU_TIPOMOV);
      TString16 codreg = caus.get(CAU_REG);
      if (codreg.not_empty() || tpm != 0)
        return f.warning_box("La causale per l'incasso immediato specificata (%s) deve essere puramente contabile", 
                             (const char *) causim);
    }
  }
  return TRUE;
}


bool CG0500_application::MostraCampi(TMask_field& f)
{
  TMask&  m = f.mask();
  const int tpm    = m.get_int(F_TIPO_MOV);
  TString16 codreg = m.get(F_COD_REG);
  if (codreg.empty()) 
  {      
    m.hide(F_AUTO_FAT);        
    m.hide(F_ALLEGAT);        
    m.hide(F_FAT_RITARDO);        
    m.hide(F_OP_INTRACOM);                    
    m.hide(F_VALINTRA);                    
    //    if (salda_conto()) 
    m.hide(F_COD_CAUS_IM);                    

    switch (tpm) 
    {
    case 0:
      m.show(F_OP_FINE_ANNO);
      m.show(F_COLL_CESP);
      m.show(F_M_770);
      if (salda_conto()) m.hide(F_MOV_VALU);    
      m.hide(F_MOV_SEZ);                    
      break;
    case 3:
    case 5:
    case 6:
      if (gestione_valuta()) m.show(F_MOV_VALU);    
      if (salda_conto())     m.show(F_MOV_SEZ);            
      m.show(F_M_770);
      m.hide(F_OP_FINE_ANNO);
      m.hide(F_COLL_CESP);        
      break;
    default:
      break;
    }
  }
  else 
  {      // codreg non vuoto   
    m.hide(F_OP_FINE_ANNO);    
    m.hide(F_MOV_SEZ);                          
    if (gestione_valuta()) m.show(F_MOV_VALU);
    if (!salda_conto())
      m.show(F_COD_CAUS_IM);                    
    m.show(F_AUTO_FAT);        
    m.show(F_ALLEGAT);        
    m.show(F_FAT_RITARDO);        
    m.show(F_COLL_CESP);        
    m.show(F_OP_INTRACOM);                    
    m.show(F_VALINTRA);                    
  }
  return TRUE;
}

bool CG0500_application::cod_reg_hndl (TMask_field& f, KEY k)
{
  if (k == K_TAB)  
  {
    app()->MostraCampi(f);
    if (f.focusdirty()) app()->fill_sheet(f.mask());
    return TRUE;
  }

  // controllo di consistenza tra codice (tipo) registro e tipo documento
  if (k == K_ENTER)
  {
    //    bool ok = TRUE;
    const TString16 tpd    = f.mask().get(F_TIPO_DOC);
    const TString16 codreg = f.mask().get(F_COD_REG);
    
    if (tpd.not_empty())
    {
      TipoIVA i = nessuna_iva;
      TRegistro grog(codreg, anno_iva());
      TTable tabtpd("%TPD");
      tabtpd.put("CODTAB", tpd);
      if (tabtpd.read() == NOERR)
      {
        i = (TipoIVA)tabtpd.get_int("I0");   // IVA acquisti, vendite, generica
        const TipoIVA ri = grog.iva();
        if (i == iva_generica) i = ri;
        if (i != ri) 
        {
          return f.warning_box("Tipo documento incompatibile con tipo registro");
          i = iva_errata;
        }  
      }
    }
  } 
  return TRUE;
}


////////////////////////////////////////////////////////////////////////////
// Handler della maschera dello spreadsheet
////////////////////////////////////////////////////////////////////////////
bool CG0500_application::conto_hndl (TMask_field& f, KEY k)
{
  // Se specifico il conto deve essere non vuoto il gruppo
  if (f.to_check(k))
  {
    int io = f.dlg();
    int c = f.mask().get_int(io);
    int g = f.mask().get_int(io - 1); 

    if (c > 0)
      if (g == 0)
        return f.warning_box("Non accetto un conto senza gruppo");
  }
  // Controllo: << se e' fattura solo la riga 1 o 7 possono essere C/F >> 
  if (k == K_ENTER)
  {
    char scarta    = '\0';
    int ultima     = 8;
    char cf        = f.mask().get(SS_TIPOCF)[0];
    TMask_field& cfld = f.mask().field(SS_TIPOCF);
    const int tpr  = app()->main_mask()->get_int(F_TIPO_REG);  
    bool    puramente_contabile = FALSE;
    
    switch (tpr)
    {
    case 1: scarta = 'F'; break;
          case 2: scarta = 'C'; break;
          case 0:
            scarta = 'Z';    // Accetto tutto
            puramente_contabile = TRUE;
            switch (app()->_tipo_des)
            {
            case incasso_pagamento:         ultima = 11; break;
                                          case incasso_pagamento_gesval:  ultima = 12; break;
                                          default: break;
                                          } 
          }
    
    if (!puramente_contabile)
    {                 
      if (app()->_riga > ultima) // se sono nelle righe libere accetto TUTTO..
        return TRUE;                           
      else
        if (app()->_riga == 0 || app()->_riga == 6)
        {
          if (cf == scarta)
            return cfld.warning_box(
              "Impossibile inserire un %s con registro di tipo %s nella riga %d", 
              cf == 'C' ? "cliente" : "fornitore", 
              tpr == 1 ? "vendite" : "acquisti", app()->_riga+1);
        }
        else
          if (cf == 'C' || cf == 'F')
            return cfld.warning_box(
              "Impossibile inserire un %s con registro di tipo %s nella riga %d", 
              cf == 'C' ? "cliente" : "fornitore",
              tpr == 1 ? "vendite" : "acquisti", app()->_riga+1);                 
    }
  }
  return TRUE;
}


// 1. Se specifico il sottoconto devono essere non vuoti gruppo e conto
// 2. g-c-s devono esistere
bool CG0500_application::sottoconto_hndl (TMask_field& f, KEY k)     
{
  if (f.to_check(k))
  {
    int io = f.dlg();
    int s = f.mask().get_int(io);
    int g = f.mask().get_int(SS_GRUPPO); 
    int c = f.mask().get_int(SS_CONTO); 

    if (s > 0)
      if (g == 0 || c == 0)
        return f.warning_box("Non accetto un sottoconto con gruppo o conto vuoti");

    /*  A che cavolo serve CHECKTYPE NORMAL ????????????????????????????????????????
        TConto tc(g,c,s);
        if (!tc.read(app()->conti().curr()))
        return f.warning_box("Conto inesistente");
        */      
  }
  return TRUE;
}


// Handler del campo tipocf della maschera di edit dello sheet
// Abilita 109 e 110 (rigaiva e codiva) SOLO SE registro 1 o 2
bool CG0500_application::tipocf_hndl (TMask_field& f, KEY k)
{
  if (k == K_SPACE)
  {
    const int tpr = app()->main_mask()->get_int(F_TIPO_REG);  
    if (tpr == 1 || tpr == 2) {
      f.mask().enable(109); f.mask().enable(110);         
    }
    else  {
      f.mask().disable(109); f.mask().disable(110);
    }
  }
  return TRUE;  
}

////////////////////////////////////////////////////////////////////////////
// Funzioni che caricano le varie descrizioni fisse nell'array
////////////////////////////////////////////////////////////////////////////
void TRighe_rcaus::CausaleVendite()
{
  int i=0;
  TConto tc();
  app()->_tipo_des = vendita;
  //  set_descr(i++, "C Clienti", 'C');
  set_descr(i++, "C Clienti");   // Lascio scelta libera
  set_descr(i++, "C Di ricavo");
  set_descr(i++, "C Iva vendite");
  set_descr(i++, "C Iva non detraibile");
  set_descr(i++, "C Imp. esenti");
  set_descr(i++, "C Imp. non imponibili");
  set_descr(i++, "C Imp. non soggetti");
  set_descr(i++, "C Ritenute fiscali");
  set_descr(i++, "C Ritenute soc.");
  CaricaRigheLibere();
}


void TRighe_rcaus::CausaleAcquisti()
{
  int i=0;
  app()->_tipo_des = acquisto;
  //  set_descr( i++, "C Fornitori", 'F');
  set_descr( i++, "C Fornitori");
  set_descr(i++, "C Di costo");
  set_descr(i++, "C Iva acquisti");
  set_descr(i++, "C Iva non detraibile");
  set_descr(i++, "C Imp. esenti");
  set_descr(i++, "C Imp. non imponibili");
  set_descr(i++, "C Imp. non soggetti");
  set_descr(i++, "C Ritenute fiscali");
  set_descr(i++, "C Ritenute soc.");
  CaricaRigheLibere();
}

void TRighe_rcaus::CausaleRitenutaOccas()
{
  int i=0;
  app()->_tipo_des = ritenuta_occas;
  set_descr (i++, "Costo");
  set_descr (i++, "Cassa/banca");
  set_descr (i++, "Erario");
  CaricaRigheLibere();
}

void TRighe_rcaus::CaricaRigheLibere()
{
  for (int i = items(); i < 20; i++)
    set_descr(i);
}

void TRighe_rcaus::CausaleIncassoPagamento()
{
  int i=0;
  app()->_tipo_des = incasso_pagamento;
  set_descr ( i++, "C Clienti/Fornitori");
  set_descr ( i++, "C Cassa o banca");
  set_descr ( i++, "C Tratta");
  set_descr ( i++, "C Ricevuta bancaria");
  set_descr ( i++, "C Cessione");
  set_descr ( i++, "C Paghero'");
  set_descr ( i++, "C Lettera di credito");
  set_descr ( i++, "C Abb. pass/sc.");
  set_descr ( i++, "C Abb. att/sc.");
  set_descr ( i++, "C Spese e rimborsi");
  set_descr ( i++, "C Ritenute fiscali");
  if (gestione_valuta())
  {
    set_descr (i++, "C Differenza cambio");
    app()->_tipo_des = incasso_pagamento_gesval;
  }
  CaricaRigheLibere();
}

void CG0500_application::compilaarray(const TString& tpd, int tpm, int tpr, int m770)
{
  _forcedCopy = FALSE;
  if (tpd.empty() || tpd == "IN" || tpd == "AN" || tpd == "PG")
  {
    if (salda_conto())
    {
      switch (tpm) {
      case 3:
      case 5:
      case 6:
        _righe_rcaus.CausaleIncassoPagamento();  
        break;
      case 0: 
        if (m770 == 6)
          _righe_rcaus.CausaleRitenutaOccas();  
        else {
          _forcedCopy = TRUE;
          _righe_rcaus.ClearDescr();        
          _righe_rcaus.CaricaRigheLibere();  
        }
        break;
      default:
        _forcedCopy = TRUE;      
        _righe_rcaus.ClearDescr();
        _righe_rcaus.CaricaRigheLibere();  
        break;
      }
    }
    else  { // NO saldaconto     
      _forcedCopy = TRUE;          
      _righe_rcaus.ClearDescr();
      _righe_rcaus.CaricaRigheLibere();        
    }
  }
  else    // C'e' il tipodoc.
  {
    if (tpr == 1)
      _righe_rcaus.CausaleVendite();  
    else
      if (tpr == 2)
        _righe_rcaus.CausaleAcquisti();  
      else
      {
        _forcedCopy = TRUE;            
        _righe_rcaus.ClearDescr();
        _righe_rcaus.CaricaRigheLibere();  
      }
  }
}

bool CG0500_application::fill_sheet(TMask& m)
{
  descr2array(m);
  array2sheet();
  return TRUE;
}

int CG0500_application::read(TMask& m)
{
  m.autoload(_rel);
  descr2array(m, FALSE);
  array2sheet();
  read_rcaus(m);
  return NOERR;
}

void CG0500_application::add_riga(int numrig, 
                                  char cf, char sz, TString& d, TString& da, bool riva, 
                                  TString& civa, TConto& tc)
{
  TSheet_field& cs = ss(); 
  TToken_string & riga = cs.row(numrig);
  riga.add(cf, 1); 
  riga.add(tc.gruppo(), 2); 
  riga.add(tc.conto(), 3); 
  riga.add(tc.sottoconto(),4);
  riga.add(sz, 5); 
  riga.add(d, 6); 
  riga.add(da,7);
  riga.add(riva ? "X" : "", 8);
  riga.add(civa, 9);
}

void CG0500_application::read_rcaus(TMask& m)
{
  int numrig, g, c;
  long s;
  TString d(50), da(3), civa(3);
  char sz, cf;
  bool riva;
  TLocalisamfile& rcaus = _rel->lfile(LF_RCAUSALI);

  _rel->update();  // chiamo position_rels()
  const TString cod(_rel->lfile().get(RCA_CODCAUS));
  
  _righe_gia_presenti.reset();
  //  _righe_rcaus.destroy();
  
  rcaus.zero();
  rcaus.put(RCA_CODCAUS, cod);
  int e = rcaus.read(_isgteq);

  while (e == NOERR && rcaus.get(RCA_CODCAUS) == cod) 
  {
    numrig = rcaus.get_int(RCA_NRIGA);
    CHECK(numrig > 0, "Causale con numero riga nullo");
    g      = rcaus.get_int(RCA_GRUPPO);
    c      = rcaus.get_int(RCA_CONTO);
    s      = rcaus.get_long(RCA_SOTTOCONTO);
    sz     = rcaus.get_char(RCA_SEZIONE); 
    d      = rcaus.get(RCA_DESC);
    da     = rcaus.get(RCA_CODDESC);
    cf     = rcaus.get_char(RCA_TIPOCF);
    riva   = rcaus.get_bool(RCA_RIGAIVA);
    civa   = rcaus.get(RCA_CODIVA);
    TConto tc(g,c,s,cf);

    add_riga(numrig-1, cf, sz, d, da, riva, civa, tc);

    _righe_gia_presenti.set(numrig);    
    e = rcaus.next();
  }
}

// ricopio l'array Righe_rcaus nello sheet
void CG0500_application::array2sheet()
{
  char _dfi [30];
  TFixed_string dfi(_dfi,30);
  _items = _righe_rcaus.items();
  bool update = FALSE;

  for (int i = 0; i < _items; i++)
  {
    TToken_string& riga = ss().row(i);
    TToken_string* r    = (TToken_string*)_righe_rcaus.objptr(i);    

    dfi = r->get(0);
    // Ricopio la descrizione solo se non vuota    
    if (_forcedCopy) {  
      update = TRUE;
      riga.add(dfi,0);    
    } else 
      if (!r->empty_items()) 
      {
        if (dfi.not_empty()) 
        {
          update = TRUE;
          riga.add(dfi,0);
        }
      }
  }
  if (update) ss().force_update();
}

bool CG0500_application::descr2array(TMask& m, bool fromHandler)
{              
  TLocalisamfile& caus = _rel->lfile();
  TString16 tpd, codreg;
  int       tpm, m770, tpr;
  
  //  if (m.mode() == MODE_MOD && !fromHandler) 
  if (fromHandler) {
    codreg = m.field(F_COD_REG).get();
    tpd    = m.field(F_TIPO_DOC).get();
    tpm    = m.get_int(F_TIPO_MOV);
    m770   = m.get_int(F_M_770);    
  } else if (m.mode() == MODE_MOD) {
    codreg = caus.get("REG");
    tpd    = caus.get("TIPODOC");
    tpm    = caus.get_int("TIPOMOV");
    m770   = caus.get_int("M770");
  } 
  else   {               // sono in inserimento e prima di entrare negli handler
    codreg = m.field(F_COD_REG).get();
    tpd    = m.field(F_TIPO_DOC).get();
    tpm    = m.get_int(F_TIPO_MOV);
    m770   = m.get_int(F_M_770);    
  }
  
  if (fromHandler)
    tpr    = m.get_int(F_TIPO_REG);  
  else  {
    TString16 chiave; chiave << anno_iva() << codreg;      
    TTable reg("REG");
    reg.put("CODTAB", chiave);
    reg.read();
    tpr = reg.get_int("I0");
  }

  // carico le descrizioni fisse nell'array Righe_rcaus  
  compilaarray(tpd,tpm,tpr,m770);

  return TRUE;
}

void CG0500_application::togli_dal_file(const TString& cau)
{
  long i;
  TLocalisamfile& rcaus = _rel->lfile(LF_RCAUSALI);
  long last  = _righe_gia_presenti.last_one();
  long start = _righe_gia_presenti.first_one();

  for (i=start; i<=last; i++)
  {
    if (_righe_gia_presenti[i])
    {
      rcaus.zero();
      rcaus.put(RCA_CODCAUS,cau);
      rcaus.put(RCA_NRIGA, i);
      //      if (rcaus.read() == NOERR)
      rcaus.remove();  
      _righe_gia_presenti.reset(i);
    }
  }
}

int CG0500_application::write(const TMask& m)
{
  return re_write(m, FALSE);
}

int CG0500_application::rewrite(const TMask& m)
{
  return re_write(m, TRUE);
}

int CG0500_application::re_write(const TMask& m,bool rewrite)
{
  const TString16 cau(m.get(F_COD_CAUS));
  TString80     desc;
  TString16     coddesc;
  TLocalisamfile& caus  = _rel->lfile(LF_CAUSALI);
  TLocalisamfile& rcaus = _rel->lfile(LF_RCAUSALI);

  m.autosave(_rel);

  TSheet_field& cs = ss();
  //  _items = _righe_rcaus.items();
  _items = cs.items();

  for (int i = 0; i < _items; i++)
  {
    TToken_string &riga = cs.row(i);
    if (riga.empty_items()) continue;
    
    const char  tipo_cf = riga.get_char(1);
    const int   g       = riga.get_int(2);
    const int   c       = riga.get_int(3);
    long        s       = riga.get_long(4);
    char        sezione = riga.get_char(5);
    desc                = riga.get(6);
    coddesc             = riga.get(7);
    
    if (g > 0 || c > 0 || s > 0L)
    {
      rcaus.zero();
      rcaus.put (RCA_CODCAUS, (const char *)cau);
      rcaus.put (RCA_NRIGA, i+1);   // Numerare da uno!
      rcaus.put (RCA_GRUPPO , g);
      rcaus.put (RCA_CONTO  , c);
      rcaus.put (RCA_SOTTOCONTO, s);
      rcaus.put (RCA_SEZIONE, sezione);
      rcaus.put (RCA_DESC   , (const char *)desc);
      rcaus.put (RCA_CODDESC, (const char *)coddesc);
      rcaus.put (RCA_TIPOCF, tipo_cf);
      if (rewrite) {
        if (_righe_gia_presenti[i+1]) {
          rcaus.rewrite();
          _righe_gia_presenti.reset(i+1);
        }
        else
          rcaus.write();
      }
      else
        rcaus.write();
    }        
  } 
  
  if (rewrite)
  {
    togli_dal_file(cau);  // Elimina dal file le righe rimaste nel bitarray
    return caus.rewrite();
  }
  else
    return caus.write();
}


bool CG0500_application::remove()
{
  _rel->restore_status();   // senno' non riesco a leggere il cod. caus.
  _rel->update();           // chiamo position_rels()
  const TString cod(_rel->lfile().get(RCA_CODCAUS));
  const bool ok = TRelation_application::remove();
  if (ok)
  {
    TLocalisamfile& rcaus = _rel->lfile(LF_RCAUSALI); 
    rcaus.zero();
    rcaus.put(RCA_CODCAUS, cod);
    int e = rcaus.read(_isgteq);
    while (e == NOERR && rcaus.get(RCA_CODCAUS) == cod) 
    {
      rcaus.remove();
      e = rcaus.next();
    }
  }
  return ok; 
}

void CG0500_application::init_query_mode(TMask& m)
{
  _righe_rcaus.destroy();
  ss().reset();
  init_mask(m);
}

void CG0500_application::init_insert_mode(TMask& m)
{
  ss().reset();
  init_mask(m);
}

void CG0500_application::init_modify_mode(TMask& m)
{
  init_mask(m);
}

void CG0500_application::init_mask(TMask& m)
{
  // 27/06/94 Setto il campo nascosto F_ANNOES all'anno di liq. Iva 
  //          preso dai par.ditta
  const int anno = anno_iva();
  m.set(F_ANNOES, anno);
}


bool CG0500_application::user_create()
{
  _rel = new TRelation (LF_CAUSALI);
  _rel->add(LF_RCAUSALI, "CODCAUS=CODCAUS");

  _conti = new TLocalisamfile (LF_PCON);

  _msk = new TMask("cg0500a");

  if (!salda_conto()) 
  {
    _msk->hide (F_MOV_SEZ);
    _msk->hide (F_TIPO_MOV_1);
    _msk->hide (F_TIPO_MOV_2);
    _msk->show (F_COD_CAUS_IM);
  }
  else 
  {
    _msk->show (F_MOV_SEZ);
    _msk->hide (F_COD_CAUS_IM);
  }
  
  if (gestione_valuta())
    _msk->show (F_MOV_VALU);
  else
    _msk->hide (F_MOV_VALU);
  
  _msk->set_handler(F_TIPO_DOC, tipodoc_hndl);
  if (salda_conto()) 
  {
    _msk->set_handler(F_TIPO_MOV_1, tipomov_hndl);
    _msk->set_handler(F_TIPO_MOV_2, tipomov_hndl);
  }
  _msk->set_handler(F_COD_REG, cod_reg_hndl);
  _msk->set_handler(F_COD_CAUS_IM, codcausim_hndl);
  _msk->set_handler(F_M_770, m770_hndl);

  TSheet_field& cs = ss();
  cs.set_notify(leggi_riga);
  
  cs.sheet_mask().set_handler(102, tipocf_hndl);  // 102 e' il TIPOCF
  cs.sheet_mask().set_handler(105, sottoconto_hndl);  
  cs.sheet_mask().set_handler(205, sottoconto_hndl); 
  cs.sheet_mask().set_handler(305, sottoconto_hndl);
  cs.sheet_mask().set_handler(104, conto_hndl);
  
  _forcedCopy = FALSE;
  
  return TRUE;
}

bool CG0500_application::user_destroy()
{
  delete _msk;
  delete _rel;
  delete _conti;
  return TRUE;
}

int cg0500(int argc, char* argv[])
{
  CG0500_application a;
  a.run(argc, argv, "Tabella causali");
  return 0;
}