#include <applicat.h>
#include <execp.h>
#include <mailbox.h>
#include <printer.h>
#include <recset.h>

#include "mglib.h"
#include "mg3300.h"

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

#define VALUE_NOT_SET "~~"

TCausale_magazzino& get_cau(const char* codcaus)
{ return cached_causale_magazzino(codcaus); }

class TForm_schedemag : public TForm_stampemg
{ 
  int _tolivgiac,_tolivart;
  TString4 _anno_prec;
  bool _magazzino_chiuso;
  bool _sottocatmer;
  bool _sudd_mag;
  bool _no_valori;
  bool _no_ff;
  bool _sintetica;
  TDate _data_inizio, _data_fine;

  TToken_string _rmov_sortexp;
  TString _rmov_raggcond,_rmov_joinexp;

  TToken_string _saldo_key;   // codart|livello|codmag

  TTipo_saldomag _tiposcheda;       // tipo scheda
  int _annoes;
  TString16 _user1;

  bool ragg_exprs(int livart,int livgiac);
  
public:
  TToken_string& rmov_sortexp() {return _rmov_sortexp;}
  TString & rmov_joinexp() {return _rmov_joinexp;}

	void set_description_field(const char* u) { _user1 = u; }

	void set_tiposcheda(const char * tipo);
  void set_chiusura_mag(const int val);
  void set_data_inizio(const TDate& d) { _data_inizio = d; }
  bool validate(TForm_item &cf, TToken_string &s);
  void setdett_perart(bool percatmer, bool sottocatmer,int livart,int livgiac,bool sudd_mag, bool sudd_dep);
  void setdett_permag(bool sudd_dep, bool showdett,int livart,int livgiac);
  void set_date_limite(const int anno, const TDate& d, const TDate& e);
  void set_options(bool no_valori, bool no_ff, bool sintetica);
  const char* descr_tiposcheda() const;
  const char* nomecampo_scheda() const;
  TTipo_saldomag tiposcheda() const { return _tiposcheda; } 

  TForm_schedemag(const char *name,const char *code)
		             : TForm_stampemg(name,code), _tolivgiac(0), _tolivart(0) {}
 
  virtual ~TForm_schedemag() {}
};

const char* TForm_schedemag::descr_tiposcheda() const
{
  switch (_tiposcheda)
  {
  case s_giac:  return TR("Giacenza");
  case s_acl:   return TR("A conto lavoro");
  case s_incl:  return TR("In conto lavoro");
  case s_prodc: return TR("In produzione componenti");
  case s_prodf: return TR("In produzione finiti");
  case s_ordc:  return TR("Ordinato clienti");
  case s_ordf:  return TR("Ordinato fornitori");
  case s_acq:
  default: break;
  }
  return "";
}

const char* TForm_schedemag::nomecampo_scheda() const
{
  switch (_tiposcheda)
  {
  case s_giac: return (MAG_GIAC);
  case s_acl:  return (MAG_ACL);
  case s_incl: return (MAG_INCL);
  case s_prodc:return (MAG_PRODCOMP);
  case s_prodf:return (MAG_PRODFIN);
  case s_ordc: return (MAG_ORDC);
  case s_ordf: return (MAG_ORDF);
  case s_acq:
  case s_ent:
  case s_ven:
  case s_usc:
  default: break;
  }
  return "";
}

