#include <currency.h>
#include <msksheet.h>
#include <recarray.h>
#include <relapp.h>
#include <sheet.h>
#include <utility.h>

#include "../ve/velib.h"

#include "ef0.h"
#include "ef0100.h"
#include "ef0101.h"

#include <comuni.h>  
#include <doc.h>

///////////////////////////////////////////////////////////////
// Classe per la gestione di effetti con metodi standard di: //
// inserimento, modifica, cancellazione.                     //
///////////////////////////////////////////////////////////////

class TVariazione_effetti: public TRelation_application
{
  TMask *_msk;
  TEffetto *_effetto;
  TRelation *_rel;

protected:
  virtual void init_query_mode(TMask&);
  virtual void init_insert_mode(TMask&);
  virtual bool get_next_key(TToken_string& key);
  virtual void init_modify_mode(TMask&);
  static bool clifo_handler(TMask_field& f, KEY k);
  static bool datascad_handler(TMask_field& f, KEY k);
  static bool handle_sheet(TMask_field& f, KEY);
  static bool cambio_handler(TMask_field& f, KEY k);
  static bool codval_handler(TMask_field& f, KEY k);
  static bool contab_handler(TMask_field& f, KEY k);
  static bool fatt_handler(TMask_field& f, KEY k);
  static bool impeff_notify(TSheet_field& s, int r, KEY key);
  TSheet_field& cess_sheet() const;
  TSheet_field& righe_sheet() const;
  void common_f(const TMask& m);
  static void calcola_totali();
  virtual int read(TMask& m);
  virtual int rewrite(const TMask& m);
  virtual int write(const TMask& m);
  virtual bool remove();
  bool user_create();
  bool user_destroy();
  virtual TMask* get_mask(int mode) {return _msk;}
  virtual bool changing_mask(int mode) {return FALSE;}
  void enable_controeuro();
  
public:
  virtual bool protected_record(TRectype&);
  virtual TRelation* get_relation() const {return _rel;}
  TVariazione_effetti() {};
  virtual ~TVariazione_effetti() {};
};

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

void TVariazione_effetti::enable_controeuro()
{
  static int ce = -1;
  if (ce < 0)
  {
    TConfig ini(CONFIG_DITTA, "ve");
    ce = ini.get_bool("CONTROEURO");
  }
  _msk->enable(F_CONTROEURO, ce != 0);
}

// quando si va in query mode resetta i due campi della maschera
// relativi ai totali
void TVariazione_effetti::init_query_mode(TMask&)
{
  _msk->reset(F_TOTIMP);
  _msk->reset(F_TOTIMPVAL);    
  _msk->enable(F_TIPOCF);
  enable_controeuro();
}

bool TVariazione_effetti::protected_record(TRectype& rec)
{
	return rec.get("TIPODIST").not_empty() || rec.get("NDIST").not_empty() || rec.get("NRIGADIST").not_empty();
}

// quando si va in insert mode resetta i due campi della maschera relativi
// ai totali, inserisce una riga vuota nello sheet e setta il flag dirty
// dello sheet per forzare l'utente all'inserimento di una riga
void TVariazione_effetti::init_insert_mode(TMask&)
{
  _msk->reset(F_TOTIMP);
  _msk->reset(F_TOTIMPVAL);
  TToken_string riga("|||||||||");
  righe_sheet().row(0) = riga;
  righe_sheet().set_dirty();
  _msk->enable(F_TIPOCF);
  enable_controeuro();
}

void TVariazione_effetti::init_modify_mode(TMask& m)
{
  m.disable(F_TIPOCF);
  enable_controeuro();
  m.efield(F_IBAN_STATO).validate(K_TAB);
}

// ritorna il prossimo numero valido di chiave
bool TVariazione_effetti::get_next_key(TToken_string& key)
{
  TLocalisamfile& effetti = _rel->lfile();
  long nprogtr = 1L;
  if ( !effetti.empty() )
  {
    effetti.zero();
    effetti.setkey(1);
    effetti.last();
    if ( effetti.good() )
      nprogtr += effetti.get_long(EFF_NPROGTR);
  }
  key.format("%d|%ld",F_NPROGTR,nprogtr);
  return TRUE;
}

