// 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 "gettext.h"

#include "schedulables_tree_widget.hh"
#include <sgpemv2/history.hh>
#include <sgpemv2/simulation.hh>
#include <sgpemv2/process.hh>
#include <sgpemv2/thread.hh>
#include <sgpemv2/resource.hh>
#include <sgpemv2/global_preferences.hh>
#include "add_request_dialog.hh"

#include <sgpemv2/templates/sequences.tcc>

#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() 
{
  _columns.add(_main_column);
  _columns.add(_types_column);
  _columns.add(_handles_column);
  _model = TreeStore::create(_columns);
  
  set_model(_model);

  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));
  
  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((Simulation::get_instance().get_state() == Simulation::state_stopped) &&
     (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("EditProcess", _("Edit Process")),
	sigc::mem_fun(*this, &SchedulablesTreeWidget::_on_edit_process) );
    
    action_group->add( Gtk::Action::create("EditThread", _("Edit Thread")),
        sigc::mem_fun(*this, &SchedulablesTreeWidget::_on_edit_thread) );
    
    action_group->add( Gtk::Action::create("EditRequest", _("Edit Request")),
        sigc::mem_fun(*this, &SchedulablesTreeWidget::_on_edit_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 adds;
    Glib::ustring edits;
    Glib::ustring removes;
    Glib::ustring separator;
    
    if(selection_type != htype_undefined)
      separator = "<separator/>";
    
    switch(selection_type)
    {
    case htype_process:
      adds = "<menuitem action='AddThread'/>";
      edits = "<menuitem action='EditProcess'/>";
      removes = "<menuitem action='RemoveProcess'/>";
      break;
    case htype_thread:
      adds = "<menuitem action='AddRequest'/>";
      edits = "<menuitem action='EditThread'/>";
      removes = "<menuitem action='RemoveThread'/>";
      break;
    case htype_request:
      edits = "<menuitem action='EditRequest'/>";
      removes = "<menuitem action='RemoveRequest'/>";
      break;
//    case htype_subrequest:
 //     removes = "<menuitem action='RemoveSubrequest'/>";
    default:
      break;
    }

    adds += "<menuitem action='AddProcess'/>";
    
    Glib::ustring ui_info = 
	  "<ui>"
	  "  <popup name='PopupMenu'>";

    ui_info += adds + separator + edits + ((edits.size() == 0) ? ustring() : separator) + removes;

    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_expanded_vector(Gtk::TreeView*, const Gtk::TreeModel::Path& path)
{
  _expanded_rows.push_back(path.to_string());
}

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();


  // Save expanded rows (FIXME: find a better way?)
  map_expanded_rows(sigc::mem_fun(*this, &SchedulablesTreeWidget::_update_expanded_vector));

  _model->clear();
  

  for(Iseq<ProcessIt> pit = 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;
//          }
      }
    }
  }

  // Restore expanded rows
  const vector<Glib::ustring>& const_expanded_rows = _expanded_rows;
  for(Iseq<vector<Glib::ustring>::const_iterator> it = iseq(const_expanded_rows); it; ++it)
    expand_row(Gtk::TreeModel::Path(*it), false);

  // We can clear it now, since until next update we won't need it.
  _expanded_rows.clear();
  
}

void
SchedulablesTreeWidget::_on_add_process()
{
  add_edit_process(true);
}

void
SchedulablesTreeWidget::_on_edit_process()
{
  add_edit_process(false);
}