bool TForm_schedemag::validate(TForm_item &cf, TToken_string &s)
{ 
  const TFixed_string msg(s.get(0)); // prende il primo parametro, il codice del messaggio

  if (msg=="_USER")
	{
    const TString80 subcode(s.get());
	  TString80 valore(VALUE_NOT_SET);

    if (subcode=="TIPOSCHEDA")
      valore = descr_tiposcheda();
		if (subcode=="GRUPPOART") 
	  {
      const TRectype& anamag = relation()->curr(LF_ANAMAG);
			if (_tolivart > 0 && _tolivart < livelli_articolo().last_level())
				valore = livelli_articolo().group_descr_packed(anamag.get(ANAMAG_CODART),_tolivart);
			else
  			valore = anamag.get(_user1.not_empty() ? _user1 : ANAMAG_DESCR);
		}
		if (subcode=="CODGRUPPOGIAC") 
		{
			const int livello=_tolivgiac; // Cosa si risparmia ???
			valore = livelli_giacenza().name(livello);
			add_giaclev(valore, 1, livello);
			valore << ' ';
			TString s = livelli_giacenza().unpack_grpcode(relation()->curr(LF_RMOVMAG).get(RMOVMAG_LIVGIAC),livello);
			if (s.blank())
				s = UNKNOWN_NAME;
			valore << s;
		}
		if (subcode=="CODGRUPPOART") 
    {
			valore = relation()->curr(LF_ANAMAG).get(ANAMAG_CODART);
			if (_tolivart > 0 && livelli_articolo().enabled())
				valore.cut(min(valore.len(),livelli_articolo().packed_length(_tolivart)));
    }
    if (subcode=="GRUPPOGIAC") 
      valore = livelli_giacenza().group_descr_packed(relation()->curr(LF_RMOVMAG).get(RMOVMAG_LIVGIAC),_tolivgiac);
    if (subcode=="CODCATMER") 
    {
      valore = relation()->curr(LF_ANAMAG).get("GRMERC");
      if (!_sottocatmer && valore.full())
        valore.cut(3);
    }  
    if (subcode=="CATMER") 
    {
      valore = relation()->curr(_sottocatmer ? -ALIAS_SOTTOCATMER : -ALIAS_CATMER).get("S0");
    }  
    if (subcode=="DADATA")
      valore = _data_inizio.string();      
    if (subcode=="ADATA")
      valore = _data_fine.string();
    
    if (subcode=="*SEGNOCAUS")
		{
      const TRectype& rmovmag = relation()->curr(LF_RMOVMAG);
      const TRectype& movmag = relation()->curr(LF_MOVMAG);
      const TString8 cau_r= rmovmag.get(RMOVMAG_CODCAUS);
      const TString8 cau_m= movmag.get(MOVMAG_CODCAUS);
      const TCausale_magazzino & cau = get_cau(cau_r.empty() ? cau_m : cau_r);

      const char qv = s.get_char();  // Segno per Quantita'o Valore
      int sgn = cau.sgn(_tiposcheda);

      switch(qv)
      {       
      case 'Q': if (!cau.update_qta()) sgn = 0; break;
      case 'V': if (!cau.update_val()) sgn = 0; break;
      default : break;
      }
      if (sgn)
      {
        real v(cf.get());
        v *= real(sgn);
        valore = v.string();
      }
      else
        valore = "";  
    }
    if (subcode=="CAUSALERIGA") 
    {
      const TRectype& rmovmag = relation()->curr(LF_RMOVMAG);
      const TRectype& movmag = relation()->curr(LF_MOVMAG);
      const TString8 cau_r= rmovmag.get(RMOVMAG_CODCAUS);
      const TString8 cau_m= movmag.get(MOVMAG_CODCAUS);
      const TCausale_magazzino & cau = get_cau(cau_r.empty() ? cau_m : cau_r);
	    valore = cau.codice();
    }
    if (subcode=="DESCRCAUSALE") 
    {
      const TRectype& rmovmag = relation()->curr(LF_RMOVMAG);
      const TRectype& movmag = relation()->curr(LF_MOVMAG);
      const TString8 cau_r= rmovmag.get(RMOVMAG_CODCAUS);
      const TString8 cau_m= movmag.get(MOVMAG_CODCAUS);
      const TCausale_magazzino & cau = get_cau(cau_r.empty() ? cau_m : cau_r);
      valore = cau.descr();
    }
    
    if (subcode=="CANPRINTSALDOPREC")   // Determina se e' possibile stampare il saldo precedente
    {                                                  
      bool printsaldoprec = true;
      const TRectype& movmag = relation()->curr(LF_MOVMAG);
      const TDate datareg = movmag.get_date(MOVMAG_DATAREG);
      const bool stampa_perart = relation()->lfile().num() == LF_ANAMAG;

      // Se il movimento corrente e' >= la data inizio stampa allora posso sempre stampare il saldo ...
      if (datareg < _data_inizio)   // ... altrimenti devo fare altri controlli
      {     
        if (stampa_perart)  // Stampa per articoli
        {
          TSortedfile& rmm = (TSortedfile&)relation()->lfile(LF_RMOVMAG);
          const TRecnotype oldpos = rmm.recno();
          TToken_string old_art; 
          old_art = rmm.get(RMOVMAG_CODART); 
          old_art.add(rmm.get(RMOVMAG_LIVGIAC));
          const int err = rmm.next();
          if (err == NOERR) // Se non sono sull'ultimo record ...
          {
            const TRectype& next_movmag = rmm.relation().curr(LF_MOVMAG);
            const TDate next_datareg = next_movmag.get_date(MOVMAG_DATAREG);
            // Se il prossimo record e' dopo la data iniziale devo stampre il saldo
            // Lo stesso dicasi se la prossima data e' inferiore alla corrente (sono su un altro articolo!)
            printsaldoprec = next_datareg >= _data_inizio || next_datareg < datareg;
            if (!printsaldoprec)
            {
              // Se la prossima data e' >= della corrente verifico se cambio articolo
              TToken_string new_art; 
              new_art = rmm.get(RMOVMAG_CODART); 
              new_art.add(rmm.get(RMOVMAG_LIVGIAC));
              printsaldoprec = old_art != new_art;
            }
          }
          rmm.readat(oldpos); // ripristino la posizione del file
        }
        else  // Stampa per magazzini  
        {
          TSortedfile& rmm = (TSortedfile&)relation()->lfile(LF_RMOVMAG);
          const TRecnotype oldpos = rmm.recno();
          TToken_string old_art; 
          old_art = rmm.get(RMOVMAG_CODART); 
          old_art.add(rmm.get(RMOVMAG_LIVGIAC));
          old_art.add(rmm.get(RMOVMAG_CODMAG));
          
          const int err = rmm.next();
          if (err == NOERR) // Se non sono sull'ultimo record ...
          {
            const long next_num_reg =  rmm.get_long(RMOVMAG_NUMREG);
            const TRectype& next_movmag = cache().get(LF_MOVMAG, next_num_reg);
            const TDate next_datareg = next_movmag.get_date(MOVMAG_DATAREG);
            // Se il prossimo record e' dopo la data iniziale devo stampre il saldo
            // Lo stesso dicasi se la prossima data e' inferiore alla corrente (sono su un altro articolo!)
            printsaldoprec = next_datareg >= _data_inizio || next_datareg < datareg;
            if (!printsaldoprec)
            {
              // Se la prossima data e' >= della corrente verifico se cambio articolo
              TToken_string new_art; 
              new_art = rmm.get(RMOVMAG_CODART); 
              new_art.add(rmm.get(RMOVMAG_LIVGIAC));
              new_art.add(rmm.get(RMOVMAG_CODMAG));
              printsaldoprec = old_art != new_art;
            }
          }
          rmm.readat(oldpos); // ripristino la posizione del file
        }  
      }
      if (printsaldoprec) // Memorizzo chiave articolo per utilizzarla al momento di calcolare il SALDOPREC
      {
        const TRectype& rmm = relation()->curr(LF_RMOVMAG);
        _saldo_key = rmm.get(RMOVMAG_CODART); 
        _saldo_key.add(rmm.get(RMOVMAG_LIVGIAC));
        _saldo_key.add(rmm.get(RMOVMAG_CODMAG));
      }
      valore = printsaldoprec ? "1" : "0";
    }
    if (subcode=="SALDOPREC") 
    {
			valore = "";
      if (!_magazzino_chiuso) // mag precedente non chiuso, mancano i saldi di apertura
      {
        TString80 codart;  _saldo_key.get(0, codart);  codart.rtrim();
        TString16 livello; _saldo_key.get(1, livello); livello.rtrim();
        TString8 codmag;   _saldo_key.get(2, codmag);  codmag.rtrim(); 
        if (_tolivart > 0 && _tolivart < livelli_articolo().last_level())
        {
          codart.cut(livelli_articolo().code_length(_tolivart));
          livello.cut(0);
        }
        else
        {
          if (_tolivgiac > 0)
          {
            if (_tolivgiac < livelli_giacenza().last_level())
              livello.cut(livelli_giacenza().code_length(_tolivgiac));
          }
          else
            livello.cut(0);
        }

        TString region;
        region << MAG_ANNOES << '=' << _anno_prec;
        region << ' ' << MAG_CODART << '=' << codart;

        TString query;
        query << "USE " << LF_MAG;
        query << "\nFROM " << region;
        query << "\nTO " << region;
        if (_tolivart <= 0 || _tolivart >= livelli_articolo().last_level())
          query << '~';

        TISAM_recordset magprec(query);
        real currsaldo = cf.get();
        for (bool ok = magprec.move_first(); ok; ok = magprec.move_next())
        {
          if (_sudd_mag && magprec.get(MAG_CODMAG).as_string() != codmag) 
            continue; // Escludo magazzini indesiderati

          if (_tolivgiac > 0) // Stampa per livello di giacenza
          {
             const TString& cl = magprec.get(MAG_LIVELLO).as_string();
             if (_tolivgiac >= livelli_giacenza().last_level())
             {
               if (cl != livello)
                 continue; // Escludi livelli non corrispondenti
             }
             else
             {
               if (!cl.starts_with(livello))
                 continue; // Escludi sotto livelli non corrispondenti
             }
          }

          const real saldoprec = magprec.get(nomecampo_scheda()).as_real();
          currsaldo += saldoprec;       // Sommo il saldo precedente al campo corrente
        }
        valore = currsaldo.string();
      }
    }
    if (subcode.left(3) == "ADD")
    {                         
      const TString8 cau = cf.section().find_field(FF_CAUSALE_RIGA).get();
      TCausale_magazzino & ccrr = get_cau(cau);
      const bool is_qta = subcode.right(3) == "QTA"; 
      const bool ok = is_qta && ccrr.update_qta() || !is_qta && ccrr.update_val();
      
			if (ok)
      {
        const short fld = s.get_int(2);
        TForm_item& dest = cf.section().find_field(fld);
        real v1(cf.get());
        real v2(dest.get());
          
        v2 += v1;
        dest.set(v2.string());
      }
			return true;
    }
		if (valore != VALUE_NOT_SET)
		{
	    cf.set(valore);
			return true;
		}

  }
  return TForm_stampemg::validate(cf, s);
}