// ritorna un riferimento allo sheet dei cessionari
TSheet_field& TVariazione_effetti::cess_sheet() const
{
  return _msk->sfield(F_SHEET_EFF);
}

// ritorna un riferimento allo sheet delle righe
TSheet_field& TVariazione_effetti::righe_sheet() const
{
  return _msk->sfield(F_SHEET_RIGHE);
}

// metodo che permette di scivere su file i dati inseriti nella maschera;
// comune alla write e alla rewrite
void TVariazione_effetti::common_f(const TMask& m)
{
  const long nprogtr = m.get_long(F_NPROGTR);
  m.autosave(*_rel);
  _effetto->head() = _rel->curr();
  TSheet_field& shcess = cess_sheet();
  TSheet_field& shrighe = righe_sheet();
  int items = shcess.items();
  _effetto->destroy_rows_c();
  int ii = 1;
  // scarico tutte le righe dei cessionari dallo sheet sul file
  for (int i = 0; i < items; i++)
  {
    TToken_string& row = shcess.row(i);
    if ( row.items()== 0 ) continue; // salta le righe vuote
    TRectype& rec = _effetto->row_c(ii, TRUE);
    row.restart();
    rec.zero();
    rec.put(CES_NPROGTR, nprogtr);
    rec.put(CES_NRIGA, ii);
    rec.put(CES_RAGSOC, row.get());
    rec.put(CES_LOCALITA, row.get());
    rec.put(CES_STATO, row.get_int());
    rec.put(CES_COM, row.get());
    ii++;
  }
  items = shrighe.items();
  _effetto->destroy_rows_r();
  ii = 1;
  // scarico tutte le righe dell'effetto dallo sheet sul file
  for (i = 0; i < items; i++)
  {
    TToken_string& row = shrighe.row(i);
    real imp_eff(row.get(shrighe.cid2index(F_IMPEFF)));
    if (imp_eff == 0.0) continue; // salta le righe con importo nullo
    row.restart();
    TRectype& rec = _effetto->row_r(ii, TRUE);
    rec.zero();           
    rec.put(REFF_NPROGTR, nprogtr);
    rec.put(REFF_NRIGATR, ii);
    rec.put(REFF_IMPORTO, row.get());
    rec.put(REFF_IMPORTOVAL, row.get());
    rec.put(REFF_CODNUM, row.get());
    rec.put(REFF_PROVV, row.get()[0]);
    rec.put(REFF_ANNODOC, row.get_int());
    rec.put(REFF_NFATT, row.get());
    rec.put(REFF_DATAFATT, row.get());
    rec.put(REFF_IMPFATT, row.get());
    rec.put(REFF_IMPFATTVAL, row.get());
    rec.put(REFF_ANNO, row.get_int());
    rec.put(REFF_NUMPART, row.get());
    rec.put(REFF_NRIGA, row.get_int());
    rec.put(REFF_NRATA, row.get_int());
    ii++;
  }
  _effetto->renum(_effetto->numero());
}