void
SchedulablesTreeWidget::add_edit_process(bool adding)
{
  /** This is ugly, I know, we should be using derived widgets, but I also believe we 
   * have little time, and I'm not going to waste too much of it on the frontend */

  RefPtr<Xml> glade(Xml::create(GLADEDIR "/add-process-dialog.glade"));
  Dialog* add_process_dialog;

  glade->get_widget("AddProcessDialog", add_process_dialog);
  
  Entry* name_entry;
  SpinButton* arrival_time_spin;
  SpinButton* base_priority_spin;

  glade->get_widget("Name.Entry", name_entry);
  glade->get_widget("ArrivalTime.Spin", arrival_time_spin);
  glade->get_widget("BasePriority.Spin", base_priority_spin);
 
  Process* selection = NULL;
  
  if(!adding)
  {
    selection = get_selected<Process>();

    name_entry->set_text(selection->get_name());
    arrival_time_spin->set_value(static_cast<double>(selection->get_arrival_time()));
    base_priority_spin->set_value(static_cast<double>(selection->get_base_priority()));
  }
//  else
//  {
//    name_entry->set_text("");
//    arrival_time_spin->set_value(0.0);
//    base_priority_spin->set_value(0.0);
//  }

  
  if(add_process_dialog->run() == RESPONSE_OK)
  {
    
    if(adding)
    {
      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());
    }
    else
    {
      Simulation::get_instance().get_history().edit_process(*selection,
                                                            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()
{  
  add_edit_thread(true);
}

void
SchedulablesTreeWidget::_on_edit_thread()
{
  add_edit_thread(false);
}

void
SchedulablesTreeWidget::add_edit_thread(bool adding)
{
  /** This is ugly, I know, we should be using derived widgets, but I also believe we 
   * have little time, and I'm not going to waste too much of it on the frontend */

  RefPtr<Xml> glade(Xml::create(GLADEDIR "/add-thread-dialog.glade"));
  Dialog* add_thread_dialog;

  glade->get_widget("AddThreadDialog", add_thread_dialog);
  
  Entry* name_entry;
  SpinButton* cpu_time_spin;
  SpinButton* arrival_time_spin;
  SpinButton* base_priority_spin;

  glade->get_widget("Name.Entry", name_entry);
  glade->get_widget("CpuTime.Spin", cpu_time_spin);
  glade->get_widget("ArrivalTime.Spin", arrival_time_spin);
  glade->get_widget("BasePriority.Spin", base_priority_spin);

  Thread* t = NULL;
  
  if(!adding)
  {
    t = get_selected<Thread>();
    
    name_entry->set_text(t->get_name());
    cpu_time_spin->set_value(static_cast<double>(t->get_total_cpu_time()));
    arrival_time_spin->set_value(static_cast<double>(t->get_arrival_time()));
    base_priority_spin->set_value(static_cast<double>(t->get_base_priority()));
  }
//  else
//  {
//    name_entry->set_text("");
//    cpu_time_spin->set_value(1.0);
//    arrival_time_spin->set_value(0.0);
//    base_priority_spin->set_value(0.0);
//  }

  
  if(add_thread_dialog->run() == RESPONSE_OK)
  {

    if(adding)
    {
      Process* p = get_selected<Process>();
      assert(p != NULL);
	  
      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());
    }
    else
    {
      Simulation::get_instance().get_history().edit_thread(*t,
                                                          name_entry->get_text(),
							  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()
{  
  RefPtr<Xml> glade(Xml::create(GLADEDIR "/add-request-dialog.glade"));
  AddRequestDialog* add_request_dialog;

  // NOTE This is *not* reflective programming! AddRequestDialog is the name of
  // the base widget in the glade file.
  glade->get_widget_derived("AddRequestDialog", add_request_dialog);
  
  Thread* t = get_selected<Thread>();
  assert(t != NULL);
  
  add_request_dialog->run_add(*t);
}

void
SchedulablesTreeWidget::_on_edit_request()
{  
  using std::vector;
  
  RefPtr<Xml> glade(Xml::create(GLADEDIR "/add-request-dialog.glade"));
  AddRequestDialog* add_request_dialog;

  // NOTE This is *not* reflective programming! AddRequestDialog is the name of
  // the base widget in the glade file.
  glade->get_widget_derived("AddRequestDialog", add_request_dialog);
  
  Request* r = get_selected<Request>();
  assert(r != NULL);

  // FIXME: write more polite code for doing this, and probably using the same logic
  // for all other editing operations may be useful for making the app more robust
  
  const Environment::Processes& processes = 
    Simulation::get_instance().get_history().get_environment_at(0).get_processes();

  for(Iseq<Environment::Processes::const_iterator> pit = iseq(processes); pit; ++pit)
  {
    vector<Thread*> threads = (*pit)->get_threads();

    for(Iseq<vector<Thread*>::iterator> tit = iseq(threads); tit; ++tit)
    {
      vector<Request*> requests = (*tit)->get_requests();
      for(Iseq<vector<Request*>::iterator> rit = iseq(requests); rit; ++rit)
      {
	if(*(*rit) == *r)
	  r = *rit;
      }
    }
  }
  
  add_request_dialog->run_edit(*r);
}

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 = static_cast<CellRendererTextMarkup&>(*cr);

  ustring marked_up;

  switch(get_row_type(it))
  {
  case htype_process:
    marked_up = markup_schedulable(*get_row_handle_as<Process>(it));
    break;
    
  case htype_thread:
    marked_up = markup_schedulable(*get_row_handle_as<Thread>(it));
    break;
  case htype_request:
    marked_up = markup_request(*get_row_handle_as<Request>(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_schedulable(const Schedulable& s)
{
  using std::ostringstream;
  using std::endl;
  
  ostringstream oss;

  // TODO : add note for the translator to use HTML-escaped text
  // See the gettext manual.
  oss << "<small><span foreground=\"" 
      << GlobalPreferences::get_instance().get_schedulable_color(s.get_state()) 
      << "\"><b>" << Markup::escape_text(s.get_name()) << "</b></span>"
      << _(", arrives at: ")    << s.get_arrival_time() 
      << _(", base priority: ") << s.get_base_priority()  
      << _(", elapsed time: ") << s.get_elapsed_time() 
      << _(", current priority: ") << s.get_current_priority() 
      << "</small>";

  return oss.str();
}

ustring
SchedulablesTreeWidget::markup_request(Request& r)
{
  using std::ostringstream;
  using std::endl;

  ostringstream oss;

  oss << "<small><span foreground=\"" 
      << GlobalPreferences::get_instance().get_request_color(r.get_state()) 
      << "\"><b>" << _("at ") << r.get_instant() << ":</b></span>";

  const Environment& env = Simulation::get_instance().get_history().get_last_environment();
  const Environment::Resources& resources = env.get_resources();
  std::vector<SubRequest*> subrequests = r.get_subrequests();

  for(Iseq<std::vector<SubRequest*>::iterator> it = iseq(subrequests); it; ++it)
  {
    SubRequest& sr = *(*it);
    Resource& res = *(resources.find(sr.get_resource_key())->second);
 
    oss << " -&gt; <span foreground=\"" 
        << GlobalPreferences::get_instance().get_request_color(sr.get_state()) 
	<< "\"><b>" << res.get_name() << "</b></span> (" 
	<< (sr.get_length() - sr.get_remaining_time())
	<< "/" << sr.get_length() << ")";
  }
  
  oss << "</small>";

  return oss.str();
}

