#include "task.h"

#include "task_type.h"   
#include "task_hal.h" 

#include "string.h"

#ifdef __cplusplus
extern "C" {
#endif

    


AL_STATIC int8_t TaskTimer(struct pt *pt1 ); 
void TaskFunc(void);


 
AL_STATIC TASK_DATA TaskDb[]={ 
    {1, TASK_MODE_PERIOD,	TASK_ID(TaskTimer),   0,  TASK_NAME(TaskTimer),	1L,     1L,		TaskTimer , {0}} ,     //   
    #include "cfg/task_container.h"
}; 
 

AL_STATIC TIMER_DATA TimerData[MAX_TIMER];
AL_STATIC volatile uint8_t TMP1msCount = 0;   
AL_STATIC volatile uint32_t AllTickCount = 0;


volatile int vIntCnt =0;
int IntCnt =0;

int8_t ActiveTask(int8_t cTaskID, int32_t lPeriod) 
{    
    int8_t result = -1;
    unsigned int i;

    for(i=0;i<sizeof(TaskDb)/sizeof(TaskDb[0]);i++)
    {
        if(TaskDb[i].cTaskID==cTaskID)
        {
            if(TaskDb[i].cActive==0)
            {
                TaskDb[i].cActive=1;
                TaskDb[i].lPeriod=lPeriod;
                TaskDb[i].lLastTime=0;
            }
            result = 0;
            break;
        }
    }
    return result;
}

void ActiveTaskNow(int8_t cTaskID, int32_t lPeriod)
{
    unsigned int i;

    for(i=0;i<sizeof(TaskDb)/sizeof(TaskDb[0]);i++)
    {
        if(TaskDb[i].cTaskID==cTaskID)
        {
            if(TaskDb[i].cActive==0)
            {
                TaskDb[i].cActive=1;
                TaskDb[i].lPeriod=lPeriod;
                TaskDb[i].lLastTime=0;
            }
            break;
        }
    }
}


int8_t SuspendTask(int8_t cTaskID)
{   
    int8_t result = -1;
    int8_t i;
    for(  i=0;i<sizeof(TaskDb)/sizeof(TaskDb[0]);i++)
    {
        if(TaskDb[i].cTaskID==cTaskID)
        {
            result = i;
            TaskDb[i].cActive=0;
            break;
        }
    }
    return result;
}


int8_t SetTaskLastTime(int8_t cTaskID,int32_t lLastTime)
{
    int16_t result = -1;
    unsigned int i; 
    for(i=0;i<sizeof(TaskDb)/sizeof(TaskDb[0]);i++)
    {
        if(TaskDb[i].cTaskID==cTaskID)
        {  
            result =(int16_t) i;
            TaskDb[i].lLastTime=lLastTime; 
            break;
        }
    }
    return result;
}


/*********************************************************************************************************
    FUNCTION:   StartTimer
    PURPOSE:    start a timer ok then return timer number ; =-1 failed;
**********************************************************************************************************/
int8_t StartTimer(int8_t cMode,int32_t lPeriod,void (* routine)(void *   Param1),void *   Param1)
{
    unsigned char   i;
    TIMER_DATA *ptimer;

    ptimer=&TimerData[0];
    for(i=0;i<MAX_TIMER;i++)
    {
        if(!ptimer[i].cUse)
        {
            switch(cMode)
            {
                case TIMER_MODE_TIMER:              // timer only
                case TIMER_MODE_ONCEROUTINE:        // timely routine
                case TIMER_MODE_CYCROUTINE:         // cyclely routine
                    break;
                default:
                    ptimer[i].cUse = 0;
                    return -1;                      // error
            }
            ptimer[i].lPeriod     = lPeriod;              // set timer period
            ptimer[i].lLastTime   = lPeriod;                // get current system time as start timer
            ptimer[i].routine     = routine;              // user timer's routine
            ptimer[i].cMode       = cMode;                // timer's work mode
            ptimer[i].cUse        = 1;
            ptimer[i].Param1      = Param1;
            return (i);                             // return timer number
        }
    }
    //if(i== MAX_TIMER);
    #ifdef _DEBUG
    printf("timer id not found!");
    #endif
    return (-1);                                    // no timer available
}


int8_t StartTimer2(int8_t *TimerID,int8_t cMode,uint32_t lPeriod,void (* routine)(void *   Param1),void *   Param1) 
{  
    int8_t id = StartTimer(cMode,lPeriod,routine,Param1);
    TimerData[id].TimerID = TimerID;
    *TimerID = id;
    return id; 
}

/**********************************************************************************************************
    FUNCTION:   StopTimer
    PURPOSE:    stop timer count
***********************************************************************************************************/
int8_t StopTimer ( signed char * pcTimerNumber )
{
    if(*pcTimerNumber>=MAX_TIMER || *pcTimerNumber==-1)
        return -1;                            // timer number error

    TimerData[*pcTimerNumber].cUse=0;
    *pcTimerNumber = -1;

    return 0;
}
/***********************************************************************************************************
    FUNCTION:   StopAllTimer
    PURPOSE:    stop all timer count
************************************************************************************************************/
void StopAllTimer(void)
{
    unsigned char i;
    memset(TimerData,0,sizeof(TimerData));
    for(i=0;i<MAX_TIMER;i++)
    {
        TimerData[i].cUse=0;
    }
}


// The callback timer executes a callback function one or more times after a specified time
AL_STATIC int8_t TaskTimer(struct pt *pt1 )
{        
    TIMER_DATA *pTimer;
    unsigned char i; 
    pTimer=&TimerData[0];                                         // pointer to the first timer
    for(i=0;i<MAX_TIMER;i++)
    {
        if(!pTimer[i].cUse)
            continue;
        if((--(pTimer[i].lLastTime))<=0)
        {
            switch(pTimer[i].cMode)
            {
                case TIMER_MODE_TIMER:                          // timer only
                     pTimer[i].cUse=0; 
                     if(pTimer[i].TimerID!=NULL)
                        *pTimer[i].TimerID = -1;
                    break; 
                case TIMER_MODE_ONCEROUTINE:                    // timer routine once
                     pTimer[i].cUse=0;                          //prevents the start of timer after stoptimer in the routine from causing an error stop. 
                     if(pTimer[i].TimerID!=NULL)
                        *pTimer[i].TimerID = -1;
                        
                     pTimer[i].lLastTime+=pTimer[i].lPeriod;
                     if(pTimer[i].routine!=NULL)
                        pTimer[i].routine(pTimer[i].Param1);    // start user's routine
                    break;
                case TIMER_MODE_CYCROUTINE:                     // cyclely routine
                     pTimer[i].lLastTime+=pTimer[i].lPeriod;
                     if(pTimer[i].routine!=NULL)
                        pTimer[i].routine(pTimer[i].Param1);    // start user's routine
                    break;
                default:
                    pTimer[i].cUse=0;
                    break;
            }
        }
    }   
    
    UNUSED(pt1);
    return 0;
}

void TaskProc (void)
{
	while(1)
	{ 
		if(!TMP1msCount)  
		{
			Idle();
		} 
        else 
        {
            vIntCnt--;
            IntCnt--;
            TaskFunc();
        }
    }
} 

            
void TaskFunc(void)
{   
    int8_t ret = 0;
    uint8_t j = 0; 
	for(j=0;j<sizeof(TaskDb)/sizeof(TaskDb[0]);j++)
	{
		if(!TaskDb[j].cActive) 
			continue; 

		TaskDb[j].lLastTime-=TMP1msCount;
		if(TaskDb[j].lLastTime<=0)
		{
			TaskDb[j].lLastTime += TaskDb[j].lPeriod;
            if(TaskDb[j].cMode==TASK_MODE_ONCE)
                TaskDb[j].cActive = 0;  
            
			if(TaskDb[j].TaskProc!=NULL)
            {  
                struct pt* pt2 = &(TaskDb[j].pt1); 
                ret = TaskDb[j].TaskProc(pt2);           
            } 
		} 
	}
	TMP1msCount = 0;   
    UNUSED(ret);
}

void Task_SysTick_Handler(void)
{
    AllTickCount++;
    TMP1msCount++;
    
    
    vIntCnt++;
    IntCnt++;
}


int32_t  get_system_ms(void)
{
    return AllTickCount;
}


#ifdef __cplusplus
}
#endif