#include <stdio.h>
#include "at_host.h"
#include "string.h"
#include "stdlib.h"
#include "rtthread.h"
#include "ble_demo.h"



//在同一个线程中调用则不需要加临界区
#if 1
	#include "rthw.h"
	#define IRQ_DISABLE()           rt_enter_critical()
	#define IRQ_ENABLE()            rt_exit_critical()
#else
	#define IRQ_DISABLE()           { }
	#define IRQ_ENABLE()            { }
#endif



/*------------------------buff相关操作函数---------------------------*/

//清空buff
static int buff_clear(ble_buff *buff);

//初始化buff
static void buff_init(ble_buff *buff)
{
	buff->buff_len=BLE_BUFF_LEN;
	buff_clear(buff);
}

//写入一个字节
static int buff_save_byte(ble_buff *buff,uint8_t data)
{
	IRQ_DISABLE();
	if (buff->buff_used<buff->buff_len)
	{
		buff->buff[buff->save_ptr]=data;
		buff->buff_used++;
		buff->save_ptr++;
		if (buff->save_ptr>=buff->buff_len)
			buff->save_ptr=0;
		IRQ_ENABLE();
		return 1;
	}
	IRQ_ENABLE();
	return 0;
}

//读取一个字节
static int buff_read_byte(ble_buff *buff,uint8_t *data)
{
	IRQ_DISABLE();
	if (buff->buff_used)
	{
		*data=buff->buff[buff->read_ptr];
		buff->buff_used--;
		buff->read_ptr++;
		if (buff->read_ptr>=buff->buff_len)
			buff->read_ptr=0;
		IRQ_ENABLE();
		return 1;
	}
	IRQ_ENABLE();
	return 0;
}

//查找buff中是否有指定字符
static int buff_find_char(ble_buff *buff,uint8_t data)
{
	int ptr=buff->read_ptr;
	int len=buff->buff_used;
	while(len--)
	{
		if(data==buff->buff[ptr])
			return 1;
		ptr++;
		if (ptr>=buff->buff_len)
			ptr=0;
		
	}
	return 0;
}

//清空buff
static int buff_clear(ble_buff *buff)
{
	IRQ_DISABLE();
	buff->buff_used=0;
	buff->read_ptr=0;
	buff->save_ptr=0;
	IRQ_ENABLE();
	return 0;
}

/*------------------------buff相关操作函数End---------------------------*/



/*------------------------device相关操作函数---------------------------*/

//初始化蓝牙设备
int device_init(ble_device *device)
{
	device->conn_handle=0;
	device->linked=0;
	memset(device->mac,0,6);
	buff_init(&device->buff_recv);
	return 1;
}

//设置此设备的mac地址
int device_set_mac(ble_device *device,uint8_t mac[6])
{
	memcpy(device->mac,mac,6);
	return 1;
}

//设置此设备的conn_handle
int device_set_handle(ble_device *device,uint16_t handle)
{
	device->conn_handle=handle;
	return 1;
}

//把数据存入设备缓冲
int device_save_buff(ble_device *device,uint8_t *buff,int size)
{
	int ret=0;
	while(size--)
	{
		if (buff_save_byte(&device->buff_recv,buff[ret])==0)
			return ret;
		ret++;
	}
	return ret;
}

//读取设备缓冲，直到遇到界定符
int device_read_buff(ble_device *device,uint8_t *buff,int buff_size,uint8_t end_par)
{
	if(buff_find_char(&device->buff_recv,end_par)==0)
		return 0;
	
	int ret=0;
	uint8_t t=0;
	while(1)
	{
		if(buff_read_byte(&device->buff_recv,&t)==0)
			return ret;
		if(buff_size)
		{
			buff[ret]=t;
			buff_size--;
			ret++;
		}
		if(t==end_par)
			return ret;
		
	}
}

//读取设备缓冲，指定长度
int device_read_buff_by_len(ble_device *device,uint8_t *buff,int read_len)
{
	
	int ret=0;
	uint8_t t=0;
	while(1)
	{
		if(buff_read_byte(&device->buff_recv,&t)==0)
			return ret;
		if(read_len)
		{
			buff[ret]=t;
			read_len--;
			ret++;
		}
		else
			return ret;
		
	}
}


/*------------------------device相关操作函数End---------------------------*/


static void ble_print_data(uint8_t *data,int len)
{
  for(int i=0;i<len;i++)
  {
    printf("%02X ",data[i]);
  }
  printf("\r\n");
}




