//-------------------------------------------------------------------------------------------------
//Lite_C event Control
//by: frankJiang
//
#ifndef _LStackNode_H
#define _LStackNode_H
#define DataType int
#define T LStackNode
typedef struct node{
    DataType data;
    struct node *next;
}T;
void InitLinkStack(T *top);
int LinkStackEmpty(T* top);
int PushLinkStack(T* top, DataType e);
int PopLinkStack(T* top,DataType *e);
int LinkStackLength(T* top);
void DestroyStack(T* top);
int GetTop(T* top,DataType *e);
//------------------------------------------------------------------------------
void InitLinkStack(T *top){
        T n;
        if((top=malloc(sizeof(n)))==NULL)
                return;
        top.next=NULL;
}
int LinkStackEmpty(T* top){
        if(top.next==NULL)                               
        return 1;                                        
        else
                return 0;
}

int PushLinkStack(T* top, DataType e){
        T *p;
        T n;
        if((p=malloc(sizeof(n)))==NULL){
                
                return -1;
        }
        p.data=e;
        p.next=top.next;
        top.next=p;
        return 1;
}
int PopLinkStack(T* top,DataType *e){
        T* p;
        p=top.next;
        if(!p){
               
                return 0;
        }
        top->next=p->next;                                
        *e=p.data;
        free(p);
        return 1;
}

int LinkStackLength(T* top){
    T *p;
    int count=0;
    p=top;
    while(p.next!=NULL){
        p=p.next;
        count++;
    }
    return count;
}

void DestroyStack(T* top){
    T *p,*q;
    p=top;
    while(!p){
            q=p;
        p=p.next;
        free(q);
    }
}

int GetTop(T* top,DataType *e){
        T *p;
    p=top.next;
    if(!p){                                                       
        printf("stack is empty");
        return 0;
    }  
        *e=p.data;                                        
    return 1;
}

#undef DataType
#undef T
#endif
#define T EventStruct
typedef struct{
    LStackNode listenList;                
        LStackNode requestList;                
        var init;
}T;
typedef struct{
        int eventType;                               
        void* pFun;                                       
        int* parm;                                        
}SingerEvent;
//interface define
void AddEventListener(int eventType,void* pFun);
void PushEvent(int eventType,int *parm);
void InitEventListener();
int isHaveEvent(SingerEvent* sl);
void doEvent(SingerEvent* cl,SingerEvent* sl,int* pL);
T* getEventList();
T eventList;


//type:Event type
//pFun:function pointer
void AddEventListener(int eventType,void* pFun){
        T* t = getEventList();
        LStackNode* pList=&(t.listenList);
        if(t.init==0){
                printf("AddEventListener:your EventControl didnt init!eventType:%d",eventType);
                return;        
        }
        SingerEvent n;
        SingerEvent* sl = malloc(sizeof(n));
        if(sl!=NULL){
                sl.eventType = eventType;
                sl.pFun                 = pFun;
                //printf("%d",sl);
                PushLinkStack(pList,sl);
        }
        else
                printf("add fail");
}
//request event
void PushEvent(int eventType,int *parm){
        T* t = getEventList();
        if(t.init==0){;
		printf("PushEvent:your EventControl didnt init!eventType:%d",eventType);
                return;        
        }
        SingerEvent sl;
        sl.eventType = eventType;
        sl.parm                 = parm;
        sl.pFun                 = NULL;
        isHaveEvent(&sl);        
}
void doEvent(SingerEvent* cl,SingerEvent* sl,int* pL){
        if(cl.eventType==sl.eventType){
                function* fun=cl.pFun;
                if(fun!=NULL){
                        ENTITY* e=ent_create(NULL,NULL,fun);
                        ptr_remove(e);
                }
                *pL=*pL+1;
        }
}
int isHaveEvent(SingerEvent* sl){
        T* t = getEventList();
        LStackNode* p=NULL;
        LStackNode* top=&(t.listenList);
        p=top;
        int i=0;

        while(p.next!=NULL){
        p=p.next;
        doEvent((SingerEvent*)(p.data),sl,&i);
    }
        if(i==0){
                printf("not have this event :%d",sl.eventType);
        }
}
T* getEventList(){
        return         &eventList;
}
void InitEventListener(){
        T* t = getEventList();
        InitLinkStack(&(t.listenList));
        InitLinkStack(&(t.requestList));
        t.init = 1;
}
#undef T





// how to used this model
//event define
#define EVENT_EAT_FISH 0
#define EVENT_EAT_CAT  1
void eatFish(){
        printf("eat fish");
}
void eatCat(){
        printf("eat cat");
}
void main(){
InitEventListener();
AddEventListener(EVENT_EAT_FISH,eatFish);
AddEventListener(EVENT_EAT_CAT,eatCat);
PushEvent(EVENT_EAT_FISH,NULL);
}