#include "../lv/lvlib.h"
#include "pl0002lib.h"
#include "pl0002100a.h"

#include <applicat.h>
#include <automask.h>
#include <defmask.h>
#include <progind.h>
#include <reprint.h>
#include <reputils.h>
#include <tabmod.h>
#include <tabutil.h>

#include <clifo.h>
#include <..\cg\cglib01.h>
#include <..\lv\lvcondv.h>
#include <..\lv\lvrcondv.h>
#include <..\mg\clifogiac.h>
#include <..\ve\condv.h>
#include <..\ve\rcondv.h>

const char* const APPNAME = TR("Conversione anagrafiche"); 

///////////////////////////////////////////////////////////
// Trasferimenti veri e propri
///////////////////////////////////////////////////////////

class TLif_clifo_co_clifor : public TLif_transfer
{
public:
  virtual bool trasferisci();
};

class TLif_clifo_ca_anagrafiche : public TLif_transfer
{
public:
  virtual bool trasferisci();
};

class TLif_clifo_ca_sedi : public TLif_transfer
{
protected:
  TISAM_recordset clifo(const char* ragsoc, const int key = 1) const;
  const long cerca_codf(const char* ragsoc) const;
public:
  virtual bool trasferisci();
};

class TLif_contratti : public TLif_transfer
{
public:
  virtual bool trasferisci();
};

class TLif_articoli : public TLif_transfer
{
public:
  virtual bool trasferisci();
};

class TLif_listini : public TLif_transfer
{
public:
  virtual bool trasferisci();
};

///////////////////////////////////////////////////////////
// TLif_clienti
///////////////////////////////////////////////////////////

// trasferisce la prima parte dei clienti
bool TLif_clifo_co_clifor::trasferisci()
{
  TString query = 
    "SELECT * "
		"FROM dbo.CO_CLIFOR";

  TRecordset& recset = create_recordset(query);
  TConfig& ini = config();
	
  TString_array lista_campi;
	ini.list_variables(lista_campi, true, "CO_CLIFOR", true);
  
  TSystemisamfile clienti(LF_CLIFO);
  clienti.open(_lock);
  TRectype& rec = clienti.curr();

  TSystemisamfile cfven(LF_CFVEN);
  cfven.open(_lock);
  TRectype& cfv_rec = cfven.curr();

  TLif_iterator hi(this);
  while (++hi)
  {
    const char     tipocf  = get_str("ind_clifor")[0];
    const long     codcf   = get_long("cod_clifor");
    const TString4 condpag = get_str("cod_pag");
    const real     fido    = get_real("val_fido");
    const char     sospeso = get_str("ind_bloccato")[0];

    TString16 codabi = get_str("cod_banca1");   codabi.lpad(5,'0');
    TString16 codcab = get_str("cod_agenzia1"); codcab.lpad(5,'0');
    TString80 iban   = get_str("sig_iban1");    iban << get_str("sig_bban1");

    const TString4 codspmezzo = get_str("cod_mezzo_trasp");
    const TString4 percprovv  = get_str("cod_catprovvi");
    const TString8 codag      = get_str("cod_agente");
    const bool     addbolli   = get_str("flg_addebito_bollo")[0] == '0' ? false : true;
    const long     percspinc  = get_str("flg_addebito_spese")[0] == '0' ? 0L : 100;
    const TString4 codporto   = get_str("cod_porto");

    TString8 codcli;
    codcli.format("%04d", codcf); codcli << "00";
    
    rec.zero();
    rec.put(CLI_TIPOCF,  tipocf);
    rec.put(CLI_CODCF,   codcli);
    rec.put(CLI_CODPAG,  condpag);
    rec.put(CLI_FIDO,    fido);
    rec.put(CLI_SOSPESO, sospeso == '0' ? false : true);
    rec.put(CLI_CODABI,  codabi);
    rec.put(CLI_CODCAB,  codcab);
    rec.put(CLI_IBAN,    iban);

    cfv_rec.zero();
    cfv_rec.put(CFV_TIPOCF,     tipocf);
    cfv_rec.put(CFV_CODCF,      codcli);
    cfv_rec.put(CFV_CODSPMEZZO, codspmezzo);
    cfv_rec.put(CFV_PERCPROVV,  percprovv);
    cfv_rec.put(CFV_CODAG,      codag);
    cfv_rec.put(CFV_ADDBOLLI,   addbolli);
    cfv_rec.put(CFV_PERCSPINC,  percspinc);
    cfv_rec.put(CFV_CODPORTO,   codporto);

    aggiorna_record(rec, lista_campi);
    if (test_write(clienti))
    {
			TString msg;
  		msg << TR("Inserito cliente ") << " '" << tipocf << "\' -> " 
          << codcli << " - " << rec.get(CLI_RAGSOC);
	  	log(msg);
    }
    aggiorna_record(cfv_rec, lista_campi);
    test_write(cfven);
  }
  cfven.close();
  clienti.close();
  return write_enabled();
  return true;
}

