/***********************************************************************/
/* clause generation called from parser to generate credential clauses */
/***********************************************************************/
#include <stdio.h>
#include <assert.h>
#include <stdlib.h>

#include "abac_set.h"
#include "abac_util.h"
#include "abac_pl.h"

#include "uthash.h"

// index to generate C1,C2..
static int cred_count=0;
extern char* abac_yyfptr_encoded;
extern int abac_cnt_yy_id_certs();
extern void abac_free_yy_id_certs();
extern char *abac_string_yy_id_certs();
char *abac_addon_clauses=NULL;

/***********************************************************************/
static int _get_next_cred_idx()
{
    cred_count++;
    return cred_count;
}

/* remember to free the returned string */
static char *_compose_cred_list()
{
    int i=cred_count;
    if(cred_count==0) return "";

    char *clist=(char *)abac_xmalloc(sizeof(char)*(cred_count)*3);
    strcpy(clist,"C1");
    if (cred_count==1) return clist;

    i=1;
    while(i!=cred_count) {
        i++;
        sprintf(clist,"%s,C%d",clist,i);
    }
    return clist;
}

/* generate role(p_name, r_name, param..) */
static char* generate_pl_head_role_string(abac_role_t *role)
{
     char *tmp=NULL;
     char *principalname=abac_role_principal_cn(role);
     char *rolename=abac_role_role_name(role);
     char *param_string=NULL;
     int cnt=0;

     /* can not be a linked role */
     abac_param_list_t *role_params=abac_role_role_params(role);
     if(role_params) {
        param_string=abac_param_list_string(role_params);
     }

     if (param_string != NULL) {
         cnt=asprintf(&tmp,"role(%s,%s,%s)", principalname, rolename, param_string);
         free(param_string);
         } else {
             cnt=asprintf(&tmp,"role(%s,%s)", principalname, rolename);
     }
     if(cnt>0)
        return tmp;
        else
           return NULL;
}

/* generate role(p_name, r_name, param..) with isMember call ?? */
static char* generate_pl_tail_role_string(abac_role_t *role)
{
     char *tmp;
     char *principalname=abac_role_principal_cn(role);
     char *rolename=abac_role_role_name(role);
     char *linkedname=abac_role_linked_role(role);

     char *param_string=NULL;
     char *linked_param_string=NULL;
     int cnt=0;

     abac_param_list_t *role_params=abac_role_role_params(role);
     if(role_params) {
        param_string=abac_param_list_string(role_params);
     }

     abac_param_list_t *linked_role_params=abac_role_linked_role_params(role);
     if(linked_role_params) {
        linked_param_string=abac_param_list_string(linked_role_params);
     }

     /* b.r.r */
     if(linkedname!=NULL && rolename!=NULL && principalname!=NULL ) {
         int fst=_get_next_cred_idx();
         int snd=_get_next_cred_idx();
         if(linked_param_string !=NULL) {
             if (param_string != NULL) {
                 cnt=asprintf(&tmp,"isMember(Y,role(%s,%s,%s),C%d),isMember(X,role(Y,%s,%s),C%d)",
                            principalname,
                            linkedname,linked_param_string,fst,
                            rolename,param_string,snd);
                 free(param_string);
                 } else {
                     cnt=asprintf(&tmp,"isMember(Y,role(%s,%s,%s),C%d),isMember(X,role(Y,%s),C%d)",
                            principalname,
                            linkedname,linked_param_string,fst,
                            rolename,snd);
             }
             free(linked_param_string);
             } else {
                 if (role_params != NULL) {
                     cnt=asprintf(&tmp,"isMember(Y,role(%s,%s),C%d),isMember(X,role(Y,%s,%s),C%d)",
                            principalname,
                            linkedname,fst,
                            rolename,param_string,snd);
                     free(param_string);
                     } else {
                         cnt=asprintf(&tmp,"isMember(Y,role(%s,%s),C%d),isMember(X,role(Y,%s),C%d)",
                            principalname,
                            linkedname,fst,
                            rolename,snd);
               }
         }
         if(cnt>0)
             return tmp;
             else
                 return NULL;
     } 
     /* b.r */
     if(linkedname==NULL && rolename!=NULL && principalname!=NULL ) {
         int fst=_get_next_cred_idx();
         if(param_string != NULL) {
             cnt=asprintf(&tmp,"isMember(X,role(%s,%s,%s),C%d)",
                          principalname, rolename, param_string, fst);
             free(param_string);
             } else {
                 cnt=asprintf(&tmp,"isMember(X,role(%s,%s),C%d)",
                          principalname, rolename, fst);
         }
         if(cnt>0)
             return tmp;
             else
                 return NULL;
     } 
     /* b */
     if(linkedname==NULL && rolename==NULL && principalname!=NULL ) {
         tmp=abac_xstrdup(principalname);
         return tmp;
     } 

     return tmp;
}


