#include <applicat.h>
#include <tabutil.h>

#include "cg2103.h"

#include <causali.h>
#include <rcausali.h>

const char* iva2name(TipoIVA iva)
{
  const char* i;
  switch(iva)
  {
  case nessuna_iva: 
    i = "Nessuna IVA"; break;
  case iva_acquisti: 
    i = "IVA Acquisti"; break;
  case iva_vendite: 
    i = "IVA Vendite"; break;
  case iva_generica: 
    i = "IVA Generica"; break;
  default: 
    i = "IVA ERRATA!"; break;
  }
  return i;
}

///////////////////////////////////////////////////////////
// Registro
///////////////////////////////////////////////////////////

TRegistro::TRegistro(const char* cod, int year) : _rec(LF_TAB), _att(LF_ATTIV)
{
  read(cod, year);
}


bool TRegistro::read(const char* cod, int year)
{               
  if (year <= 0) 
  {
    const TDate oggi(TODAY);
    year = oggi.year();
  }

  int err = ~NOERR;
  
  TTable reg("REG");
  if (cod && *cod > ' ')
  {
    TString16 chiave; chiave.format("%04d%s", year, cod);
    reg.put("CODTAB", chiave);
    err = reg.read(); 
  }
  _rec = reg.curr();
  
  if (_att.ok())  
    _att.zero();
  if (err != NOERR)
    _rec.zero();
  _prorata = -1.0;

  return err == NOERR;
}           

bool TRegistro::reread()
{
  if (ok()) 
  {
    const TString16 n(name());
    const int y = year();
    return read(n, y);
  }  
  return FALSE;
}              

int TRegistro::year() const 
{                
  int anno = 0;
  if (ok())
  { 
    TString16 sanno(_rec.get("CODTAB")); sanno.cut(4);
    anno = atoi(sanno);
  } 
  return anno;
}   


static TString16 n;
const TString& TRegistro::name() const 
{ 
  if (ok()) n = _rec.get("CODTAB").mid(4); 
  else n = "";
  return n;
}


TRegistro& TRegistro::operator =(const TRegistro& r)
{ 
  _rec = r._rec; 
  _att = r._att;
  _prorata = r._prorata;
  return *this;
}


int TRegistro::tipo() const
{
  const int t = ok() ? _rec.get_int("I0") : 0;
  return t;
}


bool TRegistro::corrispettivi() const
{
  const bool c = ok() ? _rec.get_bool("B0") : FALSE;
  return c;
}


TipoIVA TRegistro::iva() const
{ 
  TipoIVA i = (TipoIVA)tipo();
  switch (i)
  {
  case nessuna_iva:
  case iva_vendite:
  case iva_acquisti:
    break;
  case libro_giornale:
    i = nessuna_iva;
    break;
  default:  
    error_box("Il registro '%s' non e' un registro IVA o contabile: tipo %d", 
              (const char*)name(), i);
    i = nessuna_iva;
    break;
  }
  return i;     
} 

bool TRegistro::read_att()
{ 
  if (!_att.empty()) 
    return TRUE;

  TLocalisamfile attiv(LF_ATTIV);
  attiv.put("CODDITTA", main_app().get_firm());
  attiv.put("CODATT", attivita());
  const int err = attiv.read();
  _att = attiv.curr();
  if (err != NOERR)
    _att.zero();
  
  return err == NOERR;
}

bool TRegistro::agenzia_viaggi()
{                             
  bool av = FALSE;
  if (iva() == iva_vendite && read_att()) 
    av = _att.get_bool("REG74TER");
  return av;
}

const TString& TRegistro::tipo_attivita()
{
  read_att();
  return _att.get("TIPOATT");
}

const real& TRegistro::prorata()
{ 
  if (_prorata.sign() < 0)
  {
    TString16 chiave;        // Anno - Attivita' - Tipo Attivita' (fissata a 1)
    chiave << year(); 
    chiave << attivita() << "1";
    
    TTable pla("PLA");
    pla.put("CODTAB", chiave);
    if (pla.read() == NOERR)
      _prorata = pla.get_real("R8");
    else  
      _prorata = 0.0;  
  }
  
  return _prorata;
}

