#include <applicat.h>
#include <automask.h>
#include <progind.h>
#include <relation.h>

#include "baeur.h"
#include "baeur30.h"
#include "../cg/cglib01.h"
#include "../cg/cglib02.h"

#include <mov.h>
#include <pconti.h>
#include <rmov.h>
#include <saldi.h>

///////////////////////////////////////////////////////////
// Main app
///////////////////////////////////////////////////////////

struct TChiusura_data
{
  TDate _data_c, _data_a;
  int _anno_c, _anno_a;
  TString4 _caus_c, _caus_a;
  TCG_movs _movs;
  real _totale_saldo;
  TBill _proper, _bilchi, _bilape, _pereco, _utieco, _perpat, _utipat, _difarr;
};

class TEuro03_app : public TEuro_app
{ 
protected:
  virtual void main_loop();

public:
  void close_saldi_prec(const TDate& dc);
  void scan_saldi(int indbil, record_handler rh, void* jolly);
  void salva_movimento_lit(const real& imp, const TBill& c1, const TBill& c2, 
                           TChiusura_data& data, const TString& desc);
  void salva_movimento_eur(const real& imp, const TBill& c1, const TBill& c2, 
                           TChiusura_data& data, const TString& desc);
  
  void chiusura_costi(TChiusura_data& data);
  void chiusura_ricavi(TChiusura_data& data);
  void chiusura_conto_economico(TChiusura_data& data);

  void chiusura_attivita(TChiusura_data& data);
  void chiusura_passivita(TChiusura_data& data);
  void chiusura_conti_ordine(TChiusura_data& data);
  void chiusura_conto_patrimoniale(TChiusura_data& data);

  TImporto apertura_attivita(TChiusura_data& data);
  TImporto apertura_passivita(TChiusura_data& data);
  void apertura_conti_ordine(TChiusura_data& data);
};

inline TEuro03_app& app() { return (TEuro03_app&)main_app(); }

///////////////////////////////////////////////////////////
// Main mask
///////////////////////////////////////////////////////////

class TEuro30_mask : public TAutomask
{ 
public:
  virtual bool on_field_event(TOperable_field& o, TField_event e, long jolly);
  virtual void on_firm_change();
  TEuro30_mask() : TAutomask("baeur30") { }
};

bool TEuro30_mask::on_field_event(TOperable_field& o, TField_event e, long jolly)
{
  return TRUE;
}

