// Gestione sconti di Riga/Incondizionati/Documenti
#include <config.h>
#include <recarray.h>
#include <relapp.h>
#include <tabutil.h>

#include "ve2100.h"

#define MAX_REAL "9999999999.99999" //mmmhh..

static void key_hide(TMask & m, short id, int key = 1)
{
  TEditable_field & e  = ((TEditable_field &)m.field(id));
  e.reset_key(key);
  e.check_type(CHECK_NONE);
  e.set_field("");
  m.hide(id);                                     
} 

static void key_disable(TMask & m, short id, int key = 1)
{
  ((TEditable_field &)m.field(id)).reset_key(key);
  m.disable(id);
} 

static void key_enable(TMask & m, short id, int key = 1)
{
  ((TEditable_field &)m.field(id)).set_key(key);
  m.enable(id);
} 
struct enable_key_info
{ 
  bool enabled;
  short normal_field,search_field;
};

class TTabelle_sconti: public TRelation_application {
  TMask *_msk; // maschera principale
  TRelation *_rel; // relazione principale

  char _sconti; // carattere che indica il tipo di tabella
  bool _catven; // abilitazione della gestione della categoria di vendita
  bool _scoum;  // abilitazione della gestione delle unita' di misura
  bool _sca;  // abilitazione della gestione degli scaglioni
  enable_key_info _sci_k_id[4]; // struct contenente informazioni sull'abilitazione degli sconti incondizionati
  TString _gessco; // indicatore di abilitazione degli sconti incondizionati
  TString _gesscoriga; // indicatore di abilitazione degli sconti di riga
  
  virtual bool user_create();
  virtual bool user_destroy();                        
  virtual TMask *get_mask(int) { return _msk; }
  virtual bool changing_mask(int) { return FALSE; }
  virtual TRelation *get_relation() const { return _rel; }
  virtual void init_query_mode(TMask& m);
  virtual void init_query_insert_mode(TMask& m);
  virtual bool remove(); // metodo usato per rimuovere il record sul file
  void renumber_sca(const TRectype& r);   //metodo per rinumerare gli scaglioni
//  static void fill_rec(TRectype& r, TMask& m);
  static real find_prev_qta(TRectype& r);
  static real find_next_qta(TRectype& r);
  static bool handle_qta(TMask_field &, KEY); // handler della quantita' limite per scaglione
  static bool handle_sca(TMask_field &, KEY); // handler dello scaglione
  // Gli handler seguenti sono necessari solo per controllare l'esistenza effettiva del campo immesso
  // Si dira' perche' non e' stato messo un bel CHECKTYPE FORCED su tali campi?
  // Risposta, perche quando si clicca su nuovo per andare in modo ricerca/inserimento, tutti i campi
  // che hanno CHECKTYPE FORCED risultano non essere validi. Percio' si e' rimesso il CHECKTYPE REQUIRED
  // e si controlla la consistenza del campo.
//  static bool handle_um(TMask_field &, KEY);  // handler delle unita' di misura per gli sconti di riga
  static bool handle_check(TMask_field &, KEY); // handler per i check
//  static bool handle_sco(TMask_field &, KEY); // handler delle sconto cliente
//  static bool handle_zon(TMask_field &, KEY); // handler delle zone
//  static bool handle_cpg(TMask_field &, KEY); // handler delle condizioni di pagamento

public:
  // @cmember Disabilita la verifica del modulo : essendo una anagrafica, va sempre abilitata
  virtual bool check_autorization() const   {return FALSE;}
  TTabelle_sconti() {_sca = _scoum = _catven = FALSE;}
  virtual ~TTabelle_sconti() {}
};

inline TTabelle_sconti& app() { return (TTabelle_sconti &) main_app(); }

// Handlers per i campi quantita' limite e scaglione, valgono solo per gli sconti di riga

real TTabelle_sconti::find_prev_qta(TRectype& r)
{
  TLocalisamfile f(LF_SCONTI);
  real qta = 0.0;
  f.curr() = r;
  int nscagl = r.get_int("NSCAGL");
  f.put("NSCAGL", nscagl-1);
  if (f.read() == NOERR)
    qta = f.get_real("QLIM");
  return qta;
}
       
real TTabelle_sconti::find_next_qta(TRectype& r)
{
  TLocalisamfile f(LF_SCONTI);
  real qta(MAX_REAL);
  f.curr() = r;
  int nscagl = r.get_int("NSCAGL");
  f.put("NSCAGL", nscagl+1);
  if (f.read() == NOERR)
    qta = f.get_real("QLIM");
  return qta;
}