/* generate oset(p_name, r_name, param..) */
static char* generate_pl_head_oset_string(abac_oset_t *oset)
{
     char *tmp=NULL;
     char *principalname=abac_oset_principal_cn(oset);
     char *osetname=abac_oset_oset_name(oset);
     char *param_string=NULL;
     int cnt=0;

     /* can not be a linked role */
     abac_param_list_t *oset_params=abac_oset_oset_params(oset);
     if(oset_params) {
        param_string=abac_param_list_string(oset_params);
     }

     if (param_string != NULL) {
         cnt=asprintf(&tmp,"oset(%s,%s,%s)", principalname, osetname, param_string);
         free(param_string);
         } else {
             cnt=asprintf(&tmp,"oset(%s,%s)", principalname, osetname);
     }
     if(cnt>0)
        return tmp;
        else
           return NULL;
}

/* generate oset(p_name, r_name, param..) with isMember call ?? */
static char* generate_pl_tail_oset_string(abac_oset_t *oset)
{
     char *tmp;
/*
   A.oset <- B
   A.oset <- Obj
   A.oset <- B.oset
   A.oset <- B.role.oset
*/
     /* o */
     if(abac_oset_is_object(oset)) {
         char *objectname=abac_oset_object_cn(oset);
         tmp=abac_xstrdup(objectname);
         return tmp;
     } else {
         char *principalname=abac_oset_principal_cn(oset);
         char *osetname=abac_oset_oset_name(oset);
         char *linkedname=abac_oset_linked_role(oset);

         char *param_string=NULL;
         char *linked_param_string=NULL;
         int cnt=0;

         abac_param_list_t *oset_params=abac_oset_oset_params(oset);
         if(oset_params) {
             param_string=abac_param_list_string(oset_params);
         }

         abac_param_list_t *linked_role_params=abac_oset_linked_role_params(oset);
         if(linked_role_params) {
             linked_param_string=abac_param_list_string(linked_role_params);
         }

         /* b.r.r */
         if(linkedname!=NULL && osetname!=NULL && principalname!=NULL ) {
             int fst=_get_next_cred_idx();
             int snd=_get_next_cred_idx();
             if(linked_param_string !=NULL) {
                 if (param_string != NULL) {
                     cnt=asprintf(&tmp,"isMember(Y,role(%s,%s,%s),C%d),isMember(X,oset(Y,%s,%s),C%d)",
                                principalname,
                                linkedname,linked_param_string,fst,
                                osetname,param_string,snd);
                     free(param_string);
                     } else {
                         cnt=asprintf(&tmp,"isMember(Y,role(%s,%s,%s),C%d),isMember(X,oset(Y,%s),C%d)",
                                principalname,
                                linkedname,linked_param_string,fst,
                                osetname,snd);
                 }
                 free(linked_param_string);
                 } else {
                     if (oset_params != NULL) {
                         cnt=asprintf(&tmp,"isMember(Y,role(%s,%s),C%d),isMember(X,oset(Y,%s,%s),C%d)",
                                principalname,
                                linkedname,fst,
                                osetname,param_string,snd);
                         free(param_string);
                         } else {
                             cnt=asprintf(&tmp,"isMember(Y,role(%s,%s),C%d),isMember(X,oset(Y,%s),C%d)",
                                principalname,
                                linkedname,fst,
                                osetname,snd);
                   }
             }
             if(cnt>0)
                 return tmp;
                 else
                     return NULL;
         } 
         /* b.r */
         if(linkedname==NULL && osetname!=NULL && principalname!=NULL ) {
             int fst=_get_next_cred_idx();
             if(param_string != NULL) {
                 cnt=asprintf(&tmp,"isMember(X,oset(%s,%s,%s),C%d)",
                              principalname, osetname, param_string, fst);
                 free(param_string);
                 } else {
                     cnt=asprintf(&tmp,"isMember(X,oset(%s,%s),C%d)",
                              principalname, osetname, fst);
             }
             if(cnt>0)
                 return tmp;
                 else
                     return NULL;
         } 
         /* b */
         if(linkedname==NULL && osetname==NULL && principalname!=NULL ) {
             tmp=abac_xstrdup(principalname);
             return tmp;
         } 

    }
    return tmp;
}


