#include "metadataops.h"
#include "StandardConstants.h"
#include "StringUtils.h"

/*
Name: addNode
Process: adds metadata node to linked list recursively, handles empty list
Function Input/Parameters: ptr to head or next linked node (OpCodeType *),
                           ptr to new node (OpCodeType *)
Function Output/Parameters: none
Function Output/Returned: pointer to previous node, or head node (OpCodeType *)
Device Input/Device: none
Device Output/Device: none
Dependencies: malloc, copyString
*/
OpCodeType *addNode(OpCodeType *localPtr, OpCodeType *newNode)
{
    // initialize function and variables
    // check for local pointer assigned to null
    if(localPtr == NULL)
    {
        // access memory for new link/node
            // fct: malloc
        localPtr = (OpCodeType *) malloc(sizeof(OpCodeType));
        // assign all three values to newly created node
        // assign next pointer to null
            // fct: copyString
        localPtr->pid = newNode->pid;
        copyString(localPtr->command, newNode->command);
        copyString(localPtr->inOutArg, newNode->inOutArg);
        copyString(localPtr->strArg1, newNode->strArg1);
        localPtr->intArg2 = newNode->intArg2;
        localPtr->intArg3 = newNode->intArg3;
        localPtr->opEndTime = newNode->opEndTime;
        localPtr->nextNode = NULL;
        // return current local pointer
        return localPtr;
    }
    // assume end of list not found
    // assign recursive fct to current node's next link
        // fct: addNode
    localPtr->nextNode = addNode(localPtr->nextNode, newNode);
    // return current local ptr
    return localPtr;
}

/*
Name: clearMetaDataList
Process: recursively traverses list, frees dynamically allocated nodes
Function Input/Parameters: node opcode (const OpCodeType *)
Function Output/Parameters: none
Function Output/Returned: NULL (OpCodeType *)
Device Input/Device: none
Device Output/Device: none
Dependencies: ???
*/
OpCodeType *clearMetaDataList(OpCodeType *localPtr)
{
    // initialize function and variables
    // check for local pointer not set to null (list not empty)
    if(localPtr != NULL)
    {
        // call recursive function with next pointer
            // fct: clearMetaDataList
        clearMetaDataList(localPtr->nextNode);
        // after recursive call, release mem to OS
            // fct: free
        free(localPtr);
        // set given pointer to NULL
        localPtr = NULL;
    }
    // return NULL to calling fct
    return NULL;
}

/*
Name: displayMetaData
Process: data dump/display of all opcode items
Function Input/Parameters: pointer to
                           head of opcode/metadata list (const OpCodeType *)
Function Output/Parameters: none
Function Output/Returned: calculated time (int)
Device Input/Device: none
Device Output/Device: none
Dependencies: printf, compareString
*/
void displayMetaData(const OpCodeType *localPtr)
{
    // initialize function and variables
    // display title, with underline
        // fct: printf
    printf("Metadata File Display\n");
    printf("---------------------\n\n");
    // loop to end of linked list
    while(localPtr != NULL)
    {
        // print leader
            // fct: printf
        printf("Opcode: ");
        // print opcode pid
            // fct: printf
        printf("/pid: %d", localPtr->pid);
        // print opcode command
            // fct: printf
        printf("/cmd: %s", localPtr->command);
        // check for dev op
        if(compareString(localPtr->command, "dev") == 0)
        {
            // print in/out parameter
                // fct: printf
            printf("/io: %s", localPtr->inOutArg);
        }
        // otherwise, assume other than dev
        else
        {
            // print NA
                // fct: printf
            printf("/io: NA");
        }
        // print first string argument
            // fct: printf
        printf("\n\t/arg 1: %s", localPtr->strArg1);
        // print first int argument
            // fct: printf
        printf("/arg 2: %d", localPtr->intArg2);
        // print second int argument
            // fct: printf
        printf("/arg 3: %d", localPtr->intArg3);
        // print op end time
        printf("/op end time: %8.6f", localPtr->opEndTime);
        // endline print
            // fct: printf
        printf("\n\n");
        // assign local pointer to next node
        localPtr = localPtr->nextNode;
    }
    // void function, no return.
}

/*
Name: getCommand
Process: parses thre letter command part of opcode str
Function Input/Parameters: input opcode str (const char *),
                           starting index (int)
Function Output/Parameters: parsed command (char *)
Function Output/Returned: updated starting index for use by calling fct (int)
Device Input/Device: none
Device Output/Device: none
Dependencies: none
*/
int getCommand(char *cmd, const char *inputStr, int index)
{
    // initialize function and variables
    int lengthOfCommand = 3;
    // loop across command length
    while(index < lengthOfCommand)
    {
        // assign character from input string to buffer string
        cmd[index] = inputStr[index];
        // increment index
        index = index + 1;
        // set next character to null character
        cmd[index] = NULL_CHAR;
    }
    // return current index
    return index;
}

