/* BSE - Better Sound Engine	-*-mode: c;-*-
 * Copyright (C) 2000-2003 Tim Janik
 *
 * This library is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public
 * License as published by the Free Software Foundation; either
 * version 2.1 of the License, or (at your option) any later version.
 *
 * This library 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
 * Lesser General Public License for more details.
 *
 * A copy of the GNU Lesser General Public License should ship along
 * with this library; if not, see http://www.gnu.org/copyleft/.
 */
#include <bse/bseplugin.h>
#include <bse/bseprocedure.h>
#include <bse/bseserver.h>
#include <bse/bseproject.h>
#include <bse/bseloader.h>
#include <bse/bsemidinotifier.h>
#include <bse/bsemidievent.h>
#include <bse/bsejanitor.h>
#include <bse/bsescripthelper.h>
#include <bse/bsegconfig.h>
#include <bse/bseladspa.h>
#include "topconfig.h"
#include <string.h>


AUTHORS	= "Tim Janik <timj@gtk.org>";
LICENSE = "GNU Lesser General Public License";


METHOD (BseServer, use-new-project) {
  HELP	= "Create a new project, owned by the caller (name is modified to be unique if necessary)";
  IN	= bse_param_spec_object ("server", "Server", NULL,
				 BSE_TYPE_SERVER, SFI_PARAM_STANDARD);
  IN	= sfi_pspec_string ("name", "Project Name", NULL,
			    NULL, SFI_PARAM_STANDARD);
  OUT	= bse_param_spec_object ("project", "Project", NULL,
				 BSE_TYPE_PROJECT, SFI_PARAM_STANDARD);
}
BODY (BseProcedureClass *proc,
      const GValue      *in_values,
      GValue            *out_values)
{
  /* extract parameter values */
  BseServer *server     = (BseServer*) bse_value_get_object (in_values++);
  gchar *name           = sfi_value_get_string (in_values++);
  gchar *uname;
  guint num = 1;
  BseProject *project;
  
  /* check parameters */
  if (!BSE_IS_SERVER (server) || !name)
    return BSE_ERROR_PROC_PARAM_INVAL;
  
  /* enforce unique name */
  uname = g_strdup (name);
  while (bse_server_find_project (server, uname))
    {
      g_free (uname);
      uname = g_strdup_printf ("%s-%u", name, num++);
    }
  
  /* create project */
  project = bse_server_create_project (server, uname);
  g_free (uname);
  bse_item_use (BSE_ITEM (project));
  g_object_unref (project);
  
  /* set output parameters */
  bse_value_set_object (out_values++, G_OBJECT (project));
  
  return BSE_ERROR_NONE;
}

METHOD (BseServer, can-load) {
  HELP	= "Check whether a loader can be found for a wave file";
  IN	= bse_param_spec_object ("server", "Server", NULL,
				 BSE_TYPE_SERVER, SFI_PARAM_STANDARD);
  IN    = sfi_pspec_string ("file_name", "File Name", "The file to find a loader for",
			    NULL, SFI_PARAM_STANDARD);
  OUT   = sfi_pspec_bool ("can-load", NULL, NULL,
			  FALSE, SFI_PARAM_STANDARD);
}
BODY (BseProcedureClass *proc,
      const GValue      *in_values,
      GValue            *out_values)
{
  /* extract parameter values */
  BseServer *server	= bse_value_get_object (in_values++);
  gchar *file_name	= sfi_value_get_string (in_values++);
  BseWaveFileInfo *finfo;
  
  /* check parameters */
  if (!BSE_IS_SERVER (server) || !file_name)
    return BSE_ERROR_PROC_PARAM_INVAL;
  
  /* find a loader */
  finfo = bse_wave_file_info_load (file_name, NULL);
  sfi_value_set_bool (out_values++, finfo != NULL);
  if (finfo)
    bse_wave_file_info_unref (finfo);
  
  return BSE_ERROR_NONE;
}

