// Stampa dettaglio disponibilita' articoli
#include <applicat.h>
#include <automask.h>
#include <printer.h>
#include <recset.h>
#include <tabutil.h>
#include <utility.h>

#include "orlib.h"
#include "or1400a.h"

#include "../cg/cglib01.h"
#include "../mg/mglib.h"
#include "../ve/velib.h"
#include "../mg/anamag.h"
#include <clifo.h> 
#include <cfven.h> 

static TString8 __codmag;
static int __codes;

class TArticoli_recordset : public TISAM_recordset
{
	bool _sottoscorta;

protected:
	static bool filtra_sottoscorta(const TRelation* rel);

public:
	virtual TCursor* cursor() const;
	TArticoli_recordset(const char* use, bool sottoscorta, int codes, const char * codmag) : TISAM_recordset(use), _sottoscorta(sottoscorta) { __codes = codes; __codmag = codmag;}
	virtual ~TArticoli_recordset() {}
};

bool TArticoli_recordset::filtra_sottoscorta(const TRelation* rel)
{
	((TRelation *)rel)->save_status();
  const TString codart = rel->curr(LF_ANAMAG).get(ANAMAG_CODART);
  TArticolo_giacenza artgiac(codart);

  const real giac = artgiac.giacenza_anno(__codmag, NULL, __codes);

  const bool ok = giac < artgiac.scorta_minima(__codmag, NULL, __codes);
	((TRelation *)rel)->restore_status();
	return ok;
}

TCursor* TArticoli_recordset::cursor() const
{
	TCursor * c = TISAM_recordset::cursor();

	if (c != NULL && _sottoscorta)
	  c->set_filterfunction(filtra_sottoscorta);
	return c;
}

class TGenera_ordini_mask : public TAutomask
{
	TString _anamag_query;
	bool _filter_changed;
	
private:
  void serialize(bool bSave);
	void load_user_defs();

protected:
	virtual bool on_sheet_event(TOperable_field& o, TField_event e, long jolly);
  virtual bool on_field_event(TOperable_field& o, TField_event e, long jolly);
	virtual void next_page(int p);


public:
	void update_sheet();
  TGenera_ordini_mask();
  ~TGenera_ordini_mask();
};

