#include <applicat.h>
#include <filetext.h>
#include <form.h>
#include <mask.h>
#include <relation.h>
#include <tabutil.h>
#include <printer.h>
#include <progind.h>
#include <recarray.h>
#include <utility.h>

#include "..\mg\umart.h"
#include "..\mg\anamag.h"
#include "..\ve\condv.h"
#include "..\ve\rcondv.h"
#include "dl0.h"
#include "dl0800a.h"

#define DLFILENAME "XCATT00F"

////////////////////////////////////////////////////////
// Classe TCat2dl_file customizzata dalla TFile_text //
////////////////////////////////////////////////////////

class TCat2dl_file: public TFile_text
{ 
protected:
  virtual void validate(TCursor& cur,TRecord_text &rec, TToken_string &val, TString& str);

public:
  virtual int autosave(TRelation& rel, const TRecord_text& rec);
  virtual bool pre_writerel(TRelation& rel,const TRecord_text& rec);
  void write_supporto(const TRecord_text& rec);
  void write_listini(const TRecord_text& rec);
  void write_offerte(const TRecord_text& rec);
  TCat2dl_file(const TString& file_name, const TString& config_name);
  virtual ~TCat2dl_file() { }
};

TCat2dl_file::TCat2dl_file(const TString& file_name, const TString& config_name)
          : TFile_text(file_name, config_name)
{
}

int TCat2dl_file::autosave(TRelation& rel, const TRecord_text& rec)
{           
  const TString& type = rec.type(); //prendo il tracciato record del tipo del record_text 
  TTracciato_record& tr = *t_rec(type); 
  
  TArray& a_tc = tr.tracciati_campo();
  const int items =  a_tc.items();                 
  TString valore;
  for (int i = 0; i < items; i++)
  {
    const TTracciato_campo& tc = tr.get(i);
    TFieldref field(tc.field());
    if (field.name().not_empty())
    {
      if (field.file()==0)
        field.set_file(rel.lfile().num());  
      valore = rec.row(i);                     
      // formatta il campo del file di testo secondo le specifiche del campo su file isam
      preformat_field(field,valore,rel,tr.type());
      const TRectype& rel_rec = rel.curr(field.file());
      TFieldtypes tipo_campo = rel_rec.type(field.name());
      bool vuoto = valore.blank();

      switch(tipo_campo)      //in base al tipo di campo formatta i valori seguendo le specifiche del tracciato
      {
      case _datefld:          //tipo data...
        {                  
          if (real::is_null(valore))
          {
            valore.cut(0);
            vuoto = TRUE;
          }
          TDate data(valore);  
          format_date(data, fpicture(tc), valore);//formatta la data secondo le specifiche del tracciato    
        }                
        break;
      case _realfld:          //tipi numerici
      case _intfld:  
      case _longfld:  
        {
           const real numero(valore);
           vuoto = numero.is_zero();

           valore = numero.string(fpicture(tc));//formatta il numero secondo le specifiche del tracciato
           
           int length = flength(tc,rel_rec);
           if (falign(tc) == 'L')
             valore.left_just(length, ffiller(tc));
           else
             valore.right_just(length, ffiller(tc));
        }              
        break;
      default:  
        valore = format_field(tc, rel.lfile().num(), valore);//formatta il campo secondo le specifiche del record
        break;
      }

      if (!vuoto && rel.exist(field.file()))
        field.write(valore, rel);//faccio una write sulla relazione del fieldref
    }  
  } 
  
  int err = NOERR;
  if (pre_writerel(rel,rec))
  {
    err= rel.write();
    if (err == _isdupkey || err ==_isreinsert)
      err = rel.rewrite();     
  }
  return err;
}

bool TCat2dl_file::pre_writerel(TRelation& rel,const TRecord_text& rec)
{ 
  // 1) sistema i tipi di supporto
  write_supporto(rec);
  // 2) legge e scrive i dati dei listini: se il listino non esiste lo crea
  write_listini(rec);
  // 3) legge e scrive i dati delle offerte: se l'offerta non esiste la crea
  write_offerte(rec);  
  return TRUE;
}

//scrive il supporto dell'articolo nel campo UM del file umart (unita' di misura)
void TCat2dl_file::write_supporto(const TRecord_text& rec)
{ 
  const TString& codart = rec.get(2);
  const TString& um = rec.get(7);
  
  if (!um.blank())                    //il casino lo fa solo se ha un codice supporto non nullo
  {
    TLocalisamfile umart(LF_UMART);   //prende il file delle unita' di misura...
    umart.put(UMART_CODART, codart);
    umart.put(UMART_UM, um);
    umart.setkey(2);                  //..con chiave 2...
    
    int err = umart.read();           //..e lo legge
    
    if (err != NOERR)                 //Se non trova l'unita' di misura tra quelle gia' presenti...
    {
      umart.setkey(1);
      umart.put(UMART_CODART, codart);
      umart.put(UMART_NRIGA, 999);
      err = umart.read(_isgreat);                              
      err = umart.prev();
      
      int nriga = 1;
      if (err == NOERR && umart.get(UMART_CODART) == codart)  
        nriga = umart.get_int(UMART_NRIGA) + 1;
      
      umart.zero();                       //..la aggiunge come ultima unita' di misura.
      umart.put(UMART_CODART, codart);
      umart.put(UMART_NRIGA, nriga);
      umart.put(UMART_UM, um);
      umart.put(UMART_FC, 1);
      
      umart.write();
    }
  }  
}

