#include <applicat.h>
#include <config.h>
#include <form.h>
#include <mask.h>   
#include <printer.h>
#include <relation.h>
#include <strings.h>
#include <expr.h>
#include <tabutil.h>
#include <urldefid.h>
#include <utility.h>

// !! fatto (in ordine d'esecuzione):
// !! ------------------------------
// !! - lettura parametri linea di comando per eventuale esecuzione batch
// !! - impostazione di flag di interattività posto a true se non ci sono parametri sulla linea
// !!   di comando; influisce su:
// !!   - apertura maschera richiesta dati
// !!   - richiesta di stampa definitiva
// !!   - richiesta d'interruzione in caso di stato non valido durante stampa definitiva
// !!   - interruzione forzata in caso di impossibilità di rinumerazione definitiva
// !! - impostazione di flag di stampa definitiva (da linea di comando o richiesta con box);
// !!   influisce su:
// !!   - controllo stati durante la stampa
// !!   - lancio della procedura di rinumerazione definitiva
// !! - lettura tabelle codice numerazione e tipo documento
// !! - lancio batch della stampa se sono presenti i parametri sulla linea di comando
// !! - creazione e apertura della maschera e lettura dati
// !! - impostazione della regione del cursore del form
// !! - ciclo di lettura del form con stampa della posizione corrente e lancio (eventuale)
// !!   della rinumerazione
// !! - intercettazione dei seguenti messaggi custom nel form:
// !!   - _ISAMREAD per letture generiche dal database
// !!   - _TABLEREAD per lettura generiche da tabelle del database
// !!   - _DITTA per ottenere dati di configurazione sulla ditta in uso
// !!   - _CIFRELETTERE per la conversione di un valore in lettere
// !! - chiusura applicazione

// !! da fare:                                       
// !! -------
// !! - tutto il resto



#include "ve1100.h"
#include "ve0100b.h"



////////////////////////////////////////////////////////////////////////////
// classe TDocVen_Form customizzata dalla Form per i documenti di vendita
////////////////////////////////////////////////////////////////////////////

class TDocVen_Form: public TForm { 
  TRelation &_firmrel; // relazione di gestione dei dati della ditta corrente
protected:
  virtual bool validate(TForm_item &, TToken_string &);
public:
  TDocVen_Form(const char *, TRelation &);
};



TDocVen_Form::TDocVen_Form(const char* name, TRelation &rel): TForm(name), _firmrel(rel) {
  //_firmrel= rel; // prende il riferimento alla relazione di gestione dei dati della ditta
}



