/*============================================================================================
	Copyright(c) 2018 Quectel Wierless Solution,Co.,Ltd. All Rights Reserved.
	Quectel Wireless Solution Proprietary and Confidential.
============================================================================*/

#include "gps_channel.h"
#include "quec_rtos.h"
#include "UART.h"
#include "quec_uart.h"
#include "gps_debug.h"
#include "cgpio.h"
#include "pmic_rtc.h"
#include "quec_rtc.h"
#include "quec_net_app.h"
#include "sockets.h"
#include "netdb.h"
#include "quec_sockets.h"
#include "gps_app.h"
#include "quec_mfpr_api.h"

#define GPS_VIA_UART

char g_gps_data_buf[4096] = {0};
g_gps_channel_t g_gps_channel;
GPS_CHANNEL_TYPE g_gps_channel_type = CHANNEL_TYPE_UART;
static quec_mutex_t gps_uart_mutexref;
static quec_mutex_t gps_uart_mutexref_tx;
quec_gps_gpio_struct_t gps_gpio_pin;
extern int get_ntp_time_type(void);
extern int GetNTPStatus(void);
extern void get_ntp_time_internal(void);
extern int quec_boardcfg_gnss_pin_init(quec_gps_gpio_struct_t *gpio_pin);
static void quec_uart_callback(char port, void *para)
{
    if(g_gps_channel.m_event_callback != NULL)
    {
        g_gps_channel.m_event_callback(para);
    }
}

void gps_event_register_cb(gnss_event_callback cb)
{
    g_gps_channel.m_event_callback = cb;
}

void gps_delay_ms(unsigned     int ms)
{
    if(ms<5)
        ms = 5;
    quec_rtos_task_sleep_ms(ms);
}

char gps_uart_init()
{
    quec_uart_config_t dcb;
    quec_uart_register_cb(UART_PORT_BTUART, quec_uart_callback);
    quec_uart_open(UART_PORT_BTUART, QUEC_UART_BAUD_921600,QUEC_FC_NONE);
    dcb.baudrate = QUEC_UART_BAUD_921600;
    dcb.parity_bit=QUEC_UART_PARITY_NONE;
    dcb.stop_bit=QUEC_UART_STOP_1;
    dcb.data_bit=QUEC_UART_DATABIT_8;
	quec_uart_set_dcbconfig(UART_PORT_BTUART, &dcb);
    return TRUE;
}

//将uart配置成输入下拉模式防止朝GNSS漏电
static void quec_gnss_gpio_set_pulldown(int pin)
{
	GPIOConfiguration gpio_config_data = {
	   .pinDir	= GPIO_IN_PIN,
	   .pinPull = GPIO_PULLDN_ENABLE,
	   .initLv	= 0,
	   .pinEd	= GPIO_NO_EDGE,
	   .isr 	= NULL,
	   .wu		= NULL,
	 };
	 GpioInitConfiguration(pin, gpio_config_data);
	*(volatile unsigned long *)(GPIO_MFPR_ADDR(pin)) = MFP_AF0;
	
	//初始化时增加设置gpio上下拉操作，修复gpio设置为输入时，上下拉不生效
	GpioSetPullControl(pin, GPIO_PULLDN_ENABLE);
}
//rest 默认输入浮空，quectel不在控制，和芯内部弱上拉
static void quec_gnss_rest_gpio_set_float(int pin)
{
	GPIOConfiguration gpio_config_data = {
	   .pinDir	= GPIO_IN_PIN,
	   .pinPull = GPIO_PULL_DISABLE,
	   .initLv	= 0,
	   .pinEd	= GPIO_NO_EDGE,
	   .isr 	= NULL,
	   .wu		= NULL,
	 };
	 GpioInitConfiguration(pin, gpio_config_data);
	*(volatile unsigned long *)(GPIO_MFPR_ADDR(pin)) = MFP_AF0;
	GpioSetPullControl(pin, GPIO_PULL_DISABLE);
	
}

