/*

 * Copyright (c) 2009 Nokia Corporation and/or its subsidiary(-ies).

 * All rights reserved.

 * This component and the accompanying materials are made available

 * under the terms of "Eclipse Public License v1.0"

 * which accompanies this distribution, and is available

 * at the URL "http://www.eclipse.org/legal/epl-v10.html".

 *

 * Initial Contributors:

 * Nokia Corporation - initial contribution.

 *

 * Contributors:

 *

 * Description: Framework Manager. Parses the CFG file

 *

 */

#include <stdio.h>

#include <string.h>

#include "xaframeworkmgr.h"

/* Default line width permitted in the cfg file + 2 to hold "\r\n"*/

#define LINEWIDTH 82

typedef enum

    {

    FWMgrTagNone,

    FWMgrTagURIScheme,

    FWMgrTagFileExt

    } FWMgrTagType;

/* Config file location */

const char configFileLocationZ[] = "z:/openmaxal/openmaxal.cfg";

const char configFileLocationC[] = "c:/openmaxal/openmaxal.cfg";

/* Tags used for parsing */

const char mediaPlayerBeginTag[] = "<mediaplayer>";

const char mediaPlayerEndTag[] = "</mediaplayer>";

const char mediaRecorderBeginTag[] = "<mediarecorder>";

const char mediaRecorderEndTag[] = "</mediarecorder>";

const char mediaFrameworkMmfBeginTag[] = "<mmf>";

const char mediaFrameworkMmfEndTag[] = "</mmf>";

const char mediaFrameworkGstBeginTag[] = "<gst>";

const char uriSchemeBeginTag[] = "<urischeme>";

const char uriSchemeEndTag[] = "</urischeme>";

const char mediaFrameworkGstEndTag[] = "</gst>";

const char fileExtBeginTag[] = "<fileext>";

const char fileExtEndTag[] = "</fileext>";

/* Local function definitions */

/* returns FWMgrTrue if processed successfully */

static FWMgrBool processConfigEntry(const char* buffer,

        FWMgrMOType *mediaType, FWMgrFwType *frameworkType,

        FWMgrTagType *tagType, FWMgrBool *newNode, FrameworkMap **node);

/* returns FWMgrTrue if processed successfully */

static FWMgrBool processTagType(const char* buffer,

        FWMgrFwType *frameworkType, FWMgrTagType *tagType,

        FrameworkMap **node);

/* returns FWMgrTrue if processed successfully */

static FWMgrBool tokenizeTag(FWMgrTagType tagType, const char* buffer,

        FrameworkMap **node);

/* Crates a default rules config file */

static int createDefaultRules(const char * filename);

/* Global functions from header file */

/* FrameworkMap* XAFrameworkMgr_CreateFrameworkMap

 * Description: Creates a list of framework and use-case map.

 */

FrameworkMap* XAFrameworkMgr_CreateFrameworkMap()

    {

    char buffer[LINEWIDTH];

    int readSize;

    int lineNumber = 0;

    FWMgrBool processedEntry = FWMgrTrue;

    FWMgrMOType currentMediaType = FWMgrMOUnknown;

    FWMgrFwType currentFrameworkType = FWMgrFWUknown;

    FWMgrTagType currentTagType = FWMgrTagNone;

    FrameworkMap *curNode = NULL;

    FWMgrBool newNode;

    FrameworkMap *frameworkMap = NULL;

    if (fp == NULL)

        {

        }

    if (fp != NULL)

        {

        while ((fgets(buffer, LINEWIDTH, fp) != NULL) && processedEntry)

            {

            /* keep looping until NULL pointer OR error... */

            lineNumber++;

            readSize = strlen(buffer);

            /* Ignore comments line */

            if (buffer[0] == '#')

                continue;

            /* Ignore replace "\r\n" with '\0' */

            if ((readSize >= 2) && (buffer[readSize - 2] == '\r')

                    && (buffer[readSize - 1] == '\n'))

                buffer[readSize - 2] = '\0';

            /* Ignore new line... */

            if (readSize == 2)

                continue;

            processedEntry = processConfigEntry(buffer, &currentMediaType,

                    &currentFrameworkType, &currentTagType, &newNode,

                    &curNode);

            if (newNode)

                {

                /*Just link to the last element in the chain*/

                if (!frameworkMap)

                    {

                    frameworkMap = curNode;

                    }

                else

                    {

                    FrameworkMap *lastNode = frameworkMap;

                    while (lastNode->next)

                        {

                        lastNode = lastNode->next;

                        }

                    lastNode->next = curNode;

                    }

                }

            }

        fclose(fp);

        }

    else

        {

        printf("unable to open config file!\n");

        }

    return frameworkMap;

    }