bool TForm_schedemag::ragg_exprs(int livart, int livgiac)
{
  TString16 ca = RMOVMAG_CODART;
  if (livart > 0 && livart < livelli_articolo().last_level())
    ca << "[1," << livelli_articolo().packed_length(livart) <<']';
	if (_rmov_raggcond.full())
		_rmov_raggcond << '+';
  _rmov_raggcond << ca;
	_rmov_sortexp.add(ca);
  _rmov_joinexp.cut(0) << ca << "==" << ca;

  // Posso raggruppare per livello di giacenza solo se non raggruppo per livello articolo
  if (livgiac > 0 && !ca.ends_with("]"))
  {
    TString16 lg=RMOVMAG_LIVGIAC;
    if (livgiac < livelli_giacenza().last_level())
      lg << "[1," << livelli_giacenza().packed_length(livgiac) <<']';
    _rmov_raggcond << '+' << lg;
    _rmov_sortexp.add(lg);
  }

  return true;
}


void TForm_schedemag::setdett_permag(bool sudd_dep,bool show_dett,int livart,int livgiac)
{
  TForm_subsection &h_d=(TForm_subsection &)find_field('B',odd_page,"HEADER_DEP");
  h_d.enable(sudd_dep);
  TForm_subsection &h_a=(TForm_subsection &)find_field('B',odd_page,"HEADER_ARTICOLO");
  h_a.enable(show_dett);
  TForm_subsection &h_g=(TForm_subsection &)find_field('B',odd_page,"HEADER_LIVGIAC");
  // h_g.enable(livelli_giacenza().enabled() && (livart ==0 || livgiac !=0 ));  Guy was here
  h_g.enable(livelli_giacenza().enabled() && (livart ==0 && livgiac>0 )); 

  _rmov_raggcond = "CODMAG[1,3]";
  _rmov_sortexp = "CODMAG[1,3]";
  if (sudd_dep) 
  {
    _rmov_raggcond << "+CODMAG[4,5]";
    _rmov_sortexp.add("CODMAG[4,5]");
  }

  _tolivart  = livart > 0 ? livart : livelli_articolo().last_level();
  _tolivgiac = _tolivart < livelli_articolo().last_level() ? 0 : livgiac;
  if (show_dett)
    ragg_exprs(livart, livgiac);
  
  TForm_subsection& s = find_field('B',odd_page,"GRUPPI_RMOVMAG");
  s.setcondition(_rmov_raggcond,_strexpr);

  TString16 cond; cond << LF_MOVMAG << "->" << MOVMAG_DATAREG;
  _rmov_sortexp.add(cond);
  _rmov_sortexp.add(MOVMAG_NUMREG);
  
  _sudd_mag = true;   // E' una stampa suddvisa per magazzini
}

