// Programma per la gestione e la stampa della dichiarazione periodica IVA
#include <applicat.h>
#include <automask.h>
#include <currency.h>
#include <form.h>
#include <prefix.h>
#include <recarray.h>
#include <sheet.h> 
#include <tabutil.h>

#include <nditte.h>

#include "cg5700.h"

class TDich_periodica_selfirm_mask : public TAutomask
{
  TArray_sheet * _ditte;
  TString_array  _nomiditte;
  char           _freq;
  int            _year;
  
protected:
  bool select_button();
  void build_nomiditte();
  void build_ditte_sheet();
  void set_mask_freq();
public:
  const char get_freq() const { return _freq; }
  const int get_year() const { return _year; }
  const int get_period() const { return atoi(get(_freq == 'M' ? F_MONTHS : F_TRIMS)); }
  virtual bool on_field_event(TOperable_field& o, TField_event e, long jolly);
  TDich_periodica_selfirm_mask();
  virtual ~TDich_periodica_selfirm_mask();
};

TDich_periodica_selfirm_mask::TDich_periodica_selfirm_mask() : TAutomask("cg5700a")
{
  _ditte  = new TArray_sheet(-1, -1, -4, -4, "Selezione Ditte",
                             "Cod.@5|Ragione Sociale@50|Vers.");  
  TDate oggi(TODAY);                    
  
  _year = oggi.year();
  _freq = 'M';
  
  set_mask_freq();

  build_nomiditte();
  build_ditte_sheet();                             
}

TDich_periodica_selfirm_mask::~TDich_periodica_selfirm_mask()
{
  delete _ditte;
}

void TDich_periodica_selfirm_mask::build_nomiditte()
{                 
  TString fr, cod;
  TLocalisamfile dt(LF_NDITTE);
  TTable lia("%LIA");

  _nomiditte.destroy();

  for (dt.first(); !dt.eof(); dt.next())
  {     
    const long codditta = dt.get_long("CODDITTA");
    bool good = prefix().exist(codditta);
    
    if (good) 
    {           
      cod.format("%05ld%d", codditta, _year);
      lia.put("CODTAB", cod);
      if (lia.read() != NOERR) 
      {
        fr = "??";
        good = FALSE; 
      }
      else 
        fr = lia.get("S7");

      TToken_string* d = new TToken_string(64);
      
      d->add(codditta);
      d->add(dt.get("RAGSOC"));
      d->add(fr);
      
      _nomiditte.add(d);  
    }
  }
}

void TDich_periodica_selfirm_mask::build_ditte_sheet()
{
  _ditte->destroy();
  long prima = -1;
  
  for (int i = 0; i < _nomiditte.items(); i++)
  {
    TToken_string* d = new TToken_string(_nomiditte.row(i));
    const long pos = _ditte->add(d);     
    const char vers = d->get_char(2);
    const bool selectable = vers != '?';
    _ditte->enable_row(pos, selectable);
    if (selectable && prima < 0)
      _ditte->select(prima = pos);
  }     
}

void TDich_periodica_selfirm_mask::set_mask_freq()
{
  if (_freq == 'M')
  {
    show(F_MONTHS);
    hide(F_TRIMS);
  }
  else
  {
    hide(F_MONTHS);
    show(F_TRIMS);
  }
}      

bool TDich_periodica_selfirm_mask::select_button()
{     
  if (_ditte->run() == K_ENTER)
  {
    TToken_string& row = _ditte->row(_ditte->selected()); 
    set(F_CODDITTA, row.get(0));
    set(F_RAGSOC, row.get(1));
    _freq = row.get_char(2);
    set_mask_freq();
    return TRUE;        
  }
  return FALSE;
}

