#include <colors.h>
#include <diction.h>
#include <image.h>

#include "cilib.h"
#include "cimsk.h"

///////////////////////////////////////////////////////////
// TAlmanac_window
///////////////////////////////////////////////////////////

// @doc EXTERNAL

// @class TAlmanac_window | Finestra associata ad un TAlmanac_field
//
// @base public | TField_window
class TAlmanac_window : public TField_window
{
  // @author:(INTERNAL) Brugno

  // @access Protected Member
protected:
  // override da TField_window
  virtual void update();
  // override da TField_window
  virtual long handler(WINDOW win, EVENT* ep);

  // @access Public Member
public:
  // override da TField_window
  virtual bool on_key(KEY k);

  // @access Public Member
public:
  // @cmember Costruttore
  TAlmanac_window(int x, int y, int dx, int dy, WINDOW parent, TWindowed_field *owner);
  // @cmember Distruttore
  virtual ~TAlmanac_window() {}
};

void TAlmanac_window::update()
{
  COLOR col_f, col_b;
  RCT rct; xvt_vobj_get_client_rect(win(), &rct);
  RCT rcttd;
  TString str;
	TAlmanac_field& o = (TAlmanac_field&)owner();

  TField_window::update();
  TDate cdate = o.selected_date();
  cdate.set_day(1);

  int cpage = o.mask().curr_page();

  int rct_l, rct_t;
  int rct_w = (rct.right - rct.left) / 9;
  int rct_h = (rct.bottom - rct.top) / 9;
  int pad = o.padding();
  int row = 3;

  set_font("", XVT_FS_BOLD);
  set_color(NORMAL_COLOR, NORMAL_BACK_COLOR);
  int fh = CHARY;

  if (o.show_month_name())
  {
    str.format("%s %d", itom(cdate.month()),cdate.year());
    rct_l = rct.left + rct_w;
    rct_t = rct.top + rct_h;
    xvt_dwin_draw_text(win(), rct_l + pad + 2, fh + rct_t + pad + 2, str, -1);
  }

  for (int i=1;i<=7;i++)
  {
    str.format("%.3s", itow(i));
    rct_l = rct.left + rct_w*i;
    rct_t = rct.top + rct_h*2;
    xvt_dwin_draw_text(win(), rct_l + pad + 2, fh + rct_t + pad + 2, str, -1);
  }

  --cdate;

  do
  {
    if ((++cdate).wday()==1 && cdate.day() > 1) row++;

		col_b = NORMAL_BACK_COLOR;
    col_f=NORMAL_COLOR;

		if (o.is_date_void(cpage, cdate))
		{
			if (!o.can_insert(cdate))
				col_b = DISABLED_BACK_COLOR;
		}
    else
      col_b = FOCUS_BACK_COLOR;

    set_pen(col_f);
    set_brush(col_b);

    rct_l = rct.left + rct_w*cdate.wday();
    rct_t = rct.top + rct_h*row;
    
    str.format("%2d", cdate.day());

    rcttd.top = rct_t + pad;
    rcttd.left = rct_l + pad;
    rcttd.bottom = rct_t + rct_h - pad;
    rcttd.right = rct_l + rct_w - pad;

    xvt_dwin_draw_rect(win(), &rcttd);
		if (cdate.is_holiday())
		{
			set_brush(o.can_insert(cdate) ? DISABLED_BACK_COLOR : NORMAL_COLOR, PAT_FDIAG);
	    xvt_dwin_draw_rect(win(), &rcttd);
		}

    if (o.is_selected(cdate.day()))
    {
      set_pen(FOCUS_COLOR,1);
      rcttd.top++; rcttd.left++; rcttd.bottom--; rcttd.right--;
      xvt_dwin_draw_rect(win(), &rcttd);
    }

    xvt_dwin_draw_text(win(), rct_l + pad + 2, fh + rct_t + pad, str, -1);
  }
  while (!cdate.is_end_month());
}

bool TAlmanac_window::on_key(KEY key)
{
	TAlmanac_field& o = (TAlmanac_field&)owner();
  TAlmanac_mask& m = (TAlmanac_mask&)o.mask();

  const int smonth = o.selected_month();
  const int syear = o.selected_year();

  switch (key)
	{
	case K_RIGHT:	o.move_selected_day(1); break;
	case K_LEFT:  o.move_selected_day(-1); break;
	case K_UP:		o.move_selected_day(-7); break;
	case K_DOWN:	o.move_selected_day(+7); break;
  case K_SPACE:
	case K_ENTER:	m.open_day_mask(); break;
	case K_PREV:
	case K_NEXT:
	case K_CTRL+K_F1:
	case K_CTRL+K_F2:
	case K_CTRL+K_F3:
	case K_CTRL+K_F4:
	case K_CTRL+K_F5:
	case K_CTRL+K_F6:
	case K_CTRL+K_F7:
	case K_CTRL+K_F8:
	case K_CTRL+K_F9:
	case K_CTRL+K_F10:
	case K_CTRL+K_F11:
	case K_CTRL+K_F12:
		m.on_key(key);
    break;
	default:
		return TField_window::on_key(key);
  }
  
  if(syear != o.selected_year())
  {
    m.set_year(o.selected_year());
  }
	return true;
}