//将uart配置成输入下拉模式防止朝GNSS漏电
static void quec_gnss_uart_low_power(void)
{
#if defined(QUEC_HX_GNSS_SUPPORT) 
	/*初始化gnss引脚*/
	quec_boardcfg_gnss_pin_init(&gps_gpio_pin);
	quec_gnss_gpio_set_pulldown(gps_gpio_pin.rx);
	quec_gnss_gpio_set_pulldown(gps_gpio_pin.tx);
	quec_gnss_rest_gpio_set_float(gps_gpio_pin.rst);
	if(gps_gpio_pin.pwr_en)
	{
		/*默认需配置输入上拉，防止漏电*/
		#if defined (__QUECTEL_PROJECT_EG915NLA_GK__)
		*(volatile unsigned long *)(GPIO_MFPR_ADDR(gps_gpio_pin.pwr_en)) = MFP_AF0;
		#else
		*(volatile unsigned long *)(GPIO_MFPR_ADDR(gps_gpio_pin.pwr_en)) = MFP_AF1;
		#endif
		GpioSetDirection(gps_gpio_pin.pwr_en, GPIO_IN_PIN);
		GpioSetPullControl(gps_gpio_pin.pwr_en, GPIO_PULLUP_ENABLE);
	}
#endif
}

char gps_uart_deinit()
{
    int ret=0;
    ret=quec_uart_close(UART_PORT_BTUART);
#if  defined(QUEC_HX_GNSS_SUPPORT) 
    quec_gnss_uart_low_power();
#endif
    return (ret == 0);
}

unsigned int gps_uart_get_byte_status(void)
{
    unsigned int len = 0;
    len = quec_uart_get_rxrb_data_len(UART_PORT_BTUART);
    //GPS_LOGI("%d",len);
    return len;
}

unsigned int gps_uart_get_byte_buffer(char *buf, unsigned int len)
{
    int rck=0;
    int read_len=0;
    quec_rtos_mutex_lock(gps_uart_mutexref, QUEC_WAIT_FOREVER);
	read_len = quec_uart_read(UART_PORT_BTUART, (unsigned char*)buf, len);
    quec_rtos_mutex_unlock(gps_uart_mutexref);
	if (read_len <= 0)
	{
        rck=FALSE;
	}
    else 
    {
        rck=(unsigned int)read_len;
    }
	//quec_rtos_mutex_unlock(gps_uart_mutexref);
    GPS_LOGI(" length=%d received_len=%d", len, rck);
    return rck;
}

unsigned int gps_uart_put_byte_buffer(char *buf, unsigned int length)
{
    int len = 0;
    unsigned int ret = 0;
	quec_rtos_mutex_lock(gps_uart_mutexref_tx, QUEC_WAIT_FOREVER);
    quec_uart_write_sync(UART_PORT_BTUART,(unsigned char*)buf,length);
	quec_rtos_mutex_unlock(gps_uart_mutexref_tx);
    return length;
}

void gps_uart_purge_fifo()
{
    quec_uart_flush_fifo(UART_PORT_BTUART);
    GPS_LOGI(" clear fifo...");
}

void gps_uart_set_baudrate(int baud_rate)
{
    quec_uart_config_t dcb;
    dcb.baudrate = (QUEC_UART_BAUD_E)baud_rate;
    dcb.parity_bit=QUEC_UART_PARITY_NONE;
    dcb.stop_bit=QUEC_UART_STOP_1;
    dcb.data_bit=QUEC_UART_DATABIT_8;
	quec_uart_set_dcbconfig(UART_PORT_BTUART, &dcb);
    GPS_LOGI("baud_rate=%d", baud_rate);
}

void gps_gpio_set_level(unsigned int pin_num,unsigned int level)
{
    *(volatile unsigned long *)(GPIO_MFPR_ADDR(pin_num)) = 0x00;
	GPIOConfiguration gpio_config_data = {
	.pinDir  = GPIO_OUT_PIN,
	.pinPull = GPIO_PULLDN_ENABLE,
	.initLv  = level,
	.pinEd 	 = GPIO_NO_EDGE,
	.isr 	 = NULL,
	.wu 	 = NULL,
	};
	
	GpioInitConfiguration(pin_num, gpio_config_data);
}
extern int GetTimeZone(void);
unsigned int gps_get_rtc_time(void)
{    
    unsigned int rtc_cnt = 0;
    rtc_cnt = PMIC_RTC_GetTime_Count(SYS_OFFSET)-(GetTimeZone()*60);
    return rtc_cnt;
}


typedef struct 
{	
	int cid;
	char * url; // dup from user setting
	char * host; //
	char * path; //
	char * name;
	char * password;
	unsigned short int port;
	int auth_type;
	int https;
	char * auth_value;
	struct sockaddr_in ip;
	struct sockaddr_in6 ip6;
	int use_ip6;
	int url_is_ip6_address;
	int fd;
}QL_NTP_SERVSER;

