#include <applicat.h>
#include <automask.h>
#include <progind.h>
#include <recarray.h>
#include <relation.h>

#include "calib01.h"
#include "ca2.h"
#include "ca2300a.h"

#include "../cg/cglib01.h"

#include "movana.h"
#include "rmovana.h"
#include "saldana.h"

//--------------------------------------------------------------------
//  MASCHERA
//--------------------------------------------------------------------
class TRic_saldi_msk : public TAutomask
{
protected:
  virtual bool on_field_event(TOperable_field& o, TField_event fe, long jolly) {  return true; }

public:
  TRic_saldi_msk();  
  virtual ~TRic_saldi_msk(){};
};

TRic_saldi_msk::TRic_saldi_msk() :TAutomask ("ca2300a") { }  

///////////////////////////////////////////////////////////
// TAnal_mov_ric
///////////////////////////////////////////////////////////

class TAnal_mov_ric : public TAnal_mov
{
  int _annoes;

public:
  virtual int readat(TBaseisamfile& f, TRecnotype nrec, word lockop);
  virtual int read(TBaseisamfile& f, word op, word lockop);

public:
  void set_annoes(int anno) { _annoes = anno; }
  TAnal_mov_ric(long numreg = 0) : TAnal_mov(numreg), _annoes(0) {}
};

int TAnal_mov_ric::readat(TBaseisamfile& f, TRecnotype nrec, word lockop)
{
  const int err = TMultiple_rectype::readat(f, nrec, lockop);
  
	kill_saldi();
  load_saldi(false);
  save_saldi(_annoes);

  return err;
}

int TAnal_mov_ric::read(TBaseisamfile& f, word op, word lockop)
{
  const int err = TMultiple_rectype::read(f, op, lockop);
	
	kill_saldi();
	load_saldi(false);
  save_saldi(_annoes);

  return err;
}

//--------------------------------------------------------------------
//  APPLICAZIONE
//--------------------------------------------------------------------

class TRic_saldi_app : public TSkeleton_application
{
  TRic_saldi_msk * _mask;

  virtual const char * extra_modules() const {return "cm";} //deve funzionare anche per le commesse

protected:
  virtual bool create();
  virtual bool destroy();
  virtual void main_loop();
  static bool elabora_movimento(const TRelation& rel, void* pJolly) {	return true; }
  static bool remove_saldo(const TRelation& rel, void* pJolly);

public:
  TRic_saldi_app() {}
  virtual ~TRic_saldi_app() {}
};

bool TRic_saldi_app::create()
{
  _mask = new TRic_saldi_msk;  
  return TSkeleton_application::create();
}

bool TRic_saldi_app::destroy()
{
  delete _mask;
  return TSkeleton_application::destroy();
}

bool TRic_saldi_app::remove_saldo(const TRelation& rel, void* pJolly)
{	
  const int anno = *(int*)pJolly;
  TRectype& rec = rel.curr();
  const int curr_anno = rec.get_int(SALDANA_ANNO);
  //azzeratore dei saldi anno corrente
  if (curr_anno == anno)
	  ((TRelation &)rel).remove();
  else  //azzeratore dei preventivi/variazioni di altri anni
  {
    const real saldop = rec.get_real(SALDANA_SALDOP);
    const real saldov = rec.get_real(SALDANA_SALDOV);
    if (!saldop.is_zero() || !saldov.is_zero())
    {
      rec.zero(SALDANA_SALDOP);
      rec.zero(SALDANA_SALDOV);
      ((TRelation&)rel).rewrite();
    }
  }
	return true;
}

void TRic_saldi_app::main_loop()
{
  while (_mask->run() == K_ENTER)
  { 
    //Il ricalcolo saldi e' diviso in 2 fasi:
    //1  Azzeramento e ricalcolo dei saldi dei movimenti di tipo normale o temporaneo per il solo anno selezionato
    //2  Azzeramento e ricalcolo dei saldi dei movimenti di tipo preventivo o variazione per TUTTI gli esercizi..
    //..questo perche' i movimenti P e T possono essere "spalmati" su piu' anni

    //AZZERAMENTO dei saldi normali e temporanei dell'anno selezionato, preventivi e variazione di tutti..
    //..gli esercizi che trova
		const int anno = _mask->get_int(F_ANNO);
	  TRelation rel_saldi(LF_SALDANA);

    TCursor cur_saldi(&rel_saldi);
    const long items_saldi = cur_saldi.items();

    cur_saldi.scan(remove_saldo, (void*)&anno, "Azzeramento saldi...");

    //FASE 1
    //ricostruzione dei saldi normali e temporanei dell'anno selezionato
    TEsercizi_contabili esc;
    const TDate datainies = esc[anno].inizio();
    const TDate datafines = esc[anno].fine();
    TRelation rel_movana(LF_MOVANA);
    TRectype darec(LF_MOVANA), arec(LF_MOVANA);
    darec.put(MOVANA_DATACOMP, datainies);
    arec.put(MOVANA_DATACOMP, datafines);
		
    TString filter = "(TIPOMOV=='')||(TIPOMOV=='T')";

    TCursor cur_movana(&rel_movana, filter, 2, &darec, &arec);
    const long items = cur_movana.items();
    //usa la scan dei TCursor,quindi niente progind e for,x' gia' nel metodo
    if (items > 0)
    {
      TAnal_mov_ric* amr = new TAnal_mov_ric;
      amr->set_annoes(anno);
      rel_movana.lfile().set_curr(amr); //il record principale della rel e' un TMov_anal!!
      cur_movana.scan(elabora_movimento, this, "Ricostruzione saldi consuntivi e temporanei...");
      rel_movana.lfile().set_curr(new TRectype(LF_MOVANA)); //il record principale della rel e' un TMov_anal!!
    }

    //FASE 2
    //ricostruzione saldi di preventivo spammati su piu' anni
    filter = "(TIPOMOV='P')||(TIPOMOV='V')";
    TCursor cur_movana_prev(&rel_movana, filter);
    const long preventivi_items = cur_movana_prev.items();
    if (preventivi_items > 0)
    {
      TAnal_mov_ric* amr = new TAnal_mov_ric;
      amr->set_annoes(0);
      rel_movana.lfile().set_curr(amr); //il record principale della rel e' un TMov_anal!!
      cur_movana_prev.scan(elabora_movimento, this, "Ricostruzione saldi preventivi...");
      rel_movana.lfile().set_curr(new TRectype(LF_MOVANA)); //il record principale della rel e' un TMov_anal!!
    }
  } 
}

int ca2300(int argc, char* argv[])
{
  TRic_saldi_app app;
  app.run(argc, argv, "Ricostruzione saldi di analitica");
  return 0;
}