/*
Name: getMetaData
Process: main driver function to upload, parse, and store list
         of op code commands in a linked list
Function Input/Parameters: file name (const char *)
Function Output/Parameters: ptr to opcode linked list head ptr (OpCodeType **),
                            result msg of fct state after completion (char *)
Function Output/Returned: Boolean result of operation (bool)
Device Input/File: op code list uploaded
Device Output/Device: none
Dependencies: copyString, fopen, getStringToDelimiter, compareString, fclose,
              malloc, getOpCommand, updateStartCount, updateEndCount,
              clearMetaDataList, free, addNode
*/
bool getMetaData(const char *fileName, 
                                 OpCodeType **opCodeDataHead, char *endStateMsg)
{
    // initialize function and variables
        // iniitialize read only constant
    const char READ_ONLY_FLAG[] = "r";
        // initialize variables
    int accessResult, startCount = 0, endCount = 0;
    char dataBuffer[MAX_STR_LEN];
    bool returnState = true;
    OpCodeType *newNodePtr;
    OpCodeType *localHeadPtr = NULL;
    FILE *fileAccessPtr;
    // initialize opcode data pointer in case of return error
    *opCodeDataHead = NULL;
    // initialize end state message
        // fct: copyString
    copyString(endStateMsg, "Metadata file upload successful");
    // open file for reading
        // fct: fopen
    fileAccessPtr = fopen(fileName, READ_ONLY_FLAG);
    // check for file open failure
    if(fileAccessPtr == NULL)
    {
        // set end state message
            // fct: copyString
        copyString(endStateMsg, "Metadata file access error");
        // return file access error
        return false;
    }
    // check first line for correct leader
        // fct: getStringToDelimiter, compareString
    if(!getStringToDelimiter(fileAccessPtr, COLON, dataBuffer) || 
                 compareString(dataBuffer, "Start Program Meta-Data Code") != 0)
    {
        // close file
            // fct: fclose
        fclose(fileAccessPtr);
        // set end state message
            // fct: copyString
        copyString(endStateMsg, "Corrupt metadata leader line error");
        // return corrupt descriptor error
        return false;
    }
    // allocate memory for the temporary data structure
        // fct: malloc
    newNodePtr = (OpCodeType *) malloc(sizeof(OpCodeType));
    // get the first op command
        // fct: getOpCommand
    accessResult = getOpCommand(fileAccessPtr, newNodePtr);
    // get start and end counts for later comparison
        // fct: updateStartCount, updateEndCount
    startCount = updateStartCount(startCount, newNodePtr->strArg1);
    endCount = updateEndCount(endCount, newNodePtr->strArg1);
    // check for failure of first complete op command
    if(accessResult != COMPLETE_OPCMD_FOUND_MSG)
    {
        // close file
            // fct: fclose
        fclose(fileAccessPtr);
        // clear data from the structure list
            // fct: clearMetaDataList
        *opCodeDataHead = clearMetaDataList(localHeadPtr);
        // free temporary structure memory
            // fct: free
        free(newNodePtr);
        // set end state message
            // fct: copyString
        copyString(endStateMsg, "Metadata incomplete first op command found");
        // return result of operation
        return false;
    }
    // loop across all remaining op commands
    // (while complete op commands are found)
    while(accessResult == COMPLETE_OPCMD_FOUND_MSG)
    {
        // add the new op command to the linked list
            // fct: addNode
        localHeadPtr = addNode(localHeadPtr, newNodePtr);
        // get a new op command
            // fct: getOpCommand
        accessResult = getOpCommand(fileAccessPtr, newNodePtr);
        // update start and end counts for later comparison
            // fct: updateStartCount, updateEndCount
        startCount = updateStartCount(startCount, newNodePtr->strArg1);
        endCount = updateEndCount(endCount, newNodePtr->strArg1);
    }
    // end loop across all remaining op commands
    // check for last op command found
    if(accessResult == LAST_OPCMD_FOUND_MSG)
    {
        // check for start and end opcode counts equal
        if(startCount == endCount)
        {
            // add the last node to the linked list
                // fct: addNode
            localHeadPtr = addNode(localHeadPtr, newNodePtr);
            // set access result to no error for later operation
            accessResult = NO_ACCESS_ERR;
            // check last line for incorrect end descriptor
                // fct: getStringToDelimiter, compareString
            if(!getStringToDelimiter(fileAccessPtr, PERIOD, dataBuffer) || 
                   compareString(dataBuffer, "End Program Meta-Data Code") != 0)
            {
                // set access result to corrupted descriptor error
                accessResult = MD_CORRUPT_DESCRIPTOR_ERR;
                // set end state message
                    // fct: copyString
                copyString(endStateMsg, "Metadata corrupted descriptor error");
            }  
        }
        // otherwise, assume start/end counts not equal
        else
        {
            // close file
                // fct: fclose
            fclose(fileAccessPtr);
            // clear data from the structure list
                // fct: clearMetaDataList
            *opCodeDataHead = clearMetaDataList(localHeadPtr);
            // free temporary structure memory
                // fct: free
            free(newNodePtr);
            // set access result to error
            accessResult = UNBALANCED_START_END_ERR;
            // set end state message
                // fct: copyString
            copyString(endStateMsg, 
                              "Unbalanced start and end arguments in metadata");
            // return result of operation
            return false;
        }
    }
    // otherwise, assume didn't find end
    else
    {
        // set end state message
            // fct: copyString
        copyString(endStateMsg, "Corrupted metadata opcode");
        // unset return state
        returnState = false;
    }
    // check for any errors found (not no error)
    if(accessResult != NO_ACCESS_ERR)
    {
        // clear the op command list
            // fct: clearMetaDataList
        localHeadPtr = clearMetaDataList(localHeadPtr);
    }
    // close access file
        // fct: fclose
    fclose(fileAccessPtr);
    // release temporary structure memory
        // fct: free
    free(newNodePtr);
    // assign temporary local head ptr to parameter return ptr
    *opCodeDataHead = localHeadPtr;
    // return access result
    return returnState;
}

