/* -*-c-*- -------------- mixgtk_cmd_dispatcher.c :
 * Implementation of the functions declared in mixgtk_cmd_dispatcher.h
 * ------------------------------------------------------------------
 *  Last change: Time-stamp: "2001-04-08 01:34:09 jao"
 * ------------------------------------------------------------------
 * Copyright (C) 2001 Free Software Foundation, Inc.
 *  
 * This program 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.
 *  
 * This program 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 this program; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
 *  
 */

#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include <ctype.h>
#include <unistd.h>
#include <fcntl.h>
#include <errno.h>

#include <mixlib/mix_vm_command.h>
#include "mixgtk_mixvm.h"
#include "mixgtk_mixal.h"
#include "mixgtk_config.h"
#include "mixgtk_cmd_dispatcher.h"


/* a mix vm command dispatcher */
typedef struct mixgtk_dispatch_
{
  mix_vm_cmd_dispatcher_t *dispatcher; /* the underlying cmd dispatcher */
  FILE *out;			/* the dispatcher's output file */
  int fildes[2];		/* pipe for communication with the dispatcher */
  GtkWidget *prompt;		/* the command prompt widget */
  GtkWidget *log;		/* the dispatcher's messages echo area */
  GtkWidget *status;		/* the status bar widget */
  guint context;		/* context of the status bar messages */
  GCompletion *completions;	/* mixvm command completions */
} mixgtk_dispatch_data_t;

static struct mixgtk_dispatch_ dis_data_ = {NULL};

/* local commands stuff */
static const gchar *EDITOR_ = NULL;
static const gchar *MIXASM_ = NULL;
static const gchar *EDITOR_KEY_ = "Editor";
static const gchar *MIXASM_KEY_ = "Mixasm";

typedef gboolean (*local_handler_t) (mixgtk_dispatch_data_t *,
				     const gchar *);

static void
log_command_ (mixgtk_dispatch_data_t *dis, const gchar *cmd)
{
  gtk_text_insert (GTK_TEXT (dis->log), NULL, NULL, NULL,"MIX> ", -1);
  gtk_text_insert (GTK_TEXT (dis->log), NULL, NULL, NULL, cmd, -1);
  gtk_text_insert (GTK_TEXT (dis->log), NULL, NULL, NULL, "\n", -1);
}

static void
flush_log_ (mixgtk_dispatch_data_t *dis)
{
  enum {BLKSIZE = 100};
  static gchar BUFFER[BLKSIZE];
  
  ssize_t k;
  fflush (dis->out);
  while ((k = read (dis->fildes[0], BUFFER, BLKSIZE)) != 0)
    {
      if (k == -1 && errno != EINTR) break;
      if (k != -1)
	gtk_text_insert (GTK_TEXT (dis->log), NULL, NULL, NULL,
			 BUFFER, k);
    }
}

static gboolean
exec_ (mixgtk_dispatch_data_t *dis, const gchar *cmd, const gchar *arg)
{
  gchar *fullcmd = NULL;
  gboolean r = FALSE;
  fullcmd = g_strdup_printf (cmd, arg);
  r = !system (fullcmd);
  flush_log_ (dis);
  g_free (fullcmd);
  return r;
}

static const gchar *
get_src_file_path_ (mixgtk_dispatch_data_t *dis)
{
  static gchar *PATH = NULL;
  
  const mix_vm_t *vm = mix_vm_cmd_dispatcher_get_vm (dis->dispatcher);
  const mix_src_file_t *f  = mix_vm_get_src_file (vm);
  
  if (PATH)
    {
      g_free (PATH);
      PATH = NULL;
    }
    
  if (f)
    PATH = mix_file_complete_name (mix_src_file_get_path (f), MIX_SRC_DEFEXT);
      
  return PATH;
}

static gboolean
edit_handler_ (mixgtk_dispatch_data_t *dis, const gchar *arg)
{
  if (!arg) arg = get_src_file_path_ (dis);
  if (!arg) return FALSE;
  return exec_ (dis, EDITOR_, arg);
}

static gboolean
compile_handler_ (mixgtk_dispatch_data_t *dis, const gchar *arg)
{
  if (!arg) arg = get_src_file_path_ (dis);
  if (!arg) return FALSE;
  return exec_ (dis, MIXASM_, arg);
}

static const gchar* local_cmds_[] = {
  "edit", "compile"
};

static const local_handler_t handlers_[] = {
  edit_handler_, compile_handler_
};

#define LOCAL_NO_ (sizeof (local_cmds_) / sizeof (local_cmds_[0]))

