// src/schedulables_tree_widget.cc - Copyright 2005, 2006, University
//               of Padova, dept. of Pure and Applied
//               Mathematics
//
// This file is part of SGPEMv2.
//
// This is free software; you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation; either version 2 of the License, or
// (at your option) any later version.
//
// SGPEMv2 is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with SGPEMv2; if not, write to the Free Software
// Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA

#include "schedulables_tree_widget.hh"
#include "templates/sequences.tcc"
#include "backend/history.hh"
#include "backend/simulation.hh"
#include "backend/process.hh"
#include "backend/thread.hh"
#include "backend/resource.hh"
#include "add_request_dialog.hh"

#include <cassert>
#include <iostream>
#include <sstream>

#include <glibmm/markup.h>

#include <gtk/gtk.h>
#include <gtkmm/entry.h>
#include <gtkmm/spinbutton.h>


using namespace sgpem;
using namespace Gtk;
using namespace Glib;
using Gnome::Glade::Xml;

PropertyProxy_Base
SchedulablesTreeWidget::CellRendererTextMarkup::_property_renderable()
{
  return Glib::PropertyProxy_Base(this, "markup");
}

SchedulablesTreeWidget::SchedulablesTreeWidget() :
  _add_process_dialog_glade(Xml::create(GLADEDIR "/add-process-dialog.glade")),
  _add_thread_dialog_glade(Xml::create(GLADEDIR "/add-thread-dialog.glade")),
  _add_request_dialog_glade(Xml::create(GLADEDIR "/add-request-dialog.glade"))

{
  _columns.add(_main_column);
  _columns.add(_types_column);
  _columns.add(_handles_column);
  _model = TreeStore::create(_columns);
  
  set_model(_model);

  //append_column("schedulables", _main_column);
  //invisible
  //  append_column("handles", _types_column);
  //  append_column("handles", _handles_column);
  int idx = append_column("schedulables", _cell_renderer) - 1;
  Gtk::TreeViewColumn* tvc = get_column(idx);
  tvc->set_cell_data_func(_cell_renderer, sigc::mem_fun(*this, &SchedulablesTreeWidget::_on_cell_name_data));
  
/** DIALOGS **/
  _add_process_dialog_glade->get_widget("AddProcessDialog", _add_process_dialog);
  _add_thread_dialog_glade->get_widget("AddThreadDialog", _add_thread_dialog);
  // NOTE This is *not* reflective programming! AddRequestDialog is the name of
  // the base widget in the glade file.
  _add_request_dialog_glade->get_widget_derived("AddRequestDialog", _add_request_dialog);
  
  set_headers_visible(false);

  Simulation::get_instance().get_history().attach(*this);
}

SchedulablesTreeWidget::~SchedulablesTreeWidget()
{
  Simulation::get_instance().get_history().detach(*this);
}

template <typename T>
bool 
SchedulablesTreeWidget::check_type(SchedulablesTreeWidget::HandleType type)
{
  return false;
}

namespace sgpem
{
  template <>
  bool 
  SchedulablesTreeWidget::check_type<Process>(HandleType type)
  {
    return type == htype_process;
  }

  template <>
  bool 
  SchedulablesTreeWidget::check_type<Thread>(HandleType type)
  {
    return type == htype_thread;
  }

  template <>
  bool 
  SchedulablesTreeWidget::check_type<Request>(HandleType type)
  {
    return type == htype_request;
  }

  template <>
  bool 
  SchedulablesTreeWidget::check_type<SubRequest>(HandleType type)
  {
    return type == htype_subrequest;
  }
}

template <typename T>
T*
SchedulablesTreeWidget::get_selected()
{
  TreeModel::iterator sel = get_selection()->get_selected();
  
  return get_row_handle_as<T>(sel);
}

template <typename T>
T*
SchedulablesTreeWidget::get_row_handle_as(const Gtk::TreeModel::iterator& row)
{
  if(!row)
    return NULL;
  
  const void* p_handle = (*row)[_handles_column];
  HandleType type = (*row)[_types_column];

  if(!check_type<T>(type))
    return NULL;

  return reinterpret_cast<T*>(const_cast<void*>(p_handle));
}

SchedulablesTreeWidget::HandleType
SchedulablesTreeWidget::get_selection_type()
{
  TreeModel::iterator sel = get_selection()->get_selected();

  return get_row_type(sel);
}

SchedulablesTreeWidget::HandleType
SchedulablesTreeWidget::get_row_type(const TreeModel::iterator& row)
{
  if(!row)
    return htype_undefined;
  else
    return (*row)[_types_column];
}


