#include <diction.h>
#include <expr.h>
#include <isam.h>
#include <mask.h>
#include <validate.h>
#include <defmask.h>

#include <comuni.h>
#include <nditte.h>

typedef bool (*VAL_FUNC)(TMask_field&, KEY k);
HIDDEN const TString_array* _parms;

HIDDEN int get_val_param_count() 
{ return _parms->items(); }

HIDDEN const TString& get_val_param(int i)
{ 
  const TString* str = (const TString*)_parms->objptr(i);
  if (str && *str)
    return *str;
  return EMPTY_STRING; 
}

HIDDEN int get_int_val_param(int i)
{ return atoi(get_val_param(i)); }

HIDDEN const TString& get_fld_val_param(const TMask_field& f, int i)
{ 
	const TString & id = get_val_param(i);
  return f.evaluate_field(id); 
}

HIDDEN bool _expr_val(TMask_field& f, KEY)
{
  const TMask& m = f.mask();
  const TTypeexp type = get_int_val_param(0) == 0 ? _numexpr : _strexpr;
  TExpression  e(get_val_param(1), type);

  for (int i = 0; i < e.numvar(); i++)
  {
    const char* s = e.varname(i);

    if (s[0] != '#') 
    { 
      TString err; err << TR("Le variabili devono cominciare con #") << ": " << s << '\n' << e;
      return f.error_box((const char*)err);
    }  
		if (type == _numexpr)
		{
			const real r = f.evaluate_field(s);
			e.setvar(i, r);
		}
		else
			e.setvar(i, f.evaluate_field(s));
  }
  return bool(e);
}

HIDDEN bool _emptycopy_val(TMask_field& f, KEY)
{            
  if (f.empty())
  {
    const TString& val = get_fld_val_param(f, 0);
    if (val.not_empty()) 
    {
      f.set(val);
      f.on_hit();
    }  
  }
  return true;
}

HIDDEN bool check_pi_estera(const TString& st, const TString& paiva)
{
/*
 const char* stpi[] = { "AT09", "BE10", "DE09", "DK08", "EL08", "ES09", 
                         "FI08", "FR11", "GB05", "GB09", "GB12", "IE08",
                         "LU08", "NL12", "PT09", "SE12", "SM05", NULL };
  bool lenok = false;
  bool known = false;
  
  for (int g = 0; stpi[g] && !lenok; g++)
  {
    if (st.compare(stpi[g], 2, true) == 0)      // Se lo stato corrisponde
    {
      known = true;
      lenok = paiva.len() == atoi(stpi[g]+2);   // Confronto lunghezza
    }
    else
    {
      if (known)  // Inutile cercare ancora
        break;
    }
  } 
  if (known)
  {
    if (lenok)
    {
      if (st=="AT")   // Controllo speciale per l'Austria che comincia per U
        lenok = paiva[0] == 'U' && real::is_natural(paiva.mid(1)); else
      if (st=="BE")   // Controllo speciale per il Belgio che comincia per 0
        lenok = paiva[0] == '0' && real::is_natural(paiva); else
      if (st=="NL")   // Controllo speciale per l'Olanda che ha una B in posizione 10
        lenok = paiva[9] == 'B' && real::is_natural(paiva.left(9)); 
    }
  }
  else
    lenok = true;  // Gli stati ignoti hanno sempre lunghezza corretta!
  return lenok;  
*/
  const int len = paiva.len();
  const char* p = paiva;
  const bool nat = real::is_natural(p);

  if (st == "AT")
    return len == 9 && p[0] =='U' && real::is_natural(p+1);
  if (st == "BE")
    return len == 10 && p[0] =='0' && nat;
  if (st == "DE")
    return len == 9 && nat;
  if (st == "DK")
    return len == 8 && nat;
  if (st == "EL")
    return len == 9 && nat;
  if (st == "ES")
    return len == 9 && !(isdigit(p[0] && isdigit(p[8])) && real::is_natural(paiva.mid(1,7)));
  if (st == "IT")
    return len == 11 && nat; // Ridondante ma documentante
  if (st == "HU")
    return len == 8 && nat;  
  if (st == "FI")
    return len == 8 && nat;
  if (st == "FR")
    return len == 11 && real::is_natural(p+2);
  if (st == "GB")
    return (len == 5 && real::is_natural(p+2)) || ((len == 9 || len == 12) && nat);
  if (st == "IE")
    return len == 8;
  if (st == "LU")
    return len == 8 && nat;
  if (st == "NL")
    return len == 12 && paiva[9] == 'B' && real::is_natural(paiva.left(9));
  if (st == "PL")
    return len == 10 && nat;
  if (st == "PT")
    return len == 9 && nat;
  if (st == "RO")
    return len >= 2 && len <= 10 && nat;
  if (st == "SE")
    return len == 12 && nat;
  if (st == "SM")
    return len == 5;
  return paiva.full(); // Gli stati ignoti hanno sempre lunghezza corretta!
}

