\// ve6100.cpp: programma di contabilizzazione documenti
// Orgiastica visione...
//      L'anatra del dubbio dalle labbra di Vermouth.
//******************************************************************************
//          \\\\\\\\                 e                                         *
//     b     \\\\\\\\                          b                               *
//            \\\\\\\\   e                            r          d        l    *
//             \\\\\\\\                                                        *
//              \\\\\\\\    i       V              o             e      h      *
//      L        \\\\\\\\                                                      *
//                \\\\\\\\     b        d                                      *
//              o  \\\\\\\\                      m         a                   *
// +++++++++++++++++++++++++            b                              t       *
// ++++++++++++++++++++++++++--------------------------------------------------|
// ++++++++++++++++++++++++++--------------------------------------------------|
// ++++++++++++++++++++++++            |---------------------------------------|
//    u           ////////          u  |---------------------------------------|
//       '       ////////    a         |             /\            /\          |
//              ////////           i   |  r         /  \  r       /  \         |
//         a   ////////               \|/          /    \        /    \  l     |
//            ////////-----------------*---\  a   /  t   \      /   a  \      /|
//           ////////                 /|\   \    /        \    /        \    / |
//   d      ////////          n        |     \  /          \  /          \  /  |
//         ////////    l          d    |      \/     a      \/     l      \/   |
//-----------------------------------------------------------------------------|
//
// Scared uh?

#include <applicat.h>
#include <relation.h>
#include <tabutil.h>
#include <mask.h>
#include <sheet.h>
#include <urldefid.h>
#include <progind.h>
#include <modaut.h>
#include "velib.h"
#include "../cg/cgsaldac.h"
#include "ve6100a.h"


// TContabilizzazione_app
// Applicazione di contabilizzazione documenti
class TContabilizzazione_app : public TApplication
{
  TString16     _cod_el;       // codice elaborazione immesso
  TDate         _data_reg;     // data di registrazione immessa
  TDate         _data_ini;     // data di inizio intervallo
  TDate         _data_fine;    // data di fine intervallo
  bool          _auto_data;    // se TRUE prende in automatico la data di registrazione dalla data documento
  byte          _nump_iva;
  TMask         *_msk;         // maschera di selezione dati
  TArray_sheet       *_num_sheet; // Array sheet selezionabile dei codici numerazione
  TString_array      _tipi_doc;   // Array di stringhe contenente i tipi documenti da elaborare
  TArray        _file;
  
protected: // TApplication
  void open_files(int logicnum, ...);  
  // Contabilizza i documenti
  void contabilize();
  // Le 4 seguenti non hanno bisogno di commenti
  virtual bool menu(MENU_TAG mt);
  virtual bool create();
  virtual bool destroy();
  virtual void on_config_change();
  // Handler del codice elaborazione differita
  static bool handle_cod_eld(TMask_field& f, KEY k);
  // Handler dell'intervallo di date
  static bool handle_data_range(TMask_field& f, KEY k);
  // Handler della data di registrazione
  static bool handle_data_reg(TMask_field& f, KEY k);
  // Handler del pulsante di selezione codici numerazione
  static bool handle_select(TMask_field& f, KEY k);
  // Ritorna il TArray_sheet contenente le selezioni sui codici numerazione
  // Costruisce lo sheet dei codici numerazione
  void   build_num_sheet();
  TArray_sheet* get_num_sheet() const { return _num_sheet; }
  // Coontrolla se lo stato ed il tipo del documento sono validi e rispettano la selezione
  bool doc_tipo_stato_ok(TDocumento* doc);
public:
  TContabilizzazione_app() {_msk = NULL; _num_sheet = NULL;} 
  virtual ~TContabilizzazione_app() { }
};

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

void TContabilizzazione_app::open_files(int logicnum, ...)  
{  
  va_list marker;
  va_start(marker, logicnum);
  while (logicnum > 0)
  {
    CHECKD(_file.objptr(logicnum) == NULL, "File gia' aperto: ", logicnum);
    _file.add(new TLocalisamfile(logicnum), logicnum);
    logicnum = va_arg(marker, int);
  }
}

