#include <applicat.h>
#include <automask.h>
#include <dongle.h>
#include <execp.h>
#include <modaut.h>
#include <prefix.h>
#include <progind.h>
#include <relation.h>

#include <nditte.h>
#include <partite.h>
#include <scadenze.h>
#include <pagsca.h>
#include <saldi.h>

#include "baeur.h"
#include "baeur10.h"
#include "baeur11.h"

#include "../cg/cglib01.h"
#include "../mg/mag.h"
#include "../mg/movmag.h"
#include "../mg/rmovmag.h"
#include "../mg/mglib.h"

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

class TEuro01_app : public TEuro_app
{ 
protected:
  void convert_saldi(const TDate& adozione, const TBill& arrotino);
  void convert_partite();
  
  virtual bool create();

public:
  KEY convert_firm(long ditta);

  virtual void main_loop();
};

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

///////////////////////////////////////////////////////////
// Step 3
///////////////////////////////////////////////////////////

class TEuro03_mask : public TAutomask
{ 
  void fill_ditte();
  
public:
  virtual bool on_field_event(TOperable_field& o, TField_event e, long jolly);
  TEuro03_mask() : TAutomask("baeur10") { }
};

void TEuro03_mask::fill_ditte()
{
  TFilename lit, eur;
  app().get_aree_dati(lit, eur);

  TRelation rel(LF_NDITTE);
  TCursor cur(&rel); 
  const TRectype& curr = rel.curr();
  const long items = cur.items();
  cur.freeze();
  
  TSheet_field& ditte = sfield(F03_DITTE);
  ditte.destroy();
  
  for (cur = 0L; cur.pos() < items; ++cur)
  {
    const long ditta = curr.get_long(NDT_CODDITTA);
    if (prefix().exist(ditta))
    {
      TToken_string& row = ditte.row(-1);
      row.add(" ");
      row.add(ditta);
      row.add(curr.get(NDT_RAGSOC));
      
      TFilename firm; 
      firm.format("%s/%05ldA", (const char*)eur, ditta);
      
      COLOR col = COLOR_BLACK;
      if (firm.exist())
      {
        firm.add("prassid.ini");
        TConfig ini(firm, "Euro");
        TString16 dde = ini.get("DataAdozione");
        if (dde.empty())
        {
          row.add("Creata direttamente in Euro");
          col = COLOR_RED;
        }
        else
        {    
          TString str; str << "Adotta l'Euro dal " << dde;
          row.add(str);
          col = COLOR_GREEN;
        }
      }
      else
      {
        row.add("X", 0);
        row.add("Non presente in Euro");
      }
      if (col != COLOR_BLACK)
      {
        int i = ditte.items()-1;
        ditte.set_back_and_fore_color(col, -1, i);
      }
    }
  }
  
  ditte.force_update();
}

bool TEuro03_mask::on_field_event(TOperable_field& o, TField_event e, long jolly)
{
  switch (o.dlg())
  {              
  case F03_DITTE:
    if (e == fe_init)
      fill_ditte();
    if (e == se_query_add || e == se_query_del)
      return FALSE;
    break;
  default: 
    break;
  }
  return TRUE;
} 

///////////////////////////////////////////////////////////
// Step 4 - Conversione ditta
///////////////////////////////////////////////////////////

class TEuro11_mask : public TAutomask
{ 
public:
  virtual bool on_field_event(TOperable_field& o, TField_event e, long jolly);
  TEuro11_mask() : TAutomask("baeur11") { }
};

