#include "structures.h"
struct clause *exp_det(module_ptr agent,
		       struct term *top_atom, struct term *atom, 
		       struct list *sofar,
		       struct clause *base, 
		       struct clause *recursive,
		       var_array *vars,garbage_lists *g);

struct clause *expand(module_ptr agent,
                      struct term *atom,
		      var_array *vars)
{
 struct list *cl_list=
   agent->clause_head_table[atom->functor];
 garbage_lists g;
 struct clause *result;
 if (cl_list==NULL)
 {
    printf("Error: no clause for recursion expansion");
    return NULL;
 }
 garbage_init(&g);
 result=exp_det(agent,
                atom,
                atom,
                NULL,
                cl_list->object,
                cl_list->next->object,
                vars,
                &g);
 collect(g);
 return result;
}
  
struct clause *exp_det(module_ptr agent,
		       struct term *top_atom,
                       struct term *atom, 
		       struct list *sofar,
		       struct clause *base, 
		       struct clause *recursive,
		       var_array *vars,
                       garbage_lists *g)

{
  int unification_status;
  var_array *local_base_vars;
  struct clause *local_base_cl;
  local_base_cl=offset_copy_clause(base,vars->length);
  local_base_vars=create_vars(vars->length+base->var_counter);
  g->garbage_vars=cons(local_base_vars,g->garbage_vars);
  g->garbage_clauses=cons(local_base_cl,g->garbage_clauses);
  copy_vars(vars,local_base_vars);
  unification_status=unify(atom,
			   local_base_cl->head,
			   local_base_vars);
  if (unification_status==SUCCESS)
    {
      struct clause *result;
      struct list *var_seq;
      int i;
      int l=list_length(sofar);
      result=(struct clause *)malloc(sizeof(struct clause));
      result->body=
	(struct term **)calloc(l,sizeof(struct term *));
      result->head=dereference(top_atom,local_base_vars);
      var_seq=var_sequence(result->head,g);
      replace_vars(result->head,var_seq);
      for(i=0;i<l;i++)
	{
	  result->body[i]=
	    dereference(((struct term *)sofar->object),
			local_base_vars);
	  replace_vars(result->body[i],var_seq);
	  sofar=sofar->next;
	}
      result->body_size=l;
      result->var_counter=list_length(var_seq);
      return result;
    }
  else
    {
      var_array *local_rec_vars;
      struct clause *local_rec_cl;
      local_rec_vars=create_vars(vars->length+recursive->
				 var_counter);
      local_rec_cl=offset_copy_clause(recursive,vars->length);
      g->garbage_vars=cons(local_rec_vars,g->garbage_vars);
      g->garbage_clauses=cons(local_rec_cl,g->garbage_clauses);
      copy_vars(vars,local_rec_vars);
      unification_status=unify(atom,
			       local_rec_cl->head,
			       local_rec_vars);
      if (unification_status==SUCCESS)
	{
	  return exp_det(agent,top_atom,local_rec_cl->body[1],
			g_cons(local_rec_cl->body[0],sofar,g),
			base,recursive,local_rec_vars,g);
	}
      else return NULL;
    }
}