// Certified 99%                       
bool TRegistro::update(long protiva, const TDate& datareg)
{ 
  bool updated = TRUE;
  
  if (protiva > _rec.get_long("I5"))
  {
    _rec.put("I5", protiva);
    updated = FALSE;
  }  
  if (datareg > _rec.get_date("D2"))
  {
    _rec.put("D2", datareg);
    updated = FALSE;
  }  
  if (!updated)
  { 
    TTable reg("REG");
    updated = reg.rewrite(_rec) == NOERR;
  }  
  
  return updated;
}

///////////////////////////////////////////////////////////
// Libro giornale
///////////////////////////////////////////////////////////

// Legge il libro giornale dell'anno specificato
bool TLibro_giornale::read(int y)
{
  if (y <= 0) 
  {
    const TDate oggi(TODAY);
    y = oggi.year();
  }
  
  TTable reg("REG");
  bool found = FALSE;                 
  
  TString16 anno; anno.format("%04d", y);
  
  reg.setkey(1);                                  
  reg.put("CODTAB", anno);                    // Cerca il primo registro dell'anno y
  
  for (int err = reg.read(_isgteq); err == NOERR; err = reg.next())
  {
    if (strncmp(reg.get("CODTAB"), anno, 4) != 0) break;
    if (reg.get_int("I0") == libro_giornale)
    {       
      found = TRUE;
      break;
    }  
  }
  
  if (!found) reg.zero();                     // Memorizza record (anche vuoto)
  _rec = reg.curr();
  
  return found;
}

/* Now obsolete
   TDate TLibro_giornale::global_last_print() const
   {
   TTable reg("REG");
   reg.setkey(1);                                  

   TDate last(botime);
   for (int err = reg.first(); err == NOERR; err = reg.next())
   {
   if (reg.get_int("I0") == libro_giornale)
   {       
   const TDate l(reg.get("D3"));
   if (l > last) last = l;
   }  
   }
   return last;
   } 
   */

TLibro_giornale::TLibro_giornale(int y)
{
  read(y);
}

///////////////////////////////////////////////////////////
// Causale
///////////////////////////////////////////////////////////

TCausale::TCausale(const char* cod, int year) 
: TArray(12), _rec(LF_CAUSALI), _iva(iva_errata), 
  _sezione_clifo(' '), _sezione_ritsoc(' '), _corrisp(FALSE)
{
  if (*cod) read(cod, year);
}


// Legge le righe della causale attualmente selezionata sulla maschera
bool TCausale::read(const char* cod, int year)
{
  TLocalisamfile caus(LF_CAUSALI);
  
  _rec = caus.curr(); _rec.zero();                    // Delete header
  destroy();                                          // Delete all rows
  _iva = iva_errata;                                  // Delete misc info
  _sezione_clifo = _sezione_ritsoc = ' ';
  _corrisp = FALSE;

  if (*cod > ' ')
  {
    caus.setkey(1);
    caus.zero();
    caus.put(CAU_CODCAUS, cod);

    int err = caus.read();
    if (err != NOERR) return FALSE;
    _rec = caus.curr();
    
    TLocalisamfile rcaus(LF_RCAUSALI);                        
    rcaus.setkey(1);
    rcaus.zero();
    rcaus.put(CAU_CODCAUS, cod);
    rcaus.put(CAU_NRIGA, 0);          
    
    for (err = rcaus.read(_isgteq);                       // Find first line
         err == NOERR && rcaus.get(CAU_CODCAUS) == cod;
         err = rcaus.next()                               // Read next line
         )
    {
      const int riga = rcaus.get_int(CAU_NRIGA);
      add(rcaus.curr(), riga);
      
    } 
    rcaus.zero();                                      
    for (int riga = 1; riga < size(); riga++)          // Fill gaps
      if (objptr(riga) == NULL) add(rcaus.curr(), riga);

    TString16 codreg(caus.get("REG"));
    const bool ok = _reg.read(codreg, year);         // Read register
    if (!ok && codreg.not_empty()) 
      return error_box("Non esiste il registro '%s' per l'anno %d", 
                       (const char*)codreg, year);
  }
  else 
  {
    _iva = nessuna_iva;                                // Clear IVA data
    _corrisp = FALSE;
    _reg.read("", year);
  }                            

  return TRUE;
}