bool TEuro11_mask::on_field_event(TOperable_field& o, TField_event e, long jolly)
{
  switch (o.dlg())
  {
  case F11_ADOZIONE:
    if (e == fe_modify || e == fe_close)
    {
      TEsercizi_contabili esc;
      TDate d = o.get();
      if (!d.ok())
        return error_box("E' necessario specificare la data di adozione dell'Euro");
      const int codesc = esc.date2esc(d);
      if (codesc <= 0)
        return error_box("E' necessario aprire l'esercizio per l'anno %d", d.year());
/*      TLocalisamfile sch(LF_SCHPERC);
      
      if (sch.items() > 0L)
      {
        bool inizio;
        
        data_adozione_euro(-1L, d, inizio);        
        if (!inizio)
           return error_box("La conversione dei percipienti puó essere effettuata solo a inizio esercizio");
      }     
*/
      
      if (d.day() != 1)
        warning_box("Si consiglia di specificare una data di inizio mese/trimestre");
      if (dongle().active(MGAUT))
      {
        TConfig c(CONFIG_DITTA, "mg");
        if (c.get_bool("GESMAG") && d != esc[codesc].inizio())
        {   
          const int prevesc = esc.date2prevesc(d);
          if (prevesc > 0)
          {
            const TDate& cm = esc[prevesc].chiusura_mag();
            if (!cm.ok())
             return error_box("E' necessario chiudere il magazzino nel %d", prevesc);
          }
        }
      }
    }
    break;
  default: break;
  }
  return TRUE;
}

///////////////////////////////////////////////////////////
// Conversione ditta
///////////////////////////////////////////////////////////

struct TMag_data
{  
  int _annoesrif;
  TString _fields;
  TString _zero_fields;
};

static bool mag_handler(TRectype& rec, void* jolly)
{          
  TMag_data& mag = *(TMag_data*)jolly;
  const int annoesrif = *((int *) jolly);
  const int annoes = rec.get_int(MAG_ANNOES);
  if (annoes >= mag._annoesrif)
    zero_import(rec, mag._zero_fields);
  else
    convert_import(rec, mag._fields);
  return TRUE;
}

static bool movmag_handler(TRectype& rec, void* jolly)
{          
  TMag_data& mag = *(TMag_data*)jolly;
  const int annoesrif = *((int *) jolly);
  const int annoes = rec.get_int(MOVMAG_ANNOES);
  return annoes >= annoesrif;  
}

static bool righemovmag_handler(TRectype& rec, void* jolly)
{          
  TMag_data& mag = *(TMag_data*)jolly;
  const int annoesrif = *((int *) jolly);
  TString16 key; key << rec.get_long(RMOVMAG_NUMREG);
  const int annoes = atoi(cache().get(LF_MOVMAG, key, MOVMAG_ANNOES));
  return annoes >= annoesrif;  
}

struct TTab_data
{
  int _codes_rif, _annoes_rif;
};

/* static bool perc_handler(TRectype& rec, void* jolly)
{
  return app().get_firm() ==  rec.get_long("CODDITTA");
}

static bool sch_handler(TRectype& rec, void* jolly)
{            
  bool ok = perc_handler(rec, jolly);
  if (ok)  
  {
    
  }
  return ok;
}  */

static bool tab_handler(TRectype& rec, void* jolly)
{
  const TString& cod = rec.get("COD");

  if (cod == "CAM")
    return FALSE;

  if (cod == "ESC")
  {    
    TTab_data* data = (TTab_data*)jolly;
    const int ese = rec.get_int("CODTAB");
    return ese >= data->_codes_rif;
  }
  if (cod == "REG")
  {
    TTab_data* data = (TTab_data*)jolly;
    const int annoes = atoi(rec.get("CODTAB").left(4));
    zero_import(rec, "R0|R1|R2");
    return annoes >= data->_annoes_rif;  
  }
  if (cod == "SPP" || cod == "PRS")
  {
    const TString16 val = rec.get("S4");
    if (is_firm_value(val))
    {
      rec.zero("S4");
      convert_import(rec, "R0");
    }
    else
    {
      if (is_euro_value(val))
        rec.zero("S4");
    }
    return TRUE;    
  }
  if (cod == "RFA")
  {
    zero_import(rec, "R1|R2");
    return TRUE;
  }
  if (cod == "LAM" || cod == "LIM" || cod == "PIM" || cod == "PUM" || cod == "PAM" || 
      cod == "POM" || cod == "PLM" || cod == "PPA" || cod == "PRM")
    return FALSE;

  return TRUE;
}

