#include <string.h>
#include <stdint.h>
#include "hal_api.h"
#include <stdio.h>
#include "ql_type.h"
#include <stdio.h>
#include <time.h>

#include <stdint.h>
#include "ql_type.h"
#include "ql_power.h"
#include "ql_rtos.h"
#include "ql_application.h"
#include "ql_audio.h"
#include "ql_gpio.h"
#include "sockets.h"
#include "ql_uart.h"
#include "ql_func.h"
#include "netdb.h"
#include "ql_sim.h"
#include "ql_dev.h"
#include "ql_wtd.h"
#include "ql_fs.h"
#include "ql_fota.h"
#include "ql_sim.h"
#include "ql_ping.h"
#include "ql_nw.h"
#include "ql_atcmd.h"
#include "ql_uart.h"
#include "hal_api.h"
#include "build_macro.h"
#include "ql_rtc.h"
#include "talkingq_wss.h"
#include "ql_cell_locator.h"


int hal_os_init()
{

    return 0;
}

void* hal_os_malloc(uint32_t size)
{
    return malloc(size); 
}

/**
 * @brief 释放内存
 * 
 * @param[in] ptr 内存指针
 */
void hal_os_free(void *ptr)
{
    if(ptr==NULL)return;
    free(ptr);
}


void *hal_os_realloc(void *old, uint32_t size)
{
    return realloc(old,size);
}

int hal_os_get_localtime(char *buf)
{
    time_t _time = 0x00000001;
    struct tm now_time;
    _time = time(NULL);	
    ql_localtime_r(&_time,&now_time);
    buf[0] = now_time.tm_year+1900-2000;
	buf[1] = now_time.tm_mon+1;//0-11  0为1月
	buf[2] = now_time.tm_mday;
	buf[3] = now_time.tm_hour;
	buf[4] = now_time.tm_min;
	buf[5] = now_time.tm_sec;

    return 0;
}


int hal_os_set_localtime(char *buf)
{
    ql_rtc_time_t rtm;

    rtm.tm_sec  = buf[5];
    rtm.tm_min  = buf[4];
    rtm.tm_hour = buf[3];
    rtm.tm_mday = buf[2];
    rtm.tm_mon  = buf[1];
    rtm.tm_year = buf[0]+2000;

    return ql_rtc_set_time(&rtm);
}


int hal_os_get_boottime(char *buf)
{

    return -1;
}

int hal_os_set_time(char *buf)
{
    return -1;
}

int hal_os_set_time_sec(uint32_t sec)
{   
    return -1;
}

uint32_t hal_os_get_rand()
{
    return  ql_geu_random_number();
}

int hal_os_set_timezone(int zone)
{
    //TODO
    return 0;
}

int hal_os_get_timezone(int *zone)
{
    //TODO
    *zone = 8;
    return 0;
}

uint64_t hal_os_up_time_ms(void)
{
    return ql_rtos_get_systicks()*5;
}

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

int hal_os_log(char *tag, int level, const char *buf, int len)
{
    return 0;
}

void hal_os_task_sleep_ms(uint32_t ms)
{
    ql_rtos_task_sleep_ms(ms);
}

void hal_os_delay_us(uint32_t us)
{
    ql_rtos_delay_us(us);
}

int hal_os_get_hal_ver(char *buf)
{
    strcpy(buf,"V1");
    return 0;
}

int hal_os_get_build_model(char *buf)
{
    //strcpy(buf,CUSTOM_APP_BUILD_MODEL);
    return 0;
}

int hal_os_get_build_ver(char *buf)
{
   // sprintf(buf,"%s-%s",CUSTOM_APP_BUILD_VER,CUSTOM_APP_BUILD_TIME);
    sprintf(buf,"%s",CUSTOM_APP_BUILD_VER);
    return 0;
}

int hal_os_get_build_rev(char *buf)
{
    //strcpy(buf,CUSTOM_APP_BUILD_REV);
    
    return 0;
}

int hal_os_get_build_time(char *buf)
{
    strcpy(buf,CUSTOM_APP_BUILD_TIME);
    return 0;
}


void *hal_os_semaphore_create(void)
{
    ql_sem_t *sem = hal_os_malloc(sizeof(ql_sem_t));
    QlOSStatus err = 0;

    err = ql_rtos_semaphore_create(sem,0);
    if(err != 0){
        hal_os_free(sem);
        return NULL;
    }

    return sem;
}

int hal_os_semaphore_destroy(void **sem)
{
    if(sem==NULL)return -1;
    if(*sem==NULL)return -1;
    void **mysem = *sem;
    int ret = ql_rtos_semaphore_delete(*mysem);
    hal_os_free(*sem);
    *sem = NULL;
    return ret;
}

int hal_os_semaphore_get_cnt(void *sem, uint32_t *count)
{
    if(!sem)return-1;
    void **mysem = sem;
    if(!mysem)return-1;
    uint32 mycount=0;
    int ret = ql_rtos_semaphore_get_cnt(*mysem,&mycount);
    *count=mycount;
    return ret;
}

