#include <stdint.h>
#include <stdio.h>
#include <unistd.h>
#include <sys/time.h>
#include "key.h"
#include "gpio.h"
#include "elog.h"
#include "cfg.h"


#if 1
    #define LOGD  log_d
    #define LOGE  log_e
#else
    #define LOGD  printf
    #define LOGE  printf
#endif


#define KEY_NUM             3
#define KEY_LONG_TIME       500
#define KEY_PRESS_LEVEL     0


#if (CHIP_TYPE != CHIP_T113s)
#define K1_GPIO             101     //PD5, K1
#define K2_GPIO             102     //PD6, K2
#define K3_GPIO             104     //PD8, K3

#else

#define K1_GPIO             160     //PF0, K1
#define K2_GPIO             161     //PF1, K2
#define K3_GPIO             162     //PF2, K3

#endif





typedef struct {
    int      gpio;
    uint16_t key;
    uint8_t  active_level;
}io_info_t;
static io_info_t io_info[KEY_NUM]={
    {K1_GPIO, KEY_OK,    KEY_PRESS_LEVEL},      //S2
    {K2_GPIO, KEY_UP,    KEY_PRESS_LEVEL},      //S1
    {K3_GPIO, KEY_DOWN,  KEY_PRESS_LEVEL},      //S3
};

typedef struct {
    int         key;
    uint64_t    ms;
}key_info_t;
typedef struct {
    int         fd;
    key_info_t  k1;
    key_info_t  k2;
    int         long_trigged;
}key_data_t;
typedef struct {
    io_info_t   *io;
    key_data_t  kd[KEY_NUM];
}key_handle_t;
static key_handle_t keyHandle={0};

static uint64_t get_ms(void)
{
    struct timeval tv;
    gettimeofday(&tv, NULL);
    return (uint64_t)(tv.tv_sec)*1000 + (uint64_t)(tv.tv_usec)/1000;
}

///////////////////////////////////////////////////////////////

int key_init(void)
{
    int i;
    key_handle_t *h=&keyHandle;

    h->io = io_info;
    for(i=0; i<KEY_NUM; i++) {
        h->kd[i].fd = gpio_init(io_info[i].gpio, GPIO_IN);
        h->kd[i].k1.key = -1;
        h->kd[i].k1.ms = 0;

        h->kd[i].k2 = h->kd[i].k1;
        h->kd[i].long_trigged = 0;
    }
    return 0;
}

int key_deinit(void)
{
    int i;
    key_handle_t *h=&keyHandle;

    for(i=0; i<KEY_NUM; i++) {
        gpio_deinit(h->kd[i].fd);
    }
    return 0;
}


int key_get(key_val_t *kv)
{
    int i,r;
    key_val_t k;
    uint64_t ms_max=0;
    key_handle_t *h=&keyHandle;

    if(!kv) {
        return -1;
    }

    kv->key = -1;
    for(i=0; i<KEY_NUM; i++) {
        key_data_t *p=&h->kd[i];
        key_info_t *p1=&p->k1;
        key_info_t *p2=&p->k2;

        //r = gpio_get(h->kd[i].fd);
        r = gpio_get2(h->io[i].gpio);
        if(r==KEY_PRESS_LEVEL) {            //key pressed
            if(p1->key==-1) {
                p1->ms = get_ms();
                p1->key = h->io[i].key;
            }
            else {
                p2->ms = get_ms();
                p2->key = h->io[i].key;

#if 0
                if(!p->long_trigged && p2->ms-p1->ms>=KEY_LONG_TIME) {
                    *p1 = *p2;

                    kv->type = TYPE_LONG;
                    kv->key = p2->key;
                    p->long_trigged = 1;
                    return 0;
                }
#endif
            }
        }
        else {     
            if(p1->key>=0 && p2->key==-1) {
                p2->ms = get_ms();
                p2->key = h->io[i].key;
            }
                                     //key replease
            if(p2->key>=0) {
                kv->key = p2->key;
                if(p2->ms-p1->ms<KEY_LONG_TIME) {
                    kv->type = TYPE_SHORT;
                }
                else {
                    kv->type = TYPE_LONG;
                }
                p1->key = p2->key = -1;
                p->long_trigged = 0;
                
                return 0;
            }
        }
    }
    
    return -1;
}


int key_print(key_val_t *kv)
{
    switch(kv->key) {
        case KEY_UP:
        printf("____ KEY_UP, %s\n", (kv->type==TYPE_LONG)?"LONG":"SHORT");
        break;

        case KEY_DOWN:
        printf("____ KEY_DOWN, %s\n", (kv->type==TYPE_LONG)?"LONG":"SHORT");
        break;

        case KEY_OK:
        printf("____ KEY_OK, %s\n", (kv->type==TYPE_LONG)?"LONG":"SHORT");
        break;
    }
    return 0;
}