static bool conv_condv(TRectype& rec, void* jolly)
{
  const TString16 val = rec.get("CODVAL");
  
  if (is_firm_value(val) || is_euro_value(val))
  {
    rec.zero("CODVAL");
    rec.zero("CAMBIO");
    rec.zero("CONTROEURO");
  }
  else
    if (!rec.get_bool("CONTROEURO"))
    {
      real contro_change = EURO / rec.get_real("CAMBIO");
  
      rec.put("CAMBIO", contro_change);
      rec.put("CONTROEURO", "X");
    }
  return TRUE;  
}

static bool conv_rcondv(TRectype& rec, void* jolly)
{
  TString80 key;
  
  key << rec.get("TIPO");
  key << "|" << rec.get("CATVEN");
  key << "|" << rec.get("TIPOCF");
  key << "|" << rec.get("CODCF");
  key << "|" << rec.get("COD");
  
  const TString16 val = cache().get(LF_CONDV, key, "CODVAL");
  
  if (is_firm_value(val))
    convert_import(rec, "PREZZO");
  return TRUE;  
}

KEY TEuro01_app::convert_firm(long ditta)
{          
  TFilename lit, eur;
  get_aree_dati(lit, eur);
  prefix().set_studio(lit, ditta);

  TString16 firm; firm.format("%05ldA", ditta);
  TFilename litf = lit; litf.add(firm);
  TFilename eurf = eur; eurf.add(firm);
  
  const bool already_present = eurf.exist();
  bool do_copy    = !already_present;
  bool do_saldi   = !already_present;
  bool do_partite = !already_present;
  bool do_vendite = !already_present;
  bool do_magazzino = !already_present;

  TDate adozione;
  TBill arrotino;

  KEY k = K_ENTER;
  if (k == K_ENTER)
  {
    TEuro11_mask m;
    m.set(F11_DITTA, ditta, TRUE);
    m.set(F11_DATI, lit);
    m.set(F11_DATIE, eur);
    m.set(F11_COPY, do_copy ? "X" : "");
    m.set(F11_SALDI, do_saldi ? "X" : "");
    m.set(F11_PARTITE, do_partite ? "X" : "");
    m.set(F11_VENDITE, do_vendite ? "X" : "");
    m.set(F11_MAGAZZINO, do_magazzino ? "X" : "");
    
    if (already_present)
    {
      TFilename ini = eurf; ini.add("prassid.ini");
      TConfig prassid(ini, "Euro");
      adozione = prassid.get("DataAdozione");
      m.set(F11_ADOZIONE, adozione);
    }
    m.enable(-1, already_present);  // Abilita i vari checkbox

    if (load_round_bill(arrotino))
    {
      arrotino.set(m, F11_DIFF_G, F11_DIFF_C, F11_DIFF_S);
      m.field(F11_DIFF_S).check(STARTING_CHECK);
    }
    
    k = m.run();
    adozione = m.get(F11_ADOZIONE);
    arrotino.get(m, F11_DIFF_G, F11_DIFF_C, F11_DIFF_S);
    do_copy = m.get_bool(F11_COPY);
    do_saldi = m.get_bool(F11_SALDI);
    do_partite = m.get_bool(F11_PARTITE);
    do_vendite = m.get_bool(F11_VENDITE);
    do_magazzino = m.get_bool(F11_MAGAZZINO);
  }
  if (k == K_ENTER)
  {
    if (do_copy && already_present)
      do_copy = yesno_box("Si conferma la sovrascrittura della ditta %ld in Euro?", ditta);
      
    TEsercizi_contabili esc;
    const int codes_rif = esc.date2prevesc(adozione);
    const int annoes_rif = adozione.year()-1;
      
    if (do_copy)  
    {                    
      TCurrency::force_cache_update();  // Chiude cache valute     
      prefix().set(NULL);               // Chiude files ditta
      copy_dir(litf, eurf);
      
      if (adozione.ok())  // Dummy test
      {
        TFilename ini = eurf; ini.add("prassid.ini");
        TConfig prassid(ini, "Euro");
        prassid.set("DataAdozione", adozione.string());
      }
      
      save_round_bill(arrotino);
      
      prefix().set(".");  // Riapre files ditta
      set_firm(ditta);
      
      TTab_data data;
      data._codes_rif = codes_rif;
      data._annoes_rif = annoes_rif;
      convert_file(LF_TAB, NULL, NULL, tab_handler, (void*)&data);

      if (is_firm_file(LF_CLIFO))
      {
        convert_file(LF_CLIFO, NULL, "FIDO", NULL, NULL);
        convert_file(LF_CFVEN, "IMPMINEFF", "MINORD|MAXORD", NULL, NULL);
      }
      
      zap_file(LF_MOV, TRUE);     // Cancella movimenti di prima nota dell'area euro
      zap_file(LF_RMOV, TRUE);    // Cancella righe di prima nota dell'area euro
      zap_file(LF_RMOVIVA, TRUE); // Cancella righe iva dell'area euro
 
      zap_file(LF_REFFETTI, TRUE);
      zap_file(LF_EFFETTI, TRUE);
      zap_file(LF_CESS, TRUE);
  
      zap_file(LF_INTRA, TRUE);     
      zap_file(LF_RINTRA, TRUE);     
      zap_file(LF_RIEPRETT, TRUE);     
      
/*      convert_file(LF_PERC, NULL, NULL, perc_handler, (void*)&data);
      convert_file(LF_SCHPERC, NULL, NULL, sch_handler, (void*)&data);
      convert_file(LF_RVER, NULL, NULL, sch_handler, (void*)&data);
      convert_file(LF_RPAG, NULL, NULL, sch_handler, (void*)&data); */
    }
    
    if (do_saldi)
      convert_saldi(adozione, arrotino); // Converti saldi

    if (do_partite)
      convert_partite();                 // Converti partite

    if (do_vendite)
    {
      zap_file(LF_DOC, TRUE);
      zap_file(LF_RIGHEDOC, TRUE);     

      convert_file(LF_ANAMAG, "COSTSTD|ULTCOS1|ULTCOS2|VALSTATUN", "");
      convert_file(LF_UMART, "PREZZO", "");
      
      // cvrt condv codval cambio
      // cvrt rcondv prezzo
      convert_file(LF_RCONDV, "", "", conv_rcondv);
      convert_file(LF_CONDV, "", "", conv_condv);
      convert_file(LF_SVRIEP, "VALORE", "");
    }
 
    if (do_magazzino)
    {
      TMag_data mag;
      mag._annoesrif = esc.date2esc(adozione);
      mag._zero_fields << "RIM|VALRIM|ACQ|VALACQ|ENT|VALENT|VEN|VALVEN|USC|VALUSC|GIAC|ORDF|VALORDF|";
      mag._zero_fields << "ORDC|VALORDC|INCL|ACL|PRODCOMP|PRODFIN|NLABEL|NDIST|SCARTI|VALSCARTI|";
      mag._zero_fields << "USER1|USERVAL1|USER2|USERVAL2|USER3|USERVAL3|";
      mag._zero_fields << "USER4|USERVAL4|USER5|USERVAL5|USER6|USERVAL6";
      
      mag._fields << "VALRIM|VALACQ|VALENT|VALVEN|VALUSC|VALORDF|VALORDC|VALSCARTI|";
      mag._fields << "USERVAL1|USERVAL2|USERVAL3|USERVAL4|USERVAL5|USERVAL6";
      
      convert_file(LF_MAG, "", "", mag_handler, (void*)&mag);
      convert_file(LF_MOVMAG, "", "", movmag_handler, (void*)&mag);
      convert_file(LF_RMOVMAG, "PREZZO", "", righemovmag_handler, (void*)&mag);

      convert_file(LF_STOMAG, "VALORE|ULTCOS1|COSTSTD|COSTOMEDIO|PRZLIST", "");     
      convert_file(LF_DIST, "PREZZO", "");

      TExternal_app app("baeur -6 S");
      app.run();
    }
  }
  
  return k;
}

