#include <defmask.h>
#include "velib.h"
#include "vepriv.h"

#ifndef __PROGIND_H
#include <progind.h>
#endif

#ifndef __TABUTIL_H
#include <tabutil.h>

#ifndef __VERIG_H
#include "verig.h"
#endif

#ifndef __VEUML1_H
#include "veuml1.h"
#endif

#ifndef __VEINI_H
#include "veini.h"
#endif

#ifndef __SCONTI_H
#include "sconti.h"             
#endif

#ifndef __MGLIB_H 
#include "../mg/mglib.h"
#endif

#ifndef __DBLIB_H
#include "../db/dblib.h"             
#endif

#include "../mg/anamag.h"             
#include "../mg/codcorr.h"             
#include "../mg/deslin.h"             
#include "../mg/umart.h"             

bool ora_hndl( TMask_field& field, KEY key )

{
  if (field.to_check(key))
  {
    TFixed_string ora( field.get( ), 6 );
    
    ora.trim( );
    if (ora.not_empty() || field.required() )
    {
      if ( isdigit( ora[ 0 ] ) )
      {
        if ( ora[ 2 ] != ':')
        {
          if ( ora.len( ) > 4 )
            ora.overwrite( ":", 2 );
          else
            ora.insert( ":", 2 );            
        }
      }
      const bool ok = ((isdigit(ora[0]))&&(isdigit(ora[1]))&&(isdigit(ora[3]))&&(isdigit(ora[4]))) &&
                      ((atoi(&(ora[0]))<24)&&(atoi(&(ora[3]))<60));
      if (ok )
        field.set((ora));          
      else  
        return error_box("Ora errata o formato non valido");
    }
  }
  return TRUE;
}

bool dummy_hndl(TMask_field& field, KEY key)
{
  warning_box( "Al campo %d è arrivato un KEY %d", field.dlg( ), key );
  return TRUE;
}

// Handler per il calcolo delle date di pagamento
bool condpag_hndl( TMask_field& field, KEY key )
{                
  TDocumento_mask& m = (TDocumento_mask &) field.mask( );
  
  if ( field.to_check(key) || (key == K_TAB && !m.is_running()))
  {
    const TString16 condpag(m.get(F_CODPAG));
    TString16 data(m.get(F_DATAINSC));      
    
    if (data.empty())     
      data = m.get(F_DATADOC);      
    if ( condpag.not_empty())
    {
      TPagamento pag(condpag, data); 
      
      pag.set_total( 100, 10, 10 );
      pag.set_rate_auto( );      
      int numrate = pag.n_rate( );
      if (numrate > 5)
        numrate = 5;
      for( int i = 0; i < numrate; i ++ )
      {
        m.show( F_DATASCAD1 + i );
        m.set( F_DATASCAD1 + i, pag.data_rata(i).string());
      }
      for( ; i < 5; i ++ )
        m.hide( F_DATASCAD1 + i );
    }
  }
  return TRUE;
}

bool note_hndl( TMask_field& f, KEY key )
{             
  TDocumento_mask & m = (TDocumento_mask &) f.mask();

  if (key == K_TAB && (f.focusdirty() || !m.is_running()))
  {                         
    TTable & note = (TTable &) ((TEdit_field &) f).browse()->cursor()->file();
    note.setkey(1);
    const TString16 cod(f.get());
    
    if (cod != note.get("CODTAB"))
    {
      note.zero();
      note.put("CODTAB", cod);
      if (note.read() != NOERR)
        note.zero();
    }            
    if (m.doc().modificabile() || m.field(DLG_SAVEREC).enabled())
    {
      const bool reg_disabled = note.get_bool("B0");
      
      if (reg_disabled)
        message_box("Registrazione disbilitata : %s", (const char *) note.get("S0"));
      m.enable(DLG_SAVEREC, !reg_disabled);
    }
  }
  return TRUE;
}