// @doc EXTERNAL

// @func Controlla se la Partita IVA assume un valore valido
//
// @rdesc Ritorna i seguenti valori:
//
// @flag true | Se il valore della Partita IVA assume un valore corretto
// @flag false | Se il valore della Partita IVA non puo' essere valido
bool pi_check(
     const char* st,  // @parm Stato di assegnazione della Partita IVA
     const char* paiva) // @parm Codice della Partita IVA da controllare
{
  const TFixed_string stato(st); 
  const TFixed_string pi(paiva); 
  
  if (pi.blank()) 
    return true;

  bool ok = true;  // Assumiamo ottimisticamente che tutto va be'
  
  if (stato.blank() || stato == "IT") 
  {
    // Testa partita iva italiana
    ok = pi.len() == 11 && real::is_natural(pi);
    if (ok)
    {
      int tot = 0, y;
      for (int i = 0; i <= 9; i++)
      {
        if ((i + 1) & 0x0001) 
          tot += (pi[i] - '0');
        else
        {
          y = (pi[i] - '0') * 2;
          if (y >= 10)
          { 
            tot += (y / 10); 
            y = y % 10; 
          } 
          tot += y; 
        } 
      } 
      y = 10 - (tot % 10);
      if (y == 10) y = 0;
      ok = (pi[10] == (y + '0'));
    }
  }
  else
  {                 
    ok = check_pi_estera(stato, pi);
  }  
  
  return ok;
}


// Controlla la partita iva se e' non vuota ed italiana
HIDDEN bool _pi_val(TMask_field& f, KEY)
{              
  const TMask& m = f.mask();
  if (m.query_mode()) 
    return true;

  const TString& stato = m.get(get_int_val_param(0)); 
  const TString& pi = f.get();
  bool ok = pi_check (stato, pi);
  if (!ok) 
  {
    if (f.dirty())
    {
      bool len_error = true;
      if (stato.blank() || stato == "IT")
        len_error = pi.len() != 11;
      TString msg = len_error ? TR("Lunghezza partita IVA errata") : TR("Partita IVA errata");
      msg << ": " << TR("proseguire ugualmente?");
      ok = f.yesno_box(msg);
      if (ok) f.set_dirty(false);
    }
    else ok = true;      // Era gia' errata e la ho accettata
  }
  return ok;
}


HIDDEN bool __cf_check (const char* codcf)
{
  const TFixed_string cf(codcf);
  if (cf.len() != 16) 
    return false;
  const TFixed_string tab("ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789");

  int tot = 0, y;

  byte val[36][2];

  val[0][0] = 0; val[0][1] = 1;
  val[1][0] = 1; val[1][1] = 0;
  val[2][0] = 2; val[2][1] = 5; 
  val[3][0] = 3; val[3][1] = 7;
  val[4][0] = 4; val[4][1] = 9; 
  val[5][0] = 5; val[5][1] = 13; 
  val[6][0] = 6; val[6][1] = 15; 
  val[7][0] = 7; val[7][1] = 17; 
  val[8][0] = 8; val[8][1] = 19; 
  val[9][0] = 9; val[9][1] = 21;
  val[10][0] = 10; val[10][1] = 2;
  val[11][0] = 11; val[11][1] = 4;
  val[12][0] = 12; val[12][1] = 18;
  val[13][0] = 13; val[13][1] = 20; 
  val[14][0] = 14; val[14][1] = 11; 
  val[15][0] = 15; val[15][1] = 3; 
  val[16][0] = 16; val[16][1] = 6; 
  val[17][0] = 17; val[17][1] = 8; 
  val[18][0] = 18; val[18][1] = 12; 
  val[19][0] = 19; val[19][1] = 14; 
  val[20][0] = 20; val[20][1] = 16; 
  val[21][0] = 21; val[21][1] = 10; 
  val[22][0] = 22; val[22][1] = 22; 
  val[23][0] = 23; val[23][1] = 25; 
  val[24][0] = 24; val[24][1] = 24;
  val[25][0] = 25; val[25][1] = 23;
  val[26][0] = 0; val[26][1] = 1;
  val[27][0] = 1; val[27][1] = 0;
  val[28][0] = 2; val[28][1] = 5;
  val[29][0] = 3; val[29][1] = 7;
  val[30][0] = 4; val[30][1] = 9;
  val[31][0] = 5; val[31][1] = 13;
  val[32][0] = 6; val[32][1] = 15;
  val[33][0] = 7; val[33][1] = 17;
  val[34][0] = 8; val[34][1] = 19;
  val[35][0] = 9; val[35][1] = 21;
  
  for (int i = 0; i <= 14; i++)
  {
    y = tab.find(cf[i]);
    if (y >= 0) tot += val[y][(i + 1) & 0x1];
  }
  const bool ok = (cf[15] == (tot % 26) + 'A');

  return ok;
}