void TForm_schedemag::setdett_perart(bool percatmer,bool sottocatmer,int livart,int livgiac,bool sudd_mag,bool sudd_dep)
{
	_rmov_sortexp.cut(0);
  // raggruppamento MAX fino all'articolo
  TForm_subsection &h_cm=(TForm_subsection &)find_field('B',odd_page,"HEADER_CATMER");
  h_cm.enable(percatmer);
  TForm_subsection &h_cm2=(TForm_subsection &)find_field('B',odd_page,"HEADER_LIVGIACCATMER");
  h_cm2.enable(percatmer);

  TForm_subsection &h_a=(TForm_subsection &)find_field('B',odd_page,"HEADER_ARTICOLO");
  h_a.enable     (livart!=0 && !sudd_mag);
  h_a.set_newpage(livart!=0 && !sudd_mag && !_no_ff);
  TForm_subsection &t_a=(TForm_subsection &)find_field('B',odd_page,"TOTALI_GRUPPIART");
  t_a.show(  livart!=0 && !sudd_mag);

  // raggruppamento MAX fino alla giacenza
  TForm_subsection &h_g=(TForm_subsection &)find_field('B',odd_page,"HEADER_GRMOV");
  h_g.enable(livart ==0 || livgiac !=0 || sudd_mag);   
  h_g.set_newpage(!_no_ff && (livart ==0 || livgiac !=0 || sudd_mag));
  TForm_subsection &h_l=(TForm_subsection &)find_field('B',odd_page,"HEADER_LIVGIAC");
  //h_l.enable(livelli_giacenza().enabled() && (livart ==0 || livgiac !=0 ));  Guy was here
  h_l.enable(livelli_giacenza().enabled() && (livart ==0 && livgiac>0 )); 

  
  TForm_subsection &h_m=(TForm_subsection &)find_field('B',odd_page,"HEADER_MAG");
  h_m.enable(sudd_mag );
  TForm_subsection &h_d=(TForm_subsection &)find_field('B',odd_page,"HEADER_DEP");
  h_d.enable(sudd_dep);
  TForm_subsection &t_s=(TForm_subsection &)find_field('B',odd_page,"TOTALI_GRMOV");
  t_s.show(livart==0 || livgiac !=0 || sudd_mag);

  _tolivart  = livart>0 ? livart : livelli_articolo().last_level() ;
  _tolivgiac = _tolivart < livelli_articolo().last_level() ? 0 : livgiac;
  _sottocatmer=sottocatmer;

  // settaggio catmer/ragg codice
  if (livart || percatmer) 
  {
    TForm_subsection &s=(TForm_subsection &)find_field('B',odd_page,"GRUPPI_ARTICOLO");
    TString cond;
    if (percatmer) 
      cond << "GRMERC" << (sottocatmer ? "[1,3]" : "") << '+';   
    cond << "CODART[1," << livelli_articolo().packed_length(_tolivart) << ']';    
    s.setcondition(cond,_strexpr);
  }
  // settaggio raggruppamenti codice sulla scheda
  ragg_exprs(livart, livgiac);
  
  _sudd_mag = sudd_mag;  // E' una stampa suddvisa per magazzini?
  if (sudd_mag) 
  {
    _rmov_raggcond << "+CODMAG[1,3]";
    _rmov_sortexp.add("CODMAG[1,3]");
    if (sudd_dep) 
    {
      _rmov_raggcond << "+CODMAG[4,5]";
      _rmov_sortexp.add("CODMAG[4,5]");
    }
  } 
  TForm_subsection &s=(TForm_subsection &)find_field('B',odd_page,"GRUPPI_RMOVMAG");
  s.setcondition(_rmov_raggcond,_strexpr);
  TString cond;
  cond << LF_MOVMAG << "->DATAREG";
  _rmov_sortexp.add(cond);
  _rmov_sortexp.add("NUMREG");
}

