/* Copyright 2018,2020 NXP
 * SPDX-License-Identifier: Apache-2.0
 */
#include "sm_types.h"
#include "windows.h"
#include <stdlib.h>
#include <stdio.h>
#include "smComSerial.h"
#include "WinDef.h"
#include "WinBase.h"
#include "string.h"
#include <assert.h>
#define REMOTE_JC_SHELL_HEADER_LEN (4)
#define REMOTE_JC_SHELL_MSG_TYPE_APDU_DATA (0x01)
#include "sm_apdu.h"
#define MAX_BUF_SIZE (MAX_APDU_BUF_LENGTH)

#ifdef FLOW_VERBOSE
#define NX_LOG_ENABLE_SMCOM_DEBUG 1
#endif

#include "nxLog_smCom.h"
#include "nxEnsure.h"

#define MTY_ATR 0x00
#define MTY_CLOSE 0x03
#define NAD 0x00

static U8 Header[2] = {0x01, 0x00};
static U8 sockapdu[MAX_BUF_SIZE];
static U8 response[MAX_BUF_SIZE];
static U8 *pCmd = (U8 *)&sockapdu;
static U8 *pRsp = (U8 *)&response;

static HANDLE gpComHandle = INVALID_HANDLE_VALUE;

static void escapeComPortName(char pOutPortName[20], const char *iPortName)
{
    ENSURE_OR_GO_EXIT(iPortName != NULL);
    ENSURE_OR_GO_EXIT(strlen(iPortName) < 20);
    strncpy(pOutPortName, iPortName, strlen(iPortName));
    if (0 == _strnicmp(iPortName, "COM", 3)) {
        long number = atol(&iPortName[3]);
        if (number > 4) {
            _snprintf(pOutPortName, 20, "\\\\.\\%s", iPortName);
        }
    }
    else {
        _snprintf(pOutPortName, 20, "%s", iPortName);
    }
exit:
    return;
}

U32 smComVCom_Open(void** vcom_ctx, const char *pComPortString)
{
    U32 status = 0;
    COMMTIMEOUTS cto;
    char escaped_port_name[20] = {0};
    HANDLE pComHandle = INVALID_HANDLE_VALUE;
#ifdef UNICODE
    wchar_t wPortName[20] = {0};
#endif
    /* Prepare CTO structure */
    cto.ReadTotalTimeoutConstant = 500;
    cto.ReadTotalTimeoutMultiplier = 0;
    cto.ReadIntervalTimeout = 10;
    cto.WriteTotalTimeoutConstant = 0;
    cto.WriteTotalTimeoutMultiplier = 0;

    escapeComPortName(escaped_port_name, pComPortString);

    printf("Opening COM Port '%s'\n", escaped_port_name);
    if (pComHandle != INVALID_HANDLE_VALUE) {
        printf("\n Already  COM Port Open \n ");
        return SMCOM_COM_ALREADY_OPEN;
    }

#ifdef UNICODE
    mbstowcs(wPortName, escaped_port_name, sizeof(wPortName) / sizeof(wPortName[0]));
    pComHandle = CreateFile(wPortName, GENERIC_READ | GENERIC_WRITE, 0, NULL, OPEN_EXISTING, 0, NULL);
#else
    pComHandle = CreateFile(escaped_port_name, GENERIC_READ | GENERIC_WRITE, 0, NULL, OPEN_EXISTING, 0, NULL);
#endif

    status = GetLastError();

    if (status == ERROR_SUCCESS) {
        status = smComVCom_SetState(pComHandle);

        if (status == 0) {
            if (SetCommTimeouts(pComHandle, &cto) == false) {
                status = 1;
            }
        }
    }
    else if (ERROR_FILE_NOT_FOUND == status) {
        printf("ERROR! Failed opening '%s'. ERROR=ERROR_FILE_NOT_FOUND\n", pComPortString);
    }
    else if (ERROR_ACCESS_DENIED == status) {
        printf("ERROR! Failed opening '%s'. ERROR=ERROR_ACCESS_DENIED\n", pComPortString);
    }
    else if (pComHandle == INVALID_HANDLE_VALUE) {
        if (status == 0)
            status = 1; /* Over ride - it's a failure */
        printf("ERROR! Failed opening '%s'. ERROR=%X\n", escaped_port_name, status);
    }

    if (vcom_ctx == NULL) {
        gpComHandle = pComHandle;
    }
    else {
        *vcom_ctx = pComHandle;
        gpComHandle = pComHandle;
    }
    return status;
}