// @doc EXTERNAL

// @func Controlla se il Codice Fiscale assume un valore valido
//
// @rdesc Ritorna i seguenti valori:
//
// @flag true | Se il valore del Codice Fiscale assume un valore corretto
// @flag false | Se il valore del Codice Fiscale non puo' essere valido

bool cf_check (
     const char* stato, // @parm Stato di assegnazione del Codice Fiscale
     const char* codcf) // @parm Codice Fiscale da controllare
{
  bool ok = true;
  if (codcf && *codcf)
  {
    const TFixed_string cf = codcf;
    ok = (cf.len() == 11 && isdigit(cf[0])) ? pi_check(stato, cf) : __cf_check(cf);
  }
  return ok;
}

HIDDEN bool _cf_val(TMask_field& f, KEY key)
{
  if (f.mask().query_mode()) 
    return true;
  
  const TString& cf = f.get();
  bool ok = true;

  if (cf.empty()) return true;
  if (cf.len() == 11 && isdigit(cf[0]))
  {
    const TString& stato = f.mask().get(atoi(get_val_param(0)));
    if (stato.full() && stato != "IT") 
      return true;
    ok = pi_check (stato, cf);
  }
  else 
    ok = __cf_check(cf);
  if (!ok)
  {
    if(f.dirty())
    {
      ok = f.yesno_box(TR("Codice fiscale errato: lo accetto ugualmente?"));
      if (ok) f.set_dirty(false);
    } 
    else 
      ok = true;             // Era gia' errato al caricamento quindi lo accetto
  }
  return ok;
}


HIDDEN bool _xt_pi_val(TMask_field& f, KEY key)
{
  TMask& m = f.mask();
  if (m.query_mode()) 
    return true;
  
  TString16 value = f.get();                    
  if (value.empty()) 
    return f.error_box(TR("Partita IVA obbligatoria"));
  
  if (!_pi_val(f, key)) 
    return true;
    
  const TString& stato = get_fld_val_param(f, 0);
  if (stato.blank() || stato == "IT")
  {  
    TLocalisamfile c(LF_COMUNI);
    const int pi = atoi(value.mid(7,3));
    for (int i = 1 ; i < 3; i++)
    {
      const TString& com = get_fld_val_param(f, i);             // Comune residenza fiscale e residenza
      if (com.full())
      {
        c.zero();
        c.put("COM", com);
        if (c.read() == NOERR)
        {
          const int s1 = c.get_int(COM_UFFIVA1);
          const int s2 = c.get_int(COM_UFFIVA2);
          const int s3 = c.get_int(COM_UFFIVA3);
          if (pi != s1 && pi != s2 && pi != s3) 
          { 
            TString16 ui; ui.format("%03d", s1);
            if (f.yesno_box(FR("Ufficio IVA della partita IVA non congruente: correggere in %s?"), 
                            (const char*)ui))
            {
              value.overwrite(ui, 7);
              f.set(value);
            }  
          }
          break;
        }
      }
    }
  }
  return true;
}

HIDDEN bool _xtz_pi_val(TMask_field& f, KEY key)
{
  return f.empty() || _xt_pi_val(f, key);
}

