#include <FreeRTOS.h>
#include <task.h>
#include <timers.h>
#include <semphr.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <stdarg.h>
#include "kwrap/spinlock.h"
#include <kwrap/flag.h>
#include "kwrap/semaphore.h"
#include <kwrap/task.h>
#include "init.h"
#include "tcpip.h"
#include "lwip/opt.h"
#include "lwip/def.h"
#include "lwip/mem.h"
#include "lwip/pbuf.h"
#include "lwip/sys.h"
#include "lwip/tcpip.h"
#include "lwip/icmp.h"
#include "timers.h"
#include "netif/etharp.h"
#include "err.h"
#include "netif/ethernet.h"
#include <kwrap/examsys.h>
#include <WiFiIpc/nvtwifi.h>
#include <WiFiIpc/WiFiIpcAPI.h>

#if 0
#define IP_ADDR0   192
#define IP_ADDR1   168
#define IP_ADDR2   0
#define IP_ADDR3   1

#define NETMASK_ADDR0   255
#define NETMASK_ADDR1   255
#define NETMASK_ADDR2   255
#define NETMASK_ADDR3   0

#define GW_ADDR0   192
#define GW_ADDR1   168
#define GW_ADDR2   0
#define GW_ADDR3   1

struct netif wifi_netif;

static void low_level_init(struct netif *netif)
{
	netif->hwaddr_len = ETHARP_HWADDR_LEN;
	netif->mtu = 1500;
	netif->flags = NETIF_FLAG_BROADCAST | NETIF_FLAG_ETHARP;
}

static err_t low_level_output(struct netif *netif, struct pbuf *p)
{
   err_t  ret = ERR_OK;

  //the the actual xmit interface, implement in wifi lib
   ret = ssv_wifi_tx_pkt((void*) netif, (void *)p, p->tot_len);
  
   return ret;
}

err_t wifi_ethernetif_init(struct netif *netif)
{
#if LWIP_NETIF_HOSTNAME
	if(netif->name[1] == '0')
		netif->hostname = "lwip0";
#endif

	netif->output = etharp_output;
	netif->linkoutput = low_level_output;
	low_level_init(netif);

	etharp_init();

	return ERR_OK;
}

void LwIP_Init(void)
{
	ip4_addr_t ipaddr;
	ip4_addr_t netmask;
	ip4_addr_t gw;

	IP4_ADDR(&ipaddr, IP_ADDR0, IP_ADDR1, IP_ADDR2, IP_ADDR3);
	IP4_ADDR(&netmask, NETMASK_ADDR0, NETMASK_ADDR1 , NETMASK_ADDR2, NETMASK_ADDR3);
	IP4_ADDR(&gw, GW_ADDR0, GW_ADDR1, GW_ADDR2, GW_ADDR3);

	wifi_netif.name[0] = 'r';
	wifi_netif.name[1] = '0';
	netif_add(&wifi_netif, &ipaddr, &netmask, &gw, NULL, &wifi_ethernetif_init, &tcpip_input);
	netif_set_default(&wifi_netif);
	netif_set_up(&wifi_netif); 
}

#endif

int ssv6x5x_sdio_init(void)
{
    static int sdio_init = 0;
	extern int wifi_sdio_init(void);

    if (sdio_init == 0)
    {
    	if(wifi_sdio_init()){
    		printf("\n\rERROR: wifi sdio init failed!\n");
    		return -1;
    	}
        sdio_init = 1;
        
        extern void vos_task_delay_ms(int);
        vos_task_delay_ms(1000);
    }
	
	return 0;
}

EXAMFUNC_ENTRY(wifi, argc, argv)
{
    static int sdio_init = 0;
	extern int wifi_sdio_init(void);

    if (sdio_init == 0)
    {
    	if(wifi_sdio_init()){
    		printf("\n\rERROR: wifi sdio init failed!\n");
    		return -1;
    	}
        sdio_init = 1;
        
        extern void vos_task_delay_ms(int);
        vos_task_delay_ms(1000);
    }
    
	//extern void LwIP_Init(void);
	//LwIP_Init();
	//printf("LwIP_Init() ok\n");
	
	//netif_set_up(&wifi_netif);
	//netif_set_link_up(&wifi_netif);
	if (argc > 1)
	{
        if (!strcmp(argv[1], "on"))
        {
            extern int wifi_on(unsigned int on);
            wifi_on(1);
        }
        if (!strcmp(argv[1], "off"))
        {
            extern int wifi_on(unsigned int on);
            wifi_on(0);
        }
        if (!strcmp(argv[1], "sta"))
        {
            extern int wifi_connect(char *ssid, unsigned int security_type, char *password, int ssid_len, int password_len,
                           int key_id, void *semaphore);
            if (argc == 4)
            {
                if (!strcmp(argv[2], "join")) //sta join ssid
                {
                    wifi_connect(argv[3], 0, "", 0, 0, 0, 0);
                }
            }
            if (argc == 5)
            {
                if (!strcmp(argv[2], "join")) //sta join ssid key
                {
                    wifi_connect(argv[3], 0, argv[4], 0, 0, 0, 0);
                }
            }
        }
        else if (!strcmp(argv[1], "ap"))
        {
            extern int wifi_start_ap( char *ssid, unsigned int security_type, char *password, int ssid_len,
                                 int     password_len, int channel);
            if (argc == 4)
            {
                wifi_start_ap(argv[2], 0, "", strlen(argv[2]), 0, atoi(argv[3]));
            }
            if (argc == 5)
            {
                wifi_start_ap(argv[2], 0, argv[4], strlen(argv[2]), strlen(argv[4]), atoi(argv[3]));
            }
        }    
	}
    
	return 0;
}

