/*
 * Private Info
 */
typedef struct {
    char         *i2c_bus;
    ms_uint8_t    i2c_addr;
} privinfo_t;

/*
 * FrameBuffer Device
 */
typedef struct {
    privinfo_t      priv;
    ms_io_device_t  dev;
} touch_screen_dev_t;

/*
 * Device operating function set
 */
static const ms_io_driver_ops_t ts_drv_ops = {
        .type   = MS_IO_DRV_TYPE_CHR,
        .open   = __ts_open,
    	.read   = __ts_read,
        .close  = __ts_close,
        .ioctl  = __ts_ioctl,
    	.poll   = __ts_poll,
};

/*
 * Device driver
 */
static ms_io_driver_t stm32_ts_drv = {
        .nnode = {
            .name = "ts_gt9157",
        },
        .ops  = &ts_drv_ops,
};

ms_err_t ms_io_driver_register(ms_io_driver_t *drv);
ms_err_t ms_io_driver_unregister(ms_io_driver_t *drv); //此接口暂不开放

ms_err_t ms_io_device_register(ms_io_device_t *dev, const char *dev_path, 
                               const char *drv_name, ms_ptr_t ctx);
ms_err_t ms_io_device_unregister(ms_io_device_t *dev);

#define MS_TOUCH_MAX_POINT    5

typedef struct {
    uint8_t     touch_detected; // Total number of active touches detected
    ms_uint16_t touch_x[MS_TOUCH_MAX_POINT]; // Touch X[0], X[1] coordinates on 12 bits 
    ms_uint16_t touch_y[MS_TOUCH_MAX_POINT]; // Touch Y[0], Y[1] coordinates on 12 bits
    ms_uint8_t  touch_weight[MS_TOUCH_MAX_POINT]; // Weight property of each touches
    ms_uint8_t  touch_event_id[MS_TOUCH_MAX_POINT]; // Event id of each touches 
    ms_uint8_t  touch_area[MS_TOUCH_MAX_POINT]; // Touch area of each touches  
    ms_uint32_t gesture_id; // Type of gesture detected
} ms_touch_event_t;

#define __MS_IO
#include "config.h"
#include "ms_kern.h"
#include "ms_io_core.h"

/*
 * Private info
 */
typedef struct {
    ms_pollfd_t *slots[1];
} privinfo_t;

/*
 * Open device
 */
static int stm32_touch_open(ms_ptr_t ctx, ms_io_file_t *file, int oflag, ms_mode_t mode)
{
    int ret;

    if (ms_atomic_inc(MS_IO_DEV_REF(file)) == 1) {
        BSP_TS_Init(BSP_CFG_LCD_WIDTH, BSP_CFG_LCD_HEIGHT);
        ret = 0;

    } else {
        ms_atomic_dec(MS_IO_DEV_REF(file));
        ms_thread_set_errno(EBUSY);
        ret = -1;
    }

    return ret;
}

/*
 * Close device
 */
static int stm32_touch_close(ms_ptr_t ctx, ms_io_file_t *file)
{
    if (ms_atomic_dec(MS_IO_DEV_REF(file)) == 0) {
        BSP_TS_DeInit();
    }

    return 0;
}

/*
 * Control device
 */
static int stm32_touch_ioctl(ms_ptr_t ctx, ms_io_file_t *file, int cmd, void *arg)
{
    ms_thread_set_errno(EINVAL);

    return -1;
}

/*
 * Read device
 */
static ssize_t stm32_touch_read(ms_ptr_t ctx, ms_io_file_t *file, ms_ptr_t buf, size_t len)
{
    ms_touch_event_t *event = (ms_touch_event_t *)buf;
    TS_StateTypeDef state;

    BSP_TS_GetState(&state);

    event->touch_detected = state.touchDetected;
    event->touch_x[0] = state.touchX[0];
    event->touch_y[0] = state.touchY[0];

    return sizeof(ms_touch_event_t);
}

/*
 * Check device readable
 */
static ms_bool_t stm32_touch_readable_check(ms_ptr_t ctx)
{
    privinfo_t *priv = ctx;

    (void)priv;

    return MS_FALSE;
}

/*
 * Poll device
 */
static int stm32_touch_poll(ms_ptr_t ctx, ms_io_file_t *file, ms_pollfd_t *fds, ms_bool_t setup)
{
    privinfo_t *priv = ctx;

    return ms_io_poll_helper(fds, priv->slots, MS_ARRAY_SIZE(priv->slots), setup, ctx,
                             stm32_touch_readable_check, MS_NULL, MS_NULL);;
}

/*
 * Device operating function set
 */
static const ms_io_driver_ops_t stm32_touch_drv_ops = {
        .type   = MS_IO_DRV_TYPE_CHR,
        .open   = stm32_touch_open,
        .read   = stm32_touch_read,
        .ioctl  = stm32_touch_ioctl,
        .close  = stm32_touch_close,
        .poll   = stm32_touch_poll,
};

/*
 * Device driver
 */
static ms_io_driver_t stm32_touch_drv = {
        .nnode = {
            .name = "stm32_touch",
        },
        .ops = &stm32_touch_drv_ops,
};

/*
 * Register touch screen device driver
 */
ms_err_t stm32_touch_drv_register(void)
{
    return ms_io_driver_register(&stm32_touch_drv);
}

/*
 * Register touch screen device file
 */
ms_err_t stm32_touch_dev_register(const char *path)
{
    static privinfo_t priv;
    static ms_io_device_t dev;

    return ms_io_device_register(&dev, path, "stm32_touch", &priv);
}

#include <ms_rtos.h>
#include <stdlib.h>
#include <driver/ms_drv_touch.h>

#define TOUCH_DEVICE_PATH    "/dev/touch0"

int main (int argc, char **argv)
{
    int				 i;
    int              fd;
    int              ret;
    fd_set           fds_set;
    ms_touch_event_t event;
    ms_uint32_t 	 test_count = GPIO_TEST_COUNT;

    fd = ms_io_open(TOUCH_DEVICE_PATH, O_RDONLY, 0666);
    if (fd < 0) {
        ms_printf("[error]: open file %s failed!\n", TOUCH_DEVICE_PATH);
        return  (-1);
    }
    
    while (test_count--) {
        FD_ZERO(&fds_set);
        FD_SET(fd, &fds_set);

        ret = select(fd + 1, &fds_set, NULL, NULL, NULL);
        if (ret < 0) {
            ms_printf("[error]: select file %s failed!\n", TOUCH_DEVICE_PATH);
            break;
        } else {
            ret = ms_io_read(fd, &event, sizeof(ms_touch_event_t));
            if (ret < 0) {
                ms_printf("[error]: read file %s failed!\n", TOUCH_DEVICE_PATH);
            } else {
                ms_printf("[touch event]: %d point\n", event.touch_detected);
                for (i = 0; i < event.touch_detected; i++) {
                    ms_printf("x[i]: %d\n", event.touch_x[i]);
                    ms_printf("y[i]: %d\n", event.touch_y[i]);
                }
                ms_printf("\n");
            }
        }
    }

    ms_io_close(fd);
    
    return  (0);
}