HIDDEN bool _xt_cf_val(TMask_field& f, KEY key)
{
  if (f.mask().query_mode()) 
    return true;
  
  TString16 cf = f.get(); 
  if (cf.blank()) 
    return true;
  
  if (!_cf_val(f, key)) 
    return false;
  
  if (cf.len() == 11 && real::is_natural(cf))
  {
    //   if (!_xt_pi_val(f, key)) return false;
    //   TString16 stato(f.mask().get(atoi(get_val_param(0))));
    //   if ((stato.not_empty()) && (stato != "IT")) return true;
    return true;
  }

  bool passed = __cf_check(cf);
  if (!passed) return true;

  TMask& m = f.mask();
  
  TMask_field& fld_sex = m.field(get_int_val_param(1));
  TMask_field& fld_dat = m.field(get_int_val_param(2));
  TMask_field& fld_com = m.field(get_int_val_param(3));
  
  const char sesso = fld_sex.get()[0];
  TString16 data = fld_dat.get();
  TString4 com = fld_com.get();

  TString16 wm("LMNPQRSTUV");
  int p;
  if ((p = wm.find(cf[ 6])) >= 0) cf[ 6] = '0' + p;
  if ((p = wm.find(cf[ 7])) >= 0) cf[ 7] = '0' + p;
  if ((p = wm.find(cf[ 9])) >= 0) cf[ 9] = '0' + p;
  if ((p = wm.find(cf[10])) >= 0) cf[10] = '0' + p;
  if ((p = wm.find(cf[12])) >= 0) cf[12] = '0' + p;
  if ((p = wm.find(cf[13])) >= 0) cf[13] = '0' + p;
  if ((p = wm.find(cf[14])) >= 0) cf[14] = '0' + p;
  int gn = atoi(cf.mid(9,2));
  
  if ((sesso == 'F' && gn < 40) || (sesso == 'M' && gn > 40))
  {
    if (data.full()) // Non dare segnalazioni inutili sul sesso se manca la data di nascita
      passed = fld_sex.yesno_box(TR("Sesso incongruente col codice fiscale:\ncorrezione automatica?"));
    if (passed) fld_sex.set(sesso == 'M' ? "F" : "M");
    else return true;
  }

  if (gn > 40) gn -= 40;        // Aggiusta giorno di nascita delle donne

  // Controllo data di nascita
  wm = "ABCDEHLMPRST";
  if (data.full())
  {
    const TDate d(data);
    int err = 0;
    if ((d.year() % 100) != atoi(cf.mid(6, 2)))
      err = 1;
    if (wm[d.month() - 1] != cf[8])
      err = 2;
    if (d.day() != gn)
      err = 3;
    if (err != 0)
    {
      const char* const what = err==1 ? TR("Anno") : (err==2 ? TR("Mese") : TR("Giorno"));
      passed = fld_dat.yesno_box(FR("%s di nascita incongruente col codice fiscale:\ncorrezione automatica?"), what);
      if (passed) 
        data.cut(0);
      else return true;
    }
  }
  
  if (data.blank())
  {
    const int mn = wm.find(cf[8]) + 1;
    if (mn > 0)
    {
      int anno = atoi(cf.mid(6, 2));
      anno += anno < 10 ? 2000 : 1900;
      const TDate d(gn, mn, anno);
      fld_dat.set(d.string());
    }
  }

  // Controllo del comune di nascita
  const char* const codcom = cf.mid(11, 4);
  if (com.full() && com != codcom)
  {
    passed = fld_com.yesno_box(TR("Comune incongruente col codice fiscale:\ncorrezione automatica?"));
    if (passed) com.cut(0);
    else return true;
  }
  if (com.empty())
  {
    fld_com.set(codcom);
    fld_com.on_key(K_TAB);
  }  
  
  return true;
}


HIDDEN bool _xtz_cf_val(TMask_field& f, KEY key)
{
  return f.empty() || _xt_cf_val(f, key);
}

HIDDEN bool _notempty_val(TMask_field& f, KEY)
{
  return f.mask().query_mode() || !f.empty();
}

