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

#include "calib01.h"
#include "ca2.h"
#include "ca2200a.h"

#include "movana.h"
#include "rmovana.h"
#include "rip.h"
#include "rrip.h"

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

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

TRib_movanal_msk::TRib_movanal_msk() :TAutomask ("ca2200a") { }  
  
bool TRib_movanal_msk::on_field_event(TOperable_field& o, TField_event e, long jolly)
{ 
/*  switch (o.dlg())
  {
  case :
    break;
  default: break;
  }*/  
  return true;
}


//--------------------------------------------------------------------
//  CLASSE PER RIPARTIZIONI RIGHE E TESTATE
//--------------------------------------------------------------------
class TRipartizione : public TMultiple_rectype
{
  public:
  TRipartizione(TString16 codice);
};


TRipartizione::TRipartizione(TString16 codice) : TMultiple_rectype(LF_RIP)
{
  add_file(LF_RRIP, RRIP_CODICE);
  if (codice.not_empty())
    read();
}

//--------------------------------------------------------------------
//  CLASSE PER RIPARTIZIONI RIGHE
//--------------------------------------------------------------------
class TCache_ripartizioni : public TCache
{
  TLocalisamfile _rip;  //testate delle ripartizioni

protected:
  virtual TObject* key2obj(const char* key);

public:
  TRecord_array& righe(const char* costo);
  TCache_ripartizioni() : _rip(LF_RIP) {_rip.setkey(4);}
};

TObject* TCache_ripartizioni::key2obj(const char* key)
{
  

  TRecord_array* rows = new TRecord_array(LF_RRIP, RRIP_NRIGA);
  TRectype* chiave = new TRectype(LF_RRIP);
//  chiave.put(RRIP_TIPO, "B");
//  chiave.put(RRIP_CODICE, codice);
    return (TObject*);
}

TRecord_array& TCache_ripartizioni::righe(const char* costo)
{
}

//--------------------------------------------------------------------
//  APPLICAZIONE
//--------------------------------------------------------------------
class TRib_movanal_app : public TSkeleton_application
{
  TRib_movanal_msk * _mask;

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

  static bool cappotta_movimento(const TRelation& rel, void* pJolly);

public:
  TRib_movanal_app() {}
};

bool TRib_movanal_app::create()
{
  _mask = new TRib_movanal_msk;  
  return TSkeleton_application::create();
}

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

bool TRib_movanal_app::cappotta_movimento(const TRelation& rel, void* pJolly)
{
  TRib_movanal_app* app = (TRib_movanal_app*)pJolly;

  TAnal_mov& anal_mov = (TAnal_mov&)rel.curr(); //movimento analitica
  TRecord_array& input_rows = anal_mov.body();  //record_array con le righe del mov_anal (INPUT)
  
  //controllare 

  TRecord_array output_rows = input_rows; //crea il record_array di output come copia dell'INPUT..
  output_rows.destroy_rows();             //..e poi lo pulisce

  TToken_string key;  //tokenstring in cui parcheggiare la chiave del record
  for (int i = 1; i <= input_rows.rows(); i++)
  {
    const TRectype& rec = input_rows.row(i);
    key = "B";
    key.add(rec.get(RMOVANA_CODCCOSTO));


  }
  return true;
}

void TRib_movanal_app::main_loop()
{
  while (_mask->run() == K_ENTER)
  { 
    //deve scandire il file MOVANA con chiave 2 (per data e numero di registrazione)
    TRelation rel_movana(LF_MOVANA);
    TRectype darec(LF_MOVANA), arec(LF_MOVANA);
    darec.put(MOVANA_DATAREG, _mask->get_date(F_DATAINI));
    arec.put(MOVANA_DATAREG, _mask->get_date(F_DATAFIN));
    TString filtro;
    filtro << "BLOCCATO==''";

    TCursor cur_movana(&rel_movana, filtro, 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)
    {
      cur_movana.scan(cappotta_movimento, this, "Ribaltamento movimenti...");
    }
    else
      message_box(TR("Non ci sono movimenti da ribaltare nel periodo selezionato"));


  } 
}

int ca2200(int argc, char* argv[])
{
  TRib_movanal_app app;
  app.run(argc, argv, "Ribaltamento movimenti di analitica");
  return 0;
}