EXAMFUNC_ENTRY(ssv, argc, argv)
{
    extern int Cli_RunCmd(char *CmdBuffer);
    extern int At_Parser(char *buff, int len);
    int i = 0;
    static char cmd_wifi_str[128];
    memset(cmd_wifi_str, 0, 128);
    
    for (i = 1; i < argc; i++)
    {
        strcat(cmd_wifi_str, argv[i]);
        strcat(cmd_wifi_str, " ");
    }
    
    if (strlen(cmd_wifi_str))
    {
         if (Cli_RunCmd(cmd_wifi_str) < 0)
 		{				    
             if(At_Parser (cmd_wifi_str, strlen(cmd_wifi_str))!= 0)
             {
                 printf("\nCommand not found!!\r\n");
             }
 		}
    }
    
	return 0;
}

int WiFi_Adaptor_Init (int priority)
{
	extern int wifi_sdio_init(void);
	if(wifi_sdio_init()){
		printf("\n\rERROR: wifi sdio init failed!\n");
		return -1;
	}
	//extern void vos_task_delay_ms(int);
	//vos_task_delay_ms(1000);
	extern void LwIP_Init(void);
	LwIP_Init();
	printf("LwIP_Init() ok\n");
	return 0;
}

int WiFi_Adaptor_Interface_Up (nvt_wifi_settings *pwifi)
{
	extern int wifi_on(unsigned int);
	if(wifi_on(1) < 0){
		printf("\n\rERROR: Wifi on failed!\n");
		return -1;
	}
	
	extern int wifi_disable_powersave(void);
	wifi_disable_powersave();
	extern void vos_task_delay_ms(int ms);
	vos_task_delay_ms(1000);

	extern int wifi_connect(char *ssid,
							unsigned int security_type,
							char *password,
							int ssid_len,
							int password_len,
							int key_id,
							void *semaphore);

	return wifi_connect(pwifi->ssid,
				!strcmp(pwifi->security, "none") ? 0 : (!strcmp(pwifi->security, "wpa-psk-tkip") ? (0x00200000|0x0002) : (0x00400000|0x0004)),
				pwifi->passphrase,
				strlen(pwifi->ssid), 
				strlen(pwifi->passphrase), 
				-1,
				NULL);
}

int WiFi_Adaptor_Interface_Down (const char *pIntfName)
{
	extern int wifi_off(void);
	return wifi_off();
}

int WiFi_Adaptor_Get_Mac (char *mac)
{
	extern int wifi_get_mac_address(char * mac);
	return wifi_get_mac_address(mac);
}

int WiFi_Adaptor_Set_Mac (const char *pIntfName, char *mac)
{	
	extern int wifi_set_mac_address(char * mac);
	return wifi_set_mac_address(mac);
}

int WiFi_Adaptor_Register_Sta_Cb (const char *pIntfName, wifi_sta_status_cb_func_t *pFunc)
{
	extern void (*Wifi_StationStatus_CB)(char *pIntfName, char *pMacAddr, int status);
	Wifi_StationStatus_CB = pFunc;
	return 0;
}

int WiFi_Adaptor_Register_Ap_Cb (const char *pIntfName, wifi_link_status_cb_func_t *pFunc)
{
	extern void (*Wifi_Link2APStatus_CB)(char *pIntfName, int status);
	Wifi_Link2APStatus_CB = pFunc;
	return 0;
}

int WiFi_Adaptor_Config (nvt_wifi_settings *pwifi)
{
	int channel;
	char ssid[64];
	char mac[6];

	extern int wifi_on(unsigned int);
	if(wifi_on(2) < 0){
		printf("\n\rERROR: Wifi on failed!\n");
		return -1;
	}
	
	extern int wifi_disable_powersave(void);
	wifi_disable_powersave();
	extern void vos_task_delay_ms(int ms);
	vos_task_delay_ms(1000);
		
	channel = pwifi->channel;
	if(channel == 0){
		extern int wifi_get_best_channel(void);
		channel = wifi_get_best_channel();
	}
	
	strncpy(ssid, pwifi->ssid, sizeof(ssid)-1);
	if(pwifi->auto_ssid_plus_mac){
		if(WiFiIpc_get_wlan0_efuse_mac(mac))
			printf("fail to get mac\n");
		else
			snprintf(ssid, sizeof(ssid), "%s%02x%02x%02x%02x%02x%02x", 
						pwifi->ssid, mac[0], mac[1], mac[2], mac[3], mac[4], mac[5]);
	}

	extern int wifi_start_ap( char *ssid,
							unsigned int security_type,
							char *password,
							int ssid_len,
							int	password_len,
							int channel);
	return wifi_start_ap(ssid, 
					!strcmp(pwifi->security, "none") ? 0 : (!strcmp(pwifi->security, "wpa-psk-tkip") ? (0x00200000|0x0002) : (0x00400000|0x0004)),
					pwifi->passphrase, 
					strlen(ssid), 
					strlen(pwifi->passphrase), 
					channel);
}

int WiFi_Adaptor_Start_SiteSurvey(const char *pIntfName, int *pStatus)
{
	if(pStatus)
		*pStatus = -1;
	printf("WiFi_Adaptor_Start_SiteSurvey() is not implemented\n");
	return -1;
}

int WiFi_Adaptor_Query_SiteSurvey(const char *pIntfName)
{
	printf("WiFi_Adaptor_Query_SiteSurvey() is not implemented\n");
	return -1;
}

int WiFi_Adaptor_Get_SiteSurvey(const char *pIntfName, NVT_SS_STATUS_Tp pStatus, UINT32 size)
{
	printf("WiFi_Adaptor_Get_SiteSurvey() is not implemented\n");
	return -1;
}