void TForm_schedemag::set_tiposcheda(const char * tipo)
{
  if (tipo[0] == 'G')
    _tiposcheda = s_giac;
	else
		if (tipo[0] == 'A')
			_tiposcheda = s_acl;
		else
		if (tipo[0] == 'I')
			_tiposcheda = s_incl;
		else
			if (*tipo=='P')
			{
				if (tipo[1]=='F')
					_tiposcheda = s_prodf;
				else
					_tiposcheda = s_prodc;
			}
			else
				if (tipo[0] == 'O')
				{
					if (tipo[1]=='F')
						_tiposcheda = s_ordf;
					else
						_tiposcheda = s_ordc;
				}
}

void TForm_schedemag::set_options(bool no_valori, bool no_ff, bool sintetica)
{
  _no_valori = no_valori;
  if (_no_valori)
  {
    ((TForm_item &)find_field('H',odd_page, 8)).hide();
    ((TForm_item &)find_field('H',odd_page, 9)).hide();
    ((TForm_item &)find_field('B',odd_page, 104)).hide();
    
    ((TForm_item &)find_field('B',odd_page, 105)).hide();
    ((TForm_item &)find_field('B',odd_page, FF_VALORE_GART)).hide();
    
    ((TForm_item &)find_field('B',odd_page, FF_VALORE_MOV)).hide();
    ((TForm_item &)find_field('B',odd_page, 190)).hide(); 

    if (name().left(7) == "mg3300a")
      ((TForm_item &)find_field('B',odd_page, FF_VALORE_GRMOV)).hide();
  }
  _no_ff = no_ff;
  _sintetica = sintetica;
}

void TForm_schedemag::set_date_limite(const int anno, const TDate& d, const TDate& e)
{
  TEsercizi_contabili ec;
  
  _annoes = anno;
  _anno_prec.format("%4d",ec.pred(anno));
  _magazzino_chiuso = (ec.pred(anno) == 0) || !(ec.esercizio(atoi(_anno_prec)).chiusura_mag().empty());
 
   _data_inizio = d;
   _data_fine = e;
   
   const TEsercizio& es = ec[_annoes];
   
   if (!_data_inizio.ok())
   {
     _data_inizio = es.inizio();
   }
   if (!_data_fine.ok())
   {
     _data_fine = es.fine();
   }     
}


// mg3300       Stampa 
// mg3300       Stampa 
class TStampa_schede_mag : public TSkeleton_application
{
  TStampemg_mask * _mask; // static so they are visible from filter function
  TForm_schedemag *_form; // to be moved into TPrint_application
  TCursor * _cur;

  int _codicees;
  bool _raggmag; 
	bool _reload;
  
protected:
	TStampemg_mask & mask() { return *_mask;}
  virtual bool create();
  virtual bool destroy();
  virtual void main_loop();
  static bool negatives_only(const TRelation* rel);
  static bool cau_filter(const TRelation* rel);

  void setprint_perarticoli();
  void setprint_permagazzini();
  
protected:
  static bool handle_dadata(TMask_field& f, KEY k);
  static bool handle_adata(TMask_field& f, KEY k);
    
public:       
	bool & reload() {return _reload;}
  TTipo_saldomag tiposcheda() const {return _form->tiposcheda();} ;
  TStampa_schede_mag() : _reload(false) {}
	virtual ~TStampa_schede_mag() {}
};

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

bool TStampa_schede_mag::negatives_only(const TRelation* rel)
{                           
  const TString codart = rel->curr(LF_ANAMAG).get(ANAMAG_CODART);
  const int anno = app().mask().get_int(F_ANNOES);
  TArticolo_giacenza artgiac(codart);
  const real giac = artgiac.giacenza_anno(NULL, NULL, anno);
  return giac < ZERO;
}

bool TStampa_schede_mag::cau_filter(const TRelation* rel)
{      
  const TRectype& rmov = rel->curr(LF_RMOVMAG);
  TString16 cau = rmov.get(RMOVMAG_CODCAUS);
  if (cau.empty())
    cau = cache().get(LF_MOVMAG, rmov.get(RMOVMAG_NUMREG), MOVMAG_CODCAUS);
  return get_cau(cau).sgn(app().tiposcheda()) != 0;
}