void TGenera_ordini_mask::update_sheet()
{
	TSheet_field & sf = sfield(F_ARTICLES);
	TEsercizi_contabili esc;
	TString query(_anamag_query);
	TString16 grmerc(get(F_GRMERC));
	const int pos = query.find("KEY ");
	TArticolo_giacenza art;
	TString8 codmag(get(F_MAG));
	const TDate data(TODAY);
	const int anno = data.year();

	codmag.left_just(3);
	codmag << get(F_DEP);
	codmag.trim();
	
	grmerc.left_just(3);
	grmerc << get(F_SGRMERC);
	grmerc.trim();

	if (grmerc.full())
	{
		if (pos > 0)
			query[pos + 4] = '3';
		query << "\nFROM GRMERC=#GRMERC\nTO GRMERC=#GRMERC";
	}
	else
		if (pos > 0)
			query[pos + 4] = '1';
	
	TString select;

	const TString & codart = get(F_SCODART);

	if (codart.full())
		select << "(UPPER(" << ANAMAG_CODART << ")?=UPPER(\"" << codart << "\"))";

	const TString & desart = get(F_SDESART);

	if (desart.full())
	{
		if (select.full())
			select << "&&";
		select << "(UPPER(" << ANAMAG_DESCR << ")?=UPPER(\"" << desart << "\"))";
	}

	const TString & desagg = get(F_SDESAGG);

	if (desagg.full())
	{
		if (select.full())
			select << "&&";
		select << "(UPPER(" << ANAMAG_DESCRAGG << ")?=UPPER(\"" << desagg << "\"))";
	}


	const TString & codforn = get(F_SCODFOR);

	if (codforn.full())
	{
		if (select.full())
			select << "&&";
		select << "(" << ANAMAG_CODFORN << "==\"" << codforn << "\")";
	}

	const TString & ragsoc = get(F_SRAGSOC);

	if (ragsoc.full())
	{
		if (select.full())
			select << "&&";
		select << "(UPPER(CLIFO.RAGSOC)?=UPPER(\"" <<  ragsoc << "\"))";
	}

	if (select.full())
	{
		int pos = query.find("SELECT ");
		if (pos > 0)
		{
			const int acapo = query.find('\n', pos);
			query.insert("((", pos+7);
      select.insert(")&&(");
			select << "))";
			query.insert(select, acapo+2);
		}
		else
		{
		  pos = query.find('\n');
			select.insert("\nSELECT ");
			query.insert(select, pos);
		}
	}


	TArticoli_recordset recset(query, get_bool(F_SOTTOSCORTA), esc.date2esc(TDate(TODAY)), get(F_MAG));
	TVariant var ;

	var = grmerc;
	recset.set_var("#GRMERC", var);
	var =  user();
	recset.set_var("#USER", var);
	TString8 codes; codes.format("%04d", esc.date2esc(TDate(TODAY)));

	int i = 0;

	sf.destroy();

  for (bool ok = recset.move_first(); ok; ok = recset.move_next())
  {
		TToken_string & row = sf.row(i);
		const TString & codart = recset.get(ANAMAG_CODART).as_string();

		row.add(codart, sf.cid2index(F_CODART));
		art.read(codart);
		const real giac = art.giacenza_anno(codmag, "", anno);
		row.add(recset.get(ANAMAG_DESCR).as_string(), sf.cid2index(F_DESCR));
		row.add(recset.get("UMART.UM").as_string(), sf.cid2index(F_UM));

		const long  codforn = recset.get(ANAMAG_CODFORN).as_int();
		
		row.add(codforn, sf.cid2index(F_FORNITORE));
		row.add(recset.get("CLIFO.RAGSOC").as_string(), sf.cid2index(F_RAGSOC));
		row.add(recset.get(ANAMAG_GIORNIRIOR).as_string(), sf.cid2index(F_LEADTIME));
		row.add(recset.get(ANAMAG_LOTTORIOR).as_string(), sf.cid2index(F_LOTTOMIN));
		row.add(recset.get(ANAMAG_DESCRAGG).as_string(), sf.cid2index(F_DESCRAGG));
		row.add(giac.stringa(), sf.cid2index(F_GIACENZA));

		row.add(recset.get(ANAMAG_PPCONF).as_string(), sf.cid2index(F_PPCONF));
		row.add(recset.get(ANAMAG_USER1).as_string(), sf.cid2index(F_USER1));
		row.add(recset.get(ANAMAG_USER2).as_string(), sf.cid2index(F_USER2));
		row.add(recset.get(ANAMAG_USER3).as_string(), sf.cid2index(F_USER3));
		row.add(recset.get(ANAMAG_USER4).as_string(), sf.cid2index(F_USER4));
		row.add(recset.get(ANAMAG_USER5).as_string(), sf.cid2index(F_USER5));
		row.add(recset.get(ANAMAG_USER6).as_string(), sf.cid2index(F_USER6));
		row.add(recset.get(ANAMAG_USER7).as_string(), sf.cid2index(F_USER7));
		row.add(recset.get(ANAMAG_USER8).as_string(), sf.cid2index(F_USER8));
		row.add(recset.get(ANAMAG_USER9).as_string(), sf.cid2index(F_USER9));
		row.add(recset.get(ANAMAG_USER10).as_string(), sf.cid2index(F_USER10));
		const real disp = art.disponibilita(codes, get(F_MAG), NULL);
		row.add(disp.string(), sf.cid2index(F_DISPON));
		sf.check_row(i++);
	}
}

