/H********************************************************
  WiFi.cpp - Library for Arduino WiFi shield.
  Copyright (c) 2011-2014 Arduino LLC.  All right reserved.
  This library is free software; you can redistribute it and/or
  modify it under the terms of the GNU Lesser General Public
  License as published by the Free Software Foundation; either
  version 2.1 of the License, or (at your option) any later version.
  This library is distributed in the hope that it will be useful,
  but WITHOUT ANY WARRANTY; without even the implied warranty of
  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  Lesser General Public License for more details.
  You should have received a copy of the GNU Lesser General Public
  License along with this library; if not, write to the Free Software
  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
********************************************************/
#include "utility/wifi_drv.h"
#include "WiFi.h"

extern "C" {
  #include "utility/wl_definitions.h"
  #include "utility/wl_types.h"
  #include "utility/debug.h"
}

// XXX: don't make assumptions about the value of MAX_SOCK_NUM.
int16_t     WiFiClass::_state[MAX_SOCK_NUM] = { NA_STATE, NA_STATE, NA_STATE, NA_STATE };
uint16_t     WiFiClass::_server_port[MAX_SOCK_NUM] = { 0, 0, 0, 0 };

WiFiClass::WiFiClass()
{
}



/*F********************************************************************
*
**********************************************************************/
void WiFiClass::
init()
{
    WiFiDrv::wifiDriverInit();
}



/*F********************************************************************
*
**********************************************************************/
uint8_t WiFiClass::
getSocket()
{
    for( uint8_t i = 0; i < MAX_SOCK_NUM; ++i)
    {
        if( WiFiClass::_server_port[i] == 0)
        {
             return( i );
        }
    }
    return NO_SOCKET_AVAIL;
}



/*F********************************************************************
*
**********************************************************************/
char* WiFiClass::
firmwareVersion()
{
    return WiFiDrv::getFwVersion();
}



/*F********************************************************************
*
**********************************************************************/
int WiFiClass::
begin( const char *ssid )
{
    uint8_t status = WL_IDLE_STATUS;
    uint8_t attempts = WL_MAX_ATTEMPT_CONNECTION;
    if( WiFiDrv::wifiSetNetwork( ssid, strlen( ssid ) ) != WL_FAILURE)
    {
        do
        {
			delay( WL_DELAY_START_CONNECTION );
			status = WiFiDrv::getConnectionStatus();
        }while( (( status == WL_IDLE_STATUS ) || (status 
            == WL_SCAN_COMPLETED) ) && ( --attempts>0) );
    }
    else
    status = WL_CONNECT_FAILED;
    return( status );
}



/*F********************************************************************
*
**********************************************************************/
int WiFiClass::
begin( const char *ssid, uint8_t key_idx, const char *key )
{
    uint8_t status = WL_IDLE_STATUS;
    uint8_t attempts = WL_MAX_ATTEMPT_CONNECTION;
    // SET ENCRYPTION KEY
   if( WiFiDrv::wifiSetKey( ssid, strlen( ssid ), key_idx, key, strlen( key )) 
        != WL_FAILURE )
   {
       do
       {
           delay( WL_DELAY_START_CONNECTION );
           status = WiFiDrv::getConnectionStatus();
       }while( (( status == WL_IDLE_STATUS ) || (status == WL_SCAN_COMPLETED ) ) 
            && (--attempts > 0));
   }
    else
       status = WL_CONNECT_FAILED;
   return( status );
}



/*F********************************************************************
*
**********************************************************************/
int WiFiClass::
begin( const char *ssid, const char *passphrase)
{
    uint8_t status = WL_IDLE_STATUS;
    uint8_t attempts = WL_MAX_ATTEMPT_CONNECTION;
    // SET PASSPHRASE
    if( WiFiDrv::wifiSetPassphrase( ssid, strlen( ssid ), passphrase
            , strlen( passphrase ) ) != WL_FAILURE)
    {
        do
        {
            delay( WL_DELAY_START_CONNECTION );
            status = WiFiDrv::getConnectionStatus();
        }while( ((status == WL_IDLE_STATUS) 
            || (status == WL_SCAN_COMPLETED ) ) && ( --attempts > 0 ));
    }
    else
        status = WL_CONNECT_FAILED;
    return( status );
}



/*F********************************************************************
*
**********************************************************************/
void WiFiClass::
config( IPAddress local_ip ) 
{
    WiFiDrv::config( 1, (uint32_t)local_ip, 0, 0);
}

/*F********************************************************************
*
**********************************************************************/
void WiFiClass::
config( IPAddress local_ip, IPAddress dns_server )
{
    WiFiDrv::config( 1, (uint32_t)local_ip, 0, 0);
    WiFiDrv::setDNS( 1, (uint32_t)dns_server, 0);
}