METHOD (BseServer, n-scripts) {
  HELP	= "Return the number of scripts currently running on this server.";
  IN	= bse_param_spec_object ("server", "Server", NULL,
				 BSE_TYPE_SERVER, SFI_PARAM_STANDARD);
  OUT   = sfi_pspec_int ("n_connections", NULL, "Number of Connections",
			 0, 0, G_MAXINT, 1,
			 SFI_PARAM_STANDARD);
}
BODY (BseProcedureClass *proc,
      const GValue      *in_values,
      GValue            *out_values)
{
  /* extract parameter values */
  BseServer *server	= bse_value_get_object (in_values++);
  GSList *slist;
  guint n_scripts = 0;
  
  /* check parameters */
  if (!BSE_IS_SERVER (server))
    return BSE_ERROR_PROC_PARAM_INVAL;
  
  /* count script controls */
  for (slist = server->children; slist; slist = slist->next)
    if (BSE_IS_JANITOR (slist->data))
      n_scripts++;
  
  /* set output parameters */
  sfi_value_set_int (out_values++, n_scripts);
  
  return BSE_ERROR_NONE;
}

METHOD (BseServer, preferences-locked) {
  HELP	= "Returns whether the bse-preferences property is currently locked against modifications or not.";
  IN	= bse_param_spec_object ("server", "Server", NULL,
				 BSE_TYPE_SERVER, SFI_PARAM_STANDARD);
  OUT   = sfi_pspec_bool ("locked", NULL, NULL,
			  FALSE, SFI_PARAM_STANDARD);
}
BODY (BseProcedureClass *proc,
      const GValue      *in_values,
      GValue            *out_values)
{
  /* extract parameter values */
  BseServer *server	= bse_value_get_object (in_values++);
  
  /* check parameters */
  if (!BSE_IS_SERVER (server))
    return BSE_ERROR_PROC_PARAM_INVAL;
  
  /* set output parameters */
  sfi_value_set_int (out_values++, bse_gconfig_locked ());
  
  return BSE_ERROR_NONE;
}

typedef struct _ScriptRegistration ScriptRegistration;
struct _ScriptRegistration
{
  gchar         *script;
  BseErrorType (*register_func) (const gchar *script,
				 BseJanitor **janitor_p);
  ScriptRegistration *next;
};

static gboolean	register_scripts (gpointer data);

static void
script_janitor_closed (BseJanitor *janitor,
		       BseServer  *server)
{
  bse_server_registration (server, BSE_REGISTER_SCRIPT, janitor->script_name, NULL);
  bse_idle_normal (register_scripts, server);
}

static gboolean
register_scripts (gpointer data)
{
  BseServer *server = data;
  ScriptRegistration *scr = g_object_get_data (server, "script-registration-queue");
  BseJanitor *janitor = NULL;
  BseErrorType error;
  
  if (!scr)
    {
      bse_server_registration (server, BSE_REGISTER_DONE, NULL, NULL);
      return FALSE;
    }
  g_object_set_data (server, "script-registration-queue", scr->next);
  
  error = scr->register_func (scr->script, &janitor);
  if (!janitor)
    bse_server_registration (server, BSE_REGISTER_SCRIPT, scr->script, bse_error_blurb (error));
  else
    g_object_connect (janitor, "signal::shutdown", script_janitor_closed, server, NULL);
  g_free (scr->script);
  g_free (scr);
  return !janitor;
}

METHOD (BseServer, register-scripts) {
  HELP	= "Register external scripts.";
  IN	= bse_param_spec_object ("server", "Server", NULL,
				 BSE_TYPE_SERVER, SFI_PARAM_STANDARD);
}
BODY (BseProcedureClass *proc,
      const GValue      *in_values,
      GValue            *out_values)
{
  static gboolean registration_done = FALSE;
  /* extract parameter values */
  BseServer *server	       = bse_value_get_object (in_values++);
  ScriptRegistration *scr_list = NULL;
  SfiRing *ring;
  
  /* check parameters */
  if (!BSE_IS_SERVER (server))
    return BSE_ERROR_PROC_PARAM_INVAL;
  
  if (registration_done)
    {
      bse_server_registration (server, BSE_REGISTER_DONE, NULL, NULL);
      return BSE_ERROR_NONE;
    }
  registration_done = TRUE;
  
  ring = bse_script_path_list_files ();
  while (ring)
    {
      ScriptRegistration *scr = g_new0 (ScriptRegistration, 1);
      scr->script = sfi_ring_pop_head (&ring);
      scr->register_func = bse_script_file_register;
      scr->next = scr_list;
      scr_list = scr;
    }
  
  g_object_set_data (server, "script-registration-queue", scr_list);
  bse_idle_normal (register_scripts, server);
  
  return BSE_ERROR_NONE;
}