void TStampa_schede_mag::setprint_permagazzini()
{
  TRectype darec(LF_RMOVMAG),arec(LF_RMOVMAG);
  TString cfilter;
	const TMask & m = mask();

  _form->set_tiposcheda(_mask->get(F_SCHEDA));
  _cur = _form->cursor();
  // filtering from/to MAGS
  if (m.get(F_DAMAG).not_empty())
    cfilter << "(CODMAG[1,3]>=" <<'"' << m.get(F_DAMAG)<< "\")&&" ;
  if (m.get(F_AMAG).not_empty())
    cfilter << "(CODMAG[1,3]<=" <<'"' << m.get(F_AMAG)<< "\")&&" ;

  if (m.get(F_DADEP).not_empty())
    cfilter << "(CODMAG[4,]>=" <<'"' << m.get(F_DADEP)<< "\")&&" ;
  if (m.get(F_ADEP).not_empty())
    cfilter << "(CODMAG[4,]<=" <<'"' << m.get(F_ADEP)<< "\")&&" ;

  cfilter << "(" << LF_MOVMAG <<"->ANNOES==" <<'"' << m.get(F_ANNOES)<< "\")&&" ;
  // filtering from/to DATA
  if (m.get(F_ADATA).full()) 
  {
    TDate d1(m.get(F_ADATA));
    cfilter << "(ANSI(110->DATAREG)<=" <<'"' << d1.string(ANSI) << "\")&&" ;
  }
  if (m.get(F_DADATA).full())
  {
    TDate d1(m.get(F_DADATA));
    TString cond;
    
    cond << "ANSI(" << LF_MOVMAG << "->DATAREG)>=\"" << d1.string(ANSI) << '"';
    ((TForm_subsection &)_form->find_field('B',odd_page,"MOVS_INTERESSATI")).setcondition(cond,_strexpr);   
    ((TForm_subsection &)_form->find_field('B',odd_page,"H_MOVS_INTERESSATI")).setcondition(cond,_strexpr);   
    cond.cut(0) << "ANSI(" << LF_MOVMAG << "->DATAREG)<\"" << d1.string(ANSI) << '"';
    ((TForm_subsection &)_form->find_field('B',odd_page,"MOVS_PRECEDENTI")).setcondition(cond,_strexpr);    
  }

  // Imposta i livelli di dettaglio della scheda
  _form->setdett_permag(m.get_bool(F_DETTAGLIOMAG), m.get_bool(F_DETTAGLIODEP),
												m.get_int(F_TOLIVELLOART), m.get_int(F_TOLIVELLOGIAC));

  // filtering from/to ART
  darec.put(RMOVMAG_CODART, m.get(F_DAART));
  arec.put(RMOVMAG_CODART, m.get(F_AART));

  // filtering ONLY NEGATIVES
  if (m.get(F_FILTRO)[0]=='N') 
    _cur->set_filterfunction(negatives_only, true);
  
  // prepare cursor to print....
  ((TSorted_cursor *)_cur)->change_order(_form->rmov_sortexp());
  if (cfilter.not_empty())
    cfilter.rtrim(2); 

  TLocalisamfile *mag = new TLocalisamfile(LF_MAG);
  mag->setkey(2);
  TString mag_joinexp;
  mag_joinexp << "ANNOES==\"" << m.get(F_ANNOES) << "\"|CODMAG==CODMAG|CODART==CODART|LIVELLO==LIVGIAC";

  _cur->relation()->replace(mag,1,mag_joinexp);
  _cur->setfilter(cfilter,TRUE);
  _cur->setregion(darec,arec,0x2);
}

