/**
* @file configCmdObj.c
* @author NXP Semiconductors
* @version 1.0
* @par License
*
* Copyright 2018 NXP
* SPDX-License-Identifier: Apache-2.0
*
* @par Description
* Command handling for 'obj'. Includes optional console handling
*/

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <assert.h>
#include <ctype.h>

// project specific include files
#include "sm_types.h"
#include "sm_apdu.h"
#include "tst_sm_util.h"
#include "tst_a71ch_util.h"
#include "probeAxUtil.h"
#include "configCmd.h"
#include "configCli.h"
#include "a71_debug.h"
#include "HLSEAPI.h"

#include "axHostCrypto.h"
#include "tstHostCrypto.h"

#ifdef OPENSSL
#include <openssl/pem.h>
#endif

#define FLOW_VERBOSE_PROBE_A70

#ifdef FLOW_VERBOSE_PROBE_A70
#define FPRINTF(...) printf (__VA_ARGS__)
#else
#define FPRINTF(...)
#endif

// Warning: defining DBG_PROBE_A70 also exposes Private Key being set in log
// #define DBG_PROBE_A70

#ifdef DBG_PROBE_A70
#define DBGPRINTF(...) printf (__VA_ARGS__)
#else
#define DBGPRINTF(...)
#endif

/**
* a7xConfigCmdWriteObj - create object from hex data
*/
U16 a7xConfigCmdWriteObj(int index, U8 * objData, U16 objDataLen, U16 *sw) {
    HLSE_RET_CODE nRet = AX_CLI_EXEC_FAILED;
    HLSE_OBJECT_HANDLE objHandle;
    HLSE_OBJECT_TYPE objType = HLSE_DATA;
    unsigned short templateSize = 3;
    HLSE_ATTRIBUTE attr[3];

    attr[0].type = HLSE_ATTR_OBJECT_TYPE;
    attr[0].value = &objType;
    attr[0].valueLen = sizeof(objType);
    attr[1].type = HLSE_ATTR_OBJECT_INDEX;
    attr[1].value = &index;
    attr[1].valueLen = sizeof(index);
    attr[2].type = HLSE_ATTR_OBJECT_VALUE;
    attr[2].value = objData;
    attr[2].valueLen = objDataLen;

    nRet = HLSE_CreateObject(attr, templateSize, &objHandle);
    if (nRet != HLSE_SW_OK) {
        *sw = nRet;
        return AX_CLI_EXEC_FAILED;
    }
    else { *sw = 0x9000; }

    return AX_CLI_EXEC_OK;
}
/**
* a7xConfigCmdWriteObjFromSegments - create empty objects in size of n segments
*/
int a7xConfigCmdWriteObjFromSegments(int index, int segments, U16 *sw) {
    HLSE_RET_CODE nRet = AX_CLI_EXEC_FAILED;
    U8 * buffer = 0; // a buffer to hold the read data

    buffer = (U8 *)malloc(sizeof(U8) * (segments * 32) );
    memset(buffer, 0x0, segments * 32);

    nRet = a7xConfigCmdWriteObj(index, buffer, (U16)(segments * 32), sw);
    if (buffer) {free(buffer);}
    return nRet;
}

/**
* a7xConfigCmdWriteObjFromfile - create object from file
*/
static int SetObjectFromFile(int index, int offset, char *szFilename, int chunkSize, a71_ObjCmdClass_t cmdType, U16 *sw) {
    HLSE_RET_CODE nRet = AX_CLI_EXEC_FAILED;
    FILE *file;
    unsigned char *buffer;
    unsigned long fileLen;
    U8 byteArray[4096];
    int i = 0;
    int breakFromLoop = 0;
    int readIndex = 0;
    int bufSize = 0;
    *sw = 0x0000;

    if (chunkSize != 64 && chunkSize != 32) {
        return AX_CLI_ARG_RANGE_ERROR;
    }

    printf("Filename: %s\n", szFilename);
    file = fopen(szFilename, "r");
    if (!file)
    {
        printf("Unable to open the file: %s\n", szFilename);
        return AX_CLI_FILE_OPEN_FAILED;
    }

    //Get file length
    fseek(file, 0, SEEK_END);
    fileLen = ftell(file);
    fseek(file, 0, SEEK_SET);

    //Allocate memory
    buffer = (unsigned char *)malloc(sizeof(unsigned char) * (fileLen * 2));
    if (!buffer)
    {
        fprintf(stderr, "Memory error!");
        fclose(file);
        return AX_CLI_DYN_ALLOC_ERROR;
    }

    //Read file contents into buffer
    for (i = 0;i < (signed)fileLen;i += chunkSize) {
        char tmp[10];
        int y;
        // Read the chunk size make sure it is valid data
        fread(buffer + i, chunkSize, 1, file);
        for (y = 0;y < chunkSize;y++) {
            if (!isxdigit(buffer[y + i]) && (buffer[y + i] < 'a' || buffer[y + i] > 'f' || buffer[y + i] < 'A' || buffer[y + i] > 'F')) {
                if (feof(file)) {
                    breakFromLoop = 1;
                    readIndex += y;
                    break;
                }
                else {
                    fclose(file);
                    return AX_CLI_FILE_FORMAT_ERROR;
                }
            }
        }
        if (breakFromLoop) {
            break;
        }
        // Now make sure this is the end of line size of chunk data
        fread(tmp, 1, 1, file);
        if (tmp[0] == '\r') {
            fread(tmp, 1, 1, file);
        }
        if (tmp[0] != '\n') {
            fclose(file);
            return AX_CLI_FILE_FORMAT_ERROR;
        }
        readIndex += chunkSize;
        // End of file exit reading loop
        if (feof(file)) {
            break;
        }
    }
    buffer[readIndex] = 0x0;
    fclose(file);
    bufSize = strlen((const char *)buffer);
    axConvertHexString2ByteArray(byteArray, (const char *)buffer, 0, bufSize / 2);

    switch (cmdType) {
    case A71_OBJ_WRITE:
        // Create object
        nRet = a7xConfigCmdWriteObj(index, (U8 *)byteArray, (U16)(bufSize / 2), sw);
        break;
    case A71_OBJ_UPDATE:
        // Create object
        nRet = (U16)a7xConfigCmdUpdateObj(index, offset, (U8 *)byteArray, (U16)(bufSize / 2), sw);
        break;
    default:
        return AX_CLI_ARG_VALUE_ERROR;
    };

    if (buffer) { free(buffer); }
    return nRet;
}
/**
* a7xConfigCmdWriteObjFromfile - create object from file
*/
int a7xConfigCmdWriteObjFromfile(int index, char *szFilename, int chunkSize, a71_ObjCmdClass_t cmdType, U16 *sw) {
    return SetObjectFromFile(index, 0, szFilename, chunkSize, cmdType, sw);
}