typedef struct
{
    struct in_addr gps_ip4_addr;
    int pdp_cid;
    quec_task_t  gps_nw_task;
    char nw_status;
    char rtc_status;
} gps_nw_t;

char ntp_hostname[32];
gps_nw_t gps_nw_ctx_ptr ;

struct in_addr quec_get_gps_ip4_addr(void)
{
    return gps_nw_ctx_ptr.gps_ip4_addr;
}

char *get_ntp_server_ip(void)
{
    return &ntp_hostname[0];
}

int ntp_server_setting(char *ntp_svr_ip, int size ){

	if(ntp_svr_ip == NULL)
		return -1;
	
	memset(ntp_hostname,0,sizeof(ntp_hostname));
	memcpy(ntp_hostname, ntp_svr_ip, size);

	return 0;
}


static int quec_is_valid_ip46_address(char *ip_string)
{
	int a,b,c,d;
	char* temp; 
	int flag=0;
	if((sscanf(ip_string,"%d.%d.%d.%d",&a,&b,&c,&d)==4)
		&& a>=0&&a<=255
		&& b>=0&&b<=255
		&& c>=0&&c<=255
		&& d>=0&&d<=255)
	{
		return 1;
	}else{
		temp=ip_string;
		while(*temp!='\0')
		{
			if(*temp==':')
			{
				flag++;
				temp++;
				continue;
			}else{
				if(*temp=='0'
					||(*temp>='1'&&*temp<='9')
					||(*temp>='a'&&*temp<='f')
					||(*temp>='A'&&*temp<='F')){
					temp++;
				}else{
					return 0;
				}	
			}
		}
		return 2;
	}
}

int quec_gps_ntp_set_server(char *ntp_svr)
{
	int ret;
	QL_NTP_SERVSER ntp_server;
	struct addrinfo * pres = NULL;
	struct sockaddr_in	* ip4_svr_addr;
	char ntp_svr_ip[32]={0};

	if(ntp_svr == NULL){
		printf("ql_ntp_set_svr with error parameter !!\n");
		return -4;
	}

	ntp_server.host = ntp_svr;
	int valid_ip_flag=0;
	ret= quec_is_valid_ip46_address(ntp_svr);
	if(ret){
		valid_ip_flag=1;
//		memcpy(ntp_svr_ip, ntp_svr, sizeof(ntp_svr_ip));
		if(ret==1)
		{
			struct sockaddr_in adr_inet;
			unsigned int temp;
			ntp_server.use_ip6 = 0;
			inet_aton(ntp_server.host, &adr_inet.sin_addr);
			ntp_server.ip.sin_addr = adr_inet.sin_addr;
			ntp_server.ip.sin_family = AF_INET;
			ntp_server.ip.sin_port = htons(ntp_server.port);
			temp = (unsigned int)ntp_server.ip.sin_addr.s_addr;
		}
		else
		{
			struct sockaddr_in6 sa;
			inet6_aton(ntp_server.host, &sa.sin6_addr);
			ntp_server.ip6.sin6_addr=sa.sin6_addr;
			ntp_server.use_ip6 = 1;
			ntp_server.ip6.sin6_family = AF_INET6;
			ntp_server.ip6.sin6_port = htons(ntp_server.port);
			ntp_server.ip6.sin6_len = sizeof(struct sockaddr_in6);
		}
		
		inet_ntop(AF_INET, &ntp_server.ip.sin_addr, ntp_svr_ip, sizeof(ntp_svr_ip));
	}
	else
	{
        ret = getaddrinfo_with_pcid(ntp_server.host, "123", NULL, &pres,gps_nw_ctx_ptr.pdp_cid);
		if (ret < 0) 
		{
			GPS_LOGE("DNS getaddrinfo failed(%d)!\n",ret);
			return -1;
		}
		if (pres == NULL) 
		{
			GPS_LOGE("DNS getaddrinfo faield?!\n");
			return -2;
		}

		if (pres->ai_addrlen == sizeof(struct sockaddr_in)) 
		{
			ntp_server.use_ip6 = 0;
			unsigned int temp;
			struct sockaddr_in * sin_res = (struct sockaddr_in *)pres->ai_addr;
			ntp_server.ip.sin_addr = sin_res->sin_addr;
			ntp_server.ip.sin_family = AF_INET;
			ntp_server.ip.sin_port = htons(ntp_server.port);
			temp = (unsigned int)ntp_server.ip.sin_addr.s_addr;
		} 
		else 
		{
			ntp_server.use_ip6 = 1;
			ntp_server.ip6.sin6_family = AF_INET6;
			ntp_server.ip6.sin6_port = htons(ntp_server.port);
			ntp_server.ip6.sin6_len = sizeof(struct sockaddr_in6);
			memcpy(&ntp_server.ip6.sin6_addr, pres->ai_addr->sa_data, 16);
		}

		ip4_svr_addr = (struct sockaddr_in *)pres->ai_addr;
		inet_ntop(AF_INET, &ip4_svr_addr->sin_addr, ntp_svr_ip, 16);

		freeaddrinfo(pres);
	}
	
	ret = ntp_server_setting(ntp_svr_ip,sizeof(ntp_svr_ip));
	if(ret)
	{
		GPS_LOGE("ntp_server_setting failed(%d)!!!\n",ret);
		return -3;
	}

	return 0;
}