/*
Name: getOpCommand
Process: acquires one op command line from a previously opened file,
         parses it, and sets various struct members according to the
         three letter command
Function Input/Parameters: ptr to open file handle (FILE *)
Function Output/Parameters: ptr to one opcode struct (OpCodeType *)
Function Output/Returned: coded result of operation (OpCodeMessages)
Device Input/File: opcode line uploaded
Device Output/Device: none
Dependencies: getStringToDelimiter, getCommand, copyString, verifyValidCommand, 
              compareString, getStringArg, verifyFirstStringArg, getNumberArg
*/
OpCodeMessages getOpCommand(FILE *filePtr, OpCodeType *inData)
{
    // initialize function and variables
        // initialize local constants
    const int MAX_CMD_LENGTH = 5;
    const int MAX_ARG_STR_LENGTH = 15;
        // initialize other variables
    int numBuffer = 0;
    char strBuffer[STD_STR_LEN];
    char cmdBuffer[MAX_CMD_LENGTH];
    char argStrBuffer[MAX_ARG_STR_LENGTH];
    int runningStringIndex = 0;
    bool arg2FailureFlag = false;
    bool arg3FailureFlag = false;
    // get whole op command as string, check for successful access
        // fct: getStringToDelimiter
    if(getStringToDelimiter(filePtr, SEMICOLON, strBuffer))
    {
        // get three-letter command
            // fct: getCommand
        runningStringIndex = getCommand(cmdBuffer, 
                                                 strBuffer, runningStringIndex);
        // assign op command to node
            // fct: copyString
        copyString(inData->command, cmdBuffer);
    }
    // otherwise, assume unsuccessful access
    else
    {
        // set ptr to data structure to null
        inData = NULL;
        // return op command access failure
        return OPCMD_ACCESS_ERR;
    }
    // verify op command
    if(!verifyValidCommand(cmdBuffer))
    {
        // return op command error
        return CORRUPT_OPCMD_ERR;
    }
    // set all struct values that may not be initialized to defaults
    inData->pid = 0;
    inData->inOutArg[0] = NULL_CHAR;
    inData->intArg2 = 0;
    inData->intArg3 = 0;
    inData->opEndTime = 0.0;
    inData->nextNode = NULL;
    // check for device command
    if(compareString(cmdBuffer, "dev") == 0)
    {
        // get in/out arg
        runningStringIndex = getStringArg(argStrBuffer, 
                                                 strBuffer, runningStringIndex);
        // set device in/out arg
        copyString(inData->inOutArg, argStrBuffer);
        // check correct argument
        if(compareString(argStrBuffer, "in") != 0 && 
           compareString(argStrBuffer, "out") != 0)
        {
            // return argument error
            return CORRUPT_OPCMD_ARG_ERR;
        }
    }
    // get first string arg
    runningStringIndex = getStringArg(argStrBuffer,
                                                 strBuffer, runningStringIndex);
    // set device in/out arg
    copyString(inData->strArg1, argStrBuffer);
    // check for legit first string arg
    if(!verifyFirstStringArg(argStrBuffer))
    {
        // return arg error
        return CORRUPT_OPCMD_ARG_ERR;
    }
    // check for last op command found
    if(compareString(inData->command, "sys") == 0 && 
       compareString(inData->strArg1, "end") == 0)
    {
        // return last op command found message 
        return LAST_OPCMD_FOUND_MSG;
    }
    // check for app start seconds argument
    if(compareString(inData->command, "app") == 0 && 
       compareString(inData->strArg1, "start") == 0)
    {
        // get number argument
            // fct: getNumberArg
        runningStringIndex = getNumberArg(&numBuffer, 
                                                 strBuffer, runningStringIndex);
        // check for failed number access
        if(numBuffer <= BAD_ARG_VAL)
        {
            // set failure flag
            arg2FailureFlag = true;
        }
        // set first int argument to number   
        inData->intArg2 = numBuffer;
    }
    // check for cpu cycle time
    else if(compareString(inData->command, "cpu") == 0)
    {
        // get number argument
            // fct: getNumberArg
        runningStringIndex = getNumberArg(&numBuffer,
                                                 strBuffer, runningStringIndex);
        // check for failed number access
        if(numBuffer <= BAD_ARG_VAL)
        {
            // set failure flag
            arg2FailureFlag = true;
        }
        // set first int argument to number   
        inData->intArg2 = numBuffer;
    }
    // check for device cycle time
    else if(compareString(inData->command, "dev") == 0)
    {
        // get number argument
            // fct: getNumberArg
        runningStringIndex = getNumberArg(&numBuffer,
                                                 strBuffer, runningStringIndex);
        // check for failed number access
        if(numBuffer <= BAD_ARG_VAL)
        {
            // set failure flag
            arg2FailureFlag = true;
        }
        // set first int argument to number   
        inData->intArg2 = numBuffer;
    }
    // check for memory base and offset
    else if(compareString(inData->command, "mem") == 0)
    {
        // get number argument
            // fct: getNumberArg
        runningStringIndex = getNumberArg(&numBuffer,
                                                 strBuffer, runningStringIndex);
        // check for failed number access
        if(numBuffer <= BAD_ARG_VAL)
        {
            // set failure flag
            arg2FailureFlag = true;
        }
        // set first int argument to number   
        inData->intArg2 = numBuffer;
        // get number argument for offset
            // fct: getNumberArg
        runningStringIndex = getNumberArg(&numBuffer,
                                                 strBuffer, runningStringIndex);
        if(numBuffer <= BAD_ARG_VAL)
        {
            // set failure flag
            arg3FailureFlag = true;
        }
        // set second int argument to number
        inData->intArg3 = numBuffer;
    }
    // check int args for upload failure
    if(arg2FailureFlag || arg3FailureFlag)
    {
        // return corrupt op command found message
        return CORRUPT_OPCMD_ARG_ERR;
    }
    // return complete op command found message
    return COMPLETE_OPCMD_FOUND_MSG;
}

