#include <applicat.h>
#include <automask.h>
#include <progind.h>
#include <reputils.h>
#include <utility.h>
#include <relation.h>
#include <reprint.h>

#include "../ca/calib01.h"
#include "../ca/calib02.h"
#include "../ca/commesse.h"
#include "../ca/movana.h"
#include "../ca/rmovana.h"

#include "ps0713lib.h"

#include "ps0713200a.h"

                                       /////////////////////////////////
                                       ////    TIMPORTA_COMM_MSK    ////
                                       /////////////////////////////////

//Classe TImporta_comm_msk
class TImporta_comm_msk : public TAutomask
{
protected:
  virtual bool on_field_event(TOperable_field& o, TField_event e, long jolly);

public:
  TImporta_comm_msk();
};

//ON_FIELD_EVENT: metodo che gestisce i comportamenti dei vari campi della maschera
//(per adesso segnaposto)
bool TImporta_comm_msk::on_field_event(TOperable_field& f, TField_event e, long jolly)
{
  return true;
}

//metodo costruttore
TImporta_comm_msk::TImporta_comm_msk() 
                  : TAutomask("ps0713200a"){}  

                                       /////////////////////////////////
                                       ////    TIMPORTA_COMM_APP    ////
                                       /////////////////////////////////

//Classe TImporta_comm_app
class TImporta_comm_app : public TSkeleton_application
{
  virtual bool check_autorization() const {return false;}
  virtual const char * extra_modules() const {return "cg";}

	TImporta_comm_msk*				_msk;	

public:           
  virtual bool create();
  virtual bool destroy();
  virtual void main_loop();

  void scan_file(const TFilename& file, TAssoc_array& righe);
  void importa_cms(TAssoc_array& righe);

	bool transfer(const TFilename& file);
 
  TImporta_comm_app() {};
};

//SCAN_FILE: metodo che scandisce il file ed evita i duplicati
void TImporta_comm_app::scan_file(const TFilename& file, TAssoc_array& righe)
{
  TScanner s(file);
  TToken_string rec(50, ',');
  rec = s.line();
  
  TProgind pi(fsize(file), "Scansione file in corso...", true, true);

  //scorro tutto il file (per ogni riga devo riportare l'esito dell'importazione nel log)
  while (s.ok())
  {
    if (!pi.addstatus(s.tellg())) 
      break;

    TString16 idlavoro = rec.get(0);  idlavoro.strip("\"");

    //salto le righe vuote del file
    if (idlavoro.empty())
      continue;

    //recupero i dati di interesse dal file;
    //gruppo conto e sottoconto devono avere dei valori sensati
    TString gr = rec.get(1);  gr.strip("\"");  (gr == "" || gr == "?") ? gr ="0" : gr = gr;
    TString co = rec.get(2);  co.strip("\"");  (co == "" || co == "?") ? co ="0" : co = co;
    TString sc = rec.get(3);  sc.strip("\"");  (sc == "" || sc == "?") ? sc ="0" : sc = sc;

    TCommessa_string str(idlavoro, atoi(gr), atoi(co), atol(sc));
    if(!righe.is_key(str))
      righe.add(str, str);

    rec = s.line();
  }
}

void TImporta_comm_app::importa_cms(TAssoc_array& righe)
{
  TProgind pi(righe.items(), "Importazione commesse in corso...", true, true);
  TLog_report log("Importazione Commesse");

	TLocalisamfile com(LF_COMMESSE);

  FOR_EACH_ASSOC_OBJECT(righe, obj, key, itm)
  {
    if (!pi.addstatus(1))
      break;

    TCommessa_string cms(key);
    TString80 codcms = cms.idlavoro();
    TString str;

		str << "La commessa " << codcms;
		if (cache().get(LF_COMMESSE, codcms).empty())
		{
      const int  gruppo = cms.gruppo();   TString4  grup; grup.format("%03d",  gruppo);
      const int  conto  = cms.conto();    TString4  cont; cont.format("%03d",  conto);
      const long sotco  = cms.sotco();    TString8  sotc; sotc.format("%06ld", sotco);
      TString80 codconto; codconto << grup << cont << sotc;
			TString80 descr; descr << "Commessa " << codcms;
      TBill bill(gruppo, conto, sotco);
      const real percentuale(CENTO);

      com.put(COMMESSE_CODCMS,  codcms);
      com.put(COMMESSE_DESCRIZ, descr);
			com.put(COMMESSE_CODCONTO, codconto);

			int err = com.rewrite_write();

      if(err == NOERR)
      {
        str << " è stata inserita";
        log.log(0, str);
      }
      else
      {
        str << " NON è stata inserita. Errore = " << err;
        log.log(2, str);
      }
    }
    else
    {
      str << " NON è stata inserita perchè esiste già";
      log.log(2, str);
    }
  }

  //stampo a video il log
  TReport_book buc;
	buc.add(log);
	buc.preview();
}

TImporta_comm_app& app() { return (TImporta_comm_app&) main_app(); }

//TRASNFER: metodo che effettivamente svolge l'elaborazione di importazione
bool TImporta_comm_app::transfer(const TFilename& file)
{
  TAssoc_array righe;
  scan_file(file, righe);
  importa_cms(righe);
  return true;
}

bool TImporta_comm_app::create()
{
  _msk = new TImporta_comm_msk();
  return TSkeleton_application::create();
}

bool TImporta_comm_app::destroy()
{
	delete _msk;	
  return TApplication::destroy();
}

void TImporta_comm_app::main_loop()
{
  KEY	tasto;	
  tasto = _msk->run();
  if (tasto == K_ENTER)
  {
    //genero il nome del file da caricare
    TFilename name = _msk->get(F_PATH);
    name.add(_msk->get(F_NAME));
    TString str;
		if (transfer(name))
      message_box(TR("Importazione commesse completata"));
    else
      error_box(TR("L'importazione non è andata a buon fine"));		  
  }   
}

int ps0713200 (int argc, char* argv[])
{
  TImporta_comm_app main_app;
  main_app.run(argc, argv, TR("Importazione Commesse"));
  return true;
}