int hal_os_semaphore_post(void *sem)
{
    if(!sem)return-1;
    void **mysem = sem;
    if(!mysem)return-1;
    return ql_rtos_semaphore_release(*mysem);
}

int hal_os_semaphore_post_once(void *sem)
{
    if(!sem)return-1;
    void **mysem = sem;
    if(!mysem)return-1;

    uint32_t count=0;
    int ret = hal_os_semaphore_get_cnt(sem,&count);

    if(ret==0 && count>=1){
        return 1;
    }

    return ql_rtos_semaphore_release(*mysem);
}

int hal_os_semaphore_wait(void *sem, uint32_t timeout_ms)
{
    if(timeout_ms == WAIT_INFINITE) timeout_ms = 0xFFFFFFFF;
    if(!sem)return-1;
    void **mysem = sem;
    if(!mysem)return-1;
    return ql_rtos_semaphore_wait(*mysem,timeout_ms);
}

typedef struct st_ec_task
{
    ql_task_t taskRef;
    int status;
}ec_task_t;

void *hal_os_task_create(char *name, uint8_t priority, uint32_t stackSize,  void (*work_cb)(void *), void *arg)
{
    uint8_t priority_osi = 100;
    QlOSStatus err = 0;
    ec_task_t *mytsk = hal_os_malloc(sizeof(ec_task_t));


    err = ql_rtos_task_create (&mytsk->taskRef, stackSize, priority_osi, name, work_cb, arg, 3);
    if(err != 0){
        hal_os_free(mytsk);
        return NULL;
    }
    mytsk->status = 0;
    return mytsk;
}

int hal_os_task_destroy(void **thread)
{   
    ql_task_t task_del;
    int ret = 0;
    if(thread!=NULL){
        ec_task_t *mytsk = (ec_task_t *)*thread;
        if(mytsk!=NULL){
            task_del = mytsk->taskRef;
            hal_os_free(mytsk);
            mytsk=NULL;
            ql_rtos_task_delete(task_del);
        }else{
            ret = ql_rtos_task_delete(NULL);
        }
        return ret;
    }else{
        ret = ql_rtos_task_delete(NULL);
    }
    return ret;
}

typedef struct st_ec_timer
{
    ql_timer_t timer;
    void        	(*callBackRoutine)(u32);
    uint32_t timerMs;
    uint8_t timer_type;
}ec_timer_t;


void *hal_os_timer_create(void (*timer_cb)(void *), void *arg, uint8_t timer_type)
{
    ec_timer_t *timer = hal_os_malloc(sizeof(ec_timer_t));
    timer->callBackRoutine = timer_cb;
    timer->timer_type = timer_type;
    int err = ql_rtos_timer_create(&timer->timer);
    if(err != 0){
        hal_os_free(timer);
        return NULL;
    }

    return timer;
}


int hal_os_timer_start(void *timer, uint32_t timeMs)
{
    if(!timer)return-1;
    ec_timer_t *timer_t = timer;

    return  ql_rtos_timer_start(timer_t->timer,timeMs,timer_t->timer_type,timer_t->callBackRoutine,0);
}


int hal_os_timer_stop(void *timer)
{
    if(!timer)return-1;
    ec_timer_t *timer_t = timer;

    return  ql_rtos_timer_stop(timer_t->timer);
}


int hal_os_timer_destroy(void **timer){
    int ret=-1;
    if(timer==NULL)return -1;
    if(*timer!=NULL){
        ec_timer_t *timer_t = *timer;
        ret = ql_rtos_timer_delete(timer_t->timer);
        hal_os_free(*timer);
    }
    *timer = NULL;
    return ret;
}


void *hal_os_mutex_create(void)
{
    ql_mutex_t *mutex = hal_os_malloc(sizeof(ql_mutex_t));
    QlOSStatus err = 0;

    err = ql_rtos_mutex_create(mutex);
    if(err != 0){
        hal_os_free(mutex);
        return NULL;
    }

    return mutex;
}

int hal_os_mutex_destroy(void **mutex)
{
    if(mutex==NULL)return -1;
    if(*mutex == NULL)return -1;
    void **mymutex = *mutex;
    int ret = ql_rtos_mutex_delete(*mymutex);
    hal_os_free(*mutex);
    *mutex=NULL;
    return ret;
}

int hal_os_mutex_lock(void *mutex)
{
    if(!mutex)return-1;
    void **mymutex = mutex;
    if(!*mymutex)return-1;
    return ql_rtos_mutex_lock(*mymutex,10000);
}

int hal_os_mutex_try_lock(void *mutex)
{
    if(!mutex)return-1;
    void **mymutex = mutex;
    if(!*mymutex)return-1;
    return ql_rtos_mutex_try_lock(*mymutex);
}