const TRectype& TCausale::row(int num) const
{
  const TRectype* rec = (const TRectype*)objptr(num);
  CHECKD(rec, "Manca la riga di causale ", num);
  return *rec;
}


TBill& TCausale::bill(int num, TBill& conto) const
{
  const TRectype* rec = (const TRectype*)objptr(num);
  if (rec != NULL)
    conto.set(rec->get_int(RCA_GRUPPO), rec->get_int(RCA_CONTO),
              rec->get_long(RCA_SOTTOCONTO), rec->get_char(RCA_TIPOCF));
  return conto;
}   

const char* TCausale::desc_agg(int num) const
{
  const TRectype& rec = row(num);
  TString16 cod(rec.get(RCA_CODDESC));
  
  TTable da("%DPN");
  da.put("CODTAB", cod);
  if (da.read() != NOERR)
    da.zero();
  return da.get("S0");
}   

const char* TCausale::descrizione() const
{ return _rec.ok() ? _rec.get(CAU_DESCR) : ""; }

const char* TCausale::codice() const
{ return _rec.ok() ? _rec.get(CAU_CODCAUS) : ""; }


bool TCausale::data_doc() const 
{ return _rec.ok() ? _rec.get_bool("DATADOC") : FALSE; }

bool TCausale::num_doc() const 
{ return _rec.ok() ? _rec.get_bool("NUMDOC") : FALSE; }

bool TCausale::apertura() const 
{ return _rec.ok() ? _rec.get_char("MOVAP") == 'A' : FALSE; }

bool TCausale::sezionale() const 
{ return _rec.ok() ? _rec.get_bool("MOVSEZ") : FALSE; }

bool TCausale::valuta() const 
{ return _rec.ok() ? _rec.get_bool("MOVVAL") : FALSE; }

bool TCausale::intra() const 
{ return _rec.ok() ? _rec.get_bool("INTRACOM") : FALSE; }

bool TCausale::valintra() const 
{ return _rec.ok() ? _rec.get_bool("VALINTRA") : FALSE; }

const char* TCausale::causale_inc_imm() const 
{ return _rec.ok() ? _rec.get("CODCAUSIM") : ""; }

const char* TCausale::tipo_doc() const 
{ return _rec.ok() ? _rec.get("TIPODOC") : ""; }

bool TCausale::saldaconto() const
{ return _rec.ok() ? (_rec.get_int("TIPOMOV") > 0) : FALSE; }

bool TCausale::ok() const
{
  if (iva() == iva_errata) 
    return FALSE;
  
  if (corrispettivi() != reg().corrispettivi())
    return error_box("Tipo documento e registro incongruenti per i corrispettivi");
  
  return TRUE;  
}

char TCausale::sezione(int riga) const
{
  const TRectype& r = row(riga);
  char sez = toupper(r.get_char(RCA_SEZIONE));
  if (sez <= ' ')                                  // Guess section on tipocf
  {
    char tipocf = toupper(row(1).get_char(RCA_TIPOCF));
    if (tipocf <= ' ') 
      tipocf = (iva() == iva_vendite) ? 'C' : 'F'; // Guess tipocf on IVA
    sez = (tipocf == 'C') ? 'D' : 'A';
  }  
  return sez;
}

char TCausale::sezione_clifo()
{
  if (_sezione_clifo == ' ')
    _sezione_clifo = sezione(1);
  return _sezione_clifo;
}

