#include "ef0301.h"    

///////////////////////////////////////////////////
// Definizione dei metodi della classe TDistinta // 
///////////////////////////////////////////////////

// costruttore distinta utilizzando il record passato
TDistinta::TDistinta(const TRectype& rec, word lockop)
{      
 read(rec,lockop);                           
}

// costruisce la distinta del tipo e numero passati
TDistinta::TDistinta(const char tipo, const long numero, word lockop)
{      
  read(tipo,numero,lockop);                           
}

TDistinta::~TDistinta()
{
  TLocalisamfile f(LF_EFFETTI);
  if (_righe_dist.items() > 0) // Se ha letto elementi sblocca eventualmente la prima riga
    f.read((TRectype&)_righe_dist[0], _isequal,_unlock);
}

// permette di leggere la distinta del tipo e numero passati 
int TDistinta::read(const char tipo, const long numero, word lockop)
{ 
  int err = _iskeynotfound;
  TLocalisamfile f(LF_EFFETTI); f.setkey(4);
  if (_righe_dist.items() > 0) // Se ha letto una distinta precedente, sblocca la prima riga
  {
    f.read((TRectype&)_righe_dist[0],_isequal,_unlock);
    _righe_dist.destroy(); // Rimuove tutte le righe precedenti
  }
  if (tipo >= ' ' && numero > 0)
  {
    err = NOERR;
    for (int i = 1; err == NOERR ; i++)
    {
      TEffetto* effetto = new TEffetto; 
      word lock = (i == 1 && lockop == _lock) ? _lock : _nolock; // Lock solo sulla prima riga
      err = effetto->read(f, tipo, numero, i, lock);//legge un effetto per chiave 4
      if (err == NOERR)
        _righe_dist.add(effetto);
      else
        delete effetto;  
    }
  }  
  // se ho letto degli effetti della distinta ed ho 
  // trovato la fine file elimino l'errore 
  if ((_righe_dist.items()>0)||(err == _iseof) )
    err = NOERR;                                
  return err;
}
 
// permette di leggere la distinta dal record passato    
int TDistinta::read(const TRectype& rec, word lockop)
{ 
  CHECK(rec.num() == LF_EFFETTI,"Can't read distinta from a different record type");
  const char tipo = rec.get_char(EFF_TIPODIST);
  const long numero = rec.get_long(EFF_NDIST);
  return read(tipo,numero,lockop);//legge la distinta
} 

// scrive la distinta
int TDistinta::write(bool force, TToken_string* dati_dist)
{ 
  int err = NOERR;
  //quanti effetti sono nella distinta (nell'array in memoria)
  const int elem = items(); 
  TLocalisamfile f(LF_EFFETTI); f.setkey(4);

  for (int i=0; i<elem && err==NOERR; i++)
  {
    TEffetto& effetto = eff(i);
    // token string che contiene i dati da registrare sull'effetto 
    if (dati_dist)
    {
      dati_dist->restart();
      effetto.put(EFF_TIPODIST, dati_dist->get());
      effetto.put(EFF_NDIST, dati_dist->get());   
      effetto.put(EFF_DATADIST, dati_dist->get()); 
      effetto.put(EFF_CODABIP, dati_dist->get());
      effetto.put(EFF_CODCABP, dati_dist->get());  
      
      effetto.put(EFF_NRIGADIST, i+1);
    }
    //riscrivo l'effetto con i dati della distinta a cui appartiene
    err = effetto.rewrite(f);
  }    

  if (dati_dist)
  {
    f.setkey(4);
    f.put(EFF_TIPODIST, dati_dist->get(0));
    f.put(EFF_NDIST, dati_dist->get());   

    int i = elem;
    f.put(EFF_NRIGADIST, ++i);
    for (int e = f.read(); e == NOERR; e = f.read())
    {
      e = f.remove();
      f.put(EFF_NRIGADIST, ++i);
    }
  }
  
  return err;  
}

// rimuove la distinta (non si effettua la rimozione del record su file ma si 
// elimina dal file il collegamento tra gli effetti e la distinta)
int TDistinta::remove(char tipodist, long ndist)
{
  int err;
  TLocalisamfile file(LF_EFFETTI);
  // scandisco tutti gli effetti della distinta (nell'array),
  // cancello i dati della distinta e riscrivo gli effetti
  for (int i = 0; i < items(); i++)
  { 
    TEffetto& effetto = (TEffetto&)_righe_dist[i];
    err = effetto.read(file, tipodist,ndist,i+1);
    effetto.zero(EFF_TIPODIST);
    effetto.zero(EFF_NDIST);
    effetto.zero(EFF_DATADIST);
    effetto.zero(EFF_NRIGADIST);
    effetto.zero(EFF_CODABIP);
    effetto.zero(EFF_CODCABP);
    err = effetto.rewrite(file);
  }
  reset();//elimino gli effetti dalla memoria resettando l'array
  return err;  
}                        

bool TDistinta::contabilizzata() const
{   
  bool yes = FALSE;                     
  if (_righe_dist.items() > 0)
  {
    const TRectype& eff = (const TRectype&)_righe_dist[0];
    yes = eff.get_bool(EFF_EFFCONT);
  }
  return yes;
}