bool TTabelle_sconti::handle_qta(TMask_field &f, KEY k)
{
  if (f.to_check(k))
  {
    TMask& m = f.mask();
    real qta_prev,qta_next;
    real current_qta(f.get());
    TRelation r(LF_SCONTI);
    m.autosave(r);                   
    TRectype r1(r.curr());
    TRectype r2(r1);
    
    qta_prev = find_prev_qta(r1);
    qta_next = find_next_qta(r2);
    int sca = m.get_int(F_R_SCA);
    if (sca == 1 && current_qta == 0.0)
    {
      f.error_box("La quantita' limite deve essere maggiore di 0");
      return FALSE;
    }
    if (sca == 9 && current_qta == 0.0) return TRUE;
    if (qta_next <= current_qta)
    {
      f.error_box("La quantita' limite deve essere minore di %s.", 
                  (const char*)qta_next.string());
      return FALSE;
    }
    if (qta_prev >= current_qta)
    {
      f.error_box("La quantita' limite deve maggiore di %s.", 
                  (const char*)qta_prev.string());
      return FALSE;
    }
  }
  return TRUE;
}
 
bool TTabelle_sconti::handle_sca(TMask_field &f, KEY k)
{
  TMask& m = f.mask();
  if (f.to_check(k))
  {
    int sca = atoi(f.get());
    if (sca == 1) return TRUE;
    
    TRelation sconti(LF_SCONTI);
    
    m.autosave(sconti);       
      
    TRectype r(sconti.curr());
    
    sconti.read();
    if (sconti.bad()) // se non l'ha trovato significa che e' in inserimento
    {
      sca--;     
      sconti.curr() = r;
      sconti.curr().put("NSCAGL",sca); //cerca quello precedente...
      if (sconti.read() != NOERR) // se non lo trova segnala l'errore di errata sequenza
      {
        f.error_box("Il numero di scaglione immesso non e' in sequenza.");
        return FALSE;
      }
    }
  }
  return TRUE;
}

bool TTabelle_sconti::handle_check(TMask_field &f, KEY k)
{
  if (f.to_check(k))
  { 
    TEditable_field & check_field = f.mask().efield(f.dlg() + 100);
                
    check_field.set(f.get());
    if (!check_field.check())
      return f.error_box(check_field.get_warning()); 
  }
  return TRUE;
}