long TAlmanac_window::handler(WINDOW win, EVENT* ep)
{
  switch(ep->type)
  {
  case E_MOUSE_DOWN:
  case E_MOUSE_DBL:
    {
	    TAlmanac_field & o = (TAlmanac_field&)owner();
      TDate cdate = o.selected_date();
      TDate fdate = cdate; fdate.set_day(1);

      RCT rct; xvt_vobj_get_client_rect(win, &rct);
      int rct_w = ((rct.right - rct.left) / 9);
      int rct_h = ((rct.bottom - rct.top) / 9);
      int pnt_c = (ep->v.mouse.where.h) / rct_w;
      int pnt_r = (ep->v.mouse.where.v) / rct_h;
      int delta = 7*pnt_r + pnt_c - (7*(3+cdate.week()-fdate.week()) + cdate.wday());
      o.move_selected_day(delta);
      if (ep->type==E_MOUSE_DBL)
			  ((TAlmanac_mask&)o.mask()).open_day_mask();
    }
    break;
  default:
    break;
  }
  return TField_window::handler(win, ep);
}

TAlmanac_window::TAlmanac_window(int x, int y, int dx, int dy, WINDOW parent, TWindowed_field *owner)
               : TField_window(x, y, dx, dy, parent, owner)
{
	set_scroll_max(0, 0);  // Get rid of that useless scrollbars
}

///////////////////////////////////////////////////////////
// TImage_window
///////////////////////////////////////////////////////////

// @doc EXTERNAL

// @class TAlmanac_window | Finestra associata ad un TAlmanac_field
//
// @base public | TField_window
class TImage_window : public TField_window
{
  // @author:(INTERNAL) Brugno
	int _curr_month;

  // @access Protected Member
protected:
  // override da TField_window
  virtual void update();

  // @access Public Member
public:
  // @cmember Costruttore
  TImage_window(int x, int y, int dx, int dy, WINDOW parent, TWindowed_field *owner);
 // @cmember Distruttore
  virtual ~TImage_window() {}
};

void TImage_window::update()
{
  RCT rct; xvt_vobj_get_client_rect(win(), &rct);
	TAlmanac_field & f = (TAlmanac_field&) owner();
	const int month = f.selected_date().month();

  _curr_month = month;
	clear(MASK_BACK_COLOR);

	TFilename month_img; month_img.format("%2smn%02d.jpg", (const char *) f.mask().source_file().left(2), _curr_month);

	if (month_img.custom_path())
  {                     
		TImage bmp(month_img);
		const double ratiox = (double) (rct.right) / (double) bmp.width();
		const double ratioy = (double) (rct.bottom) / (double) bmp.height();
			
		if (ratiox < ratioy)
		{
			int h = int(bmp.height() * ratiox);

			rct.top = (rct.bottom - h) / 2;
			rct.bottom = rct.top + h;
		}
		else
		{
			int w = int(bmp.width() * ratioy);
			rct.left = (rct.right - w) / 2;
			rct.right = rct.left + w;
		}

		bmp.draw(win(), rct);
  }
}

TImage_window::TImage_window(int x, int y, int dx, int dy, WINDOW parent, TWindowed_field *owner)
             : TField_window(x, y, dx, dy, parent, owner), _curr_month(0)
{
	set_scroll_max(0, 0);  // Get rid of that useless scrollbars
}

///////////////////////////////////////////////////////////
// TAlmanac_field
///////////////////////////////////////////////////////////

TField_window* TAlmanac_field::create_window(int x, int y, int dx, int dy, WINDOW parent)
{
  TAlmanac_window* obj = new TAlmanac_window(x, y, dx, dy, parent, this);
  RCT rct; xvt_vobj_get_outer_rect(obj->win(), &rct);
	const int pad = 6;

	if (rct.left > pad * 4)
	{
		_image = new TImage_window(-1, y, -1, dy, parent, this);
		RCT img_rect; xvt_vobj_get_outer_rect(_image->win(), &img_rect);
		img_rect.right = rct.left - pad;
		img_rect.left = pad;
    xvt_vobj_move(_image->win(), &img_rect);
	}

  return obj;
}

