#include <applicat.h>
#include <automask.h>
#include <execp.h>
#include <filetext.h>
#include <isamrpc.h>
#include <mask.h>
#include <relation.h>
#include <tabutil.h>
#include <printer.h>
#include <progind.h>
#include <recarray.h>
#include <utility.h>

#include <doc.h>
#include <rdoc.h>

#include "dl0.h"
#include "dl0900a.h"
#include "dlutils.h"


/////////////////////////////////////////////////////
// Classe TSend_order: maschera     //
/////////////////////////////////////////////////////
  
class TSend_ord_mask : public TAutomask
{
  TRelation * _rel;
  TCursor * _cur;

protected:
  bool on_field_event(TOperable_field& o, TField_event e, long jolly);
public:

  TSend_ord_mask();
  
  virtual ~TSend_ord_mask(){};
};
  
TSend_ord_mask::TSend_ord_mask() :TAutomask ("dl0900a")
{
}  
  
bool TSend_ord_mask::on_field_event(TOperable_field& o, TField_event e, long jolly)
{ 
/*  switch (o.dlg())
  {
  default:
    break;
  }  */
  return TRUE;
}

/////////////////////////////////////////////////////
// Classe TSend_order: applicazione principale     //
/////////////////////////////////////////////////////

class TSend_ord: public TSkeleton_application
{
  TMask*    _msk;
  TString   _coddl, _codindsped, _codord, _statoini, _statoend, 
            _address, _path, _user, _password, _lastorddate, _lastordsent;
  TFilename _filename;
  TArray _testatedoc;
  
protected:
  virtual bool create(void);
  virtual void main_loop();
  virtual bool destroy(void);
  
  void select_ord(void);
  bool send_ord(void);

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

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

// creazione dell'applicazione
bool TSend_ord::create()
{                        
  open_files(LF_DOC, LF_RIGHEDOC, 0);
  _msk = new TMask("dl0900a");
// file di configurazione (discolat.ini); vengono letti i dati ed inviati alla maschera  
  TConfig config("discolat.ini","SENDORD");
  _coddl = config.get("CODDL");
  _codindsped = config.get("CODINDSPED");
  _codord = config.get("CODORD");
  _statoini = config.get("STATOINI");
  _statoend = config.get("STATOEND");
  _lastorddate = config.get("LASTORDDATE");
  _lastordsent = config.get("LASTORDSENT");
  _address = config.get("ADDRESS");
  _path = config.get("PATH");
  _user = config.get("USER");
  _password = config.get("PASSWORD");
  _msk->set(F_CODCLI, _coddl);
  _msk->set(F_CODINDSPED, _codindsped);
  _msk->set(F_CODNUM, _codord);
  _msk->set(F_STATOINI, _statoini);
  _msk->set(F_STATOEND, _statoend);
  _msk->set(F_LASTORDDATE, _lastorddate);
  _msk->set(F_LASTORDSENT, _lastordsent);
  _msk->set(F_ORDINI, atol(_lastordsent)+1);
  _msk->set(F_ADDRESS, _address);
  _msk->set(F_PATH, _path);
  _msk->set(F_USER, _user);
  _msk->set(F_PASSWORD, _password);

  return TSkeleton_application::create();
}

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

// carica la maschera 
void TSend_ord::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)
    { 
      _coddl = _msk->get(F_CODCLI);
      _codindsped = _msk->get(F_CODINDSPED);
      _codord = _msk->get(F_CODNUM);
      _statoini = _msk->get(F_STATOINI);
      _statoend = _msk->get(F_STATOEND);
      _lastorddate = _msk->get(F_LASTORDDATE);
      _lastordsent = _msk->get(F_LASTORDSENT);
      _address = _msk->get(F_ADDRESS);
      _path = _msk->get(F_PATH);
      _user = _msk->get(F_USER);
      _password = _msk->get(F_PASSWORD);
      
      select_ord();      
      bool ok = send_ord();                          
       
      if (ok)
      {
        TConfig config("discolat.ini","SENDORD");
        config.set("CODDL", _coddl);
        config.set("CODINDSPED", _codindsped);
        config.set("CODORD", _codord);
        config.set("STATOINI", _statoini);
        config.set("STATOEND", _statoend);
        config.set("LASTORDDATE", _lastorddate);
        config.set("LASTORDSENT", _lastordsent);
        config.set("ADDRESS", _address);
        config.set("PATH", _path);
        config.set("USER", _user);
        config.set("PASSWORD", _password);
        //occhio ai campi disabilitati sulla maschera!
        _msk->set(F_LASTORDDATE, _lastorddate);
        _msk->set(F_LASTORDSENT, _lastordsent);
      }      
    }
  } 
}