int hal_os_mutex_unlock(void *mutex)
{
    if(!mutex)return-1;
    void **mymutex = mutex;
    if(!*mymutex)return-1;
    return ql_rtos_mutex_unlock(*mymutex);
}

void *hal_os_queue_create(uint16_t cnt, uint16_t size)
{
    ql_queue_t *queue = hal_os_malloc(sizeof(ql_queue_t));
    QlOSStatus err = 0;

    err = ql_rtos_queue_create(queue,size,cnt);
    if(err != 0){
        hal_os_free(queue);
        return NULL;
    }

    return queue;
}


int hal_os_queue_send(void *queue, void *buf, uint16_t buf_len, uint32_t timeout)
{
    if(!queue)return-1;
    void **myqueue = queue;
    if(!*myqueue)return-1;
    if(timeout == WAIT_INFINITE) timeout = 0xFFFFFFFF;
    return  ql_rtos_queue_release(*myqueue,buf_len,buf,timeout);
}


int hal_os_queue_recv(void *queue, void *buf, uint16_t buf_len, uint32_t timeout)
{
    if(!queue)return-1;
    void **myqueue = queue;
    if(!*myqueue)return-1;
    if(timeout == WAIT_INFINITE) timeout = 0xFFFFFFFF;
    return  ql_rtos_queue_wait(*myqueue,buf,buf_len,timeout);
}

int hal_os_queue_get_cnt(void *queue)
{
    if(!queue)return-1;
    void **myqueue = queue;
    if(!*myqueue)return-1;
    uint32 cnt;
    if(0== ql_rtos_queue_get_cnt(*myqueue,&cnt)){
        return cnt;
    }  
    return -1;
}


int hal_os_queue_delete(void** queue)
{
    if(queue==NULL)return -1;
    if(*queue==NULL)return -1;
    void **myqueue = *queue;
    int ret = ql_rtos_queue_delete(*myqueue);
    hal_os_free(*queue);
    *queue=NULL;
    return ret;
}

int hal_os_feed_dog()
{
  return -1;
}

int hal_os_reboot(char mode)
{
    ql_power_reset();
  return 0;
}


static int rb_get_space_free(struct ringbuffer *rb)
{
    if (!rb) {
        return -1;
    }
    if (rb->end >= rb->start) {
        return rb->length - (rb->end - rb->start)-1;
    } else {
        return rb->start - rb->end-1;
    }
}

int rb_get_space_used(struct ringbuffer *rb)
{
    if (!rb) {
        return -1;
    }
    if (rb->end >= rb->start) {
        return rb->end - rb->start;
    } else {
        return rb->length - (rb->start - rb->end);
    }
}

void *hal_os_rb_create(int len)
{
    struct ringbuffer *rb = hal_os_malloc(sizeof(struct ringbuffer));
    if (!rb) {
        RLOGE("malloc ringbuffer failed!\n");
        return NULL;
    }
    rb->length = len + 1;
    rb->start = 0;
    rb->end = 0;
    rb->buffer = hal_os_malloc(rb->length);
    if (!rb->buffer) {
        RLOGE("malloc rb->buffer failed!\n");
        hal_os_free(rb);
        return NULL;
    }
    //rb->mutex = hal_os_mutex_create();
    rb->mutex = NULL;
    return rb;
}

int hal_os_rb_destroy(void *rbx)
{
    struct ringbuffer *rb = (struct ringbuffer *)rbx;
    if (!rb) {
        return -1;
    }

    if(rb->mutex){
        hal_os_mutex_destroy(&rb->mutex);
    }

    hal_os_free(rb->buffer);
    hal_os_free(rb);
    return 0;
}

static void *rb_end_ptr(struct ringbuffer *rb)
{
    return (void *)((char *)rb->buffer + rb->end);
}

static void *rb_start_ptr(struct ringbuffer *rb)
{
    return (void *)((char *)rb->buffer + rb->start);
}

int hal_os_rb_clean(void*rbx)
{
    struct ringbuffer *rb = (struct ringbuffer *)rbx;
    if (!rb) {
        return -1;
    }

    hal_os_mutex_lock(rb->mutex);
    rb->start = 0;
    rb->end = 0;
    memset(rb->buffer,0,rb->length);
    hal_os_mutex_unlock(rb->mutex);
    return 0;
}