U32 smComVCom_SetState(void* conn_ctx)
{
    DCB dcb;
    memset(&dcb, 0, sizeof(dcb));
    HANDLE pComHandle = (conn_ctx == NULL) ? gpComHandle : (HANDLE)conn_ctx;

    dcb.DCBlength = sizeof(DCB);
    dcb.BaudRate = 115200;
    dcb.fBinary = true;
    dcb.fParity = false;
    dcb.fOutxCtsFlow = false;
    dcb.fOutxDsrFlow = false;
    dcb.fDtrControl = DTR_CONTROL_DISABLE;
    dcb.fDsrSensitivity = false;
    dcb.fTXContinueOnXoff = true;
    dcb.fOutX = false;
    dcb.fInX = false;
    dcb.fErrorChar = false;
    dcb.fNull = false;
    dcb.fRtsControl = RTS_CONTROL_DISABLE;
    dcb.fAbortOnError = false;
    dcb.XonLim = 0;
    dcb.XoffLim = 0;
    dcb.ByteSize = 8;
    dcb.Parity = NOPARITY;
    dcb.StopBits = ONESTOPBIT;

    if (SetCommState(pComHandle, &dcb) == false) {
        return 1;
    }
    else {
        EscapeCommFunction(pComHandle, SETDTR);
        smCom_Init(&smComVCom_Transceive, &smComVCom_TransceiveRaw);
        return 0;
    }
}

U32 smComVCom_GetATR(void* conn_ctx, U8 *pAtr, U16 *atrLen)
{
    int retval;
    HANDLE pComHandle = (conn_ctx == NULL) ? gpComHandle : (HANDLE)conn_ctx;
    U32 expectedLength = 0;
    U32 totalReceived = 0;
    U8 lengthReceived = 0;
    DWORD WrittenLen = 0;
    U8 status;
    U32 rc = 1;

    // wait 256 ms
    U8 ATRCmd[4] = {MTY_ATR, NAD, 0, 0};

    ENSURE_OR_GO_EXIT(pAtr != NULL);
    ENSURE_OR_GO_EXIT(atrLen != NULL);

    LOG_MAU8_D("Get ATR", ATRCmd, sizeof(ATRCmd));
    status = WriteFile(pComHandle, ATRCmd, sizeof(ATRCmd), &WrittenLen, NULL);
    if ((status == 0) || (WrittenLen != sizeof(ATRCmd))) {
        return 1;
    }

    expectedLength = REMOTE_JC_SHELL_HEADER_LEN; // remote JC shell header length

    while (totalReceived < expectedLength) {
        U32 maxCommLength;
        DWORD numBytesRead = 0;
        if (lengthReceived == 0) {
            maxCommLength = REMOTE_JC_SHELL_HEADER_LEN - totalReceived;
        }
        else {
            maxCommLength = expectedLength - totalReceived;
        }

        status = ReadFile(pComHandle, (char *)&pAtr[totalReceived], maxCommLength, &numBytesRead, NULL);
        retval = numBytesRead;
        if ((retval < 0) || (status == 0)) {
            fprintf(stderr, "Client: recv() failed: error %i.\n", retval);
            return 1;
        }
        else {
            totalReceived += retval;
        }
        if ((totalReceived >= REMOTE_JC_SHELL_HEADER_LEN) && (lengthReceived == 0)) {
            expectedLength += ((pAtr[2] << 8) | (pAtr[3]));
            lengthReceived = 1;
        }
    }
    retval = totalReceived;
    LOG_AU8_D(pAtr, retval);

    retval -= 4; // Remove the 4 bytes of the Remote JC Terminal protocol
    memmove(pAtr, pAtr + 4, retval);

    *atrLen = (U16)retval;
    rc = 0;
exit:
    return rc;
}