// Handler per il calcolo delle date di pagamento
bool data_hndl( TMask_field& field, KEY key )
{                
  TDocumento_mask& m = (TDocumento_mask &) field.mask( );
  if (field.to_check(key))
  {                
    if (m.id2pos(F_DATAINSC) >= 0)
    {
      TEdit_field & e = m.efield(F_DATAINSC);
      e.set_dirty();
      e.on_hit();
    }

    if (m.id2pos(F_DATACAMBIO1) >= 0)
      m.set(F_DATACAMBIO1, field.get(), TRUE);
  }
  if (field.to_check(key,TRUE))
  {           
    const TCodice_numerazione codnum(m.get(F_CODNUM));
    if (codnum.dont_test_datadoc())
      return TRUE;

    TLocalisamfile doc(LF_DOC);           
    TDate datadoc(m.get(F_DATADOC));
    
    doc.curr() = m.doc().head(); 
    bool same_key = FALSE;
      
    doc.read();
    if (doc.eof() || doc.prev() == NOERR)
    {                       
      TDate dataprev = doc.get_date(DOC_DATADOC);
      same_key = doc.curr().same_key(m.doc().head(), 1, 1);
      if (!same_key)
      {
        TDate oggi(TODAY);
        dataprev = oggi;
      }
      
      if (!datadoc.ok())
      {
        datadoc = dataprev;
        field.set(dataprev.string());
      }

      if (same_key && datadoc < dataprev)
        return field.error_box("Data documento inferiore alla data del documento precedente");
    }
    
    doc.curr() = m.doc().head(); 
    doc.read(_isgreat);
    same_key = doc.curr().same_key(m.doc().head(), 1, 1);
    if (doc.good() && same_key && datadoc > doc.get_date(DOC_DATADOC))
      return field.error_box("Data documento superiore alla data del documento successivo"); 
  }
  return TRUE;
}
  
// handler delle righe

void row_set_handler( TMask& m, const int field, const int index )
{
  switch ( index )
  {
    case 1:
      m.set_handler( field, dummy_hndl );
      break;
    default:
      yesnofatal_box( FALSE, "Funzione di handler sulla riga non definita( %d ).", index );
  }
}
                                     
HIDDEN TString16 curr_um;                                                     
HIDDEN real curr_fc(1.0);

bool iva_handler( TMask_field& f, KEY key )
{   
  TDocumento_mask & mask = (TDocumento_mask &) f.mask().get_sheet()->mask();

  if (key == 0 || (key == K_ENTER && f.get().empty()))
  {
    const TString16 codiva = mask.condv().clifo().vendite().get(CFV_ASSFIS);

    if (codiva.not_empty())
      f.set(codiva);
    f.check();
  }

  if (key == K_ENTER && f.focusdirty() && f.get().empty())
  {
    TMask & row_mask = f.mask();
    const int r = f.mask().get_sheet()->selected() + 1;
    TRiga_documento& riga = mask.doc()[r];
    
    const int pos_ai = row_mask.id2pos(FR_ADDIVA);
    bool  addiva = FALSE;
    
    if (pos_ai >= 0)
      addiva = row_mask.fld(pos_ai).get() == "X"; // Controlla le righe Omaggio solo se e' settato l'addebito IVA
    
    const bool check = riga.is_merce() || riga.is_spese() || riga.is_prestazione() || 
                       (riga.is_omaggio() && addiva);
    
    if (check)
    {
      const int pos_p = row_mask.id2pos(FR_PREZZO);
      const int pos_q = row_mask.id2pos(FR_QTA);
      bool required = FALSE;
        
      if (pos_p >= 0)
        required |= row_mask.fld(pos_p).enabled() ? row_mask.fld(pos_p).get().not_empty() : FALSE;
      if (pos_q >= 0)
        required |= row_mask.fld(pos_q).enabled() ? row_mask.fld(pos_q).get().not_empty() : FALSE;
        
      if (required)
        return f.error_box("Il codice IVA e' obbligatorio se quantita' e prezzo sono indicati.");
    }
  }
  return TRUE;
}
                                       
