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

#include "../ca/calib01.h"
#include "../ca/commesse.h"

#include "rilore.h"
#include "ci1300a.h"


///////////////////////////////////////////////////////////
// Maschera
///////////////////////////////////////////////////////////

class TRil_ore_mask : public TAutomask
{
protected:
  virtual bool on_field_event(TOperable_field& o, TField_event e, long jolly);
  long calcola_giorni_lavorativi(const TDate& dataini, const TDate& datafine) const;
  long calcola_giorni_lavorativi_cms(const TDate& ini_cms, const TDate& fine_cms, 
                                     const TDate& dataini, const TDate& datafine,
                                     TDate& inizio_lav, TDate& fine_lav) const;
  void elabora_risorsa(const TString& curr_risorsa, TReport& rep) const;
	
public:
  void elabora() const;

  TRil_ore_mask();
  virtual ~TRil_ore_mask() {}
};

TRil_ore_mask::TRil_ore_mask() : TAutomask("ci1300a")
{
}

bool TRil_ore_mask::on_field_event(TOperable_field& o, TField_event e, long jolly)
{
  return true;
}

long TRil_ore_mask::calcola_giorni_lavorativi(const TDate& dataini, const TDate& datafine) const
{
  long num_giorni_lav = datafine - dataini + 1;
  //e qui si parrà l'ultima stilla di nobilitate! deve eliminare i giorni festivi dal mucchio!
  if (num_giorni_lav > 1)
  {
    for (TDate data = dataini; data <= datafine; ++data)
    {
      if (data.is_holiday())
        num_giorni_lav--;
    }
  }
  return num_giorni_lav;
}

long TRil_ore_mask::calcola_giorni_lavorativi_cms(const TDate& ini_cms, const TDate& fine_cms, 
                                                  const TDate& dataini, const TDate& datafine,
                                                  TDate& inizio_lav, TDate& fine_lav) const
{
  //date del mese
  const int anno = get_int(F_ANNO);
  const int mese = get_int(F_MESE);
  TDate ini_mese(1, mese, anno);
  TDate fine_mese = ini_mese;
  fine_mese.set_end_month();

  //se la commessa non "interseca" il mese selezionato -> finisce qui
  if (fine_cms < ini_mese || ini_cms > fine_mese)
    return 0;
  //se le date limite lavorative non "intersecano" il mese selezionato -> finisce qui
  if (datafine < ini_mese || dataini > fine_mese)
    return 0;

  //se è arrivato fin qui -> c'è qualcosa da considerare
  //vanno prese la massima data inizio e la minima data fine
  inizio_lav = fnc_max(ini_mese, ini_cms);
  fine_lav = fnc_min(fine_mese, fine_cms);

  //e qui si parrà l'ultima stilla di nobilitate! deve eliminare i giorni festivi dal mucchio!
  return calcola_giorni_lavorativi(inizio_lav, fine_lav);
}

void TRil_ore_mask::elabora_risorsa(const TString& curr_risorsa, TReport& rep) const
{
  //creare un assoc_array con chiave TToken_string cms-sede-fase(1) o sede-cms-fase(2) in base ai parametri..
  //..indicati sulla maschera
  const int tipo_ordinamento = get_int(F_ORDINAMENTO);
  const bool show_fasi = get_bool(F_SHOW_FASI);
  //il contenuto dell'assoc_array sarà: tot_Prev - 31 valori giornalieri Consuntivi - tot_Consuntivo
  TAssoc_array righe;

  const TVariant tiporisorsa = get(F_RISOATT);

  //query sul file delle ore in chiave 3: TIPO+TIPORA+CODICE+ANNO+MESE+...
  TString query;
  query << "USE RILORE KEY 5";
  query << "\nFROM TIPO=#TIPO TIPORA=#TPRA CODICE=#CODICE";
  query << "\nTO TIPO=#TIPO TIPORA=#TPRA CODICE=#CODICE";

  TISAM_recordset rilore_recset(query);
  rilore_recset.set_var("#TPRA", tiporisorsa);
  rilore_recset.set_var("#CODICE", curr_risorsa);

  //un giro con le ore a 'P'reventivo, uno con quelle a 'C'onsuntivo
  for (int i = 0; i < 2; i++)
  {
    const TVariant tipo = i == 0 ? "P" : "C";
    rilore_recset.set_var("#TIPO", tipo);

    const long rilore_recset_items = rilore_recset.items();

    TString msg;
    msg << "Scansione " << curr_risorsa << "..";

    for (bool ok = rilore_recset.move_first(); ok; ok = rilore_recset.move_next())
    {
      const TString& codcosto = rilore_recset.get(RILORE_CODCOSTO).as_string();
      const TString& codcms = rilore_recset.get(RILORE_CODCMS).as_string();
      const TString& codfase = rilore_recset.get(RILORE_CODFASE).as_string();
      //date limite commessa
      const TRectype& rec_cms = cache().get(LF_COMMESSE, codcms);
      TDate ini_cms, fine_cms;
      const int durata_cms = ca_durata_commessa(rec_cms, ini_cms, fine_cms);

      TDate dataini = rilore_recset.get(RILORE_DADATA).as_date();
      TDate datafine = rilore_recset.get(RILORE_ADATA).as_date();

      //adatta le date alla commessa se quest'ultima è contenuta nell'intervallo
      if (fine_cms < datafine)
        datafine = fine_cms;
      if (ini_cms > dataini)
        dataini = ini_cms;
      //se la commessa fosse tutta nel futuro o nel passato -> lascia perdere
      const long giorni_lavorativi = calcola_giorni_lavorativi(dataini, datafine);
      if (giorni_lavorativi <= 0)
        continue;

      //metodo semidivino per calcolare, dati l'anno ed il il mese selezionati, la commessa corrente, le date inizio e fine,..
      //..quanti sono i giorni di lavoro lavorativi per suddividere la quantità di ore
      TDate ini_lav, fine_lav;
      const long giorni_lavorativi_cms = calcola_giorni_lavorativi_cms(ini_cms, fine_cms, dataini, datafine, ini_lav, fine_lav);

      //adesso deve riproporzionare il monte ore sul record sul mese selezionato
      if (giorni_lavorativi_cms > 0)
      {
        const real tot_ore = rilore_recset.get(RILORE_QTAORE).as_real();
        const real tot_ore_uso_risorsa_nel_mese_per_cms = tot_ore * giorni_lavorativi_cms / giorni_lavorativi;

        //crea la chiave per l'assoc_array
        TToken_string key;
        switch(tipo_ordinamento)
        {
        case 1:
          key.add(codcms);
          key.add(codcosto);
          break;
        case 2:
          key.add(codcosto);
          key.add(codcms);
          break;
        }
        if (show_fasi)
          key.add(codfase);

        //se la chiave non esiste già nell'assoc_array allora crea l'elemento
        TToken_string* record = (TToken_string*)righe.objptr(key);
        if (record == NULL)
        {
          record = new TToken_string;
          righe.add(key, record);
        }

        if (i == 0) //'P'reventivo (aggiorna solo il totale)
        {
          real prev = record->get(0);
          prev += tot_ore_uso_risorsa_nel_mese_per_cms;
          record->add(prev, 0);
        }
        else  //'C'onsuntivo (aggiorna tutte le caselle dei giorni lavorativi)
        {
          const real ore_al_giorno = tot_ore / giorni_lavorativi;
          for (TData data = ini_lav; data <= fine_lav; ++data)
          {
            if (!data.is_holday())
            {
              real prev = record->get(data.day());
              prev += ore_al_giorno;
              record->add(prev, data.day());
            }
          }
        }

      } //if (giorni_lavorativi_cms > 0)..
    } //for (bool ok = rilore_recset.move_first();..

  }

  //finita l'elaborazione che ha riempito l'assoc_array, asegna il medesimo ad un..
  //..csv_recordset e poi sbatte quest'ultimo (ordinato) nel report
}