bool TDich_periodica_selfirm_mask::on_field_event(TOperable_field& o, TField_event e, long jolly)
{                                                  
  switch (o.dlg())
  {
    case F_CODDITTA:
      if (e == fe_button)
        return select_button();
      
      if (e == fe_modify)
      {
        bool found = FALSE;
        TString16 ditta = o.get();
        for (int i = 0; i < _ditte->items(); i++)
        { 
          TToken_string& row = _ditte->row(i);
          if (ditta == row.get(0))
          { 
            if (_ditte->row_enabled(i))
            {
              set(F_CODDITTA, row.get(0));
              set(F_RAGSOC, row.get(1));
              _freq = row.get_char(2);
              set_mask_freq(); 
              found = TRUE;
            }
            else 
            { 
              warning_box("Non sono definiti i parametri liquidazione per la ditta %ld",
                          atol(ditta));
              o.reset(); 
            }
            break;
          }
        }
        if (!found)
          o.reset();
        return found;
      }
      break;
    case F_RAGSOC:
      if (e == fe_button)
        return select_button();
      if (e == fe_modify)
      {
        bool found = FALSE;
        TString16 ditta = o.get();
        for (int i = 0; i < _ditte->items(); i++)
        { 
          TToken_string& row = _ditte->row(i);
          TString ts(row.get(1));
          if (ts.find(ditta) != -1)
          { 
            if (_ditte->row_enabled(i))
            {
              set(F_CODDITTA, row.get(0));
              set(F_RAGSOC, row.get(1));
              _freq = row.get_char(2); 
              set_mask_freq(); 
              found = TRUE;
              break;
            }
          }
        }
        if (!found) o.reset(); 
        return found;  
      }
      break;
    case F_YEAR:
      if (e == fe_modify)
      {
        _year = atoi(o.get());
        build_nomiditte();
        build_ditte_sheet();  
        set(F_CODDITTA, "");  
        set(F_RAGSOC, "");  
      }
      break;
    default:
      break;
  }
  
  return TRUE;
} 

bool change_prompt(TString& p, int year)
{ 
  bool changed = FALSE;
  if (p.left(2) == "VP")
  {
    const int vp = atoi(p.mid(2,2));
    if (year >= 2001)
    {
      if (vp >= 5)
      {     
        switch (vp)
        {
        case 6:
          p = "VP11 - IVA detratta per il periodo";
          break;
        case 9:
          p = "VP14 - IVA non versata o in eccesso da dich. prec.";
          break;
        default:
          TString4 n;
          n.format("%2d", vp+5);
          p.overwrite(n, 2);
          break;
        }
        changed = TRUE;
      }
    }
  }
  return changed;
}


class TDich_periodica_iva_form : public TForm
{
public:
  TDich_periodica_iva_form(int anno);
};
  
TDich_periodica_iva_form::TDich_periodica_iva_form(int anno) : TForm("cg5700a")
{
  if (anno > 2000)
  {
    TPrint_section& b = section('B', odd_page);
    TString p;
    for (int i = b.fields()-1; i > 0; i--)
    {
      TForm_item& f = b.field(i);
      p = f.prompt();
      if (change_prompt(p, anno))
        f.set_prompt(p);
    }
  }
}

class TDich_periodica_iva_mask : public TAutomask
{
  TDich_periodica_selfirm_mask * _sf;
  bool _dirty_versament, // Sporco versamento...
       _is_euro;         // importi in euro
protected:
  void search_versament();
  void write_versament();
  void read_iva_data();

public:
  void set_prospect();
  void print_prospect();
  virtual bool on_key(KEY k);
  virtual bool on_field_event(TOperable_field& o, TField_event e, long jolly);
  TDich_periodica_iva_mask(TDich_periodica_selfirm_mask *m);
  virtual ~TDich_periodica_iva_mask() {};
};

TDich_periodica_iva_mask::TDich_periodica_iva_mask(TDich_periodica_selfirm_mask *m)
                        : TAutomask("cg5700b")
{
  _sf = m;
  
  const int anno = _sf->get_int(F_YEAR);
  if (anno > 2000)
  {   
    TString p;
    for (int i = fields()-1; i > 0; i--)
    { 
      TMask_field& f = fld(i);
      p = f.prompt();
      if (change_prompt(p, anno))
        f.set_prompt(p);
    }
  }
}

void TDich_periodica_iva_mask::search_versament()
{
  TTable del("%DEL");
  TString key;
  key.format("%05ld%4d%02d1", _sf->get_long(F_CODDITTA), _sf->get_year(), _sf->get_period());
  
  del.put("CODTAB", key);
  // Se esiste il versamento la visualizza, mantenendola disabilitata (eventuale SHIFT+F12)
  if (del.read() == NOERR)
  {
    set(F_VP17_IMPORTO, del.get_real("R0"));
    set(F_VP17_DATA, del.get_date("D0"));
    set(F_VP17_ABI, del.get("S7"));
    set(F_VP17_CAB, del.get("S8"));
    set(F_VP17_CONCESSIONE, del.get("S9"));
    set(F_VP17_STAMPATO, del.get_bool("B0"));
  }
  else
    enable(-G_VP12);
}