int hal_os_rb_write(void *rbx, const void *buf, int len, uint32_t timeout)
{
    struct ringbuffer *rb = (struct ringbuffer *)rbx;
    if (!rb) {
        return -1;
    }

    uint64_t start_ms = hal_os_up_time_ms();

    if(len==0){
        return 0;
    }

    while (timeout>0)
    {
        int left = rb_get_space_free(rb);
        if (len > left) {
            if(hal_os_up_time_ms()-start_ms>timeout){
                RLOGE("Not enough space write: %zu request, %zu available\n", len, left);
                return -1;
            }else{
                hal_os_task_sleep_ms(2);
            }
        }else{
            break;
        }
    }

    //hal_os_mutex_lock(rb->mutex);
    //ql_rtos_enter_critical();
    if ((rb->length - rb->end) < len) {
        int half_tail = rb->length - rb->end;
        memcpy(rb_end_ptr(rb), (unsigned char*)buf, half_tail);
        rb->end = (rb->end + half_tail) % rb->length;

        int half_head = len - half_tail;
        memcpy(rb_end_ptr(rb), (unsigned char*)buf+half_tail, half_head);
        rb->end = (rb->end + half_head) % rb->length;
    } else {
        memcpy(rb_end_ptr(rb), buf, len);
        rb->end = (rb->end + len) % rb->length;
    }
    //ql_rtos_exit_critical();
   // hal_os_mutex_unlock(rb->mutex);
    
    return len;
}

#define MIN(a, b)           ((a) > (b) ? (b) : (a))


int hal_os_rb_read(void*rbx, void *buf, int len, uint32_t timeout)
{
    struct ringbuffer *rb = (struct ringbuffer *)rbx;
    if (!rb) {
        return -1;
    }
    
    uint32_t start_ms = hal_os_up_time_ms();
    while (timeout>0)
    {
        int left = rb_get_space_used(rb);
        if (len > left) {
            if(hal_os_up_time_ms()-start_ms>timeout){
                RLOGE("Not enough space read: %zu request, %zu available\n", len, left);
                return -1;
            }else{
                hal_os_task_sleep_ms(2);
            }
        }else{
            break;
        }
    }
    
   // hal_os_mutex_lock(rb->mutex);
    //ql_rtos_enter_critical();
    int rlen = MIN(len, rb_get_space_used(rb));

    if ((rb->length - rb->start) < rlen) {
        int half_tail = rb->length - rb->start;
        memcpy(buf, rb_start_ptr(rb), half_tail);
        rb->start = (rb->start + half_tail) % rb->length;

        int half_head = rlen - half_tail;
        memcpy((unsigned char*)buf+half_tail, rb_start_ptr(rb), half_head);
        rb->start = (rb->start + half_head) % rb->length;
    } else {
        memcpy(buf, rb_start_ptr(rb), rlen);
        rb->start = (rb->start + rlen) % rb->length;
    }

    if ((rb->start == rb->end) || (rb_get_space_used(rb) == 0)) {
        rb->start = rb->end = 0;
    }
    //ql_rtos_exit_critical();
   // hal_os_mutex_unlock(rb->mutex);
    return rlen;
}
#if 0
static void *rb_dump(struct ringbuffer *rb, int *blen)
{
    if (!rb) {
        return NULL;
    }
    void *buf = NULL;
    int len = rb_get_space_used(rb);
    if (len <= 0) {
        return NULL;
    }
    buf = hal_os_malloc(len);
    if (!buf) {
        RLOGE("malloc %zu failed!\n", len);
        return NULL;
    }
    *blen = len;

    if ((rb->length - rb->start) < len) {
        int half_tail = rb->length - rb->start;
        memcpy(buf, rb_start_ptr(rb), half_tail);

        int half_head = len - half_tail;
        memcpy((unsigned char*)buf+half_tail, rb->buffer, half_head);
    } else {
        memcpy(buf, rb_start_ptr(rb), len);
    }
    return buf;
}

static void rb_cleanup(struct ringbuffer *rb)
{
    if (!rb) {
        return;
    }
    rb->start = rb->end = 0;
}
#endif

unsigned char calculateChecksum(unsigned char *data, int length) {
    unsigned char checksum = 0;
    for (int i = 0; i < length; i++) {
        checksum ^= data[i];
    }
    return checksum;
}

int hal_kv_set(char *key, void *val, int len)
{   
    uint8_t checkbuf[4]={0};
    int ret;
    QFILE * fp = NULL;
    char path[128]={0};

    snprintf(path,sizeof(path)-1,"U:/config_k_%s",key);

    fp = ql_fopen(path,"wb+");
    if(fp==NULL)return -1;
    checkbuf[0]=0xAA;
    checkbuf[1]=len/256;
    checkbuf[2]=len%256;
    checkbuf[3]=calculateChecksum(val,len);
    ret = ql_fwrite((void *)checkbuf, 4, 1, fp);
    if(ret != 4) 
    {
        printf("[FS]ERROR!!! *** file write fail: %s ***\r\n", path);
        ql_fclose(fp);
        return -1;
    }
    ret = ql_fwrite((void *)val, len, 1, fp);
    if(ret != len) 
    {
        printf("[FS]ERROR!!! *** file write fail: %s ***\r\n", path);
        ql_fclose(fp);
        return -1;
    }
    ql_fclose(fp);
    return 0;
}