// selezione ordini da mandare
void TSend_ord::select_ord()
{ 
// relazione sui DOC; seleziona quelli con datadoc inclusa in intervallo, codnum=_codord ecc.
  TRelation reldoc(LF_DOC);
  
  long ordini = _msk->get_long(F_ORDINI);
  long ordfine = _msk->get_long(F_ORDFINE);
  const int anno = _msk->get_int(F_ANNO);
  
  TRectype darec(LF_DOC), arec(LF_DOC);

  darec.put(DOC_PROVV, "D");
  darec.put(DOC_ANNO, anno);
  darec.put(DOC_CODNUM, _codord);
  darec.put(DOC_NDOC, ordini);

  arec.put(DOC_PROVV, "D");
  arec.put(DOC_ANNO, anno);
  arec.put(DOC_CODNUM, _codord);   
  if (ordfine >= ordini)
    arec.put(DOC_NDOC, ordfine);

  TString filtro = "STATO==\"";
  filtro<<_statoini<<"\"";
  
  TCursor cursore (&reldoc, filtro, 1, &darec, &arec);
  long nitems = cursore.items();                     
  cursore.freeze();
  
  TRectype riga(LF_RIGHEDOC);
  TRecord_array righedoc(LF_RIGHEDOC,RDOC_NRIGA);    //clamoroso recordarray del file 34 (righedoc)
  TProgind pi(nitems, "Generazione ordini in corso...", FALSE, TRUE);
  
  TString rigafile;
  
  _filename = _path;
  _filename.add(_coddl);
  _filename.ext("txt");
  ofstream out(_filename);                               
 
  
  for (cursore=0;cursore.pos()<nitems;++cursore)
  {  
    pi.addstatus(1);
    const long ndoc = cursore.curr().get_long(DOC_NDOC);
    const TDate datadoc = cursore.curr().get_date(DOC_DATADOC);
    
    _testatedoc.add(cursore.curr());
    
    //per ogni documento in testata (con chiave 1)...    
    riga.put(RDOC_CODNUM, _codord);
    riga.put(RDOC_ANNO, datadoc.year());
    riga.put(RDOC_PROVV, "D");
    riga.put(RDOC_NDOC, ndoc);  

    //...scandisce tutte le sue righemov    
    righedoc.read(riga); 

    //aggiunge il file con nome _coddl+datadoc+ndoc al TStringarray con i nomi dei files
    for (int i=1; i<=righedoc.rows(); i++)
    {
      const TRectype& rigai = righedoc[i];
      const TString80 codart = rigai.get(RDOC_CODARTMAG);
      const long qta = rigai.get_long(RDOC_QTA);
  
      rigafile.format("%-6s%-4s%10s%7ld%3d%-20s%8ld%23s",
      (const char *)_coddl, (const char *)_codindsped,(const char *)datadoc.string(),ndoc,i,(const char *)codart,qta,"");  
      out << rigafile;       
    }
    
    //aggiorna il valore dell'ultimo ordine creato
    _lastorddate = datadoc;
    _lastordsent.format("%ld",ndoc);
  }
       
}

// trasferimento files ordini
bool TSend_ord::send_ord()
{ 
// crea un file txt contenente i comandi per l'invio ftp
/*  TFilename ftpsend = _path; ftpsend.add("ftps.txt");
  ofstream out(ftpsend);
  out << "USER " << _user << " " << _password << endl;
  
  for (int i = 0; i < _listafiles.items(); i++)   
    out << "PUT " << _path << "/" << i << " " << _listafiles.row(i) << endl;
    
  out << "QUIT" << endl; 
  out.close();
//crea un file .bat per eseguire i comandi ftp contenuti nel file di testo  
  TFilename ftpbat = _path; ftpbat.add("ftps.bat");
  ofstream outbat(ftpbat);
  outbat << "FTP -n " << _address << " < " << ftpsend;
  outbat.close();
//stringa magica che permette l'esecuzione dei comandi ftp lanciando e chiudendo la shell dos
//COMSPEC e' la variabile d'ambiente che contiene l'indirizzo del command.com
// /c significa 'chiudi la shell dopo l'esecuzione del comando!'  
  TString cmd;  
  cmd << getenv("COMSPEC") << " /c " << ftpbat;
  TExternal_app app(cmd);
  app.run(TRUE, FALSE, FALSE, FALSE);  */
  
  TString site, service, authorization;
  split_url(_address, site, service);
  cifratura_laziale(_user, _password, authorization);
                                                                             
  byte* answer = NULL;
  size_t length = 0;
  bool ok = http_post(site, service, _filename, authorization, answer, length);
  
  if (ok)
  {
    message_box("Esito della transazione:\n%s", answer);
    //se la transazione è andata a buon fine cambia stato ai documenti inviati
    if (answer[0] == 'O' && answer[1] == 'K')
    { 
      TLocalisamfile docfile(LF_DOC);
      for (int i = _testatedoc.last(); i>=0; i--)
      {
        TRectype& doc = (TRectype&) _testatedoc[i];
        doc.put(DOC_STATO, _statoend);
        doc.rewrite(docfile);
      }
    }
  }
  
  return ok;
}

int dl0900(int argc, char* argv[])
{
  TSend_ord a ;
  a.run(argc, argv, "Invio ordini");
  return 0;
}