void TDich_periodica_iva_mask::write_versament()
{
  TTable del("%DEL");
  TString key;
  key.format("%05ld%4d%02d1", _sf->get_long(F_CODDITTA), _sf->get_year(), _sf->get_period());
  
  del.put("CODTAB", key);
  
  const bool good = del.read() == NOERR;
  
  del.put("R0", get(F_VP17_IMPORTO));
  del.put("D0", get(F_VP17_DATA));
  del.put("S7", get(F_VP17_ABI));
  del.put("S8", get(F_VP17_CAB));
  del.put("S9", get(F_VP17_CONCESSIONE));
  del.put("B0", TRUE);
  
  if (good)
    del.rewrite();
  else
    del.write();
}

void TDich_periodica_iva_mask::read_iva_data()
{
  TTable lim("LIM");
  TTable lam("LAM");
  
  TString16 key;
  key.format("%4d%02d", _sf->get_year(), _sf->get_period());
  lim.put("CODTAB", key);
  lam.put("CODTAB", key);
  
  const bool good = lim.read() == NOERR;
  
  if (good && lim.get_bool("B0"))
  {
    lam.read();
    
    TString descrizione(120); 
    descrizione = lim.get("S0");
    descrizione << lim.get("S1");
    const bool exclude_sign = descrizione.find("$$") >= 0 || descrizione.find(">>") >= 0;
    
    real vp1  = ZERO;
    real vp1a = ZERO;
    real vp2  = ZERO;
    real vp2a = ZERO;
    real vp3  = ZERO;
    real vp3i = ZERO;
    
    TTable pum("PUM");
    key.format("%4d",_sf->get_year());
    pum.put("CODTAB", key);

    const char f = _sf->get_freq();
    const int p = _sf->get_period();
    
    for (int err = pum.read(_isgteq); err == NOERR; err = pum.next())
    {
      key = pum.get("CODTAB");
      const int anno = atoi(key.mid(0,4));
      const int perd = atoi(key.mid(10,2));
      
      if (anno != _sf->get_year())
        break;
      
      if (f == 'M')  
      {
        if (perd != p)
          continue;
      }
      else
      {
        if (perd < p-2 || perd > p)
          continue;
      }

      vp1  += pum.get_real("R14");
      vp1a += pum.get_real("R15");
      vp2  += pum.get_real("R16");
      vp2a += pum.get_real("R17");
      vp3  += pum.get_real("R18");
      vp3i += pum.get_real("R19");
    }

    // Se espressi in lire o una valuta con 0 decimali, arrotonda alle 1000
    TCurrency cur(vp1, get(F_CODVAL));
    const int ndec = cur.decimals() == 0 ? -3 : 0;
    
    vp1.round(ndec); vp1a.round(ndec); vp2.round(ndec); vp2a.round(ndec); 
    vp3.round(ndec); vp3i.round(ndec);
    
    real rettifica = lim.get_real("R5"); // Rettifiche

    real vp5       = lam.get_real("R0"); // Iva esigibile per il periodo
    if (rettifica > ZERO)
      vp5 += rettifica;
      
    real vp6       = lam.get_real("R1"); // Iva che si detrae per il periodo
    if (rettifica < ZERO && !exclude_sign)
      vp6 += abs(rettifica);

    real vp7  = vp5 - vp6;      // IVA a debito o credito per il periodo
    real vp8  = lim.get("R17"); // Variazioni d'imposta periodi precedenti
    real vp9  = lim.get("R18"); // IVA non versata da dichiarazioni precedenti
    real vp10 = lam.get_real("R3") - lam.get_real("R2") + lim.get_real("R1"); // Debito o credito precedente
    real vp11 = lim.get("R15"); // Credito IVA compensabile
    real vp12 = lim.get_real("R0") + lim.get_real("R19") + lim.get_real("R11") + lim.get_real("R9");
    real vp13 = lim.get("R19"); // Crediti speciali
    real vp14 = lim.get("R14"); // Interessi dovuti per liquidazione trimestrale
    real vp15 = ZERO;
    if (p == 12) // Gli acconti ci sono solo a Dicembre
    {
      if (f == 'T')
      {
        // Chiave delle deleghe: DITTA|ANNO|MESE=12|TIPO=7
        key.format("%05ld%04d127", _sf->get_long(F_CODDITTA), _sf->get_year());
        const TRectype& delega = cache().get("%DEL", key);
        if (delega.get_bool("B0"))  // Se delega acconto stampata
          vp15 = delega.get_real("R0");
      }
      else
        vp15 = lim.get_real("R11"); // Acconto versato
    }
                                                 
    real vp16;
    if (f == 'M' || p < 12)  // Escludere quarto trimestre ditte trimestrali
    {
      vp16 = lim.get_real("R0") + lim.get_real("R14"); // Importo da versare
      if (vp16 < ZERO) vp16 = ZERO;
    }
    
    set(F_VP1, vp1); set(F_VP1A, vp1a); set(F_VP2, vp2); set(F_VP2A, vp2a);
    set(F_VP3, vp3); set(F_VP3I, vp3i);
    set(F_VP5, vp5); set(F_VP6, vp6); set(F_VP7, vp7); 
    set(F_VP8, vp8); set(F_VP9, vp9); set(F_VP10, vp10); set(F_VP11, vp11);
    set(F_VP12, vp12); set(F_VP13, vp13); set(F_VP14, vp14); set(F_VP15, vp15); set(F_VP16, vp16);
  }
  else
    error_box("Risultati liquidazione non presenti o da ricalcolare per il periodo richiesto.");
}