bool 
SchedulablesTreeWidget::on_button_press_event(GdkEventButton* event)
{
  TreeView::on_button_press_event(event);
  
  if( (event->type == GDK_BUTTON_PRESS) && (event->button == 3) )
  {
    RefPtr<ActionGroup> action_group = Gtk::ActionGroup::create();

    action_group->add( Gtk::Action::create("AddProcess", "Add Process"),
	sigc::mem_fun(*this, &SchedulablesTreeWidget::_on_add_process) );
    
    action_group->add( Gtk::Action::create("AddThread", "Add Thread"),
	sigc::mem_fun(*this, &SchedulablesTreeWidget::_on_add_thread) );
    
    action_group->add( Gtk::Action::create("AddRequest", "Add Request"),
	sigc::mem_fun(*this, &SchedulablesTreeWidget::_on_add_request) );
    
    action_group->add( Gtk::Action::create("RemoveProcess", "Remove Process"),
	sigc::mem_fun(*this, &SchedulablesTreeWidget::_on_remove_process) );
    
    action_group->add( Gtk::Action::create("RemoveThread", "Remove Thread"),
	sigc::mem_fun(*this, &SchedulablesTreeWidget::_on_remove_thread) );
    
    action_group->add( Gtk::Action::create("RemoveRequest", "Remove Request"),
	sigc::mem_fun(*this, &SchedulablesTreeWidget::_on_remove_request) );

    action_group->add( Gtk::Action::create("RemoveSubrequest", "Remove Subrequest"),
	sigc::mem_fun(*this, &SchedulablesTreeWidget::_on_remove_subrequest) );

    RefPtr<UIManager> UIManager = Gtk::UIManager::create();
    UIManager->insert_action_group(action_group);

    const HandleType selection_type = get_selection_type();
    
    Glib::ustring ui_info = 
	  "<ui>"
	  "  <popup name='PopupMenu'>";

    if(selection_type == htype_process)
      ui_info +=    
          "    <menuitem action='AddThread'/>";
    else if(selection_type == htype_thread)
      ui_info +=      
	  "    <menuitem action='AddRequest'/>";
    
    ui_info +=
	  "    <menuitem action='AddProcess'/>";
    
    if(selection_type != htype_undefined)
      ui_info +=
	  "    <separator/>";
    
    switch(selection_type)
    {
    case htype_process:
      ui_info += 
	  "    <menuitem action='RemoveProcess'/>";
      break;
    case htype_thread:
      ui_info += 
	  "    <menuitem action='RemoveThread'/>";
      break;
    case htype_request:
      ui_info += 
	  "    <menuitem action='RemoveRequest'/>";
      break;
    case htype_subrequest:
      ui_info += 
	  "    <menuitem action='RemoveSubrequest'/>";
    }
    
    ui_info +=
          "  </popup>"
	  "</ui>";

    UIManager->add_ui_from_string(ui_info);
    Gtk::Menu* menu = dynamic_cast<Gtk::Menu*>(UIManager->get_widget("/PopupMenu"));

    menu->popup(event->button, event->time);
    return true; //It has been handled.
  }
  else
    return false;
}

void
SchedulablesTreeWidget::update(const History& history)
{
  using std::vector;
  
  typedef Environment::Processes::const_iterator ProcessIt;
  
  const Environment::Processes& processes = 
    Simulation::get_instance().get_history().get_last_environment().get_processes();

  _model->clear();
  
  for(Iseq<ProcessIt> pit = const_iseq(processes); pit; ++pit)
  {
    Process& p = *(*pit);

    TreeModel::Row prow = *(_model->append());
    
    prow[_main_column] = p.get_name();
    prow[_types_column] = htype_process;
    prow[_handles_column] = &p;

    vector<Thread*> threads = p.get_threads();
    
    for(Iseq<vector<Thread*>::iterator> tit = iseq(threads); tit; ++tit)
    {
      Thread& t = *(*tit);

      TreeModel::Row trow = *(_model->append(prow.children()));

      trow[_main_column] = t.get_name();
      trow[_types_column] = htype_thread;
      trow[_handles_column] = &t;

      vector<Request*> requests = t.get_requests();

      for(unsigned int ri = 0; ri < requests.size(); ++ri)
      {
	Request& r = *requests[ri];

	TreeModel::Row rrow = *(_model->append(trow.children()));
	
	std::ostringstream oss;
	oss << "request " << ri + 1;
	
	rrow[_main_column] = oss.str();
	rrow[_types_column] = htype_request;
        rrow[_handles_column] = &r;

	vector<SubRequest*> subrequests = r.get_subrequests();

	for(Iseq<vector<SubRequest*>::iterator> srit = iseq(subrequests); srit; ++srit)
	{
	  SubRequest& sr = *(*srit);

	  TreeModel::Row srrow = *(_model->append(rrow.children()));

	  // we are sure the key is valid, or no?
	  const Environment& env = history.get_last_environment();
	  Resource& res = *(env.get_resources().find(sr.get_resource_key())->second);

	  srrow[_main_column] = res.get_name();
	  srrow[_types_column] = htype_subrequest;
	  srrow[_handles_column] = &sr;
	}
      }
    }
  }
}