void TEuro30_mask::on_firm_change()
{
  TDate apertura(1,1,2002);
  TDate chiusura(31,12,2001);
  
  const long firm = app().get_firm();
  TFilename dati, datie;
  app().get_aree_dati(dati, datie);
  
  TString8 ditta; 
  ditta.format("%05ldA", firm);
  
  TFilename inie = datie;
  inie.add(ditta);
  inie.add("prassid.ini");
  
  bool adotta = FALSE, inizio = FALSE;
  if (inie.exist())
  {
    adotta = app().data_adozione_euro(firm, apertura, inizio);

    set(F30_DATI, dati);
    set(F30_DATIE, datie);

    TEsercizi_contabili esc;
   
    set(F30_DATA_A, apertura); 
    set(F30_ANNO_A, esc.date2esc(apertura));
    
    chiusura = apertura; --chiusura;
    set(F30_DATA_C, chiusura);
    set(F30_ANNO_C, esc.date2esc(chiusura));
    if (!adotta || !inizio)
    {
      disable(DLG_OK);
      error_box("Non č possibile utilizzare questa procedura:\n"
                "la ditta %ld non adotta l'Euro da inizio esercizio", firm);
    }
    else
      enable(DLG_OK);
  }
  else
  {
    disable(DLG_OK);
    error_box("Non č possibile utilizzare questa procedura:\n"
              "la ditta %ld non esiste nello studio in Euro.", firm);
  }
  
  TBill arrotino;
  if (app().load_round_bill(arrotino))
    arrotino.set(*this, F30_DIFARR_G, F30_DIFARR_C, F30_DIFARR_S);
  
  TFilename ini = dati;
  ini.add(ditta);
  ini.add("prassid.ini");
  if (ini.exist())
  {
    TConfig prassid(ini, "cg");
    set(F30_CAUS_C, prassid.get("CoCaCh"), TRUE);
    set(F30_CAUS_A, prassid.get("CoCaAp"), TRUE);
    
    set(F30_BILCHI_G, prassid.get("CsBiChG"));
    set(F30_BILCHI_C, prassid.get("CsBiChC"));
    set(F30_BILCHI_S, prassid.get("CsBiChS"), TRUE);
    set(F30_PROPER_G, prassid.get("CsPrPeG"));
    set(F30_PROPER_C, prassid.get("CsPrPeC"));
    set(F30_PROPER_S, prassid.get("CsPrPeS"), TRUE);
    set(F30_BILAPE_G, prassid.get("CsBiApG"));
    set(F30_BILAPE_C, prassid.get("CsBiApC"));
    set(F30_BILAPE_S, prassid.get("CsBiApS"), TRUE);
    set(F30_UTIPAT_G, prassid.get("CsUeCpG"));
    set(F30_UTIPAT_C, prassid.get("CsUeCpC"));
    set(F30_UTIPAT_S, prassid.get("CsUeCpS"), TRUE);
    set(F30_PERPAT_G, prassid.get("CsPeCpG"));
    set(F30_PERPAT_C, prassid.get("CsPeCpC"));
    set(F30_PERPAT_S, prassid.get("CsPeCpS"), TRUE);
    set(F30_UTIECO_G, prassid.get("CsUeCeG"));
    set(F30_UTIECO_C, prassid.get("CsUeCeC"));
    set(F30_UTIECO_S, prassid.get("CsUeCeS"), TRUE);
    set(F30_PERECO_G, prassid.get("CsPeCeG"));
    set(F30_PERECO_C, prassid.get("CsPeCeC"));
    set(F30_PERECO_S, prassid.get("CsPeCeS"), TRUE);
  }
}

///////////////////////////////////////////////////////////
// Main 
///////////////////////////////////////////////////////////

void TEuro03_app::close_saldi_prec(const TDate& dc)
{
  TEsercizi_contabili esc;
  const int annoes = esc.date2esc(dc);
  TLocalisamfile saldilit(LF_SALDI);  // Apre tracciati file!
  TEuroisamfile saldi(LF_SALDI, TRUE);
  for (int err = saldi.first(); err == NOERR; err = saldi.next())
  {
    const int anno = saldi.get_int(SLD_ANNOES);
    if (anno == annoes)
    {
      saldi.put(SLD_SALDOFIN, saldi.get(SLD_SALDO));
      saldi.put(SLD_FLAGSALFIN, saldi.get_char(SLD_FLAGSALINI) == 'A' ? 'D' : 'A');
      saldi.rewrite();
    }
    if (anno > annoes)
      break;
  }
}

void TEuro03_app::scan_saldi(int indbil, record_handler rh, void* jolly)
{                
  TChiusura_data& data = *(TChiusura_data*)jolly;

  TRelation rel(LF_SALDI);
  TRectype& rec = rel.curr();
  rec.put(SLD_ANNOES, data._anno_c);
  TCursor cur(&rel, "", 1, &rec, &rec);
  
  const long items = cur.items();
  cur.freeze();
  
  TString caption; 
  caption << "Scansione saldi dell'anno " << data._anno_c 
          << " con indicatore di bilancio " << indbil;
  TProgind pi(items, caption, FALSE, TRUE);
  for (cur = 0L; cur.pos() < items; ++cur)
  {
    pi.addstatus(1);
    const int g = rec.get_int(SLD_GRUPPO);
    const int c = rec.get_int(SLD_CONTO);
    if (g > 0 && c > 0)    // Should be pleonastic, but it's not!
    {
      if (indbil > 0)
      {
        const int i = data._movs.indbil(g, c);
        if (indbil != i)
          continue;
      }
      rh(rec, jolly);
    }
  }
}

///////////////////////////////////////////////////////////
// Ricavi
///////////////////////////////////////////////////////////

