#include <stdlib.h>

#include <xvtmacro.h>
#include <tabutil.h>

#include "cg2101.h"
#include "cg2103.h"

#include <mov.h>
#include <rmov.h>
#include <rmoviva.h>


// Calcola l'anno di esercizio di una data                                
// Certified 99%
int date2esc(const TDate& d, int* prevesc)
{                   
  if (prevesc) *prevesc = 0;
  TTable esc("ESC");
  for (int err = esc.first(); err == NOERR; err = esc.next())
  {
    const TDate ia(esc.get("D0"));   // Data inizio esercizio
    const TDate fa(esc.get("D1"));   // Data fine esercizio
    TString16 sanno(esc.get("CODTAB")); sanno.cut(4);
    const int anno = atoi(sanno);
    if (d >= ia && d <= fa)
      return anno;
    if (prevesc) *prevesc = anno; 
  } 
  return 0;
}

///////////////////////////////////////////////////////////
// Movimento di prima nota
///////////////////////////////////////////////////////////

TMovimentoPN::TMovimentoPN()
: TRelation(LF_MOV), _oldcg(0), _oldiva(0)
{
  add(LF_RMOV, "NUMREG=NUMREG");
  add(LF_RMOVIVA, "NUMREG=NUMREG");
}

void TMovimentoPN::destroy_rows()
{
  _cg.destroy();
  _iva.destroy();
}


TRectype& TMovimentoPN::cg(int i)
{
  TRectype* r = (TRectype*)_cg.objptr(i);
  if (r == NULL)
  {
    r = new TRectype(LF_RMOV);
    _cg.add(r, i);
  }
  return *r;
}

TRectype& TMovimentoPN::iva(int i)
{
  TRectype* r = (TRectype*)_iva.objptr(i);
  if (r == NULL)
  {
    r = new TRectype(LF_RMOVIVA);
    _iva.add(r, i);
  }
  return *r;
}


int TMovimentoPN::read_mov_rows()
{
  const TLocalisamfile& rm = lfile(LF_RMOV);
  const TLocalisamfile& ri = lfile(LF_RMOVIVA);
  position_rels();

  destroy_rows();
  for(bool ok = is_first_match(LF_RMOV); ok; ok = next_match(LF_RMOV))
  {
    const int row = rm.get_int(RMV_NUMRIG) - 1;
    cg(row) = rm.curr();
  }
  _oldcg = cg_items();

  for(ok = is_first_match(LF_RMOVIVA); ok; ok = next_match(LF_RMOVIVA))
  {
    const int row = ri.get_int(RMI_NUMRIG) - 1;
    iva(row) = ri.curr();
  }
  _oldiva = iva_items();

  return NOERR;
}


int TMovimentoPN::read(TIsamop op, TReclock lockop, TDate& atdate)
{
  int err = file().read(op, lockop, atdate);
  if (err == NOERR) err = read_mov_rows();
  return err;
}


int TMovimentoPN::write_rec(bool re, const TRectype& rec, TLocalisamfile& f)
{
  if (re)
  {
    const bool scrivi = f.rewrite(rec) != NOERR;
    if (scrivi) f.write(rec);
  }
  else
  {
    f.write(rec);
  }

  return f.status();
}


int TMovimentoPN::cancella(TLocalisamfile& f, int da, int a)
{
  const long numreg = lfile().get_long(MOV_NUMREG);
  for (int i = da; i <= a; i++)
  {
    f.zero();
    f.put(MOV_NUMREG, numreg);
    f.put(RMV_NUMRIG, i);
    if (f.read(_isequal, _lock) == NOERR)
      f.remove();
  }
  return f.status();
}