/*
Name: getNumberArg
Process: starts at given index, captures 
         and assembles int arg, returns as parameter
Function Input/Parameters: input str (const char *), starting index (int)
Function Output/Parameters: pointer to captured integer value
Function Output/Returned: updated index for next function start
Device Input/Device: none
Device Output/Device: none
Dependencies: isDigit
*/
int getNumberArg(int *number, const char *inputStr, int index)
{
    // initialize function and variables
    bool foundDigit = false;
    *number = 0;
    int multiplier = 1;
    // loop to skip whitespace
    while(inputStr[index] <= SPACE || inputStr[index] == COMMA)
    {
        // increment the index
        index = index + 1;
    }
    // loop across string length
    while(isDigit(inputStr[index]) == true && 
          inputStr[index] != NULL_CHAR)
    {
        // set digit found flag
        foundDigit = true;
        // assign digit to output
        (*number) = (*number) * multiplier + inputStr[index] - '0';
        // increment index and multiplier
        index = index + 1;
        multiplier = multiplier + 1;
    }
    // check for digit not found
    if(!foundDigit)
    {
        // set number to BAD_ARG_VAL, use dereference for ptr
        *number = BAD_ARG_VAL;
    }
    // return current index
    return index;
}

/*
Name: getStringArg
Process: starts at given index, captures 
         and assembles str arg, returns as parameter
Function Input/Parameters: input str (const char *), starting index (int)
Function Output/Parameters: ptr to captured string argument (char *)
Function Output/Returned: updated index for next fct start
Device Input/Device: none
Device Output/Device: none
Dependencies: none
*/
int getStringArg(char *strArg, const char *inputStr, int index)
{
    // initialize function and variables
    int localIndex = 0;
    // loop to skip whitespace
    while(inputStr[index] <= SPACE || inputStr[index] == COMMA)
    {
        // increment the index
        index = index + 1;
    }
    // loop across string length
    while(inputStr[index] != COMMA && inputStr[index] != NULL_CHAR)
    {
        // assign character from input string to buffer string
        strArg[localIndex] = inputStr[index];
        // increment index
        index = index + 1;
        localIndex = localIndex + 1;
        // set next character to null character
        strArg[localIndex] = NULL_CHAR;
    }
    // return current index
    return index;
}

