#include <applicat.h>
#include <mask.h>
#include <progind.h>

#include "velib04.h" 
#include "ve6200a.h"

#include <doc.h> 

///////////////////////////////////////////////////////////
// Lista Cliente/Fornitore per vendite
///////////////////////////////////////////////////////////

class TLista_clifo : public TObject
{                
  class TClifo : public TObject
  { 
    long _codice;
    long _agente;
    long _zona;
    
  protected:
    void zero() { _codice = _agente = _zona = 0L; }  
    void init(const TRectype& rec, const TRectype& ven); 
    bool read(char tipo, long cod);
  
  public: // TObject
    virtual bool ok() const { return _codice > 0; }
  
  public:     
    long codice() const { return _codice; }
    long agente() const { return _agente; }
    long zona() const { return _zona; }
  
    TClifo() { zero(); }
    TClifo(char tipo, long cod) { read(tipo, cod); }
    TClifo(const TRectype& rec, const TRectype& ven) { init(rec, ven); }
    TClifo(const TRectype& rec);
    virtual ~TClifo() { }
  };

  TArray _clifo;
  
protected:  
  virtual char tipo() const pure;
  const TClifo& clifo(int n) const { return (TClifo&)_clifo[n]; }
  
  static int sort_by_code(const TObject** o1, const TObject** o2);
  static int sort_by_agent(const TObject** o1, const TObject** o2);
  static int sort_by_zone(const TObject** o1, const TObject** o2);

public:
  int ordina_per_codice();
  int ordina_per_agente();
  int ordina_per_zona();
  
  int leggi(long dc, long ac, long da = 0, long aa = 0, const char * dz = "", const char * az = "");
  
  long operator[] (int n) const { return clifo(n).codice(); }
  int items() const { return _clifo.items(); }
  int find(long cod) const;
  int add(long cod);

  TLista_clifo() { }
  virtual ~TLista_clifo() { }
};

class TLista_clienti : public TLista_clifo 
{
protected:
  virtual char tipo() const { return 'C'; }
};

class TLista_fornitori : public TLista_clifo 
{
protected:
  virtual char tipo() const { return 'F'; }
};

class TLista_cf : public TLista_clifo 
{              
  char _tipo;
  
protected:
  virtual char tipo() const { return _tipo; }
  
public:
  TLista_cf(char tipo) { _tipo = tipo;}
};                                                  

void TLista_clifo::TClifo::init(const TRectype& rec, const TRectype& ven)
{                              
  _codice = rec.get_long(CLI_CODCF);
  CHECK(_codice > 0, "Codice cliente nullo");

  if (!ven.empty())
  {
    _agente = ven.get_long(CLI_CODAG);
    _zona   = ven.get_long(CLI_CODZONA);
  }
  else
    _agente = _zona = 0;
}

bool TLista_clifo::TClifo::read(char tipo, long cod)
{
  TRelation clifo(LF_CLIFO);
  clifo.add(LF_CFVEN, "TIPOCF=TIPOCF|CODCF=CODCF");
  
  TRectype& curr = clifo.curr();
  curr.put(CLI_TIPOCF, tipo);
  curr.put(CLI_CODCF, cod);
  if (clifo.read() == NOERR)
    init(curr, clifo.curr(LF_CFVEN));
  else
    zero();  
  
  return ok();  
}

TLista_clifo::TClifo::TClifo(const TRectype& rec)
{
  CHECK(rec.num() == LF_CLIFO, "Record non clienti");
  const char tipo = rec.get_char(CLI_TIPOCF);
  const long codice = rec.get_long(CLI_CODCF);
  read(tipo, codice);
}

