/* You need at least dot.conf 1.0.9 to compile and run this example !! */



#include <stdio.h>      /* fprintf(), stderr       */
#include <stdlib.h>     /* realloc()               */
#include <string.h>     /* strcmp()                */
/* this example does not work for WIN32 */

#ifndef WIN32
#include <dlfcn.h>      /* dlopen(), dlerror(), dlclose() */
#include <unistd.h>
#endif

#include <libpool.h>
#include <dotconf.h>

struct config_context {
   long                 current_context;
   char                 current_end_token[1024];

   pool_t *             pool;
};

struct ptr_list {
   int      n_entries;
   void **  entries;
};

static DOTCONF_CB(section_open);
static DOTCONF_CB(section_close);
static DOTCONF_CB(common_option);
static DOTCONF_CB(addmodule_option);

/*
// the last field is used to specify the context needed for
// each option. These will be checked at runtime by our contextchecker
//
*/
static const configoption_t options[] = {
   { "AddModule",       ARG_LIST,   addmodule_option, NULL, 0  },
   { "ToggleOption",    ARG_TOGGLE, common_option,    NULL, 0  },
   LAST_OPTION
};

/*
// The pointer list of dynamic options.
// This is necessary to be able to free it up later.
//
*/
struct ptr_list         memory_junk          ;

#define MAX_MODULES       10
static void *handles[MAX_MODULES];  /* handles of dynamically loaded modules */


const char *context_checker(command_t *cmd, unsigned long option_context) {
   struct config_context *context = cmd->context;

   if (context->current_context != option_context) {
      return pool_strcat(
               context->pool, "Option '", cmd->name, "' not allowed in <",
               (strlen(context->current_end_token)>2) ? context->current_end_token + 2 : "global>",
               " context", NULL);
   }

   return NULL;
}

FUNC_ERRORHANDLER(error_handler) {
   fprintf(
      stderr, "%s:%ld:[error] %s\n",
      configfile->filename, configfile->line, msg);

   /* continue reading the configfile ; return 1 stop after first error found */
   return 0;
}


int main(
   int                     argc,
   char *                  argv[]
)  {
   configfile_t *          configfile;
   struct config_context   context;

   if (argc < 2) {
      fprintf(stderr, "Usage : %s <configfile>\n", argv[0]);
      exit(1);
   }
   context.current_end_token[0]  =  '\0';
   context.current_context       =  0;
   context.pool                  =  pool_new(NULL);

   memory_junk.n_entries         =  0;
   memory_junk.entries           =  0;

   memset(handles, 0, sizeof(handles));

   configfile = dotconf_create(
                  argv[1], options, (void *)&context,
                  CASE_INSENSITIVE | DUPLICATE_OPTION_NAMES);
   if (!configfile) {
      fprintf(stderr, "Error opening configuration file\n");
      exit(1);
   }
   configfile->errorhandler   = (dotconf_errorhandler_t) error_handler;
   configfile->contextchecker = (dotconf_contextchecker_t) context_checker;

   if (dotconf_command_loop(configfile) == 0) {
      fprintf(stderr, "Error reading configuration file\n");
      exit(1);
   }

   dotconf_cleanup(configfile);
   pool_free(context.pool);

   /* clean up the possible memjunk which needed to stay in memory */
   if (memory_junk.n_entries) {
      int idx;
      for (idx = 0 ; idx < memory_junk.n_entries ; idx++) {
         free(memory_junk.entries[idx]);
      }
   }
   free(memory_junk.entries);

   return 0;
}


DOTCONF_CB(section_open) {
   struct config_context * context           = (struct config_context *)ctx;
   const char *            old_end_token     = context->current_end_token;
   int                     prev_context      = context->current_context;
   const char *            err               = 0;

   context->current_context = (long)cmd->option->info;
   sprintf(context->current_end_token, "</%s", cmd->name+1);

   while (!cmd->configfile->eof) {
      err = dotconf_command_loop_until_error(cmd->configfile);
      if (!err) {
         err = pool_strcat(context->pool, "</", cmd->name+1, " is missing", NULL);
         break;
      }

      if (err == context->current_end_token) {
         break;
      }
      dotconf_warning(cmd->configfile, DCLOG_ERR, 0, err);
   }

   sprintf(context->current_end_token, "%s", old_end_token);
   context->current_context = prev_context;

   if (err != context->current_end_token) {
      return err;
   }

   return NULL;
}

DOTCONF_CB(section_close) {
   struct config_context * context           = (struct config_context *)ctx;

   if (!context->current_end_token) {
      return pool_strcat(
         context->pool, cmd->name, " without matching <",
         cmd->name + 2, " section", NULL);
   }

   if (strcmp(context->current_end_token, cmd->name) != 0) {
      return pool_strcat(
         context->pool, "Expected '", context->current_end_token,
         "' but saw ", cmd->name, NULL);
   }

   return context->current_end_token;
}