/*--------------------------ble相关操作函数----------------------------*/

//添加通知消息
int ble_add_notice(ble_struct *ble,uint8_t *obj,int obj_size,uint8_t op,uint8_t *par,int par_size);

//连接事务改变
int ble_linked_change(ble_struct *ble,uint16_t handle,uint16_t state);

//收到数据
int ble_save_data(ble_struct *ble,uint16_t handle,uint8_t *data,int len);

//返回指定句柄的设备
ble_device *ble_find_device(ble_struct *ble,uint16_t handle);

//添加设备
int ble_add_device(ble_struct *ble,uint16_t handle);

//删除设备
int ble_sub_device(ble_struct *ble,uint16_t handle);


static int ble_service_on(void *t);
static int ble_service_off(void);



//ble初始化
void ble_init(ble_struct *ble)
{
  if(ble==0) return;
  memset(ble,0,sizeof(ble_struct));
	at_init();
	ble->mode='i';
	ble->linked=0;
	for(int i=0;i<BLE_MAX_LINKED;i++)
	{
		device_init(&ble->device[i]);
	}
	at_clear_buff();
  ble->ret_event=rt_event_create("ble_ret", RT_IPC_FLAG_FIFO);
  ble->kno_event=rt_event_create("ble_kno", RT_IPC_FLAG_FIFO);
  rt_event_send(ble->kno_event,2);
  ble_service_on(ble);
  ble_reboot(ble);
}

//ble去初始化
void ble_deinit(ble_struct *ble)
{
  if(ble==0) return ;
  ble_reboot(ble);
  ble_service_off();
  at_deinit();
  if(ble->ret_event)
    rt_event_delete(ble->ret_event);
  if(ble->kno_event)
    rt_event_delete(ble->kno_event);
}




// 设置回调函数
int ble_set_callback_linked_change(ble_struct *ble,void (*linked_change)(uint16_t handle,uint16_t state))
{
  ble->linked_change=linked_change;
  return 1;
}
int ble_set_callback_recv_data(ble_struct *ble,void (*recv_data)(uint16_t handle,uint8_t *data,int len))
{
  ble->recv_data=recv_data;
  return 1;
}
int ble_set_callback_user_irq(ble_struct *ble,void (*user_irq)(uint8_t *data,int len))
{
  ble->user_irq=user_irq;
  return 1;
}









//处理通知消息
int ble_deal_notice(ble_struct *ble)
{
  if(ble==0) return 0;
	int len=0;
	uint8_t *data=ble->return_line;
	len=at_get_return_line(data);
	if(len==-1) {
        return 0;
    }
	uint8_t *par=0;
	int par_size=0;
	uint8_t *obj=0;
	int obj_size=0;
	uint8_t op=0;
	if(at_decode_line(data,len,&obj,&obj_size,&op,&par,&par_size)==-1)
  {
    return 0;
  }
	
	if(op==CMDAT_CMD_RET)
	{
		//命令返回消息，存储到通知缓冲区
		ble_add_notice(ble,obj,obj_size,op,par,par_size);
	}
	else if(op==CMDAT_CMD_ACT)
	{
		//通知消息，进一步区分
		if(obj[0]==0x01)
		{
			//连接事务改变
			ble_linked_change(ble,*(uint16_t *)par,*(uint16_t *)(par+2));
		}
		else if(obj[0]==0x02)
		{
			//收到新数据
      if(ble->recv_data==0)
        ble_save_data(ble,*(uint16_t *)par,par+2,par_size-2);
      else
        ble->recv_data(*(uint16_t *)par,par+2,par_size-2);
		}
    else if(obj[0]==0xff)
    {
      // 用户中断
      if(ble->user_irq) ble->user_irq(par,par_size);
    }
	}
	return 1;
}

//添加通知消息
int ble_add_notice(ble_struct *ble,uint8_t *obj,int obj_size,uint8_t op,uint8_t *par,int par_size)
{
  notice_t *n=&ble->notice;
  if(ble->kno_event)
  {
    // 等待接收方查看通知
    rt_uint32_t ev;
    rt_event_recv(ble->kno_event,0xffffffff,RT_EVENT_FLAG_OR|RT_EVENT_FLAG_CLEAR,1000,&ev);
  }
  //ble_print_data(par,par_size);
  IRQ_DISABLE();
  memcpy(n->obj,obj,obj_size);
  memcpy(n->par,par,par_size);
  n->obj_size=obj_size;
  n->par_size=par_size;
  IRQ_ENABLE();
  if(ble->ret_event)
  {
    // 发送通知提醒接收方查看
    rt_event_send(ble->ret_event,1);
  }
	return 1;
}

