/*******************************************\
| * Ce programme est sous liscence GNU GPL  * |
| * This software is under GNU/GPL licence  * |
| * * * * * * * * * * * * * * * * * * * * * * |
| * http://www.gnu.org/copyleft/gpl.html    * |
 \*******************************************/

/* Cr er par Laurent Coustet <ed@zehome.com>
 * http://ed.zehome.com/                    
 * Made by Laurent Coustet <ed@zehome.com>
 */


#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/file.h>

#include "templates.h"
#include "debug.h"

#ifndef TPL_SYB
#define TPL_SYB "ø"
#endif

varval_st *tete_liste = NULL;

void parse_template (varval_st *_z_struct_varval, FILE *__out, char *__tpl_file)
{
  FILE *_tpl_opened_file;
  char *read_buffer;
  char *temp_buffer,*begin;
  char *var;
  int ok=0;

  int size=0;
  varval_st *zlist_move;

  if (( _tpl_opened_file = fopen (__tpl_file,"r"))==NULL)
    {
      printf("impossible d'ouvrir %s\n",__tpl_file);
      ERROR ("Impossible to open template file %s in read only.\n",__tpl_file);
      // exit (1);
      return;
    }
  else
    {

      fseek (_tpl_opened_file, 0, SEEK_END);
      size = ftell (_tpl_opened_file);
      fseek (_tpl_opened_file, 0, SEEK_SET);
      read_buffer =        (char *) malloc (sizeof (char) * size+1);
      temp_buffer =        (char *) malloc (sizeof (char) * size+1);
      begin       =        (char *) malloc (sizeof (char) * size+1);
      var         =        (char *) malloc (sizeof (char) * size+1);

      if (size > 100000)
  {
    ERROR ("Error: try to open a too big template: %s, size: %d\n",_tpl_opened_file,size);
    exit (1);
  }

      fread (read_buffer, sizeof (char), size, _tpl_opened_file);

      if ( strstr (read_buffer,TPL_SYB) != NULL )
  {
    strcpy (begin, read_buffer);
    strtok (begin, TPL_SYB);
    while (( temp_buffer = strstr (read_buffer,TPL_SYB)) != NULL )
      {
        //VERBOSE ("begining of the string: %s\n",begin);
        fprintf (__out,begin);
        strncpy (var,temp_buffer,strlen(read_buffer));
        if (strtok (var, TPL_SYB)==NULL)
    break;

        //VERBOSE ("var: %s\n",var);

        for (zlist_move=_z_struct_varval;zlist_move!=NULL;zlist_move=zlist_move->next)
    {
      if ((strcmp ((var+strlen(TPL_SYB)),zlist_move->_tpl_var))==0)
        {
          fprintf (__out,"%s",zlist_move->_tpl_val);
          ok=1;
          break;
        }
      else
        {
          ok=0;
          // VERBOSE ("NotAVal: %s\n",var);
        }
    }
        if (ok == 0)
    {
      fprintf (__out,"[UnknowVar]");
    }

        if ( ((strlen(temp_buffer)) - (strlen(TPL_SYB)*2) - (strlen(var))) < 0)
    {
      fprintf (__out,temp_buffer);
      break;
    }
        read_buffer += strlen(begin) + strlen(TPL_SYB) + strlen(var);
        strcpy (begin, read_buffer);
        strtok (begin, TPL_SYB);
      }
    if (strlen(read_buffer) > 0)
      {
        fprintf (__out,read_buffer);
      }
  }
      else
  {
    fprintf (__out,read_buffer);
  }

      fclose (_tpl_opened_file);
    }

  return;
}

/* retourne un pointeur vers une le prochain élément de la liste. */
varval_st *add_tpl_value (varval_st *_z_struct_varval, char *__tpl_var, char *__tpl_val)
{
  varval_st *new_node;
  varval_st *new_node_moving;
  if ((new_node = malloc(sizeof(varval_st)))==NULL)
    {
      ERROR ("Malloc structure FAILED EXITING.\n");
      exit (1);
    }
  /* on ajoute les éléments dans la structure...*/
  new_node->_tpl_var = __tpl_var;
  new_node->_tpl_val = __tpl_val;

  /* on est le dernier maillon. */
  new_node->next = NULL;

  if (_z_struct_varval == NULL)
    { /* la liste etait vide, on devient le premier element */
      return (new_node);
    }
  else
    {
      for (new_node_moving=_z_struct_varval;new_node_moving->next!=NULL;new_node_moving=new_node_moving->next);
      /* le dernier element pointe maitenant sur le nouvel element */
      new_node_moving->next = new_node;
      return (_z_struct_varval);
    }
}

varval_st *del_tpl_var (varval_st *list, char *_var)
{
  varval_st *zlist_move;
  varval_st *zlist_move_prev;
  varval_st *zlist_tmp;

  zlist_move_prev = NULL;
  for(zlist_move=list;(zlist_move!=NULL) && (zlist_move->_tpl_var!=_var);
      zlist_move_prev=zlist_move,zlist_move=zlist_move->next);

  if (zlist_move == NULL)
    {
      return (list);
    }
  else
    {
      if (zlist_move_prev == NULL)
  {
    zlist_tmp = zlist_move->next;
    free (zlist_move);
    return (zlist_tmp);
  }
      else
  {
    zlist_move_prev->next = zlist_move->next;
    free (zlist_move);
    return (list);
  }
    }
}