int hal_kv_get(char *key, void *val, int len)
{
    uint8_t checkbuf[4]={0};
    int ret;
    QFILE * fp = NULL;
    char path[128]={0};
    int readlen = 0;

    snprintf(path,sizeof(path)-1,"U:/config_k_%s",key);

    fp = ql_fopen(path,"rb+");
    if(fp==NULL)return -1;
    ret = ql_fread((void *)checkbuf, 4, 1, fp);
    if(ret !=4 ) 
    {
        printf("[FS]ERROR!!! *** file read fail: %s ***\r\n", path);
        ql_fclose(fp);
        return -1;
    }
    if(checkbuf[0]!=0xAA){
        ql_fclose(fp);
        return -1;
    }
    readlen = checkbuf[1]*256+checkbuf[2];
    if(len<readlen){
        ql_fclose(fp);
        return -1;
    }
    ret = ql_fread((void *)val, readlen, 1, fp);
    if(ret !=readlen) 
    {
        printf("[FS]ERROR!!! *** file read fail: %s ***\r\n", path);
        ql_fclose(fp);
        return -1;
    }
	
	ret = calculateChecksum(val,readlen);
	
    if(ret!=checkbuf[3]){
		RLOGE("[FS]ERROR!!! *** file read fail4: %s ***\r\n", path);
        ql_fclose(fp);
        return -1;
    }

    ql_fclose(fp);
    return readlen;
}

int hal_kv_del(char *key)
{
    char path[128]={0};
    snprintf(path,sizeof(path)-1,"U:/config_k_%s",key);

    return ql_remove(path);
}

#if 0
#define DEVICE_SN_FILE			"U:/talkingq_sn.txt"
#define DEVICE_ID_FILE          "U:/talkingq_id.txt"
#define TALKINGQ_URL_FILE       "U:/talkingq_url.txt"


int read_device_sn(uint8_t *buff, int len)
{
	QFILE * fp = NULL;
	int ret = -1;
	if(ql_access(DEVICE_SN_FILE, 0)!=0){
		printf("read %s not is exist\n", DEVICE_SN_FILE);
		return -1;
	}
	
	fp = ql_fopen(DEVICE_SN_FILE, "r");
		
	if(NULL == fp)
	{
		printf("[FS]ERROR!!! *** file open fail: %s \r\n", DEVICE_SN_FILE);
		return -1;
	}
	
	ret = ql_fread(buff, len, 1, fp);
	if(ret < 0) 
	{
		printf("[FS]ERROR!!! *** file read fail: %s \r\n", DEVICE_SN_FILE);
	}
		
	ql_fclose(fp);
	fp = NULL;
	
	return ret;
}

int save_device_sn(uint8_t *buff, int len)
{
	QFILE * fp = NULL;
	int ret = -1;
	
	fp = ql_fopen(DEVICE_SN_FILE, "w+");
		
    if(NULL == fp)
    {
		printf("[FS]ERROR!!! *** file open fail: %s \r\n", DEVICE_SN_FILE);
		return -1;
	}
	
	ret = ql_fwrite(buff, len, 1, fp);
	if(ret < 0) 
	{
		printf("[FS]ERROR!!! *** file write fail: %s \r\n", DEVICE_SN_FILE);
	}

	printf("save_device_sn:%s\n", buff);

	ql_fclose(fp);
	fp = NULL;

	return ret;
}

int read_device_id(uint8_t *buff, int len)
{
	QFILE * fp = NULL;
	int ret = -1;
	if(ql_access(DEVICE_ID_FILE, 0)!=0){
		printf("read %s not is exist\n", DEVICE_ID_FILE);
		return -1;
	}
	fp = ql_fopen(DEVICE_ID_FILE, "r");
		
	if(NULL == fp)
	{
		printf("[FS]ERROR!!! *** file open fail: %s \r\n", DEVICE_ID_FILE);
		return -1;
	}
	
	ret = ql_fread(buff, len, 1, fp);
	if(ret < 0) 
	{
		printf("[FS]ERROR!!! *** file read fail: %s \r\n", DEVICE_ID_FILE);
	}
		
	ql_fclose(fp);
	fp = NULL;
	
	return ret;
}

int save_device_id(uint8_t *buff, int len)
{
	QFILE * fp = NULL;
	int ret = -1;
	
	fp = ql_fopen(DEVICE_ID_FILE, "w+");
		
    if(NULL == fp)
    {
		printf("[FS]ERROR!!! *** file open fail: %s \r\n", DEVICE_ID_FILE);
		return -1;
	}
	
	ret = ql_fwrite(buff, len, 1, fp);
	if(ret < 0) 
	{
		printf("[FS]ERROR!!! *** file write fail: %s \r\n", DEVICE_ID_FILE);
	}

	printf("save_device_id:%s\n", buff);

	ql_fclose(fp);
	fp = NULL;

	return ret;
}