bool codmag_handler( TMask_field& f, KEY key )
{
  if (f.to_check(key, TRUE))
  {        
    TMask& row_mask = f.mask();    
    
    if (row_mask.get_sheet()->column_enabled( ((TSheet_field &)f).cid2index(FR_CODDEP)))
    {  
      const int pos = row_mask.id2pos(FR_CODDEP);
      const TString & val = f.get();
                                                                                  
      if (pos >= 0 && val.not_empty())                                                               
      {
        TTable & mag = (TTable &)((TEdit_field &) f).browse()->cursor()->file();
        const TString &codmag = mag.get("CODTAB");
        if (codmag != val)
        {
          mag.put("CODTAB", val);
          if (mag.read() != NOERR)
            mag.zero();
        }
        const bool active = mag.get_bool("B0");
        row_mask.fld(pos).enable(active);                              
        if (!active)
          row_mask.fld(pos).reset();                              
      }
    }
  }
  return TRUE;
}             

bool codmag_coll_handler( TMask_field& f, KEY key )
{
  if (f.to_check(key, TRUE))
  {        
    TMask& row_mask = f.mask();    
    
    if (row_mask.get_sheet()->column_enabled( ((TSheet_field &)f).cid2index(FR_CODDEPC)))
    {  
      const int pos = row_mask.id2pos(FR_CODDEPC);
      const TString & val = f.get();
                                                                                  
      if (pos >= 0 && val.not_empty())                                                               
      {
        TTable & mag = (TTable &)((TEdit_field &) f).browse()->cursor()->file();
        const TString &codmag = mag.get("CODTAB");
        if (codmag != val)
        {
          mag.put("CODTAB", val);
          if (mag.read() != NOERR)
            mag.zero();
        }
        const bool active = mag.get_bool("B0");
        row_mask.fld(pos).enable(active);                              
        if (!active)
          row_mask.fld(pos).reset();                              
      }
    }
  }
  return TRUE;
}             