///////////////////////////////////////////////////////////
// Conversione saldi
///////////////////////////////////////////////////////////

struct TSaldi_data
{  
  int _annoes;
  TBill _arrot;
  TImporto _sld;
};

static bool saldi_handler(TRectype& rec, void* jolly)
{ 
  TSaldi_data& sld = *(TSaldi_data*)jolly;
  const int annoes = rec.get_int(SLD_ANNOES);
  if (annoes == sld._annoes)
  {
    const TImporto iniz(rec.get_char(SLD_FLAGSALINI), rec.get_real(SLD_SALDO));
    const TImporto pdare('D', rec.get_real(SLD_PDARE));
    const TImporto pavere('A', rec.get_real(SLD_PAVERE));
    TImporto saldo = iniz; saldo += pdare; saldo += pavere; 
    if (!saldo.is_zero())
    {
      saldo.normalize();
      rec.put(SLD_FLAGSALINI, saldo.sezione());
      rec.put(SLD_SALDO, saldo.valore());
      convert_import(rec, "SALDO|FLAGSALFIN|SALDOFIN");
      zero_import(rec, "PDARE|PAVERE|PDAREPRO|PAVEREPRO");
      sld._sld += TImporto(saldo.sezione(), rec.get_real(SLD_SALDO));  // Somma saldo in euro
      return TRUE;
    }
  }  
  
  return FALSE;           
}