// trasferisce la seconda parte dei clienti
bool TLif_clifo_ca_anagrafiche::trasferisci()
{
  TString query = 
    "SELECT * "
		"FROM dbo.CA_ANAGRAFICHE";

  TRecordset& recset = create_recordset(query);
  TConfig& ini = config();
	
  TString_array lista_campi;
	ini.list_variables(lista_campi, true, "CA_ANAGRAFICHE", true);
  
  TSystemisamfile clienti(LF_CLIFO);
  clienti.open(_lock);
  TRectype& rec = clienti.curr();

  TLif_iterator hi(this);
  while (++hi)
  {
    const long codcf   = get_long("cod_anagra");
    
    TString8 codcli;
    codcli.format("%04d", codcf); codcli << "00";

    char tipocf = 'C';
    rec.zero();
    rec.put(CLI_TIPOCF, tipocf);
    rec.put(CLI_CODCF, codcli);
    int err = rec.read(clienti);
    if(err != NOERR)
    {
      tipocf = 'F';
      rec.zero();
      rec.put(CLI_TIPOCF, tipocf);
      rec.put(CLI_CODCF, codcli);
      err = rec.read(clienti);
    }

    if(err == NOERR)
    {
      const TString4  stato     = get_str("cod_naz");
      const TString80 ragsoc    = get_str("des_ragsoc");
      const TString16 cofi      = get_str("cod_cfisc");
      const TString16 paiv      = get_str("cod_piva");
      const long      tpper     = get_long("flg_per_fis");
      const TString80 mail      = get_str("des_email1");
      const TString80 tel       = get_str("sig_tel_fis");
      const TString80 fax       = get_str("sig_fax_fis");
      const TString80 indirizzo = get_str("des_indir_res");
      const long      cap       = get_long("cod_cap_fis");      
      TString   localita  = get_str("des_localita_fis"); localita.trim();
      TString8  capstr; capstr << cap;
      const TString4  codcom    = cap2comune(capstr, localita);

      rec.put(CLI_TIPOCF,   tipocf);
      rec.put(CLI_CODCF,    codcli);
      //rec.put(CLI_STATOCF,  stato);
      rec.put(CLI_RAGSOC,   ragsoc);
      rec.put(CLI_TIPOPERS, tpper == 0L ? 'G' : 'F');
      rec.put(CLI_COFI,     cofi);
      rec.put(CLI_PAIV,     paiv);
      rec.put(CLI_MAIL,     mail);
      rec.put(CLI_TEL,      tel);
      rec.put(CLI_FAX,      fax);
      rec.put(CLI_INDCF,    indirizzo);      
      rec.put(CLI_CAPCF,    cap);
      if(codcom.empty())
        rec.put(CLI_LOCCF,    localita);
      else
        rec.put(CLI_COMCF,    codcom);
      aggiorna_record(rec, lista_campi);
      if (test_write(clienti))
      {
			  TString msg;
  		  msg << TR("Inserito cliente ") << " '" << tipocf << "\' -> " 
            << codcf << " - " << rec.get(CLI_RAGSOC);
	  	  log(msg);
      }
    }
  }
  clienti.close();
  return write_enabled();
}

