// src/jump_to_dialog.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 "jump_to_dialog.hh"

#include <sgpemv2/templates/sequences.tcc>
#include <sgpemv2/history.hh>
#include <sgpemv2/environment.hh>
#include <sgpemv2/simulation.hh>
#include <sgpemv2/resource.hh>

#include <gtkmm/main.h>
#include <gtkmm/messagedialog.h>

#include <iostream>

#include <cassert>

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

JumpToDialog::JumpToDialog(BaseObjectType* cobject, const RefPtr<Xml>& glade) :
  Dialog(cobject), _glade(glade), _target_instant(0)
{
  _glade->get_widget("OK.Button", _ok_button);
  _glade->get_widget("Jump.Button", _jump_button);
  _glade->get_widget("Stop.Button", _stop_button);
  _glade->get_widget("Instant.Spin", _instant_spin);
  _glade->get_widget("ProgressBar", _progress);


  /** ATTACH SIGNAL HANDLERS FOR BUTTONS **/
  
  _jump_button->signal_clicked().connect(
      sigc::mem_fun(*this, &JumpToDialog::_on_jump));

  _stop_button->signal_clicked().connect(
      sigc::mem_fun(*this, &JumpToDialog::_on_stop));

  _ok_button->signal_clicked().connect(sigc::bind(
      sigc::mem_fun(*this, &JumpToDialog::response), RESPONSE_OK));
  _ok_button->signal_clicked().connect(
      sigc::mem_fun(*this, &JumpToDialog::hide));

  // FIXME: not implemented
  _stop_button->set_sensitive(false);
}

void
JumpToDialog::_on_jump()
{
  _ok_button->set_sensitive(false);
  _stop_button->set_sensitive(true);
  _jump_button->set_sensitive(false);
  _progress->set_fraction(0.0);
  
  assert(_instant_spin->get_value_as_int() > 0);
  _target_instant = _instant_spin->get_value_as_int();

  Simulation& sim = Simulation::get_instance();
  History&    h   = sim.get_history();

  sim.attach(*this);
  bool reenable = h.is_notify_enabled();
  try
  {
    if(_target_instant < h.get_size() - 1)
      sim.jump_to(_target_instant);
    else
      sim.jump_to(h.get_size() - 1);

    h.set_notify_enabled(false);
    while(h.get_front() <= _target_instant)
    {
      sim.run();
      if(sim.get_state() == Simulation::state_stopped)
	      break; // Simulation ended before reaching _target_instant
    }
  }
  // TODO: exception handling copied from SimulationController, it should be factored out
  catch(const UserInterruptException& uie)
  {
    // Show the user a dialog
    MessageDialog diag(_("<b>The selected user CPU policy stopped before returning:</b>\n") + Markup::escape_text(uie.what()), 
	true, Gtk::MESSAGE_ERROR, Gtk::BUTTONS_OK, true);
    diag.run();
  }
  catch(const MalformedPolicyException& mpe)
  {
    // Show user a dialog
    MessageDialog diag(_("<b>The selected user CPU policy was malformed and failed to sort the queue:</b>\n") + 
	Markup::escape_text(mpe.what()), true, Gtk::MESSAGE_ERROR, Gtk::BUTTONS_OK, true);
    diag.run();

    try
    {
      // Deactivate the policy
      sim.set_policy(NULL);
    }
    catch(const CPUPolicyException& cpe)
    {
      // Fatal error. We should never get here.
      std::cerr << _(" [EE] Fatal error. Impossible to deactivate the policy in ") <<  __FILE__ << ":" << __LINE__
                << std::endl << _(" [EE] ") << cpe.what() << std::endl;
      abort();
    }
  }
  catch(const NullPolicyException& npe)
  {
    MessageDialog diag(_("<b>No active policy selected:</b>\n") + Markup::escape_text(npe.what()), 
	true, Gtk::MESSAGE_ERROR, Gtk::BUTTONS_OK, true);
    diag.run();

  }
  catch(const CPUPolicyException& cpe)
  {
    MessageDialog diag(_("<b>Unexpected error</b>:\n") + Markup::escape_text(cpe.what()), 
	true, Gtk::MESSAGE_ERROR, Gtk::BUTTONS_OK, true);
    diag.run();
  }

  h.set_notify_enabled(reenable);
  sim.detach(*this);

  _ok_button->set_sensitive(true);
  _stop_button->set_sensitive(false);
  _jump_button->set_sensitive(true);
}

void
JumpToDialog::_on_stop()
{
  Simulation::get_instance().stop();
}

void
JumpToDialog::update(const Simulation& changed_simulation)
{
  unsigned int front = changed_simulation.get_history().get_front();

  double percent = std::min(static_cast<double>(front) / _target_instant, 1.0);

  _progress->set_fraction(percent);

  //  Needed to force display (else under
  //  intensive computation it doesn't have
  //  the time to flush all UI events):
  while(Gtk::Main::events_pending())
       Gtk::Main::iteration();
}