// ORDINAMENTO per articoli
void TStampa_schede_mag::setprint_perarticoli()
{
  TRectype darec(LF_ANAMAG),arec(LF_ANAMAG);
  TRectype darecr(LF_RMOVMAG),arecr(LF_RMOVMAG);
  TString cfilter,filter;
	const TMask & m = mask();

  _form->set_tiposcheda(m.get(F_SCHEDA));
  char subordine =m.get(F_SUBORDINE)[0];
  _cur = _form->cursor();
  // filtering ANNOES
  filter << '(' << LF_MOVMAG << "->ANNOES==" << m.get(F_ANNOES)<< ")&&" ;
  // filtering from/to MAGS
  if (m.get(F_DAMAG)[0])
    filter << "(" << LF_RMOVMAG << "->CODMAG[1,3]>=" <<'"' << m.get(F_DAMAG)<< "\")&&" ;
  if (m.get(F_AMAG)[0])
    filter << "(" << LF_RMOVMAG << "->CODMAG[1,3]<=" <<'"' << m.get(F_AMAG)<< "\")&&" ;
  
  if (m.get(F_DADEP).full())
    filter << "(" << LF_RMOVMAG << "->CODMAG[4,]>=" <<'"' << m.get(F_DADEP)<< "\")&&" ;
  if (m.get(F_ADEP).full())
    filter << "(" << LF_RMOVMAG << "->CODMAG[4,]<=" <<'"' << m.get(F_ADEP)<< "\")&&" ;

  // filtering from/to DATA
  if (m.get(F_DADATA).full())
  {
    TDate d1(m.get(F_DADATA));
    TString cond;
    cond << "ANSI(" << LF_MOVMAG << "->DATAREG)>=\"" << d1.string(ANSI) << '"';
    ((TForm_subsection &)_form->find_field('B',odd_page,"MOVS_INTERESSATI")).setcondition(cond,_strexpr);   
    ((TForm_subsection &)_form->find_field('B',odd_page,"H_MOVS_INTERESSATI")).setcondition(cond,_strexpr);   
    cond.cut(0) << "ANSI(" << LF_MOVMAG << "->DATAREG)<\"" << d1.string(ANSI) << '"';
    ((TForm_subsection &)_form->find_field('B',odd_page,"MOVS_PRECEDENTI")).setcondition(cond,_strexpr);
  }
  if (m.get(F_ADATA).not_empty()) 
  {
    TDate d1(m.get(F_ADATA));
    filter << "(ANSI(110->DATAREG)<=" <<'"' << d1.string(ANSI) << "\")&&" ;
  }

  // filtering ONLY NEGATIVES
  if (m.get(F_FILTRO)[0]=='N') 
   _cur->set_filterfunction(negatives_only);
  
  // Imposta i livelli di dettaglio della scheda
  const int tolivelloart = m.get_int(F_TOLIVELLOART);
  const int tolivellogiac = tolivelloart <= 0 ? m.get_int(F_TOLIVELLOGIAC) : 0;
	TString sortexp;
  int tilde = 0x2;
  switch (subordine)
  {
  case 'C':
    {
      _cur->setkey(1); sortexp = ANAMAG_CODART;
      darec.put(ANAMAG_CODART, m.get(F_DAART));
      const TString& aart = m.get(F_AART);
      arec.put(ANAMAG_CODART, aart);
      if (aart.blank() || cache().get(LF_ANAMAG, aart).empty())
        tilde = 0x0;
      
      _form->setdett_perart(false, false, tolivelloart, tolivellogiac,
  													m.get_bool(F_SUDDIV_MAGAZZINI),
  										      m.get_bool(F_SUDDIV_DEPOSITI));
    }
    break;
  case 'D':
		_cur->setkey(2);  sortexp = ANAMAG_DESCR;
    darec.put("DESCR", m.get(F_DADES));
    arec.put("DESCR", m.get(F_ADES));
    _form->setdett_perart(false , false, tolivelloart, tolivellogiac,
		  										m.get_bool(F_SUDDIV_MAGAZZINI),
									        m.get_bool(F_SUDDIV_DEPOSITI));
    break;
  case  'M':
    _cur->setkey(3);  sortexp = ANAMAG_GRMERC;
    darec.put("GRMERC", m.get(F_DACATMER));
    arec.put("GRMERC", m.get(F_ACATMER));
    if (m.get(F_AART).full())
      cfilter << "(CODART<=" <<'"' << m.get(F_AART)<< TString(20,(char)127)<< "\")&&" ;
    if (m.get(F_DAART).full())
      cfilter << "(CODART>=" <<'"' << m.get(F_DAART) << "\")&&" ;
    _form->setdett_perart(true, false, tolivelloart, tolivellogiac,
													m.get_bool(F_SUDDIV_MAGAZZINI),
													m.get_bool(F_SUDDIV_DEPOSITI));
    break;
  case 'P':
    _cur->setkey(1);  sortexp = ANAMAG_USER1;
    darec.put("CODART", m.get(F_DAART));
    arec.put("CODART", m.get(F_AART));
    _form->setdett_perart( false, false, tolivelloart, tolivellogiac,
													m.get_bool(F_SUDDIV_MAGAZZINI),
													m.get_bool(F_SUDDIV_DEPOSITI));
    if (m.get(F_DAUSR).full())
	    cfilter << "(USER1>=\"" << m.get(F_DAUSR) << "\")&&";
    if (m.get(F_AUSR).full())
	    cfilter << "(USER1<=\"" << m.get(F_AUSR) << "~\")&&";
    break;
	default:
		break;
  }

	_form->set_description_field(subordine == 'P' ? ANAMAG_USER1 : "");

  // prepare cursor's relation....
  TRelation *aux=new TRelation (LF_RMOVMAG);
  aux->add(LF_MOVMAG,"NUMREG==NUMREG");
  if (filter.right(2) == "&&") 
    filter.rtrim(2); 
  TSortedfile *rmovmag= new TSortedfile(LF_RMOVMAG,aux,_form->rmov_sortexp(),filter,0x2);
  darecr.put(RMOVMAG_CODART,darec.get(ANAMAG_CODART));
  arecr.put(RMOVMAG_CODART,arec.get(ANAMAG_CODART));
  rmovmag->setregion(darecr,arecr,tilde);
  if (tiposcheda() != s_giac)
    rmovmag->cursor().set_filterfunction(cau_filter);
  _cur->relation()->replace(rmovmag,1, _form->rmov_joinexp() );

  TLocalisamfile *mag=new TLocalisamfile(LF_MAG);
  mag->setkey(2);
  TString mag_joinexp;
  mag_joinexp << "ANNOES==\"" << m.get(F_ANNOES) << "\"|CODMAG==CODMAG|CODART==CODART|LIVELLO==LIVGIAC";
  _cur->relation()->replace(mag,2,mag_joinexp);
  
  if (cfilter.not_empty()) 
    cfilter.rtrim(2); 

  _cur->setfilter(cfilter);
  _cur->setregion(darec,arec,0x2);
	((TSorted_cursor*)_cur)->change_order(sortexp);
}