void TEuro01_app::convert_saldi(const TDate& adozione, const TBill& arrotino)
{
  TEsercizi_contabili esc;

  TSaldi_data sld;
  sld._annoes = esc.date2prevesc(adozione);
  sld._arrot = arrotino;
  convert_file(LF_SALDI, NULL, NULL, saldi_handler, &sld);
  
  TImporto& saldo = sld._sld;
  saldo.valore().round(-2);
  if (!saldo.is_zero())
  {       
    TLocalisamfile saldi_lire(LF_SALDI); // Open trc
    TEuroisamfile saldi(LF_SALDI, TRUE);
  
    TRectype& curr = saldi.curr();
    curr.zero();
    curr.put(SLD_ANNOES, sld._annoes);
    curr.put(SLD_GRUPPO, arrotino.gruppo());
    curr.put(SLD_CONTO, arrotino.conto());
    curr.put(SLD_SOTTOCONTO, arrotino.sottoconto());
    
    saldo.normalize();
    saldo.swap_section();
    curr.put(SLD_FLAGSALINI, saldo.sezione());
    curr.put(SLD_SALDO, saldo.valore());
    saldi.write();
  }
}

///////////////////////////////////////////////////////////
// Conversione partite
///////////////////////////////////////////////////////////

struct TSaldac_data
{ 
  real _totrate;
};

bool partite_handler(TRectype& rec, void* jolly)
{
  if (rec.get_bool(PART_CHIUSA) || rec.get_int(PART_NRIGA) == 9999)
    return FALSE;
    
  TSaldac_data* data = (TSaldac_data*)jolly;
    
  const TString16 codval = rec.get(PART_CODVAL);
  if (::is_firm_value(codval))
  {
    convert_import(rec, PART_ABBUONI);
    zero_import(rec, "CODVAL|IMPORTOVAL|DIFFCAM");
  } else
  if (::is_euro_value(codval))
  {
    zero_import(rec, "CODVAL|IMPORTOVAL|DIFFCAM");
  } else
  if (::is_true_value(codval))
  {
    const real impval = rec.get(PART_IMPORTOVAL);
    if (impval != ZERO)
    {
      const real impeur = rec.get(PART_IMPORTO);
      const real cambio = impeur / impval;
      rec.put(PART_CAMBIO, cambio);
    }
  }
  return TRUE;  
}