U32 smComVCom_Transceive(void *conn_ctx, apdu_t *pApdu)
{
    int retval;
#if defined(LOG_SOCK)
    int i;
#endif
    U32 txLen = 0;
    U32 expectedLength = 0;
    U32 totalReceived = 0;
    U8 lengthReceived = 0;
    U8 status;
    DWORD WrittenLen = 0;
    U32 rv = SMCOM_SND_FAILED;
    HANDLE pComHandle = (conn_ctx == NULL) ? gpComHandle : (HANDLE)conn_ctx;

    ENSURE_OR_GO_EXIT(pApdu != NULL);

    pApdu->rxlen = 0;
    memset(sockapdu, 0x00, MAX_BUF_SIZE);
    memset(response, 0x00, MAX_BUF_SIZE);

    // remote JC Terminal header construction
    txLen = pApdu->buflen;
    memcpy(pCmd, Header, sizeof(Header));
    pCmd[2] = (txLen & 0xFF00) >> 8;
    pCmd[3] = txLen & 0xFF;
    memcpy(&pCmd[4], pApdu->pBuf, pApdu->buflen);
    pApdu->buflen += 4; /* header & length */

#ifdef LOG_SOCK
    sm_printf(CONSOLE, "   send: ");
    for (i = 4; i < (txLen + 4); i++) {
        sm_printf(CONSOLE, "%02X", pCmd[i]);
    }
    sm_printf(CONSOLE, "\n");
#endif

    LOG_MAU8_D("H>", pCmd, 4);
    LOG_MAU8_D("Tx>", pCmd + 4, pApdu->buflen - 4);
    status = WriteFile(pComHandle, pCmd, pApdu->buflen, &WrittenLen, NULL);
    if ((status == 0) || (WrittenLen != pApdu->buflen)) {
        fprintf(stderr, "Client: send() failed: error %i.\n", WrittenLen);
        return SMCOM_SND_FAILED;
    }

    expectedLength = REMOTE_JC_SHELL_HEADER_LEN; // remote JC shell header length

    while (totalReceived < expectedLength) {
        DWORD numBytesRead = 0;
        status = ReadFile(pComHandle, (char *)&pRsp[totalReceived], MAX_BUF_SIZE, &numBytesRead, NULL);
        retval = numBytesRead;

        if ((retval < 0) || (status == 0)) {
            fprintf(stderr, "Client: recv() failed: error %i.\n", retval);
            rv = SMCOM_RCV_FAILED;
            goto exit;
        }
        else {
            totalReceived += retval;
        }
        if ((totalReceived >= REMOTE_JC_SHELL_HEADER_LEN) && (lengthReceived == 0)) {
            expectedLength += ((pRsp[2] << 8) | (pRsp[3]));
            lengthReceived = 1;
        }
    }
    retval = totalReceived;

    retval -= 4; // Remove the 4 bytes of the Remote JC Terminal protocol
    memcpy(pApdu->pBuf, &pRsp[4], retval);
    LOG_MAU8_D("<H", pRsp, 4);
    LOG_MAU8_D("<Rx", pApdu->pBuf, retval);

#ifdef LOG_SOCK
    sm_printf(CONSOLE, "   recv: ");
    for (i = 0; i < retval; i++) {
        sm_printf(CONSOLE, "%02X", pApdu->pBuf[i]);
    }
    sm_printf(CONSOLE, "\n");
#endif

    pApdu->rxlen = (U16)retval;
    // reset offset for subsequent response parsing
    pApdu->offset = 0;
    rv = SMCOM_OK;
exit:
    return rv;
}