void TGenera_ordini_mask::next_page(int p)
{
	TAutomask::next_page(p);
	if (_filter_changed)
	{
		TSheet_field & sf = sfield(F_ARTICLES);

		if (win() == sf.parent())
		{
			update_sheet();
			sf.force_update();
			_filter_changed = false;
		}
	}

}

bool TGenera_ordini_mask::on_sheet_event(TOperable_field& o, TField_event e, long jolly)
{
  TSheet_field& sht = (TSheet_field&)o;

  switch(e)
  {
	  case se_query_del:
		case se_query_add:
			return false;
			break;
		default:
			break;
  }
  return true;
}

bool TGenera_ordini_mask::on_field_event(TOperable_field& o, TField_event e, long jolly)
{
  bool ok = true;
	switch (o.dlg())
  {
		case F_GRMERC:
		case F_SGRMERC:
		case F_SOTTOSCORTA:
		case F_SCODART:
		case F_SDESART:
		case F_SDESAGG:
		case F_SCODFOR:
		case F_SRAGSOC:
			if (e == fe_modify)
				_filter_changed = true;
			break;
		default:
			break;
  }
  return ok;
}

void TGenera_ordini_mask::serialize(bool bSave)
{
  const char* defpar = "or";
  TConfig ini(CONFIG_DITTA, defpar);
  for (int i = fields()-1; i >= 0; i--)
  {
    TMask_field& f = fld(i);
    const TFieldref* fr = f.field();
    if (fr != NULL)
    {
      if (bSave)
        fr->write(ini, defpar, f.get());
      else
        f.set(fr->read(ini, defpar));
    }
  }
}

void TGenera_ordini_mask::load_user_defs()
{
  const char* defpar = "or";
  TConfig ini(CONFIG_USER, defpar);
  for (int i = fields()-1; i >= 0; i--)
  {
    TMask_field& f = fld(i);
    const TFieldref* fr = f.field();
    if (fr != NULL)
    {
      const char * val = fr->read(ini, defpar);
			if (*val)
			{
	      f.set(val);
				f.disable();
			}
    }
  }
}

TGenera_ordini_mask::TGenera_ordini_mask() 
         : TAutomask("or1400a"), 	_filter_changed(false)
	
{
  serialize(false);
	load_user_defs();
	TConfig c(CONFIG_DITTA);

	_anamag_query = c.get("OR14_QUERY");

	if (_anamag_query.blank())
		_anamag_query =  "USE ANAMAG KEY 1\nJOIN UMART INTO CODART==CODART NRIGA==1\nJOIN CLIFO INTO TIPOCF==\"F\" CODCF==CODFORN";
	else
		_anamag_query = esc(_anamag_query );

	TSheet_field & sh = sfield(F_ARTICLES);
	TMask & sh_mask = sh.sheet_mask();
	TString prompt;
  
	for (int i = 1; i <= 10; i++)
  {                  
    const int col = sh.cid2index(F_USER1 + i -1);
    TEditable_field & f = sh_mask.efield(F_USER1 + i - 1);            
		
		if (c.get_bool("CHK_USER", "ve", i)	&& c.get_bool("USERDEF", "or", i))
    {  
      prompt = c.get("PROMPT_USER", "ve", i);
      prompt.rpad(20);              
			f.set_prompt(prompt);
			sh.set_column_header(col, prompt);
    }
		else
		{
			f.hide();
			sh.delete_column(col);
		}
  } 
}

TGenera_ordini_mask::~TGenera_ordini_mask()
{
  serialize(true);
}

class TCreazione_ordini : public TSkeleton_application
{
	TString_array _userfld;

