#include "tdp.h"


static pthread_cond_t cv = PTHREAD_COND_INITIALIZER;
static pthread_mutex_t mp = PTHREAD_MUTEX_INITIALIZER;
static pthread_cond_t cv1 = PTHREAD_COND_INITIALIZER;
static pthread_mutex_t mp1 = PTHREAD_MUTEX_INITIALIZER;
static PatTable *patTable;
static PmtTable *pmtTable;
uint8_t filterPID = 0;
uint8_t tableId = 0;
static ServiceInfo services[20];
static uint8_t serviceNum = 0;
uint32_t pHandle;
uint32_t sHandle;
uint32_t fHandle;
uint32_t stVHandle;
uint32_t stAHandle;

int32_t demux_callback(uint8_t *buffer)
{

    if (tableId == 0) {

        if(parsePatTable(buffer, patTable) == TABLES_PARSE_OK)  {
                    printPatTable(patTable);

                        pthread_mutex_lock(&mp1);
                        pthread_cond_signal(&cv1);
                        pthread_mutex_unlock(&mp1);
                }

                return 0;
        }
    else if (tableId == 2) {

                if(parsePmtTable(buffer, pmtTable,services,serviceNum) == TABLES_PARSE_OK)  {
                    printPmtTable(pmtTable);

                        pthread_mutex_lock(&mp1);
                        pthread_cond_signal(&cv1);
                        pthread_mutex_unlock(&mp1);
                }

          return 0;
        }

}

int32_t tuner_callback(t_LockStatus status)
{
    if (status == 0)
    {
    printf("STATUS_ERROR\n");
    }
    else
    {
    printf("STATUS_LOCKED\n");
        pthread_mutex_lock(&mp);
        pthread_cond_signal(&cv);
        pthread_mutex_unlock(&mp);
    }

    return status;
}


t_Error tdpInit()
{
    t_Error err;

    err = Tuner_Init();
        if(err != NO_ERROR)
        {
            printf("Tuner ERROR\n");
            return ERROR;
        }


    err = Tuner_Register_Status_Callback(tuner_callback);
        if(err != NO_ERROR)
        {
            printf("Tuner_Register_Status_Callback ERROR\n");
            return ERROR;
        }

    err = Tuner_Lock_To_Frequency(DESIRED_FREQUENCY,BANDWIDTH,DVB_T);
        if(err != NO_ERROR)
        {
            printf("Tuner_Lock_To_Frequency ERROR\n");
            return ERROR;
        }

    pthread_mutex_lock(&mp);
    pthread_cond_wait(&cv,&mp);
        pthread_mutex_unlock(&mp);

    err = Player_Init(&pHandle);
        if(err != NO_ERROR)
        {
            printf("Player_Init ERROR\n");
            return ERROR;
        }

    err = Player_Source_Open(pHandle, &sHandle);
        if(err != NO_ERROR)
        {
            printf("Player_Source_Open ERROR\n");
            return ERROR;
        }

    return NO_ERROR;


}

