#include "mr0.h"
#include "mrplib.h"
#include "mrtblnp.h"

#include <tabapp.h>

class TMRPtables : public TTable_application
{
  void read_turni(TMask& m);
  void write_turni(const TMask& m);

protected:
  virtual TString& get_mask_name(TString& name) const;
  virtual TMask* set_mask(TMask* m);

  virtual int read(TMask& m);
  virtual int write(const TMask& m);
  virtual int rewrite(const TMask& m);
  virtual bool remove();
  
  virtual void ini2mask(TConfig& ini, TMask& m, bool query);
  virtual void mask2ini(const TMask& m, TConfig& ini);

public:
  char impianto_o_linea() const;
  void save_calendar(const TMask& m);
  void remove_calendar(const TMask& m);
};

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

///////////////////////////////////////////////////////////
// TMRP_mask
///////////////////////////////////////////////////////////

class TMRP_mask : public TCalendar_mask
{
protected:
  virtual bool on_field_event(TOperable_field& o, TField_event e, long jolly);
  char impianto_o_linea() const { return app().impianto_o_linea(); }

public:
  bool init_calendar();
  bool save_calendar() const;
  bool remove_calendar();
    
  TMRP_mask(const char* name, int num = 0);
  virtual ~TMRP_mask();
};

bool TMRP_mask::init_calendar()
{
  bool changed = FALSE;
  TString8 lin, imp;
  if (impianto_o_linea() == 'L')
  {
    switch (get(F_TYPE)[0])
    {
    case 'L': lin = get(F_CODICE); imp = get(F_IMPIANTO); break;
    case 'I': imp = get(F_IMPIANTO); break;
    default : break;
    }
  }
  else // "IMP"
  {
    if (get(F_TYPE) == "I")
      imp = get(F_CODICE);
  }

  TCalendar_field& cf = (TCalendar_field&)field(F_CALENDAR);

  if (calendar().linea() != lin || calendar().impianto() != imp)
  {
    if (cf.dirty())
    {
      TString str(80);
      str = TR("Il calendario ");
      switch (calendar().tipo())
      {
      case 'L': str << TR("della linea ") << calendar().linea(); break;
      case 'I': str << TR("del impianto ") << calendar().impianto(); break;
      default : str << TR("standard"); break;
      }
      str << TR(" e' stato modificato:\nsi desidera salvare le modifiche effettuate?");
      if (yesno_box(str))
        calendar().rewrite();
    }
      
    calendar().set(lin, imp);
    cf.set_dirty(FALSE);
    changed = TRUE;
  }
  cf.set_calendar(&calendar(), get_int(F_YEAR));
  return changed;
}

bool TMRP_mask::on_field_event(TOperable_field& o, TField_event e, long jolly)
{
  const char t = impianto_o_linea();
  if (t == 'I' || t == 'L')
  {
    switch (o.dlg())
    {
    case F_IMPIANTO:
      break;
    case F_CODICE:
    case F_TYPE:
      if (e == fe_modify)
        init_calendar();
      break;
    case F_YEAR:
      if (e == fe_init || e == fe_modify)
      {
        if (t == 'I')
          update_calendar(F_CALENDAR, F_YEAR, F_CODICE);
        else
          update_calendar(F_CALENDAR, F_YEAR, F_IMPIANTO, F_CODICE);
      }
      break;
    default: 
      break;
    }
  }
  return TRUE;
}

bool TMRP_mask::save_calendar() const
{
  const TCalendar_field& cf = (const TCalendar_field&)field(F_CALENDAR);
  if (cf.dirty())
    calendar().rewrite();
  return TRUE;
}

bool TMRP_mask::remove_calendar()
{
  const char tipo = impianto_o_linea();
  if (calendar().tipo() == tipo)
    calendar().remove();
  return TRUE;
}

TMRP_mask::TMRP_mask(const char* name, int num)
         : TCalendar_mask(name, num)
{
  if (impianto_o_linea() == 'L')
  {
    TConfig ini(CONFIG_DITTA, "mr");
    const bool gestione_impianti = ini.get_bool("GESTIMPIANTI");
    if (!gestione_impianti)
    {
      disable(F_IMPIANTO);
      disable(F_DESCIMPIANTO);
    }
  }
}

