#include <stdlib.h>
#include <string.h>
#include "mb.h"
#include "lock.h"
#include "sensor.h"


#define RETRY_TIMES   3
#define TIMEOUT       200


typedef struct {
    lock_t        lck;
    
    sensor_all_t  all;
}sensor_handle_t;
static sensor_handle_t ssHandle={0};


static int read_reg(uint8_t addr, uint16_t reg, uint16_t *data, int cnt)
{
    int i,r=0;
    
    for(i=0; i<RETRY_TIMES; i++) {
        r = mb_read(MB_ID_SENSOR, addr, reg, data, cnt, TIMEOUT);
        if(r==cnt) {
            break;
        }
    }
    return (r==cnt)?0:-1;
}


int sensor_init(void)
{
    sensor_handle_t *h=&ssHandle;
    
    h->lck = lock_init();
    
    return 0;
}


int sensor_deinit(void)
{
    sensor_handle_t *h=&ssHandle;
    
    lock_deinit(h->lck);
    
    return 0;
}


int sensor_set(sensor_data_t *data)
{
    int i,r=-1,cnt;
    sensor_data_t *p=NULL;
    sensor_handle_t *h=&ssHandle;
    
    if(!data) {
        return -1;
    }
    lock_on(h->lck);
    for(i=0; i<h->all.cnt; i++) {
        sensor_data_t *p=&h->all.data[i];
        if(memcmp(&data->info, &p->info, sizeof(sensor_info_t))==0) {
            r = 0;
            p->info = data->info;
            break;
        }
    }
    
    if(r==-1) {
        cnt = h->all.cnt+1;
        if(h->all.data) {
            p = (sensor_data_t*)realloc(h->all.data, sizeof(sensor_data_t)*cnt);
        }
        else {
            p = (sensor_data_t*)calloc(1, sizeof(sensor_data_t));
        }
        if(p) {
            p[cnt-1].info = data->info;
            memset(&p[cnt-1].val, 0, sizeof(p[cnt-1].val));
            
            h->all.cnt = cnt;
            h->all.data = p;
            r = 0;
        }
    }
    
    if(r==0) {
        //db_update
    }
    lock_off(h->lck);
    
    return r;
}


int sensor_remove(sensor_data_t *data)
{
    int i,r=-1;
    sensor_handle_t *h=&ssHandle;
    
    if(!data) {
        return -1;
    }
    lock_on(h->lck);
    for(i=0; i<h->all.cnt; i++) {
        sensor_data_t *p=&h->all.data[i];
        if(memcmp(&data->info, &p->info, sizeof(sensor_info_t))==0) {
            r = 0;
            break;
        }
    }
    if(r==0) {  //find and remove it
        if(i!=h->all.cnt-1) {
            memmove(&h->all.data[i], &h->all.data[i+1], sizeof(sensor_data_t)*(h->all.cnt-i-1));
        }
        h->all.cnt -= 1;
    }
    lock_off(h->lck);
    
    return r;
}