/**
* a7xConfigCmdUpdateObjFromfile - update object from file
*/
int a7xConfigCmdUpdateObjFromfile(int index, int offset, char *szFilename, int chunkSize, a71_ObjCmdClass_t cmdType, U16 *sw) {
    return SetObjectFromFile(index, offset, szFilename, chunkSize, cmdType, sw);
}

/**
* a7xConfigCmdUpdateObjFromfile - update object from hex data
*/
int a7xConfigCmdUpdateObj(int index, int offset, U8 * objData, U16 objDataLen, U16 *sw) {
    HLSE_RET_CODE nRet = AX_CLI_EXEC_FAILED;
    HLSE_ATTRIBUTE attr;
    HLSE_RET_CODE hlseRc;
    HLSE_OBJECT_HANDLE objHandles[5];
    HLSE_DIRECT_ACCESS_ATTRIBUTE_VALUE theValue;
    HLSE_OBJECT_HANDLE curHandle;
    HLSE_OBJECT_HANDLE objHandle;
    U16 objHandlesNum = sizeof(objHandles) / sizeof(HLSE_OBJECT_HANDLE);
    int handleWasSet = 0;
    int i;

    // Set curHandle
    curHandle = index;

    attr.type = HLSE_ATTR_DIRECT_ACCESS_OBJECT_VALUE;

    theValue.offset = (U16)offset;
    theValue.bytes = objDataLen;
    theValue.buffer = objData;
    theValue.bufferLen = objDataLen;

    attr.value = &theValue;
    attr.valueLen = sizeof(theValue);

    // Enumerate handles
    objHandlesNum = sizeof(objHandles) / sizeof(HLSE_OBJECT_HANDLE);
    hlseRc = HLSE_EnumerateObjects(HLSE_DATA, objHandles, &objHandlesNum);
    if (hlseRc != HLSE_SW_OK) { return AX_CLI_NO_OBJECTS; }

    // Find object handle
    // Find handle
    for (i = 0;i < 5;i++) {
        if ((objHandles[i] & 0xF) == curHandle) {
            objHandle = objHandles[i];
            handleWasSet = 1;
            break;
        }
    }
    if (!handleWasSet) { return AX_CLI_OBJECT_NOT_FOUND; }

    nRet = HLSE_SetObjectAttribute(objHandle, &attr);
    if (nRet != HLSE_SW_OK) {
        *sw = nRet;
        return AX_CLI_EXEC_FAILED;
    }
    else { *sw = 0x9000; }

    return AX_CLI_EXEC_OK;

}