/*F********************************************************************
*
**********************************************************************/
void WiFiClass::
config( IPAddress local_ip, IPAddress dns_server, IPAddress gateway )
{
    WiFiDrv::config( 2, (uint32_t)local_ip, (uint32_t)gateway, 0);
    WiFiDrv::setDNS( 1, (uint32_t)dns_server, 0);
}

/*F********************************************************************
*
**********************************************************************/
void WiFiClass::
config( IPAddress local_ip, IPAddress dns_server, IPAddress gateway
    , IPAddress subnet)
{
    WiFiDrv::config(3, (uint32_t)local_ip, (uint32_t)gateway, (uint32_t)subnet);
    WiFiDrv::setDNS(1, (uint32_t)dns_server, 0);
}



/*F********************************************************************
*
**********************************************************************/
void WiFiClass::
setDNS( IPAddress dns_server1 )
{
    WiFiDrv::setDNS( 1, (uint32_t)dns_server1, 0 );
}



/*F********************************************************************
*
**********************************************************************/
void WiFiClass::
setDNS( IPAddress dns_server1, IPAddress dns_server2 )
{
    WiFiDrv::setDNS( 2, (uint32_t)dns_server1, (uint32_t)dns_server2 );
}



/*F********************************************************************
*
**********************************************************************/
int WiFiClass::
disconnect()
{
    return WiFiDrv::disconnect();
}



/*F********************************************************************
*
**********************************************************************/
uint8_t* WiFiClass::
macAddress( uint8_t* mac )
{
    uint8_t* _mac = WiFiDrv::getMacAddress();
    memcpy( mac, _mac, WL_MAC_ADDR_LENGTH);
    return( mac );
}



/*F********************************************************************
*
**********************************************************************/
IPAddress WiFiClass::
localIP()
{
    IPAddress ret;
    WiFiDrv::getIpAddress( ret );
    return ret;
}



/*F********************************************************************
*
**********************************************************************/
IPAddress WiFiClass::
subnetMask()
{
    IPAddress ret;
    WiFiDrv::getSubnetMask( ret );
    return ret;
}



/*F********************************************************************
*
**********************************************************************/
IPAddress WiFiClass::
gatewayIP()
{
    IPAddress ret;
    WiFiDrv::getGatewayIP( ret );
    return ret;
}



/*F********************************************************************
*
**********************************************************************/
char* WiFiClass::
SSID()
{
    return WiFiDrv::getCurrentSSID();
}



/*F********************************************************************
*
**********************************************************************/
uint8_t* WiFiClass::
BSSID(  uint8_t* bssid  )
{
    uint8_t* _bssid = WiFiDrv::getCurrentBSSID();
    memcpy(bssid, _bssid, WL_MAC_ADDR_LENGTH);
    return bssid;
}



/*F********************************************************************
*
**********************************************************************/
int32_t WiFiClass::
RSSI()
{
    return WiFiDrv::getCurrentRSSI();
}



/*F********************************************************************
*
**********************************************************************/
uint8_t WiFiClass::
encryptionType()
{
    return WiFiDrv::getCurrentEncryptionType();
}



/*F********************************************************************
*
**********************************************************************/
int8_t WiFiClass::
scanNetworks()
{
    uint8_t attempts = 10;
    uint8_t numOfNetworks = 0;
    if( WiFiDrv::startScanNetworks() == WL_FAILURE)
        return( WL_FAILURE );
     do
     {
         delay( 2000 );
         numOfNetworks = WiFiDrv::getScanNetworks();
     }
    while( (numOfNetworks == 0) && ( --attempts > 0));
    return( numOfNetworks );
}



/*F********************************************************************
*
**********************************************************************/
char* WiFiClass::
SSID( uint8_t networkItem)
{
    return WiFiDrv::getSSIDNetworks(networkItem);
}



/*F********************************************************************
*
**********************************************************************/
int32_t WiFiClass::
RSSI( uint8_t networkItem)
{
    return WiFiDrv::getRSSINetworks(networkItem);
}



/*F********************************************************************
*
**********************************************************************/
uint8_t WiFiClass::
encryptionType( uint8_t networkItem)
{
    return WiFiDrv::getEncTypeNetworks(networkItem);
}



/*F********************************************************************
*
**********************************************************************/
uint8_t WiFiClass::
status()
{
    return WiFiDrv::getConnectionStatus();
}



/*F********************************************************************
*
**********************************************************************/
int WiFiClass::
hostByName( const char* aHostname, IPAddress& aResult )
{
    return WiFiDrv::getHostByName(aHostname, aResult);
}
WiFiClass WiFi;