bool TContabilizzazione_app::handle_data_range(TMask_field& f, KEY k)
{
  if (k==K_ENTER && f.dirty())
  {
    TMask& m = f.mask();
    if (m.get_bool(F_DATA_AUTO))
      return TRUE;  // Skip controls if data is automatic
    TDate da(m.get_date(F_DATA_INI));
    TDate a(m.get_date(F_DATA_FIN));
    m.field(F_DATA_REG).set_dirty();
    //if (a == botime || da == botime) return TRUE;
    if (a < da) 
    {
      f.error_box("La data di inizio deve essere minore della data di fine.");
      return FALSE;
    }
    if ((a - da) > 15)
    {
      f.error_box("L'intervallo tra le date non puo' eccedere i 15 giorni.");
      return FALSE;
    }
    if (F_DATA_FIN)
      m.set(F_DATA_REG,f.get());
  }
  if (f.focusdirty())
  {
    TMask& m = f.mask();
    if (!m.get_bool(F_DATA_AUTO) && f.dlg() == F_DATA_FIN)
      m.set(F_DATA_REG,f.get());
  }
  return TRUE;
}

bool TContabilizzazione_app::handle_data_reg(TMask_field& f, KEY k)
{
  if (k==K_ENTER && f.dirty())
  {
    TMask& m = f.mask();
    
    TDate data_reg(f.get());
    if (data_reg == botime) return TRUE;
    TDate da(m.get_date(F_DATA_INI));
    //if (!da.ok()) return TRUE;
    if ((data_reg - da) > 15)
    {
      f.error_box("L'intervallo tra la data di registrazione e la data di inizio non puo' eccedere i 15 giorni.");
      return FALSE;
    }
    if (data_reg < da)
    {
      f.error_box("La data di registrazione non puo' essere minore della data di inizio.");
      return FALSE;
    }
  }
  return TRUE;
}

bool TContabilizzazione_app::handle_cod_eld(TMask_field& f, KEY k)
{
  if (f.to_check(k) && k == K_TAB) // se e' cambiato ricostruisce anche lo sheet dei codici numerazione
  {
    app()._cod_el = f.get(); // aggiorna il codice elaborazione per la build_num_sheet()
    f.mask().disable(DLG_OK);
    app().build_num_sheet();
  }
  return TRUE;
}

bool TContabilizzazione_app::handle_select(TMask_field& f, KEY k)
{
  if (k == K_SPACE)
  {
    TMask& m = f.mask();
    TArray_sheet* s = app().get_num_sheet();
    if (s->run())
    {
      if (s->checked() != 0) // Hai selezionato qualcosa ?
        m.enable(DLG_OK);    // allora abilita il pulsante di conferma 
      else
        m.disable(DLG_OK);
    }
  }
  return TRUE;
}