HIDDEN bool saldi_handler(TRectype& rec, void* jolly)
{
  TChiusura_data& data = *(TChiusura_data*)jolly;
  
  const int g = rec.get_int(SLD_GRUPPO);
  const int c = rec.get_int(SLD_CONTO);
  const long s = rec.get_long(SLD_SOTTOCONTO);
  const int indbil = data._movs.indbil(g, c);
  
  TSaldo sld;  // Incrociare le dita: si usa l'oggetto TSaldo
  sld.ultima_immissione_bilancio(data._anno_c, g, c, s, indbil, 1);
  real saldo = sld.saldo();
  
  if (saldo != ZERO)
  {      
    if (indbil != 5)  // La somma dei conti d'ordine č sempre ZERO
      data._totale_saldo += saldo;

    char sez = 'A';
    if (saldo < ZERO)
    {                
      sez = 'D';
      saldo = -saldo;
    }
    data._movs.mov(indbil).add(g, c, s, sez, saldo);
  }  
  return TRUE;
}

void TEuro03_app::chiusura_costi(TChiusura_data& data)
{
  scan_saldi(3, saldi_handler, &data);
  const TString desc = "Chiusura costi";
  data._movs.mov(3).save(data._data_c, data._caus_c, desc, 
                         data._proper, FALSE, FALSE, FALSE);
}

void TEuro03_app::chiusura_ricavi(TChiusura_data& data)
{
  scan_saldi(4, saldi_handler, &data);
  const TString desc = "Chiusura ricavi";
  data._movs.mov(4).save(data._data_c, data._caus_c, desc, 
                         data._proper, FALSE, FALSE, FALSE);
}

void TEuro03_app::salva_movimento_lit(const real& imp, const TBill& c1, const TBill& c2, 
                                      TChiusura_data& data, const TString& desc)
{
  TImporto i1('D', imp); i1.normalize();
  TCG_mov mov; 
  mov.add(c1, i1);
  mov.save(data._data_c, data._caus_c, desc, c2, FALSE, FALSE, FALSE);
}

void TEuro03_app::chiusura_conto_economico(TChiusura_data& data)
{ 
  const TString desc = "Chiusura conto economico";
  if (data._totale_saldo > 0)
  {
    salva_movimento_lit(data._totale_saldo, data._pereco, data._proper, data, desc);
    salva_movimento_lit(data._totale_saldo, data._perpat, data._pereco, data, desc);
  }
  else
  {
    salva_movimento_lit(data._totale_saldo, data._utieco, data._proper, data, desc);
    salva_movimento_lit(data._totale_saldo, data._utipat, data._utieco, data, desc);
  }
}

void TEuro03_app::chiusura_attivita(TChiusura_data& data)
{
  scan_saldi(1, saldi_handler, &data);
  const TString desc = "Chiusura attivitā";
  data._movs.mov(1).save(data._data_c, data._caus_c, desc, 
                         data._bilchi, FALSE, FALSE, FALSE);
}

void TEuro03_app::chiusura_passivita(TChiusura_data& data)
{
  scan_saldi(2, saldi_handler, &data);
  const TString desc = "Chiusura passivitā";
  data._movs.mov(2).save(data._data_c, data._caus_c, desc, 
                         data._bilchi, FALSE, FALSE, FALSE);
}

void TEuro03_app::chiusura_conti_ordine(TChiusura_data& data)
{
//  scan_saldi(5, saldi_handler, &data);
  const TImporto saldo = data._movs.mov(5).calc_bil(FALSE, FALSE);
  if (!saldo.is_zero())
  {
    const TString desc = "Chiusura conti d'ordine";
    data._movs.mov(5).save(data._data_c, data._caus_c, desc, 
                           data._bilchi, FALSE, FALSE, FALSE);
  }
}

void TEuro03_app::chiusura_conto_patrimoniale(TChiusura_data& data)
{
  const TString desc = "Chiusura conto patrimoniale";
  if (data._totale_saldo > 0)
  {
    salva_movimento_lit(data._totale_saldo, data._utipat, data._bilchi, data, desc);
  }
  else
  {
    salva_movimento_lit(data._totale_saldo, data._perpat, data._bilchi, data, desc);
  }
}

