/*
 * 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.
 */
#ifndef HDC_HOST_USB_H
#define HDC_HOST_USB_H

#include <memory>
#include <libusb.h>
#include "ctimer.h"
#include <map>
#include <vector>
#include <mutex>
#include <condition_variable>
#include "securec.h"
#include "ffi_utils.h"

namespace Hdc {
using namespace std;
constexpr uint16_t MAX_USBFFS_BULK = 62464;
constexpr uint16_t MAX_USBFFS_BULK2 = 63488;
enum ConnType { CONN_USB = 0, CONN_TCP, CONN_SERIAL, CONN_BT };
enum ConnStatus { STATUS_UNKNOW = 0, STATUS_READY, STATUS_CONNECTED, STATUS_OFFLINE };

enum OperateID {
    OP_ADD,
    OP_REMOVE,
    OP_QUERY,
    OP_QUERY_REF,  // crossthread query, manually reduce ref
    OP_GET_STRLIST,
    OP_GET_STRLIST_FULL,
    OP_GET_READY_STRLIST,
    OP_GET_ANY,
    OP_UPDATE,
    OP_CLEAR,
    OP_INIT,
    OP_GET_ONLY,
    OP_VOTE_RESET,
    OP_WAIT_FOR_ANY
};
struct PersistBuffer {
    char *ptr;
    uint64_t size;
};
struct HdcDaemonInformation {
    uint8_t connType;
    uint8_t connStatus;
    std::string connectKey;
    std::string usbMountPoint;
    std::string devName;
    std::string version;
};
using HDaemonInfo = struct HdcDaemonInformation *;
struct HostUSBEndpoint {
    explicit HostUSBEndpoint(uint16_t epBufSize)
    {
        endpoint = 0;
        sizeEpBuf = epBufSize;  // MAX_USBFFS_BULK
        transfer = libusb_alloc_transfer(0);
        isShutdown = true;
        isComplete = true;
        bulkInOut = false;
        buf = new (std::nothrow) uint8_t[sizeEpBuf];
        (void)memset_s(buf, sizeEpBuf, 0, sizeEpBuf);
    }
    ~HostUSBEndpoint()
    {
        libusb_free_transfer(transfer);
        delete[] buf;
    }
    uint8_t endpoint;
    uint8_t *buf;  // MAX_USBFFS_BULK
    bool isComplete;
    bool isShutdown;
    bool bulkInOut;  // true is bulkIn
    uint16_t sizeEpBuf;
    std::mutex mutexIo;
    std::mutex mutexCb;
    condition_variable cv;
    libusb_transfer *transfer;
};

struct HdcUSB {
    libusb_context *ctxUSB = nullptr;  // child-use, main null
    libusb_device *device;
    libusb_device_handle *devHandle;
    uint16_t retryCount;
    uint8_t devId;
    uint8_t busId;
    uint8_t interfaceNumber;
    std::string serialNumber;
    std::string usbMountPoint;
    HostUSBEndpoint hostBulkIn;
    HostUSBEndpoint hostBulkOut;
    HdcUSB() : hostBulkIn(MAX_USBFFS_BULK2), hostBulkOut(MAX_USBFFS_BULK) {}

    uint32_t payloadSize;
    uint16_t wMaxPacketSizeSend;
    bool resetIO;  // if true, must break write and read,default false
    std::mutex lockDeviceHandle;
    std::mutex lockSendUsbBlock;
};
using HUSB = struct HdcUSB *;

enum UsbCheckStatus {
    HOST_USB_IGNORE = 1,
    HOST_USB_READY,
    HOST_USB_REGISTER,
};

class HostUsb {
public:
    HostUsb();
    ~HostUsb();
    int Initial();
    void Stop();
    static void UsbWorkThread(void *arg);  // 3rd thread
    static void WatchUsbNodeChange(void *arg);
    static void LIBUSB_CALL USBBulkCallback(struct libusb_transfer *transfer);
    void CancelUsbIo(HUSB hUSB);
    PersistBuffer ReadUsbIO(HUSB hUsb, int exceptedSize);
    int WriteUsbIO(HUSB hUsb, SerializedBuffer buf);
    HUSB GetUsbDevice(std::string connectKey);
    string AdminDaemonMap(uint8_t opType, const string &connectKey, HDaemonInfo &hDaemonInfoInOut);
    void UpdateUSBDaemonInfo(HUSB hUSB, uint8_t connStatus);
private:
    bool DetectMyNeed(libusb_device *device, string &sn);
    void ReviewUsbNodeLater(string &nodeKey);
    void RemoveIgnoreDevice(string &mountInfo);
    void CheckUsbEndpoint(int& ret, HUSB hUSB, libusb_config_descriptor *descConfig);
#ifdef HOST_MAC
    int CheckActiveConfig(libusb_device *device, HUSB hUSB, libusb_device_descriptor& desc);
#else
    int CheckActiveConfig(libusb_device *device, HUSB hUSB);
#endif
    int OpenDeviceMyNeed(HUSB hUSB);
    bool HasValidDevice(libusb_device *device);
    int CheckDescriptor(HUSB hUSB, libusb_device_descriptor& desc);
    bool IsDebuggableDev(const struct libusb_interface_descriptor *ifDescriptor);
    bool FindDeviceByID(HUSB hUSB, const char *usbMountPoint, libusb_context *ctxUSB);
    string GetDaemonMapList(uint8_t opType);
    
    libusb_context *ctxUSB;
    bool running;
    std::map<string, UsbCheckStatus> mapIgnoreDevice;
    std::unique_ptr<CTimer> timer;
    std::map<string, HUSB> mapUsbDevice;
    std::mutex lockMapDaemon;
    map<string, HDaemonInfo> mapDaemon;
};
}
#endif