//获取通知消息,返回0失败
int ble_get_notice(ble_struct *ble,uint8_t *obj,int *obj_size,uint8_t *op,uint8_t *par,int *par_size)
{
  rt_uint32_t ev;
  if(ble->ret_event)
  {
    if(rt_event_recv(ble->ret_event,0xffffffff,RT_EVENT_FLAG_OR|RT_EVENT_FLAG_CLEAR,1000,&ev)==RT_EOK)
    {
      IRQ_DISABLE();
      notice_t *n=&ble->notice;
      if(obj) memcpy(obj,n->obj,n->obj_size);
      if(obj_size) *obj_size=n->obj_size;
      if(par) memcpy(par,n->par,n->par_size);
      if(par_size) *par_size=n->par_size;
      n->obj_size=0;
      n->par_size=0;
      IRQ_ENABLE();
      if(ble->kno_event)
      {
        // 通知已查看
        rt_event_send(ble->kno_event,1);
      }
      return 1;
    }
  }
  return 0;
}


//连接事务改变
int ble_linked_change(ble_struct *ble,uint16_t handle,uint16_t state)
{
	if(state==1)
	{
		//添加连接设备
		ble_add_device(ble,handle);
	}
	else if(state==0)
	{
		//删除连接设备
		ble_sub_device(ble,handle);
	}
	else
	{
		return 0;
	}
  // 调用用户回调函数
  if(ble->linked_change) ble->linked_change(handle,state);
    
	return 1;
}


//收到数据
int ble_save_data(ble_struct *ble,uint16_t handle,uint8_t *data,int len)
{
	ble_device *device=ble_find_device(ble,handle);
	if(device)
	{
    //printf("%s:recved %d\r\n",__func__,len);
		return device_save_buff(device,data,len);
	}
	return 0;
}

//返回指定句柄的设备
ble_device *ble_find_device(ble_struct *ble,uint16_t handle)
{
	if(handle==0) return 0;
	for(int i=0;i<BLE_MAX_LINKED;i++)
	{
		if(ble->device[i].conn_handle==handle)
			return &ble->device[i];
	}
	return 0;
}


//返回指定索引的蓝牙设备
ble_device *ble_find_device_by_index(ble_struct *ble,int index)
{
    if(ble==0) return 0;
	if(index<BLE_MAX_LINKED)
	{
		if(ble->device[index].conn_handle)
			return &ble->device[index];
	}
	return 0;
}



//添加设备
int ble_add_device(ble_struct *ble,uint16_t handle)
{
	if(handle==0) return 0;
  IRQ_DISABLE();
	for(int i=0;i<BLE_MAX_LINKED;i++)
	{
		ble_device *device=&ble->device[i];
		if(device->conn_handle==0)
		{
			memcpy(device->mac,ble->conn_mac,6);
			device->conn_handle=handle;
			device->linked=1;
			ble->linked++;
      IRQ_ENABLE();
			return 1;
		}
	}
  IRQ_ENABLE();
	return 0;
}


//删除设备
int ble_sub_device(ble_struct *ble,uint16_t handle)
{
	if(handle==0) return 0;
  IRQ_DISABLE();
	for(int i=0;i<BLE_MAX_LINKED;i++)
	{
		ble_device *device=&ble->device[i];
		if(device->conn_handle==handle)
		{
			device->conn_handle=0;
			device->linked=0;
			memset(device->mac,0,6);
			buff_clear(&device->buff_recv);
			ble->linked--;
      IRQ_ENABLE();
			return 1;
		}
	}
  IRQ_ENABLE();
	return 0;
}

//读取数据直到出现界定符
int ble_get_recv_data_by_end(ble_struct *ble,uint16_t handle,uint8_t *buff,int buff_size,uint8_t end_par)
{
    if(ble==0) return 0;
	ble_device *device=ble_find_device(ble,handle);
	if (device)
	{
		return device_read_buff(device,buff,buff_size,end_par);
	}
	return 0;
}