void TRil_ore_mask::elabora() const
{
  TReport_book book;

  //query sulla tabella interessata (risorse o attrezzature)
  TString16 da_ris_att, a_ris_att;
  TString query_ris_att;
  const char tiporisorsa = get(F_RISOATT)[0];

  if (tiporisorsa == 'R')
  {
    da_ris_att = get(F_DA_CODRIS);
    a_ris_att = get(F_A_CODRIS);
    query_ris_att << "USE RSS";
  }
  else
  {
    da_ris_att = get(F_DA_CODATT);
    a_ris_att = get(F_A_CODATT);
    query_ris_att << "USE ATR";
  }

  query_ris_att << "\nFROM CODTAB=#DACODICE";
  query_ris_att << "\nTO CODTAB=#ACODICE";
  
  TISAM_recordset recset_ris_att(query_ris_att);
  recset_ris_att.set_var("#DACODICE", da_ris_att);
  recset_ris_att.set_var("#ACODICE", a_ris_att);
  const long recset_ris_att_items = recset_ris_att.items();

  TProgind pi(recset_ris_att_items, TR("Scansione risorse/attrezzature.."), true, true);

  //per ogni risorsa/attrezzatura dell'elenco genera un report singolo che viene riempito nella elabora_risorsa e..
  //..aggiunto al book per la stampa finale
  for (bool ok = recset_ris_att.move_first(); ok; ok = recset_ris_att.move_next())
  {
    if (!pi.addstatus(1))
      break;

    const TString& curr_risorsa = recset_ris_att.cursor()->curr().get("CODTAB");

    TReport rep;
    rep.load("ca1300a");

    elabora_risorsa(curr_risorsa, rep);

    book.add(rep);
  }
}

///////////////////////////////////////////////////////////
// Recordset
///////////////////////////////////////////////////////////

class TRil_ore_recordset : public TCSV_recordset
{
protected:

public:
  TRil_ore_recordset(const TMask& mask);
	
	//virtual const TVariant& get(const char* column_name) const;
	//virtual const TVariant& get(unsigned int column) const { return TCSV_recordset::get(column); }
};

TRil_ore_recordset::TRil_ore_recordset(const TMask& mask) 
: TCSV_recordset("CSV(\"\t\")")   //tab separated
{
  FOR_EACH_MASK_FIELD(mask, i, field)
	{
		const TFieldref* f = field->field();
		if (f != NULL)
		{
			const TString& name = f->name();
			set_var(name, field->get(), true);
		}
	}
}

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

class TRil_ore_report : public TReport
{
protected:
virtual bool use_mask() { return false; }
public:
  TRil_ore_report() {}
};

///////////////////////////////////////////////////////////
// Applicazione
///////////////////////////////////////////////////////////

class TRil_ore : public TSkeleton_application
{
protected:

public:
  virtual bool create();
  virtual void main_loop();
};


void TRil_ore::main_loop()
{
  TRil_ore_mask mask;
  
  while (mask.run() == K_ENTER)
  {
    mask.elabora();
  }
}

bool TRil_ore::create()
{
	return TSkeleton_application::create();
}

int ci1300(int argc, char* argv[])
{
  TRil_ore sd;
  sd.run(argc, argv, "Rilevazione ore");
  return 0;
}