int TLista_clifo::leggi(long dc, long ac, long da, long aa, const char * dz, const char * az)
{
  TRelation clifo(LF_CLIFO);
  clifo.add(LF_CFVEN, "TIPOCF==TIPOCF|CODCF==CODCF");
  
  TRectype start(LF_CLIFO), stop(LF_CLIFO);
  
  start.put(CLI_TIPOCF, tipo()); 
  if (dc > 0) 
    start.put(CLI_CODCF, dc); 

  stop.put(CLI_TIPOCF, tipo()); 
  if (ac > 0) 
    stop.put(CLI_CODCF, ac);
  
  TString filter(32);
  if (da > 0) 
    filter << '(' << LF_CFVEN << "->" << CLI_CODAG << ">=" << da << ')';
  if (aa > 0) 
  {
    if (filter.not_empty()) filter << "&&";
    filter << '(' << LF_CFVEN << "->" << CLI_CODAG << "<=" << aa << ')';
  }
  if (dz && (*dz !='\0'))
  {
    if (filter.not_empty()) filter << "&&";
    filter << '(' << LF_CFVEN << "->" << CLI_CODZONA << ">=\"" << dz << "\")";
  }  
  if (az && (*az !='\0'))
  {
    if (filter.not_empty()) filter << "&&";
    filter << '(' << LF_CFVEN << "->" << CLI_CODZONA << "<=\"" << az << "\")";
  }  
  
  TCursor cur(&clifo, "", 1, &start, &stop);
  if (filter.not_empty())
    cur.setfilter(filter, TRUE);
  const TRectype& cli = cur.curr();
  const TRectype& ven = cur.curr(LF_CFVEN);
  for (cur = 0; cur.ok(); ++cur)
  {
    TClifo* c = new TClifo(cli, ven);
    _clifo.add(c);
  }
  
  if (dc > 0 || ac > 0) 
    ordina_per_codice();
  else
    if (da > 0 || aa > 0) 
      ordina_per_agente();
    else
      if ((dz && (*dz !='\0')) || (az && (*dz !='\0'))) 
        ordina_per_zona();
  
  return _clifo.items();
}

int TLista_clifo::sort_by_code(const TObject** o1, const TObject** o2)
{
  TLista_clifo::TClifo* c1 = (TLista_clifo::TClifo*)*o1;
  TLista_clifo::TClifo* c2 = (TLista_clifo::TClifo*)*o2;
  const long d = c1->codice() - c2->codice();
  return d == 0L ? 0 : (d > 0 ? +1 : -1);
}

int TLista_clifo::sort_by_agent(const TObject** o1, const TObject** o2)
{
  TLista_clifo::TClifo* c1 = (TLista_clifo::TClifo*)*o1;
  TLista_clifo::TClifo* c2 = (TLista_clifo::TClifo*)*o2;
  const long d = c1->agente() - c2->agente();
  return d == 0L ? 0 : (d > 0 ? +1 : -1);
}

int TLista_clifo::sort_by_zone(const TObject** o1, const TObject** o2)
{
  TLista_clifo::TClifo* c1 = (TLista_clifo::TClifo*)*o1;
  TLista_clifo::TClifo* c2 = (TLista_clifo::TClifo*)*o2;
  const long d = c1->zona() - c2->zona();
  return d == 0L ? 0 : (d > 0 ? +1 : -1);
}

int TLista_clifo::ordina_per_codice()
{
  _clifo.sort(sort_by_code);
  return _clifo.items();
}

int TLista_clifo::ordina_per_agente()
{
  _clifo.sort(sort_by_agent);
  return _clifo.items();
}

int TLista_clifo::ordina_per_zona()
{
  _clifo.sort(sort_by_zone);
  return _clifo.items();
}

int TLista_clifo::find(long cod) const
{
	int i;
	
  for (i = items()-1; i >= 0; i--)
    if (clifo(i).codice() == cod) break;
  return i;  
}

int TLista_clifo::add(long cod)
{
  int pos = find(cod);
  if (pos < 0)
  {
    TClifo* c = new TClifo(tipo(), cod);
    pos = _clifo.add(c);
  }
  return pos;
}

///////////////////////////////////////////////////////////
// TFatturazione_bolle_app
///////////////////////////////////////////////////////////

class TFatturazione_bolle_app : public TSkeleton_application
{ 
  TString4 _default_selection;

protected:
  virtual bool create();
  virtual void main_loop();
  