static gboolean
register_core_plugins (gpointer data)
{
  BseServer *server = data;
  SfiRing *plugins = g_object_get_data (server, "plugin-registration-queue");
  const gchar *error;
  
  if (plugins)
    {
      gchar *name = sfi_ring_pop_head (&plugins);
      g_object_set_data (server, "plugin-registration-queue", plugins);
      error = bse_plugin_check_load (name);
      bse_server_registration (server, BSE_REGISTER_PLUGIN, name, error);
      g_free (name);
    }
  else
    {
      bse_server_registration (server, BSE_REGISTER_DONE, NULL, NULL);
      return FALSE;
    }
  return TRUE;
}

METHOD (BseServer, register-core-plugins) {
  HELP	= "Register core plugins.";
  IN	= bse_param_spec_object ("server", "Server", NULL,
				 BSE_TYPE_SERVER, SFI_PARAM_STANDARD);
}
BODY (BseProcedureClass *proc,
      const GValue      *in_values,
      GValue            *out_values)
{
  static gboolean registration_done = FALSE;
  /* extract parameter values */
  BseServer *server	= bse_value_get_object (in_values++);
  SfiRing *ring;
  
  /* check parameters */
  if (!BSE_IS_SERVER (server))
    return BSE_ERROR_PROC_PARAM_INVAL;
  
  if (registration_done)
    {
      bse_server_registration (server, BSE_REGISTER_DONE, NULL, NULL);
      return BSE_ERROR_NONE;
    }
  registration_done = TRUE;
  
  ring = bse_plugin_path_list_files (!bse_main_args->load_drivers_early, TRUE);
  g_object_set_data (server, "plugin-registration-queue", ring);
  
  bse_idle_normal (register_core_plugins, server);
  
  return BSE_ERROR_NONE;
}

static gboolean
register_ladspa_plugins (gpointer data)
{
  BseServer *server = data;
  SfiRing *lplugins = g_object_get_data (server, "ladspa-registration-queue");
  const gchar *error;
  
  if (g_object_get_data (server, "plugin-registration-queue"))
    {
      /* give precedence to core plugins until they're done registering */
      return TRUE;
    }
  
  if (lplugins)
    {
      gchar *name = sfi_ring_pop_head (&lplugins);
      g_object_set_data (server, "ladspa-registration-queue", lplugins);
      error = bse_ladspa_plugin_check_load (name);
      bse_server_registration (server, BSE_REGISTER_PLUGIN, name, error);
      g_free (name);
    }
  else
    {
      bse_server_registration (server, BSE_REGISTER_DONE, NULL, NULL);
      return FALSE;
    }
  return TRUE;
}

METHOD (BseServer, register-ladspa-plugins) {
  HELP	= "Register LADSPA (Linux Audio Developer's Simple Plugin API) plugins.";
  IN	= bse_param_spec_object ("server", "Server", NULL,
				 BSE_TYPE_SERVER, SFI_PARAM_STANDARD);
}
BODY (BseProcedureClass *proc,
      const GValue      *in_values,
      GValue            *out_values)
{
  static gboolean registration_done = FALSE;
  /* extract parameter values */
  BseServer *server	= bse_value_get_object (in_values++);
  SfiRing *ring;
  
  /* check parameters */
  if (!BSE_IS_SERVER (server))
    return BSE_ERROR_PROC_PARAM_INVAL;
  
  if (registration_done)
    {
      bse_server_registration (server, BSE_REGISTER_DONE, NULL, NULL);
      return BSE_ERROR_NONE;
    }
  registration_done = TRUE;
  
  ring = bse_ladspa_plugin_path_list_files ();
  g_object_set_data (server, "ladspa-registration-queue", ring);
  
  bse_idle_normal (register_ladspa_plugins, server);
  
  return BSE_ERROR_NONE;
}

