#include <tabapp.h>

#include "../mg/mglib.h"

#include "sv0.h"   
#include "svlib01.h"

///////////////////////////////////////////////////////////
// Applicazione generica per la gestione di tabelle di sv
///////////////////////////////////////////////////////////

class TSV_tabapp : public Tab_application
{      
protected:
  virtual TString& get_mask_name(TString& name) const;
};

TString& TSV_tabapp::get_mask_name(TString& name) const
{            
  name = get_tabname();
  if (name[0] == '%') 
    name.ltrim(1);
  name.insert("svtb", 0);
  return name;
}

///////////////////////////////////////////////////////////
// Gestione tabella PSV
///////////////////////////////////////////////////////////

#include "svtbpsv.h"

class TPSV_tabapp : public TSV_tabapp
{ 
  enum { MAX_ROWS = 8 };

  TStats_agg _stats;

protected:
  virtual void on_config_change();
  virtual bool user_create();
  virtual void init_insert_mode(TMask& m);
  virtual int read(TMask& m);
  virtual int write(const TMask& m);
  virtual int rewrite(const TMask& m);
  void mask2rec(const TMask& m);  // usata da re/write

public:
  static bool multiplo_handler(TMask_field& f, KEY k);
  static bool chiave_handler(TMask_field& f, KEY k);
  static bool campo_handler(TMask_field& f, KEY k);
  static bool artfld_handler(TMask_field& f, KEY k);
  static bool chiave_notify(TSheet_field& s, int r, KEY k);
  
  void set_frequency();
  void fill_field_list(TMask& m);
};

inline TPSV_tabapp& PSV_app() { return (TPSV_tabapp&)main_app(); }

void TPSV_tabapp::on_config_change()
{
  _stats.init();
  set_frequency();
}

void TPSV_tabapp::init_insert_mode(TMask& m)
{
  m.set(FPSV_MULTIPLO, m.get(FPSV_FREQUENZA));
}

void TPSV_tabapp::set_frequency()
{
  TMask& m = curr_mask();   

  char freq[2] = { frequency2char(_stats.frequency()), '\0' };
  m.set(FPSV_FREQUENZA, freq); 
    
  TList_field& multiplo = (TList_field&)m.field(FPSV_MULTIPLO);
    
  TToken_string std_codes("G|S|Q|1|2|3|4|6|A");
  TToken_string std_descr;
	
	std_descr.add(TR("Giornaliera"));
	std_descr.add(TR("Settimanale"));
	std_descr.add(TR("Quindicinale"));
	std_descr.add(TR("Mensile"));
	std_descr.add(TR("Bimestrale"));
	std_descr.add(TR("Trimestrale"));
	std_descr.add(TR("Quadrimestrale"));
	std_descr.add(TR("Semestrale"));
	std_descr.add(TR("Annuale"));
    
  TToken_string codes(8), descr(80);
  switch(_stats.frequency())
  {
  case fs_giornaliera   :codes = std_codes; break;
  case fs_settimanale   :codes = "S|3|6|A"; break;
  case fs_quindicinale  :codes = std_codes.mid(4); break;
  case fs_mensile       :codes = std_codes.mid(6); break;
  case fs_bimestrale    :codes = "2|4|6|A"; break;
  case fs_trimestrale   :codes = "3|6|A"; break;
  case fs_quadrimestrale:codes = "4|A"; break;
  case fs_semestrale    :codes = "6|A"; break; 
  case fs_annuale       :codes = "A"; break;
  default :break;
  } 
    
  for (const char* cod = codes.get(0); cod; cod = codes.get())
  { 
    TString16 tmp = cod;
    const int pos = std_codes.get_pos(tmp);
    CHECK(pos >= 0, "Invalid frequency char");
    tmp = std_descr.get(pos);
    descr.add(tmp);
  }
    
  multiplo.replace_items(codes, descr);
}