#ifdef _DEBUG

/* void XAFrameworkMgr_DumpFrameworkMap

 * Description: Prints map to std console.

 */

void XAFrameworkMgr_DumpFrameworkMap(FrameworkMap *map)

    {

    FrameworkMap *node = map;

    int i;

    int loopIndex = 0;

    while (node)

        {

        loopIndex++;

        printf("%d>", loopIndex);

        if (node->moType == FWMgrMOPlayer)

            printf("MediaPlayer-");

        else if (node->moType == FWMgrMORecorder)

            printf("MediaRecrdr-");

        else

            printf("UKNOWN-");

        if (node->fwType == FWMgrFWMMF)

            printf("MMF-");

        else if (node->fwType == FWMgrFWGST)

            printf("GST-");

        else

            printf("UKNOWN-");

        printf("Scheme[");

        for (i = 0; i < node->uriSchemeCount; i++)

            printf(" %s", node->uriSchemes[i]);

        printf("]FileExt[");

        for (i = 0; i < node->fileExtCount; i++)

            printf(" %s", node->fileExts[i]);

        printf("]\n");

        node = node->next;

        }

    }

#endif

/* void XAFrameworkMgr_DeleteFrameworkMap

 * Description: Deletes the list of framework and use-case map.

 */

void XAFrameworkMgr_DeleteFrameworkMap(FrameworkMap **map)

    {

    FrameworkMap *node = *map;

    FrameworkMap *nextNode = NULL;

    int i;

    while (node)

        {

        for (i = 0; i < node->uriSchemeCount; i++)

            free(node->uriSchemes[i]);

        free(node->uriSchemes);

        for (i = 0; i < node->fileExtCount; i++)

            free(node->fileExts[i]);

        free(node->fileExts);

        nextNode = node->next;

        free(node);

        node = nextNode;

        }

    *map = NULL;

    }

/* FWMgrFwType XAFrameworkMgr_GetFramework

 * Description: Returns the framework enum that handles uri.

 */