void TContabilizzazione_app::build_num_sheet()
{
  _num_sheet->destroy();
  
//  TTable eld("%ELD");
  TTable num("%NUM");
  TString s1,s2,s3;
//  TString16 tipon1,tipon2,tipon3,tipon4,tipon5,tipon6,tipon7,tipon8,tipon9,tipon10; // tipi documento validi per la numerazione
  long pos;
  
//  eld.put("CODTAB",_cod_el);
  TContabilizzazione* cont = new TContabilizzazione(_cod_el);  
//  if (eld.read() == NOERR)
  if (!cont->empty())
  {
    TToken_string t;
    TString16 tipo;
//    s1 = eld.get("S2");
//    s3 = eld.get("S7");
    for (int i=0;i<TElaborazione::_max_tipi_doc_elab;i++)
    {
//      t = s1.mid(i*4,4);     // Tipo documento
//      if (t.trim().empty()) break;
      tipo = cont->tipo_iniziale(i);
      if (tipo.not_empty())
      { 
        t = tipo;
        t.add(cont->stato_iniziale(i));  // Stato iniziale
        _tipi_doc.add(t);    // Aggiunge questo tipo documento alla lista
      }
    }
    for (pos=0,num.first();num.good();num.next(),pos++) // scorre tutte le numerazioni possibili
    {
      TToken_string t;
      t.add(" ");
      t.add(num.get("CODTAB"));
      t.add(num.get("S0"));
      _num_sheet->add(t);
      s2 = num.get("S2"); // reperisce i tipi documento validi per questa numerazione
/*      tipon1 = s2.mid(0,4);
      tipon2 = s2.mid(4,4);
      tipon3 = s2.mid(8,4);
      tipon4 = s2.mid(12,4);
      tipon5 = s2.mid(16,4);
      tipon6 = s2.mid(20,4);
      tipon7 = s2.mid(24,4);
      tipon8 = s2.mid(28,4);
      tipon9 = s2.mid(32,4);
      tipon10 = s2.mid(36,4);       */
      bool found = FALSE;  
      for  (int i = _tipi_doc.last(); !found && i >= 0; i--)
        found |= s2.find(((TToken_string &)_tipi_doc[i]).get(0)) >= 0;
      if (found)
        _num_sheet->enable_row(pos);
      else
        _num_sheet->disable_row(pos);
/*      const int n1 = s1.find(tipon1);
      const int n2 = s1.find(tipon2);
      const int n3 = s1.find(tipon3);
      const int n4 = s1.find(tipon4);
      const int n5 = s1.find(tipon5);
      const int n6 = s1.find(tipon6);
      const int n7 = s1.find(tipon7);
      const int n8 = s1.find(tipon8);
      const int n9 = s1.find(tipon9);
      const int n10 = s1.find(tipon10);
      if ((tipon1.empty() || n1<0) && (tipon2.empty() || n2<0) && 
          (tipon3.empty() || n3<0) && (tipon4.empty() || n4<0) &&
          (tipon5.empty() || n5<0) && (tipon6.empty() || n6<0) &&
          (tipon7.empty() || n7<0) && (tipon8.empty() || n8<0) &&
          (tipon9.empty() || n9<0) && (tipon10.empty() ||  n10<0))
        _num_sheet->disable_row(pos);
      else
        _num_sheet->enable_row(pos);*/
    }
  }
  delete cont;
}

bool TContabilizzazione_app::doc_tipo_stato_ok(TDocumento* doc)
// Verifica che il tipo documento corrente esista tra i tipi previsti dalla elaborazione
// differita selezionata
{
  const int items = _tipi_doc.items();
  bool found = FALSE;
  const TString16 tipo(doc->tipo().codice());
  const char stato = doc->stato();
  for (int i=0;i<items && !found;i++)
  {
    TToken_string& t = _tipi_doc.row(i);
    const TString16 tipox(t.get(0));
    const char statox = t.get(1)[0];
    if (tipo == tipox && stato == statox)
      found = TRUE;
  }
  return found;
}

void TContabilizzazione_app::on_config_change()
{
  TPartita::carica_allineamento();
}

bool TContabilizzazione_app::create()
{
  TApplication::create();
//  if (!has_module(CGAUT))
//  {
//    error_box("Impossibile eseguire il programma se il modulo Contabilita' Generale non e' abilitato");
//    return FALSE;
//  }
  open_files(LF_TABCOM, LF_TAB, LF_CLIFO, LF_OCCAS, LF_INDSP, LF_CFVEN, LF_DOC, LF_RIGHEDOC, LF_ANAMAG, LF_MOVMAG, LF_RMOVMAG, LF_CONDV, LF_SVRIEP, LF_AGENTI, LF_PERCPROV, 0);
  _msk = new TMask("ve6100a");
  _msk->set_handler(F_CODICE_ELAB,handle_cod_eld);
  _msk->set_handler(F_DATA_INI,handle_data_range);
  _msk->set_handler(F_DATA_FIN,handle_data_range);
  //_msk->set_handler(F_DATA_REG,handle_data_reg);
  _msk->set_handler(DLG_USER,handle_select);
  _num_sheet = new TArray_sheet(-1,-1,-4,-4,"Codici numerazione",
               "@1|Cod. numerazione|Descrizione@50");
  dispatch_e_menu(BAR_ITEM(1));
  return TRUE;
}

