#include "prlib.h"
#include "provv.h"
#include <doc.h>

// TProvvigioni_agente


TProvvigioni_agente::TProvvigioni_agente() : TRectype(LF_AGENTI)
{
//  _rows = new TRecord_array(LF_PROVV,PROV_NRIGA);
  _provv_rel = new TRelation(LF_PROVV);
  _provv_cur = new TCursor(_provv_rel);
}

TProvvigioni_agente::TProvvigioni_agente(const char* agente) : TRectype(LF_AGENTI)
{
  //_rows = new TRecord_array(LF_PROVV,PROV_NRIGA);
  _provv_rel = new TRelation(LF_PROVV);
  _provv_cur = new TCursor(_provv_rel);
  read(agente);
}

TProvvigioni_agente::~TProvvigioni_agente()
{
//  delete _rows;
  delete _provv_rel;
  delete _provv_cur;
}

int TProvvigioni_agente::read(const char* agente, const int anno, const char* codnum, const long ndoc)
{
  int err = NOERR;

  destroy(); // Cancella eventuali residui
  TLocalisamfile age(LF_AGENTI);
  TRectype::put(AGE_CODAGE,agente);
  err = TRectype::read(age); // Carica i dati dell'agente
  if (err != NOERR)
    return err;
    
  _agente = agente;

  TRectype rec_from(LF_PROVV);

  rec_from.put(PROV_CODAGE,agente);
  if (anno != 0)
    rec_from.put(PROV_ANNO, anno);
  if (codnum != NULL)
    rec_from.put(PROV_CODNUM, codnum);
  if (ndoc != 0L)
    rec_from.put(PROV_NDOC, ndoc);
  
  TRectype rec_to(rec_from);
  
  _provv_cur->setregion(rec_from, rec_to); // Cursore da leggere contenente le provvigioni
  
  const long items = _provv_cur->items();
  TRectype& r = _provv_cur->file().curr();
  TString key, codnum1;
  int     anno1;
  long    ndoc1;
  for (long i = 0; i < items; i++)  // Compila l'assoc_array per documenti/rate
  {
    *_provv_cur = i; // posiziona il cursore
    
    anno1   = r.get_int(PROV_ANNO);
    codnum1 = r.get(PROV_CODNUM);
    ndoc1   = r.get_long(PROV_NDOC);
    key.format("%4d%4s%7ld",anno1,(const char*)codnum1,ndoc1); // Compone la chiave

    const bool exist = _rate.is_key(key);  // Guarda se esiste gia' questo documento
    TRate_doc  com_rata(r);
    TRate_doc& rd = exist ? (TRate_doc&) _rate[key] : com_rata;
    TRata* rt = new TRata(r);
    rd.add_rata(rt);

    _rate.add(key,rd,exist); // Sostituisce/aggiunge l'elemento
  }
  
  // Dopo aver letto le righe, ordina le rate per ogni documento
  for (TRate_doc* rd = (TRate_doc*) _rate.first_item(); rd != NULL; rd = (TRate_doc*) _rate.succ_item())
    rd->sort_rate();

  return err;
}