//读取指定长度的数据
int ble_get_recv_data(ble_struct *ble,uint16_t handle,uint8_t *buff,int read_len)
{
    if(ble==0) return 0;
	ble_device *device=ble_find_device(ble,handle);
	if (device)
	{
		return device_read_buff_by_len(device,buff,read_len);
	}
	return 0;
}





//获取命令返回
int ble_get_cmd_return(ble_struct *ble,uint8_t *buff,int *buff_size)
{
  int ret=0;

  ret=ble_get_notice(ble,0,0,0,buff,buff_size);
  return ret;
}


//设置设备名称
int ble_set_name(ble_struct *ble,char *name)
{
    if(ble==0) return 0;
	uint8_t *data=ble->data_temp;
	int size=0;
	at_send_set_event(0x01,name,strlen(name));
	if(ble_get_cmd_return(ble,data,&size)==1)
	{
		if(data[0]==1)
			return 1;
	}
	return 0;
}

//获取设备mac地址
int ble_get_mac(ble_struct *ble,uint8_t mac[6])
{
    if(ble==0) return 0;
	uint8_t *data=ble->data_temp;
	int size=0;
	at_send_get_event(0x02,0,0);
	if(ble_get_cmd_return(ble,data,&size)==1)
	{
		if(size==6)
		{
			memcpy(mac,data,6);
			return 1;
		}
	}
	return 0;
}


//重启
int ble_reboot(ble_struct *ble)
{
  if(ble==0) return 0;
	uint8_t *data=ble->data_temp;
	int size=0;
	int time_out=100;
	
	do{
		at_send_set_event(0x03,0,0);
		rt_thread_delay(2);
		ble_get_notice(ble,0,0,0,data,&size);
		if((size==1)&&(data[0]==1))
		{
			rt_thread_delay(100);
			at_clear_buff();
			return 1;
		}
	}
	while(time_out--);
	
	return 0;
	
}


//设置uuid
int ble_set_uuid(ble_struct *ble,uint8_t sub,uint8_t type,uint8_t *uuid)
{
  if(ble==0) return 0;
	uint8_t *data=ble->data_temp;
	int size=0;
	
	data[0]=sub;data[1]=type;
	memcpy(&data[2],uuid,type/8);
	at_send_set_event(0x05,data,2+type/8);
	if(ble_get_cmd_return(ble,data,&size)==1)
	{
		if(data[0]==1)
			return 1;
	}
	return 0;
}


//打开/关闭数据传输
int ble_set_data_transport(ble_struct *ble,uint8_t power)
{
  if(ble==0) return 0;
	uint8_t *data=ble->data_temp;
	int size=0;
	at_send_set_event(0x06,&power,1);
	if(ble_get_cmd_return(ble,data,&size)==1)
	{
		if(data[0]==1)
			return 1;
	}
	return 0;
}




//发送数据
int ble_send_data(ble_struct *ble,uint16_t handle,uint8_t *buff,int len)
{
    if(ble==0) return 0;
	uint8_t *data=ble->data_temp;
	int size=0;
	int pack_len=0;
	while(len)
	{
		data[0]=handle;
		data[1]=handle>>8;
		if(len>20) pack_len=20;
		else pack_len=len;
		memcpy(&data[2],buff,pack_len);
		at_send_set_event(0x07,data,pack_len+2);
		if(ble_get_cmd_return(ble,data,&size)==1)
		{
			if(data[0]==1)
			{
				if (len==0)
					return 1;
			}
			else
			{
				return 0;
			}
		}
		else
			return 0;
		len-=pack_len;
		buff+=pack_len;
	}
	return 0;
}


//设置为从机模式
int ble_set_slave(ble_struct *ble)
{
    if(ble==0) return 0;
	uint8_t *data=ble->data_temp;
	int size=0;
	at_send_set_event(0x10,0,0);
	if(ble_get_cmd_return(ble,data,&size)==1)
	{
		if(data[0]==1)
		{
			ble->mode='s';
			return 1;
		}
	}
	return 0;
	
}


//设置为主机模式
int ble_set_host(ble_struct *ble)
{
    if(ble==0) return 0;
	uint8_t *data=ble->data_temp;
	int size=0;
	at_send_set_event(0x20,0,0);
	if(ble_get_cmd_return(ble,data,&size)==1)
	{
		if(data[0]==1)
		{
			ble->mode='h';
			return 1;
		}
	}
	return 0;
	
}