int read_talkingq_url(uint8_t *buff, int len)
{
	QFILE * fp = NULL;
	int ret = -1;
	
	if(ql_access(TALKINGQ_URL_FILE, 0)!=0){
		printf("read %s not is exist\n", TALKINGQ_URL_FILE);
		return -1;
	}
	
	fp = ql_fopen(TALKINGQ_URL_FILE, "r");
		
	if(NULL == fp)
	{
		printf("[FS]ERROR!!! *** file open fail: %s \r\n", TALKINGQ_URL_FILE);
		return -1;
	}
	
	ret = ql_fread(buff, len, 1, fp);
	if(ret < 0) 
	{
		printf("[FS]ERROR!!! *** file read fail: %s \r\n", TALKINGQ_URL_FILE);
	}

	ql_fclose(fp);
	fp = NULL;

    if(strncmp(buff,"ws://",5)){
		printf("error ws url %s",buff);
		return -1;
	}
	
	return ret;
}

int save_talkingq_url(uint8_t *buff, int len)
{
	QFILE * fp = NULL;
	int ret = -1;

    if(strncmp(buff,"ws://",5)){
		printf("error ws url %s",buff);
		return -1;
	}
	
	fp = ql_fopen(TALKINGQ_URL_FILE, "w+");
		
    if(NULL == fp)
    {
		printf("[FS]ERROR!!! *** file open fail: %s \r\n", TALKINGQ_URL_FILE);
		return -1;
	}
	
	ret = ql_fwrite(buff, len, 1, fp);
	if(ret < 0) 
	{
		printf("[FS]ERROR!!! *** file write fail: %s \r\n", TALKINGQ_URL_FILE);
	}

	printf("save_talkingq_url:%s\n", buff);
	ql_fclose(fp);
	fp = NULL;

	return ret;
}
#endif
int hal_os_get_talkingq_url(char *pdevice_id)
{
  char temp_device_id[TALKINGQ_URL_CAPACITY] = {0};
  int saved = hal_kv_get("talkingq_url", temp_device_id, sizeof(temp_device_id));
  temp_device_id[sizeof(temp_device_id) - 1] = 0;

 //read_talkingq_url(temp_device_id,sizeof(temp_device_id));
 if(saved > 0 && strlen(temp_device_id)>0 && !talkingq_is_legacy_ws_url(temp_device_id)){
		strcpy(pdevice_id, temp_device_id);
  }else{
		//strcpy(pdevice_id,"ws://api.talkingq.com:8080");
		//strcpy(pdevice_id,"ws://175.24.73.253:80");
		strcpy(pdevice_id, TALKINGQ_WSS_URL);
		return -1;
  }
	return 0;
}   

int hal_os_set_talkingq_url(char *pdevice_id)
{
	char temp_device_id[64] = {0x00};
	strcpy(temp_device_id, pdevice_id);
	hal_kv_set("talkingq_url", temp_device_id, strlen(temp_device_id)+1);
//	save_talkingq_url(temp_device_id, strlen(temp_device_id)+1);

	
    return 0;
}  

int hal_os_get_device_id(char *pdevice_id)
{
  char temp_device_id[32];
  memset(temp_device_id, 0, sizeof(temp_device_id));
  hal_kv_get("device_id", temp_device_id, sizeof(temp_device_id));

// read_device_id(temp_device_id,sizeof(temp_device_id));
 if(strlen(temp_device_id)>0){
		strcpy(pdevice_id, temp_device_id);
  }else{
	//	strcpy(pdevice_id,"TalkingQ_XQSN00001005");
		return -1;
  }
	return 0;
}   

int hal_os_set_device_id(char *pdevice_id)
{
	char temp_device_id[32] = {0x00};
	strcpy(temp_device_id, pdevice_id);
	hal_kv_set("device_id", temp_device_id, strlen(temp_device_id)+1);
//	save_device_id(temp_device_id, strlen(temp_device_id)+1);

	
    return 0;
}  

int hal_os_get_device_sn(char *pdevice_sn)
{
	char temp_device_sn[32];
	memset(temp_device_sn, 0, sizeof(temp_device_sn));
	hal_kv_get("device_sn", temp_device_sn, sizeof(temp_device_sn));
	//read_device_sn(temp_device_sn, sizeof(temp_device_sn));
	if(strlen(temp_device_sn)>0){
		strcpy(pdevice_sn, temp_device_sn);
	}else{
		//strcpy(pdevice_sn,"TQ_XQSN000000001005");
		return -1;
	}
    return 0;
}

int hal_os_set_device_sn(char *pdevice_sn)
{
	char temp_device_sn[32]={0x00};
	strcpy(temp_device_sn, pdevice_sn);
	hal_kv_set("device_sn", temp_device_sn, strlen(temp_device_sn)+1);
//	save_device_sn(temp_device_sn, strlen(temp_device_sn)+1);

    return 0;
}


extern int talkingq_ws_connect();
extern int  talkingq_ws_send_text(char *senddata);
extern int audio_packet_type;


int hal_os_nfc_test(void)
{
	printf("nfc_test\r\n");
	talkingq_ws_connect();
	talkingq_ws_send_text("REGISTER_TARGET_DEVICE:TalkingQ_XQSN00001004");

	audio_packet_type = 4;
	
    return 0;
} 