void TPSV_tabapp::fill_field_list(TMask& m)
{
  TSheet_field& s = m.sfield(FPSV_CHIAVE);
  TMask& sm = s.sheet_mask();

  TString_array& list = sm.efield(SPSV_CAMPO).sheet()->rows_array();
  list.destroy();

  TToken_string row(80);
    
  TCodart_livelli cal;
  int l;
  for (l = 0; l <= cal.last_level(); l++)
  {
    if (l && !cal.enabled(l)) 
      continue;

    row = "A";
    if (l) row << l;
      
    row.add(TR("Codice articolo"));
    if (l) row << '[' << l << ']';
    
    list.add(row);
  }
    
  TCodgiac_livelli cgl;
  bool is_articolo = FALSE;
  
  for (l = 0; l <= cgl.last_level(); l++)
  {
    if (l && !cgl.enabled(l)) 
      continue;
        
    is_articolo = TRUE;
    row = "L";
    if (l) row << l;
      
    row.add(TR("Livello giacenza"));
    if (l) row << '[' << l << ']';
    list.add(row);
  }
  if (is_articolo)
  {
    row = "B";
    row.add(TR("Campo dell'anagrafica articoli"));
    list.add(row);
  }  

  row = "D";
	row.add(TR("Tipo documento"));  
	list.add(row);
  row = "V";
	row.add(TR("Categoria vendita"));  
	list.add(row);
  row = "C";
	row.add(TR("Codice cliente"));
	list.add(row);
  row = "Z";
	row.add(TR("Codice zona"));
	list.add(row);
  row = "G";
	row.add(TR("Codice agente"));
	list.add(row);
  row = "M";
	row.add(TR("Codice magazzino"));
	list.add(row);
}

bool TPSV_tabapp::user_create()
{
  const bool ok = TSV_tabapp::user_create();

  TMask& m = *get_mask(MODE_QUERY);
  TMask& sm = m.sfield(FPSV_CHIAVE).sheet_mask();

  m.set_handler(FPSV_MULTIPLO, multiplo_handler);
  m.set_handler(FPSV_CHIAVE, chiave_handler);
  m.sfield(FPSV_CHIAVE).set_notify(chiave_notify);
  
  
  sm.set_handler(SPSV_CAMPO, campo_handler);
  sm.set_handler(SPSV_ARTFLD, artfld_handler);  

  fill_field_list(m);
    
  return ok;
}

int TPSV_tabapp::read(TMask& m)
{                           
  const TRectype& rec = get_relation()->curr();

  TSheet_field& sheet = m.sfield(FPSV_CHIAVE);
  sheet.destroy();
  
  TToken_string s1 = rec.get("S1");
  TToken_string s2 = rec.get("S2");
  TToken_string s4 = rec.get("S4");
  TString s5 = rec.get("S5");                              
  
  if (s4.not_empty())
    if (s4[s4.len() - 1] == '|' && s5[0] == '|') s4 << " ";
  s4 <<s5;
                             
  
  int r = 0;
  for (const char* cod = s1.get(0); cod; cod = s1.get(), r++)
  {
    TToken_string& row = sheet.row(r);  
    row = cod;
    cod = s2.get(r);
    row.add(cod);     
    row.add("");
    cod = s4.get(r);
    row.add(cod);     
    sheet.check_row(r);
  }
  
  return TSV_tabapp::read(m);
}

void TPSV_tabapp::mask2rec(const TMask& m)
{
  TString16 cod;       
  TToken_string s1, s2, s4;
  TSheet_field& sheet = m.sfield(FPSV_CHIAVE);
  bool excedeed = FALSE;
  
  for (int r = 0; r < sheet.items() && r < MAX_ROWS; r++)
  {
    TToken_string& row = sheet.row(r);
    cod = row.get(0);
    if (!cod.blank())
    { 
      s1.add(cod);
      cod = row.get();
      s2.add(cod); 
      cod = row.get(3); 
      cod.trim();
      const int l = cod.len()+1;
      excedeed = s4.len() + l > 40;
      if (!excedeed)
        s4.add(cod);
    }
  }
  
  TRectype& rec = get_relation()->curr();
  rec.put("S1", s1);
  rec.put("S2", s2);          
  rec.put("S4", s4.left(20));
  rec.put("S5", s4.mid(20));
  if (excedeed)
    warning_box(TR("Attenzione !! Sono stati definiti\ntroppi campi di anagrafica articoli.\nVerranno memorizzati solo i primi"));
}

int TPSV_tabapp::write(const TMask& m)
{
  mask2rec(m);
  return TSV_tabapp::write(m);
}

int TPSV_tabapp::rewrite(const TMask& m)
{
  mask2rec(m);
  return TSV_tabapp::rewrite(m);
}

bool TPSV_tabapp::multiplo_handler(TMask_field& f, KEY k)
{  
  if (k == K_SPACE)
  {
    TMask& m = f.mask();         
    TFrequenza_statistiche base = char2frequency(m.get(FPSV_FREQUENZA)[0]);
    TFrequenza_statistiche freq = char2frequency(f.get()[0]);
    if (base == freq)
    {
      m.enable(FPSV_NUMERO);
      if (m.is_running())   
        m.set(FPSV_NUMERO, 1);
    }  
    else
    {            
      int n = divide(freq, base);
      m.set(FPSV_NUMERO, n);
      m.disable(FPSV_NUMERO);
    }  
  }
  return TRUE;
} 

