#pragma once

#include <stdint.h>
#include <thread>
#include <functional>
#include <algorithm>
#include <memory>
#include <vector>
#include <map>
#include "camtp.h"
#include "buildconf.h"
#include "usb_gadget.h"

#include <imemory.h>

#ifdef ASYNC_EP
class async_scanner;
#endif

class UsbDevice
{
#ifdef ASYNC_EP
    async_scanner   *ascan_;

    void do_system_command(const char* cmd);

public:
    int start_scan(void);
    int stop_scan(void);
    int set_dpi(int *dpix, int* dpiy);
    int set_scan_num(int num);
    int set_img_receiver(void* api, void* param);
    int set_paper_type(int type);
    int set_pixel_type(int *type);
#endif

public:
    UsbDevice(std::function<bool(int, struct usb_ctrlrequest*, unsigned char*)> handler = std::function<bool(int, struct usb_ctrlrequest*, unsigned char*)>(),
    std::function<void(bool)> call_back = std::function<void(bool)>());
    virtual ~UsbDevice();

    int read_bulk(void* data, int size, int* err = nullptr, bool full = true);
    int write_bulk(void* data, int size, int* err = nullptr);
    int write_int(void* data, int size, int* err = nullptr);

    void abort_int();

    bool is_connected()
    {
        return b_connected;
    }

private:
    void usb_main();

    usb_gadget * init_usb_camtp_gadget(camtp_ctx * ctx);
    void deinit_usb_camtp_gadget(usb_gadget * usbctx);

    int handle_ffs_ep0(usb_gadget * ctx);
    int handle_ep0(usb_gadget * ctx);
    int add_usb_string(usb_gadget * usbctx, int id, char * string);
    void fill_ep_descriptor(camtp_ctx * ctx, usb_gadget * usbctx,struct usb_endpoint_descriptor_no_audio * desc,int index,unsigned int flags);
    void fill_if_descriptor(camtp_ctx * ctx, usb_gadget * usbctx, struct usb_interface_descriptor * desc);
    void fill_config_descriptor(camtp_ctx * ctx , usb_gadget * usbctx,struct usb_config_descriptor * desc,int total_size, int hs);
    void fill_dev_descriptor(camtp_ctx * ctx, usb_gadget * usbctx,struct usb_device_descriptor * desc);

    void handle_setup_request(usb_gadget * ctx, struct usb_ctrlrequest* setup);
    int init_eps(usb_gadget * ctx, int ffs_mode, bool open_ep = true);
    int init_ep(usb_gadget * ctx,int index,int ffs_mode, bool open_ep = true);
    int write(int fd, void* data, size_t size, int* err = nullptr);
    int read(int fd, void* data, size_t size, int* err = nullptr, bool full = true);

    int dispatch_ep0(struct usb_functionfs_event *ev, size_t len);

    static const int cacheSize;
    std::shared_ptr<camtp_ctx>  camtp_context;
    usb_gadget gadget;
    std::function<bool(int, struct usb_ctrlrequest*, unsigned char*)> ctrl_handler;
    std::function<void(bool)> connect_call;
    std::thread thread_main;
    usb_gadget *usb_ctx;
    volatile bool b_connected;

    friend class ep_waiter;
};