DOTCONF_CB(common_option) {
   fprintf(stderr, "common_option : Option %s called  Not doing anything with it...\n", cmd->name);
   return NULL;
}

/*
// We expect  option     name  filename
//      e.g.  AddModule first ./plugins/decision-test.so
//
// So in the list :
//  0 -> name
//  1 -> so_filename
*/
DOTCONF_CB(addmodule_option) {
   struct config_context * context                 =  (struct config_context *)ctx;
   configoption_t *        module_options          ;
   const char *            error                   =  0;
   int                     handle_idx              =  -1;
   char                    filename[FILENAME_MAX]  =  "";
   void *                  shared_object           =  0;

   fprintf(stderr, "addmodule_option : Option %s called\n", cmd->name);
   if (cmd->arg_count < 2) {
      return pool_strcat(
               context->pool, "Not enough parameters to option ",
               cmd->name, " expected 2", NULL);
   }

   // load the damn thing
   for (handle_idx = 0; handle_idx < MAX_MODULES ; handle_idx++) {
      if (handles[handle_idx] == 0) {
         snprintf(filename, 128, "./%s.so", cmd->data.list[1]);
         if (access(filename, R_OK) == 0) /* if file access is permitted */
         {
            /* load library */
            handles[handle_idx] = dlopen(filename, RTLD_LAZY);
            if (!handles[handle_idx]) {
               fprintf(stderr, "Error opening library: %s\n", dlerror());
               return "Error opening library";
            }
            shared_object = handles[handle_idx];
            break;
         } else {
            return pool_strcat(context->pool, "Can't open file ", filename, NULL);
         }
      }
   }
   if (handle_idx == MAX_MODULES) {
      return "Out of handle space. Not loading module\n";
   }

   // get the options
   module_options = dlsym(shared_object, "options");
   error = dlerror();
   if (error) {
      fprintf(
         stderr,
         "addmodule_option() : Error finding the options variable in %s p=%p (%s)\n",
         cmd->data.list[1], shared_object, error);
      dlclose(shared_object);
      handles[handle_idx] = 0;
      return NULL;
   }


   /*
   // Scope the options of this module to a <NAME></NAME> block where NAME is
   // the name that was specified in the configfile.
   //
   // The context field holds a unique identifier so we can verify in our
   // contextchecker that this option belongs to the right scope.
   //
   */
   {
      char *            begin_context_tag    =  (char *)malloc(strlen(cmd->data.list[1]) + 2 + 1);
      char *            end_context_tag      =  (char *)malloc(strlen(cmd->data.list[1]) + 3 + 1);
      configoption_t *  scope_options        =  0;
      int               opt_idx              =  -1;

      scope_options = (configoption_t *)malloc(3*sizeof(configoption_t));
      if (!scope_options || !begin_context_tag || !end_context_tag) {
         return "Error allocating memory";
      }
      sprintf(begin_context_tag, "<%s>", cmd->data.list[0]);
      sprintf(end_context_tag, "</%s>", cmd->data.list[0]);

      // create our two extra options (scope begin/end) and a NULL option to close
      // the list
      scope_options[0].name      =  begin_context_tag;
      scope_options[0].type      =  ARG_NONE;
      scope_options[0].callback  =  section_open;
      scope_options[0].info      =  shared_object;
      scope_options[0].context   =  CTX_ALL;

      scope_options[1].name      =  end_context_tag;
      scope_options[1].type      =  ARG_NONE;
      scope_options[1].callback  =  section_close;
      scope_options[1].info      =  NULL;
      scope_options[1].context   =  (long)shared_object;

      scope_options[2].name      =  "";
      scope_options[2].type      =  0;
      scope_options[2].callback  =  NULL;
      scope_options[2].info      =  NULL;
      scope_options[2].context   =  0;

      /* Set the context field of all options from the module to the identifier */
      for (opt_idx = 0 ; strlen(module_options[opt_idx].name) ; opt_idx++) {
         module_options[opt_idx].context = (long)shared_object;
      }

      memory_junk.entries = realloc(
                              memory_junk.entries,
                              (memory_junk.n_entries + 3) * sizeof(void *));
      memory_junk.entries[memory_junk.n_entries++] = begin_context_tag;
      memory_junk.entries[memory_junk.n_entries++] = end_context_tag;
      memory_junk.entries[memory_junk.n_entries++] = scope_options;

      dotconf_register_options(cmd->configfile, scope_options);
      dotconf_register_options(cmd->configfile, module_options);
   }

   fprintf(
      stderr, "Successfully loaded module %s (%s)\n",
      cmd->data.list[1], cmd->data.list[1]);

   return NULL;
}