static int my_read(sensor_data_t *data)
{
    int r=-1;
    uint16_t time=0;
    uint16_t tmp[10]={0};
    uint8_t addr=data->info.addr;
    sensor_handle_t *h=&ssHandle;

    switch(data->info.type) {
        case SENSOR_TYPE_TEMP_HUMI:
        {
            switch(data->info.subtype) {
                case SENSOR_TYPE_TEMP_HUMI_RSWSN01PVC:
                {
                    r = read_reg(addr, 0, tmp, 2);
                    if(r<0) {
                        return -1 ;
                    }
                    data->val[0].value = tmp[1]/10.0f; //湿度值
                    data->val[1].value = tmp[0]/10.0f; //湿度值
                }
                break;

                case SENSOR_TYPE_TEMP_HUMI_HKSHT301T1H536VRS485:    //anderson
                {
                    r = read_reg(addr, 0, tmp, 2);
                    if (r < 0) {
                        return -1;
                    }
                    data->val[0].value = tmp[0]/10.0f;   //温度值
                    data->val[1].value = tmp[1]/10.0f;   //湿度值
                }
                break;
            }
        }
        break;

        case SENSOR_TYPE_SMOKE:
        case SENSOR_TYPE_WATER:
        case SENSOR_TYPE_ACCESS:
        {
            r = -1;//read_reg(subaddr+GPIO_PD11);
            if(r<0) {
                return -1;
            }
            data->val[0].value = r;
        }
        break;

        case SENSOR_TYPE_GAS:
        {
            r = read_reg(addr, 19, tmp, 1);
            if(r<0) {
                return -1 ;
            }
            data->val[0].value = tmp[0]; //气体浓度值
        }
        break;

        case SENSOR_TYPE_AIR_PRESS:
        {

        }
        break;

        case SENSOR_TYPE_AIR_COND:
        {

        }
        break;

        case SENSOR_TYPE_TEMP_DOUBLE:
        {
            switch(data->info.subtype) {
                case SENSOR_TYPE_TEMP_HUMI_RSWSN01PVC:
                {
                    r = read_reg(addr, 0x0400, &tmp[0], 1);
                    if (r < 0) {
                        LOGE("___ sensor RSWSN01PVC 1 read failed, addr: %d\n", addr);
                        return -1;
                    }

                    r = read_reg(addr, 0x0401, &tmp[1], 1);
                    if (r < 0) {
                        LOGE("___ sensor RSWSN01PVC 2 read failed, addr: %d\n", addr);
                        return -1;
                    }
                    data->val[0].value = tmp[1]/10.0f;   //解算温度值
                    data->val[0].value = tmp[0]/10.0f;   //解算湿度值
                }
                break;
            }
        }
        break;

        case SENSOR_TYPE_TEMP:
        {
            switch(data->info.subtype) {
                case SENSOR_TYPE_TEMP_BTG50H8EL3200:
                {
                    r = read_reg(addr, 0, tmp, 1);
                    if (r < 0) {
                        LOGE("___ sensor BTG50H8EL3200 read failed, addr: %d\n", addr);
                        return -1;
                    }
                    data->val[0].value = tmp[0]/10.0f - 50;
                    //printf("___ BTG50H8EL3200 read: 0x%04x, temp: %0.2f\n", tmp, data->val[0]);
                }
                break;
            }
        }
        break;

        case SENSOR_TYPE_LEAK:
        {
            switch(data->info.subtype) {
                case SENSOR_TYPE_LEAK_XWDC01A:
                {
                    r = read_reg(addr, 0, tmp, 4);
                    if (r < 0) {
                        LOGE("___ sensor XWDC01A read failed, addr: %d\n", data->info.addr);
                        return -1;
                    }
                    //printf("___ XWDC01A read: 0x%04x, 0x%04x, 0x%04x, 0x%04x\n", tmp[0],tmp[1],tmp[2],tmp[3]);

                    data->val[0].value = 0;
                    if(tmp[0] || tmp[1]) {
                        data->val[0].value = 1;
                    }
                }
                break;
            }
        }
        break;
    }

    if(r==0) {
        data->time = mktime(localtime(NULL));
    }
    
    return r;
}


int sensor_query(void)
{
    int i,r=-1;
    sensor_handle_t *h=&ssHandle;
    
    lock_on(h->lck);
    for(i=0; i<h->all.cnt; i++) {
        r = my_read(&h->all.data[i]);
    }
    lock_off(h->lck);
    
    return 0;
}

    
int sensor_data_get(sensor_all_t *all)
{
    sensor_handle_t *h=&ssHandle;
    
    if(!all) {
        return -1;
    }
    
    lock_on(h->lck);
    *all = h->all;
    lock_off(h->lck);
    
    return 0;
}


int sensor_data_free(sensor_all_t *all)
{
    if(!all) {
        return -1;
    }
    
    if(all->data) {
        free(all->data);
        all->data = NULL;
    }
    all->cnt = 0;
    return 0;
}