TMRP_mask::~TMRP_mask()
{
}

///////////////////////////////////////////////////////////
// TMRPtables
///////////////////////////////////////////////////////////

char TMRPtables::impianto_o_linea() const
{
  const TString& tn = get_tabname();
  if (tn == "IMP" || tn == "LNP")
    return tn[0];
  return '\0';
}

TString& TMRPtables::get_mask_name(TString& name) const
{
  name = get_tabname();
  name.insert("mrtb", 0);
  return name;
}

TMask* TMRPtables::set_mask(TMask* m)
{
  if (m == NULL)
  {
    TString name; 
    get_mask_name(name);
    if (impianto_o_linea())
      m = new TMRP_mask(name);
    else
      m = new TMask(name);
  }
  return TTable_application::set_mask(m);
}

void TMRPtables::save_calendar(const TMask& m)
{
  if (impianto_o_linea())
  {
    const TMRP_mask& cm = (const TMRP_mask&)m;
    cm.save_calendar();
  }
}

void TMRPtables::remove_calendar(const TMask& m)
{
  if (impianto_o_linea())
  {
    TMRP_mask& cm = (TMRP_mask&)m;
    cm.remove_calendar();
  }
}

void TMRPtables::read_turni(TMask& m)
{
  TUnita_produttiva up(file().curr());
  for (int t = 7; t >= 0; t--)
  {
    const short id = F_T1HINIZIO+t*5;
    m.set(id,up.ora_inizio_turno(t));
    m.set(id+1,up.min_inizio_turno(t));
    m.set(id+2,up.ore_durata_turno(t));
    m.set(id+3,up.min_durata_turno(t));
    m.set(id+4,up.raw_numpers_turno(t));;
  }
}

void TMRPtables::write_turni(const TMask& m)
{
  TUnita_produttiva up(file().curr());
  for (int t=0; t < 8; t++)
  {
    const short id = F_T1HINIZIO+t*5;
    up.set_inizio_turno(t, m.get_int(id), m.get_int(id+1));
    up.set_durata_turno(t, m.get_int(id+2), m.get_int(id+3));
    up.set_numpers_turno(t, m.get_int(id+4));
  }
  file().curr() = up;
}

int TMRPtables::read(TMask& m)
{
  const int err = TTable_application::read(m);
  if (err == NOERR)
  {
    if (impianto_o_linea())
      read_turni(m);
  }
  return err;
}

int TMRPtables::write(const TMask& m)
{
  if (impianto_o_linea())
    write_turni(m);
  
  const int err = TTable_application::write(m);
  if (err == NOERR)
    save_calendar(m);
  
  return err;
}

int TMRPtables::rewrite(const TMask& m)
{
  if (impianto_o_linea())
    write_turni(m);

  const int err = TTable_application::rewrite(m);
  if (err == NOERR)
    save_calendar(m);
  
  return err;
}

bool TMRPtables::remove()
{
  const bool ok = TTable_application::remove();
  if (ok)
    remove_calendar(curr_mask());
  return ok;
}

void TMRPtables::ini2mask(TConfig& ini, TMask& m, bool query)
{
  TTable_application::ini2mask(ini, m, query);

  if (impianto_o_linea())
  {
    TAssoc_array& vars = ini.list_variables("5");
    TRectype& curr = file().curr();
    FOR_EACH_ASSOC_STRING(vars, obj, key, str)
      curr.put(key, str);
    read_turni(m);
  }
}

void TMRPtables::mask2ini(const TMask& m, TConfig& ini)
{
  TTable_application::mask2ini(m, ini);

  if (impianto_o_linea())
  {
    write_turni(m);
    const TRectype& curr = file().curr();
    ini.set_paragraph("5");
    for (int i = curr.items()-1; i >= 0; i--)
    {
      const char* fname = curr.fieldname(i);
      const TString& val = curr.get(fname);
      if (val.full() && ini.get(fname).blank())
        ini.set(fname, val);
    }
  }
}

///////////////////////////////////////////////////////////
// Main
///////////////////////////////////////////////////////////

int mr0100(int argc, char* argv[])
{
  if (argc > 2)
  {
    TString80 name;
    name << TR("Tabella") << ' ' << argv[2];
    TMRPtables a;
    a.run(argc, argv, name);
  }
  return 0;
}