FWMgrFwType XAFrameworkMgr_GetFramework(FrameworkMap *map, const char *uri,

        FWMgrMOType mediaObject)

    {

    FWMgrFwType retVal = FWMgrFWUknown;

    char fileScheme[] = "file";

    char *uriScheme = NULL;

    char *fileExt = NULL;

    FrameworkMap *node = map;

    FWMgrBool uriMatchFound = FWMgrFalse;

    FWMgrBool fileExtMatchFound = FWMgrFalse;

    int i = 0;

    int copyLen = 0;

    if (!map || !uri)

        {

        /* TODO Log invalid uri */

        return retVal;

        }

    /* Get uri scheme */

    uriScheme = strchr(uri, ':');

    if (uriScheme == NULL)

        {

        /* TODO Log invalid uri */

        return retVal;

        }

    copyLen = (uriScheme - uri);

    uriScheme = (char*) calloc(copyLen + 1, sizeof(char));

    strncpy(uriScheme, uri, copyLen);

    uriScheme[copyLen] = '\0'; /*Null terminate it*/

    if (strcasecmp(uriScheme, fileScheme) == 0)

        {

        /* Get uri extension */

        char* dotLoc = strrchr(uri, '.');

        if (dotLoc == NULL)

            {

            /* TODO Log invalid uri */

            free(uriScheme);

            return retVal;

            }

        /* We need to add 1 to exclude '.'*/

        copyLen = strlen(uri) - (dotLoc + 1 - uri);

        fileExt = (char*) calloc(copyLen + 1, sizeof(char));

        strncpy(fileExt, dotLoc + 1, copyLen);

        fileExt[copyLen] = '\0'; /*Null terminate it*/

        }

    while (node)

        {

        if (mediaObject == node->moType)

            {

            uriMatchFound = FWMgrFalse;

            fileExtMatchFound = FWMgrFalse;

            /* Match for uri*/

            for (i = 0; i < node->uriSchemeCount; i++)

                {

                if (strcasecmp(uriScheme, node->uriSchemes[i]) == 0)

                    {

                    uriMatchFound = FWMgrTrue;

                    break;

                    }

                }

            /* if uri scheme is not file, we only need to check for uri */

            if (!fileExt)

                {

                fileExtMatchFound = FWMgrTrue;

                }

            else

                {

                for (i = 0; i < node->fileExtCount; i++)

                    {

                    if (strcasecmp(fileExt, node->fileExts[i]) == 0)

                        {

                        fileExtMatchFound = FWMgrTrue;

                        break;

                        }

                    }

                }

            if ((uriMatchFound == FWMgrTrue) && (fileExtMatchFound

                    == FWMgrTrue))

                {

                retVal = node->fwType;

                break;

                }

            }

        node = node->next;

        }

    free(uriScheme);

    free(fileExt);

    return retVal;

    }

/* Local functions */

/* FWMgrBool processConfigEntry

 * Description: Processes a single line entry from the config file.

 */

FWMgrBool processConfigEntry(const char* buffer, FWMgrMOType *mediaType,

        FWMgrFwType *frameworkType, FWMgrTagType *tagType,

        FWMgrBool *newNode, FrameworkMap **node)

    {

    FWMgrBool processedSuccessfully = FWMgrTrue;

    if (!buffer || !mediaType || !frameworkType || !tagType || !newNode)

        {

        processedSuccessfully = FWMgrFalse;

        return processedSuccessfully;

        }

	*newNode = FWMgrFalse;

    switch (*mediaType)

        {

        case FWMgrMOUnknown:

            {

            if (strcmp(buffer, mediaPlayerBeginTag) == 0)

                {

                *mediaType = FWMgrMOPlayer;

                *frameworkType = FWMgrFWUknown;

                *tagType = FWMgrTagNone;

                *node = NULL;

                }

            else if (strcmp(buffer, mediaRecorderBeginTag) == 0)

                {

                *mediaType = FWMgrMORecorder;

                *frameworkType = FWMgrFWUknown;

                *tagType = FWMgrTagNone;

                *node = NULL;

                }

            }

            break;

        case FWMgrMOPlayer:

        case FWMgrMORecorder:

            {

            switch (*frameworkType)

                {

                case FWMgrFWUknown:

                    {

                    if ((*mediaType == FWMgrMOPlayer) && (strcmp(buffer,

                            mediaPlayerEndTag) == 0))

                        *mediaType = FWMgrMOUnknown;

                    else if ((*mediaType == FWMgrMORecorder) && (strcmp(

                            buffer, mediaRecorderEndTag) == 0))

                        *mediaType = FWMgrMOUnknown;

                    else if ((strcmp(buffer, mediaFrameworkMmfBeginTag) == 0)

                            || (strcmp(buffer, mediaFrameworkGstBeginTag)

                                    == 0))

                        {

                        *frameworkType = FWMgrFWMMF;

                        if (strcmp(buffer, mediaFrameworkGstBeginTag) == 0)

                            *frameworkType = FWMgrFWGST;

                        if (*node)

                            {

                            printf(

                                    "Fatal error error. Entry already exists and creating another one!!!");

                            processedSuccessfully = FWMgrFalse;

                            }

                        else

                            {

                            *node = (FrameworkMap*) calloc(1,

                                    sizeof(FrameworkMap));

                            if (!(*node))

                                {

                                printf(

                                        "Fatal error. No memory to create an Entry!!!");

                                processedSuccessfully = FWMgrFalse;

                                }

                            else

                                {

                                *newNode = FWMgrTrue;

                                (*node)->moType = *mediaType;

                                (*node)->fwType = *frameworkType;

                                }

                            }

                        }

                    }

                    break;

                case FWMgrFWMMF:

                    {

                    processedSuccessfully = processTagType(buffer,

                            frameworkType, tagType, node);

                    }

                    break;

                case FWMgrFWGST:

                    {

                    processedSuccessfully = processTagType(buffer,

                            frameworkType, tagType, node);

                    }

                    break;

                default:

                    processedSuccessfully = FWMgrFalse;

                    break;

                };

            }

            break;

        default:

            processedSuccessfully = FWMgrFalse;

            break;

        };

    return processedSuccessfully;

    }