  bool process(TIndwin& iw, TFatturazione_bolle& eld, TLista_documenti& din, const TDate& data_elab);
  void process_by_cli(const TMask& m);
  void process_by_doc(const TMask& m);
};

bool TFatturazione_bolle_app::create()
{
  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, LF_CAUSALI, 0);
                                            
  TConfig cfg(CONFIG_DITTA, "ve");
  _default_selection = cfg.get("FATBOLSEL");
             
  return TSkeleton_application::create();
}

bool TFatturazione_bolle_app::process(TIndwin& iw, TFatturazione_bolle& eld, 
                                      TLista_documenti& din, const TDate& data_elab)
{
  // Crea documenti di output
  TLista_documenti dout;
  bool ok = eld.elabora(din, dout, data_elab);
  if (ok) 
  {
    TString msg;
    msg << din.items() << " documenti raggruppati in " << dout.items(); 
    iw.set_text(msg);           // Messaggio sul cliente
    do_events();                // Attende visualizzazione

    int err = dout.write();     // Scrive documenti di output
    if (err == NOERR)
    {
      err = din.rewrite();      // Aggiorna stato dei documenti di input
      if (err != NOERR)
        ok = error_box("Errore %d durante la scrittura dei documenti raggruppati!", err);
    }
    else
      ok = error_box("Errore %d durante l'aggiornamento dei documenti da raggruppare!", err);
  }
  else
  {
    const long codcli = din[0].get_long(DOC_CODCF);
    ok = error_box("I documenti relativi al cliente %ld non sono stati elaborati.",
                   codcli);
  }  
  return ok;
}

void TFatturazione_bolle_app::process_by_cli(const TMask& m)
{
  TIndwin iw(0, "Inizializzazione ...\n ", TRUE, FALSE, 60);
  
  const TDate data_elab = m.get_date(F_DATA_ELAB); 
  const int anno = data_elab.year();
    
  const long dc = m.get_long(F_CODICE_CLIFO_DA);
  const long ac = m.get_long(F_CODICE_CLIFO_A);
  const int da = m.get_int(F_CODICE_AGENTE_DA);
  const int aa = m.get_int(F_CODICE_AGENTE_A);
  const TString16 dz(m.get(F_CODICE_ZONA_DA)); 
  const TString16 az(m.get(F_CODICE_ZONA_A));
    
  const TDate dd = m.get_date(F_DATA_DOCUMENTO_DA);
  TString st_da = m.get(F_DATA_DOCUMENTO_A); // qui verificare
  const TDate ad = st_da.not_empty() ? (TDate)(const char*)st_da : data_elab;
  const TString& codnum = m.get(F_CODICE_NUMERAZIONE);
  const long dn = m.get_long(F_NUMERO_DOCUMENTO_DA);
  const long an = m.get_long(F_NUMERO_DOCUMENTO_A);
    
  TFatturazione_bolle eld(m.get(F_CODICE_ELAB));
  TToken_string tipidoc(24), statidoc(10);
  eld.tipi_validi(tipidoc); 
  eld.stati_validi(statidoc);
      
  TTipo_documento t(eld.tipo_iniziale(0)); 
  char tipocf(t.tipocf());
  TLista_cf clienti(tipocf);
  const int tot_cli = clienti.leggi(dc, ac, da, aa, dz, az);
    
  TString msg(80);
  for (int c = 0; c < tot_cli && !iw.iscancelled(); c++)
  { 
    const long codcli = clienti[c];     // Codice cliente in esame
    msg = "Elaborazione dei documenti del cliente "; 
    msg << codcli << " ...";
    iw.set_text(msg);                   // Messaggio sul cliente
    do_events();                        // Attende visualizzazione
      
    TLista_documenti din;               // Legge tutti i documenti di input
    din.read('D', tipocf, codcli, anno, tipidoc, statidoc, dd, ad, codnum, dn, an);
    if (din.items() > 0 && !iw.iscancelled())
    {
      bool ok = process(iw, eld, din, data_elab);
      if (!ok) // In caso di errore termina qui l'elaborazione.   
        break;   
    }
  }
}