void TEuro03_app::salva_movimento_eur(const real& imp, const TBill& c1, const TBill& c2, 
                                      TChiusura_data& data, const TString& desc)
{
  TImporto i1('D', imp); i1.normalize();
  TCG_mov mov; 
  mov.add(c1, i1);
  mov.save(data._data_a, data._caus_a, desc, c2, TRUE, FALSE, FALSE);
}

TImporto TEuro03_app::apertura_attivita(TChiusura_data& data)
{
  const TString desc = "Apertura attivitā";
  return data._movs.mov(1).save(data._data_a, data._caus_a, desc, 
                                data._bilape, TRUE, TRUE, TRUE);
}

TImporto TEuro03_app::apertura_passivita(TChiusura_data& data)
{
  const TString desc = "Apertura passivitā";
  return data._movs.mov(2).save(data._data_a, data._caus_a, desc, 
                                data._bilape, TRUE, TRUE, TRUE);
}

void TEuro03_app::apertura_conti_ordine(TChiusura_data& data)
{
  const TImporto saldo = data._movs.mov(5).calc_bil(TRUE, FALSE);
  if (!saldo.is_zero())
  {
    const TString desc = "Apertura conti d'ordine";
    data._movs.mov(5).save(data._data_a, data._caus_a, desc, 
                           data._difarr, TRUE, TRUE, TRUE);
  }
}

///////////////////////////////////////////////////////////
// Main app
///////////////////////////////////////////////////////////

void TEuro03_app::main_loop()
{                
  goto_lire();
  set_firm();

  TEuro30_mask msk;
  msk.on_firm_change();
  if (msk.run() == K_ENTER)
  { 
    TChiusura_data data;
    
    data._caus_c = msk.get(F30_CAUS_C);
    data._data_c = msk.get(F30_DATA_C);
    data._anno_c = msk.get_int(F30_ANNO_C);
    
    data._caus_a = msk.get(F30_CAUS_A);
    data._data_a = msk.get(F30_DATA_A);
    data._anno_a = msk.get_int(F30_ANNO_A);
    
    data._bilchi.get(msk, F30_BILCHI_G, F30_BILCHI_C, F30_BILCHI_S);
    data._proper.get(msk, F30_PROPER_G, F30_PROPER_C, F30_PROPER_S);
    data._bilape.get(msk, F30_BILAPE_G, F30_BILAPE_C, F30_BILAPE_S);
    data._utipat.get(msk, F30_UTIPAT_G, F30_UTIPAT_C, F30_UTIPAT_S);
    data._perpat.get(msk, F30_PERPAT_G, F30_PERPAT_C, F30_PERPAT_S);
    data._utieco.get(msk, F30_UTIECO_G, F30_UTIECO_C, F30_UTIECO_S);
    data._pereco.get(msk, F30_PERECO_G, F30_PERECO_C, F30_PERECO_S);
    data._difarr.get(msk, F30_DIFARR_G, F30_DIFARR_C, F30_DIFARR_S);
    save_round_bill(data._difarr);
    
    // Scandisco i conti d'ordine fintanto che sono puliti!
    scan_saldi(5, saldi_handler, &data); 
    
    data._totale_saldo = ZERO;
    chiusura_costi(data);
    chiusura_ricavi(data);
    chiusura_conto_economico(data);
    
    data._totale_saldo = ZERO;
    chiusura_attivita(data);
    chiusura_passivita(data);
    chiusura_conti_ordine(data);
    
    close_saldi_prec(data._data_c); // Simula chiusura anche area euro
    
    TImporto bilancio;
    bilancio += apertura_attivita(data);
    bilancio += apertura_passivita(data);
    apertura_conti_ordine(data);   // La cui somma DEVE essere a ZERO
    
    if (!bilancio.is_zero())
    {                     
      const TString desc = "Rilevazione arrotondamenti";
      bilancio.normalize('D');
      salva_movimento_eur(bilancio.valore(), data._bilape, data._difarr, data, desc);
    }
  }
}

int baeur03(int argc, char* argv[])
{  
  TEuro03_app ma;
  ma.run(argc, argv, "Chiusura/Apertura conti in Euro");
  
  return 0;
}