#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <unistd.h>

METHOD (BseServer, save-preferences) {
  HELP	= "Request the bse-preferences property to be saved into BSE's configuration file.";
  IN	= bse_param_spec_object ("server", "Server", NULL,
				 BSE_TYPE_SERVER, SFI_PARAM_STANDARD);
}
BODY (BseProcedureClass *proc,
      const GValue      *in_values,
      GValue            *out_values)
{
  /* extract parameter values */
  BseServer *server = bse_value_get_object (in_values++);
  SfiWStore *wstore;
  gchar *file_name;
  GValue *value;
  SfiRec *rec;
  gint fd;
  
  /* check parameters */
  if (!BSE_IS_SERVER (server))
    return BSE_ERROR_PROC_PARAM_INVAL;
  
  file_name = g_strconcat (g_get_home_dir (), "/.bserc", NULL);
  fd = open (file_name,
	     O_WRONLY | O_CREAT | O_TRUNC, /* O_EXCL, */
	     0666);
  g_free (file_name);
  if (fd < 0)
    return BSE_ERROR_NONE;
  
  wstore = sfi_wstore_new ();
  sfi_wstore_printf (wstore, "; rc-file for BSE v%s\n", BSE_VERSION);
  
  /* store BseGConfig */
  sfi_wstore_puts (wstore, "\n; BseGConfig Dump\n");
  rec = bse_gconfig_to_rec (bse_global_config);
  value = sfi_value_rec (rec);
  sfi_wstore_put_param (wstore, value, bse_gconfig_pspec ());
  sfi_value_free (value);
  sfi_rec_unref (rec);
  sfi_wstore_puts (wstore, "\n");
  
  /* flush stuff to rc file */
  sfi_wstore_flush_fd (wstore, fd);
  sfi_wstore_destroy (wstore);
  close (fd);
  
  return BSE_ERROR_NONE;
}

METHOD (BseServer, start-recording) {
  HELP	= "Start recording to a WAV file.";
  IN	= bse_param_spec_object ("server", "Server", NULL,
				 BSE_TYPE_SERVER, SFI_PARAM_STANDARD);
  IN	= sfi_pspec_string ("wave-file", NULL, NULL, NULL, SFI_PARAM_STANDARD);
  IN    = sfi_pspec_real ("n_seconds", NULL, "Maximum number of recorded seconds",
			  0, 0, SFI_MAXNUM, 60, SFI_PARAM_STANDARD);
}
BODY (BseProcedureClass *proc,
      const GValue      *in_values,
      GValue            *out_values)
{
  /* extract parameter values */
  BseServer *server     = bse_value_get_object (in_values++);
  const char *wave_file = g_value_get_string (in_values++);
  double n_seconds      = g_value_get_double (in_values++);

  /* check parameters */
  if (!BSE_IS_SERVER (server))
    return BSE_ERROR_PROC_PARAM_INVAL;

  bse_server_start_recording (server, wave_file, n_seconds);
  return BSE_ERROR_NONE;
}

METHOD (BseServer, get-version) {
  HELP	= "Retrieve BSE version.";
  IN	= bse_param_spec_object ("server", "Server", NULL,
				 BSE_TYPE_SERVER, SFI_PARAM_STANDARD);
  OUT	= sfi_pspec_string ("version", NULL, NULL, NULL, SFI_PARAM_STANDARD);
}
BODY (BseProcedureClass *proc,
      const GValue      *in_values,
      GValue            *out_values)
{
  sfi_value_set_string (out_values++, BSE_VERSION);
  return BSE_ERROR_NONE;
}