/********************************************************************************/

static char *_build_constraint_rule_clause(char *head_string, char *tail_string)
{
    /*only,  A.R <- B */
    char *tmp;
    int idx=_get_next_cred_idx();
    asprintf(&tmp, "isMember(%s,%s,C%d)", tail_string,head_string,idx);
    return tmp;
}

static char *_build_rule_clause(char *rolename, char *head_string, char *tail_string)
{
    char *tmp=NULL;

    if(rolename == NULL) {
        /* A.R <- B */
        if(abac_addon_clauses==NULL) {
            asprintf(&tmp, "isMember(%s,%s,['%s'])",
                     tail_string,head_string,abac_yyfptr_encoded);
            } else {
                asprintf(&tmp, "isMember(%s,%s,['%s']) :- %s",
                     tail_string,head_string,abac_yyfptr_encoded,
                     abac_addon_clauses);
                free(abac_addon_clauses);
                abac_addon_clauses=NULL;
        }
        } else {
             /* A.R <- B.R */
             /* A.R <- B.R.R */
             if (cred_count==0) {
                 if(abac_addon_clauses==NULL) {
                     asprintf(&tmp,"isMember(X,%s,['%s']):-%s",
                           head_string, abac_yyfptr_encoded, tail_string);
                     } else {
                         asprintf(&tmp,"isMember(X,%s,['%s']):-%s, %s",
                                 head_string, abac_yyfptr_encoded,
                                 tail_string,abac_addon_clauses);
                         free(abac_addon_clauses);
                         abac_addon_clauses=NULL;
                 }
                 } else {
                     char *tmp_cred_list=_compose_cred_list();
                     if(abac_addon_clauses == NULL) {
                         asprintf(&tmp,"isMember(X,%s,L):-%s, appendL([['%s'],%s],L)",
                                  head_string, tail_string,
                                  abac_yyfptr_encoded, tmp_cred_list);
                         } else {
                             asprintf(&tmp,"isMember(X,%s,L):-%s, %s, appendL([['%s'],%s],L)",
                                  head_string, tail_string, abac_addon_clauses,
                                  abac_yyfptr_encoded, tmp_cred_list);
                             free(abac_addon_clauses);
                             abac_addon_clauses=NULL;
                     }
                     free(tmp_cred_list);
                     cred_count=0;
             }
    }
    return tmp;
}


static char *generate_pl_rule_role_clause(char *head_role_string, abac_role_t *tail_role)
{
    char *rolename=abac_role_role_name(tail_role);
    char *tail_role_string=generate_pl_tail_role_string(tail_role);
    if(rolename == NULL && tail_role_string == NULL) 
        goto error;
    char *tmp=_build_rule_clause(rolename,head_role_string, tail_role_string);
    if(tail_role_string) free(tail_role_string);
    return tmp;

error:
    if(tail_role_string) free(tail_role_string);
    return NULL;
}

static char *generate_pl_rule_oset_clause(char *head_oset_string, abac_oset_t *tail_oset)
{
    char *osetname=abac_oset_oset_name(tail_oset);
    char *tail_oset_string=generate_pl_tail_oset_string(tail_oset);
    if(osetname == NULL && tail_oset_string == NULL) 
        goto error;
    char *tmp=_build_rule_clause(osetname,head_oset_string, tail_oset_string);
    if(tail_oset_string) free(tail_oset_string);
    return tmp;

error:
    if(tail_oset_string) free(tail_oset_string);
    return NULL;
}