//scrive i valori dei listini (prezzi e date)
void TCat2dl_file::write_listini(const TRecord_text& rec)
{
  real prz_ingr = rec.get(11); //legge il prezzo listino ingrosso
  prz_ingr /=100;
  if (prz_ingr != ZERO)          //tutto il casino lo fa solo se il prezzo non e' nullo
  {
    TLocalisamfile condv(LF_CONDV);
    condv.put(CONDV_TIPO, 'L');
    TConfig config("cat2dl.ini","PARAMS");
    TString4 listingr = config.get("LISTINGR");
    condv.put(CONDV_COD, listingr);
    int err = condv.read();
    if (err != NOERR) //se il listino indicato nell'ini non esiste..
    {
      condv.zero();   //..se lo crea!
      condv.put(CONDV_TIPO, 'L');
      condv.put(CONDV_COD, listingr);
      condv.write();
    }

    TLocalisamfile rcondv(LF_RCONDV);     //adesso che sa che il listino esiste andiamo in rcondv
    rcondv.put(RCONDV_TIPO, 'L');
    rcondv.put(RCONDV_COD, listingr);
    rcondv.put(RCONDV_TIPORIGA, 'A');             //uguale anche x le righe listino (come sopra)
    rcondv.put(RCONDV_CODRIGA, rec.get(2));
    rcondv.put(RCONDV_PREZZO, prz_ingr);
    rcondv.write();    
  }
  
  real prz_vend = rec.get(15); //legge il prezzo listino vendite e fa lo stesso procedimento del caso precedente
  prz_vend /=100;
  if (prz_vend != ZERO)
  {
    TLocalisamfile condv(LF_CONDV);
    condv.put(CONDV_TIPO, 'L');
    TConfig config("cat2dl.ini","PARAMS");
    TString4 listvend = config.get("LISTVEND");
    condv.put(CONDV_COD, listvend);
    int err = condv.read();
    if (err != NOERR)
    {
      condv.zero();
      condv.put(CONDV_TIPO, 'L');
      condv.put(CONDV_COD, listvend);
      condv.write();
    }

    TLocalisamfile rcondv(LF_RCONDV);
    rcondv.put(RCONDV_TIPO, 'L');
    rcondv.put(RCONDV_COD, listvend);
    rcondv.put(RCONDV_TIPORIGA, 'A');
    rcondv.put(RCONDV_CODRIGA, rec.get(2));
    rcondv.put(RCONDV_PREZZO, prz_vend);
    rcondv.write();    
  } 
}

//scrive i valori delle offerte (prezzi e date)
void TCat2dl_file::write_offerte(const TRecord_text& rec)
{
  real prz_ingr = rec.get(14); //legge il prezzo offerta ingrosso
  prz_ingr /=100;
  if (prz_ingr != ZERO)          //tutto il casino lo fa solo se il prezzo non e' nullo
  {
    TLocalisamfile condv(LF_CONDV);
    condv.put(CONDV_TIPO, 'O');
    TConfig config("cat2dl.ini","PARAMS");
    TString4 offeingr = config.get("OFFEINGR");
    condv.put(CONDV_COD, offeingr);
    int err = condv.read();
    if (err != NOERR) //se l'offerta indicata nell'ini non esiste..
    {
      condv.zero();   //..se la crea!
      condv.put(CONDV_TIPO, 'O');
      condv.put(CONDV_COD, offeingr);
      TDate dataini = rec.get(12);
      TDate datafine = rec.get(13);
      condv.put(CONDV_VALIN, dataini);
      condv.put(CONDV_VALFIN, datafine);
      condv.write();
    }

    TLocalisamfile rcondv(LF_RCONDV);     //adesso che sa che l'offerta esiste andiamo in rcondv
    rcondv.put(RCONDV_TIPO, 'O');
    rcondv.put(RCONDV_COD, offeingr);
    rcondv.put(RCONDV_TIPORIGA, 'A');             
    rcondv.put(RCONDV_CODRIGA, rec.get(2));
    rcondv.put(RCONDV_PREZZO, prz_ingr);
    rcondv.write();    
  }
  
  real prz_vend = rec.get(18); //legge il prezzo offerta ingrosso
  prz_vend /=100;
  if (prz_vend != ZERO)          //tutto il casino lo fa solo se il prezzo non e' nullo
  {
    TLocalisamfile condv(LF_CONDV);
    condv.put(CONDV_TIPO, 'O');
    TConfig config("cat2dl.ini","PARAMS");
    TString4 offevend = config.get("OFFEVEND");
    condv.put(CONDV_COD, offevend);
    int err = condv.read();
    if (err != NOERR) //se l'offerta indicata nell'ini non esiste..
    {
      condv.zero();   //..se la crea!
      condv.put(CONDV_TIPO, 'O');
      condv.put(CONDV_COD, offevend);
      TDate dataini = rec.get(16);
      TDate datafine = rec.get(17);
      condv.put(CONDV_VALIN, dataini);
      condv.put(CONDV_VALFIN, datafine);
      condv.write();
    }

    TLocalisamfile rcondv(LF_RCONDV);     //adesso che sa che l'offerta esiste andiamo in rcondv
    rcondv.put(RCONDV_TIPO, 'O');
    rcondv.put(RCONDV_COD, offevend);
    rcondv.put(RCONDV_TIPORIGA, 'A');             
    rcondv.put(RCONDV_CODRIGA, rec.get(2));
    rcondv.put(RCONDV_PREZZO, prz_vend);
    rcondv.write();    
  }
}