int hal_os_get_model(char *model)
{
    strcpy(model,"CNLD-BK-S");
    return 0;
}


char* hal_os_get_current_version(void)
{
	return "1.0.0";
}


typedef struct hal_dev_uart_struct
{
    uint8_t portno;
    uint8_t hal_portno;
    void *ringbuf;
}hal_dev_uart_t;


void quec_uart_callback(QL_UART_PORT_NUMBER_E port, int len, void *para)
{
    hal_dev_uart_t *uart = para;
    if(para==NULL)return;
	int read_len = 0;
	char r_data[1024] = {0};
	read_len = ql_uart_read(port, r_data, sizeof(r_data));
    if(read_len>0&&uart->ringbuf!=NULL){
        hal_os_rb_write(uart->ringbuf,r_data,read_len,0);
    }
}

void * hal_dev_uart_open(uint8_t portno, char* configbuf)
{
    int ret;
    hal_dev_uart_t *uart = hal_os_malloc(sizeof(hal_dev_uart_t));
    if(!uart)return NULL;
    uart->portno = portno;
    ql_uart_config_t uart_cfg = {0};


    if(configbuf && !strcmp(configbuf,"3686400,8,n,1")){
        uart_cfg.baudrate = QL_UART_BAUD_3686400;
    }else if(configbuf && !strcmp(configbuf,"460800,8,n,1")){
        uart_cfg.baudrate = QL_UART_BAUD_460800;
    }else if(configbuf && !strcmp(configbuf,"921600,8,n,1")){
        uart_cfg.baudrate = QL_UART_BAUD_921600;
    }else if(configbuf && !strcmp(configbuf,"115200,8,n,1")){
        uart_cfg.baudrate = QL_UART_BAUD_115200;
    }else if(configbuf && !strcmp(configbuf,"9600,8,n,1")){
        uart_cfg.baudrate = QL_UART_BAUD_9600;
    }else if(configbuf && !strcmp(configbuf,"38400,8,n,1")){
        uart_cfg.baudrate = QL_UART_BAUD_38400;
    }else if(configbuf && !strcmp(configbuf,"19200,8,n,1")){
        uart_cfg.baudrate = QL_UART_BAUD_19200;
    }else if(configbuf && !strcmp(configbuf,"28800,8,n,1")){
        uart_cfg.baudrate = QL_UART_BAUD_28800;
    }else if(configbuf && !strcmp(configbuf,"57600,8,n,1")){
        uart_cfg.baudrate = QL_UART_BAUD_57600;
    }
	else{
        goto failed;
    }

    uart_cfg.flow_ctrl = QL_FC_NONE;
    uart_cfg.data_bit = QL_UART_DATABIT_8;
    uart_cfg.stop_bit = QL_UART_STOP_1;
    uart_cfg.parity_bit = QL_UART_PARITY_NONE;

    
    if(uart->portno==0){
        uart->hal_portno = QL_MAIN_UART_PORT;
    }else if(uart->portno==1){
        uart->hal_portno = QL_USB_CDC_PORT;
    }else{
        goto failed;
    }

    if(uart->portno==0){
        ret = ql_uart_set_dcbconfig(uart->hal_portno, &uart_cfg);
        if(QL_UART_SUCCESS != ret)
        {
            RLOGE("ql_uart_set_dcbconfig exit portno %d hal_portno %d",uart->portno,uart->hal_portno);
            goto failed;
        }
    }
    
    ret = ql_uart_open(uart->hal_portno,uart_cfg.baudrate,QL_FC_NONE);
    if(QL_UART_SUCCESS != ret)
	{
        RLOGE("ql_uart_open exit portno %d hal_portno %d",uart->portno,uart->hal_portno);
		goto failed;
	}

    uart->ringbuf = hal_os_rb_create(2048);
    if(!uart->ringbuf){
        RLOGE("hal_os_rb_create exit portno %d hal_portno %d",uart->portno,uart->hal_portno);
        goto failed;
    }

    ql_uart_register_cb_ex(uart->hal_portno, quec_uart_callback,uart);

    return uart;

failed:
    hal_os_free(uart);
    return NULL;
}


int32_t hal_dev_uart_write(void *uart, unsigned char *buf, uint32_t len, uint32_t timeout_ms)
{
    hal_dev_uart_t *myuart = (hal_dev_uart_t *)uart;
    uint64_t t_start = hal_os_up_time_ms();
    int ret;

    if(myuart==NULL)return -1;
   
	ret = ql_uart_write(myuart->hal_portno, buf, len);

    if(ret<0)return ret;
    return len;
}