/*获取第几路pdp被激活*/
static int quec_gps_get_cid_act(void)
{
    int i = 0;
    int pdp_status = 0;
    int netif_status = 0;
    for(i=1;i<QUEC_PDP_MAX_NUM;i++)
    {
        pdp_status = quec_pdp_get_act_status(i);
        netif_status=quec_netif_get_bind_status(i);
        if(pdp_status && netif_status){
           return i;
        } 
    }
    return -1;
}

/*网络状态监控线程,此task会1s执行一次*/
/*历史问题：gps侧默认激活pdp，对于应用侧重复激活pdp会存在影响，内部讨论最终决定去除之前打开gps时默认激活pdp操作*/
/*修改方案：创建一个网络监控线程，去监控用户是否激活pdp和绑定网卡，如果有，会将此路cid配置成gps网络业务cid*/
char ntp_dns_gain = 0;
char ntp_sync_cnt = 0;
void quec_gps_nw_status_monitor(void * argv)
{
    int cid_num = 0;
    struct sockaddr sockaddr = {0};
    while(1)
    {
       cid_num = quec_gps_get_cid_act();
       t_rtc tm;
       if(cid_num>0)
       {
       		quec_gps_handle * quec_gps_cfg = quec_gnss_config_para_get();
            gps_nw_ctx_ptr.pdp_cid = cid_num;
            gps_nw_ctx_ptr.nw_status = 1;
            /*获取本地网卡ip地址*/
            quec_soc_get_ipv4v6_local_addr(cid_num, AF_INET, &sockaddr);
            memcpy(&gps_nw_ctx_ptr.gps_ip4_addr, &(((struct sockaddr_in *)&sockaddr)->sin_addr), sizeof(struct in_addr));
            quec_rtos_task_sleep_s(2); 
            if(!ntp_dns_gain){
                quec_gps_ntp_set_server(quec_gps_cfg->ntp_url);
                ntp_dns_gain++;
            }
            /*限制成功激活pdp后ntp的同步次数*/
			if((gps_nw_ctx_ptr.rtc_status !=1)&&(ntp_sync_cnt < 10))
			{
				get_ntp_time_internal();
				ntp_sync_cnt++;
				GPS_LOGD("Ntp sync cnt:%d!!!",ntp_sync_cnt);
			}
            PMIC_RTC_GetTime((t_rtc *)&tm, SYS_OFFSET);
            GPS_LOGD("Found an active pdp %d:%d:%d:%d:%d:%d!!!",tm.tm_year,tm.tm_mon,tm.tm_mday,tm.tm_hour,tm.tm_min,tm.tm_sec);
       } 
       else 
       {
            gps_nw_ctx_ptr.pdp_cid = 0;
            gps_nw_ctx_ptr.nw_status = 0;
            memset((void*)&gps_nw_ctx_ptr.gps_ip4_addr,0,sizeof(gps_nw_ctx_ptr.gps_ip4_addr));
            quec_rtos_task_sleep_s(2); 
       }
       if(get_ntp_time_type()==1 || GetNTPStatus()==1)  /*检查nitz和ntp是否同步成功*/
       {
            gps_nw_ctx_ptr.rtc_status = 1; 
       }
       //RTI_LOG("Found an active pdp %d:%d:%d:%d:%d:%d!!!",tm.tm_year,tm.tm_mon,tm.tm_mday,tm.tm_hour,tm.tm_min,tm.tm_sec);
    }
}