// carica nella maschera i dati dai files
int TVariazione_effetti::read(TMask& m)
{
  m.autoload(*_rel);
  int err = _rel->status();
  if (err == NOERR)
  {
    TLocalisamfile& f = _rel->lfile(LF_EFFETTI);
    // legge l'effetto dal record corrente della relazione
    err = _effetto->read(f, _rel->curr());
    if (err == NOERR)
    {
      TString16 codcom(3);
      TToken_string riga(80);
      TSheet_field& shcess = cess_sheet();
      shcess.reset();
      TSheet_field& shrighe = righe_sheet();
      shrighe.reset();
      int items = _effetto->rows_c();
      // carica tutti i cessionari nello sheet dal file
      for (int i = 1; i <= items; i++)
      {
        const TRectype& rec = _effetto->row_c(i);
        riga.cut(0);
        riga.add(rec.get(CES_RAGSOC));
        riga.add(rec.get(CES_LOCALITA));
        // per caricare nello sheet dei cessionari la denominazione
        // del comune di cui si conosce il codice
        codcom = rec.get(CES_STATO);
        codcom << '|' << rec.get(CES_COM);
        riga.add(codcom);
        
        const TRectype& com = cache().get(LF_COMUNI, codcom);
        riga.add(com.get(COM_DENCOM));

        shcess.row(i-1)=riga;
      }
      items = _effetto->rows_r();
      // carica tutte le righe dell'effetto nello sheet dal file
//      TEdit_field & e = (TEdit_field &) shrighe.sheet_mask().field(F_NUMFATT); 
//      CheckType c = e.check_type();
                                 
//      e.check_type(CHECK_REQUIRED);                             
      for (i = 1; i <= items; i++)
      {
        const TRectype& rec = _effetto->row_r(i);
        riga.cut(0);
        riga.add(rec.get(REFF_IMPORTO));
        riga.add(rec.get(REFF_IMPORTOVAL));
        riga.add(rec.get(REFF_CODNUM));
        riga.add(rec.get(REFF_PROVV));
        riga.add(rec.get(REFF_ANNODOC));
        riga.add(rec.get(REFF_NFATT));
        riga.add(rec.get(REFF_DATAFATT));
        riga.add(rec.get(REFF_IMPFATT));
        riga.add(rec.get(REFF_IMPFATTVAL));
        riga.add(rec.get(REFF_ANNO));
        riga.add(rec.get(REFF_NUMPART));
        riga.add(rec.get(REFF_NRIGA));
        riga.add(rec.get(REFF_NRATA));
        shrighe.row(i - 1) = riga;   
        shrighe.check_row(i - 1);
      }
//      e.check_type(c);                             
    }
  }
  return err;
}

// riscrive effetto
int TVariazione_effetti::rewrite(const TMask& m)
{
  common_f(m);// scarica i dati dalla maschera
  TLocalisamfile& f = _rel->lfile(LF_EFFETTI);
  return _effetto->rewrite(f);
}

// scrive i dati su file
int TVariazione_effetti::write(const TMask& m)
{
  common_f(m);// scarica i dati dalla maschera
  TLocalisamfile& f = _rel->lfile(LF_EFFETTI);
  int err = _effetto->write(f);
  if (err == NOERR)
    _rel->read();// rilegge per posizionare correttamente la relazione
  return err;
}

// rimuove l'effetto
bool TVariazione_effetti::remove()
{
  TLocalisamfile& f = _rel->lfile(LF_EFFETTI);
  int err = _effetto->remove(f);
  return err == NOERR;
}

// crea la relap
bool TVariazione_effetti::user_create()
{ 
  open_files(LF_TAB, LF_TABCOM, LF_EFFETTI, LF_REFFETTI, LF_CESS,
             LF_COMUNI, LF_DOC, LF_RIGHEDOC, 
             LF_CLIFO, LF_CFVEN, LF_OCCAS, 0);
  _rel = new TRelation(LF_EFFETTI);
  _effetto = new TEffetto;
  _msk = new TMask("ef0100a") ;
  _msk->set_handler(F_CODCF, clifo_handler);
  _msk->set_handler(F_DATASCAD, datascad_handler);
  _msk->set_handler(F_CODVAL, codval_handler);
  _msk->set_handler(F_CAMBIO, cambio_handler);
  _msk->set_handler(F_EFFCONT, contab_handler);
  _msk->set_handler(F_SHEET_RIGHE, handle_sheet);
  righe_sheet().set_append(TRUE);
  righe_sheet().set_notify(impeff_notify);
  _msk->sfield(F_SHEET_RIGHE).sheet_mask().set_handler(F_NUMFATT, fatt_handler);
  return TRUE;
}

// distrugge la relap
bool TVariazione_effetti::user_destroy()
{
  delete _msk;
  delete _effetto;
  delete _rel;
  return TRUE;
}