void TDich_periodica_iva_mask::print_prospect()
{
  if (_dirty_versament)
    write_versament();
  
  const int anno = _sf->get_int(F_YEAR);
  TDich_periodica_iva_form frm(anno);
  
  frm.find_field('B', odd_page, FF_CODVAL).set(get(F_CODVAL));
  frm.find_field('B', odd_page, FF_YEAR).set(get(F_YEAR));
  const bool mens = _sf->get_freq() == 'M';

  TForm_item& sf1 = frm.find_field('B', odd_page, FF_MONTHS);
  TForm_item& sf2 = frm.find_field('B', odd_page, FF_TRIMS);

  sf1.set(get(F_MONTHS));
  sf2.set(get(F_TRIMS));
  sf1.show(mens);
  sf2.show(!mens);
  
  frm.find_field('B', odd_page, FF_VP1).set(get(F_VP1));
  frm.find_field('B', odd_page, FF_VP1A).set(get(F_VP1A));
  frm.find_field('B', odd_page, FF_VP2).set(get(F_VP2));
  frm.find_field('B', odd_page, FF_VP2A).set(get(F_VP2A));
  frm.find_field('B', odd_page, FF_VP3).set(get(F_VP3));
  frm.find_field('B', odd_page, FF_VP3I).set(get(F_VP3I));
  frm.find_field('B', odd_page, FF_VP5).set(get(F_VP5));
  frm.find_field('B', odd_page, FF_VP6).set(get(F_VP6));
  frm.find_field('B', odd_page, FF_VP7).set(get(F_VP7));
  frm.find_field('B', odd_page, FF_VP8).set(get(F_VP8));
  frm.find_field('B', odd_page, FF_VP9).set(get(F_VP9));
  frm.find_field('B', odd_page, FF_VP10).set(get(F_VP10));
  frm.find_field('B', odd_page, FF_VP11).set(get(F_VP11));
  frm.find_field('B', odd_page, FF_VP12).set(get(F_VP12));
  frm.find_field('B', odd_page, FF_VP13).set(get(F_VP13));
  frm.find_field('B', odd_page, FF_VP14).set(get(F_VP14));
  frm.find_field('B', odd_page, FF_VP15).set(get(F_VP15));
  frm.find_field('B', odd_page, FF_VP16).set(get(F_VP16));
  
  // Se è stato creato il versamento ora o se è stato già stampato
  // allora lo stampa, altrimenti lo nasconde.
  
  const bool b = _dirty_versament || get_bool(F_VP17_STAMPATO);
  frm.find_field('B', odd_page, FF_VP17_STAMPATO).set(b ? "X" : " "); //Mostra nasconde il gruppo 17
  if (b)
  {
    frm.find_field('B', odd_page, FF_VP17_IMPORTO).set(get(F_VP17_IMPORTO));
    frm.find_field('B', odd_page, FF_VP17_DATA).set(get(F_VP17_DATA));
    frm.find_field('B', odd_page, FF_VP17_CONCESSIONE).set(get(F_VP17_CONCESSIONE));
    frm.find_field('B', odd_page, FF_VP17_ABI).set(get(F_VP17_ABI));
    frm.find_field('B', odd_page, FF_VP17_CAB).set(get(F_VP17_CAB));
  }
  
  TRectype f(LF_NDITTE);  
  f.put(NDT_CODDITTA, get(F_CODDITTA));
  TRectype t(f);
  
  frm.cursor()->setregion(f,t);
  frm.print();
}