/////////////////////////////////////////////////////
// Classe TCat2dl: applicazione principale        //
/////////////////////////////////////////////////////

class TCat2dl: public TSkeleton_application
{
  TMask*          _msk;
  TCat2dl_file*  _trasfile;
  TString        _listingr, _listvend, _offeingr, _offevend;
  
protected:
  virtual bool create(void);
  virtual void main_loop();
  virtual bool destroy(void);
  void transfer(void);
  void inizializza_file(void);
  static bool annulla_handler(TMask_field& f, KEY k);

public:
  const TMask& msk() const { return *_msk; }
  TCat2dl() {}
  virtual ~TCat2dl() {}
};

// restituisce un riferimento all' applicazione
inline TCat2dl& app() { return (TCat2dl&) main_app();}

// creazione dell'applicazione
bool TCat2dl::create()
{                        
  open_files(LF_ANAMAG, LF_UMART, LF_CONDV, LF_RCONDV, 0);
  _msk = new TMask("dl0800a");
  _msk->set(F_FILENAME,DLFILENAME);
  _trasfile = NULL;
  TConfig config("cat2dl.ini","PARAMS");
  _listingr = config.get("LISTINGR");
  _listvend = config.get("LISTVEND");
  _offeingr = config.get("OFFEINGR");
  _offevend = config.get("OFFEVEND");

  return TSkeleton_application::create();
}

// distruzione dell'applicazione
bool TCat2dl::destroy()
{
  delete _msk;
  return TSkeleton_application::destroy();
}

// carica la maschera 
void TCat2dl::main_loop()
{ 
  // Preimposta gli eventuali valori specificati sulla riga di comando            
  //error_box("Attenzione: manca la configurazione del trasferimento!");
  KEY key = K_ENTER;
  while (key != K_QUIT)
  {
    key = _msk->run();
    if (key == K_ENTER)
      transfer();
  } 
}


// trasferimento dati da file su archivi
void TCat2dl::transfer()
{
  TFilename catdlini = "cat2dl.ini";
  
  _trasfile = new TCat2dl_file(_msk->get(F_FILENAME), catdlini);
  inizializza_file();
  const long dimension = fsize(_msk->get(F_FILENAME));
  TProgind pi(dimension,"Acquisizione in corso...");

  TRelation rel(LF_ANAMAG);
  TRectype& record = rel.curr();          //record corrente della relazione
  
  TString str;  // Stringa jolly di lavoro
  TRecord_text curr;
  while (_trasfile->read(curr) == NOERR) 
  { 
    pi.setstatus(_trasfile->read_file()->tellg());
    
    // read del file dell'ANAMAG
    str = curr.get(2);          //legge il codart
    rel.curr().put(ANAMAG_CODART, str);
    int err = rel.read();
    
    if (err != NOERR)
    {
      rel.curr().zero();
      rel.curr().put(ANAMAG_CODART, str);
    }     
    _trasfile->autosave(rel, curr); //esegue l'effettivo passaggio dati basandosi sulla formattazione del file .ini
    
  }
  _trasfile->close();
  message_box("Operazione terminata");
}


//inizializza il file di testo su cui emettere i dati
void TCat2dl::inizializza_file()
{
  TFilename filect = _msk->get(F_FILENAME); //aggiungere lettura automatica nomi file
  _trasfile->open(filect,'r');
}


// handler per gestire la conferma dell'annullamento dei dati inseriti
// nella maschera
bool TCat2dl::annulla_handler(TMask_field& f, KEY k)
{
  TMask &m = f.mask();
  if (k == K_SPACE)
  {
    if (yesno_box("Vuoi veramente annullare i dati inseriti"))
       m.reset();
  }
  return TRUE;
}

// gestione dei messaggi estesi nei campi
void TCat2dl_file::validate(TCursor& cur,TRecord_text &rec, TToken_string &s, TString& str)
{
  const TString code(s.get(0));
  TString valore;
  if (code == "_UPPERCASE")
  {
    valore.upper(); 
  }
  else NFCHECK("Macro non definita: %s", (const char *)code);
  str = valore;
} 

int dl0800(int argc, char* argv[])
{
  TCat2dl a ;
  a.run(argc, argv, "Importazione catalogo");
  return 0;
}