bool TTabelle_sconti::user_create()
{
  bool gotcha= FALSE; // booleano di avvenuta inizializzazione
    
  _sconti= '*'; // inizializzazione dell'indicatore del tipo di tabella
  if (argc()>2)
    _sconti = toupper((argv(2))[0]); // se c'è, prende il tipo di tabella dalla linea di comando
  else
  {
    TMask choose("ve2100"); // istanzia la maschera di scelta del tipo di tabella
    if (choose.run() == K_ENTER)
      _sconti = toupper((choose.get(F_TIPOSC))[0]); // prende il tipo di tabella dalla maschera
    else 
      return FALSE;
  }
  TConfig prassid(CONFIG_DITTA, "ve"); // apre il file di configurazione di ditta
  switch (_sconti) {
    case 'D': // sconti documento
      _msk= new TMask("ve2100d"); // apre la maschera relativa
      set_search_field(F_D_CODCAT); // setta il campo di ricerca
      gotcha= TRUE;
      break;
    case 'R': // sconti di riga
      _gesscoriga = prassid.get("GESSCORIGA");  // legge lo stato del parametro di abilitazione degli sconti riga
      if (_gesscoriga == "A")
      {
        _msk= new TMask("ve2100r"); // apre la maschera relativa

        _catven= prassid.get_bool("GESSCORIGACV"); // legge il parametro di abilitazione delle categorie di vendita
        if (!_catven)
          key_disable(*_msk, F_R_CODCAT); // se non è abilitato, viene disabilitato anche il campo

        _scoum = prassid.get_bool("GESSCOUM"); // legge il parametro di abilitazione delle unita' di misura
        if (!_scoum)
          key_disable(*_msk, F_R_UM); // se non e' abilitato, viene disabilitato anche il campo
//        else
//          _msk->set_handler(F_R_UM,handle_um);

        _sca = prassid.get_bool("GESSCOSCA"); // legge il parametro di abilitazione degli scaglioni
        if (!_sca)
        {
          key_disable(*_msk, F_R_SCA); // se non e' abilitato, viene disabilitato anche il campo
          _msk->disable(F_R_QLIM); // disabilita pure la qta' limite
        }
        else
        {
          _msk->set_handler(F_R_QLIM, handle_qta); // setta l'handler per controllare la quantita' limite
          _msk->set_handler(F_R_SCA,  handle_sca); // setta l'handler per controllare la sequenza degli scaglioni
        }
        _msk->set_handler(F_R_CODART_A,handle_check);
        _msk->set_handler(F_R_RFA_A,handle_check);
        _msk->set_handler(F_R_GRM_A,handle_check);
        _msk->set_handler(F_R_SGM_A,handle_check);
        gotcha= TRUE;
        
        TString16 rigakey = prassid.get("SCORIGAKEY");                        

        if (rigakey.empty())
          rigakey = "A";
        _msk->set(F_R_TIPO_RIGA, rigakey);
        switch (rigakey[0])
        {
          case 'A' :
            key_hide(*_msk, F_R_RFA_A);
            key_hide(*_msk, F_R_RFA);
            key_hide(*_msk, F_R_GRM_A);
            key_hide(*_msk, F_R_GRM);
            key_hide(*_msk, F_R_SGM_A);
            key_hide(*_msk, F_R_SGM);
            break;
          case 'R' :
            key_hide(*_msk, F_R_CODART_A);
            key_hide(*_msk, F_R_CODART);
            key_hide(*_msk, F_R_GRM_A);
            key_hide(*_msk, F_R_GRM);
            key_hide(*_msk, F_R_SGM_A);
            key_hide(*_msk, F_R_SGM);
            break;
          case 'C' :
            key_hide(*_msk, F_R_CODART_A);
            key_hide(*_msk, F_R_CODART);
            key_hide(*_msk, F_R_RFA_A);
            key_hide(*_msk, F_R_RFA);
            key_hide(*_msk, F_R_GRM_A);
            key_hide(*_msk, F_R_GRM);
            break;
          case 'L' :
            key_hide(*_msk, F_R_CODART_A);
            key_hide(*_msk, F_R_CODART);
            key_hide(*_msk, F_R_RFA_A);
            key_hide(*_msk, F_R_RFA);
            key_hide(*_msk, F_R_SGM_A);
            key_hide(*_msk, F_R_SGM);
            break;
          default :
            break;
        }
      }
      else
        error_box("Gli sconti di riga non sono abilitati nella configurazione");
      break;
    case 'I': // sconti incondizionati
      _gessco= prassid.get("GESSCO"); // legge lo stato del parametro di abilitazione degli sconti
      if (_gessco=="A") {
        _msk= new TMask("ve2100i"); // apre la maschera relativa
        // inizializza l'array dei campi da disabilitare condizionalmente
        _sci_k_id[0].normal_field = F_I_CATVEN;
        _sci_k_id[0].search_field = F_I_RICERCA;
        _sci_k_id[0].enabled = TRUE;
        _sci_k_id[1].normal_field = F_I_SCCLIENTI;
        _sci_k_id[1].search_field = F_I_RICERCA_SC;
        _sci_k_id[1].enabled = TRUE;
        _sci_k_id[2].normal_field = F_I_ZONE;
        _sci_k_id[2].search_field = F_I_RICERCA_ZO;
        _sci_k_id[2].enabled = TRUE;
        _sci_k_id[3].normal_field = F_I_CONDPAG;
        _sci_k_id[3].search_field = F_I_RICERCA_CO;
        _sci_k_id[3].enabled = TRUE;
        _msk->set_handler(F_I_RICERCA, handle_check);
        _msk->set_handler(F_I_RICERCA_SC, handle_check);
        _msk->set_handler(F_I_RICERCA_ZO, handle_check);
        _msk->set_handler(F_I_RICERCA_CO, handle_check);
        for (int i = 0; i < 4; i++)
        {
          if (!prassid.get_bool("SCOKEY", NULL, i+1)) // se nel file di config. il campo non è abilitato...
          {
            key_disable(*_msk, _sci_k_id[i].normal_field); // il campo non è abilitato viene disabilitato anche sulla maschera
            key_disable(*_msk, _sci_k_id[i].search_field);
            _sci_k_id[i].enabled = FALSE;
          }
          else gotcha = TRUE;
        }
        if (!gotcha) error_box("Non ci sono campi chiave abilitati nella configurazione della ditta");
        ////
        ////
        //// Necessito della possibilita' di cambiare il filtro alla browse di un TEdit_field!!
        //// Cosi' posso far vedere solo i record editabili.
        ////
      } else error_box("Gli sconti incondizionati non sono abilitati nella configurazione");
      break;
    default: // messaggio di errore se si indica una tabella non valida
      error_box("Indicare la tabella sulla linea di comando (D, R o I) oppure selezionarla dalla maschera di partenza");
      break;
  }
  if (gotcha) _rel= new TRelation(LF_SCONTI); // se è stata selezionata una tabella, apre la relazione (un unico file)
  return (gotcha);
}