t_Error startChannelScan()
{
    t_Error err;
    uint8_t i = 0;

    patTable=(PatTable*)malloc(sizeof(PatTable));
    if(patTable==NULL)
    {
            printf("\n%s : ERROR Cannot allocate memory\n", __FUNCTION__);
            return -1;
        }
     memset(patTable, 0, sizeof(PatTable));

        pmtTable=(PmtTable*)malloc(sizeof(PmtTable));
        if(pmtTable==NULL)
    {
            printf("\n%s : ERROR Cannot allocate memory\n", __FUNCTION__);
            return -1;
     }
        memset(pmtTable, 0, sizeof(PmtTable));

    err = Demux_Register_Section_Filter_Callback(demux_callback);
        if(err != NO_ERROR)
        {
            printf("Demux_Register_Section_Filter_Callback ERROR\n");
            return ERROR;
        }
    err = Demux_Set_Filter(pHandle,tableId,filterPID,&fHandle);
        if(err != NO_ERROR)
        {
            printf("Demux_Set_Filter ERROR\n");
            return ERROR;
        }

    pthread_mutex_lock(&mp1);
    pthread_cond_wait(&cv1,&mp1);
        pthread_mutex_unlock(&mp1);

    err = Demux_Free_Filter(pHandle, fHandle);
        if(err != NO_ERROR)
        {
            printf("Demux_Free_Filter ERROR\n");
            return ERROR;
        }

    tableId = 2;
    for(i = 1; i < patTable->serviceInfoCount; i++)
    {
        err = Demux_Set_Filter(pHandle,patTable->patServiceInfoArray[i].pid,tableId,&fHandle);
            if(err != NO_ERROR)
            {
                printf("Demux_Register_Section_Filter_Callback ERROR\n");
                return ERROR;
            }


            pthread_mutex_lock(&mp1);
            pthread_cond_wait(&cv1, &mp1);
            pthread_mutex_unlock(&mp1);

        serviceNum++;
        err = Demux_Free_Filter(pHandle, fHandle);
            if(err != NO_ERROR)
            {
                printf("Demux_Free_Filter ERROR\n");
                return ERROR;
            }
        }

    return NO_ERROR;
}



t_Error createStream(uint8_t isInitial)
{
    t_Error err;

    if(isInitial == 0)
    {
        err = Player_Stream_Remove(pHandle,sHandle,stAHandle);
            if(err != NO_ERROR)
            {
                printf("Player_Stream_Remove ERROR\n");
                return ERROR;
            }
        err = Player_Stream_Remove(pHandle,sHandle,stVHandle);
            if(err != NO_ERROR)
            {
                printf("Player_Stream_Remove ERROR\n");
                return ERROR;
            }

    }

    err = Player_Stream_Create(pHandle, sHandle,VIDEO_PID,VIDEO_TYPE_MPEG2,&stVHandle);
        if(err != NO_ERROR)
        {
            printf("Player_Stream_Create ERROR\n");
            return ERROR;
        }
    err = Player_Stream_Create(pHandle, sHandle,AUDIO_PID,AUDIO_TYPE_MPEG_AUDIO,&stAHandle);
        if(err != NO_ERROR)
        {
            printf("Player_Stream_Create ERROR\n");
            return ERROR;
        }

    return NO_ERROR;
}

t_Error tdpDeinit()
{
    t_Error err;

    err = Player_Stream_Remove(pHandle,sHandle,stAHandle);
        if(err != NO_ERROR)
        {
            printf("Player_Stream_Remove ERROR\n");
            return ERROR;
        }
    err = Player_Stream_Remove(pHandle,sHandle,stVHandle);
        if(err != NO_ERROR)
        {
            printf("Player_Stream_Remove ERROR\n");
            return ERROR;
        }
    err = Demux_Free_Filter(pHandle,fHandle);
        if(err != NO_ERROR)
        {
            printf("Demux_Free_Filter ERROR\n");
            return ERROR;
        }
    err = Demux_Unregister_Section_Filter_Callback(demux_callback);
        if(err != NO_ERROR)
        {
            printf("Demux_Unregister_Section_Filter_Callback ERROR\n");
            return ERROR;
        }
    err = Player_Source_Close(pHandle, sHandle);
        if(err != NO_ERROR)
        {
            printf("Player_Source_Close ERROR\n");
            return ERROR;
        }

    err = Player_Deinit(pHandle);
        if(err != NO_ERROR)
        {
            printf("Player_Deinit ERROR\n");
            return ERROR;
        }
    err = Tuner_Unregister_Status_Callback(tuner_callback);
        if(err != NO_ERROR)
        {
            printf("Tuner_Unregister_Status_Callback ERROR\n");
            return ERROR;
        }
    err = Tuner_Deinit();
        if(err != NO_ERROR)
        {
            printf("Tuner_Deinit ERROR\n");
            return ERROR;
        }

    free(pmtTable);
        free(patTable);

    return NO_ERROR;

}