HIDDEN bool _date_cmp(TMask_field& f, KEY)
{
  const TString& s = f.get();
  if (s.empty()) 
    return true;

  const TDate d0(s), d1(get_fld_val_param(f, 1));
  const TFixed_string op(get_val_param(0));

  if (op == "==") return d0 == d1;
  if (op == "!=") return d0 != d1;
  if (op == ">")  return d0 >  d1;
  if (op == "<")  return d0 <  d1;
  if (op == ">=") return d0 >= d1;
  if (op == "<=") return d0 <= d1;

#ifdef DBG  
  f.error_box("Bad date operator '%s' in field %d", (const char*) op, f.dlg()); 
#endif  

  return false;
}

HIDDEN bool _fixlen_val(TMask_field& f, KEY)
{
  if (f.empty()) 
    return true;

  const TString& s = f.get();
  const int length = get_int_val_param(0);
  const bool ok = s.len() == length;
  if (!ok) 
    f.error_box(FR("La lunghezza del campo deve essere %d caratteri"), length);
  return ok;
}

HIDDEN bool _mtcheck_val(TMask_field& f, KEY)
{
  const int month = atoi(f.get());
  if (month < 1 || month > 13) 
    return false;                                                                                              
                                                                                                  
  TLocalisamfile d(LF_NDITTE);
  d.put(NDT_CODDITTA, prefix().get_codditta());
  if (d.read() != NOERR)
    return true;
  if (d.get_char(NDT_FREQVIVA) == 'M') 
    return true;
  return month == 13 || (month % 3) == 0;
}


HIDDEN bool _reqif_val(TMask_field& f, KEY k)
{
  if (k == K_ENTER && f.empty())
  {
    const int nparms = get_val_param_count();

    for (int i = 0; i < nparms; i++)
    {
      const TString& fld = get_fld_val_param(f, i);
      if (fld.full()) 
        return false;
    }
  }  
  return true;
}


HIDDEN bool _autoexit_val(TMask_field& f, KEY key)
{
  TMask& m = f.mask();
  
  if (!m.query_mode() || key == K_ENTER) 
    return true;

  const int nparms = get_val_param_count();
  bool one_not_empty = false;
  for (int i = nparms-1; i >= 0; i--)
  {
    const short id = get_int_val_param(i);
    const int pos = m.id2pos(id);
    if (pos >= 0)
    {
      const TMask_field& c = m.fld(pos);
      if (c.empty())
      { 
        if (c.check_type() != CHECK_NONE || one_not_empty)
          return true;
      } 
      else 
        one_not_empty = true;
    }
  }
  
  if (one_not_empty)
    m.stop_run(K_AUTO_ENTER);

  return true;
}


HIDDEN bool _numcalc_val(TMask_field& f, KEY k)
{
  if (k != K_TAB) return true;
  TExpression e(get_val_param(0), _numexpr);

  for (int i = 0; i < e.numvar(); i++)
  {
    const char* s = e.varname(i);
    
		if (s[0] != '#') 
    { 
      TString err; err << "Can't load variable " << s << " in " << e;
      return f.error_box((const char*)err);
    }  
		e.setvar(i, f.evaluate_field(s));
  }
  const TString& s = e.as_string();
  f.set(s);
  return true;
}


HIDDEN bool _strcalc_val(TMask_field& f, KEY k)
{
  if (k != K_TAB) return true;
  TExpression e(get_val_param(0), _strexpr);

  for (int i = 0 ; i < e.numvar(); i++)
  {
    const char* s = e.varname(i);
    if (s[0] != '#') 
    { 
      TString err; err << "Can't load variable " << s << " in " << e;
      return f.error_box((const char*)err);
    }  
		e.setvar(i, f.evaluate_field(s));
  }
  const TString& s = e.as_string();
  f.set(s);
  return true;
}


HIDDEN bool _onereq_val(TMask_field& f, KEY k)
{
  if (k != K_ENTER || f.mask().mode() == MODE_QUERY) 
    return true;
  
  const int nparms = get_val_param_count();

  for (int i = 0; i < nparms ; i++)
  {
    const TString& s = get_fld_val_param(f, i);
    if (s.full()) 
      return true;
  }
  return false;
}

HIDDEN bool _chkfld_val(TMask_field& f, KEY k)
{
  if (f.to_check(k))
  {
    const int fldid = get_int_val_param(0);

    if (fldid == THIS_FIELD)
    {
      if (!f.required() && f.get().empty())
        return true;
      else
        return f.check();
    }
    
    TMask_field & chkfld = f.mask().field(fldid);

    chkfld.set(f.get());
    return chkfld.check();
  }
  return true;
}