METHOD (BseServer, get-demo-path) {
  HELP	= "Retrieve demo search path.";
  IN	= bse_param_spec_object ("server", "Server", NULL,
				 BSE_TYPE_SERVER, SFI_PARAM_STANDARD);
  OUT	= sfi_pspec_string ("path", NULL, NULL, NULL, SFI_PARAM_STANDARD);
}
BODY (BseProcedureClass *proc,
      const GValue      *in_values,
      GValue            *out_values)
{
  sfi_value_set_string (out_values++, BSE_PATH_DEMOS);
  return BSE_ERROR_NONE;
}

METHOD (BseServer, get-sample-path) {
  HELP	= "Retrieve sample search path.";
  IN	= bse_param_spec_object ("server", "Server", NULL,
				 BSE_TYPE_SERVER, SFI_PARAM_STANDARD);
  OUT	= sfi_pspec_string ("path", NULL, NULL, NULL, SFI_PARAM_STANDARD);
}
BODY (BseProcedureClass *proc,
      const GValue      *in_values,
      GValue            *out_values)
{
  sfi_value_take_string (out_values++, g_path_concat (BSE_PATH_SAMPLES, BSE_GCONFIG (sample_path), NULL));
  return BSE_ERROR_NONE;
}

METHOD (BseServer, get-custom-effect-dir) {
  HELP	= "Retrieve user specific effects directory.";
  IN	= bse_param_spec_object ("server", "Server", NULL,
				 BSE_TYPE_SERVER, SFI_PARAM_STANDARD);
  OUT	= sfi_pspec_string ("directory", NULL, NULL, NULL, SFI_PARAM_STANDARD);
}
BODY (BseProcedureClass *proc,
      const GValue      *in_values,
      GValue            *out_values)
{
  gchar **dirs = g_strsplit (BSE_GCONFIG (effect_path), G_SEARCHPATH_SEPARATOR_S, 2);
  sfi_value_set_string (out_values++, dirs[0]);
  g_strfreev (dirs);
  return BSE_ERROR_NONE;
}

METHOD (BseServer, get-effect-path) {
  HELP	= "Retrieve effect search path.";
  IN	= bse_param_spec_object ("server", "Server", NULL,
				 BSE_TYPE_SERVER, SFI_PARAM_STANDARD);
  OUT	= sfi_pspec_string ("path", NULL, NULL, NULL, SFI_PARAM_STANDARD);
}
BODY (BseProcedureClass *proc,
      const GValue      *in_values,
      GValue            *out_values)
{
  sfi_value_take_string (out_values++, g_path_concat (BSE_PATH_EFFECTS, BSE_GCONFIG (effect_path), NULL));
  return BSE_ERROR_NONE;
}

METHOD (BseServer, get-custom-instrument-dir) {
  HELP	= "Retrieve user specific instruments directory.";
  IN	= bse_param_spec_object ("server", "Server", NULL,
				 BSE_TYPE_SERVER, SFI_PARAM_STANDARD);
  OUT	= sfi_pspec_string ("directory", NULL, NULL, NULL, SFI_PARAM_STANDARD);
}
BODY (BseProcedureClass *proc,
      const GValue      *in_values,
      GValue            *out_values)
{
  gchar **dirs = g_strsplit (BSE_GCONFIG (instrument_path), G_SEARCHPATH_SEPARATOR_S, 2);
  sfi_value_set_string (out_values++, dirs[0]);
  g_strfreev (dirs);
  return BSE_ERROR_NONE;
}

METHOD (BseServer, get-instrument-path) {
  HELP	= "Retrieve instrument search path.";
  IN	= bse_param_spec_object ("server", "Server", NULL,
				 BSE_TYPE_SERVER, SFI_PARAM_STANDARD);
  OUT	= sfi_pspec_string ("path", NULL, NULL, NULL, SFI_PARAM_STANDARD);
}
BODY (BseProcedureClass *proc,
      const GValue      *in_values,
      GValue            *out_values)
{
  sfi_value_take_string (out_values++, g_path_concat (BSE_PATH_INSTRUMENTS, BSE_GCONFIG (instrument_path), NULL));
  return BSE_ERROR_NONE;
}