bool codart_handler( TMask_field& f, KEY key )
{
  TMask& row_mask = f.mask();   
  TDocumento_mask & mask = (TDocumento_mask &) row_mask.get_sheet()->mask();
  TSheet_field & sh = (TSheet_field &)mask.field(F_SHEET);
  const int current_doc_row = sh.selected() + 1;      
              
  if (f.to_check(key, TRUE))
  { 
    if (f.get().not_empty())
        row_mask.enable(FR_LIV1);
    else
    {
      row_mask.reset(FR_LIV1);
      row_mask.disable(FR_LIV1);
    }    
    row_mask.field(FR_LIV1).on_hit();
  }
  
  if (key == K_TAB && (f.focusdirty() || row_mask.get(FR_CHECKED).empty()))
  {            
    TCond_vendita & condv = mask.condv();
    
    condv.set_testa(&mask);
    condv.set_riga(&row_mask);

    TLocalisamfile & anamag = ((TEdit_field &) f).browse()->cursor()->file();
    TLocalisamfile & umart  = ((TEdit_field &) row_mask.field(FR_UMQTA)).browse()->cursor()->file();
    
//    condv.set_anamag(anamag);
//    condv.set_umart(umart);
    
    TString80 codart(f.get());   
    anamag.setkey(1);
    anamag.put(ANAMAG_CODART, codart);
    bool found = anamag.read() == NOERR;
    if (found)
      row_mask.set(FR_CODARTMAG, codart, TRUE);
    else
    {
      TLocalisamfile codalt(LF_CODCORR);
      
      codalt.setkey(2);
      codalt.put(CODCORR_CODARTALT, codart);
      if (codalt.read() == NOERR)
      {                              
        codart = codalt.get(CODCORR_CODART);
        anamag.zero();
        anamag.put(ANAMAG_CODART, codart);
        found = anamag.read() == NOERR;
        if (found)
          row_mask.set(FR_CODARTMAG, codart, TRUE);
      }
    }     
    row_mask.set(FR_CHECKED, "X");
    if (!found)
        row_mask.set(FR_CODARTMAG, "", TRUE);
    else
    {
      const TString16 lingua = mask.get(F_CODLIN);                              
      const TString codart(row_mask.get(FR_CODARTMAG));
      TString desc(anamag.get("DESCR"));
      
      if (mask.doc()[current_doc_row].is_omaggio())  
        desc << " (OMAGGIO)";
      if (lingua.not_empty())
      {
        if (mask.doc()[((TSheet_field &)mask.field(F_SHEET)).selected() + 1].is_omaggio())  
          desc << " (OMAGGIO)";
        TLocalisamfile deslin(LF_DESLIN);
        
        deslin.setkey(2);
        deslin.put(DESLIN_CODART, codart);
        deslin.put(DESLIN_CODLIN, lingua);
        if (deslin.read() == NOERR)
          desc << '\n' << deslin.get(DESLIN_DESCR);
      }                        

      TString descest(anamag.get("DESCRAGG"));
      if (descest.not_empty())
        desc << "\n" << descest;
      
      row_mask.set(FR_DESCR, desc);
                                     
      umart.setkey(1);              
      umart.zero(); 
      umart.put(UMART_CODART, codart);
      if (umart.read(_isgteq) == NOERR && codart == umart.get(UMART_CODART))
      {
        curr_um = umart.get(UMART_UM);       
        curr_fc = umart.get_real(UMART_FC);
      }
      else
      {
        curr_um.cut(0);                  
        curr_fc = 1.0;
      }
      row_mask.set(FR_UMQTA, curr_um);
    }

    condv.ricerca();
    const int pos = row_mask.id2pos(FR_CODIVA);

    if (pos >= 0)
      iva_handler(row_mask.fld(pos), 0);
  }
  
  if (key == K_F8 && !sh.sheet_mask().is_running())
  {
    TConfig d(CONFIG_DITTA, "ve");      
    const bool explode_db = d.get_bool("EXPLODEDB");
    const bool valcomp = d.get_bool("VALCOMP");
    const bool matbase = d.get_bool("TIPOESPL");
    const bool raggart = d.get_bool("RAGGART");
    const bool elrorig = d.get_bool("ELRORIG");
    const int livello = d.get_int("LIVESPL");
    const int ordin = d.get_int("ORDDB");
    if (explode_db)
    {                  
      TCodice_articolo a(f.get());
      TDistinta_tree db;     
      TArray components;
      
      db.set_root(a);       
      
      const int items = db.explode(components, matbase, (int)raggart, livello, "A", ordin);
      if (items > 0)
      { 
        TProgind pi(items, "Esplosione in corso...",FALSE, TRUE);
        int row = current_doc_row;
        TDocumento & doc = mask.doc();
        TRiga_documento & curr_row = doc[current_doc_row];  
        const TString16 tiporiga(curr_row.tipo().codice());
    
        sh.update_row(current_doc_row - 1);
        curr_row.autosave(sh);                                                      
        real qta_fin = curr_row.get_real(RDOC_QTA);
        
        TString_array& str_arr = sh.rows_array();
        
        for (int i = components.first(); i < items; i = components.succ(i))
        {
          pi.addstatus(1L);
          TRiga_esplosione & r = (TRiga_esplosione &) components[i];
          TRiga_documento & new_row = doc.insert_row(row + 1, tiporiga);
          //sh.insert(row, FALSE);                 
          str_arr.add("",row);
          
          TDocumento::copy_data(new_row, curr_row);
          new_row.put(RDOC_CODART, r.articolo());
          new_row.put(RDOC_CODARTMAG, r.articolo());
          new_row.zero(RDOC_DESCR);
          new_row.put(RDOC_DESCLUNGA, "X");
          new_row.zero(RDOC_DESCEST);
          new_row.put(RDOC_CHECKED, "");
          new_row.put(RDOC_UMQTA, r.um());
          new_row.put(RDOC_QTA, r.val() * qta_fin);
          new_row.autoload(sh);
          sh.check_row(row++);
          new_row.autosave(sh);
          if (!valcomp)
          {
            new_row.zero(RDOC_PREZZO);
            new_row.autoload(sh);
          }
        }                          
        if (elrorig)
        {
          doc.destroy_row(current_doc_row, TRUE);
          sh.destroy(current_doc_row - 1, FALSE);    
          row--;
        }
        else
          if (valcomp)
          {
            curr_row.zero(RDOC_PREZZO);
            curr_row.autoload(sh);
          }
        sh.force_update();  
        sh.select(row-1);
      }
    }
  }
  return TRUE;
}                           