// trasferisce la terza parte dei clienti
bool TLif_clifo_ca_sedi::trasferisci()
{
  TString query = 
    "SELECT * "
		"FROM dbo.CA_SEDI";

  TRecordset& recset = create_recordset(query);
  TConfig& ini = config();
	
  TString_array lista_campi;
	ini.list_variables(lista_campi, true, "CA_SEDI", true);
  
  TSystemisamfile clienti(LF_CLIFO);
  clienti.open(_lock);
  TRectype& rec = clienti.curr();

  TSystemisamfile cfven(LF_CFVEN);
  cfven.open(_lock);
  TRectype& cfv_rec = cfven.curr();

  TLif_iterator hi(this);
  while (++hi)
  {
    TString8 codcf;   codcf.format("%04d", get_long("cod_anagra_sede"));
    TString4 codsede; codsede.format("%02d", get_long("cdn_sede"));
    TString8 codcli;  codcli << codcf << codsede;
    TString8 codcont; codcont << codcf << "00";

    TToken_string key;
    key.add('C');
    key.add(codcont);

    const TRectype& clifo_cache = cache().get(LF_CLIFO, key);
    const TRectype& cfven_cache = cache().get(LF_CFVEN, key);

    rec.zero();     rec = clifo_cache;
    cfv_rec.zero(); cfv_rec = cfven_cache;
        
    
    const TString80 ragsoc    = get_str("des_sede");
    const TString80 indirizzo = get_str("des_indir");
    const long      cap       = get_long("cod_cap");
    const TString4  prov      = get_str("sig_prov");
    const TString80 tel       = get_str("sig_tel");
    const TString16 cofi      = "";
    const TString   paiv      = "";
    const TString8  fatt_a    = codcont;
    TString80 localita  = get_str("des_localita"); localita.trim();
    TString8  capstr; capstr << cap;
    const TString4  codcom    = cap2comune(capstr, localita);


    rec.put(CLI_CODCF,     codcli);
    rec.put(CLI_RAGSOC,    ragsoc);
    rec.put(CLI_INDCF,     indirizzo);    
    rec.put(CLI_CAPCF,     0);   
    rec.put(CLI_TEL,       tel);
    rec.put(CLI_COFI,      cofi);
    rec.put(CLI_PAIV,      paiv);
    rec.put(CLI_CODCFFATT, fatt_a);
    rec.put(CLI_LOCCF,     localita);
    rec.put(CLI_COMCF,     "");

    cfv_rec.put(CFV_CODCF, codcli);

    aggiorna_record(rec, lista_campi);
    test_write(clienti);
    test_write(cfven);
  }  
  clienti.close();
  cfven.close();
  return write_enabled();
  return true;
}

///////////////////////////////////////////////////////////
// TLif_contratti
///////////////////////////////////////////////////////////