bool TTabelle_sconti::user_destroy() {
  delete _rel;
  delete _msk;
  return TRUE;
}

void TTabelle_sconti::init_query_mode(TMask& m) {
  
  switch (_sconti)
  {
    case 'D':
      set_search_field(F_D_CODCAT); // setta il campo di ricerca
      break;
    case 'I':
      {
        for (int i = 0; i < 4 ; i++)
        {
          if (_sci_k_id[i].enabled)
          {
            m.show(_sci_k_id[i].search_field);
            m.hide(_sci_k_id[i].normal_field);
            key_enable(m,_sci_k_id[i].search_field);
            key_disable(m,_sci_k_id[i].normal_field);
          }
        }
        set_search_field(F_I_RICERCA);
      }
      break;
    case 'R':    
      {
        TString16 rigakey = m.get(F_R_TIPO_RIGA);
        
        switch (rigakey[0])
        {
          case 'A' :
            m.show(F_R_CODART_A);
            m.hide(F_R_CODART);
            set_search_field(F_R_CODART_A); // setta il campo di ricerca
            break;
          case 'R' :
            m.show(F_R_RFA_A);
            m.hide(F_R_RFA);
            set_search_field(F_R_RFA_A); // setta il campo di ricerca
            break;
          case 'C' :
            m.show(F_R_SGM_A);
            m.hide(F_R_SGM);
            set_search_field(F_R_SGM_A); // setta il campo di ricerca
            break;
          case 'L' :
            m.show(F_R_GRM_A);
            m.hide(F_R_GRM);
            set_search_field(F_R_GRM_A); // setta il campo di ricerca
            break;
          default :
            break;
        }
      }
      break;
    default: break;
  }
}

void TTabelle_sconti::init_query_insert_mode(TMask& m)
{
  switch (_sconti)
  {
    case 'D':
      set_search_field(F_D_CODCAT); // setta il campo di ricerca
      break;
    case 'I':       
      {
        for (int i = 0; i < 4; i++)
        {
          if (_sci_k_id[i].enabled)
          {
            m.show(_sci_k_id[i].normal_field);
            m.hide(_sci_k_id[i].search_field);
            key_enable(m,_sci_k_id[i].normal_field);
            key_disable(m,_sci_k_id[i].search_field);
          }
        }
        set_search_field(F_I_CATVEN);
      }
      break;
    case 'R':
      {
        TString16 rigakey = m.get(F_R_TIPO_RIGA);
        
        switch (rigakey[0])
        {
          case 'A' :
            m.show(F_R_CODART);
            m.hide(F_R_CODART_A);
            set_search_field(F_R_CODART); // setta il campo di ricerca
            break;
          case 'R' :
            m.show(F_R_RFA);
            m.hide(F_R_RFA_A);
            set_search_field(F_R_RFA); // setta il campo di ricerca
            break;
          case 'C' :
            m.show(F_R_SGM);
            m.hide(F_R_SGM_A);
            set_search_field(F_R_SGM); // setta il campo di ricerca
            break;
          case 'L' :
            m.show(F_R_GRM);
            m.hide(F_R_GRM_A);
            set_search_field(F_R_GRM); // setta il campo di ricerca
            break;
          default :
            break;
        }
      }
      break;
    default: break;
  }
}

void TTabelle_sconti::renumber_sca(const TRectype& r)
{
  TRectype from(r);
  from.zero("NSCAGL");  
  TRecord_array rec_arr(from,"NSCAGL");
  if (rec_arr.read(from) == NOERR)
  {
    rec_arr.pack();
    rec_arr.rewrite();
  }
}

bool TTabelle_sconti::remove()
{
  TRectype r(LF_SCONTI);
  const bool rt = TRelation_application::remove();
  if (_sca) // rinumera gli scaglioni
    renumber_sca(r);
  return rt;
}

int ve2100(int argc, char* argv[]) {
  TTabelle_sconti a;
  
  a.run(argc, argv, TR("Tabella sconti "));
  return 0;
}