// handler che permette di effettuare il controllo sul fatto
// che venga inserita almeno una riga per un effetto
bool TVariazione_effetti::handle_sheet(TMask_field &f, KEY k)
{
  TMask& m = f.mask();
  const int mode = m.mode();
  // se si vuole salvare e si è in uno dei due modi di funzionamento
  if ( k == K_ENTER && (mode == MODE_INS || mode == MODE_MOD) )
  { // si controllano le righe del effetto nello sheet
    TSheet_field& sf = m.sfield(F_SHEET_RIGHE);
    int items = sf.items();
    bool found = FALSE;
    for (int i = 0; i < items && !found; i++)// scandisco tutte le righe dello sheet
    {
      TToken_string& row = sf.row(i);
      real imp_eff(row.get(sf.cid2index(F_IMPEFF)));
      // controlla che le righe abbiano un importo
      if (imp_eff != 0.0) found = TRUE;
    }
    // se non ha trovato righe nello sheet oppure se quelle che ci sono non
    // hanno importo
    if (!found)
    { // non permetto di salvare l'effetto
      error_box(TR("L'effetto non può contenere righe con importo nullo!"));
      return FALSE;
    }
  }
  return TRUE;
}

bool TVariazione_effetti::clifo_handler(TMask_field& f, KEY k)
{
  if (k == K_TAB && f.to_check(k))
  {
    TMask& m = f.mask();
    TString8 str; 
    str << m.get(F_TIPOCF) << '|' << m.get(F_CODCF);
    const TString& iban = cache().get(LF_CFVEN, str, "IBAN");
    if (iban.not_empty())
    {
      m.set(F_IBAN, iban);
      m.set(F_IBAN_STATO, iban.left(2));
      m.set(F_IBAN_CHECK, iban.mid(2,2));
      m.set(F_BBAN,       iban.mid(4));
      m.set(F_BBAN_CIN,   iban.mid(4,1));
      m.set(F_BBAN_ABI,   iban.mid(5,5));
      m.set(F_BBAN_CAB,   iban.mid(10,5));
      m.set(F_BBAN_CONTO, iban.mid(15));
      m.efield(F_IBAN_STATO).validate(K_TAB);
    }
  }
  return true;
}

bool TVariazione_effetti::datascad_handler(TMask_field& f, KEY k)
{
  if (k == K_ENTER)
  {  
    const TDate datascad = f.get();
    TSheet_field& sf = f.mask().sfield(F_SHEET_RIGHE);
    FOR_EACH_SHEET_ROW(sf, r, row)
    {
      TDate datafat = row->get(F_DATAFATT-FIRST_FIELD);
      if (datascad < datafat)
        return f.error_box(FR("La data fattura della riga %d è successiva alla data di scadenza"), r+1);
    }    
  }
  return TRUE;
}

// handler che permette il controllo sulla abilitazione dei campi collegati
// al codice valuta
bool TVariazione_effetti::codval_handler(TMask_field& f, KEY k)
{
  if (f.to_check(k, TRUE))
  {
     TMask& m = f.mask();
     const TString& val = f.get();
      // se non c'e valuta o se è lire disabilitato i campi collegati
      const bool valuta = (val.not_empty() && val != TCurrency::get_firm_val());
      m.enable(-1,valuta);
      TSheet_field& sf = m.sfield(F_SHEET_RIGHE);
      if (!valuta)
      {
        m.reset(-1);
        m.reset(F_TOTIMPVAL);
        for (int i = sf.items() - 1; i >= 0; i--)
        {
          TToken_string& row = sf.row(i);
          row.add(" ", sf.cid2index(F_IMPEFFVAL));
          row.add(" ", sf.cid2index(F_IMPFATTVAL));
        }
      }
      sf.enable_column(F_IMPEFFVAL, valuta);
      if (f.focusdirty())
        sf.force_update();
  }
  return TRUE;
}

// handler che gestisce la modifica del cambio
bool TVariazione_effetti::cambio_handler(TMask_field& f, KEY k)
{
  TMask &m = f.mask();
  //if (k == K_TAB && f.to_check(k, TRUE))
  if (k == K_TAB && f.focusdirty())
  {
    const real cambio = f.get();
    const TString& valuta = m.get(F_CODVAL);
    TSheet_field& sf = m.sfield(F_SHEET_RIGHE);
    int items = sf.items();
    real imp, impval;
    // scandisco tutte le righe dello sheet e modifico gli importi in lire
    for (int i = 0; i < items; i++)
    {
      TToken_string& row = sf.row(i);  
      impval = row.get(sf.cid2index(F_IMPEFFVAL));
      TCurrency val(impval, valuta, cambio);
      val.change_to_firm_val();
      imp = val.get_num();
      row.add(imp.string(), sf.cid2index(F_IMPEFF));
    }
    if (f.focusdirty())
      sf.force_update();
  }
  return TRUE;
}