void TFatturazione_bolle_app::process_by_doc(const TMask& m)
{
  TIndwin iw(0, "Inizializzazione ...\n ", TRUE, FALSE, 60);

  const TDate data_elab = m.get_date(F_DATA_ELAB); 
  const int anno = data_elab.year();
  long dc = m.get_long(F_CODICE_CLIFO_DA);
  long ac = m.get_long(F_CODICE_CLIFO_A);   
  
  const int da = m.get_int(F_CODICE_AGENTE_DA);
  const int aa = m.get_int(F_CODICE_AGENTE_A);
  const TString8 dz(m.get(F_CODICE_ZONA_DA)); 
  const TString8 az(m.get(F_CODICE_ZONA_A));
    
  const TDate dd = m.get_date(F_DATA_DOCUMENTO_DA);
  TDate ad = m.get_date(F_DATA_DOCUMENTO_A);
  if (!ad.ok()) ad = data_elab;
  
  const TString& codnum = m.get(F_CODICE_NUMERAZIONE);
  const long dn = m.get_long(F_NUMERO_DOCUMENTO_DA);
  const long an = m.get_long(F_NUMERO_DOCUMENTO_A);

  TFatturazione_bolle eld(m.get(F_CODICE_ELAB));
  TToken_string tipidoc(24), statidoc(10);
  eld.tipi_validi(tipidoc); 
  eld.stati_validi(statidoc);

  TTipo_documento t(eld.tipo_iniziale(0));
  char tipocf(t.tipocf());
  TLista_cf clienti(tipocf);
  const int tot_cli = clienti.leggi(dc, ac);

  TString msg(80);
  for (int c = 0; c < tot_cli && !iw.iscancelled(); c++)
  { 
    const long codcli = clienti[c];     // Codice cliente in esame
    msg = "Elaborazione dei documenti del cliente "; 
    msg << codcli << " ...";
    iw.set_text(msg);                   // Messaggio sul cliente
    do_events();                        // Attende visualizzazione
    
    TLista_documenti din, dout;         // Legge tutti i documenti di input
    din.read('D', tipocf, codcli, anno, tipidoc, statidoc, dd, ad, codnum, dn, an);
    
    for (int i = din.items()-1; i >= 0; i--)
    {              
      const TDocumento& doc = din[i];        
      
      bool to_del = FALSE;
      const int agente = doc.get_int(DOC_CODAG);
      if (agente > 0)
      {
        if (da > 0 && agente < da) to_del = TRUE;
        if (aa > 0 && agente > aa) to_del = TRUE;
      }
      const TString8 zona = doc.get(DOC_ZONA);
      if (zona.not_empty())
      {
        if (dz.not_empty() && zona < dz) to_del = TRUE;
        if (az.not_empty() && zona > az) to_del = TRUE;
      }
      if (to_del)
        din.destroy(i);
    }
    if (din.items() > 0 && !iw.iscancelled())
    {
      bool ok = process(iw, eld, din, data_elab);
      if (!ok) // In caso di errore termina qui l'elaborazione.   
        break;   
    }
  }
}
 
void TFatturazione_bolle_app::main_loop()
{
  TMask m("ve6200a");
  m.set(F_SELEZIONE, _default_selection);
  
  while (m.run() == K_ENTER)
  {                              
    const TString& select_from = m.get(F_SELEZIONE);  
    if (select_from != _default_selection)
    {
      TConfig cfg(CONFIG_DITTA, "ve"); 
      cfg.set("FATBOLSEL", _default_selection = select_from);
    }
    if (select_from == "D")
      process_by_doc(m);
    else  
      process_by_cli(m);
  }
}

int ve6200 (int argc, char **argv)
{
  TFatturazione_bolle_app a;
  a.run (argc, argv, "Fatturazione Bolle");
  return TRUE;
}