METHOD (BseServer, get-script-path) {
  HELP	= "Retrieve script search path.";
  IN	= bse_param_spec_object ("server", "Server", NULL,
				 BSE_TYPE_SERVER, SFI_PARAM_STANDARD);
  OUT	= sfi_pspec_string ("path", NULL, NULL, NULL, SFI_PARAM_STANDARD);
}
BODY (BseProcedureClass *proc,
      const GValue      *in_values,
      GValue            *out_values)
{
  sfi_value_take_string (out_values++, g_path_concat (BSE_PATH_SCRIPTS, BSE_GCONFIG (script_path), NULL));
  return BSE_ERROR_NONE;
}

METHOD (BseServer, get-plugin-path) {
  HELP	= "Retrieve plugin search path.";
  IN	= bse_param_spec_object ("server", "Server", NULL,
				 BSE_TYPE_SERVER, SFI_PARAM_STANDARD);
  OUT	= sfi_pspec_string ("path", NULL, NULL, NULL, SFI_PARAM_STANDARD);
}
BODY (BseProcedureClass *proc,
      const GValue      *in_values,
      GValue            *out_values)
{
  sfi_value_take_string (out_values++, g_path_concat (BSE_PATH_PLUGINS, BSE_GCONFIG (plugin_path), NULL));
  return BSE_ERROR_NONE;
}

METHOD (BseServer, get-ladspa-path) {
  HELP	= "Retrieve ladspa search path.";
  IN	= bse_param_spec_object ("server", "Server", NULL,
				 BSE_TYPE_SERVER, SFI_PARAM_STANDARD);
  OUT	= sfi_pspec_string ("path", NULL, NULL, NULL, SFI_PARAM_STANDARD);
}
BODY (BseProcedureClass *proc,
      const GValue      *in_values,
      GValue            *out_values)
{
  sfi_value_take_string (out_values++, g_path_concat (BSE_PATH_LADSPA, BSE_GCONFIG (ladspa_path), NULL));
  return BSE_ERROR_NONE;
}

#include "gslvorbis-enc.h"

METHOD (BseServer, get-vorbis-version) {
  HELP	= "Retrieve BSE Vorbis handler version.";
  IN	= bse_param_spec_object ("server", "Server", NULL,
				 BSE_TYPE_SERVER, SFI_PARAM_STANDARD);
  OUT	= sfi_pspec_string ("version", NULL, NULL, NULL, SFI_PARAM_STANDARD);
}
BODY (BseProcedureClass *proc,
      const GValue      *in_values,
      GValue            *out_values)
{
  gchar *v = gsl_vorbis_encoder_version();
  if (v && strncmp (v, "Xiphophorus libVorbis", 21) == 0)
    sfi_value_take_string (out_values++, g_strconcat ("Ogg/Vorbis", v + 21, NULL));
  else if (v && strncmp (v, "Xiph.Org libVorbis", 18) == 0)
    sfi_value_take_string (out_values++, g_strconcat ("Ogg/Vorbis", v + 18, NULL));
  else if (v)
    sfi_value_take_string (out_values++, g_strconcat ("Ogg/Vorbis ", v, NULL));
  g_free (v);
  return BSE_ERROR_NONE;
}

#include "gsldatahandle-mad.h"

METHOD (BseServer, get-mp3-version) {
  HELP	= "Retrieve BSE MP3 handler version.";
  IN	= bse_param_spec_object ("server", "Server", NULL,
				 BSE_TYPE_SERVER, SFI_PARAM_STANDARD);
  OUT	= sfi_pspec_string ("version", NULL, NULL, NULL, SFI_PARAM_STANDARD);
}
BODY (BseProcedureClass *proc,
      const GValue      *in_values,
      GValue            *out_values)
{
  const gchar *c = gsl_data_handle_mad_version ();
  if (c)
    sfi_value_take_string (out_values++, g_strconcat ("MAD ", c, NULL));
  return BSE_ERROR_NONE;
}