// handler che permette il controllo sulla abilitazione dei campi collegati
// al codice valuta
bool TVariazione_effetti::fatt_handler(TMask_field& f, KEY k)
{
  TMask &m = f.mask();            
  if (k == K_TAB && f.focusdirty() || !app().get_mask(MODE_MOD)->is_running())
  {                 
    TEdit_field & e = (TEdit_field &) f; 
    CheckType c = e.check_type();
                                 
    e.check_type(CHECK_REQUIRED);                             
    const bool ok = e.check();
    e.check_type(c);                             
    m.enable(F_DATAFATT, !ok);
    m.enable(F_IMPFATT, !ok);
    m.enable(F_IMPFATTVAL, !ok && app().get_mask(MODE_MOD)->get(F_CODVAL).not_empty());
    if (app().get_mask(MODE_MOD)->is_running() && ok && k == K_TAB && f.focusdirty())
    {                       
      const TDocumento d(e.browse()->cursor()->curr());
      m.set(F_DATAFATT, d.get("DATADOC"));
      const real imp = d.totale_doc();
      if (d.in_valuta())
      {                     
        const TString16 codval = d.get(DOC_CODVAL);
        TCurrency val(imp, codval, d.get_real(DOC_CAMBIO));
        val.change_to_firm_val();
        const real& lit = val.get_num();
        
        m.set(F_IMPFATT, lit);
        m.set(F_IMPFATTVAL, imp);
      }
      else
      {
        m.set(F_IMPFATT, imp);
        m.reset(F_IMPFATTVAL);
      }
    }
  }
  return TRUE;
}

bool TVariazione_effetti::contab_handler(TMask_field& f, KEY k)
{
  if (k == K_SPACE)
  {
    TMask &m = f.mask();
    const bool da_contab = f.get().empty();
    TSheet_field& sf = m.sfield(F_SHEET_RIGHE);
    sf.enable_column(F_ANNO, da_contab);
    sf.enable_column(F_NUMPART, da_contab);
    sf.force_update();
  }
  return TRUE;
}

// funzione chiamata dal notify dello sheet per effettuare il calcolo degli
// importi totali (in lire ed in valuta) dell'effetto
void TVariazione_effetti::calcola_totali()
{
  TMask* m = app()._msk;
  TSheet_field& sf = m->sfield(F_SHEET_RIGHE);
  int items = sf.items();
  real imp, impval, impeff, impeffval;
  // scandisco tutte le righe dello sheet e ne prendo gli importi
  // (in lire ed in valuta) e li sommo al totale
  for (int i = 0; i < items; i++)
  {
    TToken_string& row = sf.row(i);
    imp = row.get(sf.cid2index(F_IMPEFF));
    impeff += imp;
    impval = row.get(sf.cid2index(F_IMPEFFVAL));
    impeffval += impval;
  }
  m->set(F_TOTIMP, impeff);
  m->set(F_TOTIMPVAL, impeffval);
}

// notify per il calcolo dei totali dell'effetto e per il controllo che non
// vengano eliminate tutte le righe dell'effetto, almeno una deve rimanere
bool TVariazione_effetti::impeff_notify(TSheet_field& s, int r, KEY key)
{
  if (s.to_check(key, TRUE))
  {
    calcola_totali();
  }
  //se rimane una sola riga nello sheet non la si può cancellare
  if (key == K_DEL && s.items() == 1)
    return s.error_box(TR("IMPOSSIBILE CANCELLARE: L'effetto deve contenere almeno una riga!"));
  return TRUE;
}

int ef0100(int argc, char* argv[])
{
  TVariazione_effetti a ;
  a.run(argc, argv, TR("Effetti"));
  return 0;
}