bool TDocVen_Form::validate(TForm_item &cf, TToken_string &s) {
  const TString16 code(s.get(0)); // prende il primo parametro, il codice del messaggio

  if (code== "_ISAMREAD") {

    // lettura generica di un file del database
    // sintassi: _ISAMREAD <file> <espressione input>,<espressione input>,... <espressione output>,<espressione output>,...
    // dove: <file> è il numero logico del file o il nome della tabella
    //       <espressione input> è un'espressione del tipo <campo file>=<espressione campi form>
    //       <espressione campi form> è un'espressione di costanti numeriche, stringhe e valori di campi della form (indicati con il loro numero preceduto da @)
    //       <espressione output> è un'espressione del tipo <campo form o gruppo>=<campo file> (se è un gruppo deve essere seguito da @) oppure solo <campo file> (il campo della form è quello corrente)
    
    int i, j, poseq, posrv, itms;
    pagetype pt;
    char sec;
    TLocalisamfile *file;
    
    TString f_code(s.get()); // prende il codice del file da leggere
    if (atoi(f_code) != 0) file= new TLocalisamfile(atoi(f_code)); // se il codice è numerico allora è un file
    else file= new TTable(f_code); // altrimenti è una tabella
    TToken_string in(s.get(), ',');
    for (i=0; i<in.items(); i++) { // scansione sugli elementi dell'input
      TString curr(in.get(i));
      poseq= curr.find("=="); // divide la stringa corrente in lvalue e rvalue
      if (poseq== -1) {
        poseq= curr.find('=');
        if (poseq != -1) posrv= poseq+1;
      } else posrv= poseq+2;
      const TString &fld= curr.left(poseq); // preleva il nome del campo del file alla sinistra dell'uguale
      const TString &expr= curr.mid(posrv); // preleva l'espressione di assegnamento alla destra dell'uguale
      TExpression rval(expr, _strexpr);
      for (j=0; j<rval.numvar(); j++) { // scansione delle variabili dell'espressione di rvalue
        TString var= rval.varname(j);
        if (var[0]=='@') var.ltrim(1); // rimuove dalla stringa il primo carattere
        TForm_item &fi= cf.find_field(var);
        rval.setvar(j, fi.get()); // il valore corrente del campo viene settato nell'espressione
      }
      file->put(fld, (const char *)rval); // scrive il risultato dell'espressione nel campo del file
    }
    if (file->read()== NOERR) { // tenta una lettura del file
      TToken_string out(s.get(), ',');
      for (i=0; i<out.items(); i++) { // scansione sugli elementi dell'output
        TString curr(out.get(i));
        poseq= curr.find("=="); // divide la stringa corrente in lvalue e rvalue
        if (poseq== -1) {
          poseq= curr.find('=');
          if (poseq != -1) posrv= poseq+1;
        } else posrv= poseq+2;
        if (poseq== -1) {
          const TString &dat= file->get(curr.mid(posrv)); // preleva il nome del campo del file alla destra dell'uguale e lo legge dal record
          cf.set(dat); // setta il campo letto dal file nel campo corrente della form   
        } else {
          TString fld= curr.left(poseq); // preleva il nome del campo del form alla sinistra dell'uguale
          const TString &dat= file->get(curr.mid(posrv)); // preleva il nome del campo del file alla destra dell'uguale e lo legge dal record
          if (fld.left(1)== "@") fld.ltrim(1);
          if (fld.right(1)== "@") { // se c'è la a-commerciale è un gruppo
            if (fld.find("->") != -1) { // se nel gruppo c'è la freccia si riferisce ad un'altra sezione
              sec= fld[0];
              if (fld[1] != '-') pt= char2page(fld[1]);
              else pt= even_page;
              itms= section(sec, pt).fields();
            } else { // altrimenti si riferisce alla sezione corrente
              sec= cf.section().section_type();
              pt= cf.section().page_type();
              itms= cf.section().fields();
            }
            for (j=0; j<itms; j++) { // per ogni campo della sezione specificata (o sottointesa)...
              TForm_item &fi= section(sec, pt).field(j);
              fi.set(dat); // ...il contenuto viene settato al valore del file
            }
          } else {
            TForm_item &fi= cf.find_field(fld);
            fi.set(dat);
          }
        }
      }
    }
    delete file;
    return (TRUE);
  } // fine _ISAMREAD
  
  if (code== "_TABLEREAD") {

    // lettura generica di un campo di una tabella
    // sintassi: _TABLEREAD <tabella> <chiave> <campo file>
    // dove: <tabella> nome tabella da leggere
    //       <chiave> costante stringa o riferimento a campo della form da usare come chiave di ricerca
    //       <campo file> identificativo del campo da leggere dalla tabella

    TTable tab(s.get()); // prende il nome della tabella
    TString in(s.get()); // prende il valore o il campo da usare come codice di ricerca
    if (in.left(1)== '@') {
      in= in.mid(1);
      TForm_item &fi= cf.find_field(in);
      in= fi.get();
    }
    tab.put("CODTAB", in); // setta la chiave nella tabella
    if (tab.read()== NOERR) {
      const TString &fld= s.get(); // prende il nome del campo da leggere...
      cf.set(tab.get(fld)); // ...e lo scrive nel campo del form
    }
    return (TRUE);
  } // fine _TABLEREAD
  
  if (code== "_DITTA") {
    
    // lettura dei dati della ditta
    // sintassi: _DITTA <campo relazione>
    // dove: <campo relazione> è un riferimento alla relazione di gestione dei dati della ditta (es. 113@->DENCOM è la denominazione del comune di residenza della ditta)
    // nota: la relazione di della ditta è così strutturata:
    //       %NDITTE (9) Dati ditte
    //       + %ANAGR (6) Anagrafica generale (indirizzo, ecc.)
    //          + %COMUNI (113@) Comune di residenza
    //          + %COMUNI (213@) Comune di residenza fiscale

    TFieldref fref(s.get(), 0);
    cf.set(fref.read(&_firmrel));
    return (TRUE);
  } // fine _DITTA
  
  if (code== "_CIFRELETTERE") {
    
    // conversione di un reale da cifre a lettere
    // sintassi: _CIFRELETTERE
    
    real n(cf.get());
    cf.set(n.string("LETTERE"));
    return (TRUE);
  } // fine _CIFRELETTERE
  
  return TForm::validate(cf, s); // se il codice del messaggio non è identificato viene passato alla funzione standard
}



