#include <stdio.h>
#include <stdlib.h>
#include <sys/time.h>   //      gettimeofday
#include <sys/stat.h>
#include <string.h>
#include <unistd.h>
#include <sys/types.h>
#include <fcntl.h>
#include <sys/mman.h>
#include <sys/ioctl.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <netdb.h>
#include <errno.h>
#include <pthread.h>
#include "serial.h"
#include "uartinf.h"
#include <stdbool.h>
#include "parase.h"

char _rx_data[200];
unsigned char tx_jingdu[] = {0x01, 0x03, 0x00, 0xcf, 0x00, 0x03,0x35,0xf4};
unsigned char tx_weidu[] = {0x01, 0x03, 0x00, 0xd2, 0x00, 0x03,0xa5,0xf2};
unsigned char tx_state[] = {0x01, 0x03, 0x00, 0xc8, 0x00, 0x01,0x05,0xf4};

static int socket_descriptor;
static struct sockaddr_in address;

//bool first = false;

int socket_descriptor_recv;
struct sockaddr_in address_recv;
pthread_attr_t attr;
pthread_t pkts_thread;

// 定义数据发送格式结构体
typedef struct {
    char header[2];       // 帧头 0xAA 0x55
    uint16_t  dingwei_state;
    uint32_t longitude;     // 经度
    uint32_t latitude;      // 纬度
    char footer;          // 帧尾 0xFF
} LocationData;
// 互斥锁保护经纬度数据访问
pthread_mutex_t loc_mutex = PTHREAD_MUTEX_INITIALIZER;

uint32_t lon_val;
uint32_t lat_val;
uint16_t state_val;
int udp_init(char *ip, int port){
    
    bzero(&address,sizeof(address));
    address.sin_family=AF_INET;
    address.sin_addr.s_addr=inet_addr(ip);
    address.sin_port=htons(port);

    socket_descriptor=socket(AF_INET,SOCK_DGRAM,0);//IPV4
    return 0;
}

int send_specified_bytes(UART_INTF uart_type,unsigned char *data) {

    int ret = uart_write_len(uart_type, (char*)data, 8);
    if (ret < 0) {
        printf("发送失败，返回值: %d\n", ret);
    }
    return ret;
}
uint32_t parse_tude(unsigned char *data, int start_idx){
	return ((uint32_t)data[start_idx + 3] << 24 |
           (uint32_t)data[start_idx + 2] << 16 |
           (uint32_t)data[start_idx + 1] << 8 |
           (uint32_t)data[start_idx ]);
}
// 发送经纬度数据
void send_location_data() {
    LocationData loc_data;
    
    pthread_mutex_lock(&loc_mutex);
    // 初始化数据包
    loc_data.header[0] = 0xAA;
    loc_data.header[1] = 0x55;
    loc_data.dingwei_state = state_val;
    loc_data.longitude = lon_val;
    loc_data.latitude = lat_val;
    loc_data.footer = 0xFF;
    
    pthread_mutex_unlock(&loc_mutex);
    // 发送数据
    int send_len = sendto(socket_descriptor, &loc_data, sizeof(LocationData), 
                         0, (struct sockaddr *)&address, sizeof(address));
    if (send_len < 0) {
        perror("发送经纬度失败");
    } else {
        //printf("成功发送经纬度数据，长度: %d 字节\n", send_len);
    }
}

// 经纬度发送线程函数
void *send_location_thread(void *arg) {
    while (1) {
        send_location_data();
        // 1秒发送一次
        sleep(1);
    }
    return NULL;
}
#if 1
int pthread_init()
{
        int ret;
        pthread_attr_init(&attr);
        pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_JOINABLE);
        ret = pthread_create(&pkts_thread, &attr, send_location_thread, NULL);

        pthread_attr_destroy(&attr);

        if(ret){
                printf("create pthread1 error\n");
                return 1;
        }

}
#endif

int main (int argc, char *argv[])
{
    	int n_read;
	

    	n_read = uart_init(ROUTE_UART, "/dev/ttyAMA4", 9600, 'N');
    	if(n_read <=0 ) {
		printf("open /dev/ttyAMA4 failed\n");
		return -1;
    	}

	udp_init(argv[1], atoi(argv[2]));
	pthread_init();

	while(1){
		send_specified_bytes(ROUTE_UART,tx_state);
		n_read = uart_read(ROUTE_UART, _rx_data);
		if(n_read >0 && _rx_data[2]==0x02 ){
                
                	pthread_mutex_lock(&loc_mutex);
			state_val=(uint16_t)_rx_data[3] |(uint16_t)_rx_data[4]<<8;
                        pthread_mutex_unlock(&loc_mutex);
			//printf("%x \n",state_val);
                        
                }
		usleep(100000);
		send_specified_bytes(ROUTE_UART,tx_jingdu);
		n_read = uart_read(ROUTE_UART, _rx_data);

		if(n_read >0 &&(_rx_data[4]==0x45||_rx_data[4]==0x57)){
		
			pthread_mutex_lock(&loc_mutex);
			lon_val = parse_tude(_rx_data, 5);

                	//current_longitude = parse_longitude(_rx_data);
                	pthread_mutex_unlock(&loc_mutex);
                	//printf("经度: %x°\n", lon_val);
			
		}

		usleep(100000);
		send_specified_bytes(ROUTE_UART,tx_weidu);
		n_read = uart_read(ROUTE_UART, _rx_data);
		if(n_read >0 &&(_rx_data[4]==0x4E || _rx_data[4]==0x53)){		
			pthread_mutex_lock(&loc_mutex);
			lat_val = parse_tude(_rx_data, 5);
                	//current_latitude = parse_latitude(_rx_data);
                	pthread_mutex_unlock(&loc_mutex);
                	//printf("纬度: %x°\n", lat_val);
	
		}
		usleep(500000);
	}


}