bool codartmag_handler( TMask_field& f, KEY key )
{                  
  bool to_check = key == K_TAB && f.focusdirty();
  TMask & m = f.mask(); 

  if (!to_check)
  {
    TSheet_field * s = m.get_sheet();
    
    if (s)
      to_check = !s->mask().is_running();
  }
  if (to_check)
  {                            
    const bool artmag = f.get().not_empty();
    
    m.show(FR_UMQTA, artmag);
    m.show(FR_UMQTA2, !artmag);
  }
  return TRUE;
}

bool liv_handler( TMask_field& f, KEY key )
{
  if (key == K_TAB & f.focusdirty() && !f.get().empty()) 
  {
    TDocumento_mask & mask=(TDocumento_mask &) f.mask().get_sheet()->mask();
    const int levnum=f.dlg()-FR_LIV1+1;
    // Se e' abilitato l'autoinserimento del livello di giacenza...
    if (mask.livelli().autoinsert(levnum))
      mask.livelli().autoinsert(levnum, f);
  }
  
  if (f.to_check(key, TRUE))
  {
    TMask& row_mask = f.mask();   
    TMask_field & next = row_mask.field(f.dlg() + 1);
    if (f.get().not_empty())
      next.enable();
    else
    {
      next.reset();
      next.disable();
    }                    
    next.on_hit();
  }
  return TRUE;
}  

void set_curr_um(const TMask & m)
{                
  curr_um = m.get(FR_UMQTA);
  curr_fc = -1.0;
}

bool umart_handler( TMask_field& f, KEY key )
{
  // Se qualcuno cerca di modificare la maschera
  if ( key == K_TAB && f.focusdirty())
  { 
    TMask& row_mask = f.mask( );               
    TDocumento_mask & mask = (TDocumento_mask &) row_mask.get_sheet()->mask();
    TLocalisamfile & anamag = ((TEdit_field &) row_mask.field(FR_CODART)).browse()->cursor()->file();
    TLocalisamfile & umart  = ((TEdit_field &) f).browse()->cursor()->file();
    TCond_vendita & condv = mask.condv();
    
//    condv.set_testa(&mask);
    condv.set_riga(&row_mask);
//    condv.set_anamag(anamag);
//    condv.set_umart(umart);

    const TString16 um(f.get());
    real fc(1.0);
    
    if (um.not_empty() && curr_um.not_empty() && um != curr_um)
    {           
      umart.setkey(2);                               
      umart.put(UMART_CODART, row_mask.get(FR_CODARTMAG));
      umart.put(UMART_UM, um);
      if (umart.read() == NOERR)
      {
        real qta(row_mask.get_real(FR_QTA));
        fc = umart.get_real(UMART_FC);
        if (curr_fc < ZERO)
        {
          umart.put(UMART_CODART, row_mask.get(FR_CODARTMAG));
          umart.put(UMART_UM, curr_um);
          if (umart.read() == NOERR)
            curr_fc = umart.get_real(UMART_FC);
          else
            curr_fc = 1.0;
        }
        qta *= curr_fc;          
        qta /= fc;
        qta.round(5);
        row_mask.set(FR_QTA, qta);
      }
        
    }
    curr_um = um;
    curr_fc = fc;
    condv.ricerca(TRUE);
  }   
  return TRUE;
}

bool descr_handler( TMask_field& f, KEY key )
{
  if (key == K_TAB && f.focusdirty())
  {            
    const TString s(f.get());
    if (s.find('\n') < 0)
    {
      TLocalisamfile & anamag = ((TEdit_field &) f).browse()->cursor()->file();
      
      anamag.zero();
      anamag.setkey(2);
      anamag.put(ANAMAG_DESCR, ((TZoom_field &) f).get_first_line());
      if (anamag.read() == NOERR)
      {                         
        f.mask().set(FR_CODART, anamag.get(ANAMAG_CODART));
        f.mask().field(FR_CODART).set_dirty();
        f.mask().check_field(FR_CODART);
      }
    }
  }       
  return TRUE;
}