bool scadenze_handler(TRectype& rec, void* jolly)
{ 
  TSaldac_data* sd = (TSaldac_data*)jolly;

  TEuroisamfile part(LF_PARTITE, TRUE);
  TRectype& curr = part.curr();
  curr.zero();
  curr.put(PART_TIPOCF, rec.get(SCAD_TIPOCF));
  curr.put(PART_GRUPPO, rec.get(SCAD_GRUPPO));
  curr.put(PART_CONTO, rec.get(SCAD_CONTO));
  curr.put(PART_SOTTOCONTO, rec.get(SCAD_SOTTOCONTO));
  curr.put(PART_ANNO, rec.get(SCAD_ANNO));
  curr.put(PART_NUMPART, rec.get(SCAD_NUMPART));
  curr.put(PART_NRIGA, rec.get(SCAD_NRIGA));
  if (part.read() != NOERR)
    return FALSE;
    
  const int nrata = rec.get_int(SCAD_NRATA);
  if (nrata == 1)
    sd->_totrate = ZERO;
  sd->_totrate += rec.get_real(SCAD_IMPORTO);
  
  // I problemi di arrotondamento dovrei averli solo con tante rate
  if (nrata > 1)
  {
    TLocalisamfile scad(LF_SCADENZE, FALSE);
    scad.curr() = rec;
    scad.curr().put(SCAD_NRATA, nrata+1);
    if (scad.read() != NOERR)   // Sono l'ultima rata
    {
      real toteur = part.get(PART_IMPTOTDOC); 
      toteur /= EURO; 
      toteur.round(2);
      const real diff = toteur - sd->_totrate; 
      if (diff != ZERO)
      {
        real rata = rec.get(SCAD_IMPORTO);
        rata += diff;
        rec.put(SCAD_IMPORTO, rata);
      }
    }
  }  
  return TRUE;  
}

bool pagamenti_handler(TRectype& rec, void* jolly)
{ 
  TSaldac_data* sd = (TSaldac_data*)jolly;

  TEuroisamfile part(LF_PARTITE, TRUE);
  TRectype& curr = part.curr();
  curr.zero();
  curr.put(PART_TIPOCF, rec.get(PAGSCA_TIPOC));
  curr.put(PART_GRUPPO, rec.get(PAGSCA_GRUPPO));
  curr.put(PART_CONTO, rec.get(PAGSCA_CONTO));
  curr.put(PART_SOTTOCONTO, rec.get(PAGSCA_SOTTOCONTO));
  curr.put(PART_ANNO, rec.get(PAGSCA_ANNO));
  curr.put(PART_NUMPART, rec.get(PAGSCA_NUMPART));
  curr.put(PART_NRIGA, rec.get(PAGSCA_NRIGA));
  if (part.read() != NOERR)
    return FALSE;
  
  // Ero in lire (ora sono in euro) devo convertire gli abbuoni
  if (curr.get_real(PART_IMPORTOVAL) == ZERO)  
    convert_import(rec, PAGSCA_ABBUONI);
  
  return TRUE;  
}

void TEuro01_app::convert_partite()
{                  
  TSaldac_data data;
  convert_file(LF_PARTITE, "IMPORTO|IMPOSTA|SPESE|RITENUTE", PART_NREG, partite_handler, &data);
  
  TLocalisamfile part(LF_PARTITE);  // Serve ad avere disponibile il tracciato record
  convert_file(LF_SCADENZE, "IMPORTO", NULL, scadenze_handler, &data);
  convert_file(LF_PAGSCA, "IMPORTO|RITENUTE", NULL, pagamenti_handler, &data);
}

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

bool TEuro01_app::create()
{                
  TFilename lit, eur;
  if (!app().get_aree_dati(lit, eur))
    return error_box("Non esiste lo studio in Euro di destinazione");
  return TEuro_app::create();  
}

void TEuro01_app::main_loop()
{ 
  KEY k = K_ENTER;
  while (k == K_ENTER)
  {  
    TString_array lista;
    if (goto_lire())
    {
      TEuro03_mask m;
      k = m.run();   
      if (k == K_ENTER)
      {
        TSheet_field& ditte = m.sfield(F03_DITTE);
        lista = ditte.rows_array();
      }
    }
    if (lista.items() > 0)
    {
      FOR_EACH_ARRAY_ROW(lista, r, row) if (*row->get(0) > ' ')
      {
        const long ditta = row->get_long(1);
        KEY t = convert_firm(ditta);
        if (t == K_ESC)
          break;
      }
    }
    else
      break;
  }
}

int baeur01(int argc, char* argv[])
{  
  TEuro01_app ma;
  ma.run(argc, argv, "Conversione Ditte Euro");
  
  return 0;
}