/* FWMgrBool processTagType

 * Description: Processes a framework type, uri, file tags entry from 

 * the config file.

 */

FWMgrBool processTagType(const char* buffer, FWMgrFwType *frameworkType,

        FWMgrTagType *tagType, FrameworkMap **node)

    {

    FWMgrBool processedSuccessfully = FWMgrTrue;

    if (!buffer || !frameworkType || !tagType || (*node == NULL))

        {

        processedSuccessfully = FWMgrFalse;

        return processedSuccessfully;

        }

    switch (*tagType)

        {

        case FWMgrTagNone:

            {

            if (((*frameworkType == FWMgrFWMMF) && (strcmp(buffer,

                    mediaFrameworkMmfEndTag) == 0)) || ((*frameworkType

                    == FWMgrFWGST)

                    && (strcmp(buffer, mediaFrameworkGstEndTag) == 0)))

                {

                *node = NULL;

                *frameworkType = FWMgrFWUknown;

                }

            else if (strcmp(buffer, uriSchemeBeginTag) == 0)

                *tagType = FWMgrTagURIScheme;

            else if (strcmp(buffer, fileExtBeginTag) == 0)

                *tagType = FWMgrTagFileExt;

            }

            break;

        case FWMgrTagURIScheme:

            {

            if (strcmp(buffer, uriSchemeEndTag) == 0)

                *tagType = FWMgrTagNone;

            else

                {

                processedSuccessfully = FWMgrFalse;

                if (*node)

                    processedSuccessfully = tokenizeTag(FWMgrTagURIScheme,

                            buffer, node);

                }

            }

            break;

        case FWMgrTagFileExt:

            {

            if (strcmp(buffer, fileExtEndTag) == 0)

                *tagType = FWMgrTagNone;

            else

                {

                processedSuccessfully = FWMgrFalse;

                if (*node)

                    processedSuccessfully = tokenizeTag(FWMgrTagFileExt,

                            buffer, node);

                }

            }

            break;

        default:

            processedSuccessfully = FWMgrFalse;

            break;

        };

    return processedSuccessfully;

    }

/* FWMgrBool processTagType

 * Description: Processes a framework type, uri, file tags entry from 

 * the config file.

 */

FWMgrBool tokenizeTag(FWMgrTagType tagType, const char* buffer,

        FrameworkMap **node)

    {

    char* tempStartPtr;

    char* tempEndPtr;

    int index = 0;

    int strLen = 0;

    if (!buffer || (*node == NULL))

        {

        return FWMgrFalse;

        }

    tempStartPtr = /*const_cast<char*>*/(char*) (buffer);

    tempEndPtr = /*const_cast<char*>*/(char*) (buffer);

    if (tagType == FWMgrTagURIScheme)

        {

        (*node)->uriSchemeCount = atoi(buffer);

        (*node)->uriSchemes = (char**) calloc((*node)->uriSchemeCount,