#include "structures.h"
#include "AOPcomm.h"
#include "network.h"
#include <string.h>
extern SystemActionDescriptor action_preds[];
extern int ActionCount;
/*
============================================================
|                    GetSysActionDescriptor()                 |
|----------------------------------------------------------|
| Params : 1)a functor                                     |
|                                                          |
| Returns: The pointer to the descriptor of the action     |
|          predicate, if functor is an action predicate.   |
|          NULL otherwise                                  |
|==========================================================|
*/
SystemActionDescriptor *
GetSysActionDescriptor(int functor)
{
   int k,i=0,j=ActionCount;
   SystemActionDescriptor *res=NULL;
   while(j-i>0 && res==NULL)
   {
      k=i+(j-i)/2;
      if(action_preds[k].functor==functor)
         res=&action_preds[k];
      else if (action_preds[k].functor<functor)
         i=k+1;
      else
         j=k;
   }
   return res;
}


void process_action(struct agent_term *action);

void process_actions()
{
  struct agent_term *action=next_action();
  while(action)
    {
      process_action(action);
      free(action);
      action=next_action();
    }
}

void process_action(struct agent_term *action)
{
   SystemActionDescriptor *f_dis=
      GetSysActionDescriptor(action->term->functor);
   (f_dis->funct)(action->agent,action->term);
}

extern int message_trace;
extern int justify_trace;
extern void stabilize();
extern void unrequest_goal(struct proposition *p);
extern int identical(struct term *t1, struct term *t2);

extern int just_high;

void *send_message(int message_type, 
		   int recepient, 
		   int sender,
		   struct term *content)
{
   int functor;
   struct proposition *message;
   struct term **args;
   int strip_user(int);
   void dump_justification(void);
   if (message_trace)
   {
      printf("message from %s to %s\n",sym_table[sender]->name,
             sym_table[recepient]->name);
      printf("message type: %s\ncontent:",sym_table[message_type]);
      print_term(content,sym_table);
      printf("\n");
   }

   if(sym_table[recepient]->agent_ref != NULL)
   {
      /* My agent. */
      just_high=0;
      switch (message_type)
      {
      case INFORM:
         args=maketermarray(3);
         args[0]=maketerm(INTEGER,time(NULL),0,NULL,NULL);
         args[1]=maketerm(NONVAR,sender,0,NULL,NULL);
         args[2]=content;
         message=get_prop(sym_table[recepient]->agent_ref,
                          maketerm(NONVAR,ASSIMILATE, 3,NULL,args),
                          'I',
                          NON_ACTION);
         free(args[0]);
         free(args[1]);
         free(args);
         back_chain(message);
         make_fact(message);
         stabilize();
         break;
      case REQUEST:
         args=maketermarray(3);
         args[0]=maketerm(INTEGER,time(NULL),0,NULL,NULL);
         args[1]=maketerm(NONVAR,sender,0,NULL,NULL);
         args[2]=content;
         message=get_prop(sym_table[recepient]->agent_ref,
                          maketerm(NONVAR,COMPLY, 3,NULL,args),
                          'N',
                          NON_ACTION);
         free(args[0]);
         free(args[1]);
         free(args);
         back_chain(message);
         make_goal(message);
         stabilize();
         break;
      case B_INFORM:
         args=maketermarray(2);
         args[0]=maketerm(NONVAR,sender,0,NULL,NULL);
         args[1]=content;
         message=get_prop(sym_table[recepient]->agent_ref,
                          maketerm(NONVAR,B_ASSIMILATE, 2,NULL,args),
                          'I',
                          NON_ACTION);
         free(args[0]);
         free(args);
         back_chain(message);
         make_fact(message);
         stabilize();
         break;
      case B_REQUEST:
         args=maketermarray(2);
         args[0]=maketerm(NONVAR,sender,0,NULL,NULL);
         args[1]=content;
         message=get_prop(sym_table[recepient]->agent_ref,
                          maketerm(NONVAR,B_COMPLY, 2,NULL,args),
                          'N',
                          NON_ACTION);
         free(args[0]);
         free(args);
         back_chain(message);
         make_goal(message);
         stabilize();
         break;
      case UNREQUEST:
         {
            struct list *potentials;
            struct proposition *prop;
            potentials=
               sym_table[recepient]->agent_ref->prop_table[COMPLY];
            while (potentials)
            {
               prop=potentials->object;
               if (prop->term->argument_array[1]->functor==sender&&
                   identical(prop->term->argument_array[2],content))
               {
                  unrequest_goal(prop);
                  stabilize();
               }
               potentials=potentials->next;
            }
            potentials=
               sym_table[recepient]->agent_ref->prop_table[B_COMPLY];
            while (potentials)
            {
               prop=potentials->object;
               if (prop->term->argument_array[0]->functor==sender&&
                   identical(prop->term->argument_array[1],content))
               {
                  unrequest_goal(prop);
                  stabilize();
               }
               potentials=potentials->next;
            }
         }
         break;
      }
      if (justify_trace)
         dump_justifications();
   }
   else {
      /* External agent. */
      /* Resolve agent, user, machine */
      full_address *addr;

      addr = resolveAgentAddress(sym_table[recepient]->name);
      if(addr == NULL) {
         /* Can not resolve the agent address. */
      }
      else {
         char *term_string;
         term_ptr temp_term;

         args=maketermarray(2);
         args[0]=maketerm(STRING,0,0,addr->agent,NULL);
         args[1]=content;
         temp_term=maketerm(NONVAR,message_type,2,NULL,args);

         term_string = TermToString(temp_term);
         sendNetMessage(PACKET_TYPE_MESSAGE,
                        sym_table[sender]->name,
                        addr->machine, addr->user, addr->agent,
                        term_string, strlen(term_string)+1);
         /* Garbage colection. */
         free(addr->agent);
         free(addr);
         free_term(temp_term);
         free(term_string);
      }
   }
}

void send_initialize_message(void)
{
   term_ptr message=term_template("n");
   message->functor=INITIAL;
   send_message(INFORM,AGENT_INIT,INITIAL,message);
}

/* the main loop of the interpreter */  
void dispatch_loop()
{
  while (TRUE) 
    {
       time_trim();
       process_actions();
       getInterpreterEvent();   
    }
}

extern char *user_name;

int strip_user(int alias)
{
  int functor_string(char *string);
  char *copy_string(char *);
  char *position;
  char *stripped;
  int result;
  char *c_alias=sym_table[alias]->name;
  position=strchr(c_alias,'@');
  if (position==NULL)
    return alias;
  
  position++;
  if (strcmp(position,user_name)!=0)
    return alias;
  
  stripped=copy_string(c_alias);
  *(strchr(stripped,'@'))='\0';
  result= functor_string(stripped);
  free(stripped);
  if (result==-1) return alias;
  else return result;
}