bool TContabilizzazione_app::destroy()
{
  if (_msk) delete _msk;
  if (_num_sheet) delete _num_sheet;
  return TApplication::destroy();
}

bool TContabilizzazione_app::menu(MENU_TAG mt)
{
  while (_msk->run() == K_ENTER)
  {
    _cod_el = _msk->get(F_CODICE_ELAB);
    _data_ini = _msk->get_date(F_DATA_INI);
    _data_fine = _msk->get_date(F_DATA_FIN);
    _data_reg = _msk->get_date(F_DATA_REG);
    _auto_data = _msk->get_bool(F_DATA_AUTO);
    _nump_iva = _msk->get_int(F_SELPROT);
    contabilize();
  }
  return FALSE;
}

void TContabilizzazione_app::contabilize()
{
  TRelation *doc_rel = new TRelation(LF_DOC);
  TRectype *da = new TRectype(LF_DOC);
  TRectype *a = new TRectype(LF_DOC);
  const long items = _num_sheet->items();
  int year_from = _data_ini.year();
  int year_to = _data_fine.year();
  TString16 codnum;
  TString msg,filt_expr;
  TLista_documenti lista_in,lista_out;
  TContabilizzazione* cont = new TContabilizzazione(_cod_el);  
  // Compone la lista dei documenti da elaborare
  
  da->put("DATADOC",_data_ini);
  da->put("PROVV","D");
  da->put("ANNO",year_from);
  a->put("DATADOC",_data_fine);
  a->put("PROVV","D");
  a->put("ANNO",year_to);
  for (long i=0L; i<items;i++)  // Scorre per tutte le numerazioni dello sheet
    if (_num_sheet->checked(i)) // Se la numerazione corrente e' stata selezionata
    {                           // istanzia un cursore per la numerazione corrente, con i limiti di data
      codnum = _num_sheet->row(i).get(1);
      filt_expr = "CODNUM=\"";
      filt_expr << codnum << "\"";
      TCursor doc_cur(doc_rel,filt_expr,3,da,a);
      const long cur_items = doc_cur.items(); // Scorre tutti i documenti che rientrano nell'intervallo selezionato
      if (cur_items == 0) 
      {
        warning_box("Non vi sono documenti da contabilizzare per il codice numerazione %s",(const char*)codnum);
        continue;
      }
      msg = "Selezione documenti ";
      msg << codnum << " dal ";
      msg << _data_ini.string() << " al ";
      msg << _data_fine.string();
#ifdef DBG      
      TProgind p(cur_items,msg,TRUE,TRUE,1);
#else
      TProgind p(cur_items,msg,FALSE,TRUE,1);
#endif
      long j = 0;
#ifdef DBG      
      for (;j<cur_items && !p.iscancelled();j++)
#else      
      for (;j<cur_items;j++)
#endif      
      { 
        p.setstatus(j+1);
        doc_cur = j;
        TDocumento* doc = new TDocumento;
        if (doc->read(doc_cur.curr()) == NOERR && // legge il documento
            codnum == doc->get("CODNUM") &&       // controlla che il tipo documento e lo stato siano coerenti con la ELD selezionata
            doc_tipo_stato_ok(doc)) 
          lista_in.add(doc); // Viene aggiunto alla lista dei documenti
        else
          delete doc;
      }
#ifdef DBG      
      if (p.iscancelled()) break;
#endif
    }

  cont->set_auto(_auto_data); // Setta il flag per il settaggio automatico della data di registrazione del movimento
  cont->set_nump(_nump_iva);  // Setta il flag per il settaggio del numero di protocollo
  cont->elabora(lista_in,lista_out,_data_reg);
  if (cont->docs() > 0L)
    message_box("Totale documenti contabilizzati: %ld",cont->docs());
}

int ve6100 (int argc, char **argv)
{
  TContabilizzazione_app a;
  a.run(argc,argv,"Contabilizzazione documenti");
  return TRUE;
}