#include <applicat.h>
#include <execp.h>
#include <reprint.h>

#include "movana.h"
#include "pconana.h"
#include "rmovana.h"

#include "ca3.h"
#include "calib01.h"
#include "calib02.h"

#include "ca3300.h"

////////////////////////////////////////////////////////
//	MASCHERA
////////////////////////////////////////////////////////

class TPrint_bilancio_ca_mask : public TAutomask
{
protected:
  virtual bool on_field_event(TOperable_field& o, TField_event e, long jolly);
  const TString& get_report_class() const; 
  bool test_compatible_report();
	
  void create_sheet();
	int create_sheet_fields(int lf, int& y, short& dlg, bool required);
public:
  TPrint_bilancio_ca_mask();
  virtual ~TPrint_bilancio_ca_mask() {}
};

const TString& TPrint_bilancio_ca_mask::get_report_class() const
{
  TString& lib = get_tmp_string();
  lib = "ca3300";
  const char stp = get(F_TIPOSTAMPA)[0]; // Raffronto o No?
  const char bil = get(F_BILANCIO)[0];    // Verifica o sezioni Contrapposte
  if (bil == 'V')
    lib << (stp == 'R' ? 'a' : 'b');  // Verifica
  else
    lib << (stp == 'R' ? 'c' : 'd');  // Sezioni contrapposte 
  return lib;
}

bool TPrint_bilancio_ca_mask::test_compatible_report()
{
  const TString& cls = get_report_class();
  const TString& name = get(F_REPORT);
  bool ok = name.not_empty();
  if (ok)
  {
    TReport rep; 
    ok = rep.load(name);
    if (ok)
    {
      const TString& classe = rep.get_class();
      ok = classe == cls;
    }
  }
  if (!ok)
  {
    set(F_REPORT, cls);
    TFilename path = cls;
    path.ext("rep");
    ok = path.custom_path();
  }
  return ok;
}

bool TPrint_bilancio_ca_mask::on_field_event(TOperable_field& o, TField_event e, long jolly) 
{
  switch (o.dlg())
  {
  case F_BILANCIO:
  case F_TIPOSTAMPA:
    if (e == fe_init || e == fe_modify)
      test_compatible_report();
    break;
  case F_REPORT:
    if (e == fe_button)
    {
      const TString8 lib = get_report_class();
      TFilename path = o.get();
      if (select_custom_file(path, "rep", lib))
      {
        path = path.name();
        path.ext("");
        o.set(path);
      }
    } else
    if (e == fe_close)
    {
      if (!test_compatible_report())
        return error_box("Impossibile trovare un report compatibile");
    }
    break;
  default:
    break;
  }
  return true;
}

int TPrint_bilancio_ca_mask::create_sheet_fields(int lf, int& y, short& dlg, bool required)
{
	TSheet_field& sf = sfield(F_RIGHE);
  TMask& sm = sf.sheet_mask();

  const int h = ca_create_fields(sm, 0, lf, 1, y, dlg, dlg+50);

  for (int i = 0; i < h; i++)
  {
    TEdit_field& fld = sm.efield(dlg+i);
    int logic = lf;
    if (logic == LF_FASI)
    {
      const TMultilevel_code_info& fasinfo = ca_multilevel_code_info(LF_FASI);
      if (fasinfo.parent() != 0)
      {
        const TMultilevel_code_info& parinfo = ca_multilevel_code_info(fasinfo.parent());
        if (i < parinfo.levels())
          logic = fasinfo.parent();
      }
    }

    const char* fieldname = NULL;
    switch(logic)
    {
    case LF_CDC     : fieldname = RMOVANA_CODCCOSTO; break;
    case LF_COMMESSE: fieldname = RMOVANA_CODCMS;   break;
    case LF_FASI    : fieldname = RMOVANA_CODFASE;  break;
    default         : fieldname = RMOVANA_CODCONTO; break;
    }
    TFieldref* f = (TFieldref*)fld.field();
    f->set_name(fieldname);
    
    fld.check_type(required ? CHECK_REQUIRED : CHECK_NORMAL);

    TEdit_field& dfld = sm.efield(dlg+50+i);
    dfld.set_field(EMPTY_STRING); // Toglie campi che fan saltare gli output!
  }

  y += h+1;
  dlg += h;

  return h;
}