static gboolean
dispatch_local_command_ (mixgtk_dispatch_data_t *dis, const gchar *cmd)
{
  int k = 0;
  
  g_return_val_if_fail (dis != NULL, FALSE);
  g_return_val_if_fail (cmd != NULL, FALSE);

  for (k = 0; k < LOCAL_NO_; ++k)
    {
      if (!strncmp (local_cmds_[k], cmd, strlen (local_cmds_[k])))
	{
	  int j = 0;
	  const gchar *arg = NULL;
	  while (cmd[j] && !isspace (cmd[j])) ++j;
	  if (cmd[j]) arg = cmd + j;
	  log_command_ (dis, cmd);
	  handlers_[k](dis, arg);
	  return TRUE;
	}
    }
  
  return FALSE;
}
	  

/* completions */
static void
init_completions_ (void)
{
  GList *cmds = NULL;
  gint k;
  
  dis_data_.completions = g_completion_new (NULL);
  for (k = 0; k < MIX_CMD_INVALID; ++k)
    cmds = g_list_append (cmds, (gpointer) mix_vm_command_to_string (k));
  for (k = 0; k < sizeof (local_cmds_) / sizeof (local_cmds_[0]); ++k)
    cmds = g_list_append (cmds, (gpointer)local_cmds_[k]);
  g_completion_add_items (dis_data_.completions, cmds);
}

/* global hooks for the command dispatcher 
static void
global_pre_hook_ (mix_vm_cmd_dispatcher_t *dis,
		  mix_vm_command_t cmd, const gchar *arg, gpointer data)
{
  if (cmd < MIX_CMD_INVALID)
    {
      gtk_text_insert (GTK_TEXT (dis_data_.log), NULL, NULL, NULL,
		       "MIX> ", -1);
      gtk_text_insert (GTK_TEXT (dis_data_.log), NULL, NULL, NULL,
		       mix_vm_command_to_string (cmd), -1);
      gtk_text_insert (GTK_TEXT (dis_data_.log), NULL, NULL, NULL,
		       " ", -1);
      gtk_text_insert (GTK_TEXT (dis_data_.log), NULL, NULL, NULL,
		       arg, -1);
      gtk_text_insert (GTK_TEXT (dis_data_.log), NULL, NULL, NULL,
		       "\n", -1);
    }
  else
    {
      gtk_text_insert (GTK_TEXT (dis_data_.log), NULL, NULL, NULL,
		       _("\n*** Invalid command ***\n"), -1);
    }
}
*/

static void
global_post_hook_ (mix_vm_cmd_dispatcher_t *dis,
		   mix_vm_command_t cmd, const gchar *arg, gpointer data)
{
  flush_log_ ((mixgtk_dispatch_data_t *)data);
  mixgtk_mixvm_update_vm_widgets ();
}

static void
load_post_hook_ (mix_vm_cmd_dispatcher_t *dis, const gchar *arg,
		 gpointer data)
{
  static glong id = -1;
 
  if (mix_vm_cmd_dispatcher_get_last_result (dis))
    {
      gchar *file = g_strdup (arg);
      mixgtk_mixal_load_file ();
      mixgtk_mixal_update ();
      mixgtk_mixal_update_bp_all ();
      
      if (id != -1)
	gtk_statusbar_remove (GTK_STATUSBAR (dis_data_.status),
			      dis_data_.context, (guint)id);
      id =
	gtk_statusbar_push (GTK_STATUSBAR (dis_data_.status), dis_data_.context,
			    file);
    }
}

static void
run_post_hook_ (mix_vm_cmd_dispatcher_t *dis, const gchar *arg,
		 gpointer data)
{
  mixgtk_mixal_update ();
}

static void
next_post_hook_ (mix_vm_cmd_dispatcher_t *dis, const gchar *arg,
		 gpointer data)
{
  mixgtk_mixal_update ();
}

static void
linebp_post_hook_ (mix_vm_cmd_dispatcher_t *dis, const gchar *arg,
		gpointer data)
{
  if (arg && strlen (arg)) mixgtk_mixal_update_bp_at_line (atoi (arg));
}

static void
addrbp_post_hook_ (mix_vm_cmd_dispatcher_t *dis, const gchar *arg,
		gpointer data)
{
  if (arg && strlen (arg)) mixgtk_mixal_update_bp_at_address (atoi (arg));
}

static void
allbp_post_hook_ (mix_vm_cmd_dispatcher_t *dis, const gchar *arg,
		  gpointer data)
{
  mixgtk_mixal_update_bp_all ();
}