static char *_add_string(char *dstr, char *nstr)
{
    if(strlen(dstr)==0) {
        dstr=abac_xstrdup(nstr);
        return dstr;
        } else { 
            int len = strlen(dstr)+strlen(nstr)+2;
            char *tmp=abac_xmalloc(len*sizeof(char));
            sprintf(tmp,"%s,%s", dstr,nstr);
            free(dstr);
            return tmp;
    }
    return NULL;
}

static char *_build_intersecting_clause(char *head_role_string, char *tail_role_string)
{
    char *tmp;

    if (cred_count==0) {
        if(abac_addon_clauses ==NULL) {
            asprintf(&tmp,"isMember(X,%s,['%s']):-%s",
                   head_role_string, abac_yyfptr_encoded, tail_role_string);
            } else {
                asprintf(&tmp,"isMember(X,%s,['%s']):-%s, %s",
                       head_role_string, abac_yyfptr_encoded, 
                       tail_role_string, abac_addon_clauses);
                free(abac_addon_clauses);
                abac_addon_clauses=NULL;
        }
        } else {
            char *tmp_cred_list=_compose_cred_list();
            if(abac_addon_clauses ==NULL) {
                asprintf(&tmp,"isMember(X,%s,L):-%s, appendL([['%s'],%s],L)",
                                head_role_string, tail_role_string,
                                abac_yyfptr_encoded, tmp_cred_list);
                } else {
                    asprintf(&tmp,"isMember(X,%s,L):-%s, %s, appendL([['%s'],%s],L)",
                                head_role_string, tail_role_string, abac_addon_clauses,
                                abac_yyfptr_encoded, tmp_cred_list);
                    free(abac_addon_clauses);
                    abac_addon_clauses=NULL;
            }
            free(tmp_cred_list);
            cred_count=0;
    }
    return tmp;
}

static char *generate_pl_intersecting_role_clause(char *head_role_string, abac_role_t *tail_role)
{
    char *tmp=NULL;
    char* tail_role_string=NULL;
    abac_list_t *list=abac_role_prereqs(tail_role);
    /* A.R <- B.R & C.R.R */

    if (list != NULL) {
        abac_role_t *cur;
        abac_list_foreach(list, cur,
            char *ntmp=generate_pl_tail_role_string(cur);
            if(tail_role_string==NULL)
                 asprintf(&tail_role_string,"%s",ntmp);
                 else
                    asprintf(&tail_role_string,"%s, %s",tail_role_string,ntmp);
            free(ntmp);
        );
    }

    tmp=_build_intersecting_clause(head_role_string, tail_role_string);
    if(tail_role_string) free(tail_role_string);
    return tmp;
}

static char *generate_pl_intersecting_oset_clause(char *head_oset_string, abac_oset_t *tail_oset)
{
    char *tmp=NULL;
    char* tail_oset_string=NULL;
    abac_list_t *list=abac_oset_prereqs(tail_oset);
    /* A.O <- B.O & C.R.O */

    if (list != NULL) {
        abac_oset_t *cur;
        abac_list_foreach(list, cur,
            char *ntmp=generate_pl_tail_oset_string(cur);
            if(tail_oset_string==NULL)
                 asprintf(&tail_oset_string,"%s",ntmp);
                 else
                    asprintf(&tail_oset_string,"%s, %s",tail_oset_string,ntmp);
            free(ntmp);
        );
    }

    tmp=_build_intersecting_clause(head_oset_string, tail_oset_string);
    if(tail_oset_string) free(tail_oset_string);
    return tmp;
}