  void generate_orders(TGenera_ordini_mask & mask);

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

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

bool TCreazione_ordini::create()
{
  open_files(LF_DOC, LF_RIGHEDOC, LF_CONDV, LF_RCONDV, LF_ANAMAG, LF_SCONTI, LF_UMART, LF_DESLIN, LF_CODCORR,
             LF_TAB, LF_TABCOM, LF_CLIFO, LF_CFVEN, LF_INDSP, LF_OCCAS, LF_PCON, LF_MOV, LF_STOMAG, 
             LF_MOVMAG, LF_RMOVMAG, LF_MAG, LF_SVRIEP, LF_AGENTI, LF_PERCPROV, LF_ATTIV, LF_CAUSALI, 0);
	TConfig c(CONFIG_DITTA);

	for (int i = 0; i < 10; i++ )
		_userfld.add(c.get("USERFLD", NULL, i + 1), i);

  return TSkeleton_application::create();
}

void TCreazione_ordini::generate_orders(TGenera_ordini_mask & mask)
{
	TSheet_field & sf = mask.sfield(F_ARTICLES);
	TAssoc_array orders;
	const TDate datadoc(TODAY);
	const TString16 codnum(mask.get(F_CODNUM));
	const TString16 tipodoc(mask.get(F_TIPODOC));
	const TString8 tipo_prezzo(mask.get(F_PREZZO));
	long minforn = 999999L;
	long maxforn = 0L;
	const TString commessat = mask.get(F_CDCT);
	const TString faset = mask.get(F_FSCT);
	TString16 codmag(mask.get(F_MAG));
	
	codmag.right_just(3);
	codmag << mask.get(F_DEP);

  FOR_EACH_SHEET_ROW(sf, n, row)
  {
		const real qta(row->get(sf.cid2index(F_QTA)));
		if (qta > ZERO)
		{
			const TString16 codforn(row->get(sf.cid2index(F_FORNITORE)));
			const long cod = atoi(codforn);
			const TDate datacons(row->get(sf.cid2index(F_DATACONS)));
			TString16 key ; key. format ("F|%s", (const char *) codforn);
			const TRectype & forn = cache().get(LF_CLIFO, key);
			const TRectype & forven = cache().get(LF_CFVEN, key);
			const TString16 codval(forn.get(CLI_CODVAL));
			TString16 codiva(forven.get(CFV_ASSFIS));
			const TString commessa = row->get(sf.cid2index(F_CDC));
			const TString fase = row->get(sf.cid2index(F_FSC));
			TDocumento * d = (TDocumento *)orders.objptr(codforn);

			if (d == NULL)
			{
				TTipo_documento tipo(tipodoc);

				d = new TDocumento('D', datadoc.year(), codnum, 0L);
				d->put(DOC_TIPODOC, tipodoc);
				d->put(DOC_TIPOCF, "F");
				d->put(DOC_CODCF, codforn);
				d->put(DOC_DATADOC, datadoc);
				d->put(DOC_DATACONS, datacons);
				d->put(DOC_CODVAL, codval);
				d->put(DOC_CODLIN, forn.get(CLI_CODLIN));
				d->put(DOC_CODPAG, forn.get(CLI_CODPAG));
				d->put(DOC_CODABIA, forn.get(CLI_CODABI));
				d->put(DOC_CODCABA, forn.get(CLI_CODCAB));
				d->put(DOC_IBAN, forn.get(CLI_IBAN));
				d->put(DOC_CODABIP, forven.get(CFV_CODABIPR));
				d->put(DOC_CODCABP, forven.get(CFV_CODCABPR));
				d->put(DOC_RAGGR, forven.get(CFV_RAGGDOC));
				d->put(DOC_RAGGREFF, forven.get(CFV_RAGGEFF));
				d->put(DOC_CODINDSP, forven.get(CFV_CODINDSP));
				d->put(DOC_CODAG, forven.get(CFV_CODAG));
				d->put(DOC_ZONA, forven.get(CFV_CODZONA));
				d->put(DOC_CODSPMEZZO, forven.get(CFV_CODSPMEZZO));
				d->put(DOC_CODPORTO, forven.get(CFV_CODPORTO));
				d->put(DOC_CODNOTESP1, forven.get(CFV_CODNOTESP1));
				d->put(DOC_CODNOTESP2, forven.get(CFV_CODNOTESP2));
				d->put(DOC_CODNOTE, forven.get(CFV_CODNOTE));
				d->put(DOC_CODVETT1, forven.get(CFV_CODVETT1));
				d->put(DOC_CODVETT2, forven.get(CFV_CODVETT2));
				d->put(DOC_CODVETT3, forven.get(CFV_CODVETT3));
				d->put(DOC_PERCSPINC, forven.get(CFV_PERCSPINC));  
				d->put(DOC_ADDBOLLI, forven.get(CFV_ADDBOLLI));
				d->put(DOC_CATVEN, forven.get(CFV_CATVEN));
				d->put(DOC_CODLIST, forven.get(CFV_CODLIST));
				d->put(DOC_CODCMS, commessat);
				d->put(DOC_NOTE, mask.get(F_NOTE));
				const TString & causmag = tipo.caus_mov();
				d->put(DOC_CAUSMAG, causmag);
				orders.add(codforn, d);
				if (cod < minforn)
					minforn = cod;
				if (cod > maxforn)
					maxforn = cod;
			}

			TRiga_documento & rdoc = d->new_row("01");
			const TString codart(row->get(sf.cid2index(F_CODART)));
			
			rdoc.put(RDOC_CODMAG, codmag);
			rdoc.put(RDOC_CODART, codart);
			rdoc.put(RDOC_CODARTMAG, codart);
			rdoc.put(RDOC_CHECKED, "X");
			rdoc.put(RDOC_DESCR, row->get(sf.cid2index(F_DESCR)));

			const TString descr_agg(row->get(sf.cid2index(F_DESCRAGG)));

			if (descr_agg.full())
			{
				rdoc.put(RDOC_DESCLUNGA, "X");
				rdoc.put(RDOC_DESCEST, descr_agg);
			}
			rdoc.put(RDOC_UMQTA, row->get(sf.cid2index(F_UM)));
			rdoc.put(RDOC_QTA, qta);
			rdoc.put(RDOC_DATACONS, datacons);
			const TRectype & articolo = cache().get(LF_ANAMAG, codart);
			TPrice prezzo;
			
			if (tipo_prezzo == "U")
				prezzo = articolo.get_real(ANAMAG_ULTCOS1);
			else
				prezzo = articolo.get_real(ANAMAG_COSTSTD);
			prezzo.change_value(codval);
			rdoc.put(RDOC_PREZZO, prezzo.get_num());
			if (codiva.full())
				rdoc.put(RDOC_CODIVA, codiva);
			else
				rdoc.put(RDOC_CODIVA, articolo.get(ANAMAG_CODIVA));
			rdoc.put(RDOC_CODCMS, commessa);
			rdoc.put(RDOC_FASCMS, fase);
			for (int i = 0; i < 10 ; i++)
				if (_userfld.row(i).full())
					rdoc.put(_userfld.row(i), mask.get(F_USER1 + i));

			rdoc.put(RDOC_CODAGG1, row->get(sf.cid2index(F_CODAGG1)));
			rdoc.put(RDOC_CODAGG2, row->get(sf.cid2index(F_CODAGG2)));
		}
	}
	int cnt = 0;
	for (long cod = minforn; cod <= maxforn; cod++)
	{
		TString16 key; key.format("%ld", cod);
		TDocumento * d = (TDocumento *) orders.objptr(key);

		if ( d != NULL)
		{
			d->write();
			cnt++;
		}
	}
  	message_box("Attenzione sono stati generati %d documenti", cnt);
}

void TCreazione_ordini::main_loop()
{
	TGenera_ordini_mask mask;

	while (true)
	{
		mask.update_sheet();
		if (mask.run() == K_ENTER)
			generate_orders(mask);
		else break;
	}
}

bool TCreazione_ordini::destroy()
{
  return TSkeleton_application::destroy();
}

int or1400(int argc, char** argv)
{
  TCreazione_ordini a;
  a.run(argc,argv,TR("Generazione Ordini a fornitore"));
  return 0;
}