static void
install_hooks_ (void)
{
  mix_vm_cmd_dispatcher_global_post_hook (dis_data_.dispatcher,
					  global_post_hook_,
					  (gpointer)(&dis_data_));
  mix_vm_cmd_dispatcher_post_hook (dis_data_.dispatcher,
				   MIX_CMD_LOAD, load_post_hook_,
				   NULL);
  mix_vm_cmd_dispatcher_post_hook (dis_data_.dispatcher,
				   MIX_CMD_RUN, run_post_hook_,
				   NULL);
  mix_vm_cmd_dispatcher_post_hook (dis_data_.dispatcher,
				   MIX_CMD_NEXT, next_post_hook_,
				   NULL);
  mix_vm_cmd_dispatcher_post_hook (dis_data_.dispatcher,
				   MIX_CMD_SBP, linebp_post_hook_,
				   NULL);
  mix_vm_cmd_dispatcher_post_hook (dis_data_.dispatcher,
				   MIX_CMD_CBP, linebp_post_hook_,
				   NULL);
  mix_vm_cmd_dispatcher_post_hook (dis_data_.dispatcher,
				   MIX_CMD_SBPA, addrbp_post_hook_,
				   NULL);
  mix_vm_cmd_dispatcher_post_hook (dis_data_.dispatcher,
				   MIX_CMD_CBPA, addrbp_post_hook_,
				   NULL);
  mix_vm_cmd_dispatcher_post_hook (dis_data_.dispatcher,
				   MIX_CMD_CABP, allbp_post_hook_,
				   NULL);
}

/* configuration stuff */
static void
read_config_ (void)
{
  EDITOR_ = mixgtk_config_get (EDITOR_KEY_);
  if (!EDITOR_)
    {
      static const gchar *ENV[] = {"MDK_EDITOR", "X_EDITOR", NULL};
      int k = 0;
      while (!EDITOR_ && ENV[k]) EDITOR_ = getenv (ENV[k++]);
      if (EDITOR_) EDITOR_ = g_strconcat (EDITOR_, " %s", NULL);
    }
  MIXASM_ = mixgtk_config_get (MIXASM_KEY_);
  if (!MIXASM_) MIXASM_ = "mixasm -g %s";
}

static GtkWidget *ext_dlg_ = NULL;
static GtkWidget *ed_entry_ = NULL;
static GtkWidget *asm_entry_ = NULL;

static const gchar *ED_NAME_ = "editor_entry";
static const gchar *ASM_NAME_ = "mixasm_entry";

void
on_external_programs_activate ()
{
  if (!ext_dlg_)
    {
      ext_dlg_ = mixgtk_widget_factory_get_dialog (MIXGTK_EXTERNPROG_DIALOG);
      g_return_if_fail (ext_dlg_ != NULL);
      ed_entry_ = mixgtk_widget_factory_get_child_by_name
	(MIXGTK_EXTERNPROG_DIALOG, ED_NAME_);
      g_assert (ed_entry_);
      asm_entry_ = mixgtk_widget_factory_get_child_by_name
	(MIXGTK_EXTERNPROG_DIALOG, ASM_NAME_);
      g_assert (asm_entry_);
    }
  gtk_entry_set_text (GTK_ENTRY (ed_entry_), EDITOR_);
  gtk_entry_set_text (GTK_ENTRY (asm_entry_), MIXASM_);
  gtk_widget_show (ext_dlg_);
}

void
on_extern_cancel_button_clicked ()
{
  gtk_widget_hide (ext_dlg_);
}

void
on_extern_ok_button_clicked ()
{
  EDITOR_ = gtk_entry_get_text (GTK_ENTRY (ed_entry_));
  MIXASM_ = gtk_entry_get_text (GTK_ENTRY (asm_entry_));
  mixgtk_config_update (EDITOR_KEY_, EDITOR_);
  mixgtk_config_update (MIXASM_KEY_, MIXASM_);
  gtk_widget_hide (ext_dlg_);
}

