// 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 <sheet.h> 
#include <tabutil.h>
#include <utility.h>
#include <urldefid.h>

#include <nditte.h>

#include "cg5700.h"

class TDich_periodica_selfirm_mask : public TAutomask
{
  TArray_sheet * _ditte;
  TString_array  _nomiditte;
  TString16      _freq;
  int            _year;
  
protected:
  bool select_button();
  void build_nomiditte();
  void build_ditte_sheet();
  void set_mask_freq();
public:
  const TString& 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(2);
  TLocalisamfile dt(LF_NDITTE);
  TTable lia("%LIA");

  _nomiditte.destroy();

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

    TToken_string* d = new TToken_string(64);
    
    d->add(dt.get("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(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(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(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;
}

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;
}

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_VP12_IMPORTO, del.get_real("R0"));
    set(F_VP12_DATA, del.get_date("D0"));
    set(F_VP12_ABI, del.get("S7"));
    set(F_VP12_CAB, del.get("S8"));
    set(F_VP12_CONCESSIONE, del.get("S9"));
    set(F_VP12_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_VP12_IMPORTO));
  del.put("D0", get(F_VP12_DATA));
  del.put("S7", get(F_VP12_ABI));
  del.put("S8", get(F_VP12_CAB));
  del.put("S9", get(F_VP12_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(lim.get("S0"));
    descrizione << lim.get("S1");
    const bool exclude_sign = descrizione.find("$$") >= 0 || descrizione.find(">>") >= 0;
    
    real vp1 = ZERO;
    real vp2 = ZERO;
    real vp3 = ZERO;
    real vp4 = ZERO;
    
    TTable pum("PUM");
    key.format("%4d",_sf->get_year());
    pum.put("CODTAB", key);
    
    for (pum.first(); !pum.eof(); 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() || perd != _sf->get_period())
        continue;
      vp1 += pum.get_real("R14");
      vp2 += pum.get_real("R15");
      vp3 += pum.get_real("R16");
      vp4 += pum.get_real("R17");
    }

    // 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 : cur.decimals();
    
    real rettifica = lim.get_real("R5");

    real vp5       = lam.get_real("R0");
    if (rettifica > ZERO)
      vp5 += rettifica;
      
    real vp6       = lam.get_real("R1");
    if (rettifica < ZERO && !exclude_sign)
      vp6 += abs(rettifica);
    
    real vp7       = lam.get_real("R2") + lim.get_real("R1");
    
    real vp8 = ZERO;
    if (rettifica < ZERO && exclude_sign)
      vp8 = abs(rettifica);
    
    real vp9 = lim.get_real("R14");
    
    vp1.round(ndec); vp2.round(ndec); vp3.round(ndec); vp4.round(ndec);
    vp5.round(ndec); vp6.round(ndec); vp7.round(ndec); vp8.round(ndec);
    vp9.round(ndec);
    
    // I seguenti vengono giusti ed arrotondati bene di conseguenza
    real vp10 =  vp5 - (vp6+vp7+vp8) + vp9;
    real vp11 = (vp6+vp7) - vp5;
    
    if (vp10 < ZERO)
      vp10 = ZERO;
    
    if (vp11 < ZERO)
      vp11 = ZERO;

    set(F_VP1, vp1);set(F_VP2, vp2);set(F_VP3, vp3);set(F_VP4, vp4);
    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);
  }
  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();
  
  TForm frm("cg5700a");
  
  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_IMPORTI).set(_is_euro ? "1" : " ");
  frm.find_field('B', odd_page, FF_VP1).set(get(F_VP1));
  frm.find_field('B', odd_page, FF_VP2).set(get(F_VP2));
  frm.find_field('B', odd_page, FF_VP3).set(get(F_VP3));
  frm.find_field('B', odd_page, FF_VP4).set(get(F_VP4));
  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));
  
  // 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_VP12_STAMPATO);
  frm.find_field('B', odd_page, FF_VP12_STAMPATO).set(b ? "X" : " "); //Mostra nasconde il gruppo 12
  if (b)
  {
    frm.find_field('B', odd_page, FF_VP12_IMPORTO).set(get(F_VP12_IMPORTO));
    frm.find_field('B', odd_page, FF_VP12_DATA).set(get(F_VP12_DATA));
    frm.find_field('B', odd_page, FF_VP12_CONCESSIONE).set(get(F_VP12_CONCESSIONE));
    frm.find_field('B', odd_page, FF_VP12_ABI).set(get(F_VP12_ABI));
    frm.find_field('B', odd_page, FF_VP12_CAB).set(get(F_VP12_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 TString& 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_VP12_DATA:
    case F_VP12_CONCESSIONE:
    case F_VP12_ABI:
    case F_VP12_CAB:
      if (e == fe_modify)
        _dirty_versament = TRUE;
      break;
    case F_VP12_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;
  TDich_periodica_iva_mask     * _m2;
  
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()
{ 
  _m1 = new TDich_periodica_selfirm_mask();
  _m2 = new TDich_periodica_iva_mask(_m1);
  open_files(LF_NDITTE, 0);
  return TSkeleton_application::create();
}

bool TDich_periodica_iva_app::destroy()
{
  delete _m2;
  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));

    _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;
}