/*
Name: isDigit
Process: tests character parameter for digit, 
         returns true if is digit, false otherwise
Function Input/Parameters: test character (char)
Function Output/Parameters: none
Function Output/Returned: bool result of test (bool)
Device Input/Device: none
Device Output/Device: none
Dependencies: none
*/
bool isDigit(char testChar)
{
    // check for test character between characters '0' - '9'
        // return true
    // otherwise, assume character if not digit, return false
    return testChar >= '0' && testChar <= '9';
}

/*
Name: updateEndCount
Process: manages count of "end" arguments 
         to be compared at end of process input
Function Input/Parameters: initial count (int),
                           test string for "end" (const char *)
Function Output/Parameters: none
Function Output/Returned: updated count, if "end" string found, 
                          otherwise no change
Device Input/Device: none
Device Output/Device: none
Dependencies: compareString
*/
int updateEndCount(int count, const char *opString)
{
    // check for "end" in op string
        // fct: compareString
    if(compareString(opString, "end") == 0)
    {
        // return incremented end count
        return count + 1;
    }
    // return unchanged end count
    return count;
}

/*
Name: updateStartCount
Process: manages count of "start" arguments
         to be compared at start of process input
Function Input/Parameters: initial count (int),
                           test string for "start" (const char *)
Function Output/Parameters: none
Function Output/Returned: updated count, if "start" string found,
                          otherwise no change
Device Input/Device: none
Device Output/Device: none
Dependencies: compareString
*/
int updateStartCount(int count, const char *opString)
{
    // check for "start" in op string
    // fct: compareString
    if (compareString(opString, "start") == 0)
    {
        // return incremented start count
        return count + 1;
    }
    // return unchanged start count
    return count;
}

/*
Name: verifyFirstStringArg
Process: checks for all possibilities of first argument string of op command
Function Input/Parameters: test string (const char *)
Function Output/Parameters: none
Function Output/Returned: bool result of test (bool)
Device Input/Device: none
Device Output/Device: none
Dependencies: compareString
*/
bool verifyFirstStringArg(const char *strArg)
{
    // check for string holding correct first argument
        // fct: compareString
        // return true
    // otherwise, assume test fail, return false
    return compareString(strArg, "access") == 0 ||
           compareString(strArg, "allocate") == 0 ||
           compareString(strArg, "end") == 0 ||
           compareString(strArg, "ethernet") == 0 ||
           compareString(strArg, "hard drive") == 0 ||
           compareString(strArg, "keyboard") == 0 ||
           compareString(strArg, "monitor") == 0 ||
           compareString(strArg, "printer") == 0 ||
           compareString(strArg, "process") == 0 ||
           compareString(strArg, "serial") == 0 ||
           compareString(strArg, "sound signal") == 0 ||
           compareString(strArg, "start") == 0 ||
           compareString(strArg, "usb") == 0 ||
           compareString(strArg, "video signal") == 0;
}

/*
Name: verifyValidCommand
Process: checks for all possibilities of three-letter opcode command
Function Input/Parameters: test string for command (const char *)
Function Output/Parameters: none
Function Output/Returned: bool result of test (bool)
Device Input/Device: none
Device Output/Device: none
Dependencies: compareString
*/
bool verifyValidCommand(char *testCmd)
{
    // check for string holding three-letter opcode command
        // fct: compareString
        // return true
    // otherwise, assume test failure, return false
    return compareString(testCmd, "sys") == 0 ||
           compareString(testCmd, "app") == 0 ||
           compareString(testCmd, "cpu") == 0 ||
           compareString(testCmd, "mem") == 0 ||
           compareString(testCmd, "dev") == 0;
}