char TCausale::sezione_ritsoc()
{
  if (_sezione_ritsoc == ' ')
    _sezione_ritsoc = sezione(9);
  return _sezione_ritsoc;
}

TipoIVA TCausale::iva() const
{
  if (_iva == iva_errata)
  {      
    TipoIVA i = nessuna_iva;                          // Tipo IVA di default
    bool c = FALSE;                                   // Corrispettivi di default
    
    TString16 tipodoc(_rec.get("TIPODOC"));
    if (tipodoc.not_empty())
    {
      TTable tpd("%TPD");
      tpd.put("CODTAB", tipodoc);
      if (tpd.read() == NOERR)
      {
        i = (TipoIVA)tpd.get_int("I0");               // IVA acquisti, vendite, generica
        const TipoIVA ri = _reg.iva();
        if (i == iva_generica)
          i = ri;
        if (i != ri) 
        {
          error_box("Tipo documento incompatibile con tipo registro");
          i = iva_errata;
        }  
        c = tpd.get_bool("B0"); 
      }
    }
    ((TCausale*)this)->_iva = i;                        // Ricorda IVA per la prossima volta
    ((TCausale*)this)->_corrisp = c;                    // Ricorda flag per la prossima volta
  }
  return _iva;  
}  

bool TCausale::corrispettivi() const
{
  if (_iva == iva_errata) iva();
  return _corrisp;
}

bool TCausale::similar(const TCausale& c) const
{                                         
  const char* err = "";
  if (sezionale() != c.sezionale()) err = "il segnale di sezionale";
  if (intra() != c.intra()) err = "la gestione dei movimenti intra";
  if (valuta() != c.valuta()) err = "la gestione valuta";
  if (corrispettivi() != c.corrispettivi()) err = "la gestione dei corrispettivi";
  if (iva() != c.iva()) err = "il tipo di IVA";
  
  if (*err)  
    error_box("La causale e' diversa per %s", err);
  
  return *err ? FALSE : TRUE;
}

///////////////////////////////////////////////////////////
// Codice IVA
///////////////////////////////////////////////////////////

TCodiceIVA::TCodiceIVA(const char* cod) : TRectype(LF_TABCOM)
{
  read(cod);
}                 

bool TCodiceIVA::read(const char* cod)
{   
  int err = ~NOERR;
  TTable iva("%IVA");
  if (cod && *cod)
  {
    iva.setkey(1);
    iva.put("CODTAB", cod);
    err = iva.read();
  }   
  TRectype::operator=(iva.curr());
  if (err != NOERR) zero();
  return err == NOERR;
}               


///////////////////////////////////////////////////////////
// Importo
///////////////////////////////////////////////////////////

const TImporto& TImporto::add_to(TToken_string& s) const
{       
  const bool dare = sezione() == 'D';
  const char* v = valore().string();
  s.add(dare ? v : "", 0);
  s.add(dare ? "" : v, 1);
  return *this;
}

// Cerified 99%
// Ambigous section for ZERO
const TImporto& TImporto::operator =(TToken_string& sv)
{
  _valore = real(sv.get(0));
  if (_valore == ZERO)
  {
    _valore = real(sv.get());
    _sezione = 'A';
  }  
  else
    _sezione = 'D';
  return *this;
}


const TImporto& TImporto::set(char s, const real& v)
{
  CHECKD(s == 'D' || s == 'A', "Sezione errata per importo: codice ", (int)s);
  _sezione = s; _valore = v;
  return *this;
}


const TImporto& TImporto::operator += (const TImporto& i)
{                           
  if (_sezione == i._sezione)
    _valore += i._valore;
  else
    _valore -= i._valore;
  return *this;  
}


const TImporto& TImporto::operator -= (const TImporto& i)
{
  if (_sezione == i._sezione)
    _valore -= i._valore;
  else
    _valore += i._valore;
  return *this;  
}

const TImporto& TImporto::swap_section()
{
  _sezione = (_sezione == 'D') ? 'A' : 'D';
  return *this;
}