/* initialise the command dispatcher */
gboolean
mixgtk_cmd_dispatcher_init (void)
{
  if (!dis_data_.prompt)
    {
      dis_data_.prompt = mixgtk_widget_factory_get (MIXGTK_WIDGET_PROMPT);
      g_return_val_if_fail (dis_data_.prompt != NULL, FALSE);
      dis_data_.log = mixgtk_widget_factory_get (MIXGTK_WIDGET_LOG);
      g_return_val_if_fail (dis_data_.log != NULL, FALSE);
    }
    
  if (!dis_data_.dispatcher)
    {
      int r = pipe (dis_data_.fildes);
      g_return_val_if_fail (r == 0, FALSE);
      /* connect stdout/stderr to the pipe's write end */
      if (dup2 (dis_data_.fildes[1], STDOUT_FILENO) == -1
	  || dup2 (dis_data_.fildes[1], STDERR_FILENO) == -1)
	return FALSE;
      dis_data_.out = fdopen (dis_data_.fildes[1], "w");
      g_return_val_if_fail (dis_data_.out != NULL, FALSE);
      r = fcntl (dis_data_.fildes[0], F_GETFL, 0);
      g_return_val_if_fail (r != -1, FALSE);
      r |= O_NONBLOCK;
      r = fcntl(dis_data_.fildes[0], F_SETFL, r);
      g_return_val_if_fail (r != -1, FALSE);
      dis_data_.dispatcher =
	mix_vm_cmd_dispatcher_new (dis_data_.out, dis_data_.out);
      mix_vm_cmd_dispatcher_print_time (dis_data_.dispatcher, FALSE);
      
      install_hooks_ ();
    }
  
  if (!dis_data_.status)
    {
      dis_data_.status = mixgtk_widget_factory_get (MIXGTK_WIDGET_STATUSBAR);
      g_return_val_if_fail (dis_data_.status != NULL, FALSE);
      dis_data_.context = gtk_statusbar_get_context_id (GTK_STATUSBAR
							(dis_data_.status),
							"cmd_dis_context");
    }
  
  if (!dis_data_.completions) init_completions_ ();
  read_config_ ();
  
  return TRUE;
}

/* dispatch an externally provided command */
void
mixgtk_cmd_dispatcher_dispatch (const gchar *command)
{
  GtkWidget *entry = dis_data_.prompt;
  g_return_if_fail (command != NULL);
  g_assert (entry != NULL);
  gtk_entry_set_text (GTK_ENTRY (entry), command);
  on_mixvm_cmd_entry_activate (entry, NULL);
}

/* get times */
void
mixgtk_cmd_dispatcher_get_times (gint *uptime, gint *progtime, gint *laptime)
{
  if (uptime != NULL)
    *uptime = mix_vm_cmd_dispatcher_get_uptime (dis_data_.dispatcher);
  if (progtime != NULL)
    *progtime = mix_vm_cmd_dispatcher_get_progtime (dis_data_.dispatcher);
  if (laptime != NULL)
    *laptime = mix_vm_cmd_dispatcher_get_laptime (dis_data_.dispatcher);
}

/* get the underlying vm */
mix_vm_t *
mixgtk_cmd_dispatcher_get_vm (void)
{
  return (mix_vm_t *) mix_vm_cmd_dispatcher_get_vm (dis_data_.dispatcher);
}

/* process new command */
void
on_mixvm_cmd_entry_activate (GtkWidget *w, gpointer e)
{
  gchar *text;
  GList *cmds = NULL;
  gchar *prefix = NULL;
  
  text = g_strchomp (gtk_entry_get_text (GTK_ENTRY (w)));

  if (mix_vm_command_from_string (text) != MIX_CMD_INVALID)
    {
      mix_vm_cmd_dispatcher_dispatch_text (dis_data_.dispatcher, text);
      gtk_entry_set_text (GTK_ENTRY (w), "");
      return;
    }

  if (dispatch_local_command_ (&dis_data_, text))
    {
      gtk_entry_set_text (GTK_ENTRY (w), "");
      return;
    }
  
  cmds = g_completion_complete (dis_data_.completions, text, &prefix);

  if (prefix != NULL)
    {
      gtk_entry_set_text (GTK_ENTRY (w), prefix);
      g_free (prefix);
      if (g_list_length (cmds) > 1)
	{
	  gint k = 0;
	  gtk_text_insert (GTK_TEXT (dis_data_.log),
			   NULL, NULL, NULL, "Completions:\n", -1);
	  while (cmds)
	    {
	      ++k;
	      gtk_text_insert (GTK_TEXT (dis_data_.log),
			       NULL, NULL, NULL,
			       (gchar *)(cmds->data), -1);
	      gtk_text_insert (GTK_TEXT (dis_data_.log),
			       NULL, NULL, NULL, "     ", -1);
	      if (k%5 == 0)
		gtk_text_insert (GTK_TEXT (dis_data_.log),
				 NULL, NULL, NULL, "\n", -1);
	      
	      cmds = cmds->next;
	    }
	  if (k%5 != 0)
	    gtk_text_insert (GTK_TEXT (dis_data_.log),
			     NULL, NULL, NULL, "\n", -1);
	}
      else
	gtk_entry_append_text (GTK_ENTRY (w), " ");
    }
  else
    {
      log_command_ (&dis_data_, text);
      mix_vm_cmd_dispatcher_dispatch_text (dis_data_.dispatcher, text);
      gtk_entry_set_text (GTK_ENTRY (w), "");
    }
}