void TDich_periodica_iva_mask::set_prospect()
{
  CHECK(_sf, "Invalid mask");
  
  _dirty_versament = FALSE;
  
  set(F_YEAR, _sf->get_year());
  set(F_CODDITTA, _sf->get(F_CODDITTA));
  set(F_RAGSOC, _sf->get(F_RAGSOC));
  
  const char f = _sf->get_freq();
  show(F_MONTHS, f == 'M');
  show(F_TRIMS,  f == 'T');
  
  set(F_MONTHS, _sf->get(F_MONTHS));
  set(F_TRIMS,  _sf->get(F_TRIMS));
  
  TFirm frm(_sf->get_long(F_CODDITTA));
  
  const TString& cv  = frm.codice_valuta();
  _is_euro = cv == TCurrency::get_euro_val();
  
  set(F_CODVAL, cv);  
  
  search_versament();
  
  read_iva_data();
}

bool TDich_periodica_iva_mask::on_key(KEY k)
{
  if (k == K_SHIFT + K_F12) // Abilita i campi relativi al versamento
    enable(-G_VP12);

  return TAutomask::on_key(k);
}

bool TDich_periodica_iva_mask::on_field_event(TOperable_field& o, TField_event e, long jolly)
{
  switch (o.dlg())
  {
    case F_VP17_DATA:
    case F_VP17_CONCESSIONE:
    case F_VP17_ABI:
    case F_VP17_CAB:
      if (e == fe_modify)
        _dirty_versament = TRUE;
      break;
    case F_VP17_IMPORTO:
      if (e == fe_modify)
      {
        _dirty_versament = TRUE;
        real r(o.get());
        TCurrency cur(r, get(F_CODVAL));
        const int ndec = cur.decimals(); // Decimali di questa valuta per gli importi
    
        // Arrotondamento alle migliaia nel caso il numero
        // di decimali della ditta sia zero (come per le lire)
        // altrimenti al numero di decimali impostato
        r.round(ndec == 0 ? -3 : ndec);
        o.set(r.string());
      }
      break;
    default:
      break;
  }
  return TRUE;
}

class TDich_periodica_iva_app : public TSkeleton_application
{
  TDich_periodica_selfirm_mask * _m1;
  
protected:
  virtual bool create(); 
  virtual bool destroy(); 
  virtual void main_loop();
public:
  virtual bool firm_change_enabled() const { return FALSE; }
  TDich_periodica_iva_app  () {};
  virtual ~TDich_periodica_iva_app  () {};
};

bool TDich_periodica_iva_app::create()
{ 
  open_files(LF_TAB, LF_TABCOM, LF_NDITTE, 0);
  _m1 = new TDich_periodica_selfirm_mask();
  return TSkeleton_application::create();
}

bool TDich_periodica_iva_app::destroy()
{
  delete _m1;
  return TSkeleton_application::destroy();
}

void TDich_periodica_iva_app::main_loop()
{
  long ditta = get_firm();

  while (_m1->run() != K_QUIT)
  {
    if (_m1->get(F_CODDITTA).empty() || _m1->get(F_RAGSOC).empty())  
    { 
      beep();
      continue;
    }
    
    set_firm(_m1->get_long(F_CODDITTA));

    TDich_periodica_iva_mask* m2 = new TDich_periodica_iva_mask(_m1);
    m2->reset();
    m2->enable_default();
    m2->set_prospect();
    if (m2->run() == K_ENTER)
      m2->print_prospect();
  }

  set_firm(ditta);
}

int cg5700 (int argc, char* argv[])
{
  TDich_periodica_iva_app a;
  a.run(argc, argv, "Dichiarazione periodica");
  return 0;
}