bool TLif_contratti::trasferisci()
{
  TString query = 
    "SELECT * "
		"FROM dbo.LIF_Contratti";

  TRecordset& recset = create_recordset(query);
  TConfig& ini = config();
	TString_array lista_campi;
	ini.list_variables(lista_campi, true, "CONTRATTI", true);
  TSystemisamfile condv(LF_LVCONDV);
  TSystemisamfile rcondv(LF_LVRCONDV);
  TSystemisamfile clifogiac(LF_CLIFOGIAC);
  condv.open(_lock);
  rcondv.open(_lock);
  clifogiac.open(_lock);
  TRectype& trec = condv.curr();
  TRectype& rrec = rcondv.curr();
  TRectype& grec = clifogiac.curr();

  const int anno = TDate(TODAY).year();

  TLif_iterator hi(this);

  TAssoc_array contratti;
  
  while (++hi)
  {
    const long codcf  = get_long("cod_clifor");
    const long codsed = get_long("cdn_sede");

    TString8 cod_anagra_sede; cod_anagra_sede.format("%04d", codcf);
    TString4 cdn_sede;        cdn_sede.format("%02d", codsed);
     
    TString8 codcli; codcli << cod_anagra_sede << cdn_sede;

    if(!contratti.is_key(codcli))
    {
      TDate dadata(get_str("dat_inizio"));
      bool inbolla = get_str("flg_nonriportaddt")[0] == 'N' ? false : true;

      trec.zero();
      trec.put(LVCONDV_CODCF,    codcli);
      trec.put(LVCONDV_CODCONT,  1);
      trec.put(LVCONDV_DATAIN,   dadata);
      trec.put(LVCONDV_STPRZBOL, inbolla);
      trec.put(LVCONDV_PERFAT,   3);  //da accordi con Tassan in data 23/03/2011 la fatturazione è sempre mensile
      test_write(condv);
      contratti.add(codcli, codcli);
    }
    
    rrec.zero();
    grec.zero();
    rrec.put(LVRCONDV_CODCF,   codcli);
    rrec.put(LVRCONDV_CODCONT, 1);

    const real dotin(get_str("qta_iniziale"));
    const real dotod(get_str("qta_attuale"));
    const TString80 codart = get_str("cod_art");

    grec.put(CLIFOGIAC_ANNOES,  anno);
    grec.put(CLIFOGIAC_TIPOCF,  'C');
    grec.put(CLIFOGIAC_CODCF,   codcli);
    grec.put(CLIFOGIAC_INDSPED, 0);
    grec.put(CLIFOGIAC_CODART,  codart);
    grec.put(CLIFOGIAC_NRIGA,   1);
    grec.put(CLIFOGIAC_DOTIN,   dotin);
    grec.put(CLIFOGIAC_DOTOD,   dotod);

    test_write(clifogiac);
    
    real prezzo(get_str("prezzo_inuso"));
    real mincic(get_str("qta_minimociclaggio"));
    real valcon(get_str("valore_convenzionale"));
    real percfo(get_str("perc_forfait"));
    real przfis(get_str("prezzo_quotesisse"));
   
    int bloccato = get_str("flg_disabilitato")[0] == '0' ? 0 : 1; //articolo in sostituzione ->accordi Tassan il 16/03/2011

    rrec.put(LVRCONDV_CODART,    codart);
    rrec.put(LVRCONDV_PREZZO,    prezzo);
    rrec.put(LVRCONDV_MINCIC,    mincic);
    rrec.put(LVRCONDV_VALCONV,   valcon);
    rrec.put(LVRCONDV_FORFPERCL, percfo);
    rrec.put(LVRCONDV_ARTBLOC,   bloccato);
    rrec.put(LVRCONDV_IMPFISART, przfis);

    test_write(rcondv);
  }
  condv.close();
  rcondv.close();

  return write_enabled();
}

