/*
 * Copyright (C) 2021 Huawei Device Co., Ltd.
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
#include "securec.h"
#include "uart.h"
#include "fcntl.h"
#include <dirent.h>
#include <cstring>
#include "log.h"

using namespace std;
using namespace Hdc;

bool g_ioCancel = false;

// review why not use QueryDosDevice ?
bool EnumSerialPort(bool &portChange)
{
    std::vector<string> newPortInfo;
    std::vector<string> serialPortInfo;
    std::vector<string> serialPortRemoved;
    serialPortRemoved.clear();
    bool bRet = true;

#ifdef HOST_MINGW
    constexpr int MAX_KEY_LENGTH = 255;
    constexpr int MAX_VALUE_NAME = 16383;
    HKEY hKey;
    TCHAR achValue[MAX_VALUE_NAME];    // buffer for subkey name
    DWORD cchValue = MAX_VALUE_NAME;   // size of name string
    TCHAR achClass[MAX_PATH] = _T(""); // buffer for class name
    DWORD cchClassName = MAX_PATH;     // size of class string
    DWORD cSubKeys = 0;                // number of subkeys
    DWORD cbMaxSubKey;                 // longest subkey size
    DWORD cchMaxClass;                 // longest class string
    DWORD cKeyNum;                     // number of values for key
    DWORD cchMaxValue;                 // longest value name
    DWORD cbMaxValueData;              // longest value data
    DWORD cbSecurityDescriptor;        // size of security descriptor
    FILETIME ftLastWriteTime;          // last write time
    LSTATUS iRet = -1;
    std::string port;
    TCHAR strDSName[MAX_VALUE_NAME];
    errno_t nRet = 0;
    nRet = memset_s(strDSName, sizeof(TCHAR) * MAX_VALUE_NAME, 0, sizeof(TCHAR) * MAX_VALUE_NAME);
    if (nRet != EOK) {
        return false;
    }
    DWORD nBuffLen = 10;
    if (ERROR_SUCCESS == RegOpenKeyEx(HKEY_LOCAL_MACHINE, _T("HARDWARE\\DEVICEMAP\\SERIALCOMM"), 0,
                                      KEY_READ, &hKey)) {
        // Get the class name and the value count.
        iRet = RegQueryInfoKey(hKey, achClass, &cchClassName, NULL, &cSubKeys, &cbMaxSubKey,
                               &cchMaxClass, &cKeyNum, &cchMaxValue, &cbMaxValueData,
                               &cbSecurityDescriptor, &ftLastWriteTime);
        // Enumerate the key values.
        if (ERROR_SUCCESS == iRet) {
            for (DWORD i = 0; i < cKeyNum; i++) {
                cchValue = MAX_VALUE_NAME;
                achValue[0] = '\0';
                nBuffLen = MAX_KEY_LENGTH;
                if (ERROR_SUCCESS == RegEnumValue(hKey, i, achValue, &cchValue, NULL, NULL,
                                                  (LPBYTE)strDSName, &nBuffLen)) {
#ifdef UNICODE
                    strPortName = WstringToString(strDSName);
#else
                    port = std::string(strDSName);
#endif
                    newPortInfo.push_back(port);
                    auto it = std::find(serialPortInfo.begin(), serialPortInfo.end(), port);
                    if (it == serialPortInfo.end()) {
                        portChange = true;
                    }
                } else {
                    bRet = false;
                }
            }
        } else {
            bRet = false;
        }
    } else {
        bRet = false;
    }
    RegCloseKey(hKey);
#else
    DIR *dir = opendir("/dev");
    dirent *p = nullptr;
    if (dir != nullptr) {
        while ((p = readdir(dir)) != nullptr) {
#ifdef HOST_LINUX
            if (p->d_name[0] != '.' && string(p->d_name).find("tty") != std::string::npos) {
#else
            if (p->d_name[0] != '.' && string(p->d_name).find("serial") != std::string::npos) {
#endif
                string port = "/dev/" + string(p->d_name);
                if (port.find("/dev/ttyUSB") == 0 || port.find("/dev/ttySerial") == 0 || port.find("/dev/cu.") == 0) {
                    newPortInfo.push_back(port);
                    auto it = std::find(serialPortInfo.begin(), serialPortInfo.end(), port);
                    if (it == serialPortInfo.end()) {
                        portChange = true;
                        WRITE_LOG(LOG_INFO, "new port:%s", port.c_str());
                    }
                }
            }
        }
        closedir(dir);
    }
#endif
    for (auto &oldPort : serialPortInfo) {
        auto it = std::find(newPortInfo.begin(), newPortInfo.end(), oldPort);
        if (it == newPortInfo.end()) {
            // not found in new port list
            // we need remove the connect info
            serialPortRemoved.emplace_back(oldPort);
        }
    }

    if (!portChange) {
        // new scan empty , same as port changed
        if (serialPortInfo.size() != newPortInfo.size()) {
            portChange = true;
        }
    }
    if (portChange) {
        serialPortInfo.swap(newPortInfo);
    }
    return bRet;
}

std::string CanonicalizeSpecPath(std::string &src) {
    char resolvedPath[PATH_MAX] = { 0 };
#ifdef HOST_MINGW
    if (!_fullpath(resolvedPath, src.c_str(), PATH_MAX)) {
        return "";
    }
#else
    if (realpath(src.c_str(), resolvedPath) == nullptr) {
        return "";
    }
#endif
    std::string res(resolvedPath);
    return res;
}

#ifdef HOST_MINGW

static constexpr int PORT_NAME_LEN = 10;
static constexpr int NUM = 2;

HANDLE WinOpenSerialPort(std::string portName) {
    WRITE_LOG(LOG_INFO, "WinOpenSerialPort start, portName %s", portName.c_str());
    TCHAR buf[PORT_NAME_LEN * NUM];
    #ifdef UNICODE
        _stprintf_s(buf, MAX_PATH, _T("\\\\.\\%S"), portName.c_str());
    #else
        _stprintf_s(buf, MAX_PATH, _T("\\\\.\\%s"), portName.c_str());
    #endif // UNICODE
    DWORD dwFlagsAndAttributes = FILE_ATTRIBUTE_NORMAL | FILE_FLAG_OVERLAPPED;
    HANDLE devUartHandle = CreateFile(buf, GENERIC_READ | GENERIC_WRITE, 0, NULL,
                                        OPEN_EXISTING, dwFlagsAndAttributes, NULL);
    if (devUartHandle == INVALID_HANDLE_VALUE)
    {
        WRITE_LOG(LOG_INFO, "CreateFile, open handle ok");
    } else {
        WRITE_LOG(LOG_WARN, "CreateFile open failed");
    }

    return devUartHandle;
}

bool WinSetSerialPort(HANDLE devUartHandle, string serialport, int byteSize, int baudRate) {
    bool winRet = true;
    COMMTIMEOUTS timeouts;
    GetCommTimeouts(devUartHandle, &timeouts);
    int interTimeout = 5;
    timeouts.ReadIntervalTimeout = interTimeout;
    timeouts.ReadTotalTimeoutMultiplier = 0;
    timeouts.ReadTotalTimeoutConstant = 0;
    timeouts.WriteTotalTimeoutMultiplier = 0;
    timeouts.WriteTotalTimeoutConstant = 0;
    SetCommTimeouts(devUartHandle, &timeouts);
    constexpr int max = DEFAULT_BAUD_RATE_VALUE / 8 * 2; // 2 second buffer size
    do {
        if (!SetupComm(devUartHandle, max, max)) {
            WRITE_LOG(LOG_WARN, "SetupComm %s fail, err:%lu.", serialport.c_str(), GetLastError());
            winRet = false;
            break;
        }
        DCB dcb;
        if (!GetCommState(devUartHandle, &dcb)) {
            WRITE_LOG(LOG_WARN, "GetCommState %s fail, err:%lu.", serialport.c_str(), GetLastError());
            winRet = false;
        }
        dcb.DCBlength = sizeof(DCB);
        dcb.BaudRate = baudRate;
        dcb.Parity = 0;
        dcb.ByteSize = byteSize;
        dcb.StopBits = ONESTOPBIT;
        if (!SetCommState(devUartHandle, &dcb)) {
            WRITE_LOG(LOG_WARN, "SetCommState %s fail, err:%lu.", serialport.c_str(), GetLastError());
            winRet = false;
            break;
        }
        if (!PurgeComm(devUartHandle,
                       PURGE_RXCLEAR | PURGE_TXCLEAR | PURGE_RXABORT | PURGE_TXABORT)) {
            WRITE_LOG(LOG_WARN, "PurgeComm  %s fail, err:%lu.", serialport.c_str(), GetLastError());
            winRet = false;
            break;
        }
        DWORD dwError;
        COMSTAT cs;
        if (!ClearCommError(devUartHandle, &dwError, &cs)) {
            WRITE_LOG(LOG_WARN, "ClearCommError %s fail, err:%lu.", serialport.c_str(), GetLastError());
            winRet = false;
            break;
        }
    } while (false);
    WRITE_LOG(LOG_INFO, "WinSetSerialPort ret %d\n", winRet);
    if (!winRet) {
        WinCloseSerialPort(devUartHandle);
    }
    return winRet;
}

bool WinCloseSerialPort(HANDLE &handle) {
    WRITE_LOG(LOG_DEBUG, "CloseSerialPort");
    if (handle != INVALID_HANDLE_VALUE) {
        CloseHandle(handle);
        handle = INVALID_HANDLE_VALUE;
    }
    return true;
}

ssize_t WinReadUartDev(HANDLE handle, std::vector<uint8_t> &readBuf, size_t expectedSize, OVERLAPPED &overRead) {
    ssize_t totalBytesRead = 0;
    uint8_t uartReadBuffer[MAX_UART_SIZE_IOBUF];
    DWORD bytesRead = 0;

    do {
        bytesRead = 0;
        BOOL bReadStatus = ReadFile(handle, uartReadBuffer, sizeof(uartReadBuffer), &bytesRead, &overRead);
        if (!bReadStatus) {
            if (GetLastError() == ERROR_IO_PENDING) {
                bytesRead = 0;
                DWORD dwMilliseconds = READ_GIVE_UP_TIME_OUT_TIME_MS;
                if (expectedSize == 0) {
                    dwMilliseconds = INFINITE;
                }
                if (!GetOverlappedResultEx(handle, &overRead, &bytesRead,
                                           dwMilliseconds, FALSE)) {
                    // wait io failed
                    DWORD error = GetLastError();
                    if (error == ERROR_OPERATION_ABORTED) {
                        totalBytesRead += bytesRead;
                        WRITE_LOG(LOG_WARN, "%s error cancel read. %lu %zd",
                                  __FUNCTION__, bytesRead, totalBytesRead);
                        return totalBytesRead;
                    } else if (error == WAIT_TIMEOUT) {
                        totalBytesRead += bytesRead;
                        WRITE_LOG(LOG_WARN, "%s error timeout. %lu %zd",
                                  __FUNCTION__, bytesRead, totalBytesRead);
                        return totalBytesRead;
                    } else {
                        WRITE_LOG(LOG_WARN, "%s error wait io:%lu.", __FUNCTION__, GetLastError());
                    }
                    return -1;
                }
            } else {
                // not ERROR_IO_PENDING
                WRITE_LOG(LOG_WARN, "%s  err:%lu. ", __FUNCTION__, GetLastError());
                return -1;
            }
        }
        if (bytesRead > 0) {
            readBuf.insert(readBuf.end(), uartReadBuffer, uartReadBuffer + bytesRead);
            totalBytesRead += bytesRead;
        }
    } while (readBuf.size() < expectedSize || bytesRead == 0);
    return totalBytesRead;
}

ssize_t WinWriteUartDev(HANDLE handle, uint8_t *data, const size_t length, OVERLAPPED &ovWrite) {
    ssize_t totalBytesWrite = 0;
    do {
        DWORD bytesWrite = 0;
        BOOL bWriteStat = WriteFile(handle, data + totalBytesWrite, length - totalBytesWrite, &bytesWrite, &ovWrite);
        if (!bWriteStat) {
            if (GetLastError() == ERROR_IO_PENDING) {
                if (!GetOverlappedResult(handle, &ovWrite, &bytesWrite, TRUE)) {
                    WRITE_LOG(LOG_WARN, "%s error wait io:%lu. bytesWrite %lu", __FUNCTION__,
                           GetLastError(), bytesWrite);
                    return -1;
                }
            } else {
                WRITE_LOG(LOG_WARN, "%s err:%lu. bytesWrite %lu", __FUNCTION__, GetLastError(),
                       bytesWrite);
                return -1;
            }
        }
        totalBytesWrite += bytesWrite;
    } while (totalBytesWrite < signed(length));
    return totalBytesWrite;
}

#else

int GetUartSpeed(int speed) {
    switch (speed) {
        case UART_SPEED2400:
            return (B2400);
        case UART_SPEED4800:
            return (B4800);
        case UART_SPEED9600:
            return (B9600);
        case UART_SPEED115200:
            return (B115200);
        case UART_SPEED921600:
            return (B921600);
        case UART_SPEED1500000:
            return (B1500000);
        default:
            return (B921600);
    }
}

int GetUartBits(int bits) {
    switch (bits) {
        case UART_BIT1:
            return (CS7);
        case UART_BIT2:
            return (CS8);
        default:
            return (CS8);
    }
}

int OpenSerialPort(std::string portName) {
    int uartHandle = -1;
    if ((uartHandle = open(portName.c_str(), O_RDWR | O_NOCTTY | O_NDELAY)) < 0) {
        WRITE_LOG(LOG_WARN, "%s: cannot open uartHandle: errno=%d\n", portName.c_str(), errno);
        return -1;
    }
    usleep(UART_IO_WAIT_TIME_100);
    // cannot open with O_CLOEXEC, must fcntl
    fcntl(uartHandle, F_SETFD, FD_CLOEXEC);
    int flag = fcntl(uartHandle, F_GETFL);
    if (flag < 0) {
        WRITE_LOG(LOG_WARN, "fcntl failed: error=%d\n", errno);
        return -1;
    }
    uint32_t ret = static_cast<uint32_t>(flag);
    ret &= ~O_NONBLOCK;
    flag &= static_cast<int>(ret);
    fcntl(uartHandle, F_SETFL, flag);

    return uartHandle;
}

#ifdef HOST_MAC
int SetSerial(int fd, int nSpeed, int nBits, char nEvent, int nStop) {
    struct termios options, oldttys1;
    if (tcgetattr(fd, &oldttys1) != 0) {
        constexpr int buf_size = 1024;
        char buf[buf_size] = { 0 };
        strerror_r(errno, buf, buf_size);
        return ERR_GENERIC;
    }

    errno_t nRet = 0;
    nRet = memcpy_s(&options, sizeof(options), &oldttys1, sizeof(options));
    if (nRet != EOK) {
        return ERR_GENERIC;
    }
    cfmakeraw(&options);
    options.c_cc[VMIN] = 0;
    options.c_cc[VTIME] = 10; // 10 * 1/10 sec : 1 sec

    cfsetspeed(&options, B19200);
    options.c_cflag |= GetUartBits(nBits); // Use 8 bit words
    options.c_cflag &= ~PARENB;

    speed_t speed = nSpeed;
    if (ioctl(fd, IOSSIOSPEED, &speed) == -1) {
    }
    if ((tcsetattr(fd, TCSANOW, &options)) != 0) {
        return ERR_GENERIC;
    }
    if (ioctl(fd, IOSSIOSPEED, &speed) == -1) {
    }
    return RET_SUCCESS;
}
#else
int SetSerial(int fd, int nSpeed, int nBits, char nEvent, int nStop) {
    struct termios newttys1, oldttys1;
    if (tcgetattr(fd, &oldttys1) != 0) {
        constexpr int buf_size = 1024;
        char buf[buf_size] = { 0 };
        strerror_r(errno, buf, buf_size);
        return ERR_GENERIC;
    }
    bzero(&newttys1, sizeof(newttys1));
    newttys1.c_cflag = GetUartSpeed(nSpeed);
    newttys1.c_cflag |= (CLOCAL | CREAD);
    newttys1.c_cflag &= ~CSIZE;
    newttys1.c_lflag &= ~ICANON;
    newttys1.c_cflag |= GetUartBits(nBits);
    switch (nEvent) {
        case 'O':
            newttys1.c_cflag |= PARENB;
            newttys1.c_iflag |= (INPCK | ISTRIP);
            newttys1.c_cflag |= PARODD;
            break;
        case 'E':
            newttys1.c_cflag |= PARENB;
            newttys1.c_iflag |= (INPCK | ISTRIP);
            newttys1.c_cflag &= ~PARODD;
            break;
        case 'N':
            newttys1.c_cflag &= ~PARENB;
            break;
        default:
            break;
    }
    if (nStop == UART_STOP1) {
        newttys1.c_cflag &= ~CSTOPB;
    } else if (nStop == UART_STOP2) {
        newttys1.c_cflag |= CSTOPB;
    }
    newttys1.c_cc[VTIME] = 0;
    newttys1.c_cc[VMIN] = 0;
    if (tcflush(fd, TCIOFLUSH)) {
        return ERR_GENERIC;
    }
    if ((tcsetattr(fd, TCSANOW, &newttys1)) != 0) {
        return ERR_GENERIC;
    }
    return ERR_SUCCESS;
}
#endif

ssize_t ReadUartDev(int handle, std::vector<uint8_t> &readBuf, size_t expectedSize) {
    ssize_t totalBytesRead = 0;
    uint8_t uartReadBuffer[MAX_UART_SIZE_IOBUF];
    ssize_t bytesRead = 0;

    do {
        bytesRead = 0;
        int ret = 0;
        fd_set readFds;
        FD_ZERO(&readFds);
        FD_SET(handle, &readFds);
        const constexpr int msTous = 1000;
        const constexpr int sTous = 1000 * msTous;
        struct timeval tv;
        tv.tv_sec = 0;

        if (expectedSize == 0) {
            tv.tv_usec = WAIT_RESPONSE_TIME_OUT_MS * msTous;
            tv.tv_sec = tv.tv_usec / sTous;
            tv.tv_usec = tv.tv_usec % sTous;
#ifdef HDC_HOST
            // only host side need this
            // in this caes
            // We need a way to exit from the select for the destruction and recovery of the
            // serial port read thread.
            ret = select(handle + 1, &readFds, nullptr, nullptr, &tv);
#else
            ret = select(handle + 1, &readFds, nullptr, nullptr, nullptr);
#endif
        } else {
            // when we have expect size , we need timeout for link data drop issue
            tv.tv_usec = READ_GIVE_UP_TIME_OUT_TIME_MS * msTous;
            tv.tv_sec = tv.tv_usec / sTous;
            tv.tv_usec = tv.tv_usec % sTous;
            ret = select(handle + 1, &readFds, nullptr, nullptr, &tv);
        }
        if (ret == 0 and expectedSize == 0) {
            // no expect but timeout
            if (g_ioCancel) {
                g_ioCancel = true;
                return totalBytesRead;
            } else {
                continue;
            }
        } else if (ret == 0) {
            // we expected some byte , but not arrive before timeout
            return totalBytesRead;
        } else if (ret < 0) {
            return -1; // wait failed.
        } else {
            // select > 0
            size_t maxReadSize = expectedSize - static_cast<size_t>(totalBytesRead);
            if (maxReadSize > MAX_UART_SIZE_IOBUF) {
                maxReadSize = MAX_UART_SIZE_IOBUF;
            }
            bytesRead = read(handle, uartReadBuffer, maxReadSize);
            if (bytesRead <= 0) {
                // read failed !
                return -1;
            }
        }
        if (bytesRead > 0) {
            readBuf.insert(readBuf.end(), uartReadBuffer, uartReadBuffer + bytesRead);
            totalBytesRead += bytesRead;
        }
    } while (readBuf.size() < expectedSize or bytesRead == 0); // if caller know how many bytes it want
    return totalBytesRead;
}

ssize_t WriteUartDev(int handle, uint8_t *data, const size_t length) {
    ssize_t totalBytesWrite = 0;
    do {
        ssize_t bytesWrite = 0;
        bytesWrite = write(handle, data + totalBytesWrite, length - totalBytesWrite);
        if (bytesWrite < 0) {
            if (errno == EINTR or errno == EAGAIN) {
                continue;
            } else {
                // we don't know how to recory in this function
                // need reopen device ?
                constexpr int buf_size = 1024;
                char buf[buf_size] = { 0 };
                strerror_r(errno, buf, buf_size);
                return -1;
            }
        } else {
            // waits until all output written to the object referred to by fd has been transmitted.
            tcdrain(handle);
        }
        totalBytesWrite += bytesWrite;
    } while (totalBytesWrite < signed(length));

    return totalBytesWrite;
}

bool CloseSerialPort(int &handle) {
    if (handle != -1)
    {
        return CloseFd(handle) >= 0;
    } else {
        return true;
    }
}

int CloseFd(int &fd) {
    int rc = 0;
#ifndef HDC_HOST
#endif
    if (fd > 0) {
        rc = close(fd);
        if (rc < 0) {
            char buffer[Hdc::BUF_SIZE_DEFAULT] = { 0 };
#ifdef _WIN32
            strerror_s(buffer, Hdc::BUF_SIZE_DEFAULT, errno);
#else
            strerror_r(errno, buffer, Hdc::BUF_SIZE_DEFAULT);
#endif
        } else {
            fd = -1;
        }
    }
    return rc;
}

#endif