int TProvvigioni_agente::rate2rows(int action)
{
  // Scorre gli elementi di _rate (TDoc_rate) uno ad uno
  // per settare le righe provvigionali 
  TString_array kl;
  const int items = documenti(kl); // Prende l'elenco dei documenti
  kl.sort();                       // ordina per documento
  int err = NOERR;
  for (int i = 0; i < items && err == NOERR; i++)
  {
    TRate_doc& rd = (TRate_doc&)_rate[kl.row(i)];
    const int anno  = rd.anno();
    const long ndoc = rd.ndoc();
    TString    codnum(rd.codnum());
    TRecord_array* rows = new TRecord_array(LF_PROVV,PROV_NRIGA);
    // Chiave del TRecord_array
    TRectype* k = new TRectype(LF_PROVV);
    k->put(PROV_CODAGE, _agente);
    k->put(PROV_ANNO,anno);
    k->put(PROV_CODNUM,codnum);
    k->put(PROV_NDOC,ndoc);
    rows->set_key(k);
    const int ritems = rd.items(); // Ciclo per rate di questo documento
    int nrow = 1;
    for (int j = 0; j < ritems; j++)
    {
      TRata& rt        =  rd[j];
      TRectype* record =  new TRectype(LF_PROVV);
      record->put(PROV_CODAGE,_agente);
      record->put(PROV_ANNO,anno);
      record->put(PROV_CODNUM,codnum);
      record->put(PROV_NDOC,ndoc);
      record->put(PROV_NRIGA,nrow++);
      record->put(PROV_NRATA,rt.rata());
      record->put(PROV_GENERATA,rt.generata());
      record->put(PROV_SALDATA,rt.saldata());
      record->put(PROV_TIPOPAGPR,rt.tipopagpr());
      record->put(PROV_DATADOC,rd.datadoc());
      record->put(PROV_IMPDOC,rd.impdoc());
      record->put(PROV_IMPPRDOC,rd.impprdoc());
      record->put(PROV_IMPNETDOC,rd.impnet());
      record->put(PROV_CODCLI,rd.codcf());
      record->put(PROV_TIPOPAG,rd.tipo());
      record->put(PROV_CODVAL,rd.codval());
      record->put(PROV_DATACAMBIO,rd.datacam());
      record->put(PROV_CAMBIO,rd.cambio());
      record->put(PROV_DATASCAD,rt.datascad());
      record->put(PROV_IMPRATA,rt.imprata());
      record->put(PROV_IMPPROVV,rt.impprovv());
      record->put(PROV_PAGATO,rt.pagato());
      record->put(PROV_PROVVPAG,rt.provvpag());
      record->put(PROV_PAGMAT,rt.pagmat());
      record->put(PROV_PROVVMAT,rt.provvmat());
      rows->add_row(record);
    }
    switch (action)
    {
      case 0: // write
        err = rows->write();
        break;
      case 1: // rewrite
        err = rows->rewrite();
        break;
      case 2: // remove
        err = rows->remove();
        break;
      default: // remove
        break;
    }
    delete rows;
  }
  return err;
}

TRate_doc& TProvvigioni_agente::rate(int anno, const char* codnum, long ndoc, bool create)
{
  TString k;
  
  k.format("%4d%4s%7ld",anno,codnum,ndoc);
  return rate(k,create);
}

TRate_doc& TProvvigioni_agente::rate(const char* key, bool create)
{
  const bool exist = _rate.is_key(key);
  if (!exist)
  {
    if (create)
    {
      TRectype r(LF_PROVV);
      TString  k(key);
      r.put(PROV_ANNO,k.sub(0,4));
      r.put(PROV_CODNUM,k.sub(4,8));
      r.put(PROV_NDOC,k.sub(8));
      TRate_doc* rd = new TRate_doc(r);
      _rate.add(key,rd);
    }
    else
      fatal_box("Impossibile trovare l'elemento %s tra le righe provvigionali",key);
  }
  return (TRate_doc&) _rate[key];
}

void TProvvigioni_agente::remove_rate(int anno, const char* codnum, long ndoc)
{
  TString k;
  
  k.format("%4d%4s%7ld",anno,codnum,ndoc);
  remove_rate(k);
}

void TProvvigioni_agente::remove_rate(const char* key)
{
  const bool exist = _rate.is_key(key);
  if (exist)
    _rate.remove(key);
  else
    fatal_box("Impossibile trovare l'elemento %s tra le righe provvigionali", key);
}

/////////////////////////////////////////////////////////////////////////////////
// TRate_doc
/////////////////////////////////////////////////////////////////////////////////
TRate_doc::TRate_doc(TRectype& rec)
{
  set(rec); // bleah!
}