HIDDEN bool _filename_val(TMask_field& f, KEY)
{
  const TFilename fn(f.get());
  return fn.blank() || fn.ok();
}

HIDDEN bool _zerofill_val(TMask_field& f, KEY k)
{
  if (f.to_check(k))
  {
    const int columns = get_int_val_param(0);
    const TString& val = f.get();
    if (val.len() < columns && real::is_natural(val))
    {             
      TString z(val);
      z.right_just(columns, '0');
      f.set(z);
    }
  }
  return true;
}

HIDDEN bool _alpha_val(TMask_field& f, KEY k)
{
  if (f.to_check(k))
  {
    const TString& s = f.get();
    for (int i = 0; s[i]; i++)
      if (!isalpha(s[i])) 
        return f.error_box(TR("Sono ammessi solo caratteri alfabetici"));
  }
  return true;
}

HIDDEN bool _not_empty_chkfld_val(TMask_field& f, KEY k)
{
  bool ok = true;
  if (f.to_check(k,true) && f.get().not_empty())
  {                         
    TBrowse * b = ((TEdit_field&)f).browse();
    if (b != NULL) ok = b->check(k == K_TAB ? RUNNING_CHECK : FINAL_CHECK);
  }
  return ok;
}

HIDDEN bool _sconto_val(TMask_field& f, KEY key)
{
  bool ok = true;
  
  if ( f.to_check( key ) )
  {
    const TString80 work(f.get());
    TString80 goodexp;
    // Elimina gli spazi molesti
  //  work.strip_spaces( );
    if (work.not_empty())
    {
      TString80 num;
      bool dec = false;      // Flag che indica se si attende l'inizio di un numero
      bool startnum = true;  // Flag che indica se siamo all'inizio di un numero   
      int errorchar = ' ';
      
      // Flag che indica se sono nella parte decimale di un numero
      for (const char * s  = (const char *)work; *s  && errorchar == ' '; s++)
      { 
        const char c = *s;
        switch(c)
        {
        case '+': 
        case '-':
          // Se ero in in numero ...
          if( !startnum )
            goodexp << num;
          // Inizia il nuovo numero
          num = (c == '-') ? "-" : "+";  
          startnum = true;
          dec = false;
          break;         
        case '0':  
        case '1':
        case '2':
        case '3':
        case '4':
        case '5':
        case '6':
        case '7':
        case '8':
        case '9':
          num << c;
          startnum = false;
          break;
        case '.':
        case ',':
          if(!dec)
          {
            if( startnum )
              num << '0';        // Se occorreva un numero ci metto lo 0
            num << '.';          // Interpreto la virgola come punto
            dec = true;       
            startnum = true;
          }
          else
            errorchar = c;        // Se siamo gi` nella parte decimale segnala un errore
          break;
        case ' ':
          break;
        default:
          errorchar = c;
          break;         
        }
      }
      // Controlla la validita`
      ok = errorchar == ' ';
      
      if (ok)
      {
        goodexp << num; // Assegna la nuova espressione formattata bene     
        f.set(goodexp);
      }
      else
        f.error_box(FR("Espressione di sconto non valida. Errore sul carattere %c"), errorchar);
    }
  }
  return ok;
}

HIDDEN bool _ora_val(TMask_field& f, KEY key)
{
  if ( f.to_check( key ) )
  {
    TString8 ora = f.get();
    if ( ora.full( ) || f.required( ) )
    {
      if ( isdigit( ora[ 0 ] ) )
      {
        if ( ora[ 2 ] != ':' )
        {
          if ( ora.len( ) > 4 )
            ora.overwrite( ":", 2 );
          else
            ora.insert( ":", 2 );            
        }
      }
      bool ok = ((isdigit(ora[0]))&&(isdigit(ora[1]))&&(isdigit(ora[3]))&&(isdigit(ora[4])));
      ok &= ((atoi(&(ora[0]))<24)&&(atoi(&(ora[3]))<60));
       if ( ok )
        f.set( ora );
      else  
        return f.error_box(TR("Ora errata o formato non valido"));
    }
  }
  return true;
}