void TAlmanac_field::create(short id, const RCT& rect, WINDOW parent)
{
  int x = rect.left/CHARX, y = rect.top/ROWY;
  int h = (rect.bottom - rect.top)/ROWY, w = (rect.right - rect.left)/CHARX;
  if (x+w > 80)
    x = x + w - mask().columns() - 1;
  TWindowed_field::create(id, x, y, w, h, parent);
}

bool TAlmanac_field::is_date_void(int currpage, const TDate& cdate)
{
	return ((TAlmanac_mask &)mask()).is_date_void(currpage, cdate);
}

void TAlmanac_field::force_update(bool update_image)
{
	win().force_update();
	if (update_image && _image != NULL)
		_image->force_update();
}

void TAlmanac_field::adjust_selected_day()
{
  const int last = TDate::last_day(_selecteddate.month(), _selecteddate.year());
  if (_selecteddate.day() > last)
    _selecteddate.set_day(last);
}

void TAlmanac_field::set_selected_day(int nday)
{ 
  if (nday>=1 && nday<=31 && nday != _selecteddate.day())
	{
    _selecteddate.set_day(nday);
    adjust_selected_day();
		force_update(false); // Dont'update the picture
	}
}

void TAlmanac_field::move_selected_day(int ddays)
{ 
	const int old_month = _selecteddate.month();
  _selecteddate += ddays;
  force_update(old_month != _selecteddate.month()); // Dont'update the picture if needed
}

void TAlmanac_field::set_selected_month(int nmonth)
{ 
  if (nmonth >= 1 && nmonth <= 12 && nmonth != _selecteddate.month())
	{
    _selecteddate.set_month(nmonth);
    adjust_selected_day();
		force_update(true); // Update the picture too
	}
}

void TAlmanac_field::move_selected_month(int dmonths)
{ 
	_selecteddate.addmonth(dmonths);
  force_update(true); // Update the picture too
}

void TAlmanac_field::set_selected_year(int nyear)
{ 
  _selecteddate.set_year(nyear);
  adjust_selected_day();
  force_update(false); // Don't update the picture
}

///////////////////////////////////////////////////////////
// TAlmanac_mask
///////////////////////////////////////////////////////////

TMask_field* TAlmanac_mask::parse_field(TScanner& scanner)
{
  const TString& k = scanner.key();
  if (k.starts_with("AL", true))
  {
    TAlmanac_field* na = new TAlmanac_field(this);
    _almanacs.add(na);
    return na;
  }
  return TAutomask::parse_field(scanner);
}

bool TAlmanac_mask::on_field_event(TOperable_field& o, TField_event e, long jolly)
{
	switch (o.dlg())
	{
	case F_PREVMONTH:
	case F_NEXTMONTH:
		if (e == fe_button)
		{
			TAlmanac_field& al = almanac();
      const int old_year = al.selected_year();
      al.move_selected_month(o.dlg() == F_PREVMONTH ? -1 : +1);
      const int new_year = al.selected_year();
      if (old_year != new_year) // Se cambio anno
			  set_year(new_year);
		}
		break;
  case F_PREVYEAR:
	case F_NEXTYEAR:
		if (e == fe_button)
    {
			TAlmanac_field& al = almanac();
			const int year = al.selected_year();
			set_year(year + (o.dlg() == F_PREVYEAR ? -1 : +1));
    }
		break;    
	default:
		break;
	}     

  return true;
}  

void TAlmanac_mask::set_focus()
{
  TAutomask::set_focus();

  int i;
  for (i = _almanacs.last(); i >= 0; i = _almanacs.pred(i))
  {
    if (almanac(i).parent() == curr_win())
      break;
  }
  
  const bool nav = i >= 0;
  enable(F_PREVYEAR,  nav);
  enable(F_PREVMONTH, nav);
  enable(F_NEXTMONTH, nav);
  enable(F_NEXTYEAR,  nav);
}