bool TLif_articoli::trasferisci()
{
  TString query = 
    "SELECT * "
		"FROM dbo.MG_ARTICOLI";

  TRecordset& recset = create_recordset(query);
  TConfig& ini = config();
	
  TString_array lista_campi;
	ini.list_variables(lista_campi, true, "MG_ARTICOLI", true);
  
  TSystemisamfile anamag(LF_ANAMAG);
  anamag.open(_lock);
  TRectype& rec = anamag.curr();

  TSystemisamfile umart(LF_UMART);
  umart.open(_lock);
  TRectype& umrec = umart.curr();

  TAssoc_array articoli;

  TLif_iterator hi(this);
  while (++hi)
  {
    const TString80 codart = get_str("cod_art");
    const TString80 descr  = get_str("des_articolo");
    const TString   descragg = get_str("des_articolo_ex");
    const real      pnetto(get_str("qta_pes_netto_kg"));
    const long      ppconf = get_long("num_colli");
    const TString4  ump = pnetto > ZERO ? "GR" : "";

    rec.put(ANAMAG_CODART,   codart);
    rec.put(ANAMAG_DESCR,    descr);
    rec.put(ANAMAG_DESCRAGG, descragg);
    rec.put(ANAMAG_PESO,     pnetto);
    rec.put(ANAMAG_UMP,      ump);
    rec.put(ANAMAG_PPCONF,   ppconf);
    rec.put(ANAMAG_CODIVA,   "20");
    
    aggiorna_record(rec, lista_campi);
    if (test_write(anamag))
    {
      if(!articoli.is_key(codart))
      {
        umrec.put(UMART_CODART, codart);
        umrec.put(UMART_NRIGA,  1);
        umrec.put(UMART_UM,     "NR");
        test_write(umart);

        articoli.add(codart, codart);
      }
      TString msg;
		  msg << TR("Inserito articolo ") << " '" << codart << "\' -> " << descr;
  	  log(msg);
    }
  }
  anamag.close();
  return write_enabled();
  return true;
}

bool TLif_listini::trasferisci()
{
  TString query = 
    "SELECT * "
		"FROM dbo.PZ_PREZZIBASE";

  TRecordset& recset = create_recordset(query);
  TConfig& ini = config();
	
  TString_array lista_campi;
	ini.list_variables(lista_campi, true, "PZ_PREZZIBASE", true);
  
  TSystemisamfile umart(LF_UMART);
  umart.open(_lock);
  TRectype& umrec = umart.curr();

  TSystemisamfile condv(LF_LVCONDV);
  condv.open(_lock);
  TRectype& conrec = condv.curr();

  TSystemisamfile rcondv(LF_LVRCONDV);
  rcondv.open(_lock);
  
  TLif_iterator hi(this);

  TAssoc_array contratti;

  while (++hi)
  {
    const TString80 codart = get_str("cod_art");
    const TString4  codlis = get_str("cod_listino");
    const long      prglis = get_long("prg_listino");
    const real      prezzo(get_str("prz_listino"));

    TString8 listino = codlis; listino << prglis;

    umrec.zero();
    umrec.put(UMART_CODART, codart);
    umrec.put(UMART_NRIGA,  1);
    umrec.read(umart);
    umrec.put(UMART_CODART, codart);
    umrec.put(UMART_NRIGA,  1);
    umrec.put(UMART_PREZZO, prezzo);
    
    aggiorna_record(umrec, lista_campi);
    if (test_write(umart))
    {
      TString query;
      query << "USE LVRCONDV\n"
            << "SELECT CODART=\"" << codart << "\"";

      TISAM_recordset rcont(query);

      for(bool ok = rcont.move_first(); ok; ok = rcont.move_next())
      {
        TRectype& riga = rcont.cursor()->curr();
        riga.put(LVRCONDV_PREZDAN, prezzo);
        riga.rewrite(rcondv);

        const long codcf = riga.get_long(LVRCONDV_CODCF);
        const long codco = riga.get_long(LVRCONDV_CODCONT);

        TToken_string ckey;
        ckey.add(codcf);
        ckey.add(codco);

        if(!contratti.is_key(ckey))
        {
          conrec.put(LVCONDV_CODCF, codcf);
          conrec.put(LVCONDV_CODCONT, codco);
          conrec.read(condv);
          conrec.put(LVCONDV_CODCF, codcf);
          conrec.put(LVCONDV_CODCONT, codco);
          conrec.put(LVCONDV_ADDCAPROT, true);
          conrec.rewrite(condv);
        }
        contratti.add(ckey, ckey);
      }
    }
  }
  umart.close();
  condv.close();
  rcondv.close();

  return write_enabled();
}


///////////////////////////////////////////////////////////
// TImportazione_lif_msk
///////////////////////////////////////////////////////////

class TImportazione_lif_msk : public TAutomask
{
protected:
  virtual bool on_field_event(TOperable_field& o, TField_event e, long jolly);
  void serialize(bool bSave);

public:
  void trasferisci();