//////////////////////////////////////////////////////////////////////////////////////////////
// classe TStampa_Doc_Vendita customizzata dalla TApplication per l'applicazione principale
//////////////////////////////////////////////////////////////////////////////////////////////

class TStampa_Doc_Vendita: public TApplication {
  TString16 _codnum; // codice di numerazione
  TString16 _provv; // stampa provvisioria
  int _anno; // anno della documentazione
  long _dalnum, _alnum; // estremi di numerazione dei documenti
  TString16 _tipodoc; // tipo documento ricavato dal codice di numerazione
  TString _profilo; // nome del profilo di stampa del form
  TString _config; // nome del file di configurazione
  TToken_string _stati; // token string con gli stati validi dei documenti
  bool _interattivo; // flag che indica se il prog. funziona in interattivo o in batch
  bool _definitiva; // flag che indica se la stampa è definitiva o no
  TRelation *_firmrel; // puntatore alla relazione che gestisce i dati della ditta corrente
protected:
  virtual bool create(void);
  virtual bool destroy(void);
  virtual bool menu(MENU_TAG);
  int select(void);
  int initialize(void);
  virtual void print(void);
  virtual void on_firm_change(void);
};



bool TStampa_Doc_Vendita::create() {
  TApplication::create();

  _firmrel= new TRelation(LF_NDITTE); // istanziamento e impostazione della relazione di gestione della ditta corrente
  _firmrel->add(LF_ANAG, "TIPOA=TIPOA|CODANAGR=CODANAGR");
  _firmrel->add(LF_COMUNI, "COM=COMRES", 1, LF_ANAG, 100+LF_COMUNI);
  _firmrel->add(LF_COMUNI, "COM=COMRF", 1, LF_ANAG, 200+LF_COMUNI);

  if (argc()>2) { // lettura dei parametri iniziali dalla linea di comando
    _codnum= argv(2); // il primo parametro è il codice di numerazione
    _anno= atoi(argv(3)); // il secondo è l'anno
    _provv= argv(4); // il terzo è il flag di numerazione provvisoria
    _dalnum= atol(argv(5)); // il quarto è il numero di documento di partenza
    _alnum= atol(argv(6)); // il quinto è il numero di documento di fine
    _definitiva= (strcmp(argv(7), "D")==0); // il sesto è il flag di stampa definitiva
    _interattivo= FALSE;
    if (initialize()==1) print();
  } else { // oppure lancio della maschera
    _interattivo= TRUE;
    dispatch_e_menu(BAR_ITEM(1));
  }

  return (TRUE);
}



bool TStampa_Doc_Vendita::destroy() {
  delete _firmrel; // distruzione della relazione di gestione della ditta corrente
  return TApplication::destroy();
}



void TStampa_Doc_Vendita::on_firm_change() {
  TLocalisamfile &firmfile= _firmrel->lfile();
  firmfile.put("CODDITTA", get_firm());
  _firmrel->read();
}



