// Rinumerazione movimenti e saldi
// fv 12/12/93
// -------------------------------------------------------------------------
// *TBI* Partenza dall'ultimo movimento stampato
// *TBI* Aggiornamento scadenziario
// *TBI* Aggiornamento cespiti
// -------------------------------------------------------------------------

#include <applicat.h>
#include <isam.h>
#include <sort.h>
#include <lffiles.h>
#include <urldefid.h>
#include <stdlib.h>
#include <utility.h>
#include <mask.h>
#include <progind.h>

//#if XVT_OS == XVT_OS_SCOUNIX
#include <signal.h>
//#endif

#define FLD_CG41_YEAR 100

#include <mov.h>
#include <rmov.h>
#include <rmoviva.h>
#include <saldi.h>
#include <causali.h>

// for access()
#if XVT_OS == XVT_OS_DOS || XVT_OS == XVT_OS_WIN
#include <io.h>
#else
#include <unistd.h>
#endif

struct therec {
	char DATAREG[7];
  char REG[4];
  char DATADOC[7];
  char NUMDOC[7];
  char ANNOES[5];
  char NUMREG[8];
};

struct truc {
  char GRUPPO[4];
  char CONTO[4];
  char SOTTOCONTO[7];
  char SEZIONE[2];
  char IMPORTO[19];
  char NUMREG[8];
};


class CG4100_App : public TApplication
{
  TString _year;

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

  bool set_parms(bool year);
	virtual bool menu(MENU_TAG m);

  void restore_mov(TSystemisamfile& a, TSystemisamfile& b, TSystemisamfile& c);
  void sort_all();
  bool sort_mov();
  bool sort_sal();

  CG4100_App() : TApplication(), _year(4)
    { }
	virtual ~CG4100_App() {}
};


bool CG4100_App::create()
{
  TApplication::create();

// UNIX: signal() per intercettare errori
#if XVT_OS == XVT_OS_SCOUNIX
	signal(SIGINT,SIG_IGN);
#endif

	if (fexist("__sal__.sav"))
		warning_box("Un'operazione di riordino saldi si e' conclusa"
								" impropriamente. Si raccomanda di rieseguirla");

	if (fexist("__mov__.sav"))
		warning_box("Un'operazione di riordino movimenti si e' conclusa"
								" impropriamente. Si raccomanda di rieseguirla");

	return TRUE;
}

bool CG4100_App::destroy()
{
// UNIX: resettare i segnali
#if XVT_OS == XVT_OS_SCOUNIX
	signal(SIGINT,SIG_DFL);
#endif

  return TApplication::destroy();
}

bool CG4100_App::set_parms(bool year)
{
	TMask m("cg4100a");

  if (!year)
    m.hide(FLD_CG41_YEAR);

  m.run();

	_year = m.get(FLD_CG41_YEAR);

  return m.last_key() == K_ENTER;
}


bool CG4100_App::menu(MENU_TAG m)
{
	switch (m)
		{
		case BAR_ITEM(1):
			sort_mov();
			break;
		case BAR_ITEM(2):
			sort_sal();
			break;
		}
	return TApplication::menu(m);
}


void CG4100_App::restore_mov(TSystemisamfile& mov, TSystemisamfile& rmov,
					 TSystemisamfile& rmoviva)
{
  long rn, rec;
	if (fexist("__mov__.ind"))
    {
      // rebuild all indexes
      mov.close(); rmov.close(); rmoviva.close();
      mov.packfile(); rmov.packfile(); rmoviva.packfile();
      mov.packindex(); rmov.packindex(); rmoviva.packindex();
      remove("__mov__.ind");
      return;
    }

  FILE* fp = fopen("__mov__.sav","r");
  if (feof(fp)) 
    { 
    warning_box("File di ripristino vuoto; il ripristino non e' necessario"); 
    remove("__mov__.sav");
    return; 
  }; 
  
  for (;;)
    {
      if (feof(fp)) break;
      fscanf(fp,"%ld %ld", &rn, &rec);
      
      mov.readat(rec);
			mov.curr().put(MOV_NUMREG,format("%ld",rn));
      mov.rewrite();
      
      for (;;)
	{
	  if (feof(fp)) break;
	  fscanf(fp,"%ld",&rec);
	  if (rec == -1l) break;
	  rmov.readat(rec);
		rmov.curr().put(RMV_NUMREG,format("%ld",rn));
	  rmov.rewrite();
	}
      for (;;)
	{
	  if (feof(fp)) break;
	  fscanf(fp,"%ld",&rec);
	  if (rec == -1l) break;
	  rmoviva.readat(rec);
		rmoviva.curr().put(RMI_NUMREG,format("%ld",rn));
	  rmoviva.rewrite();
	}
    }
  
  fclose(fp);
  remove("__mov__.sav");  
}