U32 smComVCom_TransceiveRaw(void* conn_ctx, U8 *pTx, U16 txLen, U8 *pRx, U32 *pRxLen)
{
    DWORD retval;
    U32 answerReceived = 0;
    U32 len = 0;
    U8 status = 0;
    DWORD WrittenLen = 0;
#if defined(LOG_SOCK) || defined(DBG_LOG_SOCK)
    int i;
#endif
    U32 readOffset = 0;
    U8 headerParsed = 0;
    U8 correctHeader = 0;
    U32 rv = SMCOM_COM_FAILED;
    HANDLE pComHandle = (conn_ctx == NULL) ? gpComHandle : (HANDLE)conn_ctx;

    ENSURE_OR_GO_EXIT(pTx != NULL);
    ENSURE_OR_GO_EXIT(pRx != NULL);
    ENSURE_OR_GO_EXIT(pRxLen != NULL);

    memset(sockapdu, 0x00, MAX_BUF_SIZE);
    memset(response, 0x00, MAX_BUF_SIZE);

    memcpy(pCmd, Header, 2);
    pCmd[2] = (txLen & 0xFF00) >> 8;
    pCmd[3] = (txLen & 0x00FF);
    memcpy(&pCmd[4], pTx, txLen);
    txLen += 4; /* header + len */

#ifdef DBG_LOG_SOCK
    sm_printf(CONSOLE, "   full send: ");
    for (i = 0; i < txLen; i++) {
        sm_printf(CONSOLE, "%02X", pCmd[i]);
    }
    sm_printf(CONSOLE, "\n");
#endif

    LOG_MAU8_D("H>", pCmd, 4);
    LOG_MAU8_D("Tx>", pCmd + 4, txLen - 4);
    status = WriteFile(pComHandle, pCmd, txLen, &WrittenLen, NULL);
    if ((status == false) || (WrittenLen != txLen)) {
        fprintf(stderr, "Client: send() failed: error %i.\n", WrittenLen);
        return SMCOM_SND_FAILED;
    }
    else {
#ifdef DBG_LOG_SOCK
        sm_printf(CONSOLE, "Client: send() is OK.\n");
#endif
    }

#ifdef LOG_SOCK
    sm_printf(CONSOLE, "   send: ");
    for (i = 4; i < txLen; i++) {
        sm_printf(CONSOLE, "%02X", pCmd[i]);
    }
    sm_printf(CONSOLE, "\n");
#endif

    retval = REMOTE_JC_SHELL_HEADER_LEN; // receive at least the JCTerminal header

    while ((retval > 0) || (answerReceived == 0)) {
        status = ReadFile(pComHandle, (char *)pRsp, MAX_BUF_SIZE, &retval, NULL);

        if ((retval < 0) || (status == 0)) {
            return SMCOM_RCV_FAILED;
        }
        else // data received
        {
            if (retval > 4) {
                LOG_MAU8_D("<H", pRsp, 4);
                LOG_MAU8_D("<Rx", pRsp + 4, retval - 4);
            }
            while (retval > 0) // parse all bytes
            {
                if (headerParsed == 1) // header already parsed; get data
                {
                    if (retval >= (S32)len) {
                        if (correctHeader == 1) {
                            memcpy(&pRx[0], &pRsp[readOffset], len);
                            answerReceived = 1;
                        }
                        else {
                            // reset header parsed
                            readOffset += len;
                            headerParsed = 0;
                        }
                        retval -= len;

                        if (retval == 0) // no data left, reset readOffset
                        {
                            readOffset = 0;
                        }
                    }
                    else {
                        // data too small according header => Error
                        fprintf(stderr, "Failed reading data %x %x\n", retval, len);
                        return SMCOM_RCV_FAILED;
                    }
                }
                else // parse header
                {
                    len = ((pRsp[readOffset + 2] << 8) | (pRsp[readOffset + 3]));

                    if (pRsp[readOffset] == REMOTE_JC_SHELL_MSG_TYPE_APDU_DATA) {
                        // type correct => copy the data
                        retval -= REMOTE_JC_SHELL_HEADER_LEN;
                        if (retval > 0) // data left to read
                        {
                            readOffset += REMOTE_JC_SHELL_HEADER_LEN;
                        }
                        correctHeader = 1;
                    }
                    else {
                        // type incorrect => skip the data as well and try again if data are left
                        readOffset += REMOTE_JC_SHELL_HEADER_LEN;
                        retval -= REMOTE_JC_SHELL_HEADER_LEN;
                        correctHeader = 0;
                    }
                    headerParsed = 1;
                }
            }
        }
    }

#ifdef LOG_SOCK
    sm_printf(CONSOLE, "   recv: ");
    for (i = 0; i < len; i++) {
        sm_printf(CONSOLE, "%02X", pRx[i]);
    }
    sm_printf(CONSOLE, "\n");
#endif

    *pRxLen = len;

    rv = SMCOM_OK;
exit:
    return rv;
}

U32 smComVCom_Close(void* conn_ctx)
{
    int retval;
    U16 status;
    U32 u32status;
    U8 Cmd[4] = {MTY_CLOSE, NAD, 0, 0};
    DWORD WrittenLen = 0;
    U32 totalReceived = 0;
    U8 lengthReceived = 0;
    U32 expectedLength = 0;
    HANDLE pComHandle = (conn_ctx == NULL) ? gpComHandle : (HANDLE)conn_ctx;

    status = WriteFile(pComHandle, Cmd, sizeof(Cmd), &WrittenLen, NULL);
    if ((status == 0) || (WrittenLen != sizeof(Cmd))) {
        return 1;
    }

    expectedLength = REMOTE_JC_SHELL_HEADER_LEN; // remote JC shell header length

    while (totalReceived < expectedLength) {
        U32 maxCommLength;
        DWORD numBytesRead = 0;
        if (lengthReceived == 0) {
            maxCommLength = REMOTE_JC_SHELL_HEADER_LEN - totalReceived;
        }
        else {
            maxCommLength = expectedLength - totalReceived;
        }

        status = ReadFile(pComHandle, (char *)&pRsp[totalReceived], maxCommLength, &numBytesRead, NULL);
        retval = numBytesRead;
        if ((retval < 0) || (status == 0)) {
            fprintf(stderr, "Client: recv() failed: error %i.\n", retval);
            return 1;
        }
        else {
            totalReceived += retval;
        }
        if ((totalReceived >= REMOTE_JC_SHELL_HEADER_LEN) && (lengthReceived == 0)) {
            expectedLength += ((pRsp[2] << 8) | (pRsp[3]));
            lengthReceived = 1;
        }
    }
    retval = totalReceived;
    status = CloseHandle(pComHandle);
    pComHandle = INVALID_HANDLE_VALUE;

    u32status = GetLastError();
    if (u32status == ERROR_SUCCESS)
        return SMCOM_OK;
    else {
        status = (U16)u32status;
        return status;
    }
}