  TImportazione_lif_msk();
  virtual ~TImportazione_lif_msk();
};

// Funzione di trasferimento dati da/verso file .ini con lo stesso nome della maschera
// Andrebbe messo in libreria
void TImportazione_lif_msk::serialize(bool bSave)
{
  TFilename n = source_file(); n.ext("ini");  // Construisce il nome del .ini in base al .msk
  TConfig cfg(n, "Main");                     // Crea il file di configurazione
  TString4 id; 
  for (int i = fields()-1; i >= 0; i--)       // Scandisce tutti i campi della maschera ...   
  {
    TMask_field& f = fld(i);
    if (f.active() && f.is_loadable())        // ... selezionando solo quelli editabili
    {
      id.format("%d", f.dlg());
      if (bSave)                              // A seconda del flag di scrittura ... 
        cfg.set(id, f.get());                 // ... o scrive sul .ini 
      else 
        f.set(cfg.get(id));                   // ... o legge dal .ini
    }
  }
}

void TImportazione_lif_msk::trasferisci()
{
  TString query_header1;
  TString query_header2;

  query_header1 << "ODBC(" << get(F_DSN1) << ',' << get(F_USR) << ',' << get(F_PWD) << ")\n";
  query_header2 << "ODBC(" << get(F_DSN2) << ',' << get(F_USR) << ',' << get(F_PWD) << ")\n";

  TReport_book book;
  TLif_log log;

  bool rep_to_print = false;
  bool go_on = true;

  if (go_on && get_bool(F_ANAGRAFICHE))
  {
    TLif_clifo_co_clifor pc;
    pc.init(TR("Clienti / Fornitori"), query_header1, log);
    go_on = pc.trasferisci();

    TLif_clifo_ca_anagrafiche pc1;
    pc1.init(TR("Clienti / Fornitori"), query_header2, log);
    go_on = pc1.trasferisci();

    TLif_clifo_ca_sedi pc2;
    pc2.init(TR("Sedi"), query_header2, log);
    go_on = pc2.trasferisci();

    book.add(log);
		rep_to_print = true;
  }

  if (go_on && get_bool(F_CONTRATTI))
  {
    TLif_contratti pc;
    pc.init(TR("Contratti"), query_header1, log);
    go_on = pc.trasferisci();
    book.add(log);
		rep_to_print = true;
  }

  if (go_on && get_bool(F_ARTICOLI))
  {
    TLif_articoli pc;
    pc.init(TR("Articoli"), query_header1, log);
    go_on = pc.trasferisci();

    TLif_listini pc1;
    pc1.init(TR("Listini"), query_header1, log);
    go_on = pc1.trasferisci();

    book.add(log);
		rep_to_print = true;
  }

  if (rep_to_print && book.pages() > 0)
		book.preview();
}

bool TImportazione_lif_msk::on_field_event(TOperable_field& o, TField_event e, long jolly)
{
  switch (o.dlg())
  {
  case DLG_OK:
    if (e == fe_button)
      serialize(true);
    break;
  default:
    break;
  }
  return true;
}

TImportazione_lif_msk::TImportazione_lif_msk() : TAutomask("pl0002100a")
{
  serialize(false);
}

TImportazione_lif_msk::~TImportazione_lif_msk()
{ }

                                      /////////////////////////////////////
                                      ////    TIMPORTAZIONE_LIF_APP    ////
                                      /////////////////////////////////////

class TImportazione_lif_app : public TSkeleton_application
{
protected:
  virtual const char * extra_modules() const {return "ba";}
  virtual void main_loop();
};

void TImportazione_lif_app::main_loop()
{
  TImportazione_lif_msk mask;
  while (mask.run() == K_ENTER)
    mask.trasferisci();
}

int pl0002100(int argc, char* argv[])
{
  TImportazione_lif_app ih;
  ih.run(argc, argv, APPNAME);
  return 0;
}