/* generate the yap isMember rule clause for the credential stmt */
abac_list_t *generate_pl_role_clauses(abac_role_t *head_role, abac_role_t *tail_role)
{
   char *tmp=NULL;
   abac_list_t *clauses=abac_list_new();
  
   int cnt=abac_cnt_yy_id_certs();
   if(cnt > 0) { /* string it up */
       //abac_addon_clauses=abac_string_yy_id_certs();
       tmp=abac_string_yy_id_certs();
       abac_free_yy_id_certs();
   }

   cnt=abac_cnt_yy_constraints();
   if(cnt > 0) {
      char *ntmp=abac_string_yy_constraints();
      abac_free_yy_constraints();
      if(tmp)
          asprintf(&tmp,"%s,%s",tmp,ntmp);
          else tmp=ntmp;
   }
   abac_addon_clauses=tmp; 

/* generate head's role string */
    char *head_role_string=generate_pl_head_role_string(head_role);
    if(head_role_string == NULL)
        goto error;

/* tail side */
    if(abac_role_is_intersection(tail_role)) {
       tmp=generate_pl_intersecting_role_clause(head_role_string, tail_role);
       } else {
           tmp=generate_pl_rule_role_clause(head_role_string, tail_role);
    }
    if(tmp==NULL)
        goto error;
 
    abac_list_add(clauses,tmp);
    return clauses;

error:
    if(head_role_string) free(head_role_string);
    return clauses;
}

abac_list_t *generate_pl_oset_clauses(abac_oset_t *head_oset, abac_oset_t *tail_oset)
{
   char *tmp=NULL;
   abac_list_t *clauses=abac_list_new();

   int cnt=abac_cnt_yy_id_certs();
   if(cnt > 0) { /* string it up */
       tmp=abac_string_yy_id_certs();
       abac_free_yy_id_certs();
   }

   cnt=abac_cnt_yy_constraints();
   if(cnt > 0) {
      char *ntmp=abac_string_yy_constraints();
      abac_free_yy_constraints();
      if(tmp)
          asprintf(&tmp,"%s,%s",tmp,ntmp);
          else tmp=ntmp;
   }
   abac_addon_clauses=tmp; 

/* generate head's oset string */
    char *head_oset_string=generate_pl_head_oset_string(head_oset);
    if(head_oset_string == NULL)
        goto error;
    
/* tail side */
    if(abac_oset_is_intersection(tail_oset)) {
       tmp=generate_pl_intersecting_oset_clause(head_oset_string, tail_oset);
       } else {
           tmp=generate_pl_rule_oset_clause(head_oset_string, tail_oset);
    }
    if(tmp==NULL)
        goto error;

    abac_list_add(clauses,tmp);
    return clauses;

error:
    if(head_oset_string) free(head_oset_string);
    return clauses;
}

/* should be just 1 */
char *generate_pl_role_constraint_clause(abac_role_t *head_role, char *tail_string)
{
/* generate head's role string */
    char *head_role_string=generate_pl_head_role_string(head_role);
    if(head_role_string == NULL)
        goto error;

/* tail side */
    char *tmp=_build_constraint_rule_clause(head_role_string, tail_string);
    if(tmp==NULL)
        goto error;

    return tmp;

error:
    if(head_role_string) free(head_role_string);
    return NULL;
}



/* so far, for integer type only */
char *generate_pl_range_constraint_clause(char *typestr,char *var,char *val,char *op)
{
   char *tmp=NULL;
   asprintf(&tmp,"%s(%s)%s%s",typestr,var,op,val);
   return tmp;
}

/* should just be 1 clause */
char *generate_pl_oset_constraint_clause(abac_oset_t *head_oset,
char *tail_string)
{
/* generate head's oset string */
    char *head_oset_string=generate_pl_head_oset_string(head_oset);
    if(head_oset_string == NULL)
        goto error;

/* tail side */
    char *tmp=_build_constraint_rule_clause(head_oset_string, tail_string);
    if(tmp==NULL)
        goto error;

    return tmp;
error:
    if(head_oset_string) free(head_oset_string);
    return NULL;
}


/* generate the yap isType rule clause for the type,
   isType(Acme, keyid); */
char *generate_pl_type_clause(char *principalname, int type)
{
    char *tmp=NULL;
    char *typeid= abac_keyid_type(type);
    int cnt=asprintf(&tmp,"isType(%s,%s)",
                                principalname, typeid);
    return tmp;
}