void TStampa_schede_mag::main_loop()
{        
	TStampemg_mask & m = mask();
  while (reload() || m.run() == K_ENTER) 
  { 
		reload() = false;
    if (m.magazz_ini().gestmag(true))
    {
      const char dettaglio=m.get(F_ENABLER)[0];
      if (dettaglio=='A') // Filtra su livello articolo
      {
        if (m.get_int(F_TOLIVELLOART)==0)
          m.set(F_TOLIVELLOART,livelli_articolo().last_level());
        m.reset(F_TOLIVELLOGIAC);
      }
      else                // Filtra su livello giacenza
      {
        if (m.get_int(F_TOLIVELLOGIAC)==0)
          m.set(F_TOLIVELLOGIAC,livelli_giacenza().last_level());
      }
      TString8 frmname;
      const bool per_articoli = *m.get(F_ORDINE) == 'A';
      const bool sintetica = m.get_bool(F_SINTETICA);
      if (per_articoli)
        frmname = "mg3300a";
      else
        frmname = "mg3300b";
      if (sintetica)
        frmname << 's';
      _form = new TForm_schedemag(frmname, "") ;
      _form->set_options(m.get_bool(F_NO_VALORI), m.get_bool(F_NO_FF),
                         sintetica);
        
      if (per_articoli)  
        setprint_perarticoli();
      else
        setprint_permagazzini();

      _form->set_date_limite(m.get_int(F_ANNOES), m.get_date(F_DADATA), m.get_date(F_ADATA));
  
      _form->print();
      delete _form;
      _form = NULL;
    }
  } // while true  
  return ;
}

bool TStampa_schede_mag::handle_dadata(TMask_field& f, KEY k)
{ 
  if (!f.empty() && f.to_check(k))       // se f deve essere controllato (cioé se é cambiato e sono uscito da lui o dalla maschera)
  {
    const int annoes = f.mask().get_int(F_ANNOES);
    TEsercizi_contabili ec;
    const TEsercizio& es = ec[annoes];
    TDate data(f.get());
    if (data < es.inizio())    
      return f.error_box (FR("La data di inizio non puo' essere anteriore al %s"), es.inizio().string());     
  }
  return TRUE;
}

bool TStampa_schede_mag::handle_adata(TMask_field& f, KEY k)
{ 
  if (!f.empty() && f.to_check(k))       // se f deve essere controllato (cioé se é cambiato e sono uscito da lui o dalla maschera)
  {
    const int annoes = f.mask().get_int(F_ANNOES);
    TEsercizi_contabili ec;
    const TEsercizio& es = ec[annoes];
    const TDate data(f.get());
    if (data > es.fine())    
      return f.error_box (FR("La data di fine non puo' essere successiva al %s"), es.fine().string());     
  }
  return true;
}

static bool linker(int n, const char* str)
{
  if (n == 0)
  {
		TRectype art(LF_ANAMAG);
		
		art.put(ANAMAG_CODART, str);
		app().reload() = art.edit();
  }
  else
  {
		TRectype mov(LF_MOVMAG);
		
		mov.put(MOVMAG_NUMREG, str);
		app().reload() = mov.edit();
  }
	return false;
}

bool TStampa_schede_mag::create()
{
  open_files(LF_TABCOM, LF_TAB, LF_RMOVMAG, LF_MOVMAG, LF_MAG, LF_ANAMAG, 0);
  _mask = new TStampemg_mask("mg3300");
  _mask->set_handler(F_DADATA,handle_dadata);
  _mask->set_handler(F_ADATA,handle_adata);

  TConfig prassid(CONFIG_DITTA, "ve"); // apre il file di configurazione della ditta corrente
	
	if (prassid.get_bool("CHK_USER", "ve", 1))
	{
		const TString& user1 = prassid.get("PROMPT_USER", "ve", 1);

		_mask->field(F_DAUSR).set_prompt(user1);
		_mask->show(F_DAUSR); _mask->show(F_AUSR);
  }
  
  printer().links().add("Articolo |b|w");  // Crea il link blu alle anagrafiche
  printer().links().add("Movimento |v|w");  // Crea il link viola ai movimenti
  printer().setlinkhandler(linker);
  
  return TSkeleton_application::create();
}

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

int mg3300(int argc, char* argv[])
{
  TStampa_schede_mag a;// derivata da Application e con uso di form
  a.run(argc,argv,TR("Stampa schede di magazzino"));
  return 0;
}