int TMovimentoPN::registra(bool re, bool force)
{
  TLocalisamfile& m = lfile();
  
  const int err = write_rec(re, m.curr(), m);
  if (err != NOERR) return err;

  TLocalisamfile& rm = lfile(LF_RMOV);
  TLocalisamfile& ri = lfile(LF_RMOVIVA);

  const long numreg = m.get_long("NUMREG");

  for (int i = 0 ; i < cg_items(); i++)
  {                                  
    if (!re) cg(i).put("NUMREG", numreg);
    const int err = write_rec(re, cg(i), rm);
    if (!force && err != NOERR) return err;
  }
  if (i < _oldcg)
    cancella(rm, i+1, _oldcg);
  _oldcg = cg_items();

  for (i = 0 ; i < iva_items(); i++)
  {
    if (!re) iva(i).put("NUMREG", numreg);
    const int err = write_rec(re, iva(i), ri);
    if (!force && err != NOERR) return err;
  }
  if (i < _oldiva)
    cancella(ri, i+1, _oldiva);
  _oldiva = iva_items();

  // Resetta il flag di calcolato sulla liquidazione IVA del mese di registrazione        
  // Chiave di LIM: Anno (1-4), Mese (5-6)

  const TDate d(m.get("DATAREG"));
  TString16 chiave; chiave << d.year() << d.month();
  TTable lim("LIM");
  lim.put("CODTAB", chiave);
  if (lim.read() == NOERR)
  {
    const bool calcolato = lim.get_bool("B0");
    if (calcolato)
    {
      lim.put("B0", FALSE);
      lim.rewrite();
    }  
  } 
  
  const TString16 cod(m.get("REG"));
  const int anno = m.get_int("ANNOIVA");
  TRegistro reg(cod, anno);
  const int att = reg.attivita_mista() ? 2 : 1;
  
  // Chiave di PLM: Anno (1-4), Cod. Att. (5-9), Tipo att. (10-10), Mese (11-12)
  TTable plm("PLM"); 
  for (int a = 1; a <= att; a++)
  {
    chiave.cut(0);
    chiave << d.year() << reg.attivita() << a << d.month();
    plm.put("CODTAB", chiave);
    if (plm.read() == NOERR)
    {
      const bool calcolato = plm.get_bool("B0");
      if (calcolato)
      {
        plm.put("B0", FALSE);
        plm.rewrite();
      }  
    }  
  }

  return err;
}


int TMovimentoPN::write(bool force, TDate&)
{
  const TRectype& r = lfile().curr();
  const int annoiva = r.get_int("ANNOIVA");
  const TString16 reg(r.get("REG"));
  TRegistro registro(reg, annoiva);
  
  if (registro.iva() != nessuna_iva)
  {
    const bool mista = registro.attivita_mista();
    for (int i = 0; i < iva_items(); i++)
    {
      int tipoatt = 1;
      if (mista)
      {
        const char tipo = r.get_char("TIPO");
        if (tipo == ' ')               
        {
          TBill c(r.get_int("GRUPPO"), r.get_int("CONTO"), r.get_long("SOTTOCONTO"));
          tipoatt = c.tipo_att();
        }                      
      }  
      iva(i).put("TIPOATT", tipoatt);
    }
  }  
  
  _oldcg = _oldiva = 0;
  int err = registra(FALSE, force);
  
  if (err == NOERR)
  {
    const TDate datareg(r.get("DATAREG"));
    TLibro_giornale gio(date2esc(datareg));
    gio.update(0L, datareg);      // Aggiorna data registrazione sul libro giornale

    if (reg.not_empty())
    {                             // Aggiorna data registrazione e protocollo IVA sul registro
      const long protiva = r.get_long("PROTIVA");
      const long uprotiva = r.get_long("UPROTIVA");
      const TDate datareg = r.get_date("DATAREG");
      registro.update(max(protiva, uprotiva), datareg);
    }
  }      
  return err;
}


int TMovimentoPN::rewrite(bool force, TDate&)
{
  return registra(TRUE, force);
}


int TMovimentoPN::remove(TDate&)
{
  TLocalisamfile& m  = lfile();
  TLocalisamfile& rm = lfile(LF_RMOV);
  TLocalisamfile& ri = lfile(LF_RMOVIVA);

  cancella(rm, 1, _oldcg);
  cancella(ri, 1, _oldiva);
  m.remove();
  _oldcg = _oldiva = 0;
  return m.status();
}