bool CG4100_App::sort_mov()
{
	if (!set_parms(FALSE))
		return FALSE;

	TSystemisamfile mov(LF_MOV);
	TSystemisamfile rmov(LF_RMOV);
	TSystemisamfile rmoviva(LF_RMOVIVA);

	if (mov.open(_excllock) || rmov.open(_excllock) ||
			rmoviva.open(_excllock))
		{
			warning_box("Gli archivi sono in uso. Operazione interrotta");
			return FALSE;
		}

	mov.first();
	mov.indexoff(); rmov.indexoff(); rmoviva.indexoff();

	TSort sort(sizeof(struct therec));

	if (fexist("__mov__.sav") || fexist("__mov__.ind"))
		{
			// previous operation failed
			if (yesno_box("Un riordinamento precedente e' fallito.\n"
				" Ripristino la situazione iniziale ora?" ))
	restore_mov(mov, rmov, rmoviva);
			else return FALSE;
		}

	therec rbuf;

	sort.addsortkey(rbuf.DATAREG - (char*)&rbuf, 6);
	sort.addsortkey(rbuf.REG     - (char*)&rbuf, 3);
	sort.addsortkey(rbuf.NUMDOC  - (char*)&rbuf, 6);
	sort.addsortkey(rbuf.DATADOC - (char*)&rbuf, 6);

	sort.init();

	TProgind prnd(mov.items(),
		"Riordino archivio movimenti in corso\nOrdinamento file movimenti...",
		FALSE,TRUE,30);


	while (!mov.eof())
		{
			do_events();
			TDate d(mov.curr().get(MOV_DATAREG));
			strcpy(rbuf.DATAREG, format("%ld",(long)d));
			strcpy(rbuf.REG,     mov.curr().get(MOV_REG));
			d = mov.curr().get(MOV_DATADOC);
			strcpy(rbuf.NUMDOC,  mov.curr().get(MOV_NUMDOC));
			strcpy(rbuf.DATADOC, format("%ld",(long)d));
			strcpy(rbuf.ANNOES,  mov.curr().get(MOV_ANNOES));
			strcpy(rbuf.NUMREG,  mov.curr().get(MOV_NUMREG));

			sort.sort((char*)&rbuf);
			mov.next();
			prnd.addstatus(1);
		}
	sort.endsort();

	prnd.setstatus(0);
	prnd.set_text("Riordino archivio movimenti in corso\nRiscrittura file movimenti...");

	therec* rr;
	long num = 1;

	while ((rr = (therec*)sort.retrieve()) != NULL)
		{
			do_events();
			if (atol(rr->NUMREG) != num)
	{
		// find record
		mov.curr().zero();
		mov.curr().put(MOV_NUMREG, rr->NUMREG);
		mov.curr().put(MOV_ANNOES, rr->ANNOES);

		mov.read();
		// should never happen
		CHECK(!mov.bad(), "Archivio movimenti inconsistente. Questo si' che e' un casino.");

		// retrieve and change NUMREG
		TString rgn = rr->NUMREG;
		FILE* fsav  = fopen("__mov__.sav","a");
		fprintf(fsav,"%s %d ", (const char*)rgn, mov.recno());
		fclose(fsav);

		mov.curr().put(MOV_NUMREG,num);
		mov.rewrite();
		// update linked records

		rmov.curr().zero();
		rmov.curr().put(RMV_NUMREG,rgn);
		rmov.read(_isgteq);


		while (!rmov.eof())
			{
				if (rgn  != rmov.curr().get(RMV_NUMREG))
		break;
				fsav = fopen("__mov__.sav","a");
				fprintf(fsav,"%ld ", (long)rmov.recno());
				fclose(fsav);
				rmov.curr().put(RMV_NUMREG,num);
				rmov.rewrite();
				rmov.next();
			}
		fsav = fopen("__mov__.sav","a");
		fprintf(fsav,"-1");  fclose(fsav);

		rmoviva.curr().zero();
		rmoviva.curr().put(RMI_NUMREG,rgn);
	  rmoviva.read(_isgteq);

	  while (!rmoviva.eof())
	    {
	      if (rgn  != rmoviva.curr().get(RMV_NUMREG))
		break;
	      fsav = fopen("__mov__.sav","a");
	      fprintf(fsav,"%ld ", (long)rmov.recno());
	      fclose(fsav);
	      rmoviva.curr().put(RMI_NUMREG,num);
				rmoviva.rewrite();
	      rmoviva.next();
	    } 
	  fsav = fopen("__mov__.sav","a");
	  fprintf(fsav,"-1"); fclose(fsav);
	}
      num++;
      prnd.addstatus(1);
		}

  remove("__mov__.sav");

  FILE* fsav = fopen("__mov__.ind","w"); fclose(fsav);

	prnd.set_text("Riordino archivio movimenti in corso\nRicostruzione files indice...");

  // rebuild indexes
  mov.close(); rmov.close(); rmoviva.close();
  mov.packfile(); rmov.packfile(); rmoviva.packfile();
  mov.packindex(); rmov.packindex(); rmoviva.packindex();

  remove("__mov__.ind");

  return TRUE;
}