//连接指定的从机
int ble_connect_by_mac(ble_struct *ble,uint8_t mac[6])
{
    if(ble==0) return 0;
	uint8_t *data=ble->data_temp;
	int size=0;
	at_send_set_event(0x21,mac,6);
	if(ble_get_cmd_return(ble,data,&size)==1)
	{
		if(data[0]==1)
		{
			memcpy(ble->conn_mac,mac,6);
			return 1;
		}
	}
	return 0;
}



//断开指定的从机
int ble_discon_by_mac(ble_struct *ble,uint8_t mac[6])
{
    if(ble==0) return 0;
	uint8_t *data=ble->data_temp;
	int size=0;
	at_send_set_event(0x22,mac,6);
	if(ble_get_cmd_return(ble,data,&size)==1)
	{
		if(data[0]==1)
			return 1;
	}
	return 0;
}

//扫描
int ble_scan(ble_struct *ble,ble_mac_name mac[32],int *mac_num)
{
    if(ble==0) return 0;
	uint8_t *data=ble->data_temp;
	int size=0;
	*mac_num=0;
	at_send_set_event(0x23,0,0);
	rt_thread_delay(3500);
	while(1)
	{
		if(ble_get_cmd_return(ble,data,&size)==1)
		{
			if(size==1)
			{
				if(data[0]==1)
					return 1;
				else
					return 0;
			}
			else if(size>=7)
			{
				memcpy(mac[*mac_num].mac,data,6);
				mac[*mac_num].rssi=data[6];
				if(size>7)
				{
					int len=size-7;
					memcpy(mac[*mac_num].name,data+7,len);
					mac[*mac_num].name[len]=0;
				}
				else
					mac[*mac_num].name[0]=0;
				(*mac_num)++;
			}
		}
		else
			return 0;
	}
}




//发送用户设置数据
int ble_user_cmd_set(ble_struct *ble,uint8_t *tx,int tx_len)
{
  if(ble==0) return 0;
	uint8_t *data=ble->data_temp;
	int size=0;
	at_send_set_event(0xff,tx,tx_len);
	if(ble_get_cmd_return(ble,data,&size)==1)
	{
		if(size==1)
			return 1;
	}
	return 0;
}



//发送用户获取数据，rx_len获取的数据长度，失败返回0
int ble_user_cmd_get(ble_struct *ble,uint8_t *tx,int tx_len,uint8_t *rx,int *rx_len)
{
  if(ble==0) return 0;
	uint8_t *data=ble->data_temp;
	int size=0;
  int recv_len=0;
  uint8_t obj;
  int obj_size;
	at_send_get_event(0xff,tx,tx_len);
  while(1)
  {
    if(ble_get_notice(ble,&obj,&obj_size,0,data,&size)==1)
    {
      if(obj_size==0)
        return data[0];
      else
      {
        if(recv_len==0)
        {
          if(size>*rx_len) recv_len=*rx_len;
          else recv_len=size;
          memcpy(rx,data,recv_len);
          //ble_print_data(rx,recv_len);
          *rx_len=recv_len;
        }
      }
    }else break;
  }
	return 0;
}






static int g_service_work;
static int g_service_done=1;
// ble 服务线程
static void ble_service_thread(void *t)
{
  ble_struct *ble=t;
  g_service_done=0;
  
  int ev;
  while(g_service_work)
  {
    ev=at_get_event();
    if(ev&CMDAT_EVENT_RECV)
    {
      ev&=~CMDAT_EVENT_RECV;
      while(ble_deal_notice(ble)==1);
    }
    if(ev&CMDAT_EVENT_USER)
    {
      ev&=~CMDAT_EVENT_USER;
      at_send_packet();
    }
    if(ev)
    {
      
    }
  }
  
  g_service_done=1;
}


static int ble_service_on(void *t)
{
	rt_err_t result = RT_EOK;
	rt_thread_t tid;

  // 保证线程没有被创建
  if(g_service_done)
  {
    g_service_work=1;
    tid = rt_thread_create("ble_service_thread", ble_service_thread, t, 2048, 11, 10);
    if (tid != NULL && result == RT_EOK)
      rt_thread_startup(tid);
    return 0;
  }
  else
  {
    return -1;
  }
  
}



static int ble_service_off(void)
{
  // 保证线程已经被创建
  if(g_service_work)
  {
    g_service_work=0;
    at_send_user_event(0x04);
    while(g_service_done==0)
    {
      rt_thread_delay(10);
    }
    return 0;
  }
  else
  {
    return -1;
  }
}