void TPrint_bilancio_ca_mask::create_sheet()
{
	TSheet_field& sf = sfield(F_RIGHE);
  TMask& sm = sf.sheet_mask();
  sm.hide(-1);

  const TMultilevel_code_info& fasinfo = ca_multilevel_code_info(LF_FASI);

  TConfig_anal ini;
  const bool fsc_req = ini.get_bool("FscRequired");

  int y = 1;
  short dlg = S_CDC1 + 100; // id del primo campo da generare

  for (int i = 0; i < 2; i++)
  {
    const TString& level = ini.get("Level", NULL, i+1);  // Legge il livello 1 o 2
    if (level == "CDC")                                  // Crea centro di costo 
    {
      if (fasinfo.parent() == LF_CDC)
        create_sheet_fields(LF_FASI, y, dlg, fsc_req);
      else
      {
        const bool cdc_req = ini.get_bool("CdcRequired");
        create_sheet_fields(LF_CDC, y, dlg, cdc_req);
      }
    } else
    if (level == "CMS")                                   // Crea commessa
    {
      if (fasinfo.parent() == LF_COMMESSE)
        create_sheet_fields(LF_FASI, y, dlg, fsc_req);
      else
      {
        const bool cms_req = ini.get_bool("CmsRequired");
        create_sheet_fields(LF_COMMESSE, y, dlg, cms_req);
      }
    }
  }

  if (fasinfo.levels() > 0 && fasinfo.parent() <= 0)
    create_sheet_fields(LF_FASI, y, dlg, fsc_req);

	for (short id = S_CDC12+100; id >= S_CDC1+100; id--)
  {
    const int pos = sm.id2pos(id);
    if (pos >= 0)
    {
      TMask_field& f = sm.fld(pos);
      const int size = f.size();
      const TString& prompt = f.prompt();
      sf.set_column_header(id, prompt);
      sf.set_column_justify(id, f.is_kind_of(CLASS_REAL_FIELD));
      sf.set_column_width(id, (max(3+size, prompt.len()+1)) * CHARX);
    }
    else
      sf.delete_column(id);
	}
}


TPrint_bilancio_ca_mask::TPrint_bilancio_ca_mask()
								:TAutomask("ca3300")
{
	TConfig_anal cfg;
	const bool use_pdcc = cfg.get_bool("UsePdcc");

	const int logicnum = use_pdcc ? LF_PCON : LF_PCONANA;

	const int nfields = ca_create_fields(*this, 1, logicnum, 2, 1, F_PDC1_INI, F_DES1_INI, 0x0, PCONANA_CODCONTO);
	ca_create_fields(*this, 1, logicnum, 2, 7, F_PDC1_FIN, F_DES1_FIN, 0x0, PCONANA_CODCONTO);

	for (int i = 0; i < nfields; i++)
	{
		TMask_field& daconto = field(F_PDC1_INI + i);
		daconto.set_group(1);
		daconto.check_type(CHECK_NORMAL);
		TMask_field& aconto = field(F_PDC1_FIN + i);
		aconto.set_group(2);
		aconto.check_type(CHECK_NORMAL);
	}
	// creazione dei campi della seconda pagina della maschera
	create_sheet();
}

////////////////////////////////////////////////////////
// Report
////////////////////////////////////////////////////////

class TReport_bilancio_ca : public TAnal_report
{
protected:
  virtual bool set_recordset(const TString& sql);

public:
  void set_filter(const TMask& msk, int row);
  TReport_bilancio_ca(const char* name);
};

bool TReport_bilancio_ca::set_recordset(const TString& /* sql */)
{
  TPconana_recordset* rset = new TPconana_recordset();
  return TReport::set_recordset(rset);
}

void TReport_bilancio_ca::set_filter(const TMask& m, int row)
{
  TString da_conto, a_conto, costo, commessa, fase;
  for (int i = 0; m.id2pos(F_PDC1_INI+i) > 0; i++)
  {
    da_conto << m.get(F_PDC1_INI+i);
    a_conto << m.get(F_PDC1_FIN+i);
  }
  
  const TDate dal = m.get(F_DATADA);
  const TDate al = m.get(F_DATAA);

  int tipimov = 0;
  switch (m.get(F_TIPOSTAMPA)[0])
  {
  case 'C': tipimov = 1; break; // Consuntivo
  case 'P': tipimov = 6; break; // Preventivo e variazioni 
  default : tipimov = 7; break; // Raffronto
  }

  const bool movimentati = m.get_int(F_STAMPAV) == 1;
  const bool nonnulli = m.get_int(F_STAMPAV) == 2;

  TSheet_field& sf = m.sfield(F_RIGHE);
  TMask& sm = sf.sheet_mask();
  sf.update_mask(row);
  TRelation rel(LF_RMOVANA);
  sm.autosave(rel);
  costo = rel.curr().get(RMOVANA_CODCCOSTO);
  commessa = rel.curr().get(RMOVANA_CODCMS);
  fase = rel.curr().get(RMOVANA_CODFASE);

  TPconana_recordset* rset = (TPconana_recordset*)recordset();
  rset->set_filter(da_conto, a_conto, costo, commessa, fase, dal, al, tipimov, movimentati, nonnulli);
}

TReport_bilancio_ca::TReport_bilancio_ca(const char* name) 
{ 
  load(name); 
}

////////////////////////////////////////////////////////
//	APPLICAZIONE
////////////////////////////////////////////////////////
class TPrint_bilancio_ca : public TSkeleton_application
{
public:
  virtual void main_loop();
};

void TPrint_bilancio_ca::main_loop()
{
  TPrint_bilancio_ca_mask mask;
  while (mask.run() != K_QUIT)
  {
    TReport_book book;
		TReport_bilancio_ca rep(mask.get(F_REPORT));

    TSheet_field& sf = mask.sfield(F_RIGHE);
    if (sf.empty())
      sf.row(-1);  // Aggiungo riga vuota
    const int rows = sf.items();
    for (int i = 0; i < rows; i++)
    {
      rep.set_filter(mask, i);   
      book.add(rep);
    }
    
    book.print_or_preview();
	}
}

int ca3300(int argc, char* argv[])
{
  TPrint_bilancio_ca a;
  a.run(argc, argv, TR("Stampa bilancio"));
  return 0;
}