int32_t hal_dev_uart_read(void *uart, unsigned char *buf, uint32_t len, uint32_t timeout_ms)
{
    hal_dev_uart_t *myuart = (hal_dev_uart_t *)uart;
    uint64_t t_start = hal_os_up_time_ms();
    int ret;
    int recv_index = 0;
    int recv_req = len;
    uint64_t t_start2=t_start;
    
    if(myuart==NULL){
        hal_os_task_sleep_ms(3);
        return -1;
    }

rerecv:
	ret = hal_os_rb_read(myuart->ringbuf, buf + recv_index, recv_req, 0);
	if(ret<0){
		return -1;
	}else if(ret<recv_req){
		recv_req = recv_req - ret;
		recv_index += ret;
		if(hal_os_up_time_ms()-t_start>=timeout_ms){
			ret = -3;
            if(recv_index!=0 && recv_index!=len){
			    RLOGD("uart read data timeout len %d recv %d port %d",len, recv_index, myuart->portno);
				return ret;
            }
			 	
			return recv_index;
		}else if((hal_os_up_time_ms()-t_start2)>5000){
            t_start2 = hal_os_up_time_ms();
            hal_os_feed_dog();
        }else if(ret==0 && len==1){
            hal_os_task_sleep_ms(2);
        }else if(ret==0){
            hal_os_task_sleep_ms(1);
        }
		goto rerecv;
	}
	ret = 0;

    return len;
}
int hal_dev_uart_close(void *uart)
{
    hal_dev_uart_t *myuart = (hal_dev_uart_t *)uart;
    int ret = ql_uart_close(myuart->hal_portno);
    if(myuart->ringbuf!=NULL)hal_os_rb_destroy(myuart->ringbuf);
    hal_os_free(uart);
    return ret;
}

static void ql_cell_call_back(QL_CELL_LOC_STATE_E state, ql_cell_cfg *cell_cfg)
{	
	RLOGD("cb lng: %f, lat: %f, accuracy: %d err:%d\n",cell_cfg->lng, cell_cfg->lat, cell_cfg->accuracy, cell_cfg->err.err_code);
}

#define CELL_LOCATOR_SERVER_DOMAIN "www.queclocator.com"

int hal_os_get_locator(float *lon,float *lat)
{
	int ret;
	char token [32] ="go518q365z17qA22";
    int port = 80;
	int timeout = 10;
	ql_cell_cfg *g_cell_cfg = NULL;

	RLOGD("cell_locator started!!");
	
	g_cell_cfg = malloc(sizeof(ql_cell_cfg));
	if(g_cell_cfg == NULL){
		RLOGE("g_cell_cfg malloc failed !!");
	
        return -1;
    }
    ret = ql_cell_locator_init(g_cell_cfg);
    if(ret)
    {
        RLOGE("ql_cell_locator_init error.");
		
        goto error;
    }
	ret = ql_cell_locator_set_server(g_cell_cfg,CELL_LOCATOR_SERVER_DOMAIN, port);
    if(ret)
    {
        RLOGE("ql_cell_locator_set_server error.");
		
        goto error;
    }

	ret = ql_cell_locator_set_cid(g_cell_cfg,1);
    if(ret)
    {
        RLOGE("ql_cell_locator_set_cid error.");

        goto error;
    }

	 ret = ql_cell_locator_set_timeout(g_cell_cfg,timeout);
    if(ret)
    {
		
        RLOGE("ql_cell_locator_set_timeout error.");
        goto error;
    }

    ret = ql_cell_locator_set_token(g_cell_cfg,token, strlen(token));
    if(ret)
    {
        RLOGE("ql_cell_locator_set_token error.");
		
        goto error;
    }

	ret = ql_cell_locator_setopt(g_cell_cfg, QL_CELL_OPT_ASYN, 0);
    if(ret)
    {
		
        RLOGE("ql_cell_locator set ASYN error.");
        goto error;
    }

	ret = ql_cell_locator_setopt(g_cell_cfg, QL_CELL_OPT_ASYN_CB, ql_cell_call_back);/*Asynchronous callback*/
    if(ret)
    {
        RLOGE("ql_cell_locator set ASYN_CB error");
        goto error;
    }
	
	ret = ql_cell_locator_setopt(g_cell_cfg, QL_CELL_OPT_METHOD, QL_CELL_TYPE_CELL);
    if(ret)
    {
        RLOGE("ql_cell_locator set METHOD error.");
        goto error;
    }


    ret = ql_cell_locator_perform(g_cell_cfg);
    if(ret){
        RLOGE("ql_cell_locator_perform ret %d  error:%d",ret,g_cell_cfg->err.err_code);
		
    }else{
        *lon = g_cell_cfg->lng;
        *lat = g_cell_cfg->lat;
		
        RLOGD("lon: %f, lat: %f, accuracy: %d city_code:%s err:%d",g_cell_cfg->lng,g_cell_cfg->lat,g_cell_cfg->accuracy,g_cell_cfg->city_code,g_cell_cfg->err.err_code);
    }

error:
    ql_cell_locator_release(g_cell_cfg);
	
    return ret;
}