int iban_check(const TString& b, TString& msg)
{
  if (b.len() < 5)
  {
    msg = TR("Lunghezza inferiore a 5 caratteri");
    return 2;
  }
  if (!isalpha(b[0]) || !isalpha(b[1]))
  {
    msg.format(FR("I primi due caratteri (%s) devono essere alfabetici"), (const char*)b.left(2));
    return 3;
  }
  if (!isdigit(b[2]) || !isdigit(b[3]))
  {
    msg.format(FR("I caratteri 3 e 4 (%s) devono essere numerici"), (const char*)b.mid(2,2));
    return 4;
  }

  TString80 s;
  s << b.mid(4) << b.left(4);

  int r = 0;
  for (int i = 0; s[i]; i++)
  {
    const char c = s[i];
    if (c >= '0' && c <= '9')
    {
      const int k = c - '0';
      r = (10 * r + k) % 97;
    } else
    if (c >= 'A' && c <= 'Z')
    {
      const int k = c - 'A' + 10;
      r = (100 * r + k) % 97;
    }
    else
    {
      msg.format(FR("Carattere non ammesso: '%c'"), c);
      return 5;
    }
  }

  if (r != 1)
  {
    msg = TR("Codice di controllo errato");
    return 1;
  }

  return 0;
}

int bban_check(const TString& b, TString& msg)
{
  const unsigned char dispari[26] = { 1,  0, 5, 7, 9, 13, 15, 17, 19, 21,  2,  4, 18,
                                     20, 11, 3, 6, 8, 12, 14, 16, 10, 22, 25, 24, 23 };
  if (b.len() != 23)
  {
    msg = TR("Lunghezza diversa da 23 caratteri");
    return 2;
  }
  if (b[0] < 'A' || b[0] > 'Z')
  {
    msg.format(FR("Il CIN deve essere una lettera maiuscola: '%c'"), b[0]);
    return 2;
  }
  for (int a = 1; a <= 10; a++)
  {
    if (!isdigit(b[a]))
    {
      msg = TR("ABI e CAB devono essere numerici");
      return 3;
    }
  }

  int s = 0, kcin = 0;
  for (int i = 0; b[i]; i++)
  {
    const char c = b[i];
    int k = 0;
    if (isdigit(c))
    {
      k = c - '0';
    } else
    if (c >= 'A' && c <= 'Z')
    {
      k = c - 'A';
    }
    else
    {
      msg.format(FR("Carattere non ammesso: '%c'"), c);
      return 4;
    }
    if (i == 0)
      kcin = k;
    else
    {
      if (i & 1) // dispari
        s += dispari[k];
      else
        s += k;
    }
  }

  if (s % 26 != kcin)
  {
    msg.format(TR("Codice di controlo (CIN) errato"));
    return 1; 
  }

  return 0;
}

HIDDEN bool _iban_val(TMask_field& f, KEY key)
{
  bool ok = true;

  if (key == K_TAB || key == K_ENTER)
  {
    TMask& m = f.mask();
    const int nparms = get_val_param_count();
    CHECKD(nparms == 8, "IBAN_CHECK deve avere 8 parametri: ", nparms);
    int id[8];
    for (int i = 0; i < 8; i++)
      id[i] = get_int_val_param(i);


    if (f.dlg() == id[1]) // Campo Stato IBAN
    {
      if (key == K_TAB && !f.focusdirty())
      {
        const TString& iban = m.get(id[0]);
        m.set(id[1], iban.left(2));
        m.set(id[2], iban.mid(2,2));
        m.set(id[3], iban.mid(4));
        m.set(id[4], iban.mid(4,1));
        m.set(id[5], iban.mid(5,5));
        m.set(id[6], iban.mid(10,5));
        m.set(id[7], iban.mid(15));
      }
      const bool italy = f.empty() || f.get() == "IT";
      m.show(id[3], !italy);
      m.show(id[4], italy);
      m.show(id[5], italy);
      m.show(id[6], italy);
      m.show(id[7], italy);
    }
    if (f.dlg() == id[2])
    {
      TString4 stato = m.get(id[1]);
      if (stato.empty()) 
        stato = "IT";
      const bool italy = stato=="IT";
      const bool do_test = !m.field(id[italy ? 7 : 3]).empty(); // Faccio il test solo in presenza di conto corrente
      TString80 iban;
      if (do_test)
      {
        if (f.empty()) // Cifra di controllo vuota
        {
          TString msg;
          TString80 iban;
          iban << stato << "@@";
          if (italy)
            iban << m.get(id[4]) << m.get(id[5]) << m.get(id[6]) << m.get(id[7]);
          else
            iban << m.get(id[3]);
            
          int err = 1;
          for (int pp = 0; pp <= 99 && err == 1; pp++)
          {
            msg.format("%02d", pp);
            iban.overwrite(msg, 2);
            err = iban_check(iban, msg);
            if (err == 0)
            {
              m.set(id[1], stato);
              m.set(id[2], pp);
              break;
            }
          }
        }

        iban << m.get(id[1]) << m.get(id[2]);
        if (italy)
          iban << m.get(id[4]) << m.get(id[5]) << m.get(id[6]) << m.get(id[7]);
        else
          iban << m.get(id[3]);

        TString msg;
        const int err = iban_check(iban, msg);
        if (err != 0)
        {
          msg.insert(TR("Codice IBAN errato:\n"));
          if (err > 1) // Errore grave
            ok = error_box(msg);
          else
          {
            msg << '\n' << TR("Si desidera continuare ugualmente?");
            ok = yesno_box(msg);
          }
        }
      }
      if (key == K_ENTER)
      {
        if (!ok) iban.cut(0);
        m.set(id[0], iban);
      }
    }
  }

  return ok;
}