bool qta_handler( TMask_field& f, KEY key )
{                   
  // Se qualcuno cerca di modificare la maschera
  if ( key == K_TAB && f.focusdirty())
  { 
    TMask& row_mask = f.mask( );               
    TDocumento_mask & mask = (TDocumento_mask &) row_mask.get_sheet()->mask();
//    TLocalisamfile & anamag = ((TEdit_field &) row_mask.field(FR_CODART)).browse()->cursor()->file();
//    TLocalisamfile & umart  = ((TEdit_field &) row_mask.field(FR_UMQTA)).browse()->cursor()->file();
    TCond_vendita & condv = mask.condv();
    
//    condv.set_testa(&mask);
    condv.set_riga(&row_mask);
//    condv.set_anamag(anamag);
//    condv.set_umart(umart);
    condv.ricerca(FALSE, TRUE);
    return qta_handler(f, key);
  } 
  return TRUE;
}
  
bool qta_handler( TMask_field& f, KEY key )
{                   
  // Se qualcuno cerca di modificare la maschera
  if ( key == K_TAB && f.focusdirty())
  { 
    TMask& row_mask = f.mask( );               
    const real qta_evasa = row_mask.get_real(FR_QTAEVASA);
    const real qta(f.get());

    if (qta_evasa > 0 && qta_evasa >= qta)
    {
      row_mask.set(FR_RIGAEVASA, "X");
      row_mask.disable(FR_RIGAEVASA);
    }
    else
      row_mask.enable(FR_RIGAEVASA);
  } 
  return TRUE;
}
  
bool qta_evasa_handler( TMask_field& f, KEY key )
{                   
  if (f.to_check(key))
  {
    TMask& row_mask = f.mask( );               
    const real qta_evasa(f.get());
    const real qta = row_mask.get_real(FR_QTA);

    if (qta_evasa > 0 && qta_evasa >= qta)
    {
      row_mask.set(FR_RIGAEVASA, "X");
      row_mask.disable(FR_RIGAEVASA);
    }
    else
      row_mask.enable(FR_RIGAEVASA);
  } 
  return TRUE;
}
   
bool sppr_handler( TMask_field& f, KEY key )
{ 
  TMask& row_mask = f.mask();               
  
  if (key == K_TAB && (f.focusdirty() || row_mask.get(FR_DESCR).empty()))
  {                  
    const int pos = row_mask.id2pos(FR_PREZZO);
    
    if (pos >= 0)
    {
      TMask & mask = row_mask.get_sheet()->mask();
      TRectype & spprrec = ((TEdit_field &) row_mask.field(FR_CODART)).browse()->cursor()->file().curr();
      
      if (spprrec.get("CODTAB") == row_mask.get(FR_CODART))
      {                
        const char  tipo = spprrec.get_char("S6");         
        const bool qta_val_fl = tipo == 'Q';
        const bool perc_fl = tipo == 'P';

        short pos = row_mask.id2pos(FR_UMQTASP);
        if (pos >= 0)
          row_mask.fld(pos).enable(!perc_fl);
        pos = row_mask.id2pos(FR_PREZZO);
        if (pos >= 0)
          row_mask.fld(pos).enable(!perc_fl);
        pos = row_mask.id2pos(FR_SCONTO);
        if (pos >= 0)
          row_mask.fld(pos).enable(!perc_fl);
        pos = row_mask.id2pos(FR_QTA);
        if (pos >= 0)
        {                                    
          row_mask.fld(pos).show(!perc_fl);
          row_mask.fld(pos).enable(qta_val_fl);
        }  
        pos = row_mask.id2pos(FR_PERCSP);
        if (pos >= 0)
        {                                    
          row_mask.fld(pos).show(perc_fl);
          row_mask.fld(pos).enable(perc_fl);
        }  
        
        if (!perc_fl)
        {
          const real cambio = mask.get(F_CAMBIO);
          real prezzo = row_mask.get(FR_PREZZO);
          const TString16 doc_valuta(mask.get(F_CODVAL));
          sppr_calc(spprrec, doc_valuta, cambio, prezzo);
          row_mask.set(FR_PREZZO, prezzo);          
          
        }
        const int posiva = row_mask.id2pos(FR_CODIVA);
        
        if (posiva >= 0)
          iva_handler(row_mask.fld(posiva), 0);
      }
    }
  } 
  return TRUE;
}