#include <applicat.h>     
#include <automask.h>     
#include <config.h>     
#include <defmask.h>
#include <execp.h>
#include <incstr.h>
#include <golem.h>     
#include <prefix.h>
                    
#include <clifo.h>                    
#include <doc.h>                    
#include <rdoc.h>                    
                    
#include "ve6700a.h"
#include "velib04.h"
#include "../mg/mglib.h"

///////////////////////////////////////////////////////////
// Maschera principale
///////////////////////////////////////////////////////////

class TCopia_interattiva_mask : public TAutomask
{

protected:
  virtual bool on_field_event(TOperable_field& o, TField_event e, long jolly);

public:                         
  TCopia_interattiva_mask() : TAutomask("ve6700a") {}
  virtual ~TCopia_interattiva_mask() {}
};

bool TCopia_interattiva_mask::on_field_event(TOperable_field& o, TField_event e, long jolly)
{
  switch (o.dlg())
  {
  case DLG_SAVEREC:
    if (e == fe_button)
	    stop_run(K_AUTO_ENTER);
    break;  
  default:
    break;
  }
  return TRUE;
}

///////////////////////////////////////////////////////////
// Applicazione principale
///////////////////////////////////////////////////////////

class TCopia_interattiva : public TSkeleton_application
{ 
	TDocumento  * _outdoc;
	TDocumento  * _indoc;
	TFilename _ini_name;
	TElaborazione_esterna  * _e;
	TString16 _num_in;
	TArray _arts;
	TString16 _stato_in;
	TString16 _tipo_doc;
	long _firm;
	char _stato_fin;
	bool _copy_header;

public:
	bool load();
	bool load_indoc(const TMask & m);
	bool aggiorna_in();
	void copia_doc();
  virtual void main_loop();
};        

bool TCopia_interattiva::load()
{ 
	bool ok = false;
  const TApplication& a = main_app();
  const int argc = a.argc();

  if (argc > 2)
	{
		const TString& arg = a.argv(2);
		if ((arg[0] != '-' && arg[0] != '/') || (arg[1] != 'i' && arg[1] != 'I'))
			return false;
    
		_ini_name = arg.mid(2);
		if (_ini_name.blank() && argc > 3)  
			_ini_name = a.argv(3);
    
		if (_ini_name.exist())  
		{
			TConfig ini(_ini_name, "Transaction");
			const char provv = ini.get_char("ProvvOut");
			const int anno = ini.get_int("AnnoOut");
			const TString16 codnum(ini.get("CodNumOut"));
			const long numdoc = ini.get_long("NDocOut");

	    _e = new TElaborazione_esterna(ini.get("Action"));
			_num_in = _e->codice_numerazione_iniziale();
			_stato_in << _e->stato_iniziale(0);
			_stato_fin = _e->stato_finale_doc_iniziale()[0];
			_copy_header = _e->aggiorna_testata_se_vuoto();
 
			ok = _outdoc->read(provv, anno, codnum, numdoc) == NOERR;

			const int i = _outdoc->physical_rows();

			TString16 para;	para.format("%d", LF_DOC);

			_tipo_doc = ini.get(DOC_TIPODOC, para);
			_firm = -1;

			if (ok)
			{
				TFilename c("ve6700.ini");
				c.custom_path();

				if (c.exist())
				{
					TConfig val(c);
				
					_firm = val.get_long("Firm", "Main", -1, -1L);

  				TString16 para;
					TString tmp;
					
					para.format("%d", LF_DOC);
					val.set_paragraph(para);
					TAssoc_array& vars = val.list_variables();
					FOR_EACH_ASSOC_STRING(vars, obj, key, str)
					{
						if (*str == '"')
						{
							tmp = str;
							tmp.strip("\"");
							str = tmp;
						}
						_outdoc->put(key, str);
					}
				}
			}
		}
	}
  return ok;
}