bool CG4100_App::sort_sal()
{
	bool first;

  if (!set_parms(TRUE))
    return FALSE;

  FILE* fp = fopen ("__sal__.sav","w");
  fclose(fp);

  TLocalisamfile rmov(LF_RMOV);
  TLocalisamfile saldi(LF_SALDI);
  TLocalisamfile mov(LF_MOV);
  TLocalisamfile causali(LF_CAUSALI);

  long jj = 0l;

  rmov.first(); saldi.first(); mov.first(); causali.first();

  TSort sort(sizeof(struct truc));
  truc rbuf;

	sort.addsortkey(rbuf.GRUPPO - (char*)&rbuf, 3);
	sort.addsortkey(rbuf.CONTO - (char*)&rbuf, 3);
	sort.addsortkey(rbuf.SOTTOCONTO - (char*)&rbuf, 6);
	sort.addsortkey(rbuf.SEZIONE - (char*)&rbuf, 1);

  sort.init();

	TProgind prnd(rmov.items(),
		"Riordino archivio saldi in corso\nOrdinamento archivio movimenti...",
		FALSE,TRUE,30);

  while (!rmov.eof())
    {
      if (_year == rmov.curr().get(RMV_ANNOES))
	{
	  strcpy(rbuf.GRUPPO, rmov.curr().get(RMV_GRUPPO));
	  strcpy(rbuf.CONTO, rmov.curr().get(RMV_CONTO));
	  strcpy(rbuf.SOTTOCONTO, rmov.curr().get(RMV_SOTTOCONTO));
	  strcpy(rbuf.SEZIONE, rmov.curr().get(RMV_SEZIONE));
	  strcpy(rbuf.IMPORTO, rmov.curr().get(RMV_IMPORTO));
	  strcpy(rbuf.NUMREG, rmov.curr().get(RMV_NUMREG));
	  sort.sort((char*)&rbuf);
	  jj++;
	}
      rmov.next();
      prnd.addstatus(1);
      do_events();
		}

	prnd.setstatus(0);
	prnd.set_text("Riordino archivio saldi in corso\nRiscrittura file saldi...");
	prnd.setmax(jj);

	do_events();
	sort.endsort();

	truc* rr = (truc*)sort.retrieve();

	while (rr != NULL)
		{
			do_events();

			real dare = 0.0, avere = 0.0, saldo = 0.0;
      TString conto, sottoconto, gruppo, h;
      
      saldi.curr().zero();
      saldi.curr().put(SLD_CONTO, rr->CONTO);
      saldi.curr().put(SLD_SOTTOCONTO, rr->SOTTOCONTO);
      saldi.curr().put(SLD_GRUPPO, rr->GRUPPO);
      saldi.curr().put(SLD_ANNOES, _year);
      saldi.read();

      if (saldi.eof())
	{
	  saldi.curr().zero();
	  saldi.curr().put(SLD_CONTO, rr->CONTO);
	  saldi.curr().put(SLD_SOTTOCONTO, rr->SOTTOCONTO);
	  saldi.curr().put(SLD_GRUPPO, rr->GRUPPO);
	  saldi.curr().put(SLD_ANNOES, _year);
	}
			else
	{
	  saldi.curr().put(SLD_SALDO,"");
	  saldi.curr().put(SLD_PDARESCA,"");
	  saldi.curr().put(SLD_PAVERESCA,"");
	  saldi.curr().put(SLD_PDARE,"");
	  saldi.curr().put(SLD_PAVERE,"");
	  saldi.curr().put(SLD_DATAULMOV,"");
	  saldi.curr().put(SLD_NUMULTMOV,"");
	  saldi.rewrite();
	}

      first = TRUE;

      do 
	{
	  bool apertura = FALSE;

	  conto  = rr->CONTO; 
	  sottoconto = rr->SOTTOCONTO;
	  gruppo = rr->GRUPPO;
	  h = rr->SEZIONE;

	  real imp = rr->IMPORTO;

	  // cerca causale
	  mov.curr().zero();
	  mov.curr().put(MOV_ANNOES,_year);
	  mov.curr().put(MOV_NUMREG, rr->NUMREG);
	  mov.read();

	  CHECK(!mov.bad(),"Archivi movimenti e righe inconsistenti");
	  causali.curr().zero();
	  causali.curr().put(CAU_CODCAUS,mov.curr().get(MOV_CODCAUS));
	  
	  CHECK(!causali.bad(),"Archivi causali e movimenti inconsistenti");
	  
	  if (first) 
	    { apertura = causali.curr().get_bool(CAU_MOVAP); first = FALSE; }

	  if (apertura)
			{
		saldo += imp;
	    }
	  else
	    {
	      if (rr->SEZIONE[0] == 'D')
		dare += imp;
	      else avere += imp;              
	    }
	  prnd.addstatus(1);
	  rr = (truc*)sort.retrieve();
	  do_events();
	}
      while (rr && conto == rr->CONTO && sottoconto == rr->SOTTOCONTO &&
	     gruppo == rr->GRUPPO);
      
      if (dare != 0.0) 
	{ 
	  saldi.curr().put(SLD_PDARE,dare); 
	  saldi.curr().put(SLD_FLAGSALINI,"D");
	}
      else if (avere != 0.0) 
	{
	  saldi.curr().put(SLD_PAVERE,avere);
	  saldi.curr().put(SLD_FLAGSALINI,"A"); 
	}
      else if (saldo != 0.0)
	{
	  saldi.curr().put(SLD_SALDO,saldo);
	  saldi.curr().put(SLD_FLAGSALINI,h); 
	}
      
      if (saldi.eof())  
	saldi.write();
      else
	saldi.rewrite();
    }
  remove("__sal__.sav");
  return TRUE;
}


int cg4100(int argc, char* argv[])
{
  CG4100_App main_app;
  main_app.run(argc, argv, "Riordinamento movimenti/Ricalcolo Saldi");
  return TRUE;
}