int TAlmanac_mask::activate_almanac(const short id, const char* title)
{
  int i = -1; // Calendario non trovato

  const int pos = id2pos(id);
  if (pos >= 0) // Calendario esistente
  {
    for (i = _almanacs.last(); i >= 0; i = _almanacs.pred(i))
      if (almanac(i).dlg() == id)
        break;
    if (i < 0)                     // Calendario non ancora censito ...
      i = _almanacs.add(fld(pos)); // ... non dovrebbe mai succedere
  }

  if (i < 0) // Devo creare al volo un calendario 
  {
    WINDOW parent = create_page(TR("Calendario"), -1);
    const TAlmanac_field& ca = almanac(0);
    RCT rect; ca.get_rect(rect);
    TAlmanac_field* na = new TAlmanac_field(this);
    na->create(id, rect, parent);
    add_field(na);
    i = _almanacs.add(na);
  }
  
  TAlmanac_field& na = almanac(i);
  if (title && *title)
  {
    const int page = find_parent_page(na);
    xvt_notebk_set_tab_title(notebook(), page, title);
  }
  const TDate sdate(TODAY); // Inizilizzo con la data odierna
  na.set_selected_date(sdate);

  return i;
}

TAlmanac_field & TAlmanac_mask::almanac(byte page) const
{ 
	if (page >= _almanacs.items()) // Calcolo dell'indice del calendario corrente
  {
    for (page = _almanacs.last(); page > 0; page = _almanacs.pred(page))
    {
      if (almanac(page).parent() == curr_win())
        break;
    }
  }
	return (TAlmanac_field&)_almanacs[page];
} 

void TAlmanac_mask::set_year(int newyear) 
{ 
  for (int i = _almanacs.last(); i >= 0; i = _almanacs.pred(i)) 
    almanac(i).set_selected_year(newyear); 
  change_year(newyear);
}

const TDate& TAlmanac_mask::selected_day() const 
{ return almanac().selected_date(); }

void TAlmanac_mask::change_year(int newyear) 
{ 
  // Funzione virtuale da ridefinire!
}

bool TAlmanac_mask::is_date_void(int currpage, const TDate& cdate) 
{ 
  return true;
}

TAlmanac_mask::TAlmanac_mask(const char* name)
{
	read_mask(name, 0, -1); // Deve funzionare la virtual parse_field 
	set_handlers();
}

                                ////////////////////////////
                                ////    TRISOATT_KEY    ////
                                ////////////////////////////

//TIPO: metodo che restituisce il tipo (<R>isorsa o <A>ttrezzatura)
const char TRisoatt_key::tipo() const
{
  return left(1)[0];
}

//COD: metodo che restituisce il codice della risorsa op dell'attrezzatura
const TString& TRisoatt_key::cod() const
{
  return mid(1, 16);
}

//ANNO: metodo che restituisce l'anno a cui fa riferimento la risorsa o l'attrezzatura
const int TRisoatt_key::anno() const
{
  return atoi(mid(17, 4));
}

//MESE: metodo che restituisce il mese a cui fa riferimento la risorsa o l'attrezzatura
const TString& TRisoatt_key::mese() const
{
  return mid(21, 2);
}

//TPORA: metodo che restituisce il tipo dell'ora a cui fa riferimento la risorsa o l'attrezzatura
const TString& TRisoatt_key::tpora() const
{
  return right(2);
}

TRisoatt_key::TRisoatt_key(const char* roakey)
{
  set(roakey);
}

                                ////////////////////////
                                ////    TRISOATT    ////
                                ////////////////////////

//CHIAVE: metodo che restituisce la chiave della tabella di modulo
const TString& TRisoatt::chiave() const
{
  return get("CODTAB");
}

//DESCR: metodo che restituisce la descrizione contenuta nella tabella di modulo
const TString& TRisoatt::descr() const
{
  return get("S0");
}

//VALUNI: metodo che restituisce il valore unitario contenuto nella tabella di modulo
const real TRisoatt::valuni() const
{
  return get_real("R1");
}

//costruttore
TRisoatt::TRisoatt(const TRectype& r)
        : TRectype(r)
{
  CHECK(r.num() == LF_TABMOD, "Tipo record errato");
}

                                /////////////////////////////
                                ////    TDISP_RISOATT    ////
                                /////////////////////////////

//CHIAVE: metodo che restituisce la chiave della tabella di modulo
const TString& TDisp_risoatt::chiave() const
{
  return get("CODTAB");
}

//DESCR: metodo che restituisce la descrizione contenuta nella tabella di modulo
const TString& TDisp_risoatt::descr() const
{
  return get("S0");
}

//VALUNI: metodo che restituisce il valore unitario contenuto nella tabella di modulo
const int TDisp_risoatt::ore_prev() const
{
  return get_int("I0");
}

//VALUNI: metodo che restituisce il valore unitario contenuto nella tabella di modulo
const int TDisp_risoatt::ore_cons() const
{
  return get_int("I1");
}

//costruttore
TDisp_risoatt::TDisp_risoatt(const TRectype& r)
        : TRectype(r)
{
  CHECK(r.num() == LF_TABMOD, "Tipo record errato");
}