HIDDEN bool _bban_val(TMask_field& f, KEY key)
{
  bool ok = true;

  if (!f.empty() && f.to_check(key))
  {
    TMask& m = f.mask();
    const int nparms = get_val_param_count();
    CHECKD(nparms == 5, "BBAN_CHECK deve avere 5 parametri: ", nparms);
    int id[5];
    for (int i = 0; i < 5; i++)
      id[i] = get_int_val_param(i);

    if (m.field(id[1]).empty()) // CIN vuoto
    {
      TString msg;
      TString80 bban;
      bban << "#" << m.get(id[2]) << m.get(id[3]) << m.get(id[4]);
      int err = 1;
      for (char cin = 'A'; cin <= 'Z' && err == 1; cin++)
      {
        bban[0] = cin;
        err = bban_check(bban, msg);
        if (err == 0)
        {
          m.set(id[1], bban.left(1));
          break;
        }
      }
    }


    if (f.dlg() == id[1] && key == K_ENTER)
    {
      TString80 bban;
      for (int i = 1; i < 5; i++)
        bban << m.get(id[i]);
      if (bban.len() > 11)
      {
        TString msg;
        const int err = bban_check(bban, msg);
        if (err != 0)
        {
          msg.insert(TR("Codice BBAN errato:\n"));
          if (err > 1) // Errore grave
            ok = error_box(msg);
          else
          {
            msg << '\n' << TR("Si desidera continuare ugualmente?");
            ok = yesno_box(msg);
          }
        }
      }
    }
  }

  return ok;
}

#define MAX_FUNC 26

HIDDEN VAL_FUNC _global_val_func[MAX_FUNC] = 
{
  _expr_val,                 // 0
  _emptycopy_val,
  _pi_val,
  _cf_val,
  _notempty_val,
  _date_cmp,                 // 5
  _xt_pi_val,
  _xt_cf_val,
  _xtz_pi_val,
  _xtz_cf_val,
  _fixlen_val,               // 10
  _mtcheck_val,
  _reqif_val,
  _autoexit_val,
  _numcalc_val,
  _strcalc_val,              // 15
  _onereq_val,
  _chkfld_val,
  _filename_val,
  _zerofill_val,
  _alpha_val,                // 20
  _not_empty_chkfld_val,
  _ora_val,
  _sconto_val,
  _iban_val,
  _bban_val,                 // 25
};

// @doc INTERNAL

// @func Effettua i controlli sui campi di una maschera
//
// @rdesc Ritorna se il controllo ha avuto successo:
//
// @flag true | Il campo e' positivo al controllo
// @flag false | Il campo non ha i requisiti necessari per passare il controllo
bool validate(
     int fn,      // @parm Numero della funzione da effettuare
     TMask_field& f,    // @parm Identificatore del campo da controllare
     KEY k,       // @parm Codice del tasto premuto sul campo
     const TString_array& parms) // @parm Array di parametri per effettuare il controllo
{                                                                
  _parms = &parms;
  return (fn >= 0 && fn < MAX_FUNC) ? _global_val_func[fn](f, k) : true;
}