bool TPSV_tabapp::chiave_notify(TSheet_field& s, int r, KEY k)
{           
  bool ok = TRUE;
  if (k == K_INS)
    ok = s.items() < MAX_ROWS;
  return ok;
}

bool TPSV_tabapp::chiave_handler(TMask_field& f, KEY k)
{       
  bool ok = TRUE;
  if (k == K_ENTER)
  {              
    TSheet_field& sheet = (TSheet_field&)f;
    TToken_string used;
    TString16 campo;
    for (int r = 0; r < sheet.items(); r++)
    {
      TToken_string& row = sheet.row(r);
      campo = row.get(0);
      
      if (campo.blank())
        continue;
        
      switch(campo[0])  
      {              
      case 'C': 
        if (!PSV_app()._stats.grp_cliente())
          ok = error_box(TR("Le statistiche sono raggruppate per cliente"));
        break;  
      case 'G': 
        if (!PSV_app()._stats.grp_agente())
          ok = error_box(TR("Le statistiche sono raggruppate per agente"));
        break;  
      case 'L': 
        if (!PSV_app()._stats.grp_giacenza())
          ok = error_box(TR("Le statistiche sono raggruppate per livello di giacenza"));
        break;  
      case 'M': 
        if (!PSV_app()._stats.grp_magazzino())
          ok = error_box(TR("Le statistiche sono raggruppate per magazzino"));
        break;  
      case 'Z': 
        if (!PSV_app()._stats.grp_zona())
          ok = error_box(TR("Le statistiche sono raggruppate per zona"));
        break;  
      default : break;
      }
      
      bool found = used.get_pos(campo) >= 0;
      if (!found && (campo[0] == 'A' || campo[0] == 'L'))
      {
        char str[2]; str[0] = campo[0]; str[1] = '\0';
        found = used.get_pos(str) >= 0;
      }
      
      if (campo[0] != 'B' && found )
      {       
        ok = error_box(FR("Il codice %s inserito alla riga %d e' gia'\nutilizzato in una riga precedente."),
                       (const char*)campo, r+1);
      }
      else
        used.add(campo);
    }
  }
  return ok;
}

bool TPSV_tabapp::campo_handler(TMask_field& f, KEY k)
{  
  if (f.to_check(k,TRUE))            
  {         
    const bool is_fld = f.get()== "B";
    
    if (!is_fld)
      f.mask().reset(SPSV_ARTFLD);
    f.mask().field(SPSV_ARTFLD).check_type(is_fld ? CHECK_REQUIRED : CHECK_NONE);
    f.mask().enable(SPSV_ARTFLD, is_fld);
  }
  return TRUE;
}  

bool TPSV_tabapp::artfld_handler(TMask_field& f, KEY k)
{  
  bool ok = TRUE;      
  switch (k)
  {       
	  case K_TAB:
	  case K_ENTER:
	    if (!f.empty() && f.to_check(k))
	    {
	      const TRectype rec(LF_ANAMAG);        
	      TString16 field = f.get();
	      int pos = field.find('[');
	      if (pos > 0)
	        field.cut(pos);
	      if (!rec.exist(field))
	        ok = f.error_box(FR("Il campo '%s' non esiste."), (const char*)field);
	    }
	    break;
	  case K_F9:
	    {                                                      
	      TRelation anamag(LF_ANAMAG);
	      TRelation_description rd(anamag);
	      if (rd.choose_field(f.get()))
	        f.set(rd.field_name());   
	        
	    }
	    break;
    default:
      break;
  }
  return ok;
}

///////////////////////////////////////////////////////////
// Pseudo main
///////////////////////////////////////////////////////////

int sv0100(int argc, char* argv[])
{                     
  TApplication::check_parameters(argc, argv);   
  if (argc > 2)
  {
    TFixed_string tab(argv[2]);
    
    TSV_tabapp* app;
    if (tab.upper() == "PSV")
      app = new TPSV_tabapp;
    else  
      app = new TSV_tabapp;
    app->run(argc, argv, TR("Tabella"));
    delete app;                        // Guy's humour
  }
  else
    error_box(TR("Manca il nome della tabella"));  
  return 0;
}