bool TCopia_interattiva::load_indoc(const TMask & m)
{ 
	const char provv = m.get(DOC_PROVV)[0];
	const int anno = atoi(m.get(DOC_ANNO));
	const TString16 codnum(m.get(DOC_CODNUM));
	const long numdoc = atol(m.get(DOC_NDOC));
	if (numdoc <= 0L)
		return false;
  const bool ok = _indoc->read(provv, anno, codnum, numdoc) == NOERR;
	const int rows = _indoc->physical_rows();

	if (ok)
	{
		for (int i = 1; i <= rows; i++)
		{
			const TRiga_documento & r = (*_indoc)[i];

			if (r.is_articolo())
			{
				TArticolo * art = new TArticolo(r.get(RDOC_CODARTMAG));

			  art->um();
				art->deslin();
				art->codcorr();
				_arts.add(art);
			}
			const TString & memo = r.get(RDOC_DESCEST);
		}
	}

	return ok;
}

bool TCopia_interattiva::aggiorna_in()
{ 
  TApplication& a = main_app();
	
	_indoc->stato(_stato_fin);
	const int err = _indoc->rewrite();

	if (err != NOERR)
		return error_box("Errore %d di riscrittura del documento sorgente", err);

	const int rows = _indoc->physical_rows();

	for (int j = 1; j <= rows; j++)
	{
    TRiga_documento& rin = (*_indoc)[j]; 
    TRiga_documento& rout = _outdoc->new_row(); // ... crea una riga nuova e 

    _outdoc->copy_data(rout, rin);             // copiaci tutti i campi della riga sorgente.
    rout.reset_original_rdoc_key();
	}
	
	return err == NOERR;
}

void TCopia_interattiva::copia_doc()
{ 
	const int rows = _outdoc->physical_rows();

	_outdoc->reset_memo();

	for (int j = 1; j <= rows; j++)
	{
		TRiga_documento & r = (*_outdoc)[j];
	
		r.reset_memo();
	}
	
	int err = _outdoc->rewrite();

	if (err != NOERR)
	{
		error_box("Errore %d di riscrittura del documento destinazione", err);
		return;
	}
	FOR_EACH_ARRAY_ITEM(_arts, i, o)
	{
		TLocalisamfile anamag(LF_ANAMAG);
		TArticolo * art = (TArticolo *) o;

		anamag.put(ANAMAG_CODART, art->codice());
		if (anamag.read() != NOERR)
		{
			const int err = art->write();
			if (err != NOERR)
				error_box("Errore %d nella scrittura dell'articolo %s", err, (const char *) art->codice());
		}
	}
	TConfig ini(_ini_name, "Main");
	ini.set("Result", "OUTDOC");

}

void TCopia_interattiva::main_loop()
{                
  open_files(LF_TAB, LF_TABCOM, LF_DOC, LF_RIGHEDOC, LF_MOVMAG, NULL);
  open_files(LF_ANAMAG, LF_CLIFO, LF_CFVEN, LF_OCCAS, LF_RMOVMAG, NULL);
	_outdoc = new TDocumento();
  if (load())
	{
	  TCopia_interattiva_mask m;
	  TApplication& a = main_app();
		const long firm = a.get_firm();
		int err = safely_close_closeable_isamfiles();

		a.set_firm(_firm);
		_indoc = new TDocumento();
		m.set(F_CODDITTA, a.get_firm(), true);
		m.set(F_CODNUM, _num_in);
		m.set(F_STATO, _stato_in);
		m.set(F_TIPODOC, _tipo_doc);
		
		KEY k = m.run();
		
		bool ok = true;

		ok = load_indoc(m);
		if (ok)
			ok = aggiorna_in();
		delete _indoc;
		err = safely_close_closeable_isamfiles();
		a.set_firm(firm);
		copia_doc();
	}
	delete _outdoc;
}

int ve6700(int argc, char** argv)
{
  TCopia_interattiva app;

	app.run(argc, argv, TR("Trasferimento documenti"));
  return 0;
}