/*

 * Copyright (C) 2024 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 "host_usb.h"



#include <thread>

#include "usb_util.h"



namespace Hdc {

constexpr uint16_t DEVICE_CHECK_INTERVAL = 3000;  // ms

constexpr uint16_t BUF_SIZE_MEDIUM = 512;

constexpr uint16_t BUF_SIZE_TINY = 64;

constexpr uint8_t GLOBAL_TIMEOUT = 30;

constexpr uint16_t TIME_BASE = 1000;

constexpr uint16_t MAX_SIZE_IOBUF = 61440;



uint8_t *g_bufPtr = nullptr;



const std::string StringFormat(const char * const formater, va_list &vaArgs)

{

    std::vector<char> args(MAX_SIZE_IOBUF);

    const int retSize = vsnprintf_s(args.data(), MAX_SIZE_IOBUF, MAX_SIZE_IOBUF - 1, formater, vaArgs);

    if (retSize < 0) {

        return std::string("");

    } else {

        return std::string(args.data(), retSize);

    }

}



const std::string StringFormat(const char * const formater, ...)

{

    va_list vaArgs;

    va_start(vaArgs, formater);

    std::string ret = StringFormat(formater, vaArgs);

    va_end(vaArgs);

    return ret;

}



HostUsb::HostUsb()

{

    if (libusb_init((libusb_context **)&ctxUSB) != 0) {

        ctxUSB = nullptr;

    }

    running = false;

}



HostUsb::~HostUsb()

{

    if (running) {

        Stop();

    }

}



void HostUsb::Stop()

{

    if (!ctxUSB) {

        return;

    }

    timer->Stop();

    libusb_exit((libusb_context *)ctxUSB);

    running = false;



    if (g_bufPtr != nullptr) {

        delete[] g_bufPtr;

        g_bufPtr = nullptr;

    }

}



// Main thread USB operates in this thread

void HostUsb::UsbWorkThread(void *arg)

{

    HostUsb *thisClass = (HostUsb *)arg;

    constexpr uint8_t usbHandleTimeout = 30;  // second

    while (thisClass->running) {

        struct timeval zerotime;

        zerotime.tv_sec = usbHandleTimeout;

        zerotime.tv_usec = 0;  // if == 0,windows will be high CPU load

        libusb_handle_events_timeout(thisClass->ctxUSB, &zerotime);

    }

}



void HostUsb::WatchUsbNodeChange(void *arg)

{

    HostUsb *thisClass = (HostUsb *)arg;

    libusb_device **devs = nullptr;

    libusb_device *dev = nullptr;

    ssize_t cnt = libusb_get_device_list(thisClass->ctxUSB, &devs);

    if (cnt < 0) {

        return;

    }

    int i = 0;

    // linux replug devid increment，windows will be not

    while ((dev = devs[i++]) != nullptr) {  // must postfix++

        std::string szTmpKey = StringFormat("%d-%d", libusb_get_bus_number(dev), libusb_get_device_address(dev));

        // check is in ignore list

        UsbCheckStatus statusCheck = thisClass->mapIgnoreDevice[szTmpKey];

        if (statusCheck == HOST_USB_IGNORE || statusCheck == HOST_USB_REGISTER) {

            continue;

        }

        std::string sn = szTmpKey;

        if (thisClass->HasValidDevice(dev) && !thisClass->DetectMyNeed(dev, sn)) {

            thisClass->ReviewUsbNodeLater(szTmpKey);

        }

    }

    libusb_free_device_list(devs, 1);

}



void HostUsb::ReviewUsbNodeLater(string &nodeKey)

{

    // add to ignore list

    mapIgnoreDevice[nodeKey] = HOST_USB_IGNORE;

    RemoveIgnoreDevice(nodeKey);

}



bool HostUsb::HasValidDevice(libusb_device *device)

{

    struct libusb_config_descriptor *descConfig = nullptr;

    int ret = libusb_get_active_config_descriptor(device, &descConfig);

    if (ret != 0) {

        return false;

    }

    bool hasValid = false;

    for (unsigned int j = 0; j < descConfig->bNumInterfaces; ++j) {

        const struct libusb_interface *interface = &descConfig->interface[j];

        if (interface->num_altsetting < 1) {

            continue;

        }

        const struct libusb_interface_descriptor *ifDescriptor = &interface->altsetting[0];

        if (!IsDebuggableDev(ifDescriptor)) {

            continue;

        }

        hasValid = true;

        break;

    }

    return hasValid;

}



bool HostUsb::IsDebuggableDev(const struct libusb_interface_descriptor *ifDescriptor)

{

    constexpr uint8_t harmonyEpNum = 2;

    constexpr uint8_t harmonyClass = 0xff;

    constexpr uint8_t harmonySubClass = 0x50;

    constexpr uint8_t harmonyProtocol = 0x01;



    if (ifDescriptor->bInterfaceClass != harmonyClass || ifDescriptor->bInterfaceSubClass != harmonySubClass ||

        ifDescriptor->bInterfaceProtocol != harmonyProtocol) {

        return false;

    }

    if (ifDescriptor->bNumEndpoints != harmonyEpNum) {

        return false;

    }

    return true;

}



bool HostUsb::DetectMyNeed(libusb_device *device, string &sn)

{

    HUSB hUSB = new(std::nothrow) HdcUSB();

    if (hUSB == nullptr) {

        return false;

    }

    hUSB->device = device;

    // just get usb SN, close handle immediately

    int childRet = OpenDeviceMyNeed(hUSB);

    if (childRet < 0) {

        delete hUSB;

        return false;

    }

    UpdateUSBDaemonInfo(hUSB, STATUS_READY);

    mapIgnoreDevice[sn] = HOST_USB_REGISTER;

    mapUsbDevice[hUSB->serialNumber] = hUSB;

    return true;

}



void HostUsb::UpdateUSBDaemonInfo(HUSB hUSB, uint8_t connStatus)

{

    // add to list

    HdcDaemonInformation di;

    di.connectKey = hUSB->serialNumber;

    di.connType = CONN_USB;

    di.connStatus = connStatus;

    di.usbMountPoint = "";

    di.usbMountPoint = StringFormat("%d-%d", hUSB->busId, hUSB->devId);



    HDaemonInfo pDi = nullptr;

    HDaemonInfo hdiNew = &di;

    AdminDaemonMap(OP_QUERY, hUSB->serialNumber, pDi);

    if (!pDi) {

        AdminDaemonMap(OP_ADD, hUSB->serialNumber, hdiNew);

    } else {

        AdminDaemonMap(OP_UPDATE, hUSB->serialNumber, hdiNew);

        if (connStatus == STATUS_OFFLINE) {

            RemoveIgnoreDevice(di.usbMountPoint);

        }

    }

}



// ==0 Represents new equipment and is what we need,<0  my need

int HostUsb::OpenDeviceMyNeed(HUSB hUSB)

{

    libusb_device *device = hUSB->device;

    int ret = -1;

    int openRet = libusb_open(device, &hUSB->devHandle);

    if (openRet != LIBUSB_SUCCESS) {

        return -1;

    }

    while (running) {

        libusb_device_handle *handle = hUSB->devHandle;

        struct libusb_device_descriptor desc;

        if (CheckDescriptor(hUSB, desc)) {

            break;

        }

#ifdef HOST_MAC

        if (CheckActiveConfig(device, hUSB, desc)) {

#else

        if (CheckActiveConfig(device, hUSB)) {

#endif

            break;

        }

        

        // USB filter rules are set according to specific device pedding device

        ret = libusb_claim_interface(handle, hUSB->interfaceNumber);

        break;

    }

    if (ret) {

        // not my need device, release the device

        libusb_close(hUSB->devHandle);

        hUSB->devHandle = nullptr;

    }

    return ret;

}



int HostUsb::CheckDescriptor(HUSB hUSB, libusb_device_descriptor& desc)

{

    char serialNum[BUF_SIZE_MEDIUM] = "";

    int childRet = 0;

    uint8_t curBus = libusb_get_bus_number(hUSB->device);

    uint8_t curDev = libusb_get_device_address(hUSB->device);

    hUSB->busId = curBus;

    hUSB->devId = curDev;

    if (libusb_get_device_descriptor(hUSB->device, &desc)) {

        return -1;

    }

    // Get the serial number of the device, if there is no serial number, use the ID number to replace

    // If the device is not in time, occasionally can't get it, this is determined by the external factor, cannot be

    // changed. LIBUSB_SUCCESS

    childRet = libusb_get_string_descriptor_ascii(hUSB->devHandle, desc.iSerialNumber, (uint8_t *)serialNum,

                                                  sizeof(serialNum));

    if (childRet < 0) {

        return -1;

    } else {

        hUSB->serialNumber = serialNum;

    }

    return 0;

}



#ifdef HOST_MAC

int HostUsb::CheckActiveConfig(libusb_device *device, HUSB hUSB, libusb_device_descriptor& desc)

#else

int HostUsb::CheckActiveConfig(libusb_device *device, HUSB hUSB)

#endif

{

    struct libusb_config_descriptor *descConfig = nullptr;

    int ret = libusb_get_active_config_descriptor(device, &descConfig);

    if (ret != 0) {

#ifdef HOST_MAC

        if ((desc.bDeviceClass == 0xFF)

            && (desc.bDeviceSubClass == 0xFF)

            && (desc.bDeviceProtocol == 0xFF)) {

            ret = libusb_set_configuration(hUSB->devHandle, 1);

            if (ret != 0) {

                return -1;

            }

        }



        ret = libusb_get_active_config_descriptor(device, &descConfig);

        if (ret != 0) {

#endif

            return -1;

        }

#ifdef HOST_MAC

    }

#endif



    ret = -1;

    CheckUsbEndpoint(ret, hUSB, descConfig);

    libusb_free_config_descriptor(descConfig);

    return ret;

}



void HostUsb::CheckUsbEndpoint(int& ret, HUSB hUSB, libusb_config_descriptor *descConfig)

{

    unsigned int j = 0;

    for (j = 0; j < descConfig->bNumInterfaces; ++j) {

        const struct libusb_interface *interface = &descConfig->interface[j];

        if (interface->num_altsetting < 1) {

            continue;

        }

        const struct libusb_interface_descriptor *ifDescriptor = &interface->altsetting[0];

        if (!IsDebuggableDev(ifDescriptor)) {

            continue;

        }

        hUSB->interfaceNumber = ifDescriptor->bInterfaceNumber;

        unsigned int k = 0;

        for (k = 0; k < ifDescriptor->bNumEndpoints; ++k) {

            const struct libusb_endpoint_descriptor *ep_desc = &ifDescriptor->endpoint[k];

            if ((ep_desc->bmAttributes & 0x03) != LIBUSB_TRANSFER_TYPE_BULK) {

                continue;

            }

            if (ep_desc->bEndpointAddress & LIBUSB_ENDPOINT_IN) {

                hUSB->hostBulkIn.endpoint = ep_desc->bEndpointAddress;

                hUSB->hostBulkIn.bulkInOut = true;

            } else {

                hUSB->hostBulkOut.endpoint = ep_desc->bEndpointAddress;

                hUSB->wMaxPacketSizeSend = ep_desc->wMaxPacketSize;

                hUSB->hostBulkOut.bulkInOut = false;

            }

        }

        if (hUSB->hostBulkIn.endpoint == 0 || hUSB->hostBulkOut.endpoint == 0) {

            break;

        }

        ret = 0;

    }

}



bool HostUsb::FindDeviceByID(HUSB hUSB, const char *usbMountPoint, libusb_context *ctxUSB)

{

    libusb_device **listDevices = nullptr;

    bool ret = false;

    char tmpStr[BUF_SIZE_TINY] = "";

    int busNum = 0;

    int devNum = 0;

    int curBus = 0;

    int curDev = 0;



    int deviceNum = libusb_get_device_list(ctxUSB, &listDevices);

    if (deviceNum <= 0) {

        libusb_free_device_list(listDevices, 1);

        return false;

    }

    if (strchr(usbMountPoint, '-') && EOK == strcpy_s(tmpStr, sizeof(tmpStr), usbMountPoint)) {

        *strchr(tmpStr, '-') = '\0';

        busNum = atoi(tmpStr);

        devNum = atoi(tmpStr + strlen(tmpStr) + 1);

    } else {

        return false;

    }



    int i = 0;

    for (i = 0; i < deviceNum; ++i) {

        struct libusb_device_descriptor desc;

        if (LIBUSB_SUCCESS != libusb_get_device_descriptor(listDevices[i], &desc)) {

            continue;

        }

        curBus = libusb_get_bus_number(listDevices[i]);

        curDev = libusb_get_device_address(listDevices[i]);

        if ((curBus == busNum && curDev == devNum)) {

            hUSB->device = listDevices[i];

            int childRet = OpenDeviceMyNeed(hUSB);

            if (!childRet) {

                ret = true;

            } else {

                string key = string(usbMountPoint);

                RemoveIgnoreDevice(key);

            }

            break;

        }

    }

    libusb_free_device_list(listDevices, 1);

    return ret;

}



// multi-thread calll

void HostUsb::CancelUsbIo(HUSB hUSB)

{

    std::unique_lock<std::mutex> lock(hUSB->lockDeviceHandle);

    if (!hUSB->hostBulkIn.isShutdown) {

        if (!hUSB->hostBulkIn.isComplete) {

            libusb_cancel_transfer(hUSB->hostBulkIn.transfer);

            hUSB->hostBulkIn.cv.notify_one();

        } else {

            hUSB->hostBulkIn.isShutdown = true;

        }

    }

    if (!hUSB->hostBulkOut.isShutdown) {

        if (!hUSB->hostBulkOut.isComplete) {

            libusb_cancel_transfer(hUSB->hostBulkOut.transfer);

            hUSB->hostBulkOut.cv.notify_one();

        } else {

            hUSB->hostBulkOut.isShutdown = true;

        }

    }

}



void HostUsb::RemoveIgnoreDevice(string &mountInfo)

{

    if (mapIgnoreDevice.count(mountInfo)) {

        mapIgnoreDevice.erase(mountInfo);

    }

}



void LIBUSB_CALL HostUsb::USBBulkCallback(struct libusb_transfer *transfer)

{

    auto *ep = reinterpret_cast<HostUSBEndpoint *>(transfer->user_data);

    std::unique_lock<std::mutex> lock(ep->mutexIo);

    bool retrySumit = false;

    int childRet = 0;

    do {

        if (transfer->status != LIBUSB_TRANSFER_COMPLETED) {

            break;

        }

        if (!ep->bulkInOut && transfer->actual_length != transfer->length) {

            transfer->length -= transfer->actual_length;

            transfer->buffer += transfer->actual_length;

            retrySumit = true;

            break;

        }

    } while (false);

    while (retrySumit) {

        childRet = libusb_submit_transfer(transfer);

        if (childRet != 0) {

            transfer->status = LIBUSB_TRANSFER_ERROR;

            break;

        }

        return;

    }

    ep->isComplete = true;

    ep->cv.notify_one();

}



PersistBuffer HostUsb::ReadUsbIO(HUSB hUSB, int exceptedSize)

{

    int timeout = 0;

    int childRet = 0;

    int ret = 0;



    HostUSBEndpoint* ep = &hUSB->hostBulkIn;



    if (g_bufPtr == nullptr) {

        g_bufPtr = new uint8_t[MAX_SIZE_IOBUF];

    }



    hUSB->lockDeviceHandle.lock();

    ep->isComplete = false;

    do {

        std::unique_lock<std::mutex> lock(ep->mutexIo);

        libusb_fill_bulk_transfer(ep->transfer, hUSB->devHandle, ep->endpoint, g_bufPtr, exceptedSize,

            USBBulkCallback, ep, timeout);

        childRet = libusb_submit_transfer(ep->transfer);

        hUSB->lockDeviceHandle.unlock();

        if (childRet < 0) {

            break;

        }

        ep->cv.wait(lock, [ep]() { return ep->isComplete; });

        if (ep->transfer->status != 0) {

            break;

        }

        ret = ep->transfer->actual_length;

    } while (false);

    return PersistBuffer{reinterpret_cast<char *>(g_bufPtr), static_cast<uint64_t>(ret)};

}



HUSB HostUsb::GetUsbDevice(std::string connectKey)

{

    return mapUsbDevice[connectKey];

}



int HostUsb::WriteUsbIO(HUSB hUSB, SerializedBuffer buf)

{

    int childRet = 0;

    int ret = -14000;

    int timeout = GLOBAL_TIMEOUT * TIME_BASE;

    HostUSBEndpoint *ep = &hUSB->hostBulkOut;



    hUSB->lockDeviceHandle.lock();

    ep->isComplete = false;

    uint8_t* ptr = reinterpret_cast<uint8_t *>(buf.ptr);

    size_t size = static_cast<size_t>(buf.size);

    do {

        std::unique_lock<std::mutex> lock(ep->mutexIo);

        libusb_fill_bulk_transfer(ep->transfer, hUSB->devHandle, ep->endpoint, ptr, size, USBBulkCallback, ep,

                                  timeout);

        childRet = libusb_submit_transfer(ep->transfer);

        hUSB->lockDeviceHandle.unlock();

        if (childRet < 0) {

            break;

        }

        ep->cv.wait(lock, [ep]() { return ep->isComplete; });

        if (ep->transfer->status != 0) {

            break;

        }

        ret = ep->transfer->actual_length;

    } while (false);

    return ret;

}



int HostUsb::Initial()

{

    if (!ctxUSB) {

        return -1;

    }

    running = true;

    auto WatchUsbNodeChangeFunc = [this]() { WatchUsbNodeChange(this); };

    timer = std::make_unique<CTimer>(WatchUsbNodeChangeFunc);

    timer->Start(DEVICE_CHECK_INTERVAL);

    std::thread([this]() {

        UsbWorkThread(this);

    }).detach();

    return 0;

}



static void BuildDaemonVisableLine(HDaemonInfo hdi, bool fullDisplay, string &out)

{

    if (fullDisplay) {

        string sConn;

        string sStatus;

        switch (hdi->connType) {

            case CONN_TCP:

                sConn = "TCP";

                break;

            case CONN_USB:

                sConn = "USB";

                break;

#ifdef HDC_SUPPORT_UART

            case CONN_SERIAL:

                sConn = "UART";

                break;

#endif

            case CONN_BT:

                sConn = "BT";

                break;

            default:

                sConn = "UNKNOW";

                break;

        }

        switch (hdi->connStatus) {

            case STATUS_READY:

                sStatus = "Ready";

                break;

            case STATUS_CONNECTED:

                sStatus = "Connected";

                break;

            case STATUS_OFFLINE:

                sStatus = "Offline";

                break;

            default:

                sStatus = "UNKNOW";

                break;

        }

        out = StringFormat("%s\t\t%s\t%s\t%s\n", hdi->connectKey.c_str(), sConn.c_str(), sStatus.c_str(),

                  hdi->devName.c_str());

    } else {

        if (hdi->connStatus == STATUS_CONNECTED) {

            out = StringFormat("%s\n", hdi->connectKey.c_str());

        }

    }

}



string HostUsb::GetDaemonMapList(uint8_t opType)

{

    string ret;

    bool fullDisplay = false;

    if (opType == OP_GET_STRLIST_FULL) {

        fullDisplay = true;

    }

    lockMapDaemon.lock();

    map<string, HDaemonInfo>::iterator iter;

    string echoLine;

    for (iter = mapDaemon.begin(); iter != mapDaemon.end(); ++iter) {

        HDaemonInfo di = iter->second;

        if (!di) {

            continue;

        }

        echoLine = "";

        if (opType == OP_GET_READY_STRLIST) {

            if (di->connStatus == STATUS_READY) {

                echoLine = StringFormat("%s ", di->connectKey.c_str());

                ret += echoLine;

            }

            continue;

        }

        BuildDaemonVisableLine(di, fullDisplay, echoLine);

        ret += echoLine;

    }

    lockMapDaemon.unlock();

    return ret;

}



string HostUsb::AdminDaemonMap(uint8_t opType, const string &connectKey, HDaemonInfo &hDaemonInfoInOut)

{

    string sRet;

    switch (opType) {

        case OP_ADD: {

            HDaemonInfo pdiNew = new(std::nothrow) HdcDaemonInformation();

            if (pdiNew == nullptr) {

                break;

            }

            *pdiNew = *hDaemonInfoInOut;

            lockMapDaemon.lock();

            if (!mapDaemon[hDaemonInfoInOut->connectKey]) {

                mapDaemon[hDaemonInfoInOut->connectKey] = pdiNew;

            }

            lockMapDaemon.unlock();

            break;

        }

        case OP_GET_READY_STRLIST:

            sRet = GetDaemonMapList(opType);

            break;

        case OP_GET_STRLIST:

        case OP_GET_STRLIST_FULL: {

            sRet = GetDaemonMapList(opType);

            break;

        }

        case OP_QUERY: {

            lockMapDaemon.lock();

            if (mapDaemon.count(connectKey)) {

                hDaemonInfoInOut = mapDaemon[connectKey];

            }

            lockMapDaemon.unlock();

            break;

        }

        case OP_REMOVE: {

            lockMapDaemon.lock();

            if (mapDaemon.count(connectKey)) {

                mapDaemon.erase(connectKey);

            }

            lockMapDaemon.unlock();

            break;

        }

        case OP_GET_ANY: {

            lockMapDaemon.lock();

            map<string, HDaemonInfo>::iterator iter;

            for (iter = mapDaemon.begin(); iter != mapDaemon.end(); ++iter) {

                HDaemonInfo di = iter->second;

                // usb will be auto connected

                if (di->connStatus == STATUS_READY || di->connStatus == STATUS_CONNECTED) {

                    hDaemonInfoInOut = di;

                    break;

                }

            }

            lockMapDaemon.unlock();

            break;

        }

        case OP_WAIT_FOR_ANY: {

            lockMapDaemon.lock();

            map<string, HDaemonInfo>::iterator iter;

            for (iter = mapDaemon.begin(); iter != mapDaemon.end(); ++iter) {

                HDaemonInfo di = iter->second;

                if (di->connStatus == STATUS_CONNECTED) {

                    hDaemonInfoInOut = di;

                    break;

                }

            }

            lockMapDaemon.unlock();

            break;

        }

        case OP_UPDATE: {  // Cannot update the Object HDi lower key value by direct value

            lockMapDaemon.lock();

            HDaemonInfo hdi = mapDaemon[hDaemonInfoInOut->connectKey];

            if (hdi) {

                *mapDaemon[hDaemonInfoInOut->connectKey] = *hDaemonInfoInOut;

            }

            lockMapDaemon.unlock();

            break;

        }

        default:

            break;

    }

    return sRet;

}

}