int TStampa_Doc_Vendita::initialize() {
  TTable num("NUM");
  num.put("CODTAB", _codnum);
  if (num.read()== NOERR) {
    _tipodoc= num.get("S2"); // legge il tipo di documento dalla tabella codici di numerazione

    TTable tip("TIP");
    tip.put("CODTAB", _tipodoc);
    if (tip.read()== NOERR) {
      _config= tip.get("S4"); // legge il nome del file di configurazione
      _profilo= tip.get("S5"); // legge il nome del profilo di stampa

      TConfig config(_config);
      config.set_paragraph("STAMPA");
      if (config.exist("STATIVALIDI")) {
        _stati= config.get("STATIVALIDI");
        return (1); // 1 indica che è tutto a posto
      } else return (-11); // -11 indica che non è stata trovata una variabile nel file di configurazione
    } else return (-2); // -2 indica che c'è stato un errore nella lettura della tabella TIP
  } else return (-1); // -1 indica che c'è stato un errore nella lettura della tabella NUM
}       



int TStampa_Doc_Vendita::select() {
  TMask m("ve1100a");
  if (m.run() == K_ENTER) {
    _codnum= m.get(F_CODNUM); // lettura dei dati dalla maschera
    _anno= m.get_int(F_ANNO);
    _provv= (m.get_bool(F_PROVV))?("P"):("D");
    _dalnum= m.get_long(F_DA_NDOC);
    _alnum= m.get_long(F_A_NDOC);

    return (initialize());
  } else return (0); // 0 indica che non si è usciti con "Conferma" dalla maschera
}



bool TStampa_Doc_Vendita::menu(MENU_TAG) { // procedura di dispatch dei menu
  int s;
  
  while ((s= select()) != 0) if (s==1) print(); // se la selezione della maschera ritorna 1 viene lanciata la stamapppa
  return (FALSE);
}



void TStampa_Doc_Vendita::print() {
  bool ok;

  if (_interattivo) {
    switch (yesnocancel_box("Inserire il modulo prefincato nella stampante. E' una stampa definitiva?")) {
    case K_YES: _definitiva= ok= TRUE; break;
              case K_NO: _definitiva= FALSE; ok= TRUE; break;
              case K_ESC:
              default: ok= FALSE; break;
              }
  } else ok= TRUE; // se il programma è lanciato in batch si considera già confermata la richiesta di stampa
  if (ok) {
    printer().open();
    
    TDocVen_Form f(_profilo, *_firmrel);
    TCursor &cur= *(f.cursor()); // ricava il riferimento al cursore originale del form
    TLocalisamfile &doc= cur.file(); // ricava il riferimento al file principale del cursore

    doc.put("CODNUM", _codnum); // si posiziona sul record di inizio cursore
    doc.put("ANNO", _anno);
    doc.put("PROVV", _provv);
    doc.put("NDOC", _dalnum);
    doc.read();
    TRectype darec= doc.curr();
    
    doc.put("NDOC", _alnum); // si posiziona sul record di fine cursore
    doc.read();
    TRectype arec= doc.curr();
    
    cur.setregion(darec, arec); // imposta il filtro sul cursore di stampa
    
    for (int i= 0; i<cur.items(); i++) {
      cur= i; // posiziona il cursore
      if ((_stati.get_pos(doc.get("STATO"))== -1) && _definitiva) { // se lo stato del doc. corrente non è valido...
        if (_interattivo) { // ...viene mostrata una richiesta d'interruzione in modo interattivo...
          if (yesno_box("Non è possibile stampare un documento con stato non valido: interrompo la stampa?")) break;
        } else break; // ...o viene interrotta brutalmente la stampa in modo batch
      }
      f.print(-1); // stampa il record corrente del form
      if (_definitiva && (numerazione_definitiva(doc) != NOERR)) { // se la stampa è definitiva viene lanciata la procedura di rinumerazione
        if (_interattivo) error_box("Non è possibile completare la procedura di numerazione definitiva dei documenti");
        break;
      }
    }
    
    printer().close();
  }
}



int ve1100(int argc, char* argv[]) {
  TStampa_Doc_Vendita a;
  a.run(argc, argv, "Stampa doc. vendita");
  return (0);
}