void
SchedulablesTreeWidget::_on_add_process()
{
  if(_add_process_dialog->run() == RESPONSE_OK)
  {
    Entry* name_entry;
    SpinButton* arrival_time_spin;
    SpinButton* base_priority_spin;
    
    _add_process_dialog_glade->get_widget("Name.Entry", name_entry);
    _add_process_dialog_glade->get_widget("ArrivalTime.Spin", arrival_time_spin);
    _add_process_dialog_glade->get_widget("BasePriority.Spin", base_priority_spin);

    Simulation::get_instance().get_history().add_process(name_entry->get_text(), 
                                                         arrival_time_spin->get_value_as_int(), 
							 base_priority_spin->get_value_as_int());
  }
  
  _add_process_dialog->hide();
}

void
SchedulablesTreeWidget::_on_add_thread()
{  
  Process* p = get_selected<Process>();
  if(p == NULL)
    return;
  
  if(_add_thread_dialog->run() == RESPONSE_OK)
  {
    Entry* name_entry;
    SpinButton* cpu_time_spin;
    SpinButton* arrival_time_spin;
    SpinButton* base_priority_spin;
    
    _add_thread_dialog_glade->get_widget("Name.Entry", name_entry);
    _add_thread_dialog_glade->get_widget("CpuTime.Spin", cpu_time_spin);
    _add_thread_dialog_glade->get_widget("ArrivalTime.Spin", arrival_time_spin);
    _add_thread_dialog_glade->get_widget("BasePriority.Spin", base_priority_spin);

    Simulation::get_instance().get_history().add_thread(name_entry->get_text(),
							*p, 
							cpu_time_spin->get_value_as_int(),
							arrival_time_spin->get_value_as_int(), 
							base_priority_spin->get_value_as_int());
    
  }
  
  _add_thread_dialog->hide();
}

void
SchedulablesTreeWidget::_on_add_request()
{  
  Thread* t = get_selected<Thread>();

  if(t == NULL)
    return;

  if(_add_request_dialog->run() == RESPONSE_OK)
    _add_request_dialog->construct_request(*t);
  
  _add_request_dialog->hide();
}

void
SchedulablesTreeWidget::_on_remove_process()
{
  Process* p = get_selected<Process>();
  assert(p != NULL);

  Simulation::get_instance().get_history().remove(*p);
}

void
SchedulablesTreeWidget::_on_remove_thread()
{
  Thread* t = get_selected<Thread>();
  assert(t != NULL);

  Simulation::get_instance().get_history().remove(*t);
}

void
SchedulablesTreeWidget::_on_remove_request()
{
  Request* r = get_selected<Request>();
  assert(r != NULL);

  Simulation::get_instance().get_history().remove(*r);
}

void
SchedulablesTreeWidget::_on_remove_subrequest()
{
  SubRequest* sr = get_selected<SubRequest>();
  assert(sr != NULL);

  Request& owner = sr->get_request();
  
  Simulation::get_instance().get_history().remove(*sr);

  // empty requests are COMPLETELY useless with the current GUI
  if(owner.get_subrequests().empty())
    Simulation::get_instance().get_history().remove(owner);
}

void 
SchedulablesTreeWidget::_on_cell_name_data(Gtk::CellRenderer* cr, 
                                           const Gtk::TreeModel::iterator& it)
{
  CellRendererTextMarkup& crtm = reinterpret_cast<CellRendererTextMarkup&>(*cr);

  ustring marked_up;

  switch(get_row_type(it))
  {
  case htype_process:
    marked_up = markup_process(*get_row_handle_as<Process>(it));
    break;
  default:
    marked_up = "<small>";
    marked_up += Markup::escape_text(it->get_value(_main_column));
    marked_up += "</small>";
  }
  
  crtm.property_markup() = marked_up;
}

ustring
SchedulablesTreeWidget::markup_process(const Process& p)
{
  using std::ostringstream;
  using std::endl;
  
  ustring color;
  
  switch(p.get_state())
  {
  case Process::state_running:
    color = "green";
    break;
  case Process::state_ready:
    color = "yellow";
    break;
  case Process::state_blocked:
    color = "red";
    break;
  case Process::state_terminated:
    color = "grey";
    break;
  case Process::state_future:
    color = "LightSeaGreen";
    break;
  }

  ostringstream oss;

  oss << "<b>" << Markup::escape_text(p.get_name()) << 
    "</b> / arrived at: " << p.get_arrival_time() << 
    " / base priority: " << p.get_base_priority() << endl;
  oss << "<small>elapsed: " << p.get_elapsed_time() << "</small>" << endl;
  oss << "<small>priority: " << p.get_current_priority() << "</small>";

  // TODO I'm unable to set foreground color, why?
  return ustring("<span background=\"") + color + "\">" + oss.str() + "</span>";
}