/**
* a7xConfigCmdReadObj - read object data at offset
*/
int a7xConfigCmdReadObj(int index, int offset, int length, int chunkSize, char *szFilename, U16 *sw) {
    HLSE_RET_CODE nRet = AX_CLI_EXEC_FAILED;
    HLSE_ATTRIBUTE attr;
    int i;
    int curLength = 0;
    int writeLength = 0;
    HLSE_RET_CODE hlseRc;
    HLSE_DIRECT_ACCESS_ATTRIBUTE_VALUE theValue;
    HLSE_OBJECT_HANDLE objHandles[5];
    HLSE_OBJECT_HANDLE curHandle;
    HLSE_OBJECT_HANDLE readHandle;
    int handleWasSet = 0;
    U16 objHandlesNum = sizeof(objHandles) / sizeof(HLSE_OBJECT_HANDLE);
    U8 buffer[4096]; // a buffer to hold the read data
    char objData[4096];
    int objDataBufSize = sizeof(objData);
    FILE * pFile = NULL;
    int saveObj = 0;

    if (chunkSize != 64 && chunkSize != 32) {
        return AX_CLI_ARG_RANGE_ERROR;
    }

    // Check if we have file name
    if (szFilename[0] != 0x0) { saveObj = 1; }

    // Set curHandle
    curHandle = index;

    // Enumerate handles
    objHandlesNum = sizeof(objHandles) / sizeof(HLSE_OBJECT_HANDLE);
    hlseRc = HLSE_EnumerateObjects(HLSE_DATA, objHandles, &objHandlesNum);
    if (hlseRc != HLSE_SW_OK) { return AX_CLI_NO_OBJECTS; }

    // Find handle
    for (i = 0;i < objHandlesNum;i++) {
        if ((objHandles[i] & 0xF) == curHandle) {
            readHandle = objHandles[i];
            handleWasSet = 1;
            break;
        }
    }
    if (!handleWasSet) { return AX_CLI_OBJECT_NOT_FOUND; }

    if (length > 0) {
        attr.type = HLSE_ATTR_DIRECT_ACCESS_OBJECT_VALUE;
        theValue.offset = (U16)offset;
        theValue.bytes = (U16)length;
        theValue.buffer = buffer;
        theValue.bufferLen = sizeof(buffer);

        attr.value = &theValue;
        attr.valueLen = sizeof(theValue);
    }
    else {
        attr.type = HLSE_ATTR_OBJECT_VALUE;
        attr.value = buffer;
        attr.valueLen = sizeof(buffer);;
    }

    nRet = HLSE_GetObjectAttribute(readHandle, &attr);
    if (nRet != HLSE_SW_OK) {
        *sw = nRet;
        return AX_CLI_EXEC_FAILED;
    }
    else { *sw = 0x9000; }
    if (length > 0) {
        axPrintByteArray("OBJ_DATA", (U8*)theValue.buffer, theValue.bufferLen, AX_COMPACT_32);
        writeLength = curLength = theValue.bufferLen;
    }
    else {
        axPrintByteArray("OBJ_DATA", (U8*)attr.value, attr.valueLen, AX_COMPACT_32);
        writeLength = curLength = attr.valueLen;
    }

    // Create file according to the user file path
    if (saveObj) {
        if (length > 0) {
            axConvertByteArray2HexString(objData, objDataBufSize, theValue.buffer, theValue.bufferLen, AX_COMPACT_LINE);
        }
        else {
            axConvertByteArray2HexString(objData, objDataBufSize, attr.value, attr.valueLen, AX_COMPACT_LINE);
        }
        pFile = fopen(szFilename, "w");
        writeLength = writeLength * 2;
        if (pFile) {
            for (i = 0;i < curLength * 2;i += chunkSize) {
                if (writeLength < chunkSize) {
                    fwrite(objData + i, writeLength, 1, pFile);
                    writeLength -= writeLength;
                }
                else {
                    fwrite(objData + i, chunkSize, 1, pFile);
                    writeLength -= chunkSize;
                }
                if ((i + chunkSize) < curLength*2) {
                    fwrite("\n", sizeof(char), 1, pFile);
                }
            }
            fclose(pFile);
        }
        else {
            return AX_CLI_EXEC_FAILED;
        }

    }

    return AX_CLI_EXEC_OK;
}

/**
* a7xConfigCmdEraseObj - erase object at index x
*/
int a7xConfigCmdEraseObj(int index, U16 *sw) {
    int i;
    HLSE_RET_CODE hlseRc;
    HLSE_OBJECT_HANDLE objHandles[5];
    HLSE_OBJECT_HANDLE curHandle;
    HLSE_OBJECT_HANDLE eraseHandle;
    int handleWasSet = 0;
    U16 objHandlesNum = sizeof(objHandles) / sizeof(HLSE_OBJECT_HANDLE);

    *sw = 0x0000;

    memset(objHandles, 0x00, sizeof(objHandles));

    // Get Index
    curHandle = index;

    // Enumerate handles
    objHandlesNum = sizeof(objHandles) / sizeof(HLSE_OBJECT_HANDLE);
    hlseRc = HLSE_EnumerateObjects(HLSE_DATA, objHandles, &objHandlesNum);
    if (hlseRc != HLSE_SW_OK) { return AX_CLI_NO_OBJECTS; }

    // Find handle
    for (i = 0;i < objHandlesNum;i++) {
        if ((objHandles[i] & 0xF) == curHandle) {
            eraseHandle = objHandles[i];
            handleWasSet = 1;
            break;
        }
    }
    if (!handleWasSet) { return AX_CLI_OBJECT_NOT_FOUND; }

    // Erase
    hlseRc = HLSE_EraseObject(eraseHandle);
    if (hlseRc != HLSE_SW_OK) {
        *sw = hlseRc;
        return AX_CLI_EXEC_FAILED;
    }
    else { *sw = 0x9000; }

    return AX_CLI_EXEC_OK;
}