int quec_get_rtc_status(void)
{
    return gps_nw_ctx_ptr.rtc_status;
}
/*获取网卡状态，如果已经激活则返回pdpnum*/
int quec_get_nw_status(void)
{
    if(gps_nw_ctx_ptr.nw_status)
        return gps_nw_ctx_ptr.pdp_cid;
    else 
        return gps_nw_ctx_ptr.nw_status;
}
int gps_nw_active(void)
{
    int cid_num = 0;
    cid_num = quec_gps_get_cid_act();
    struct sockaddr sockaddr = {0};
    if(cid_num>0)
    {
    	quec_gps_handle * quec_gps_cfg = quec_gnss_config_para_get();
        gps_nw_ctx_ptr.pdp_cid = cid_num;
        gps_nw_ctx_ptr.nw_status = 1;
        /*获取本地网卡ip地址*/
        quec_soc_get_ipv4v6_local_addr(cid_num, AF_INET, &sockaddr);
        memcpy(&gps_nw_ctx_ptr.gps_ip4_addr, &(((struct sockaddr_in *)&sockaddr)->sin_addr), sizeof(struct in_addr));
        if(!ntp_dns_gain){
            quec_gps_ntp_set_server(quec_gps_cfg->ntp_url);
            ntp_dns_gain++;
        }
        GPS_LOGI("Found an active pdp!!!");
    } 
    else 
    {
        gps_nw_ctx_ptr.pdp_cid = 0;
        gps_nw_ctx_ptr.nw_status = 0;
        memset(&gps_nw_ctx_ptr.gps_ip4_addr,0,sizeof(gps_nw_ctx_ptr.gps_ip4_addr));
    }
    if(gps_nw_ctx_ptr.gps_nw_task == NULL){
        quec_rtos_task_create(&gps_nw_ctx_ptr.gps_nw_task, 1024*2, 100,"gps_nw", quec_gps_nw_status_monitor,NULL);
    }
    return 0;
}

int gps_nw_deactive(void)
{
    if(gps_nw_ctx_ptr.gps_nw_task){
        quec_rtos_task_delete(gps_nw_ctx_ptr.gps_nw_task);
        gps_nw_ctx_ptr.gps_nw_task = NULL;
    }
    return 0;
}

char gps_channel_init(void)
{
    char success = TRUE;
#ifdef GPS_VIA_UART
    g_gps_channel_type = CHANNEL_TYPE_UART;
    g_gps_channel.m_com_init              = gps_uart_init;
    g_gps_channel.m_com_get_byte_status   = gps_uart_get_byte_status;
    g_gps_channel.m_com_get_byte_buffer   = gps_uart_get_byte_buffer;
    g_gps_channel.m_com_put_byte_buffer   = gps_uart_put_byte_buffer;
    g_gps_channel.m_com_purge_fifo        = gps_uart_purge_fifo;
    g_gps_channel.m_com_set_baudrate      = gps_uart_set_baudrate;
    g_gps_channel.m_com_deinit            = gps_uart_deinit;
    g_gps_channel.m_com_event_register_cb = gps_event_register_cb;
    g_gps_channel.m_get_rtc_time          = gps_get_rtc_time;
    g_gps_channel.m_nw_act                = gps_nw_active;
    g_gps_channel.m_get_rtc_status        = quec_get_rtc_status;
    g_gps_channel.m_get_netif_status      = quec_get_nw_status;
    g_gps_channel.m_nw_deact              = gps_nw_deactive;
#elif defined(GPS_VIA_SPI)
    g_gps_channel_type = CHANNEL_TYPE_SPI;
#elif defined(GPS_VIA_I2C)
    g_gps_channel_type = CHANNEL_TYPE_I2C;
#else
#error "No Define GPS_VIA_UART/SPI/I2C"
#endif

    g_gps_channel.m_gpio_set_level        = gps_gpio_set_level;
    if(gps_uart_mutexref==NULL){
        quec_rtos_mutex_create(&gps_uart_mutexref);
    }
	if(gps_uart_mutexref_tx==NULL){
        quec_rtos_mutex_create(&gps_uart_mutexref_tx);
    }
	//20240313初始化gnss相关pin脚
	quec_gnss_uart_low_power();
    GPS_LOGI("gps_channel_type=%d", g_gps_channel_type);
    return success;
}

char gps_get_channel_type(void)
{
    return g_gps_channel_type;
}