TRata& TRate_doc::row(int i, bool create)
{
  if (create && _rows.objptr(i) == NULL) // Parametro di creazione
    _rows.add(new TRata(),i);
  return (TRata&) _rows[i];
}

bool TRate_doc::ok_provvigione()
{
  real totprov;
  const int its = items();

  for (int i = 0; i < its; i++) // Somma le provvigioni di tutte le rate
    totprov += row(i).impprovv();
    
  return totprov <= _impprdoc; // controlla che tale somma e' compresa nel totale provvigione del documento 
}

void TRate_doc::set(TRectype& rec)
{
  CHECK(rec.num() == LF_PROVV,"Il record non ha il tracciato di LF_PROVV");
  _anno       = rec.get_int(PROV_ANNO);
  _codnum     = rec.get(PROV_CODNUM);
  _codval     = rec.get(PROV_CODVAL);
  _ndoc       = rec.get_long(PROV_NDOC);
  _codcf      = rec.get_long(PROV_CODCLI);
  _datadoc    = rec.get_date(PROV_DATADOC);
  _datacambio = rec.get_date(PROV_DATACAMBIO);
  _tipopag    = rec.get_char(PROV_TIPOPAG);
  _impdoc     = rec.get_real(PROV_IMPDOC);
  _impprdoc   = rec.get_real(PROV_IMPPRDOC);
  _impnetdoc  = rec.get_real(PROV_IMPNETDOC);
  _cambio     = rec.get_real(PROV_CAMBIO);
}

void TRate_doc::set(TToken_string& t)
{
  CHECK(t.items() >= 12, "Numero di items non valido");
  _anno       = t.get_int(0);
  _codnum     = t.get(1);
  _ndoc       = t.get_long(2);
  _datadoc    = t.get(3);
  _impdoc     = t.get(4);
  _impprdoc   = t.get(5);
  _impnetdoc  = t.get(6);
  _codcf      = t.get_long(7); 
  _tipopag    = t.get_char(8);
  _codval     = t.get(9); 
  _cambio     = t.get(10); 
  _datacambio = t.get(11); 
}

/////////////////////////////////////////////////////////////////////////////////
// TRata
/////////////////////////////////////////////////////////////////////////////////
int TRata::compare(const TSortable& s) const
{
  const TRata& r = (const TRata&) s;
  
  if (_nrata > r.rata()) 
    return 1; // Numero maggiore
  else
    if (_nrata < r.rata());
      return -1; // Numero minore
  
  return 0; // Stesso numero di rata
}

void TRata::set(TToken_string& t)
{
  CHECK(t.items() == 10, "Troppi pochi elementi nella token string");
  _nrata    = t.get_int(0);
  _datascad = t.get(1);
  _imprata  = t.get(2);
  _impprovv = t.get(3);
  _pagmat   = t.get(4);
  _provvmat = t.get(5);
  _pagato   = t.get(6);
  _provvpag = t.get(7);
  _saldata  = t.get(8)[0] == 'X' ? TRUE : FALSE;
  _tipopagpr = t.get_int(9);
}

void TRata::set(TRectype& rec)
{
  CHECK(rec.num() == LF_PROVV,"Il record non ha il tracciato di LF_PROVV");
  _datascad = rec.get_date(PROV_DATASCAD);
  _imprata  = rec.get_real(PROV_IMPRATA);
  _impprovv = rec.get_real(PROV_IMPPROVV);
  _pagato   = rec.get_real(PROV_PAGATO);
  _provvpag = rec.get_real(PROV_PROVVPAG);
  _pagmat   = rec.get_real(PROV_PAGMAT);
  _provvmat = rec.get_real(PROV_PROVVMAT);
  _saldata  = rec.get_bool(PROV_SALDATA);
  _nrata    = rec.get_int(PROV_NRATA);
  _generata = rec.get_char(PROV_GENERATA);
  _tipopagpr = rec.get_int(PROV_TIPOPAGPR);
}

TRata::TRata(TRectype& rec)
{
  set(rec);
}